Skip to content

GitLab

T
tangled
Commit 3ddb3789 authored by asvitkine@chromium.org's avatar asvitkine@chromium.org
Browse files
Options

Remove unused file canvas_linux.cc and associated gyp entries. 

Linux/GTK has been using canvas_skia.cc since M21 and
ChromeOS has been using canvas_skia.cc since M19.

BUG=105550
TEST=compiles

Review URL: https://chromiumcodereview.appspot.com/10830285

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@151370 0039d316-1c4b-4281-b951-d872f2087c98
parent 2ce52afb
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 266 deletions
ui/gfx/canvas_linux.cc deleted 100644 → 0
View file @ 2ce52afb
// Copyright (c) 2012 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/gfx/canvas.h"
#include <algorithm>
#include <cairo/cairo.h>
#include <pango/pango.h>
#include <pango/pangocairo.h>
#include "base/i18n/rtl.h"
#include "base/logging.h"
#include "ui/gfx/font.h"
#include "ui/gfx/pango_util.h"
#include "ui/gfx/platform_font_pango.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/skia_util.h"
namespace {
// Multiply by the text height to determine how much text should be faded
// when elliding.
const double kFadeWidthFactor = 1.5;
// End state of the elliding fade.
const double kFadeFinalAlpha = 0.15;
// Width of the border drawn around haloed text.
const double kTextHaloWidth = 1.0;
// A class to encapsulate string drawing params and operations.
class DrawStringContext {
public:
DrawStringContext(gfx::Canvas* canvas,
const string16& text,
const gfx::Font& font,
const gfx::Rect& bounds,
const gfx::Rect& clip,
int flags);
~DrawStringContext();
void Draw(SkColor text_color);
void DrawWithHalo(SkColor text_color, SkColor halo_color);
private:
// Draw an underline under the text using |cr|, which must already be
// initialized with the correct source. |extra_edge_width| is added to the
// outer edge of the line. Helper method for Draw() and DrawWithHalo().
void DrawUnderline(cairo_t* cr, double extra_edge_width);
const gfx::Rect& bounds_;
int flags_;
const gfx::Font& font_;
gfx::Canvas* canvas_;
cairo_t* cr_;
PangoLayout* layout_;
gfx::Rect text_rect_;
base::i18n::TextDirection text_direction_;
DISALLOW_COPY_AND_ASSIGN(DrawStringContext);
};
DrawStringContext::DrawStringContext(gfx::Canvas* canvas,
const string16& text,
const gfx::Font& font,
const gfx::Rect& bounds,
const gfx::Rect& clip,
int flags)
: bounds_(bounds),
flags_(flags),
font_(font),
canvas_(canvas),
cr_(NULL),
layout_(NULL),
text_rect_(bounds.x(), bounds.y(), 0, 0),
text_direction_(base::i18n::GetFirstStrongCharacterDirection(text)) {
DCHECK(!bounds_.IsEmpty());
cr_ = skia::BeginPlatformPaint(canvas_->sk_canvas());
layout_ = pango_cairo_create_layout(cr_);
gfx::SetupPangoLayout(
layout_, text, font, bounds_.width(), text_direction_, flags_);
pango_layout_set_height(layout_, bounds_.height() * PANGO_SCALE);
cairo_save(cr_);
cairo_rectangle(cr_, clip.x(), clip.y(), clip.width(), clip.height());
cairo_clip(cr_);
AdjustTextRectBasedOnLayout(layout_, bounds_, flags_, &text_rect_);
}
DrawStringContext::~DrawStringContext() {
cairo_restore(cr_);
skia::EndPlatformPaint(canvas_->sk_canvas());
g_object_unref(layout_);
// NOTE: BeginPlatformPaint returned its surface, we shouldn't destroy it.
}
void DrawStringContext::Draw(SkColor text_color) {
DrawPangoLayout(cr_, layout_, font_, bounds_, text_rect_, text_color,
text_direction_, flags_);
}
void DrawStringContext::DrawWithHalo(SkColor text_color,
SkColor halo_color) {
gfx::Size size(bounds_.width() + 2, bounds_.height() + 2);
gfx::Canvas text_canvas(size, scale_factor(), false);
text_canvas.FillRect(gfx::Rect(size), static_cast<SkColor>(0));
{
skia::ScopedPlatformPaint scoped_platform_paint(text_canvas.sk_canvas());
cairo_t* text_cr = scoped_platform_paint.GetPlatformSurface();
// TODO: The current approach (stroking the text path to generate the halo
// and then filling it for the main text) won't work if |text_color| is
// non-opaque. If we need to do this at some later point,
// http://lists.freedesktop.org/archives/cairo/2004-September/001829.html
// suggests "do[ing] the stroke and fill with opaque paint onto an
// intermediate surface, and then us[ing] cairo_show_surface to composite
// that intermediate result with the desired compositing operator."
cairo_set_source_rgba(text_cr,
SkColorGetR(halo_color) / 255.0,
SkColorGetG(halo_color) / 255.0,
SkColorGetB(halo_color) / 255.0,
SkColorGetA(halo_color) / 255.0);
// Draw the halo underline first so that we can use the same path for the
// outer/halo text and inner text.
if (font_.GetStyle() & gfx::Font::UNDERLINED)
DrawUnderline(text_cr, kTextHaloWidth);
cairo_move_to(text_cr, 2, 1);
pango_cairo_layout_path(text_cr, layout_);
cairo_set_line_width(text_cr, 2 * kTextHaloWidth);
cairo_set_line_join(text_cr, CAIRO_LINE_JOIN_ROUND);
cairo_stroke_preserve(text_cr);
cairo_set_operator(text_cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba(text_cr,
SkColorGetR(text_color) / 255.0,
SkColorGetG(text_color) / 255.0,
SkColorGetB(text_color) / 255.0,
SkColorGetA(text_color) / 255.0);
cairo_fill(text_cr);
if (font_.GetStyle() & gfx::Font::UNDERLINED)
DrawUnderline(text_cr, 0.0);
}
const SkBitmap& text_bitmap = const_cast<SkBitmap&>(
skia::GetTopDevice(*text_canvas.sk_canvas())->accessBitmap(false));
const gfx::ImageSkia text_image = gfx::ImageSkia(gfx::ImageSkiaRep(
text_bitmap, text_canvas.scale_factor()));
canvas_->DrawImageInt(text_image, text_rect_.x() - 1, text_rect_.y() - 1);
}
void DrawStringContext::DrawUnderline(cairo_t* cr, double extra_edge_width) {
gfx::PlatformFontPango* platform_font =
static_cast<gfx::PlatformFontPango*>(font_.platform_font());
gfx::DrawPangoTextUnderline(cr,
platform_font,
extra_edge_width,
text_rect_);
}
} // namespace
namespace gfx {
// static
void Canvas::SizeStringInt(const string16& text,
const gfx::Font& font,
int* width, int* height,
int flags) {
int org_width = *width;
cairo_surface_t* surface =
cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 0, 0);
cairo_t* cr = cairo_create(surface);
PangoLayout* layout = pango_cairo_create_layout(cr);
SetupPangoLayout(
layout,
text,
font,
*width,
base::i18n::GetFirstStrongCharacterDirection(text),
flags);
pango_layout_get_pixel_size(layout, width, height);
if (font.GetStyle() & gfx::Font::UNDERLINED) {
gfx::PlatformFontPango* platform_font =
static_cast<gfx::PlatformFontPango*>(font.platform_font());
*height += std::max(platform_font->underline_position() +
platform_font->underline_thickness(), 0.0);
}
// TODO: If the text is being drawn with a halo, we should also pad each of
// the edges by |kTextHaloWidth|... except haloing is currently a drawing-time
// thing, and we don't know how the text will be drawn here. :-( This only
// seems to come into play at present if the text is both haloed and
// underlined; otherwise, the size returned by Pango is (at least sometimes)
// large enough to include the halo.
if (org_width > 0 && flags & Canvas::MULTI_LINE &&
pango_layout_is_wrapped(layout)) {
// The text wrapped. There seems to be a bug in Pango when this happens
// such that the width returned from pango_layout_get_pixel_size is too
// small. Using the width from pango_layout_get_pixel_size in this case
// results in wrapping across more lines, which requires a bigger height.
// As a workaround we use the original width, which is not necessarily
// exactly correct, but isn't wrong by much.
//
// It looks like Pango uses the size of whitespace in calculating wrapping
// but doesn't include the size of the whitespace when the extents are
// asked for. See the loop in pango-layout.c process_item that determines
// where to wrap.
*width = org_width;
}
g_object_unref(layout);
cairo_destroy(cr);
cairo_surface_destroy(surface);
}
void Canvas::DrawStringWithHalo(const string16& text,
const gfx::Font& font,
SkColor text_color,
SkColor halo_color,
int x, int y, int w, int h,
int flags) {
if (!IntersectsClipRectInt(x, y, w, h))
return;
gfx::Rect bounds(x, y, w, h);
gfx::Rect clip(x - 1, y - 1, w + 2, h + 2); // Bigger clip for halo
DrawStringContext context(this, text, font, bounds, clip,flags);
context.DrawWithHalo(text_color, halo_color);
}
void Canvas::DrawStringWithShadows(const string16& text,
const gfx::Font& font,
SkColor color,
const gfx::Rect& text_bounds,
int flags,
const ShadowValues& shadows) {
DLOG_IF(WARNING, !shadows.empty()) << "Text shadow not implemented.";
if (!IntersectsClipRect(text_bounds))
return;
DrawStringContext context(this, text, font, text_bounds, text_bounds, flags);
context.Draw(color);
}
} // namespace gfx
ui/ui.gyp
View file @ 3ddb3789
......@@ -339,7 +339,6 @@
'gfx/canvas.cc',
'gfx/canvas.h',
'gfx/canvas_android.cc',
'gfx/canvas_linux.cc',
'gfx/canvas_mac.mm',
'gfx/canvas_paint.h',
'gfx/canvas_paint_win.cc',
......@@ -487,7 +486,6 @@
['use_canvas_skia==1', {
'sources!': [
'gfx/canvas_android.cc',
'gfx/canvas_linux.cc',
'gfx/canvas_mac.mm',
],
}, { # use_canvas_skia!=1
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment