style

const (
	// Superscript shifts text upward by 0.5 * (baseline - ascent)
	BaselineShiftSuperscript BaselineShift = 0.5
	// Subscript shifts text downward by -0.5 * (baseline - ascent)
	BaselineShiftSubscript BaselineShift = -0.5
	// None applies no baseline shift
	BaselineShiftNone BaselineShift = 0.0
)

const (
	// This represents an unset value, a usual replacement for "null" when a primitive value is
	// desired.
	HyphensUnspecified Hyphens = 0

	// Lines will break with no hyphenation.
	//
	// "Hard" hyphens will still be respected. However, no automatic hyphenation will be
	// attempted. If a word must be broken due to being longer than a line, it will break at any
	// character and will not attempt to break at a syllable boundary.
	//
	// +---------+
	// | Experim |
	// | ental   |
	// +---------+
	HyphensNone Hyphens = 1

	// The words will be automatically broken at appropriate hyphenation points.
	//
	// However, suggested line break opportunities (see Suggesting line break opportunities
	// above) will override automatic break point selection when present.
	//
	// +---------+
	// | Experi- |
	// | mental  |
	// +---------+
	HyphensAuto Hyphens = 2
)

const LineBreakUnspecified LineBreak = 0

const (
	// LineBreakStrategySimple Basic, fast break strategy. Hyphenation, if enabled, is done only for words that
	// don't fit on an entire line by themselves.
	LineBreakStrategySimple LineBreakStrategy = 1

	// LineBreakStrategyHighQuality Does whole paragraph optimization for more readable text, including hyphenation if
	// enabled.
	LineBreakStrategyHighQuality LineBreakStrategy = 2

	// LineBreakStrategyBalanced Attempts to balance the line lengths of the text, also applying automatic hyphenation
	// if enabled. Suitable for small screens.
	LineBreakStrategyBalanced LineBreakStrategy = 3

	// LineBreakStrategyUnspecified This represents an unset value, a usual replacement for "null" when a primitive value
	// is desired.
	LineBreakStrategyUnspecified LineBreakStrategy = 0
)

const (
	// LineBreakStrictnessDefault Default breaking rules for the locale, which may correspond to [Normal] or [Strict].
	LineBreakStrictnessDefault LineBreakStrictness = 1

	// LineBreakStrictnessLoose The least restrictive rules, suitable for short lines.
	//
	// For example, in Japanese it allows breaking before iteration marks, such as 々, 〻.
	LineBreakStrictnessLoose LineBreakStrictness = 2

	// LineBreakStrictnessNormal The most common rules for line breaking.
	//
	// For example, in Japanese it allows breaking before characters like small hiragana
	// (ぁ), small katakana (ァ), halfwidth variants (ｧ).
	LineBreakStrictnessNormal LineBreakStrictness = 3

	// LineBreakStrictnessStrict The most stringent rules for line breaking.
	//
	// For example, in Japanese it does not allow breaking before characters like small
	// hiragana (ぁ), small katakana (ァ), halfwidth variants (ｧ).
	LineBreakStrictnessStrict LineBreakStrictness = 4

	// LineBreakStrictnessUnspecified This represents an unset value, a usual replacement for "null" when a primitive value
	// is desired.
	LineBreakStrictnessUnspecified LineBreakStrictness = 0
)

const (
	// LineBreakWordBreakDefault Default word breaking rules for the locale. In latin scripts this means inserting
	// line breaks between words, while in languages that don't use whitespace (e.g.
	// Japanese) the line can break between characters.
	LineBreakWordBreakDefault LineBreakWordBreak = 1

	// LineBreakWordBreakPhrase Line breaking is based on phrases. In languages that don't use whitespace (e.g.
	// Japanese), line breaks are not inserted between characters that are part of the same
	// phrase unit. This is ideal for short text such as titles and UI labels.
	LineBreakWordBreakPhrase LineBreakWordBreak = 2

	// LineBreakWordBreakUnspecified This represents an unset value, a usual replacement for "null" when a primitive value
	// is desired.
	LineBreakWordBreakUnspecified LineBreakWordBreak = 0
)

const (
	LineHeightStyleModeUnspecified LineHeightStyleMode = -1
	// LineHeightStyleModeFixed guarantees that taller glyphs won't be trimmed at the boundaries.
	LineHeightStyleModeFixed LineHeightStyleMode = 0
	// LineHeightStyleModeMinimum prevents the overflow of tall glyphs in middle lines.
	LineHeightStyleModeMinimum LineHeightStyleMode = 1
	// LineHeightStyleModeTight gets rid of the safety rails that are added by Fixed.
	LineHeightStyleModeTight LineHeightStyleMode = 2
)

const (
	LineHeightStyleTrimFirstLineTop   LineHeightStyleTrim = flagTrimTop
	LineHeightStyleTrimLastLineBottom LineHeightStyleTrim = flagTrimBottom
	LineHeightStyleTrimBoth           LineHeightStyleTrim = flagTrimTop | flagTrimBottom
	LineHeightStyleTrimNone           LineHeightStyleTrim = 0
	LineHeightStyleTrimUnspecified    LineHeightStyleTrim = -1
)

const (
	LinearityUnspecified Linearity = 0
	// LinearityLinear is equal to applying LINEAR_TEXT_FLAG and turning hinting off.
	LinearityLinear Linearity = 1
	// LinearityFontHinting is equal to removing LINEAR_TEXT_FLAG and turning hinting on.
	LinearityFontHinting Linearity = 2
	// LinearityNone is equal to removing LINEAR_TEXT_FLAG and turning hinting off.
	LinearityNone Linearity = 3
)

