Inheritance diagram for RandomScalerContext:

Public Member Functions
	RandomScalerContext (sk_sp< SkRandomTypeface >, const SkScalerContextEffects &, const SkDescriptor *, bool fFakeIt)

Public Member Functions inherited from SkScalerContext
	SkScalerContext (sk_sp< SkTypeface >, const SkScalerContextEffects &, const SkDescriptor *)

virtual	~SkScalerContext ()

SkTypeface *	getTypeface () const

SkMask::Format	getMaskFormat () const

bool	isSubpixel () const

bool	isLinearMetrics () const

bool	isVertical () const

SkGlyph	makeGlyph (SkPackedGlyphID, SkArenaAlloc *)

void	getImage (const SkGlyph &)

void	getPath (SkGlyph &, SkArenaAlloc *)

sk_sp< SkDrawable >	getDrawable (SkGlyph &)

void	getFontMetrics (SkFontMetrics *)

const SkScalerContextRec &	getRec () const

SkScalerContextEffects	getEffects () const

SkAxisAlignment	computeAxisAlignmentForHText () const

Protected Member Functions
GlyphMetrics	generateMetrics (const SkGlyph &, SkArenaAlloc *) override

void	generateImage (const SkGlyph &, void *) override

bool	generatePath (const SkGlyph &, SkPath *) override

sk_sp< SkDrawable >	generateDrawable (const SkGlyph &) override

void	generateFontMetrics (SkFontMetrics *) override

Protected Member Functions inherited from SkScalerContext
virtual GlyphMetrics	generateMetrics (const SkGlyph &, SkArenaAlloc *)=0

virtual void	generateImage (const SkGlyph &glyph, void *imageBuffer)=0

virtual bool	generatePath (const SkGlyph &, SkPath *)=0

virtual sk_sp< SkDrawable >	generateDrawable (const SkGlyph &)

virtual void	generateFontMetrics (SkFontMetrics *)=0

void	forceGenerateImageFromPath ()

void	forceOffGenerateImageFromPath ()

Additional Inherited Members
Public Types inherited from SkScalerContext
enum	Flags { kFrameAndFill_Flag = 0x0001 , kUnused = 0x0002 , kEmbeddedBitmapText_Flag = 0x0004 , kEmbolden_Flag = 0x0008 , kSubpixelPositioning_Flag = 0x0010 , kForceAutohinting_Flag = 0x0020 , kHinting_Shift = 7 , kHintingBit1_Flag = 0x0080 , kHintingBit2_Flag = 0x0100 , kLCD_Vertical_Flag = 0x0200 , kLCD_BGROrder_Flag = 0x0400 , kGenA8FromLCD_Flag = 0x0800 , kLinearMetrics_Flag = 0x1000 , kBaselineSnap_Flag = 0x2000 , kNeedsForegroundColor_Flag = 0x4000 }

enum	{ kHinting_Mask = kHintingBit1_Flag \| kHintingBit2_Flag }

Static Public Member Functions inherited from SkScalerContext
static size_t	GetGammaLUTSize (SkScalar contrast, SkScalar deviceGamma, int width, int height)

static bool	GetGammaLUTData (SkScalar contrast, SkScalar deviceGamma, uint8_t *data)

static void	MakeRecAndEffects (const SkFont &font, const SkPaint &paint, const SkSurfaceProps &surfaceProps, SkScalerContextFlags scalerContextFlags, const SkMatrix &deviceMatrix, SkScalerContextRec rec, SkScalerContextEffects effects)

static void	MakeRecAndEffectsFromFont (const SkFont &font, SkScalerContextRec rec, SkScalerContextEffects effects)

static std::unique_ptr< SkScalerContext >	MakeEmpty (sk_sp< SkTypeface > typeface, const SkScalerContextEffects &effects, const SkDescriptor *desc)

static SkDescriptor *	AutoDescriptorGivenRecAndEffects (const SkScalerContextRec &rec, const SkScalerContextEffects &effects, SkAutoDescriptor *ad)

static std::unique_ptr< SkDescriptor >	DescriptorGivenRecAndEffects (const SkScalerContextRec &rec, const SkScalerContextEffects &effects)

static void	DescriptorBufferGiveRec (const SkScalerContextRec &rec, void *buffer)

