Inheritance diagram for ParagraphGM:

Public Member Functions
	ParagraphGM (unsigned flags)

void	buildParagraph ()

Public Member Functions inherited from skiagm::GM
	GM (SkColor backgroundColor=SK_ColorWHITE)

virtual	~GM ()

void	setMode (Mode mode)

Mode	getMode () const

DrawResult	gpuSetup (SkCanvas , SkString errorMsg, GraphiteTestContext *=nullptr)

void	gpuTeardown ()

void	onceBeforeDraw ()

DrawResult	draw (SkCanvas *canvas)

DrawResult	draw (SkCanvas , SkString errorMsg)

void	drawBackground (SkCanvas *)

DrawResult	drawContent (SkCanvas *canvas)

DrawResult	drawContent (SkCanvas , SkString errorMsg)

SkScalar	width ()

SkScalar	height ()

SkColor	getBGColor () const

void	setBGColor (SkColor)

void	drawSizeBounds (SkCanvas *, SkColor)

bool	animate (double)

virtual bool	onChar (SkUnichar)

bool	getControls (SkMetaData *controls)

void	setControls (const SkMetaData &controls)

virtual void	modifyGrContextOptions (GrContextOptions *)

virtual void	modifyGraphiteContextOptions (skgpu::graphite::ContextOptions *) const

virtual bool	isBazelOnly () const

virtual std::map< std::string, std::string >	getGoldKeys () const

Protected Member Functions
void	onOnceBeforeDraw () override

SkString	getName () const override

SkISize	getISize () override

void	drawFromVisitor (SkCanvas canvas, skia::textlayout::Paragraph para) const

DrawResult	onDraw (SkCanvas canvas, SkString errorMsg) override

bool	runAsBench () const override

bool	onAnimate (double) override

Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas , SkString , GraphiteTestContext *)

virtual void	onGpuTeardown ()

virtual void	onDraw (SkCanvas *)

virtual bool	onGetControls (SkMetaData *)

virtual void	onSetControls (const SkMetaData &)

GraphiteTestContext *	graphiteTestContext () const

Additional Inherited Members
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }

using	DrawResult = skiagm::DrawResult

using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext

Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Definition at line 68 of file simple_gm.cpp.

Constructor & Destructor Documentation

◆ ParagraphGM()

ParagraphGM::ParagraphGM ( unsigned flags )

inline

Definition at line 73 of file simple_gm.cpp.

73: fFlags(flags) {}

flags

FlutterSemanticsFlag flags

Definition fl_accessible_node.cc:105

Member Function Documentation

◆ buildParagraph()

void ParagraphGM::buildParagraph ( )

inline

Definition at line 75 of file simple_gm.cpp.

                          {
        skia::textlayout::TextStyle style;
        style.setForegroundColor(SkPaint());
        style.setFontFamilies({SkString("sans-serif")});
        style.setFontSize(30);
 
        if (fFlags & kUseUnderline) {
            style.setDecoration(skia::textlayout::TextDecoration::kUnderline);
            style.setDecorationMode(skia::textlayout::TextDecorationMode::kThrough);
            style.setDecorationColor(SK_ColorBLACK);
            style.setDecorationThicknessMultiplier(2);
        }
 
        skia::textlayout::ParagraphStyle paraStyle;
        paraStyle.setTextStyle(style);
 
        sk_sp<SkFontMgr> fontmgr = ToolUtils::TestFontMgr();
        if (fontmgr->countFamilies() == 0) {
            fPara = nullptr;
            return;
        }
        auto collection = sk_make_sp<skia::textlayout::FontCollection>();
        collection->setDefaultFontManager(std::move(fontmgr));
 
        auto unicode = get_unicode();
        if (!unicode) {
            fPara = nullptr;
            return;
        }
        auto builder = skia::textlayout::ParagraphBuilderImpl::make(
                paraStyle, collection, unicode);
        if (nullptr == builder) {
            fPara = nullptr;
            return;
        }
 
        builder->addText(gSpeech, strlen(gSpeech));
 
        fPara = builder->Build();
        fPara->layout(400);
    }

◆ drawFromVisitor()

void ParagraphGM::drawFromVisitor	(	SkCanvas *	canvas,
		skia::textlayout::Paragraph *	para
	)		const

inlineprotected

Definition at line 140 of file simple_gm.cpp.

                                                                                {
        SkPaint p, p2;
        p.setColor(0xFF0000FF);
        p2.setColor(0xFFFF0000);
        p2.setStrokeWidth(4);
        p2.setStrokeCap(SkPaint::kSquare_Cap);
        SkPaint underp;
        underp.setStroke(true);
        underp.setStrokeWidth(2);
        underp.setAntiAlias(true);
        underp.setColor(p.getColor());
        const SkScalar GAP = 2;
 
        para->visit([&](int, const skia::textlayout::Paragraph::VisitorInfo* info) {
            if (!info) {
                return;
            }
            canvas->drawGlyphs(info->count, info->glyphs, info->positions, info->origin,
                               info->font, p);
 
            if (fFlags & kUseUnderline) {
                // Need to modify positions to roll-in the orign
                std::vector<SkPoint> pos;
                for (int i = 0; i < info->count; ++i) {
                    pos.push_back({info->origin.fX + info->positions[i].fX,
                                   info->origin.fY + info->positions[i].fY});
                }
 
                const SkScalar X0 = pos[0].fX;
                const SkScalar X1 = X0 + info->advanceX;
                const SkScalar Y  = pos[0].fY;
                auto sects = info->font.getIntercepts(info->glyphs, info->count, pos.data(),
                                                      Y+1, Y+3);
 
                SkScalar x0 = X0;
                for (size_t i = 0; i < sects.size(); i += 2) {
                    SkScalar x1 = sects[i] - GAP;
                    if (x0 < x1) {
                        canvas->drawLine(x0, Y+2, x1, Y+2, underp);
                    }
                    x0 = sects[i+1] + GAP;
                }
                canvas->drawLine(x0, Y+2, X1, Y+2, underp);
            }
 
            if ((false)) {
                if (info->utf8Starts) {
                    SkString str;
                    for (int i = 0; i < info->count; ++i) {
                        str.appendUnichar(gSpeech[info->utf8Starts[i]]);
                    }
                    SkDebugf("'%s'\n", str.c_str());
                }
 
                // show position points
                for (int i = 0; i < info->count; ++i) {
                    auto pos = info->positions[i];
                    canvas->drawPoint(pos.fX + info->origin.fX, pos.fY + info->origin.fY, p2);
                }
            }
        });
    }