const (
	// ResolvedTextDirectionLtr represents text that is left-to-right.
	ResolvedTextDirectionLtr ResolvedTextDirection = iota

	// ResolvedTextDirectionRtl represents text that is right-to-left.
	ResolvedTextDirectionRtl
)

const (
	SubpixelTextPositioningUnspecified SubpixelTextPositioning = 0
	SubpixelTextPositioningTrue        SubpixelTextPositioning = 1
	SubpixelTextPositioningFalse       SubpixelTextPositioning = 2
)

const (
	// TextAlignUnspecified represents an unset value, a usual replacement for "null"
	// when a primitive value is desired.
	TextAlignUnspecified TextAlign = 0

	// TextAlignLeft aligns the text on the left edge of the container.
	TextAlignLeft TextAlign = 1

	// TextAlignRight aligns the text on the right edge of the container.
	TextAlignRight TextAlign = 2

	// TextAlignCenter aligns the text in the center of the container.
	TextAlignCenter TextAlign = 3

	// TextAlignJustify stretches lines of text that end with a soft line break
	// to fill the width of the container.
	// Lines that end with hard line breaks are aligned towards the Start edge.
	TextAlignJustify TextAlign = 4

	// TextAlignStart aligns the text on the leading edge of the container.
	// For Left to Right text, this is the left edge.
	// For Right to Left text, like Arabic, this is the right edge.
	TextAlignStart TextAlign = 5

	// TextAlignEnd aligns the text on the trailing edge of the container.
	// For Left to Right text, this is the right edge.
	// For Right to Left text, like Arabic, this is the left edge.
	TextAlignEnd TextAlign = 6
)

const (
	TextDecorationMaskUnspecified TextDecorationMask = -1
	TextDecorationMaskNone        TextDecorationMask = 0x0
	TextDecorationMaskUnderline   TextDecorationMask = 0x1
	TextDecorationMaskLineThrough TextDecorationMask = 0x2
)

const (
	// TextDirectionUnspecified represents an unset value, a usual replacement for "null"
	// when a primitive value is desired.
	TextDirectionUnspecified TextDirection = 0

	// TextDirectionLtr always sets the text direction to be Left to Right.
	TextDirectionLtr TextDirection = 1

	// TextDirectionRtl always sets the text direction to be Right to Left.
	TextDirectionRtl TextDirection = 2

	// TextDirectionContent indicates that the text direction depends on the first strong
	// directional character in the text according to the Unicode Bidirectional Algorithm.
	// If no strong directional character is present, then LayoutDirection is used to
	// resolve the final TextDirection.
	// * if used while creating a Paragraph object, LocaleList will be used to resolve
	//   the direction as a fallback instead of LayoutDirection.
	TextDirectionContent TextDirection = 3

	// TextDirectionContentOrLtr indicates that the text direction depends on the first
	// strong directional character in the text according to the Unicode Bidirectional
	// Algorithm. If no strong directional character is present, then Left to Right will
	// be used as the default direction.
	TextDirectionContentOrLtr TextDirection = 4

	// TextDirectionContentOrRtl indicates that the text direction depends on the first
	// strong directional character in the text according to the Unicode Bidirectional
	// Algorithm. If no strong directional character is present, then Right to Left will
	// be used as the default direction.
	TextDirectionContentOrRtl TextDirection = 5
)

const (
	// Clip the overflowing text to fix its container.
	OverFlowClip TextOverFlow = 1

	// Use an ellipsis at the end of the string to indicate that the text has overflowed.
	// For example, [This is a ...].
	OverFlowEllipsis TextOverFlow = 2

	// Display all text, even if there is not enough space in the specified bounds. When
	// overflow is visible, text may be rendered outside the bounds of the composable displaying
	// the text. This ensures that all text is displayed to the user, and is typically the right
	// choice for most text display. It does mean that the text may visually occupy a region
	// larger than the bounds of its composable. This can lead to situations where text
	// displays outside the bounds of the background and clickable on a Text composable with a
	// fixed height and width.
	//
	// To make the background and click region expand to match the size of the text, allow it to
	// expand vertically/horizontally using Modifier.heightIn/Modifier.widthIn or similar.
	//
	// Note: text that expands past its bounds using Visible may be clipped by other modifiers
	// such as Modifier.clipToBounds.
	OverFlowVisible TextOverFlow = 3

	// Use an ellipsis at the start of the string to indicate that the text has overflowed.
	// For example, [... is a text].
	//
	// Note that not all platforms support the ellipsis at the start. For example, on Android
	// the start ellipsis is only available for a single line text (i.e. when either a soft wrap
	// is disabled or a maximum number of lines maxLines set to 1). In case of multiline text it
	// will fallback to Clip.
	OverFlowStartEllipsis TextOverFlow = 4

	// Use an ellipsis in the middle of the string to indicate that the text has overflowed.
	// For example, [This ... text].
	//
	// Note that not all platforms support the ellipsis in the middle. For example, on Android
	// the middle ellipsis is only available for a single line text (i.e. when either a soft
	// wrap is disabled or a maximum number of lines maxLines set to 1). In case of multiline
	// text it will fallback to Clip.
	OverFlowMiddleEllipsis TextOverFlow = 5
)