static bool	CheckBufferSizeForRec (const SkScalerContextRec &rec, const SkScalerContextEffects &effects, size_t size)

static SkMaskGamma::PreBlend	GetMaskPreBlend (const SkScalerContextRec &rec)

static SkDescriptor *	CreateDescriptorAndEffectsUsingPaint (const SkFont &, const SkPaint &, const SkSurfaceProps &, SkScalerContextFlags scalerContextFlags, const SkMatrix &deviceMatrix, SkAutoDescriptor ad, SkScalerContextEffects effects)

Static Protected Member Functions inherited from SkScalerContext
static void	GenerateMetricsFromPath (SkGlyph *glyph, const SkPath &path, SkMask::Format format, bool verticalLCD, bool a8FromLCD, bool hairline)

static void	SaturateGlyphBounds (SkGlyph *glyph, SkRect &&)

static void	SaturateGlyphBounds (SkGlyph *glyph, SkIRect const &)

static void	GenerateImageFromPath (SkMaskBuilder &dst, const SkPath &path, const SkMaskGamma::PreBlend &maskPreBlend, bool doBGR, bool verticalLCD, bool a8FromLCD, bool hairline)

Protected Attributes inherited from SkScalerContext
SkScalerContextRec	fRec

const SkMaskGamma::PreBlend	fPreBlend

Detailed Description

Definition at line 24 of file RandomScalerContext.cpp.

Constructor & Destructor Documentation

◆ RandomScalerContext()

RandomScalerContext::RandomScalerContext	(	sk_sp< SkRandomTypeface >	face,
		const SkScalerContextEffects &	effects,
		const SkDescriptor *	desc,
		bool	fFakeIt
	)

Definition at line 49 of file RandomScalerContext.cpp.

        : SkScalerContext(std::move(face), effects, desc)
        , fProxy(getRandomTypeface()->proxy()->createScalerContext(SkScalerContextEffects(), desc))
        , fFakeIt(fakeIt) {
    fProxy->forceGenerateImageFromPath();
}

Member Function Documentation

◆ generateDrawable()

sk_sp< SkDrawable > RandomScalerContext::generateDrawable ( const SkGlyph & )

overrideprotectedvirtual

Returns the drawable for the glyph (if any).

The generated drawable will be lifetime scoped to the lifetime of this scaler context. This means the drawable may refer to the scaler context and associated font data.

The drawable does not need to be flattenable (e.g. implement getFactory and getTypeName). Any necessary serialization will be done with makePictureSnapshot.

Reimplemented from SkScalerContext.

Definition at line 151 of file RandomScalerContext.cpp.

                                                                            {
    SkGlyph* shadowProxyGlyph = fProxyGlyphs.find(glyph.getPackedID());
    if (shadowProxyGlyph && shadowProxyGlyph->path()) {
        return nullptr;
    }
    return fProxy->generateDrawable(glyph);
}

◆ generateFontMetrics()

void RandomScalerContext::generateFontMetrics ( SkFontMetrics * )

overrideprotectedvirtual

Retrieves font metrics.

Implements SkScalerContext.

Definition at line 159 of file RandomScalerContext.cpp.

                                                                    {
    fProxy->getFontMetrics(metrics);
}

◆ generateImage()

void RandomScalerContext::generateImage	(	const SkGlyph &	glyph,
		void *	imageBuffer
	)

overrideprotectedvirtual

Generates the contents of glyph.fImage. When called, glyph.fImage will be pointing to a pre-allocated, uninitialized region of memory of size glyph.imageSize(). This method may not change glyph.fMaskFormat.

Because glyph.imageSize() will determine the size of fImage, generateMetrics will be called before generateImage.

Implements SkScalerContext.

