kitepdf-core/io.github.yuroyami.kitepdf.core.render/GraphicsState

GraphicsState

data class GraphicsState(val ctm: KiteMatrix = KiteMatrix.IDENTITY, val strokeColor: RgbColor = RgbColor.BLACK, val fillColor: RgbColor = RgbColor.BLACK, val lineWidth: Double = 1.0, val text: TextState = TextState(), val fillColorSpace: KiteColorSpace = KiteColorSpace.DeviceGray, val strokeColorSpace: KiteColorSpace = KiteColorSpace.DeviceGray, val fillAlpha: Double = 1.0, val strokeAlpha: Double = 1.0, val blendMode: KiteBlendMode = KiteBlendMode.Normal, val softMask: SoftMask? = null, val softMaskCtm: KiteMatrix? = null, val fillPattern: KitePattern? = null, val strokePattern: KitePattern? = null, val dashArray: List<Double>? = null, val dashPhase: Double = 0.0, val lineCap: Int = 0, val lineJoin: Int = 0, val miterLimit: Double = 10.0, val renderingIntent: KiteRenderingIntent = KiteRenderingIntent.RelativeColorimetric, val blackPointCompensation: Boolean = true, val fillComponents: DoubleArray? = null, val strokeComponents: DoubleArray? = null, val overprintStroke: Boolean = false, val overprintFill: Boolean = false, val overprintMode: Int = 0)(source)

Graphics state (ISO 32000-1 §8.4).

Every PDF content stream runs inside a stack of graphics states. q pushes a copy; Q pops back. cm, color setters, font setters etc. mutate the top of the stack. We model this with an immutable GraphicsState data class and a stack on the side (see GraphicsStack). That is easier to reason about than a mutable struct, and it costs one small allocation per q.

Text state (Tm, Tlm, font, size, spacing) is tracked separately on TextState and lives only inside BT…ET blocks.

Constructors

GraphicsState

constructor(ctm: KiteMatrix = KiteMatrix.IDENTITY, strokeColor: RgbColor = RgbColor.BLACK, fillColor: RgbColor = RgbColor.BLACK, lineWidth: Double = 1.0, text: TextState = TextState(), fillColorSpace: KiteColorSpace = KiteColorSpace.DeviceGray, strokeColorSpace: KiteColorSpace = KiteColorSpace.DeviceGray, fillAlpha: Double = 1.0, strokeAlpha: Double = 1.0, blendMode: KiteBlendMode = KiteBlendMode.Normal, softMask: SoftMask? = null, softMaskCtm: KiteMatrix? = null, fillPattern: KitePattern? = null, strokePattern: KitePattern? = null, dashArray: List<Double>? = null, dashPhase: Double = 0.0, lineCap: Int = 0, lineJoin: Int = 0, miterLimit: Double = 10.0, renderingIntent: KiteRenderingIntent = KiteRenderingIntent.RelativeColorimetric, blackPointCompensation: Boolean = true, fillComponents: DoubleArray? = null, strokeComponents: DoubleArray? = null, overprintStroke: Boolean = false, overprintFill: Boolean = false, overprintMode: Int = 0)

Properties

blackPointCompensation

val blackPointCompensation: Boolean

Black point compensation in that conversion (ExtGState /UseBlackPtComp).

blendMode

val blendMode: KiteBlendMode

Blend mode applied to paints (ExtGState /BM).

ctm

val ctm: KiteMatrix

dashArray

val dashArray: List<Double>?

Dash pattern (d operator): on/off lengths in user-space units; null/empty = solid.

dashPhase

val dashPhase: Double

Dash phase offset (d operator), user-space units.

fillAlpha

val fillAlpha: Double

Per-pixel alpha multiplier for fills (ExtGState /ca), 0..1.

fillColor

val fillColor: RgbColor

fillColorSpace

val fillColorSpace: KiteColorSpace

Current non-stroke colour space (cs operator).

fillComponents

val fillComponents: DoubleArray?

The components fillColor came from in fillColorSpace, or null for the initial colour of the space.

fillPattern

val fillPattern: KitePattern?

Active fill pattern, set by scn when the fill colour-space is /Pattern. When non-null, fillColor is ignored and paint operators route through the canvas's gradient/tile path. Cleared by any plain colour setter (g, rg, k, cs, sc).

lineCap

val lineCap: Int

Line cap (J): 0 butt, 1 round, 2 projecting square.

lineJoin

val lineJoin: Int

Line join (j): 0 miter, 1 round, 2 bevel.

lineWidth

val lineWidth: Double

miterLimit

val miterLimit: Double

Miter limit (M).

overprintFill

val overprintFill: Boolean

Overprint for fills and other paints (ExtGState /op).

overprintMode

val overprintMode: Int

The overprint mode (ExtGState /OPM): 1 leaves the backdrop's ink wherever a DeviceCMYK paint sets 0.

overprintStroke

val overprintStroke: Boolean

Overprint for strokes (ExtGState /OP).

renderingIntent

val renderingIntent: KiteRenderingIntent

The rendering intent (ri, ExtGState /RI) that colours convert through.

softMask

val softMask: SoftMask?

Active soft mask (ExtGState /SMask); null when none.

softMaskCtm

val softMaskCtm: KiteMatrix?

The CTM when softMask was set: the mask is drawn under it, never under a later cm (#67).

strokeAlpha

val strokeAlpha: Double

Per-pixel alpha multiplier for strokes (ExtGState /CA), 0..1.

strokeColor

val strokeColor: RgbColor

strokeColorSpace

val strokeColorSpace: KiteColorSpace

Current stroke colour space (CS operator).

strokeComponents

val strokeComponents: DoubleArray?

The components strokeColor came from in strokeColorSpace, or null for the initial colour of the space.

strokePattern

val strokePattern: KitePattern?

Active stroke pattern: same semantics as fillPattern for SCN.

text

val text: TextState

Functions

applyExtGState

fun GraphicsState.applyExtGState(ext: ExtGState): GraphicsState

Merge the non-null fields of ext into this state. Spec semantics for gs <name>: only entries present in the ExtGState override; everything else passes through.

withColorRendering

fun GraphicsState.withColorRendering(intent: KiteRenderingIntent, blackPointCompensation: Boolean): GraphicsState

This state with colours converting through intent, with or without black point compensation. The current colours convert again from their components, so a colour set before ri follows it, as it does in MuPDF (#201).