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/gfx/canvas.h" 6 7 #include "base/i18n/rtl.h" 8 #include "base/logging.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "ui/gfx/font_list.h" 11 #include "ui/gfx/insets.h" 12 #include "ui/gfx/range/range.h" 13 #include "ui/gfx/rect.h" 14 #include "ui/gfx/render_text.h" 15 #include "ui/gfx/shadow_value.h" 16 #include "ui/gfx/text_elider.h" 17 #include "ui/gfx/text_utils.h" 18 19 namespace gfx { 20 21 namespace { 22 23 #if defined(OS_WIN) 24 // If necessary, wraps |text| with RTL/LTR directionality characters based on 25 // |flags| and |text| content. 26 // Returns true if the text will be rendered right-to-left. 27 // TODO(msw): Nix this, now that RenderTextWin supports directionality directly. 28 bool AdjustStringDirection(int flags, base::string16* text) { 29 // TODO(msw): FORCE_LTR_DIRECTIONALITY does not work for RTL text now. 30 31 // If the string is empty or LTR was forced, simply return false since the 32 // default RenderText directionality is already LTR. 33 if (text->empty() || (flags & Canvas::FORCE_LTR_DIRECTIONALITY)) 34 return false; 35 36 // If RTL is forced, apply it to the string. 37 if (flags & Canvas::FORCE_RTL_DIRECTIONALITY) { 38 base::i18n::WrapStringWithRTLFormatting(text); 39 return true; 40 } 41 42 // If a direction wasn't forced but the UI language is RTL and there were 43 // strong RTL characters, ensure RTL is applied. 44 if (base::i18n::IsRTL() && base::i18n::StringContainsStrongRTLChars(*text)) { 45 base::i18n::WrapStringWithRTLFormatting(text); 46 return true; 47 } 48 49 // In the default case, the string should be rendered as LTR. RenderText's 50 // default directionality is LTR, so the text doesn't need to be wrapped. 51 // Note that individual runs within the string may still be rendered RTL 52 // (which will be the case for RTL text under non-RTL locales, since under RTL 53 // locales it will be handled by the if statement above). 54 return false; 55 } 56 #endif // defined(OS_WIN) 57 58 // Checks each pixel immediately adjacent to the given pixel in the bitmap. If 59 // any of them are not the halo color, returns true. This defines the halo of 60 // pixels that will appear around the text. Note that we have to check each 61 // pixel against both the halo color and transparent since 62 // |DrawStringRectWithHalo| will modify the bitmap as it goes, and cleared 63 // pixels shouldn't count as changed. 64 bool PixelShouldGetHalo(const SkBitmap& bitmap, 65 int x, int y, 66 SkColor halo_color) { 67 if (x > 0 && 68 *bitmap.getAddr32(x - 1, y) != halo_color && 69 *bitmap.getAddr32(x - 1, y) != 0) 70 return true; // Touched pixel to the left. 71 if (x < bitmap.width() - 1 && 72 *bitmap.getAddr32(x + 1, y) != halo_color && 73 *bitmap.getAddr32(x + 1, y) != 0) 74 return true; // Touched pixel to the right. 75 if (y > 0 && 76 *bitmap.getAddr32(x, y - 1) != halo_color && 77 *bitmap.getAddr32(x, y - 1) != 0) 78 return true; // Touched pixel above. 79 if (y < bitmap.height() - 1 && 80 *bitmap.getAddr32(x, y + 1) != halo_color && 81 *bitmap.getAddr32(x, y + 1) != 0) 82 return true; // Touched pixel below. 83 return false; 84 } 85 86 // Strips accelerator character prefixes in |text| if needed, based on |flags|. 87 // Returns a range in |text| to underline or Range::InvalidRange() if 88 // underlining is not needed. 89 Range StripAcceleratorChars(int flags, base::string16* text) { 90 if (flags & (Canvas::SHOW_PREFIX | Canvas::HIDE_PREFIX)) { 91 int char_pos = -1; 92 int char_span = 0; 93 *text = RemoveAcceleratorChar(*text, '&', &char_pos, &char_span); 94 if ((flags & Canvas::SHOW_PREFIX) && char_pos != -1) 95 return Range(char_pos, char_pos + char_span); 96 } 97 return Range::InvalidRange(); 98 } 99 100 // Elides |text| and adjusts |range| appropriately. If eliding causes |range| 101 // to no longer point to the same character in |text|, |range| is made invalid. 102 void ElideTextAndAdjustRange(const FontList& font_list, 103 int width, 104 base::string16* text, 105 Range* range) { 106 const base::char16 start_char = 107 (range->IsValid() ? text->at(range->start()) : 0); 108 *text = ElideText(*text, font_list, width, ELIDE_TAIL); 109 if (!range->IsValid()) 110 return; 111 if (range->start() >= text->length() || 112 text->at(range->start()) != start_char) { 113 *range = Range::InvalidRange(); 114 } 115 } 116 117 // Updates |render_text| from the specified parameters. 118 void UpdateRenderText(const Rect& rect, 119 const base::string16& text, 120 const FontList& font_list, 121 int flags, 122 SkColor color, 123 RenderText* render_text) { 124 render_text->SetFontList(font_list); 125 render_text->SetText(text); 126 render_text->SetCursorEnabled(false); 127 128 Rect display_rect = rect; 129 display_rect.set_height(font_list.GetHeight()); 130 render_text->SetDisplayRect(display_rect); 131 132 // Set the text alignment explicitly based on the directionality of the UI, 133 // if not specified. 134 if (!(flags & (Canvas::TEXT_ALIGN_CENTER | 135 Canvas::TEXT_ALIGN_RIGHT | 136 Canvas::TEXT_ALIGN_LEFT))) { 137 flags |= Canvas::DefaultCanvasTextAlignment(); 138 } 139 140 if (flags & Canvas::TEXT_ALIGN_RIGHT) 141 render_text->SetHorizontalAlignment(ALIGN_RIGHT); 142 else if (flags & Canvas::TEXT_ALIGN_CENTER) 143 render_text->SetHorizontalAlignment(ALIGN_CENTER); 144 else 145 render_text->SetHorizontalAlignment(ALIGN_LEFT); 146 147 if (flags & Canvas::NO_SUBPIXEL_RENDERING) 148 render_text->set_background_is_transparent(true); 149 150 render_text->SetColor(color); 151 const int font_style = font_list.GetFontStyle(); 152 render_text->SetStyle(BOLD, (font_style & Font::BOLD) != 0); 153 render_text->SetStyle(ITALIC, (font_style & Font::ITALIC) != 0); 154 render_text->SetStyle(UNDERLINE, (font_style & Font::UNDERLINE) != 0); 155 } 156 157 } // namespace 158 159 // static 160 void Canvas::SizeStringFloat(const base::string16& text, 161 const FontList& font_list, 162 float* width, float* height, 163 int line_height, 164 int flags) { 165 DCHECK_GE(*width, 0); 166 DCHECK_GE(*height, 0); 167 168 base::string16 adjusted_text = text; 169 #if defined(OS_WIN) 170 AdjustStringDirection(flags, &adjusted_text); 171 #endif 172 173 if ((flags & MULTI_LINE) && *width != 0) { 174 WordWrapBehavior wrap_behavior = TRUNCATE_LONG_WORDS; 175 if (flags & CHARACTER_BREAK) 176 wrap_behavior = WRAP_LONG_WORDS; 177 else if (!(flags & NO_ELLIPSIS)) 178 wrap_behavior = ELIDE_LONG_WORDS; 179 180 Rect rect(*width, INT_MAX); 181 std::vector<base::string16> strings; 182 ElideRectangleText(adjusted_text, font_list, rect.width(), rect.height(), 183 wrap_behavior, &strings); 184 scoped_ptr<RenderText> render_text(RenderText::CreateInstance()); 185 UpdateRenderText(rect, base::string16(), font_list, flags, 0, 186 render_text.get()); 187 188 float h = 0; 189 float w = 0; 190 for (size_t i = 0; i < strings.size(); ++i) { 191 StripAcceleratorChars(flags, &strings[i]); 192 render_text->SetText(strings[i]); 193 const SizeF& string_size = render_text->GetStringSizeF(); 194 w = std::max(w, string_size.width()); 195 h += (i > 0 && line_height > 0) ? line_height : string_size.height(); 196 } 197 *width = w; 198 *height = h; 199 } else { 200 // If the string is too long, the call by |RenderTextWin| to |ScriptShape()| 201 // will inexplicably fail with result E_INVALIDARG. Guard against this. 202 const size_t kMaxRenderTextLength = 5000; 203 if (adjusted_text.length() >= kMaxRenderTextLength) { 204 *width = font_list.GetExpectedTextWidth(adjusted_text.length()); 205 *height = font_list.GetHeight(); 206 } else { 207 scoped_ptr<RenderText> render_text(RenderText::CreateInstance()); 208 Rect rect(*width, *height); 209 StripAcceleratorChars(flags, &adjusted_text); 210 UpdateRenderText(rect, adjusted_text, font_list, flags, 0, 211 render_text.get()); 212 const SizeF& string_size = render_text->GetStringSizeF(); 213 *width = string_size.width(); 214 *height = string_size.height(); 215 } 216 } 217 } 218 219 void Canvas::DrawStringRectWithShadows(const base::string16& text, 220 const FontList& font_list, 221 SkColor color, 222 const Rect& text_bounds, 223 int line_height, 224 int flags, 225 const ShadowValues& shadows) { 226 if (!IntersectsClipRect(text_bounds)) 227 return; 228 229 Rect clip_rect(text_bounds); 230 clip_rect.Inset(ShadowValue::GetMargin(shadows)); 231 232 canvas_->save(); 233 ClipRect(clip_rect); 234 235 Rect rect(text_bounds); 236 base::string16 adjusted_text = text; 237 238 #if defined(OS_WIN) 239 AdjustStringDirection(flags, &adjusted_text); 240 #endif 241 242 scoped_ptr<RenderText> render_text(RenderText::CreateInstance()); 243 render_text->set_shadows(shadows); 244 245 if (flags & MULTI_LINE) { 246 WordWrapBehavior wrap_behavior = IGNORE_LONG_WORDS; 247 if (flags & CHARACTER_BREAK) 248 wrap_behavior = WRAP_LONG_WORDS; 249 else if (!(flags & NO_ELLIPSIS)) 250 wrap_behavior = ELIDE_LONG_WORDS; 251 252 std::vector<base::string16> strings; 253 ElideRectangleText(adjusted_text, font_list, text_bounds.width(), 254 text_bounds.height(), wrap_behavior, &strings); 255 256 for (size_t i = 0; i < strings.size(); i++) { 257 Range range = StripAcceleratorChars(flags, &strings[i]); 258 UpdateRenderText(rect, strings[i], font_list, flags, color, 259 render_text.get()); 260 int line_padding = 0; 261 if (line_height > 0) 262 line_padding = line_height - render_text->GetStringSize().height(); 263 else 264 line_height = render_text->GetStringSize().height(); 265 266 // TODO(msw|asvitkine): Center Windows multi-line text: crbug.com/107357 267 #if !defined(OS_WIN) 268 if (i == 0) { 269 // TODO(msw|asvitkine): Support multi-line text with varied heights. 270 const int text_height = strings.size() * line_height - line_padding; 271 rect += Vector2d(0, (text_bounds.height() - text_height) / 2); 272 } 273 #endif 274 275 rect.set_height(line_height - line_padding); 276 277 if (range.IsValid()) 278 render_text->ApplyStyle(UNDERLINE, true, range); 279 render_text->SetDisplayRect(rect); 280 render_text->Draw(this); 281 rect += Vector2d(0, line_height); 282 } 283 } else { 284 Range range = StripAcceleratorChars(flags, &adjusted_text); 285 bool elide_text = ((flags & NO_ELLIPSIS) == 0); 286 287 #if defined(OS_LINUX) 288 // On Linux, eliding really means fading the end of the string. But only 289 // for LTR text. RTL text is still elided (on the left) with "...". 290 if (elide_text) { 291 render_text->SetText(adjusted_text); 292 if (render_text->GetTextDirection() == base::i18n::LEFT_TO_RIGHT) { 293 render_text->SetElideBehavior(FADE_TAIL); 294 elide_text = false; 295 } 296 } 297 #endif 298 299 if (elide_text) { 300 ElideTextAndAdjustRange(font_list, text_bounds.width(), &adjusted_text, 301 &range); 302 } 303 304 UpdateRenderText(rect, adjusted_text, font_list, flags, color, 305 render_text.get()); 306 307 const int text_height = render_text->GetStringSize().height(); 308 rect += Vector2d(0, (text_bounds.height() - text_height) / 2); 309 rect.set_height(text_height); 310 render_text->SetDisplayRect(rect); 311 if (range.IsValid()) 312 render_text->ApplyStyle(UNDERLINE, true, range); 313 render_text->Draw(this); 314 } 315 316 canvas_->restore(); 317 } 318 319 void Canvas::DrawStringRectWithHalo(const base::string16& text, 320 const FontList& font_list, 321 SkColor text_color, 322 SkColor halo_color_in, 323 const Rect& display_rect, 324 int flags) { 325 // Some callers will have semitransparent halo colors, which we don't handle 326 // (since the resulting image can have 1-bit transparency only). 327 SkColor halo_color = SkColorSetA(halo_color_in, 0xFF); 328 329 // Create a temporary buffer filled with the halo color. It must leave room 330 // for the 1-pixel border around the text. 331 Size size(display_rect.width() + 2, display_rect.height() + 2); 332 Canvas text_canvas(size, image_scale(), false); 333 SkPaint bkgnd_paint; 334 bkgnd_paint.setColor(halo_color); 335 text_canvas.DrawRect(Rect(size), bkgnd_paint); 336 337 // Draw the text into the temporary buffer. This will have correct 338 // ClearType since the background color is the same as the halo color. 339 text_canvas.DrawStringRectWithFlags( 340 text, font_list, text_color, 341 Rect(1, 1, display_rect.width(), display_rect.height()), flags); 342 343 uint32_t halo_premul = SkPreMultiplyColor(halo_color); 344 SkBitmap& text_bitmap = const_cast<SkBitmap&>( 345 skia::GetTopDevice(*text_canvas.sk_canvas())->accessBitmap(true)); 346 347 for (int cur_y = 0; cur_y < text_bitmap.height(); cur_y++) { 348 uint32_t* text_row = text_bitmap.getAddr32(0, cur_y); 349 for (int cur_x = 0; cur_x < text_bitmap.width(); cur_x++) { 350 if (text_row[cur_x] == halo_premul) { 351 // This pixel was not touched by the text routines. See if it borders 352 // a touched pixel in any of the 4 directions (not diagonally). 353 if (!PixelShouldGetHalo(text_bitmap, cur_x, cur_y, halo_premul)) 354 text_row[cur_x] = 0; // Make transparent. 355 } else { 356 text_row[cur_x] |= 0xff << SK_A32_SHIFT; // Make opaque. 357 } 358 } 359 } 360 361 // Draw the halo bitmap with blur. 362 ImageSkia text_image = ImageSkia(ImageSkiaRep(text_bitmap, 363 text_canvas.image_scale())); 364 DrawImageInt(text_image, display_rect.x() - 1, display_rect.y() - 1); 365 } 366 367 void Canvas::DrawFadedString(const base::string16& text, 368 const FontList& font_list, 369 SkColor color, 370 const Rect& display_rect, 371 int flags) { 372 // If the whole string fits in the destination then just draw it directly. 373 if (GetStringWidth(text, font_list) <= display_rect.width()) { 374 DrawStringRectWithFlags(text, font_list, color, display_rect, flags); 375 return; 376 } 377 378 // Align with forced content directionality, overriding alignment flags. 379 if (flags & FORCE_RTL_DIRECTIONALITY) { 380 flags &= ~(TEXT_ALIGN_CENTER | TEXT_ALIGN_LEFT); 381 flags |= TEXT_ALIGN_RIGHT; 382 } else if (flags & FORCE_LTR_DIRECTIONALITY) { 383 flags &= ~(TEXT_ALIGN_CENTER | TEXT_ALIGN_RIGHT); 384 flags |= TEXT_ALIGN_LEFT; 385 } else if (!(flags & TEXT_ALIGN_LEFT) && !(flags & TEXT_ALIGN_RIGHT)) { 386 // Also align with content directionality instead of fading both ends. 387 flags &= ~TEXT_ALIGN_CENTER; 388 const bool is_rtl = base::i18n::GetFirstStrongCharacterDirection(text) == 389 base::i18n::RIGHT_TO_LEFT; 390 flags |= is_rtl ? TEXT_ALIGN_RIGHT : TEXT_ALIGN_LEFT; 391 } 392 flags |= NO_ELLIPSIS; 393 394 scoped_ptr<RenderText> render_text(RenderText::CreateInstance()); 395 Rect rect = display_rect; 396 UpdateRenderText(rect, text, font_list, flags, color, render_text.get()); 397 render_text->SetElideBehavior(FADE_TAIL); 398 399 const int line_height = render_text->GetStringSize().height(); 400 rect += Vector2d(0, (display_rect.height() - line_height) / 2); 401 rect.set_height(line_height); 402 render_text->SetDisplayRect(rect); 403 404 canvas_->save(); 405 ClipRect(display_rect); 406 render_text->Draw(this); 407 canvas_->restore(); 408 } 409 410 } // namespace gfx 411