libs/hwui/hwui/Canvas.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "Canvas.h"

 #include <SkFontMetrics.h>
 #include <SkRRect.h>

 #include "FeatureFlags.h"
 #include "MinikinUtils.h"
 #include "Paint.h"
 #include "Properties.h"
 #include "RenderNode.h"
 #include "Typeface.h"
 #include "hwui/DrawTextFunctor.h"
 #include "hwui/PaintFilter.h"
 #include "pipeline/skia/SkiaRecordingCanvas.h"

 namespace android {

 Canvas* Canvas::create_recording_canvas(int width, int height, uirenderer::RenderNode* renderNode) {
     return new uirenderer::skiapipeline::SkiaRecordingCanvas(renderNode, width, height);
 }

 void Canvas::drawTextDecorations(float x, float y, float length, const Paint& paint) {
     // paint has already been filtered by our caller, so we can ignore any filter
     const bool strikeThru = paint.isStrikeThru();
     const bool underline = paint.isUnderline();
     if (strikeThru || underline) {
         const SkScalar left = x;
         const SkScalar right = x + length;
         const float textSize = paint.getSkFont().getSize();
         if (underline) {
             SkFontMetrics metrics;
             paint.getSkFont().getMetrics(&metrics);
             SkScalar position;
             if (!metrics.hasUnderlinePosition(&position)) {
                 position = textSize * Paint::kStdUnderline_Top;
             }
             SkScalar thickness;
             if (!metrics.hasUnderlineThickness(&thickness)) {
                 thickness = textSize * Paint::kStdUnderline_Thickness;
             }
             const SkScalar top = y + position;
             drawStroke(left, right, top, thickness, paint, this);
         }
         if (strikeThru) {
             const float position = textSize * Paint::kStdStrikeThru_Top;
             const SkScalar thickness = textSize * Paint::kStdStrikeThru_Thickness;
             const SkScalar top = y + position;
             drawStroke(left, right, top, thickness, paint, this);
         }
     }
 }

 void Canvas::drawGlyphs(const minikin::Font& font, const int* glyphIds, const float* positions,
                         int glyphCount, const Paint& paint) {
     // Minikin modify skFont for auto-fakebold/auto-fakeitalic.
     Paint copied(paint);

     auto glyphFunc = [&](uint16_t* outGlyphIds, float* outPositions) {
         for (uint32_t i = 0; i < glyphCount; ++i) {
             outGlyphIds[i] = static_cast<uint16_t>(glyphIds[i]);
         }
         memcpy(outPositions, positions, sizeof(float) * 2 * glyphCount);
     };

     const minikin::MinikinFont* minikinFont = font.baseTypeface().get();
     SkFont* skfont = &copied.getSkFont();
     MinikinFontSkia::populateSkFont(skfont, minikinFont, minikin::FontFakery());

     // total advance is used for drawing underline. We do not support underlyine by glyph drawing.
     drawGlyphs(glyphFunc, glyphCount, copied, 0 /* x */, 0 /* y */, 0 /* total Advance */);
 }

 void Canvas::drawText(const uint16_t* text, int textSize, int start, int count, int contextStart,
                       int contextCount, float x, float y, minikin::Bidi bidiFlags,
                       const Paint& origPaint, const Typeface* typeface, minikin::MeasuredText* mt) {
     // minikin may modify the original paint
     Paint paint(origPaint);

     // interpret 'linear metrics' flag as 'linear', forcing no-hinting when drawing
     if (paint.getSkFont().isLinearMetrics()) {
         paint.getSkFont().setHinting(SkFontHinting::kNone);
     }

     minikin::Layout layout = MinikinUtils::doLayout(&paint, bidiFlags, typeface, text, textSize,
                                                     start, count, contextStart, contextCount, mt);

     x += MinikinUtils::xOffsetForTextAlign(&paint, layout);

     // Set align to left for drawing, as we don't want individual
     // glyphs centered or right-aligned; the offset above takes
     // care of all alignment.
     paint.setTextAlign(Paint::kLeft_Align);

     DrawTextFunctor f(layout, this, paint, x, y, layout.getAdvance());
     MinikinUtils::forFontRun(layout, &paint, f);

     if (text_feature::fix_double_underline()) {
         Paint copied(paint);
         PaintFilter* filter = getPaintFilter();
         if (filter != nullptr) {
             filter->filterFullPaint(&copied);
         }
         const bool isUnderline = copied.isUnderline();
         const bool isStrikeThru = copied.isStrikeThru();
         if (isUnderline || isStrikeThru) {
             const SkScalar left = x;
             const SkScalar right = x + layout.getAdvance();
             if (isUnderline) {
                 const SkScalar top = y + f.getUnderlinePosition();
                 drawStroke(left, right, top, f.getUnderlineThickness(), copied, this);
             }
             if (isStrikeThru) {
                 float textSize = paint.getSkFont().getSize();
                 const float position = textSize * Paint::kStdStrikeThru_Top;
                 const SkScalar thickness = textSize * Paint::kStdStrikeThru_Thickness;
                 const SkScalar top = y + position;
                 drawStroke(left, right, top, thickness, copied, this);
             }
         }
     }
 }

 void Canvas::drawDoubleRoundRectXY(float outerLeft, float outerTop, float outerRight,
                             float outerBottom, float outerRx, float outerRy, float innerLeft,
                             float innerTop, float innerRight, float innerBottom, float innerRx,
                             float innerRy, const Paint& paint) {
     if (CC_UNLIKELY(paint.nothingToDraw())) return;
     SkRect outer = SkRect::MakeLTRB(outerLeft, outerTop, outerRight, outerBottom);
     SkRect inner = SkRect::MakeLTRB(innerLeft, innerTop, innerRight, innerBottom);

     SkRRect outerRRect;
     outerRRect.setRectXY(outer, outerRx, outerRy);

     SkRRect innerRRect;
     innerRRect.setRectXY(inner, innerRx, innerRy);
     drawDoubleRoundRect(outerRRect, innerRRect, paint);
 }

 void Canvas::drawDoubleRoundRectRadii(float outerLeft, float outerTop, float outerRight,
                             float outerBottom, const float* outerRadii, float innerLeft,
                             float innerTop, float innerRight, float innerBottom,
                             const float* innerRadii, const Paint& paint) {
     static_assert(sizeof(SkVector) == sizeof(float) * 2);
     if (CC_UNLIKELY(paint.nothingToDraw())) return;
     SkRect outer = SkRect::MakeLTRB(outerLeft, outerTop, outerRight, outerBottom);
     SkRect inner = SkRect::MakeLTRB(innerLeft, innerTop, innerRight, innerBottom);

     SkRRect outerRRect;
     const SkVector* outerSkVector = reinterpret_cast<const SkVector*>(outerRadii);
     outerRRect.setRectRadii(outer, outerSkVector);

     SkRRect innerRRect;
     const SkVector* innerSkVector = reinterpret_cast<const SkVector*>(innerRadii);
     innerRRect.setRectRadii(inner, innerSkVector);
     drawDoubleRoundRect(outerRRect, innerRRect, paint);
 }

 class DrawTextOnPathFunctor {
 public:
     DrawTextOnPathFunctor(const minikin::Layout& layout, Canvas* canvas, float hOffset,
                           float vOffset, const Paint& paint, const SkPath& path)
             : layout(layout)
             , canvas(canvas)
             , hOffset(hOffset)
             , vOffset(vOffset)
             , paint(paint)
             , path(path) {}

     void operator()(size_t start, size_t end) {
         canvas->drawLayoutOnPath(layout, hOffset, vOffset, paint, path, start, end);
     }

 private:
     const minikin::Layout& layout;
     Canvas* canvas;
     float hOffset;
     float vOffset;
     const Paint& paint;
     const SkPath& path;
 };

 void Canvas::drawTextOnPath(const uint16_t* text, int count, minikin::Bidi bidiFlags,
                             const SkPath& path, float hOffset, float vOffset,
                             const Paint& origPaint, const Typeface* typeface) {
     // minikin may modify the original paint
     Paint paint(origPaint);

     // interpret 'linear metrics' flag as 'linear', forcing no-hinting when drawing
     if (paint.getSkFont().isLinearMetrics()) {
         paint.getSkFont().setHinting(SkFontHinting::kNone);
     }

     minikin::Layout layout =
             MinikinUtils::doLayout(&paint, bidiFlags, typeface, text, count,  // text buffer
                                    0, count,                                  // draw range
                                    0, count,                                  // context range
                                    nullptr);
     hOffset += MinikinUtils::hOffsetForTextAlign(&paint, layout, path);

     // Set align to left for drawing, as we don't want individual
     // glyphs centered or right-aligned; the offset above takes
     // care of all alignment.
     paint.setTextAlign(Paint::kLeft_Align);

     DrawTextOnPathFunctor f(layout, this, hOffset, vOffset, paint, path);
     MinikinUtils::forFontRun(layout, &paint, f);
 }

 int Canvas::sApiLevel = 1;

 void Canvas::setCompatibilityVersion(int apiLevel) {
     sApiLevel = apiLevel;
 }

 }  // namespace android
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "Canvas.h"

	#include <SkFontMetrics.h>
	#include <SkRRect.h>

	#include "FeatureFlags.h"
	#include "MinikinUtils.h"
	#include "Paint.h"
	#include "Properties.h"
	#include "RenderNode.h"
	#include "Typeface.h"
	#include "hwui/DrawTextFunctor.h"
	#include "hwui/PaintFilter.h"
	#include "pipeline/skia/SkiaRecordingCanvas.h"

	namespace android {

	Canvas* Canvas::create_recording_canvas(int width, int height, uirenderer::RenderNode* renderNode) {
	return new uirenderer::skiapipeline::SkiaRecordingCanvas(renderNode, width, height);
	}

	void Canvas::drawTextDecorations(float x, float y, float length, const Paint& paint) {
	// paint has already been filtered by our caller, so we can ignore any filter
	const bool strikeThru = paint.isStrikeThru();
	const bool underline = paint.isUnderline();
	if (strikeThru \|\| underline) {
	const SkScalar left = x;
	const SkScalar right = x + length;
	const float textSize = paint.getSkFont().getSize();
	if (underline) {
	SkFontMetrics metrics;
	paint.getSkFont().getMetrics(&metrics);
	SkScalar position;
	if (!metrics.hasUnderlinePosition(&position)) {
	position = textSize * Paint::kStdUnderline_Top;
	}
	SkScalar thickness;
	if (!metrics.hasUnderlineThickness(&thickness)) {
	thickness = textSize * Paint::kStdUnderline_Thickness;
	}
	const SkScalar top = y + position;
	drawStroke(left, right, top, thickness, paint, this);
	}
	if (strikeThru) {
	const float position = textSize * Paint::kStdStrikeThru_Top;
	const SkScalar thickness = textSize * Paint::kStdStrikeThru_Thickness;
	const SkScalar top = y + position;
	drawStroke(left, right, top, thickness, paint, this);
	}
	}
	}

	void Canvas::drawGlyphs(const minikin::Font& font, const int* glyphIds, const float* positions,
	int glyphCount, const Paint& paint) {
	// Minikin modify skFont for auto-fakebold/auto-fakeitalic.
	Paint copied(paint);

	auto glyphFunc = [&](uint16_t* outGlyphIds, float* outPositions) {
	for (uint32_t i = 0; i < glyphCount; ++i) {
	outGlyphIds[i] = static_cast<uint16_t>(glyphIds[i]);
	}
	memcpy(outPositions, positions, sizeof(float) * 2 * glyphCount);
	};

	const minikin::MinikinFont* minikinFont = font.baseTypeface().get();
	SkFont* skfont = &copied.getSkFont();
	MinikinFontSkia::populateSkFont(skfont, minikinFont, minikin::FontFakery());

	// total advance is used for drawing underline. We do not support underlyine by glyph drawing.
	drawGlyphs(glyphFunc, glyphCount, copied, 0 /* x /, 0 / y /, 0 / total Advance */);
	}

	void Canvas::drawText(const uint16_t* text, int textSize, int start, int count, int contextStart,
	int contextCount, float x, float y, minikin::Bidi bidiFlags,
	const Paint& origPaint, const Typeface* typeface, minikin::MeasuredText* mt) {
	// minikin may modify the original paint
	Paint paint(origPaint);

	// interpret 'linear metrics' flag as 'linear', forcing no-hinting when drawing
	if (paint.getSkFont().isLinearMetrics()) {
	paint.getSkFont().setHinting(SkFontHinting::kNone);
	}

	minikin::Layout layout = MinikinUtils::doLayout(&paint, bidiFlags, typeface, text, textSize,
	start, count, contextStart, contextCount, mt);

	x += MinikinUtils::xOffsetForTextAlign(&paint, layout);

	// Set align to left for drawing, as we don't want individual
	// glyphs centered or right-aligned; the offset above takes
	// care of all alignment.
	paint.setTextAlign(Paint::kLeft_Align);

	DrawTextFunctor f(layout, this, paint, x, y, layout.getAdvance());
	MinikinUtils::forFontRun(layout, &paint, f);

	if (text_feature::fix_double_underline()) {
	Paint copied(paint);
	PaintFilter* filter = getPaintFilter();
	if (filter != nullptr) {
	filter->filterFullPaint(&copied);
	}
	const bool isUnderline = copied.isUnderline();
	const bool isStrikeThru = copied.isStrikeThru();
	if (isUnderline \|\| isStrikeThru) {
	const SkScalar left = x;
	const SkScalar right = x + layout.getAdvance();
	if (isUnderline) {
	const SkScalar top = y + f.getUnderlinePosition();
	drawStroke(left, right, top, f.getUnderlineThickness(), copied, this);
	}
	if (isStrikeThru) {
	float textSize = paint.getSkFont().getSize();
	const float position = textSize * Paint::kStdStrikeThru_Top;
	const SkScalar thickness = textSize * Paint::kStdStrikeThru_Thickness;
	const SkScalar top = y + position;
	drawStroke(left, right, top, thickness, copied, this);
	}
	}
	}
	}

	void Canvas::drawDoubleRoundRectXY(float outerLeft, float outerTop, float outerRight,
	float outerBottom, float outerRx, float outerRy, float innerLeft,
	float innerTop, float innerRight, float innerBottom, float innerRx,
	float innerRy, const Paint& paint) {
	if (CC_UNLIKELY(paint.nothingToDraw())) return;
	SkRect outer = SkRect::MakeLTRB(outerLeft, outerTop, outerRight, outerBottom);
	SkRect inner = SkRect::MakeLTRB(innerLeft, innerTop, innerRight, innerBottom);

	SkRRect outerRRect;
	outerRRect.setRectXY(outer, outerRx, outerRy);

	SkRRect innerRRect;
	innerRRect.setRectXY(inner, innerRx, innerRy);
	drawDoubleRoundRect(outerRRect, innerRRect, paint);
	}

	void Canvas::drawDoubleRoundRectRadii(float outerLeft, float outerTop, float outerRight,
	float outerBottom, const float* outerRadii, float innerLeft,
	float innerTop, float innerRight, float innerBottom,
	const float* innerRadii, const Paint& paint) {
	static_assert(sizeof(SkVector) == sizeof(float) * 2);
	if (CC_UNLIKELY(paint.nothingToDraw())) return;
	SkRect outer = SkRect::MakeLTRB(outerLeft, outerTop, outerRight, outerBottom);
	SkRect inner = SkRect::MakeLTRB(innerLeft, innerTop, innerRight, innerBottom);

	SkRRect outerRRect;
	const SkVector* outerSkVector = reinterpret_cast<const SkVector*>(outerRadii);
	outerRRect.setRectRadii(outer, outerSkVector);

	SkRRect innerRRect;
	const SkVector* innerSkVector = reinterpret_cast<const SkVector*>(innerRadii);
	innerRRect.setRectRadii(inner, innerSkVector);
	drawDoubleRoundRect(outerRRect, innerRRect, paint);
	}

	class DrawTextOnPathFunctor {
	public:
	DrawTextOnPathFunctor(const minikin::Layout& layout, Canvas* canvas, float hOffset,
	float vOffset, const Paint& paint, const SkPath& path)
	: layout(layout)
	, canvas(canvas)
	, hOffset(hOffset)
	, vOffset(vOffset)
	, paint(paint)
	, path(path) {}

	void operator()(size_t start, size_t end) {
	canvas->drawLayoutOnPath(layout, hOffset, vOffset, paint, path, start, end);
	}

	private:
	const minikin::Layout& layout;
	Canvas* canvas;
	float hOffset;
	float vOffset;
	const Paint& paint;
	const SkPath& path;
	};

	void Canvas::drawTextOnPath(const uint16_t* text, int count, minikin::Bidi bidiFlags,
	const SkPath& path, float hOffset, float vOffset,
	const Paint& origPaint, const Typeface* typeface) {
	// minikin may modify the original paint
	Paint paint(origPaint);

	// interpret 'linear metrics' flag as 'linear', forcing no-hinting when drawing
	if (paint.getSkFont().isLinearMetrics()) {
	paint.getSkFont().setHinting(SkFontHinting::kNone);
	}

	minikin::Layout layout =
	MinikinUtils::doLayout(&paint, bidiFlags, typeface, text, count, // text buffer
	0, count, // draw range
	0, count, // context range
	nullptr);
	hOffset += MinikinUtils::hOffsetForTextAlign(&paint, layout, path);

	// Set align to left for drawing, as we don't want individual
	// glyphs centered or right-aligned; the offset above takes
	// care of all alignment.
	paint.setTextAlign(Paint::kLeft_Align);

	DrawTextOnPathFunctor f(layout, this, hOffset, vOffset, paint, path);
	MinikinUtils::forFontRun(layout, &paint, f);
	}

	int Canvas::sApiLevel = 1;

	void Canvas::setCompatibilityVersion(int apiLevel) {
	sApiLevel = apiLevel;
	}

	} // namespace android