Definition at line 111 of file RandomScalerContext.cpp.

                                                                               {
    if (fFakeIt) {
        sk_bzero(imageBuffer, glyph.imageSize());
        return;
    }
 
    SkGlyph* proxyGlyph = fProxyGlyphs.find(glyph.getPackedID());
    if (!proxyGlyph || !proxyGlyph->path()) {
        fProxy->getImage(glyph);
        return;
    }
    const SkPath& path = *proxyGlyph->path();
    const bool hairline = proxyGlyph->pathIsHairline();
 
    SkBitmap bm;
    bm.installPixels(SkImageInfo::MakeN32Premul(glyph.width(), glyph.height()),
                     imageBuffer, glyph.rowBytes());
    bm.eraseColor(0);
 
    SkCanvas canvas(bm);
    canvas.translate(-SkIntToScalar(glyph.left()), -SkIntToScalar(glyph.top()));
    SkPaint paint = this->getRandomTypeface()->paint();
    if (hairline) {
        // We have a device path with effects already applied which is normally a fill path.
        // However here we do not have a fill path and there is no area to fill.
        paint.setStyle(SkPaint::kStroke_Style);
        paint.setStroke(0);
    }
    canvas.drawPath(path, paint); //Need to modify the paint if the devPath is hairline
}

◆ generateMetrics()

SkScalerContext::GlyphMetrics RandomScalerContext::generateMetrics	(	const SkGlyph &	origGlyph,
		SkArenaAlloc *	alloc
	)

overrideprotectedvirtual

Implements SkScalerContext.

Definition at line 59 of file RandomScalerContext.cpp.

                                                                                        {
    // Here we will change the mask format of the glyph
    // NOTE: this may be overridden by the base class (e.g. if a mask filter is applied).
    SkMask::Format format = SkMask::kA8_Format;
    switch (origGlyph.getGlyphID() % 4) {
        case 0: format = SkMask::kLCD16_Format; break;
        case 1: format = SkMask::kA8_Format; break;
        case 2: format = SkMask::kARGB32_Format; break;
        case 3: format = SkMask::kBW_Format; break;
    }
 
    auto glyph = fProxy->internalMakeGlyph(origGlyph.getPackedID(), format, alloc);
 
    GlyphMetrics mx(SkMask::kA8_Format);
    mx.advance = glyph.advanceVector();
    mx.bounds = glyph.rect();
    mx.maskFormat = glyph.maskFormat();
    mx.extraBits = glyph.extraBits();
 
    if (fFakeIt || (glyph.getGlyphID() % 4) != 2) {
        mx.neverRequestPath = glyph.setPathHasBeenCalled() && !glyph.path();
        mx.computeFromPath = !mx.neverRequestPath;
        return mx;
    }
 
    fProxy->getPath(glyph, alloc);
    if (!glyph.path()) {
        mx.neverRequestPath = true;
        return mx;
    }
 
    // The proxy glyph has a path, but this glyph does not.
    // Stash the proxy glyph so it can be used later.
    const auto packedID = glyph.getPackedID();
    const SkGlyph* proxyGlyph = fProxyGlyphs.set(packedID, std::move(glyph));
    const SkPath& proxyPath = *proxyGlyph->path();
 
    mx.neverRequestPath = true;
    mx.maskFormat = SkMask::kARGB32_Format;
    mx.advance = proxyGlyph->advanceVector();
    mx.extraBits = proxyGlyph->extraBits();
 
    SkRect         storage;
    const SkPaint& paint = this->getRandomTypeface()->paint();
    const SkRect&  newBounds =
            paint.doComputeFastBounds(proxyPath.getBounds(), &storage, SkPaint::kFill_Style);
    newBounds.roundOut(&mx.bounds);
 
    return mx;
}

◆ generatePath()

bool RandomScalerContext::generatePath	(	const SkGlyph &	,
		SkPath *
	)

overrideprotectedvirtual

Sets the passed path to the glyph outline. If this cannot be done the path is set to empty; Does not apply subpixel positioning to the path.

Returns: false if this glyph does not have any path.

Implements SkScalerContext.

Definition at line 142 of file RandomScalerContext.cpp.

                                                                         {
    SkGlyph* shadowProxyGlyph = fProxyGlyphs.find(glyph.getPackedID());
    if (shadowProxyGlyph && shadowProxyGlyph->path()) {
        path->reset();
        return false;
    }
    return fProxy->generatePath(glyph, path);
}

The documentation for this class was generated from the following file:

third_party/skia/tools/fonts/RandomScalerContext.cpp

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RandomScalerContext()

Member Function Documentation

◆ generateDrawable()

◆ generateFontMetrics()

◆ generateImage()

◆ generateMetrics()

◆ generatePath()