diff --git a/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/Ribbon.kt b/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/Ribbon.kt index 95bc4711..8ee5e9d7 100644 --- a/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/Ribbon.kt +++ b/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/Ribbon.kt @@ -89,15 +89,17 @@ fun PresentationModel.inRibbon( data class RibbonGalleryContentModel( val icon: Painter? = null, val commandGroups: List, + val selectedCommand: Command? = null, val extraPopupGroups: List, - val commandAction: (() -> Unit)? = null, + val commandAction: ((Command?) -> Unit)? = null, val commandActionPreview: CommandActionPreview? = null, ) : ContentModel data class RibbonGalleryPresentationModel( + val preferredVisibleCommandCounts: Map, val popupLayoutSpec: MenuPopupPanelLayoutSpec, + val commandButtonPresentationState: CommandButtonPresentationState, val expandKeyTip: String? = null, - val policies: Map ) : PresentationModel class RibbonGalleryProjection( diff --git a/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/RibbonBand.kt b/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/RibbonBand.kt index bc34e126..0362cada 100644 --- a/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/RibbonBand.kt +++ b/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/RibbonBand.kt @@ -16,7 +16,14 @@ package org.pushingpixels.aurora.component.ribbon import androidx.compose.ui.graphics.painter.Painter +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.unit.Density +import androidx.compose.ui.unit.LayoutDirection +import org.pushingpixels.aurora.component.layout.CommandButtonLayoutManager +import org.pushingpixels.aurora.component.layout.CommandButtonLayoutManagerBig import org.pushingpixels.aurora.component.model.Command +import org.pushingpixels.aurora.component.model.CommandButtonPresentationState import org.pushingpixels.aurora.component.ribbon.resize.CoreRibbonResizePolicies import org.pushingpixels.aurora.component.ribbon.resize.RibbonBandResizePolicy @@ -53,4 +60,29 @@ data class FlowRibbonBand( val flowComponentProjections: List = emptyList() ) : AbstractRibbonBand +object RibbonBandCommandButtonPresentationStates { + val BigFixed: CommandButtonPresentationState = + object : CommandButtonPresentationState("Big Fixed") { + override fun createLayoutManager( + layoutDirection: LayoutDirection, + density: Density, + textStyle: TextStyle, + fontFamilyResolver: FontFamily.Resolver + ): CommandButtonLayoutManager { + throw UnsupportedOperationException() + } + } + val BigFixedLandscape: CommandButtonPresentationState = + object : CommandButtonPresentationState("Big Fixed Landscape") { + override fun createLayoutManager( + layoutDirection: LayoutDirection, + density: Density, + textStyle: TextStyle, + fontFamilyResolver: FontFamily.Resolver + ): CommandButtonLayoutManager { + throw UnsupportedOperationException() + } + } + +} diff --git a/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/resize/RibbonBandResizePolicies.kt b/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/resize/RibbonBandResizePolicies.kt index 73bc33fb..5e7b9279 100644 --- a/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/resize/RibbonBandResizePolicies.kt +++ b/component/src/desktopMain/kotlin/org/pushingpixels/aurora/component/ribbon/resize/RibbonBandResizePolicies.kt @@ -118,6 +118,10 @@ object CoreRibbonResizePolicies { return emptyList() } + public fun getCorePoliciesRestrictive(): List { + return emptyList() + } + public fun getCoreFlowPoliciesRestrictive(stepsToRepeat: Int): List { return emptyList() } diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/LocaleSwitcher.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/LocaleSwitcher.kt index 9c03a1b8..da99b2b4 100644 --- a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/LocaleSwitcher.kt +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/LocaleSwitcher.kt @@ -20,7 +20,7 @@ import org.pushingpixels.aurora.component.model.* import org.pushingpixels.aurora.component.projection.CommandButtonProjection import org.pushingpixels.aurora.demo.svg.flags.il import org.pushingpixels.aurora.demo.svg.flags.us -import org.pushingpixels.aurora.demo.svg.tango.preferences_desktop_locale_2 +import org.pushingpixels.aurora.demo.svg.tango.preferences_desktop_locale import org.pushingpixels.aurora.window.AuroraLocaleScope import java.awt.ComponentOrientation import java.awt.Window @@ -58,7 +58,7 @@ fun AuroraLocaleScope.AuroraLocaleSwitcher( ) val localeCommand = Command( text = resourceBundle.getString("Language.select"), - icon = preferences_desktop_locale_2(), + icon = preferences_desktop_locale(), secondaryContentModel = CommandMenuContentModel( group = CommandGroup( commands = arrayListOf(englishLocale, hebrewLocale) diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/ribbon/AuroraRibbonDemo.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/ribbon/AuroraRibbonDemo.kt index 40e64cfc..4c57df5c 100644 --- a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/ribbon/AuroraRibbonDemo.kt +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/ribbon/AuroraRibbonDemo.kt @@ -25,6 +25,7 @@ import androidx.compose.ui.window.WindowPosition import androidx.compose.ui.window.rememberWindowState import org.pushingpixels.aurora.component.model.* import org.pushingpixels.aurora.component.ribbon.* +import org.pushingpixels.aurora.component.ribbon.resize.CoreRibbonResizePolicies import org.pushingpixels.aurora.component.ribbon.resize.CoreRibbonResizeSequencingPolicies import org.pushingpixels.aurora.demo.ColorAuroraIcon import org.pushingpixels.aurora.demo.getQuickStylesContentModel @@ -47,9 +48,11 @@ fun main() = auroraApplication { val builder = RibbonBuilder(resourceBundle) val clipboardBand = builder.getClipboardBand() + val quickStylesBand = builder.getQuickStylesBand() + val pageLayoutTask = RibbonTask( title = resourceBundle.getString("PageLayout.textTaskTitle"), - bands = listOf(clipboardBand), + bands = listOf(clipboardBand, quickStylesBand), resizeSequencingPolicy = CoreRibbonResizeSequencingPolicies.RoundRobin(), keyTip = "P" ) @@ -134,6 +137,53 @@ private class RibbonBuilder(val resourceBundle: ResourceBundle) { action = { println("Apply Styles activated") } ) + var mfButtonText = MessageFormat( + resourceBundle.getString("StylesGallery.textButton") + ) + val stylesGalleryCommandList = CommandGroup( + title = resourceBundle.getString("StylesGallery.textGroupTitle1"), + commands = (0..10).map { + Command( + text = mfButtonText.format(arrayOf(it)), + icon = font_x_generic(), + isActionToggle = true + ) + } + ) + val stylesGalleryCommandList2 = CommandGroup( + title = resourceBundle.getString("StylesGallery.textGroupTitle1"), + commands = (11..30).map { + Command( + text = mfButtonText.format(arrayOf(it)), + icon = font_x_generic(), + isActionToggle = true + ) + } + ) + + val styleGalleryContentModel = RibbonGalleryContentModel( + icon = font_x_generic(), + commandGroups = listOf(stylesGalleryCommandList, stylesGalleryCommandList2), + selectedCommand = stylesGalleryCommandList.commands[1], + extraPopupGroups = listOf( + CommandGroup(commands = listOf(this.menuSaveSelection, this.menuClearSelection)), + CommandGroup(commands = listOf(this.applyStyles)) + ), + commandAction = { + val text = it?.text ?: "[null]" + println("Command '$text' activated!") + }, + commandActionPreview = object: CommandActionPreview { + override fun onCommandPreviewActivated(command: Command) { + println("Preview activated for '${command.text}'") + } + + override fun onCommandPreviewCanceled(command: Command) { + println("Preview canceled for '${command.text}'") + } + } + ) + fun getSimpleMenuModel(): CommandMenuContentModel { return CommandMenuContentModel( groups = listOf( @@ -238,6 +288,56 @@ private class RibbonBuilder(val resourceBundle: ResourceBundle) { ) ) } + + fun getQuickStylesBand(): RibbonBand { + return RibbonBand( + title = resourceBundle.getString("QuickStyles.textBandTitle"), + icon = preferences_desktop_theme(), + collapsedStateKeyTip = "ZS", + resizePolicies = CoreRibbonResizePolicies.getCorePoliciesRestrictive(), + commandProjections = listOf( + RibbonCommandButtonProjection( + contentModel = Command( + text = resourceBundle.getString("Styles1.text"), + icon = font_x_generic(), + action = { println("Generic activated") } + ), + presentationModel = RibbonCommandButtonPresentationModel( + presentationPriority = PresentationPriority.Medium, + actionKeyTip = "SA" + ) + ), + RibbonCommandButtonProjection( + contentModel = Command( + text = resourceBundle.getString("Styles2.text"), + icon = image_x_generic(), + action = { println("Image activated") } + ), + presentationModel = RibbonCommandButtonPresentationModel( + presentationPriority = PresentationPriority.Medium, + actionKeyTip = "SB" + ) + ) + ), + galleryProjections = listOf( + RibbonGalleryProjection( + contentModel = styleGalleryContentModel, + presentationModel = RibbonGalleryPresentationModel( + preferredVisibleCommandCounts = mapOf( + PresentationPriority.Low to 1, + PresentationPriority.Medium to 2, + PresentationPriority.Top to 2 + ), + popupLayoutSpec = MenuPopupPanelLayoutSpec( + columnCount = 3, visibleRowCount = 3 + ), + commandButtonPresentationState = RibbonBandCommandButtonPresentationStates.BigFixedLandscape, + expandKeyTip = "L" + ) + ) + ) + ) + } } diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/image-x-generic.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/image-x-generic.svg new file mode 100644 index 00000000..361d273c --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/image-x-generic.svg @@ -0,0 +1,521 @@ + + + + + + image/svg+xml + + + + + + + + Genric Image + + + Jakub Steiner + + + + imagepicturesnapshotphoto + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/image_x_generic.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/image_x_generic.kt new file mode 100644 index 00000000..a5865227 --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/image_x_generic.kt @@ -0,0 +1,704 @@ +package org.pushingpixels.aurora.demo.svg.tango + +import androidx.compose.ui.geometry.* +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Fill +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.clipRect +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.graphics.drawscope.withTransform +import androidx.compose.ui.graphics.painter.Painter +import java.lang.ref.WeakReference +import java.util.* +import kotlin.math.min + +/** + * This class has been automatically generated using + * Aurora SVG transcoder. + */ +class image_x_generic : Painter() { + @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null + @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null + @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null + @Suppress("UNUSED_VARIABLE") private var stroke: Stroke? = null + @Suppress("UNUSED_VARIABLE") private var clip: Shape? = null + private var alpha = 1.0f + private var blendMode = DrawScope.DefaultBlendMode + private var alphaStack = mutableListOf(1.0f) + private var blendModeStack = mutableListOf(DrawScope.DefaultBlendMode) + + @Suppress("UNUSED_VARIABLE", "UNUSED_VALUE", "VARIABLE_WITH_REDUNDANT_INITIALIZER", "UNNECESSARY_NOT_NULL_ASSERTION") +private fun _paint0(drawScope : DrawScope) { +var shapeText: Outline? +var generalPathText: Path? = null +var alphaText = 0.0f +var blendModeText = DrawScope.DefaultBlendMode +with(drawScope) { +// +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0 +alphaStack.add(0, alpha) +alpha *= 0.5276382f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-1.3864840269088745f, -2.9843900203704834f, 0.0f, 1.0f) +))}){ +// _0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(46.315495f, 41.63604f) + cubicTo(46.350906f, 43.092964f, 42.146984f, 44.442017f, 35.295578f, 45.172367f) + cubicTo(28.444166f, 45.902714f, 19.992647f, 45.902714f, 13.141237f, 45.172367f) + cubicTo(6.289828f, 44.442017f, 2.085908f, 43.092964f, 2.1213188f, 41.63604f) + cubicTo(2.085908f, 40.179115f, 6.289828f, 38.830063f, 13.141237f, 38.099712f) + cubicTo(19.992647f, 37.369366f, 28.444166f, 37.369366f, 35.295578f, 38.099712f) + cubicTo(42.146984f, 38.830063f, 46.350906f, 40.179115f, 46.315495f, 41.63604f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(24.218407f, 41.63604f), radius = 22.097088f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(2.7177715f, 6.454775f) + lineTo(43.379543f, 6.454775f) + cubicTo(44.002792f, 6.454775f, 44.504543f, 6.956525f, 44.504543f, 7.5797744f) + lineTo(44.504543f, 31.480581f) + cubicTo(44.504543f, 32.103832f, 36.04784f, 39.49987f, 35.424595f, 39.49987f) + lineTo(2.7177715f, 39.49987f) + cubicTo(2.094522f, 39.49987f, 1.5927727f, 38.998123f, 1.5927727f, 38.37487f) + lineTo(1.5927727f, 7.5797744f) + cubicTo(1.5927727f, 6.956525f, 2.094522f, 6.454775f, 2.7177715f, 6.454775f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(210, 210, 210, 255), 1.0f to Color(237, 237, 237, 255), start = Offset(70.2285f, 6.5338235f), end = Offset(96.89235f, 38.514523f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(187, 191, 187, 255)) +stroke = Stroke(width=0.99999994f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(2.7177715f, 6.454775f) + lineTo(43.379543f, 6.454775f) + cubicTo(44.002792f, 6.454775f, 44.504543f, 6.956525f, 44.504543f, 7.5797744f) + lineTo(44.504543f, 31.480581f) + cubicTo(44.504543f, 32.103832f, 36.04784f, 39.49987f, 35.424595f, 39.49987f) + lineTo(2.7177715f, 39.49987f) + cubicTo(2.094522f, 39.49987f, 1.5927727f, 38.998123f, 1.5927727f, 38.37487f) + lineTo(1.5927727f, 7.5797744f) + cubicTo(1.5927727f, 6.956525f, 2.094522f, 6.454775f, 2.7177715f, 6.454775f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0547740459442139f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0499889850616455f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-0.8146470189094543f, 4.485012054443359f, 0.0f, 1.0f) +))}){ +// _0_2 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(5.512695f, 30.0f) + lineTo(39.643234f, 30.0f) + lineTo(39.643234f, 19.627375f) + lineTo(5.512695f, 19.627375f) + lineTo(5.512695f, 30.0f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(133, 149, 188, 255), 1.0f to Color(4, 26, 59, 255), start = Offset(22.149822f, 17.67732f), end = Offset(22.149822f, 31.652668f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(5.512695f, 5.237844f) + lineTo(39.643234f, 5.237844f) + lineTo(39.643234f, 19.627375f) + lineTo(5.512695f, 19.627375f) + lineTo(5.512695f, 5.237844f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(208, 214, 229, 255), 1.0f to Color(9, 58, 128, 255), start = Offset(22.149822f, 22.332615f), end = Offset(22.149822f, 2.945166f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.1892169713974f, 0.0f, 0.0f, 0.0f, +0.0f, 1.1892169713974f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-3.525355100631714f, -6.535408020019531f, 0.0f, 1.0f) +))}){ +// _0_2_2 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_2_0 +alphaStack.add(0, alpha) +alpha *= 0.04999994f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_2_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(18.4f, 15.4f) + cubicTo(18.4f, 17.6f, 16.6f, 19.5f, 14.3f, 19.5f) + cubicTo(12.1f, 19.5f, 10.2f, 17.7f, 10.2f, 15.4f) + cubicTo(10.2f, 13.2f, 12.0f, 11.3f, 14.3f, 11.3f) + cubicTo(16.5f, 11.3f, 18.4f, 13.1f, 18.4f, 15.4f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(232, 245, 47, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.20829993f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_2_0_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(18.0f, 15.4f) + cubicTo(18.0f, 17.4f, 16.4f, 19.1f, 14.3f, 19.1f) + cubicTo(12.3f, 19.1f, 10.6f, 17.5f, 10.6f, 15.4f) + cubicTo(10.6f, 13.4f, 12.2f, 11.7f, 14.3f, 11.7f) + cubicTo(16.3f, 11.7f, 18.0f, 13.3f, 18.0f, 15.4f) + lineTo(18.0f, 15.4f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(236, 247, 81, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.36669993f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_2_0_2 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.6f, 15.4f) + cubicTo(17.6f, 17.2f, 16.1f, 18.7f, 14.3f, 18.7f) + cubicTo(12.5f, 18.7f, 11.0f, 17.2f, 11.0f, 15.4f) + cubicTo(11.0f, 13.6f, 12.5f, 12.1f, 14.3f, 12.1f) + cubicTo(16.1f, 12.1f, 17.6f, 13.6f, 17.6f, 15.4f) + lineTo(17.6f, 15.4f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(240, 249, 114, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.525f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_2_0_3 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.2f, 15.4f) + cubicTo(17.2f, 17.0f, 15.9f, 18.3f, 14.3f, 18.3f) + cubicTo(12.7f, 18.3f, 11.4f, 17.0f, 11.4f, 15.4f) + cubicTo(11.4f, 13.8f, 12.7f, 12.5f, 14.3f, 12.5f) + cubicTo(15.9f, 12.5f, 17.2f, 13.8f, 17.2f, 15.4f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(244, 250, 149, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.6833f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_2_0_4 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(16.8f, 15.4f) + cubicTo(16.8f, 16.8f, 15.7f, 17.9f, 14.3f, 17.9f) + cubicTo(12.9f, 17.9f, 11.8f, 16.8f, 11.8f, 15.4f) + cubicTo(11.8f, 14.0f, 12.9f, 12.9f, 14.3f, 12.9f) + cubicTo(15.7f, 12.9f, 16.8f, 14.0f, 16.8f, 15.4f) + lineTo(16.8f, 15.4f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(247, 252, 183, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.8417f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_2_0_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(16.4f, 15.4f) + cubicTo(16.4f, 16.6f, 15.4f, 17.5f, 14.3f, 17.5f) + cubicTo(13.2f, 17.5f, 12.2f, 16.5f, 12.2f, 15.4f) + cubicTo(12.2f, 14.3f, 13.2f, 13.3f, 14.3f, 13.3f) + cubicTo(15.4f, 13.3f, 16.4f, 14.3f, 16.4f, 15.4f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(251, 253, 219, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_2_0_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(16.0f, 15.4f) + cubicTo(16.0f, 16.4f, 15.2f, 17.2f, 14.2f, 17.2f) + cubicTo(13.2f, 17.2f, 12.4f, 16.4f, 12.4f, 15.4f) + cubicTo(12.4f, 14.4f, 13.2f, 13.6f, 14.2f, 13.6f) + cubicTo(15.2f, 13.6f, 16.0f, 14.4f, 16.0f, 15.4f) + lineTo(16.0f, 15.4f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.3f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_3 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(25.01586f, 21.649044f) + lineTo(33.697147f, 21.649044f) + lineTo(35.362053f, 22.124731f) + lineTo(32.50793f, 22.124731f) + cubicTo(32.50793f, 22.124731f, 35.362053f, 22.362574f, 36.789116f, 24.1464f) + cubicTo(38.216175f, 25.811304f, 35.12421f, 27.832975f, 35.12421f, 27.832975f) + cubicTo(35.12421f, 27.832975f, 35.12421f, 27.832975f, 35.12421f, 27.832975f) + cubicTo(35.005287f, 27.47621f, 34.291756f, 24.622087f, 32.864697f, 23.43287f) + cubicTo(31.7944f, 22.481497f, 30.605183f, 22.243652f, 30.605183f, 22.243652f) + lineTo(25.01586f, 22.243652f) + lineTo(25.01586f, 21.767965f) + lineTo(25.01586f, 21.649044f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(0, 0, 0, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.3f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_4 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(30.724106f, 22.362574f) + lineTo(25.729391f, 22.362574f) + lineTo(35.005287f, 27.59513f) + lineTo(30.724106f, 22.362574f) + lineTo(30.724106f, 22.362574f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(0, 0, 0, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(25.01586f, 21.767965f) + lineTo(33.697147f, 21.767965f) + lineTo(35.005287f, 20.935513f) + lineTo(32.15117f, 20.935513f) + cubicTo(32.15117f, 20.935513f, 34.767445f, 20.459827f, 35.12421f, 17.486782f) + cubicTo(35.480972f, 14.513739f, 31.08087f, 11.183931f, 31.08087f, 11.183931f) + cubicTo(31.08087f, 11.183931f, 31.08087f, 11.183931f, 31.08087f, 11.302853f) + cubicTo(31.19979f, 12.016383f, 32.389008f, 17.011095f, 31.556557f, 18.913845f) + cubicTo(31.19979f, 20.578747f, 30.129496f, 20.935513f, 30.129496f, 20.935513f) + lineTo(24.659094f, 20.935513f) + lineTo(24.896938f, 21.767965f) + lineTo(25.01586f, 21.767965f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(81, 81, 81, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_2_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(30.248419f, 20.459827f) + lineTo(25.253704f, 20.459827f) + lineTo(31.19979f, 11.421773f) + lineTo(30.248419f, 20.459827f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(81, 81, 81, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_3 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=0.99999976f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(2.8042316f, 7.4528584f) + lineTo(43.233986f, 7.4528584f) + cubicTo(43.384365f, 7.4528584f, 43.505432f, 7.5739236f, 43.505432f, 7.7243047f) + lineTo(43.505432f, 31.422651f) + cubicTo(43.505432f, 32.368526f, 36.401688f, 38.5f, 36.251305f, 38.5f) + lineTo(2.8042316f, 38.5f) + cubicTo(2.6538508f, 38.5f, 2.532786f, 38.378937f, 2.532786f, 38.228554f) + lineTo(2.532786f, 7.7243047f) + cubicTo(2.532786f, 7.5739236f, 2.6538508f, 7.4528584f, 2.8042316f, 7.4528584f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.84659094f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_4 +brush = SolidColor(Color(79, 79, 79, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rectangle(rect = Rect(left = 5.5f, top = 10.5f, right = 40.5625f, bottom = 35.5625f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(35.206654f, 39.46876f) + cubicTo(37.23707f, 39.79866f, 44.795444f, 34.938835f, 44.491062f, 30.970919f) + cubicTo(42.9278f, 33.394016f, 39.73254f, 32.257656f, 35.623783f, 32.416668f) + cubicTo(35.623783f, 32.416668f, 36.019154f, 38.96876f, 35.206654f, 39.46876f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(124, 124, 124, 255), 1.0f to Color(184, 184, 184, 255), start = Offset(41.144154f, 37.42343f), end = Offset(38.812492f, 34.73593f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = Brush.linearGradient(0.0f to Color(187, 189, 186, 255), 1.0f to Color(112, 116, 110, 255), start = Offset(42.1875f, 31.0f), end = Offset(45.0f, 39.98469f), tileMode = TileMode.Clamp) +stroke = Stroke(width=1.0000002f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(35.206654f, 39.46876f) + cubicTo(37.23707f, 39.79866f, 44.795444f, 34.938835f, 44.491062f, 30.970919f) + cubicTo(42.9278f, 33.394016f, 39.73254f, 32.257656f, 35.623783f, 32.416668f) + cubicTo(35.623783f, 32.416668f, 36.019154f, 38.96876f, 35.206654f, 39.46876f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.36931816f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_6 +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(38.543575f, 33.511543f), end = Offset(39.31762f, 34.66059f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.9999998f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(36.65709f, 37.27726f) + cubicTo(38.026867f, 36.593433f, 41.08534f, 35.130795f, 42.38472f, 33.24979f) + cubicTo(40.788624f, 33.929848f, 39.43691f, 33.45929f, 36.682384f, 33.440197f) + cubicTo(36.682384f, 33.440197f, 36.844707f, 36.502293f, 36.65709f, 37.27726f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.30113637f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_7 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(3.0625f, 8.0f) + lineTo(3.0625f, 30.0625f) + cubicTo(25.388578f, 30.950861f, 27.884634f, 17.0f, 43.0f, 17.0f) + lineTo(43.0f, 8.0f) + lineTo(3.0625f, 8.0f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), center = Offset(10.156253f, 13.506495f), radius = 34.15717f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) + +} +} + + + + private fun innerPaint(drawScope: DrawScope) { + _paint0(drawScope) + + + shape = null + generalPath = null + brush = null + stroke = null + clip = null + alpha = 1.0f + } + + companion object { + /** + * Returns the X of the bounding box of the original SVG image. + * + * @return The X of the bounding box of the original SVG image. + */ + fun getOrigX(): Double { + return 0.6994239091873169 + } + + /** + * Returns the Y of the bounding box of the original SVG image. + * + * @return The Y of the bounding box of the original SVG image. + */ + fun getOrigY(): Double { + return 5.954774856567383 + } + + /** + * Returns the width of the bounding box of the original SVG image. + * + * @return The width of the bounding box of the original SVG image. + */ + fun getOrigWidth(): Double { + return 44.3132209777832 + } + + /** + * Returns the height of the bounding box of the original SVG image. + * + * @return The height of the bounding box of the original SVG image. + */ + fun getOrigHeight(): Double { + return 36.96355056762695 + } + + + } + + override val intrinsicSize: Size + get() = Size.Unspecified + + override fun DrawScope.onDraw() { + clipRect { + // Use the original icon bounding box and the current icon dimension to compute + // the scaling factor + val fullOrigWidth = getOrigX() + getOrigWidth() + val fullOrigHeight = getOrigY() + getOrigHeight() + val coef1 = size.width / fullOrigWidth + val coef2 = size.height / fullOrigHeight + val coef = min(coef1, coef2).toFloat() + + // Use the original icon bounding box and the current icon dimension to compute + // the offset pivot for the scaling + var translateX = -getOrigX() + var translateY = -getOrigY() + if (coef1 != coef2) { + if (coef1 < coef2) { + val extraDy = ((fullOrigWidth - fullOrigHeight) / 2.0f).toFloat() + translateY += extraDy + } else { + val extraDx = ((fullOrigHeight - fullOrigWidth) / 2.0f).toFloat() + translateX += extraDx + } + } + val translateXDp = translateX.toFloat().toDp().value + val translateYDp = translateY.toFloat().toDp().value + + // Create a combined scale + translate + clip transform before calling the transcoded painting instructions + withTransform({ + scale(scaleX = coef, scaleY = coef, pivot = Offset.Zero) + translate(translateXDp, translateYDp) + clipRect(left = 0.0f, top = 0.0f, right = fullOrigWidth.toFloat(), bottom = fullOrigHeight.toFloat(), clipOp = ClipOp.Intersect) + }) { + innerPaint(this) + } + } + } +} + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-accessibility.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-accessibility.svg new file mode 100644 index 00000000..9a7b47b7 --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-accessibility.svg @@ -0,0 +1,196 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + Jakub Steiner + + + http://jimmac.musichall.cz + + Accessibility + + + accessibility + assist + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-assistive-technology.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-assistive-technology.svg new file mode 100644 index 00000000..7a9176f0 --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-assistive-technology.svg @@ -0,0 +1,296 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + Jakub Steiner + + + http://jimmac.musichall.cz + + Assistive Technology + + + accessibility + assist + assistive technology + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-font.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-font.svg new file mode 100644 index 00000000..3b568183 --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-font.svg @@ -0,0 +1,171 @@ + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + Jakub Steiner + + + http://jimmac.musichall.cz + + Wi-Fi network + + + + + + + + + + + + + + + + + + + + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-keyboard-shortcuts.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-keyboard-shortcuts.svg new file mode 100644 index 00000000..78593b11 --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-keyboard-shortcuts.svg @@ -0,0 +1,836 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + Jakub Steiner + + + http://jimmac.musichall.cz + + Character Map + + + key + map + character + accessory + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-locale-2.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-locale-2.svg deleted file mode 100644 index 10f89069..00000000 --- a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-locale-2.svg +++ /dev/null @@ -1,876 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - image/svg+xml - - - - Jakub Steiner - - - http://jimmac.musichall.cz - - Locale Preferences - - - locale preferences - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-locale.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-locale.svg new file mode 100644 index 00000000..2a50ccca --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-locale.svg @@ -0,0 +1,387 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-screensaver.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-screensaver.svg new file mode 100644 index 00000000..80b1538d --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-screensaver.svg @@ -0,0 +1,715 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + Screensacer + + + + Jakub Steiner + + + + + video + display + screensaver + saver + + + + http://jimmac.musichall.cz/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-theme.svg b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-theme.svg new file mode 100644 index 00000000..18402941 --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences-desktop-theme.svg @@ -0,0 +1,798 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + Jakub Steiner + + + http://jimmac.musichall.cz + + Themes + + + skin + color + theme + customize + flavor + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_accessibility.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_accessibility.kt new file mode 100644 index 00000000..02402688 --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_accessibility.kt @@ -0,0 +1,346 @@ +package org.pushingpixels.aurora.demo.svg.tango + +import androidx.compose.ui.geometry.* +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Fill +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.clipRect +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.graphics.drawscope.withTransform +import androidx.compose.ui.graphics.painter.Painter +import java.lang.ref.WeakReference +import java.util.* +import kotlin.math.min + +/** + * This class has been automatically generated using + * Aurora SVG transcoder. + */ +class preferences_desktop_accessibility : Painter() { + @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null + @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null + @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null + @Suppress("UNUSED_VARIABLE") private var stroke: Stroke? = null + @Suppress("UNUSED_VARIABLE") private var clip: Shape? = null + private var alpha = 1.0f + private var blendMode = DrawScope.DefaultBlendMode + private var alphaStack = mutableListOf(1.0f) + private var blendModeStack = mutableListOf(DrawScope.DefaultBlendMode) + + @Suppress("UNUSED_VARIABLE", "UNUSED_VALUE", "VARIABLE_WITH_REDUNDANT_INITIALIZER", "UNNECESSARY_NOT_NULL_ASSERTION") +private fun _paint0(drawScope : DrawScope) { +var shapeText: Outline? +var generalPathText: Path? = null +var alphaText = 0.0f +var blendModeText = DrawScope.DefaultBlendMode +with(drawScope) { +// +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0 +alphaStack.add(0, alpha) +alpha *= 0.4064171f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +2.4600489139556885f, 0.0f, 0.0f, 0.0f, +0.0f, 2.4600489139556885f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-49.40945816040039f, -67.96373748779297f, 0.0f, 1.0f) +))}){ +// _0_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(36.769554f, 44.565483f) + cubicTo(36.780075f, 45.361816f, 35.53091f, 46.099186f, 33.495064f, 46.498383f) + cubicTo(31.459217f, 46.89758f, 28.947906f, 46.89758f, 26.91206f, 46.498383f) + cubicTo(24.876213f, 46.099186f, 23.627047f, 45.361816f, 23.63757f, 44.565483f) + cubicTo(23.627047f, 43.76915f, 24.876213f, 43.03178f, 26.91206f, 42.632584f) + cubicTo(28.947906f, 42.233387f, 31.459217f, 42.233387f, 33.495064f, 42.632584f) + cubicTo(35.53091f, 43.03178f, 36.780075f, 43.76915f, 36.769554f, 44.565483f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(30.203562f, 44.565502f), radius = 6.5659924f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_1 +shape = Outline.Rounded(roundRect = RoundRect(left = 4.414728164672852f, top = 3.5233452320098877f, right = 44.47665214538574f, bottom = 43.58526921272278f,radiusX = 10.909647941589355f, radiusY = 10.909647941589355f)) +brush = Brush.radialGradient(0.0f to Color(156, 188, 222, 255), 1.0f to Color(32, 74, 135, 255), center = Offset(25.159983f, 35.84003f), radius = 43.693687f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(52, 101, 164, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Bevel, miter=10.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 4.414728164672852f, top = 3.5233452320098877f, right = 44.47665214538574f, bottom = 43.58526921272278f,radiusX = 10.909647941589355f, radiusY = 10.909647941589355f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=2.0000021f, cap=StrokeCap.Butt, join=StrokeJoin.Bevel, miter=10.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 5.8954033851623535f, top = 5.004019737243652f, right = 42.99603891372681f, bottom = 42.104655265808105f,radiusX = 7.81350040435791f, radiusY = 7.81350040435791f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +1.5521910190582275f, -0.6401000022888184f, 0.0f, 1.0f) +))}){ +// _0_0_3 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.7692310214042664f, 0.0f, 0.0f, 0.0f, +0.0f, 0.7692310214042664f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +6.846158027648926f, 4.576913833618164f, 0.0f, 1.0f) +))}){ +// _0_0_3_0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.444443941116333f, 0.0f, 0.0f, 0.0f, +0.0f, 1.444443941116333f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-7.841267108917236f, -5.8095221519470215f, 0.0f, 1.0f) +))}){ +// _0_0_3_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.857141f, 13.071428f) + cubicTo(20.862293f, 14.2232065f, 20.250782f, 15.289703f, 19.254162f, 15.8670845f) + cubicTo(18.257544f, 16.444466f, 17.02817f, 16.444466f, 16.03155f, 15.8670845f) + cubicTo(15.03493f, 15.289703f, 14.42342f, 14.2232065f, 14.428571f, 13.071428f) + cubicTo(14.42342f, 11.91965f, 15.03493f, 10.853153f, 16.03155f, 10.275772f) + cubicTo(17.02817f, 9.698391f, 18.257544f, 9.698391f, 19.254162f, 10.275772f) + cubicTo(20.250782f, 10.853153f, 20.862293f, 11.91965f, 20.857141f, 13.071428f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_0_1 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=2.5f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.571428f, 13.142857f) + lineTo(20.0f, 30.0f) + lineTo(32.0f, 27.428572f) + lineTo(34.42857f, 37.0f) + lineTo(38.0f, 36.0f) +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.374998f, 21.668259f) + cubicTo(14.821727f, 23.078575f, 13.0f, 25.694616f, 13.0f, 28.80768f) + cubicTo(13.0f, 33.36178f, 16.715132f, 37.076912f, 21.26923f, 37.076912f) + cubicTo(25.584839f, 37.076912f, 29.03297f, 33.705624f, 29.39423f, 29.480759f) + lineTo(27.399036f, 29.937489f) + cubicTo(26.85153f, 32.888084f, 24.382202f, 35.153835f, 21.26923f, 35.153835f) + cubicTo(17.755636f, 35.153835f, 14.923077f, 32.321274f, 14.923077f, 28.80768f) + cubicTo(14.923077f, 26.611685f, 16.12003f, 24.778076f, 17.807692f, 23.639412f) + lineTo(17.374998f, 21.668259f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_4 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=1.9230775f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(22.857143f, 20.857143f) + lineTo(31.714287f, 20.0f) +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) + +} +} + + + + private fun innerPaint(drawScope: DrawScope) { + _paint0(drawScope) + + + shape = null + generalPath = null + brush = null + stroke = null + clip = null + alpha = 1.0f + } + + companion object { + /** + * Returns the X of the bounding box of the original SVG image. + * + * @return The X of the bounding box of the original SVG image. + */ + fun getOrigX(): Double { + return 3.9147281646728516 + } + + /** + * Returns the Y of the bounding box of the original SVG image. + * + * @return The Y of the bounding box of the original SVG image. + */ + fun getOrigY(): Double { + return 3.0233452320098877 + } + + /** + * Returns the width of the bounding box of the original SVG image. + * + * @return The width of the bounding box of the original SVG image. + */ + fun getOrigWidth(): Double { + return 41.06192398071289 + } + + /** + * Returns the height of the bounding box of the original SVG image. + * + * @return The height of the bounding box of the original SVG image. + */ + fun getOrigHeight(): Double { + return 44.38325500488281 + } + + + } + + override val intrinsicSize: Size + get() = Size.Unspecified + + override fun DrawScope.onDraw() { + clipRect { + // Use the original icon bounding box and the current icon dimension to compute + // the scaling factor + val fullOrigWidth = getOrigX() + getOrigWidth() + val fullOrigHeight = getOrigY() + getOrigHeight() + val coef1 = size.width / fullOrigWidth + val coef2 = size.height / fullOrigHeight + val coef = min(coef1, coef2).toFloat() + + // Use the original icon bounding box and the current icon dimension to compute + // the offset pivot for the scaling + var translateX = -getOrigX() + var translateY = -getOrigY() + if (coef1 != coef2) { + if (coef1 < coef2) { + val extraDy = ((fullOrigWidth - fullOrigHeight) / 2.0f).toFloat() + translateY += extraDy + } else { + val extraDx = ((fullOrigHeight - fullOrigWidth) / 2.0f).toFloat() + translateX += extraDx + } + } + val translateXDp = translateX.toFloat().toDp().value + val translateYDp = translateY.toFloat().toDp().value + + // Create a combined scale + translate + clip transform before calling the transcoded painting instructions + withTransform({ + scale(scaleX = coef, scaleY = coef, pivot = Offset.Zero) + translate(translateXDp, translateYDp) + clipRect(left = 0.0f, top = 0.0f, right = fullOrigWidth.toFloat(), bottom = fullOrigHeight.toFloat(), clipOp = ClipOp.Intersect) + }) { + innerPaint(this) + } + } + } +} + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_assistive_technology.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_assistive_technology.kt new file mode 100644 index 00000000..697c0270 --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_assistive_technology.kt @@ -0,0 +1,611 @@ +package org.pushingpixels.aurora.demo.svg.tango + +import androidx.compose.ui.geometry.* +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Fill +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.clipRect +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.graphics.drawscope.withTransform +import androidx.compose.ui.graphics.painter.Painter +import java.lang.ref.WeakReference +import java.util.* +import kotlin.math.min + +/** + * This class has been automatically generated using + * Aurora SVG transcoder. + */ +class preferences_desktop_assistive_technology : Painter() { + @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null + @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null + @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null + @Suppress("UNUSED_VARIABLE") private var stroke: Stroke? = null + @Suppress("UNUSED_VARIABLE") private var clip: Shape? = null + private var alpha = 1.0f + private var blendMode = DrawScope.DefaultBlendMode + private var alphaStack = mutableListOf(1.0f) + private var blendModeStack = mutableListOf(DrawScope.DefaultBlendMode) + + @Suppress("UNUSED_VARIABLE", "UNUSED_VALUE", "VARIABLE_WITH_REDUNDANT_INITIALIZER", "UNNECESSARY_NOT_NULL_ASSERTION") +private fun _paint0(drawScope : DrawScope) { +var shapeText: Outline? +var generalPathText: Path? = null +var alphaText = 0.0f +var blendModeText = DrawScope.DefaultBlendMode +with(drawScope) { +// +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0 +alphaStack.add(0, alpha) +alpha *= 0.4064171f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +2.4600489139556885f, 0.0f, 0.0f, 0.0f, +0.0f, 2.4600489139556885f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-49.40945816040039f, -67.96373748779297f, 0.0f, 1.0f) +))}){ +// _0_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(36.769554f, 44.565483f) + cubicTo(36.780075f, 45.361816f, 35.53091f, 46.099186f, 33.495064f, 46.498383f) + cubicTo(31.459217f, 46.89758f, 28.947906f, 46.89758f, 26.91206f, 46.498383f) + cubicTo(24.876213f, 46.099186f, 23.627047f, 45.361816f, 23.63757f, 44.565483f) + cubicTo(23.627047f, 43.76915f, 24.876213f, 43.03178f, 26.91206f, 42.632584f) + cubicTo(28.947906f, 42.233387f, 31.459217f, 42.233387f, 33.495064f, 42.632584f) + cubicTo(35.53091f, 43.03178f, 36.780075f, 43.76915f, 36.769554f, 44.565483f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(30.203562f, 44.565502f), radius = 6.5659924f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_1 +shape = Outline.Rounded(roundRect = RoundRect(left = 4.414728164672852f, top = 3.5233452320098877f, right = 44.47665214538574f, bottom = 43.58526921272278f,radiusX = 10.909647941589355f, radiusY = 10.909647941589355f)) +brush = Brush.radialGradient(0.0f to Color(156, 188, 222, 255), 1.0f to Color(32, 74, 135, 255), center = Offset(25.159983f, 35.84003f), radius = 43.693687f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(52, 101, 164, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Bevel, miter=10.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 4.414728164672852f, top = 3.5233452320098877f, right = 44.47665214538574f, bottom = 43.58526921272278f,radiusX = 10.909647941589355f, radiusY = 10.909647941589355f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=2.0000021f, cap=StrokeCap.Butt, join=StrokeJoin.Bevel, miter=10.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 5.8954033851623535f, top = 5.004019737243652f, right = 42.99603891372681f, bottom = 42.104655265808105f,radiusX = 7.81350040435791f, radiusY = 7.81350040435791f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +1.5521910190582275f, -0.6401000022888184f, 0.0f, 1.0f) +))}){ +// _0_0_3 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.7692310214042664f, 0.0f, 0.0f, 0.0f, +0.0f, 0.7692310214042664f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +6.846158027648926f, 4.576913833618164f, 0.0f, 1.0f) +))}){ +// _0_0_3_0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.444443941116333f, 0.0f, 0.0f, 0.0f, +0.0f, 1.444443941116333f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-7.841267108917236f, -5.8095221519470215f, 0.0f, 1.0f) +))}){ +// _0_0_3_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.857141f, 13.071428f) + cubicTo(20.862293f, 14.2232065f, 20.250782f, 15.289703f, 19.254162f, 15.8670845f) + cubicTo(18.257544f, 16.444466f, 17.02817f, 16.444466f, 16.03155f, 15.8670845f) + cubicTo(15.03493f, 15.289703f, 14.42342f, 14.2232065f, 14.428571f, 13.071428f) + cubicTo(14.42342f, 11.91965f, 15.03493f, 10.853153f, 16.03155f, 10.275772f) + cubicTo(17.02817f, 9.698391f, 18.257544f, 9.698391f, 19.254162f, 10.275772f) + cubicTo(20.250782f, 10.853153f, 20.862293f, 11.91965f, 20.857141f, 13.071428f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_0_1 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=2.5f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.571428f, 13.142857f) + lineTo(20.0f, 30.0f) + lineTo(32.0f, 27.428572f) + lineTo(34.42857f, 37.0f) + lineTo(38.0f, 36.0f) +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.374998f, 21.668259f) + cubicTo(14.821727f, 23.078575f, 13.0f, 25.694616f, 13.0f, 28.80768f) + cubicTo(13.0f, 33.36178f, 16.715132f, 37.076912f, 21.26923f, 37.076912f) + cubicTo(25.584839f, 37.076912f, 29.03297f, 33.705624f, 29.39423f, 29.480759f) + lineTo(27.399036f, 29.937489f) + cubicTo(26.85153f, 32.888084f, 24.382202f, 35.153835f, 21.26923f, 35.153835f) + cubicTo(17.755636f, 35.153835f, 14.923077f, 32.321274f, 14.923077f, 28.80768f) + cubicTo(14.923077f, 26.611685f, 16.12003f, 24.778076f, 17.807692f, 23.639412f) + lineTo(17.374998f, 21.668259f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_4 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=1.9230775f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(22.857143f, 20.857143f) + lineTo(31.714287f, 20.0f) +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.6082140207290649f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6082140207290649f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +20.155799865722656f, 19.565080642700195f, 0.0f, 1.0f) +))}){ +// _0_0_5 +alphaStack.add(0, alpha) +alpha *= 0.40909088f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-0.8838850259780884f, 2.4748740196228027f, 0.0f, 1.0f) +))}){ +// _0_0_5_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(45.078056f, 39.161163f) + cubicTo(45.1095f, 41.378223f, 41.37642f, 43.431126f, 35.29237f, 44.542526f) + cubicTo(29.208319f, 45.65393f, 21.70337f, 45.65393f, 15.619318f, 44.542526f) + cubicTo(9.535267f, 43.431126f, 5.802187f, 41.378223f, 5.8336315f, 39.161163f) + cubicTo(5.802187f, 36.944103f, 9.535267f, 34.8912f, 15.619318f, 33.7798f) + cubicTo(21.70337f, 32.668396f, 29.208319f, 32.668396f, 35.29237f, 33.7798f) + cubicTo(41.37642f, 34.8912f, 45.1095f, 36.944103f, 45.078056f, 39.161163f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(25.455845f, 39.16115f), radius = 19.622211f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_5_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(23.25f, 0.46875f) + cubicTo(22.784561f, 0.5005963f, 22.332167f, 0.5726847f, 21.875f, 0.625f) + lineTo(21.84375f, 0.625f) + lineTo(20.75f, 6.59375f) + cubicTo(18.967276f, 6.99974f, 17.29009f, 7.6887417f, 15.78125f, 8.625f) + lineTo(10.875f, 5.09375f) + cubicTo(9.548712f, 6.1234407f, 8.341802f, 7.3243456f, 7.28125f, 8.625f) + lineTo(10.6875f, 13.59375f) + cubicTo(9.653267f, 15.174265f, 8.875532f, 16.978973f, 8.4375f, 18.875f) + cubicTo(8.437425f, 18.883963f, 8.437439f, 18.904688f, 8.4375f, 18.90625f) + lineTo(2.5f, 19.84375f) + cubicTo(2.3914466f, 20.730383f, 2.34375f, 21.646688f, 2.34375f, 22.5625f) + cubicTo(2.34375f, 23.3118f, 2.3644395f, 24.051088f, 2.4375f, 24.78125f) + lineTo(8.375f, 25.84375f) + cubicTo(8.797279f, 27.905642f, 9.599459f, 29.831263f, 10.71875f, 31.53125f) + lineTo(7.1875f, 36.375f) + cubicTo(8.198826f, 37.63052f, 9.366392f, 38.773617f, 10.625f, 39.78125f) + lineTo(15.625f, 36.34375f) + cubicTo(17.372433f, 37.458466f, 19.323084f, 38.240124f, 21.4375f, 38.625f) + lineTo(22.375f, 44.53125f) + cubicTo(23.041183f, 44.59189f, 23.724348f, 44.59375f, 24.40625f, 44.59375f) + cubicTo(25.368935f, 44.59375f, 26.288486f, 44.557266f, 27.21875f, 44.4375f) + lineTo(28.34375f, 38.40625f) + cubicTo(30.35131f, 37.90665f, 32.23722f, 37.03996f, 33.875f, 35.875f) + lineTo(38.6875f, 39.375f) + cubicTo(39.935528f, 38.3132f, 41.07678f, 37.092743f, 42.0625f, 35.78125f) + lineTo(38.5625f, 30.71875f) + cubicTo(39.510353f, 29.08176f, 40.16713f, 27.275608f, 40.5f, 25.34375f) + lineTo(46.40625f, 24.40625f) + cubicTo(46.458042f, 23.789904f, 46.46875f, 23.192163f, 46.46875f, 22.5625f) + cubicTo(46.46875f, 21.468287f, 46.341568f, 20.395416f, 46.1875f, 19.34375f) + lineTo(40.1875f, 18.25f) + cubicTo(39.717304f, 16.513777f, 38.945824f, 14.893898f, 37.96875f, 13.4375f) + lineTo(41.5f, 8.59375f) + cubicTo(40.405426f, 7.255143f, 39.156822f, 6.018569f, 37.78125f, 4.96875f) + lineTo(32.6875f, 8.46875f) + cubicTo(31.223503f, 7.602913f, 29.648037f, 6.938568f, 27.9375f, 6.5625f) + lineTo(27.0f, 0.625f) + cubicTo(26.146702f, 0.5246246f, 25.286379f, 0.46875f, 24.40625f, 0.46875f) + cubicTo(24.168379f, 0.46875f, 23.923567f, 0.4612654f, 23.6875f, 0.46875f) + cubicTo(23.572416f, 0.47239882f, 23.458534f, 0.4620551f, 23.34375f, 0.46875f) + cubicTo(23.312662f, 0.4705632f, 23.281029f, 0.4666269f, 23.25f, 0.46875f) + close() + moveTo(24.0625f, 15.65625f) + cubicTo(24.176666f, 15.650457f, 24.290651f, 15.65625f, 24.40625f, 15.65625f) + cubicTo(28.105377f, 15.65625f, 31.125f, 18.675875f, 31.125f, 22.375f) + cubicTo(31.125002f, 26.074125f, 28.105375f, 29.0625f, 24.40625f, 29.0625f) + cubicTo(20.707125f, 29.062502f, 17.71875f, 26.074125f, 17.71875f, 22.375f) + cubicTo(17.718752f, 18.791473f, 20.52335f, 15.835842f, 24.0625f, 15.65625f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(201, 201, 201, 255), 0.25f to Color(248, 248, 248, 255), 0.5f to Color(226, 226, 226, 255), 0.75f to Color(176, 176, 176, 255), 1.0f to Color(201, 201, 201, 255), start = Offset(12.9344635f, 8.047592f), end = Offset(37.861908f, 42.077095f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(128, 128, 128, 255)) +stroke = Stroke(width=1.6441573f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(23.25f, 0.46875f) + cubicTo(22.784561f, 0.5005963f, 22.332167f, 0.5726847f, 21.875f, 0.625f) + lineTo(21.84375f, 0.625f) + lineTo(20.75f, 6.59375f) + cubicTo(18.967276f, 6.99974f, 17.29009f, 7.6887417f, 15.78125f, 8.625f) + lineTo(10.875f, 5.09375f) + cubicTo(9.548712f, 6.1234407f, 8.341802f, 7.3243456f, 7.28125f, 8.625f) + lineTo(10.6875f, 13.59375f) + cubicTo(9.653267f, 15.174265f, 8.875532f, 16.978973f, 8.4375f, 18.875f) + cubicTo(8.437425f, 18.883963f, 8.437439f, 18.904688f, 8.4375f, 18.90625f) + lineTo(2.5f, 19.84375f) + cubicTo(2.3914466f, 20.730383f, 2.34375f, 21.646688f, 2.34375f, 22.5625f) + cubicTo(2.34375f, 23.3118f, 2.3644395f, 24.051088f, 2.4375f, 24.78125f) + lineTo(8.375f, 25.84375f) + cubicTo(8.797279f, 27.905642f, 9.599459f, 29.831263f, 10.71875f, 31.53125f) + lineTo(7.1875f, 36.375f) + cubicTo(8.198826f, 37.63052f, 9.366392f, 38.773617f, 10.625f, 39.78125f) + lineTo(15.625f, 36.34375f) + cubicTo(17.372433f, 37.458466f, 19.323084f, 38.240124f, 21.4375f, 38.625f) + lineTo(22.375f, 44.53125f) + cubicTo(23.041183f, 44.59189f, 23.724348f, 44.59375f, 24.40625f, 44.59375f) + cubicTo(25.368935f, 44.59375f, 26.288486f, 44.557266f, 27.21875f, 44.4375f) + lineTo(28.34375f, 38.40625f) + cubicTo(30.35131f, 37.90665f, 32.23722f, 37.03996f, 33.875f, 35.875f) + lineTo(38.6875f, 39.375f) + cubicTo(39.935528f, 38.3132f, 41.07678f, 37.092743f, 42.0625f, 35.78125f) + lineTo(38.5625f, 30.71875f) + cubicTo(39.510353f, 29.08176f, 40.16713f, 27.275608f, 40.5f, 25.34375f) + lineTo(46.40625f, 24.40625f) + cubicTo(46.458042f, 23.789904f, 46.46875f, 23.192163f, 46.46875f, 22.5625f) + cubicTo(46.46875f, 21.468287f, 46.341568f, 20.395416f, 46.1875f, 19.34375f) + lineTo(40.1875f, 18.25f) + cubicTo(39.717304f, 16.513777f, 38.945824f, 14.893898f, 37.96875f, 13.4375f) + lineTo(41.5f, 8.59375f) + cubicTo(40.405426f, 7.255143f, 39.156822f, 6.018569f, 37.78125f, 4.96875f) + lineTo(32.6875f, 8.46875f) + cubicTo(31.223503f, 7.602913f, 29.648037f, 6.938568f, 27.9375f, 6.5625f) + lineTo(27.0f, 0.625f) + cubicTo(26.146702f, 0.5246246f, 25.286379f, 0.46875f, 24.40625f, 0.46875f) + cubicTo(24.168379f, 0.46875f, 23.923567f, 0.4612654f, 23.6875f, 0.46875f) + cubicTo(23.572416f, 0.47239882f, 23.458534f, 0.4620551f, 23.34375f, 0.46875f) + cubicTo(23.312662f, 0.4705632f, 23.281029f, 0.4666269f, 23.25f, 0.46875f) + close() + moveTo(24.0625f, 15.65625f) + cubicTo(24.176666f, 15.650457f, 24.290651f, 15.65625f, 24.40625f, 15.65625f) + cubicTo(28.105377f, 15.65625f, 31.125f, 18.675875f, 31.125f, 22.375f) + cubicTo(31.125002f, 26.074125f, 28.105375f, 29.0625f, 24.40625f, 29.0625f) + cubicTo(20.707125f, 29.062502f, 17.71875f, 26.074125f, 17.71875f, 22.375f) + cubicTo(17.718752f, 18.791473f, 20.52335f, 15.835842f, 24.0625f, 15.65625f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.64772725f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.6684309840202332f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6684309840202332f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +8.69454574584961f, 6.464436054229736f, 0.0f, 1.0f) +))}){ +// _0_0_5_2 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=2.4597247f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(36.239223f, 23.781593f) + cubicTo(36.25962f, 28.342402f, 33.83816f, 32.565517f, 29.89175f, 34.85183f) + cubicTo(25.94534f, 37.13814f, 21.077263f, 37.13814f, 17.130852f, 34.85183f) + cubicTo(13.18444f, 32.565517f, 10.762982f, 28.342402f, 10.783379f, 23.781593f) + cubicTo(10.762982f, 19.220785f, 13.18444f, 14.997669f, 17.130852f, 12.711357f) + cubicTo(21.077263f, 10.425044f, 25.94534f, 10.425044f, 29.89175f, 12.711357f) + cubicTo(33.83816f, 14.997669f, 36.25962f, 19.220785f, 36.239223f, 23.781593f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.34659088f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_5_3 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=1.644156f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(22.66343f, 2.8294024f) + lineTo(21.834734f, 8.282713f) + cubicTo(20.257912f, 8.641812f, 17.357416f, 9.740083f, 16.022846f, 10.568205f) + lineTo(11.614124f, 7.2775526f) + cubicTo(10.441019f, 8.188315f, 10.36057f, 8.250079f, 9.42251f, 9.40051f) + lineTo(12.610179f, 14.128108f) + cubicTo(11.6954f, 15.526075f, 10.596635f, 18.017319f, 10.202127f, 19.797586f) + cubicTo(10.202127f, 19.797586f, 4.61633f, 20.73919f, 4.61633f, 20.73919f) + cubicTo(4.5203147f, 21.523417f, 4.566459f, 23.201902f, 4.631081f, 23.84773f) + lineTo(9.966658f, 24.80891f) + cubicTo(10.340164f, 26.632656f, 11.7379f, 29.568249f, 12.727915f, 31.07189f) + lineTo(9.353855f, 35.52969f) + cubicTo(10.248374f, 36.640198f, 10.427401f, 36.741817f, 11.540642f, 37.63307f) + lineTo(16.052347f, 34.327667f) + cubicTo(17.597954f, 35.313633f, 20.66584f, 36.51303f, 22.536043f, 36.853455f) + lineTo(23.276506f, 42.23811f) + cubicTo(23.865746f, 42.291744f, 25.493572f, 42.4422f, 26.316393f, 42.336266f) + lineTo(27.145086f, 36.730892f) + cubicTo(28.920776f, 36.288998f, 31.988947f, 35.02955f, 33.437565f, 33.999138f) + lineTo(37.944447f, 37.255463f) + cubicTo(39.04833f, 36.316303f, 39.05822f, 36.17479f, 39.93009f, 35.01477f) + lineTo(36.59036f, 30.267595f) + cubicTo(37.428738f, 28.819675f, 38.51277f, 25.987974f, 38.807198f, 24.279242f) + lineTo(44.275257f, 23.371965f) + cubicTo(44.321068f, 22.826805f, 44.3233f, 21.306536f, 44.187027f, 20.376335f) + lineTo(38.61598f, 19.415154f) + cubicTo(38.200092f, 17.879461f, 36.77285f, 15.112168f, 35.908627f, 13.823982f) + lineTo(39.4495f, 9.366181f) + cubicTo(38.481354f, 8.182182f, 38.12138f, 8.019728f, 36.904682f, 7.091162f) + lineTo(32.240913f, 10.430893f) + cubicTo(30.946007f, 9.66506f, 28.363857f, 8.497611f, 26.850887f, 8.164979f) + lineTo(26.027018f, 2.8294024f) + cubicTo(25.272272f, 2.7406204f, 23.094751f, 2.7800448f, 22.66343f, 2.8294024f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) + +} +} + + + + private fun innerPaint(drawScope: DrawScope) { + _paint0(drawScope) + + + shape = null + generalPath = null + brush = null + stroke = null + clip = null + alpha = 1.0f + } + + companion object { + /** + * Returns the X of the bounding box of the original SVG image. + * + * @return The X of the bounding box of the original SVG image. + */ + fun getOrigX(): Double { + return 3.9147281646728516 + } + + /** + * Returns the Y of the bounding box of the original SVG image. + * + * @return The Y of the bounding box of the original SVG image. + */ + fun getOrigY(): Double { + return 3.0233452320098877 + } + + /** + * Returns the width of the bounding box of the original SVG image. + * + * @return The width of the bounding box of the original SVG image. + */ + fun getOrigWidth(): Double { + return 44.08527374267578 + } + + /** + * Returns the height of the bounding box of the original SVG image. + * + * @return The height of the bounding box of the original SVG image. + */ + fun getOrigHeight(): Double { + return 44.976654052734375 + } + + + } + + override val intrinsicSize: Size + get() = Size.Unspecified + + override fun DrawScope.onDraw() { + clipRect { + // Use the original icon bounding box and the current icon dimension to compute + // the scaling factor + val fullOrigWidth = getOrigX() + getOrigWidth() + val fullOrigHeight = getOrigY() + getOrigHeight() + val coef1 = size.width / fullOrigWidth + val coef2 = size.height / fullOrigHeight + val coef = min(coef1, coef2).toFloat() + + // Use the original icon bounding box and the current icon dimension to compute + // the offset pivot for the scaling + var translateX = -getOrigX() + var translateY = -getOrigY() + if (coef1 != coef2) { + if (coef1 < coef2) { + val extraDy = ((fullOrigWidth - fullOrigHeight) / 2.0f).toFloat() + translateY += extraDy + } else { + val extraDx = ((fullOrigHeight - fullOrigWidth) / 2.0f).toFloat() + translateX += extraDx + } + } + val translateXDp = translateX.toFloat().toDp().value + val translateYDp = translateY.toFloat().toDp().value + + // Create a combined scale + translate + clip transform before calling the transcoded painting instructions + withTransform({ + scale(scaleX = coef, scaleY = coef, pivot = Offset.Zero) + translate(translateXDp, translateYDp) + clipRect(left = 0.0f, top = 0.0f, right = fullOrigWidth.toFloat(), bottom = fullOrigHeight.toFloat(), clipOp = ClipOp.Intersect) + }) { + innerPaint(this) + } + } + } +} + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_font.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_font.kt new file mode 100644 index 00000000..37fd39ec --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_font.kt @@ -0,0 +1,354 @@ +package org.pushingpixels.aurora.demo.svg.tango + +import androidx.compose.ui.geometry.* +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Fill +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.clipRect +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.graphics.drawscope.withTransform +import androidx.compose.ui.graphics.painter.Painter +import java.lang.ref.WeakReference +import java.util.* +import kotlin.math.min + +/** + * This class has been automatically generated using + * Aurora SVG transcoder. + */ +class preferences_desktop_font : Painter() { + @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null + @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null + @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null + @Suppress("UNUSED_VARIABLE") private var stroke: Stroke? = null + @Suppress("UNUSED_VARIABLE") private var clip: Shape? = null + private var alpha = 1.0f + private var blendMode = DrawScope.DefaultBlendMode + private var alphaStack = mutableListOf(1.0f) + private var blendModeStack = mutableListOf(DrawScope.DefaultBlendMode) + + @Suppress("UNUSED_VARIABLE", "UNUSED_VALUE", "VARIABLE_WITH_REDUNDANT_INITIALIZER", "UNNECESSARY_NOT_NULL_ASSERTION") +private fun _paint0(drawScope : DrawScope) { +var shapeText: Outline? +var generalPathText: Path? = null +var alphaText = 0.0f +var blendModeText = DrawScope.DefaultBlendMode +with(drawScope) { +// +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0 +alphaStack.add(0, alpha) +alpha *= 0.4064171f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +2.4600489139556885f, 0.0f, 0.0f, 0.0f, +0.0f, 2.4600489139556885f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-49.40945816040039f, -67.96373748779297f, 0.0f, 1.0f) +))}){ +// _0_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(36.769554f, 44.565483f) + cubicTo(36.780075f, 45.361816f, 35.53091f, 46.099186f, 33.495064f, 46.498383f) + cubicTo(31.459217f, 46.89758f, 28.947906f, 46.89758f, 26.91206f, 46.498383f) + cubicTo(24.876213f, 46.099186f, 23.627047f, 45.361816f, 23.63757f, 44.565483f) + cubicTo(23.627047f, 43.76915f, 24.876213f, 43.03178f, 26.91206f, 42.632584f) + cubicTo(28.947906f, 42.233387f, 31.459217f, 42.233387f, 33.495064f, 42.632584f) + cubicTo(35.53091f, 43.03178f, 36.780075f, 43.76915f, 36.769554f, 44.565483f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(30.203562f, 44.565502f), radius = 6.5659924f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_1 +shape = Outline.Rounded(roundRect = RoundRect(left = 4.414728164672852f, top = 3.5233452320098877f, right = 44.47665214538574f, bottom = 43.58526921272278f,radiusX = 10.909647941589355f, radiusY = 10.909647941589355f)) +brush = Brush.radialGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(220, 220, 220, 255), center = Offset(24.445688f, 35.878155f), radius = 40.960464f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(155, 155, 155, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Bevel, miter=10.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 4.414728164672852f, top = 3.5233452320098877f, right = 44.47665214538574f, bottom = 43.58526921272278f,radiusX = 10.909647941589355f, radiusY = 10.909647941589355f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=0.99999976f, cap=StrokeCap.Butt, join=StrokeJoin.Bevel, miter=10.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 5.597388744354248f, top = 4.70600700378418f, right = 43.29397535324097f, bottom = 42.4025936126709f,radiusX = 8.485278129577637f, radiusY = 8.485278129577637f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(19.187523f, 7.5673065f) + lineTo(16.902367f, 15.512619f) + lineTo(16.644554f, 16.579025f) + cubicTo(16.621107f, 16.68059f, 16.60939f, 16.766527f, 16.609398f, 16.836838f) + cubicTo(16.60939f, 16.96184f, 16.648453f, 17.071215f, 16.726585f, 17.164963f) + cubicTo(16.789078f, 17.235275f, 16.867203f, 17.270432f, 16.96096f, 17.270432f) + cubicTo(17.062513f, 17.270432f, 17.195328f, 17.207932f, 17.359398f, 17.082932f) + cubicTo(17.664076f, 16.85637f, 18.070326f, 16.38762f, 18.578148f, 15.676682f) + lineTo(18.976585f, 15.957932f) + cubicTo(18.437513f, 16.770433f, 17.882826f, 17.391525f, 17.312523f, 17.821213f) + cubicTo(16.742203f, 18.243088f, 16.214859f, 18.454025f, 15.730492f, 18.454025f) + cubicTo(15.394547f, 18.454025f, 15.140641f, 18.368088f, 14.968773f, 18.196213f) + cubicTo(14.804704f, 18.03215f, 14.722673f, 17.789963f, 14.72268f, 17.46965f) + cubicTo(14.722673f, 17.08684f, 14.80861f, 16.582933f, 14.980492f, 15.957932f) + lineTo(15.226586f, 15.079025f) + cubicTo(14.203142f, 16.414965f, 13.261737f, 17.348557f, 12.402367f, 17.879807f) + cubicTo(11.785176f, 18.262619f, 11.179708f, 18.454025f, 10.585961f, 18.454025f) + cubicTo(10.015646f, 18.454025f, 9.523459f, 18.21965f, 9.109399f, 17.7509f) + cubicTo(8.695335f, 17.27434f, 8.488304f, 16.621996f, 8.488305f, 15.793869f) + cubicTo(8.488304f, 14.551685f, 8.859398f, 13.243093f, 9.601586f, 11.868088f) + cubicTo(10.351583f, 10.485283f, 11.300801f, 9.379815f, 12.449242f, 8.5516815f) + cubicTo(13.347674f, 7.895442f, 14.19533f, 7.567317f, 14.992211f, 7.5673065f) + cubicTo(15.468766f, 7.567317f, 15.863297f, 7.692317f, 16.175804f, 7.9423065f) + cubicTo(16.496109f, 8.192317f, 16.738297f, 8.606379f, 16.902367f, 9.184494f) + lineTo(17.324242f, 7.8485565f) + lineTo(19.187523f, 7.5673065f) + moveTo(15.015648f, 8.1766815f) + cubicTo(14.515642f, 8.176692f, 13.984392f, 8.411066f, 13.421898f, 8.8798065f) + cubicTo(12.625019f, 9.543878f, 11.914082f, 10.528252f, 11.289086f, 11.832932f) + cubicTo(10.671896f, 13.137624f, 10.363302f, 14.31731f, 10.363305f, 15.371994f) + cubicTo(10.363302f, 15.903246f, 10.496115f, 16.32512f, 10.761742f, 16.637619f) + cubicTo(11.027364f, 16.942308f, 11.332051f, 17.09465f, 11.675805f, 17.09465f) + cubicTo(12.527363f, 17.09465f, 13.453143f, 16.465746f, 14.453148f, 15.207932f) + cubicTo(15.789078f, 13.536061f, 16.457047f, 11.821219f, 16.457054f, 10.0634f) + cubicTo(16.457047f, 9.399346f, 16.32814f, 8.918879f, 16.070335f, 8.621994f) + cubicTo(15.812515f, 8.325129f, 15.460953f, 8.176692f, 15.015648f, 8.1766815f) +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(0, 0, 0, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_4 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(23.843164f, 20.148026f) + lineTo(23.843164f, 26.056417f) + cubicTo(24.570492f, 25.30076f, 25.31199f, 24.724564f, 26.067669f, 24.327824f) + cubicTo(26.82333f, 23.921665f, 27.758469f, 23.718578f, 28.87309f, 23.718563f) + cubicTo(30.157719f, 23.718578f, 31.281775f, 24.02557f, 32.245266f, 24.639536f) + cubicTo(33.218178f, 25.244085f, 33.969124f, 26.127274f, 34.498108f, 27.289103f) + cubicTo(35.036507f, 28.44151f, 35.305714f, 29.81116f, 35.30573f, 31.398058f) + cubicTo(35.305714f, 32.56935f, 35.15458f, 33.64618f, 34.85233f, 34.628544f) + cubicTo(34.55949f, 35.601475f, 34.129704f, 36.446877f, 33.562965f, 37.16476f) + cubicTo(32.9962f, 37.88265f, 32.306652f, 38.439953f, 31.49432f, 38.83668f) + cubicTo(30.691408f, 39.22396f, 29.803497f, 39.417603f, 28.830585f, 39.417603f) + cubicTo(28.235485f, 39.417603f, 27.673456f, 39.346756f, 27.144497f, 39.20507f) + cubicTo(26.624966f, 39.06338f, 26.18101f, 38.87919f, 25.81263f, 38.652485f) + cubicTo(25.444233f, 38.41634f, 25.127796f, 38.17547f, 24.86332f, 37.92988f) + cubicTo(24.608274f, 37.684284f, 24.268223f, 37.3159f, 23.843164f, 36.82471f) + lineTo(23.843164f, 37.207268f) + cubicTo(23.843159f, 37.9346f, 23.668411f, 38.487183f, 23.318918f, 38.865017f) + cubicTo(22.969418f, 39.233406f, 22.525461f, 39.417603f, 21.987051f, 39.417603f) + cubicTo(21.439188f, 39.417603f, 20.999954f, 39.233406f, 20.669352f, 38.865017f) + cubicTo(20.34819f, 38.487183f, 20.18761f, 37.9346f, 20.187613f, 37.207268f) + lineTo(20.187613f, 20.31805f) + cubicTo(20.18761f, 19.534063f, 20.343468f, 18.943695f, 20.655184f, 18.54695f) + cubicTo(20.976341f, 18.140799f, 21.420296f, 17.937712f, 21.987051f, 17.93769f) + cubicTo(22.582136f, 17.937712f, 23.04026f, 18.131351f, 23.361425f, 18.518612f) + cubicTo(23.68258f, 18.896467f, 23.843159f, 19.439604f, 23.843164f, 20.148026f) + moveTo(24.02736f, 31.638927f) + cubicTo(24.027353f, 33.178608f, 24.37685f, 34.364063f, 25.075851f, 35.195297f) + cubicTo(25.784285f, 36.01709f, 26.709978f, 36.427986f, 27.852938f, 36.427982f) + cubicTo(28.825851f, 36.427986f, 29.66181f, 36.007645f, 30.360815f, 35.166958f) + cubicTo(31.069244f, 34.316837f, 31.423464f, 33.103043f, 31.423475f, 31.525576f) + cubicTo(31.423464f, 30.50543f, 31.277052f, 29.626966f, 30.984243f, 28.890179f) + cubicTo(30.691408f, 28.153412f, 30.275791f, 27.58666f, 29.737389f, 27.18992f) + cubicTo(29.198963f, 26.78376f, 28.570812f, 26.580675f, 27.852938f, 26.580664f) + cubicTo(27.11615f, 26.580675f, 26.459663f, 26.78376f, 25.883472f, 27.18992f) + cubicTo(25.307268f, 27.58666f, 24.853867f, 28.16758f, 24.523268f, 28.932686f) + cubicTo(24.192656f, 29.688364f, 24.027353f, 30.590443f, 24.02736f, 31.638927f) +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(0, 0, 0, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(39.201935f, 12.649522f) + cubicTo(39.201927f, 12.84475f, 39.18891f, 13.13107f, 39.16289f, 13.508484f) + cubicTo(39.149868f, 13.8729f, 39.14336f, 14.139699f, 39.143368f, 14.308881f) + lineTo(36.41031f, 14.308881f) + lineTo(36.41031f, 11.907691f) + cubicTo(36.4103f, 11.439177f, 36.15001f, 11.204915f, 35.629433f, 11.204904f) + cubicTo(35.108845f, 11.204915f, 34.848553f, 11.439177f, 34.848557f, 11.907691f) + lineTo(34.848557f, 19.618828f) + cubicTo(34.848553f, 20.100368f, 35.108845f, 20.341139f, 35.629433f, 20.341137f) + cubicTo(36.15001f, 20.341139f, 36.4103f, 20.100368f, 36.41031f, 19.618828f) + lineTo(36.41031f, 17.061464f) + lineTo(39.143368f, 17.061464f) + lineTo(39.143368f, 19.560263f) + cubicTo(39.14336f, 20.328123f, 38.726894f, 20.913778f, 37.89397f, 21.31723f) + cubicTo(37.23022f, 21.642595f, 36.475376f, 21.805277f, 35.629433f, 21.805277f) + cubicTo(34.770466f, 21.805277f, 34.01562f, 21.642595f, 33.364895f, 21.31723f) + cubicTo(32.531963f, 20.913778f, 32.115498f, 20.328123f, 32.115498f, 19.560263f) + lineTo(32.115498f, 12.044344f) + cubicTo(32.115498f, 10.599737f, 33.286808f, 9.877429f, 35.629433f, 9.877418f) + cubicTo(36.80074f, 9.877429f, 37.6597f, 10.053126f, 38.206318f, 10.404508f) + cubicTo(38.870056f, 10.833999f, 39.201927f, 11.582337f, 39.201935f, 12.649522f) +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(0, 0, 0, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) + +} +} + + + + private fun innerPaint(drawScope: DrawScope) { + _paint0(drawScope) + + + shape = null + generalPath = null + brush = null + stroke = null + clip = null + alpha = 1.0f + } + + companion object { + /** + * Returns the X of the bounding box of the original SVG image. + * + * @return The X of the bounding box of the original SVG image. + */ + fun getOrigX(): Double { + return 3.9147281646728516 + } + + /** + * Returns the Y of the bounding box of the original SVG image. + * + * @return The Y of the bounding box of the original SVG image. + */ + fun getOrigY(): Double { + return 3.0233452320098877 + } + + /** + * Returns the width of the bounding box of the original SVG image. + * + * @return The width of the bounding box of the original SVG image. + */ + fun getOrigWidth(): Double { + return 41.06192398071289 + } + + /** + * Returns the height of the bounding box of the original SVG image. + * + * @return The height of the bounding box of the original SVG image. + */ + fun getOrigHeight(): Double { + return 44.38325500488281 + } + + + } + + override val intrinsicSize: Size + get() = Size.Unspecified + + override fun DrawScope.onDraw() { + clipRect { + // Use the original icon bounding box and the current icon dimension to compute + // the scaling factor + val fullOrigWidth = getOrigX() + getOrigWidth() + val fullOrigHeight = getOrigY() + getOrigHeight() + val coef1 = size.width / fullOrigWidth + val coef2 = size.height / fullOrigHeight + val coef = min(coef1, coef2).toFloat() + + // Use the original icon bounding box and the current icon dimension to compute + // the offset pivot for the scaling + var translateX = -getOrigX() + var translateY = -getOrigY() + if (coef1 != coef2) { + if (coef1 < coef2) { + val extraDy = ((fullOrigWidth - fullOrigHeight) / 2.0f).toFloat() + translateY += extraDy + } else { + val extraDx = ((fullOrigHeight - fullOrigWidth) / 2.0f).toFloat() + translateX += extraDx + } + } + val translateXDp = translateX.toFloat().toDp().value + val translateYDp = translateY.toFloat().toDp().value + + // Create a combined scale + translate + clip transform before calling the transcoded painting instructions + withTransform({ + scale(scaleX = coef, scaleY = coef, pivot = Offset.Zero) + translate(translateXDp, translateYDp) + clipRect(left = 0.0f, top = 0.0f, right = fullOrigWidth.toFloat(), bottom = fullOrigHeight.toFloat(), clipOp = ClipOp.Intersect) + }) { + innerPaint(this) + } + } + } +} + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_keyboard_shortcuts.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_keyboard_shortcuts.kt new file mode 100644 index 00000000..5e9b896a --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_keyboard_shortcuts.kt @@ -0,0 +1,903 @@ +package org.pushingpixels.aurora.demo.svg.tango + +import androidx.compose.ui.geometry.* +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Fill +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.clipRect +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.graphics.drawscope.withTransform +import androidx.compose.ui.graphics.painter.Painter +import java.lang.ref.WeakReference +import java.util.* +import kotlin.math.min + +/** + * This class has been automatically generated using + * Aurora SVG transcoder. + */ +class preferences_desktop_keyboard_shortcuts : Painter() { + @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null + @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null + @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null + @Suppress("UNUSED_VARIABLE") private var stroke: Stroke? = null + @Suppress("UNUSED_VARIABLE") private var clip: Shape? = null + private var alpha = 1.0f + private var blendMode = DrawScope.DefaultBlendMode + private var alphaStack = mutableListOf(1.0f) + private var blendModeStack = mutableListOf(DrawScope.DefaultBlendMode) + + @Suppress("UNUSED_VARIABLE", "UNUSED_VALUE", "VARIABLE_WITH_REDUNDANT_INITIALIZER", "UNNECESSARY_NOT_NULL_ASSERTION") +private fun _paint0(drawScope : DrawScope) { +var shapeText: Outline? +var generalPathText: Path? = null +var alphaText = 0.0f +var blendModeText = DrawScope.DefaultBlendMode +with(drawScope) { +// +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-3.000005006790161f, -2.993760108947754f, 0.0f, 1.0f) +))}){ +// _0_0_0 +alphaStack.add(0, alpha) +alpha *= 0.3888889f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.5241569876670837f, 0.0f, 0.0f, 0.0f, +0.0f, 0.27388399839401245f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +2.4482979774475098f, 12.695910453796387f, 0.0f, 1.0f) +))}){ +// _0_0_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(41.625f, 39.8125f) + cubicTo(41.652843f, 42.29842f, 38.34729f, 44.600277f, 32.960007f, 45.84646f) + cubicTo(27.572727f, 47.09264f, 20.927273f, 47.09264f, 15.539991f, 45.84646f) + cubicTo(10.15271f, 44.600277f, 6.8471565f, 42.29842f, 6.875f, 39.8125f) + cubicTo(6.8471565f, 37.32658f, 10.15271f, 35.024723f, 15.539991f, 33.77854f) + cubicTo(20.927273f, 32.53236f, 27.572727f, 32.53236f, 32.960007f, 33.77854f) + cubicTo(38.34729f, 35.024723f, 41.652843f, 37.32658f, 41.625f, 39.8125f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(24.25f, 39.812515f), radius = 17.375f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_0_1 +shape = Outline.Rounded(roundRect = RoundRect(left = 5.495044231414795f, top = 4.505629539489746f, right = 25.48451566696167f, bottom = 25.44937038421631f,radiusX = 4.898674011230469f, radiusY = 5.132530212402344f)) +brush = Brush.radialGradient(0.0f to Color(248, 248, 247, 255), 1.0f to Color(186, 189, 182, 255), center = Offset(15.489777f, 5.8524966f), radius = 23.122776f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(136, 138, 133, 255)) +stroke = Stroke(width=0.9999993f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 5.495044231414795f, top = 4.505629539489746f, right = 25.48451566696167f, bottom = 25.44937038421631f,radiusX = 4.898674011230469f, radiusY = 5.132530212402344f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +-1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +0.0f, 0.0f, 0.0f, 1.0f) +))}){ +// _0_0_0_2 +shape = Outline.Rounded(roundRect = RoundRect(left = -22.537153244018555f, top = 7.234417915344238f, right = -8.462854385375977f, bottom = 20.561720848083496f,radiusX = 3.4490861892700195f, radiusY = 3.2660250663757324f)) +brush = Brush.radialGradient(0.0f to Color(242, 244, 241, 255), 1.0f to Color(211, 215, 207, 255), center = Offset(-15.499998f, 17.550545f), radius = 15.777922f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = Brush.linearGradient(0.0f to Color(238, 238, 236, 255), 1.0f to Color(255, 255, 255, 255), start = Offset(-15.500005f, 10.017332f), end = Offset(-15.500005f, 19.83331f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.9999998f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = -22.537153244018555f, top = 7.234417915344238f, right = -8.462854385375977f, bottom = 20.561720848083496f,radiusX = 3.4490861892700195f, radiusY = 3.2660250663757324f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_0_3 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=0.9999997f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 6.489673137664795f, top = 5.500080108642578f, right = 24.510337352752686f, bottom = 24.496803283691406f,radiusX = 3.1135053634643555f, radiusY = 3.1135053634643555f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_0_4 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(6.975835f, 22.771961f) + cubicTo(6.920206f, 23.604708f, 7.4649177f, 24.090702f, 8.383736f, 24.022097f) + lineTo(9.265165f, 20.851969f) + lineTo(8.619088f, 20.469515f) + lineTo(6.975835f, 22.771961f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_0_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(24.054497f, 22.998959f) + cubicTo(23.867056f, 23.942188f, 23.167665f, 24.052534f, 22.337234f, 24.05022f) + lineTo(21.522097f, 20.96848f) + lineTo(22.190271f, 20.563929f) + lineTo(24.054497f, 22.998959f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_0_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(24.029566f, 7.081846f) + cubicTo(23.977024f, 6.4997454f, 23.650196f, 6.0533137f, 23.015554f, 6.0f) + lineTo(22.15468f, 7.1442795f) + lineTo(22.756563f, 7.778922f) + lineTo(24.029566f, 7.081846f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 0), 0.5f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(22.481161f, 6.8019323f), end = Offset(23.081062f, 7.5591f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_0_7 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(6.903371f, 6.982795f) + cubicTo(7.0443015f, 6.4669857f, 7.4488535f, 6.0312166f, 8.017205f, 6.0f) + lineTo(8.779029f, 7.187702f) + lineTo(8.219797f, 7.822345f) + lineTo(6.903371f, 6.982795f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 0), 0.5f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(7.7836266f, 7.406542f), end = Offset(8.281891f, 6.80426f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.384225994348526f, 0.0f, 0.0f, 0.0f, +0.0f, 0.384225994348526f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +25.257190704345703f, 17.865219116210938f, 0.0f, 1.0f) +))}){ +// _0_0_1 +brush = SolidColor(Color(32, 74, 135, 255)) +stroke = Stroke(width=5.20527f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(44.724503f, 19.538952f) + cubicTo(44.746315f, 24.416483f, 42.1567f, 28.932869f, 37.936234f, 31.377954f) + cubicTo(33.715767f, 33.823036f, 28.50963f, 33.823036f, 24.289162f, 31.377954f) + cubicTo(20.068693f, 28.932869f, 17.47908f, 24.416483f, 17.500893f, 19.538952f) + cubicTo(17.47908f, 14.661421f, 20.068693f, 10.145034f, 24.289162f, 7.6999497f) + cubicTo(28.50963f, 5.2548656f, 33.715767f, 5.2548656f, 37.936234f, 7.6999497f) + cubicTo(42.1567f, 10.145034f, 44.746315f, 14.661421f, 44.724503f, 19.538952f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +20.004959106445312f, -2.9431300163269043f, 0.0f, 1.0f) +))}){ +// _0_0_2 +alphaStack.add(0, alpha) +alpha *= 0.3888889f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.5241569876670837f, 0.0f, 0.0f, 0.0f, +0.0f, 0.27388399839401245f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +2.4482979774475098f, 12.695910453796387f, 0.0f, 1.0f) +))}){ +// _0_0_2_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(41.625f, 39.8125f) + cubicTo(41.652843f, 42.29842f, 38.34729f, 44.600277f, 32.960007f, 45.84646f) + cubicTo(27.572727f, 47.09264f, 20.927273f, 47.09264f, 15.539991f, 45.84646f) + cubicTo(10.15271f, 44.600277f, 6.8471565f, 42.29842f, 6.875f, 39.8125f) + cubicTo(6.8471565f, 37.32658f, 10.15271f, 35.024723f, 15.539991f, 33.77854f) + cubicTo(20.927273f, 32.53236f, 27.572727f, 32.53236f, 32.960007f, 33.77854f) + cubicTo(38.34729f, 35.024723f, 41.652843f, 37.32658f, 41.625f, 39.8125f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(24.25f, 39.812515f), radius = 17.375f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_1 +shape = Outline.Rounded(roundRect = RoundRect(left = 5.495044231414795f, top = 4.505629539489746f, right = 25.48451566696167f, bottom = 25.44937038421631f,radiusX = 4.898674011230469f, radiusY = 5.132530212402344f)) +brush = SolidColor(Color(186, 189, 182, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(136, 138, 133, 255)) +stroke = Stroke(width=0.9999993f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 5.495044231414795f, top = 4.505629539489746f, right = 25.48451566696167f, bottom = 25.44937038421631f,radiusX = 4.898674011230469f, radiusY = 5.132530212402344f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +-1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +0.0f, 0.0f, 0.0f, 1.0f) +))}){ +// _0_0_2_2 +shape = Outline.Rounded(roundRect = RoundRect(left = -22.537153244018555f, top = 7.234417915344238f, right = -8.462854385375977f, bottom = 20.561720848083496f,radiusX = 3.4490861892700195f, radiusY = 3.2660250663757324f)) +brush = Brush.radialGradient(0.0f to Color(242, 244, 241, 255), 1.0f to Color(211, 215, 207, 255), center = Offset(-15.499998f, 17.550545f), radius = 15.777922f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = Brush.linearGradient(0.0f to Color(238, 238, 236, 255), 1.0f to Color(255, 255, 255, 255), start = Offset(-15.500005f, 10.017332f), end = Offset(-15.500005f, 19.83331f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.9999998f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = -22.537153244018555f, top = 7.234417915344238f, right = -8.462854385375977f, bottom = 20.561720848083496f,radiusX = 3.4490861892700195f, radiusY = 3.2660250663757324f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_3 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=0.9999997f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 6.489673137664795f, top = 5.500080108642578f, right = 24.510337352752686f, bottom = 24.496803283691406f,radiusX = 3.1135053634643555f, radiusY = 3.1135053634643555f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_4 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(6.975835f, 22.771961f) + cubicTo(6.920206f, 23.604708f, 7.4649177f, 24.090702f, 8.383736f, 24.022097f) + lineTo(9.265165f, 20.851969f) + lineTo(8.619088f, 20.469515f) + lineTo(6.975835f, 22.771961f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(24.054497f, 22.998959f) + cubicTo(23.867056f, 23.942188f, 23.167665f, 24.052534f, 22.337234f, 24.05022f) + lineTo(21.522097f, 20.96848f) + lineTo(22.190271f, 20.563929f) + lineTo(24.054497f, 22.998959f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(24.029566f, 7.081846f) + cubicTo(23.977024f, 6.4997454f, 23.650196f, 6.0533137f, 23.015554f, 6.0f) + lineTo(22.15468f, 7.1442795f) + lineTo(22.756563f, 7.778922f) + lineTo(24.029566f, 7.081846f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 0), 0.5f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(22.481161f, 6.8019323f), end = Offset(23.081062f, 7.5591f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_7 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(6.903371f, 6.982795f) + cubicTo(7.0443015f, 6.4669857f, 7.4488535f, 6.0312166f, 8.017205f, 6.0f) + lineTo(8.779029f, 7.187702f) + lineTo(8.219797f, 7.822345f) + lineTo(6.903371f, 6.982795f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 0), 0.5f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(7.7836266f, 7.406542f), end = Offset(8.281891f, 6.80426f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.005411982536316f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-2.9845149517059326f, 19.97269058227539f, 0.0f, 1.0f) +))}){ +// _0_0_3 +alphaStack.add(0, alpha) +alpha *= 0.3888889f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.5241569876670837f, 0.0f, 0.0f, 0.0f, +0.0f, 0.27388399839401245f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +2.4482979774475098f, 12.695910453796387f, 0.0f, 1.0f) +))}){ +// _0_0_3_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(41.625f, 39.8125f) + cubicTo(41.652843f, 42.29842f, 38.34729f, 44.600277f, 32.960007f, 45.84646f) + cubicTo(27.572727f, 47.09264f, 20.927273f, 47.09264f, 15.539991f, 45.84646f) + cubicTo(10.15271f, 44.600277f, 6.8471565f, 42.29842f, 6.875f, 39.8125f) + cubicTo(6.8471565f, 37.32658f, 10.15271f, 35.024723f, 15.539991f, 33.77854f) + cubicTo(20.927273f, 32.53236f, 27.572727f, 32.53236f, 32.960007f, 33.77854f) + cubicTo(38.34729f, 35.024723f, 41.652843f, 37.32658f, 41.625f, 39.8125f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(24.25f, 39.812515f), radius = 17.375f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_1 +shape = Outline.Rounded(roundRect = RoundRect(left = 6.365069389343262f, top = 4.505629539489746f, right = 39.52490520477295f, bottom = 25.44937038421631f,radiusX = 5.132530689239502f, radiusY = 5.104902267456055f)) +brush = SolidColor(Color(186, 189, 182, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(136, 138, 133, 255)) +stroke = Stroke(width=0.99730414f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 6.365069389343262f, top = 4.505629539489746f, right = 39.52490520477295f, bottom = 25.44937038421631f,radiusX = 5.132530689239502f, radiusY = 5.104902267456055f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_2 +shape = Outline.Rounded(roundRect = RoundRect(left = 9.190199851989746f, top = 7.44936990737915f, right = 36.48972988128662f, bottom = 20.500000476837158f,radiusX = 2.6410248279571533f, radiusY = 2.6268086433410645f)) +brush = Brush.radialGradient(0.0f to Color(242, 244, 241, 255), 1.0f to Color(211, 215, 207, 255), center = Offset(22.839966f, 20.127712f), radius = 14.35202f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = Brush.linearGradient(0.0f to Color(238, 238, 236, 255), 1.0f to Color(255, 255, 255, 255), start = Offset(15.591383f, 10.232284f), end = Offset(15.591383f, 20.04826f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.99730474f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 9.190199851989746f, top = 7.44936990737915f, right = 36.48972988128662f, bottom = 20.500000476837158f,radiusX = 2.6410248279571533f, radiusY = 2.6268086433410645f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_3 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=0.99730456f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 7.3617119789123535f, top = 5.437580108642578f, right = 38.57697343826294f, bottom = 24.434303283691406f,radiusX = 3.1135053634643555f, radiusY = 3.096745729446411f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_4 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(7.96021f, 22.928211f) + cubicTo(7.920206f, 23.604708f, 8.730542f, 23.981327f, 9.086861f, 23.943972f) + lineTo(10.12454f, 20.883219f) + lineTo(9.353463f, 20.29764f) + lineTo(7.96021f, 22.928211f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.48888892f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(38.516914f, 22.835573f) + cubicTo(38.329475f, 23.778805f, 37.63008f, 23.88915f, 36.799652f, 23.886835f) + lineTo(35.984516f, 20.805096f) + lineTo(36.65269f, 20.400543f) + lineTo(38.516914f, 22.835573f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(37.8594f, 6.968716f) + cubicTo(37.806858f, 6.3866153f, 37.480034f, 5.9401836f, 36.84539f, 5.88687f) + lineTo(35.984516f, 7.0311494f) + lineTo(36.5864f, 7.6657925f) + lineTo(37.8594f, 6.968716f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 0), 0.5f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(36.311f, 6.688802f), end = Offset(36.910904f, 7.4459696f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_7 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(7.984515f, 6.932165f) + cubicTo(8.125445f, 6.4163556f, 8.529998f, 5.9805865f, 9.09835f, 5.94937f) + lineTo(9.860173f, 7.137072f) + lineTo(9.300941f, 7.7717147f) + lineTo(7.984515f, 6.932165f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 0), 0.5f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(8.864771f, 7.3559117f), end = Offset(9.363035f, 6.7536297f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_4 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.61914f, 8.9375f) + lineTo(15.37793f, 14.635742f) + cubicTo(15.159828f, 15.185871f, 14.889646f, 15.597655f, 14.567383f, 15.871094f) + cubicTo(14.245116f, 16.147783f, 13.872395f, 16.28613f, 13.449219f, 16.286133f) + cubicTo(13.292968f, 16.28613f, 13.12858f, 16.2666f, 12.956055f, 16.22754f) + lineTo(12.956055f, 15.329102f) + cubicTo(13.148112f, 15.387694f, 13.322265f, 15.416991f, 13.478516f, 15.416992f) + cubicTo(13.667317f, 15.416991f, 13.839843f, 15.360025f, 13.996094f, 15.246094f) + cubicTo(14.155597f, 15.135415f, 14.284178f, 14.966145f, 14.381836f, 14.738281f) + lineTo(14.728516f, 13.9375f) + lineTo(12.746094f, 8.9375f) + lineTo(13.795898f, 8.9375f) + lineTo(15.089844f, 12.6875f) + cubicTo(15.112628f, 12.746095f, 15.141925f, 12.876303f, 15.177734f, 13.078125f) + lineTo(15.207031f, 13.078125f) + cubicTo(15.255857f, 12.873048f, 15.290036f, 12.74284f, 15.30957f, 12.6875f) + lineTo(16.637695f, 8.9375f) + lineTo(17.61914f, 8.9375f) +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(0, 0, 0, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(39.714844f, 8.9375f) + lineTo(38.035156f, 11.457031f) + lineTo(39.70508f, 13.9375f) + lineTo(38.606445f, 13.9375f) + lineTo(37.4541f, 11.989258f) + lineTo(36.262695f, 13.9375f) + lineTo(35.183594f, 13.9375f) + lineTo(36.907227f, 11.476562f) + lineTo(35.286133f, 8.9375f) + lineTo(36.384766f, 8.9375f) + lineTo(37.493164f, 10.978516f) + lineTo(38.68457f, 8.9375f) + lineTo(39.714844f, 8.9375f) +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(0, 0, 0, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(14.385742f, 38.052734f) + cubicTo(13.851883f, 38.348957f, 13.189449f, 38.49707f, 12.398438f, 38.49707f) + cubicTo(11.405596f, 38.49707f, 10.609699f, 38.176434f, 10.010742f, 37.535156f) + cubicTo(9.415038f, 36.893883f, 9.1171875f, 36.050785f, 9.1171875f, 35.00586f) + cubicTo(9.1171875f, 33.89584f, 9.458983f, 32.994144f, 10.142578f, 32.30078f) + cubicTo(10.829425f, 31.604174f, 11.680661f, 31.255865f, 12.696289f, 31.25586f) + cubicTo(13.383133f, 31.255865f, 13.946284f, 31.35515f, 14.385742f, 31.55371f) + lineTo(14.385742f, 32.583984f) + cubicTo(13.868159f, 32.278f, 13.301753f, 32.125008f, 12.686523f, 32.125f) + cubicTo(11.924801f, 32.125008f, 11.304685f, 32.382168f, 10.826172f, 32.896484f) + cubicTo(10.347655f, 33.40756f, 10.108397f, 34.094406f, 10.108398f, 34.95703f) + cubicTo(10.108397f, 35.77409f, 10.329751f, 36.425133f, 10.772461f, 36.910156f) + cubicTo(11.215167f, 37.39193f, 11.802731f, 37.632812f, 12.535156f, 37.632812f) + cubicTo(13.244787f, 37.632812f, 13.861648f, 37.463543f, 14.385742f, 37.125f) + lineTo(14.385742f, 38.052734f) + moveTo(18.13086f, 38.30664f) + cubicTo(17.925777f, 38.41081f, 17.662107f, 38.46289f, 17.339844f, 38.46289f) + cubicTo(16.874348f, 38.46289f, 16.52604f, 38.337566f, 16.294922f, 38.086914f) + cubicTo(16.0638f, 37.833008f, 15.948241f, 37.45215f, 15.948242f, 36.944336f) + lineTo(15.948242f, 34.126953f) + lineTo(15.108398f, 34.126953f) + lineTo(15.108398f, 33.375f) + lineTo(15.948242f, 33.375f) + lineTo(15.948242f, 32.183594f) + lineTo(16.890625f, 31.885742f) + lineTo(16.890625f, 33.375f) + lineTo(18.13086f, 33.375f) + lineTo(18.13086f, 34.126953f) + lineTo(16.890625f, 34.126953f) + lineTo(16.890625f, 36.76367f) + cubicTo(16.890623f, 37.089195f, 16.945961f, 37.32194f, 17.05664f, 37.461914f) + cubicTo(17.167315f, 37.598633f, 17.361f, 37.666992f, 17.637695f, 37.666992f) + cubicTo(17.816729f, 37.666992f, 17.981117f, 37.61328f, 18.13086f, 37.50586f) + lineTo(18.13086f, 38.30664f) + moveTo(22.011719f, 34.336914f) + cubicTo(21.842445f, 34.222984f, 21.625973f, 34.16602f, 21.362305f, 34.166016f) + cubicTo(21.049803f, 34.16602f, 20.50488f, 34.30925f, 20.29004f, 34.595703f) + cubicTo(20.075193f, 34.882164f, 19.967772f, 35.261395f, 19.967773f, 35.7334f) + lineTo(19.967773f, 38.375f) + lineTo(19.030273f, 38.375f) + lineTo(19.030273f, 33.375f) + lineTo(19.967773f, 33.375f) + lineTo(19.967773f, 34.36621f) + cubicTo(20.088215f, 34.014652f, 20.263994f, 33.747726f, 20.495117f, 33.56543f) + cubicTo(20.726234f, 33.379887f, 21.259764f, 33.287113f, 21.533203f, 33.28711f) + cubicTo(21.738277f, 33.287113f, 21.897783f, 33.309902f, 22.011719f, 33.35547f) + lineTo(22.011719f, 34.336914f) + moveTo(24.00586f, 38.375f) + lineTo(23.058594f, 38.375f) + lineTo(23.058594f, 30.972656f) + lineTo(24.00586f, 30.972656f) + lineTo(24.00586f, 38.375f) +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(0, 0, 0, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_7 +brush = SolidColor(Color(32, 74, 135, 255)) +stroke = Stroke(width=2.0000005f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 3.1503379344940186f, top = 23.928627014160156f, right = 36.84966731071472f, bottom = 46.071388244628906f,radiusX = 5.800036430358887f, radiusY = 5.800036430358887f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_8 +brush = SolidColor(Color(32, 74, 135, 255)) +stroke = Stroke(width=2.0000012f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +shape = Outline.Rounded(roundRect = RoundRect(left = 25.063217163085938f, top = 1.1243784427642822f, right = 45.94068145751953f, bottom = 22.90563416481018f,radiusX = 5.446484088897705f, radiusY = 5.446484088897705f)) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) + +} +} + + + + private fun innerPaint(drawScope: DrawScope) { + _paint0(drawScope) + + + shape = null + generalPath = null + brush = null + stroke = null + clip = null + alpha = 1.0f + } + + companion object { + /** + * Returns the X of the bounding box of the original SVG image. + * + * @return The X of the bounding box of the original SVG image. + */ + fun getOrigX(): Double { + return 1.995039701461792 + } + + /** + * Returns the Y of the bounding box of the original SVG image. + * + * @return The Y of the bounding box of the original SVG image. + */ + fun getOrigY(): Double { + return 0.12437784671783447 + } + + /** + * Returns the width of the bounding box of the original SVG image. + * + * @return The width of the bounding box of the original SVG image. + */ + fun getOrigWidth(): Double { + return 44.945640563964844 + } + + /** + * Returns the height of the bounding box of the original SVG image. + * + * @return The height of the bounding box of the original SVG image. + */ + fun getOrigHeight(): Double { + return 46.9470100402832 + } + + + } + + override val intrinsicSize: Size + get() = Size.Unspecified + + override fun DrawScope.onDraw() { + clipRect { + // Use the original icon bounding box and the current icon dimension to compute + // the scaling factor + val fullOrigWidth = getOrigX() + getOrigWidth() + val fullOrigHeight = getOrigY() + getOrigHeight() + val coef1 = size.width / fullOrigWidth + val coef2 = size.height / fullOrigHeight + val coef = min(coef1, coef2).toFloat() + + // Use the original icon bounding box and the current icon dimension to compute + // the offset pivot for the scaling + var translateX = -getOrigX() + var translateY = -getOrigY() + if (coef1 != coef2) { + if (coef1 < coef2) { + val extraDy = ((fullOrigWidth - fullOrigHeight) / 2.0f).toFloat() + translateY += extraDy + } else { + val extraDx = ((fullOrigHeight - fullOrigWidth) / 2.0f).toFloat() + translateX += extraDx + } + } + val translateXDp = translateX.toFloat().toDp().value + val translateYDp = translateY.toFloat().toDp().value + + // Create a combined scale + translate + clip transform before calling the transcoded painting instructions + withTransform({ + scale(scaleX = coef, scaleY = coef, pivot = Offset.Zero) + translate(translateXDp, translateYDp) + clipRect(left = 0.0f, top = 0.0f, right = fullOrigWidth.toFloat(), bottom = fullOrigHeight.toFloat(), clipOp = ClipOp.Intersect) + }) { + innerPaint(this) + } + } + } +} + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_locale_2.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_locale.kt similarity index 57% rename from demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_locale_2.kt rename to demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_locale.kt index 4498aad3..ee49b60d 100644 --- a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_locale_2.kt +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_locale.kt @@ -17,7 +17,7 @@ import kotlin.math.min * This class has been automatically generated using * Aurora SVG transcoder. */ -class preferences_desktop_locale_2 : Painter() { +class preferences_desktop_locale : Painter() { @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null @@ -190,24 +190,37 @@ alphaStack.add(0, alpha) alpha *= 1.0f blendModeStack.add(0, BlendMode.SrcOver) blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +2.1213181018829346f, 2.0329320430755615f, 0.0f, 1.0f) +))}){ // _0_0_2 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_0 if (generalPath == null) { generalPath = Path() } else { generalPath!!.reset() } generalPath?.run { - moveTo(3.6234345f, 6.1923113f) - cubicTo(12.805777f, -0.3484262f, 29.264694f, 8.136855f, 38.62029f, 6.1923113f) - lineTo(38.62029f, 31.294603f) - cubicTo(29.611198f, 34.29981f, 14.01854f, 24.930641f, 3.6234345f, 31.294603f) - lineTo(3.6234345f, 6.1923113f) + moveTo(1.5021164f, 4.1593795f) + cubicTo(10.684459f, -2.3813581f, 27.143377f, 6.1039233f, 36.498974f, 4.1593795f) + lineTo(36.498974f, 29.261671f) + cubicTo(27.489882f, 32.266876f, 11.897222f, 22.89771f, 1.5021164f, 29.261671f) + lineTo(1.5021164f, 4.1593795f) close() } shape = Outline.Generic(generalPath!!) -brush = Brush.linearGradient(0.0f to Color(117, 80, 123, 255), 0.25709054f to Color(169, 132, 175, 255), 0.5655992f to Color(81, 55, 85, 255), 1.0f to Color(135, 92, 142, 255), start = Offset(3.1234348f, 17.789515f), end = Offset(39.12029f, 17.789515f), tileMode = TileMode.Clamp) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 0.42424244f to Color(190, 190, 190, 255), 1.0f to Color(235, 235, 235, 255), start = Offset(1.0120871f, 16.710526f), end = Offset(36.989002f, 16.710526f), tileMode = TileMode.Clamp) drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) -brush = SolidColor(Color(92, 53, 102, 255)) +brush = SolidColor(Color(85, 87, 83, 255)) stroke = Stroke(width=0.9999994f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) if (generalPath == null) { generalPath = Path() @@ -215,11 +228,11 @@ if (generalPath == null) { generalPath!!.reset() } generalPath?.run { - moveTo(3.6234345f, 6.1923113f) - cubicTo(12.805777f, -0.3484262f, 29.264694f, 8.136855f, 38.62029f, 6.1923113f) - lineTo(38.62029f, 31.294603f) - cubicTo(29.611198f, 34.29981f, 14.01854f, 24.930641f, 3.6234345f, 31.294603f) - lineTo(3.6234345f, 6.1923113f) + moveTo(1.5021164f, 4.1593795f) + cubicTo(10.684459f, -2.3813581f, 27.143377f, 6.1039233f, 36.498974f, 4.1593795f) + lineTo(36.498974f, 29.261671f) + cubicTo(27.489882f, 32.266876f, 11.897222f, 22.89771f, 1.5021164f, 29.261671f) + lineTo(1.5021164f, 4.1593795f) close() } shape = Outline.Generic(generalPath!!) @@ -227,11 +240,103 @@ drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, b alpha = alphaStack.removeAt(0) blendMode = blendModeStack.removeAt(0) alphaStack.add(0, alpha) -alpha *= 0.62921345f +alpha *= 1.0f blendModeStack.add(0, BlendMode.SrcOver) blendMode = BlendMode.SrcOver -// _0_0_3 -brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 112), 0.5f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(4.121318f, 24.253414f), end = Offset(33.066338f, 25.661276f), tileMode = TileMode.Clamp) +// _0_0_2_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(2.0f, 26.0f) + cubicTo(11.0625f, 19.9375f, 29.8125f, 29.25f, 36.0f, 26.0f) + lineTo(36.0f, 23.0f) + cubicTo(29.3125f, 26.4375f, 11.0f, 16.8125f, 2.0f, 23.0f) + lineTo(2.0f, 26.0f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(204, 0, 0, 255), 0.15151516f to Color(255, 55, 55, 255), 0.57575756f to Color(180, 20, 20, 255), 1.0f to Color(255, 76, 76, 255), start = Offset(2.0f, 23.791155f), end = Offset(36.0f, 23.791155f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_2 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(2.0f, 14.751733f) + cubicTo(11.0625f, 8.689233f, 29.8125f, 18.001734f, 36.0f, 14.751733f) + lineTo(36.0f, 11.751733f) + cubicTo(29.3125f, 15.189233f, 11.0f, 5.5642333f, 2.0f, 11.751733f) + lineTo(2.0f, 14.751733f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(204, 0, 0, 255), 0.15151516f to Color(255, 55, 55, 255), 0.57575756f to Color(180, 20, 20, 255), 1.0f to Color(255, 76, 76, 255), start = Offset(2.0f, 12.542885f), end = Offset(36.0f, 12.542885f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_3 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(2.0f, 20.375868f) + cubicTo(11.0625f, 14.313367f, 29.8125f, 23.625868f, 36.0f, 20.375868f) + lineTo(36.0f, 17.375868f) + cubicTo(29.3125f, 20.813368f, 11.0f, 11.188367f, 2.0f, 17.375868f) + lineTo(2.0f, 20.375868f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(204, 0, 0, 255), 0.15151516f to Color(255, 55, 55, 255), 0.57575756f to Color(180, 20, 20, 255), 1.0f to Color(255, 76, 76, 255), start = Offset(2.0f, 18.167023f), end = Offset(36.0f, 18.167023f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_4 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(2.0f, 9.127602f) + cubicTo(11.0625f, 3.0651011f, 29.8125f, 12.377601f, 36.0f, 9.127602f) + lineTo(36.0f, 6.1276016f) + cubicTo(29.3125f, 9.565102f, 11.0f, -0.0598988f, 2.0f, 6.1276016f) + lineTo(2.0f, 9.127602f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(204, 0, 0, 255), 0.15151516f to Color(255, 55, 55, 255), 0.57575756f to Color(180, 20, 20, 255), 1.0f to Color(255, 76, 76, 255), start = Offset(2.0f, 6.9187546f), end = Offset(36.0f, 6.9187546f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.5f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2_5 +brush = SolidColor(Color(255, 255, 255, 255)) stroke = Stroke(width=0.9999999f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) if (generalPath == null) { generalPath = Path() @@ -239,11 +344,11 @@ if (generalPath == null) { generalPath!!.reset() } generalPath?.run { - moveTo(4.621318f, 6.8032613f) - cubicTo(12.598466f, 1.0750242f, 28.454912f, 8.747806f, 37.656868f, 7.3032613f) - lineTo(37.531868f, 30.593054f) - cubicTo(30.717024f, 32.785755f, 14.794159f, 24.888617f, 4.683818f, 29.468054f) - lineTo(4.621318f, 6.8032613f) + moveTo(2.5f, 4.7703295f) + cubicTo(10.477148f, -0.9579077f, 26.333595f, 6.7148733f, 35.53555f, 5.2703295f) + lineTo(35.41055f, 28.560122f) + cubicTo(28.595705f, 30.752825f, 12.672841f, 22.855684f, 2.5625f, 27.435122f) + lineTo(2.5f, 4.7703295f) close() } shape = Outline.Generic(generalPath!!) @@ -254,24 +359,63 @@ alphaStack.add(0, alpha) alpha *= 1.0f blendModeStack.add(0, BlendMode.SrcOver) blendMode = BlendMode.SrcOver -// _0_0_4 +// _0_0_2_6 if (generalPath == null) { generalPath = Path() } else { generalPath!!.reset() } generalPath?.run { - moveTo(10.529842f, 17.09872f) - cubicTo(19.712185f, 10.557982f, 36.171104f, 19.043262f, 45.5267f, 17.09872f) - lineTo(45.5267f, 42.20101f) - cubicTo(36.51761f, 45.206215f, 20.924948f, 35.83705f, 10.529842f, 42.20101f) - lineTo(10.529842f, 17.09872f) + moveTo(2.0f, 4.5f) + cubicTo(2.0f, 4.5f, 2.0f, 14.875f, 2.0f, 14.875f) + cubicTo(4.125f, 13.0f, 9.8125f, 11.625f, 19.0f, 13.5f) + lineTo(19.0f, 3.0f) + cubicTo(15.375f, 2.125f, 5.5f, 1.0624999f, 2.0f, 4.5f) close() } shape = Outline.Generic(generalPath!!) -brush = Brush.linearGradient(0.0f to Color(115, 210, 22, 255), 0.2556818f to Color(156, 237, 75, 255), 0.59400827f to Color(100, 184, 19, 255), 1.0f to Color(142, 234, 52, 255), start = Offset(10.029842f, 28.695923f), end = Offset(46.0267f, 28.695923f), tileMode = TileMode.Clamp) +brush = Brush.linearGradient(0.0f to Color(32, 74, 135, 255), 0.21212122f to Color(63, 123, 210, 255), 1.0f to Color(32, 74, 135, 255), start = Offset(2.0f, 8.501786f), end = Offset(19.0f, 8.501786f), tileMode = TileMode.Clamp) drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) -brush = SolidColor(Color(78, 154, 6, 255)) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-0.9722740054130554f, -1.0606600046157837f, 0.0f, 1.0f) +))}){ +// _0_0_3 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(11.502116f, 18.15938f) + cubicTo(20.68446f, 11.618642f, 37.143375f, 20.103924f, 46.498974f, 18.15938f) + lineTo(46.498974f, 43.26167f) + cubicTo(37.48988f, 46.266876f, 21.897223f, 36.89771f, 11.502116f, 43.26167f) + lineTo(11.502116f, 18.15938f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(237, 212, 0, 255), 0.27272728f to Color(255, 244, 145, 255), 1.0f to Color(237, 212, 0, 255), start = Offset(11.002116f, 29.756582f), end = Offset(46.998974f, 29.756582f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(85, 87, 83, 255)) stroke = Stroke(width=0.9999994f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) if (generalPath == null) { generalPath = Path() @@ -279,11 +423,11 @@ if (generalPath == null) { generalPath!!.reset() } generalPath?.run { - moveTo(10.529842f, 17.09872f) - cubicTo(19.712185f, 10.557982f, 36.171104f, 19.043262f, 45.5267f, 17.09872f) - lineTo(45.5267f, 42.20101f) - cubicTo(36.51761f, 45.206215f, 20.924948f, 35.83705f, 10.529842f, 42.20101f) - lineTo(10.529842f, 17.09872f) + moveTo(11.502116f, 18.15938f) + cubicTo(20.68446f, 11.618642f, 37.143375f, 20.103924f, 46.498974f, 18.15938f) + lineTo(46.498974f, 43.26167f) + cubicTo(37.48988f, 46.266876f, 21.897223f, 36.89771f, 11.502116f, 43.26167f) + lineTo(11.502116f, 18.15938f) close() } shape = Outline.Generic(generalPath!!) @@ -291,11 +435,57 @@ drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, b alpha = alphaStack.removeAt(0) blendMode = blendModeStack.removeAt(0) alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(11.976621f, 18.478292f) + lineTo(12.020815f, 26.61002f) + cubicTo(19.975765f, 21.612175f, 38.890873f, 29.350058f, 46.05033f, 26.963573f) + lineTo(46.05033f, 18.522486f) + cubicTo(38.09538f, 20.599611f, 19.666407f, 12.202719f, 11.976621f, 18.478292f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(46, 52, 54, 255), 0.27272728f to Color(80, 90, 93, 255), 0.6363636f to Color(20, 23, 23, 255), 1.0f to Color(46, 52, 54, 255), start = Offset(11.976621f, 21.723522f), end = Offset(46.138718f, 21.723522f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3_2 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(11.976621f, 26.61002f) + lineTo(12.020815f, 34.564972f) + cubicTo(20.682873f, 27.759068f, 37.476658f, 38.719223f, 46.050327f, 35.095303f) + lineTo(46.050327f, 26.830992f) + cubicTo(37.918602f, 29.084894f, 20.73963f, 19.831844f, 11.976621f, 26.61002f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(204, 0, 0, 255), 0.24242425f to Color(255, 71, 71, 255), 0.6097337f to Color(155, 18, 18, 255), 1.0f to Color(204, 0, 0, 255), start = Offset(11.976621f, 29.74867f), end = Offset(46.138718f, 29.74867f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) alpha *= 0.62921345f blendModeStack.add(0, BlendMode.SrcOver) blendMode = BlendMode.SrcOver -// _0_0_5 -brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 112), 0.5f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(10.964451f, 28.712873f), end = Offset(36.33661f, 27.445059f), tileMode = TileMode.Clamp) +// _0_0_3_3 +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(29.017775f, 40.347282f), end = Offset(29.017775f, 17.189533f), tileMode = TileMode.Clamp) stroke = Stroke(width=0.9999999f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) if (generalPath == null) { generalPath = Path() @@ -303,17 +493,20 @@ if (generalPath == null) { generalPath!!.reset() } generalPath?.run { - moveTo(11.464451f, 17.654135f) - cubicTo(19.441599f, 11.925898f, 35.298046f, 19.598679f, 44.5f, 18.154135f) - lineTo(44.375f, 41.532314f) - cubicTo(37.560158f, 43.725018f, 21.637293f, 35.82788f, 11.526951f, 40.407314f) - lineTo(11.464451f, 17.654135f) + moveTo(12.5f, 18.68194f) + cubicTo(20.477148f, 12.953704f, 36.333595f, 20.626486f, 45.53555f, 19.18194f) + lineTo(45.41055f, 42.56012f) + cubicTo(38.595703f, 44.752827f, 22.67284f, 36.855686f, 12.5625f, 41.43512f) + lineTo(12.5f, 18.68194f) close() } shape = Outline.Generic(generalPath!!) drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) alpha = alphaStack.removeAt(0) blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) alpha = alphaStack.removeAt(0) blendMode = blendModeStack.removeAt(0) alpha = alphaStack.removeAt(0) diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_screensaver.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_screensaver.kt new file mode 100644 index 00000000..3166551d --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_screensaver.kt @@ -0,0 +1,1060 @@ +package org.pushingpixels.aurora.demo.svg.tango + +import androidx.compose.ui.geometry.* +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Fill +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.clipRect +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.graphics.drawscope.withTransform +import androidx.compose.ui.graphics.painter.Painter +import java.lang.ref.WeakReference +import java.util.* +import kotlin.math.min + +/** + * This class has been automatically generated using + * Aurora SVG transcoder. + */ +class preferences_desktop_screensaver : Painter() { + @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null + @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null + @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null + @Suppress("UNUSED_VARIABLE") private var stroke: Stroke? = null + @Suppress("UNUSED_VARIABLE") private var clip: Shape? = null + private var alpha = 1.0f + private var blendMode = DrawScope.DefaultBlendMode + private var alphaStack = mutableListOf(1.0f) + private var blendModeStack = mutableListOf(DrawScope.DefaultBlendMode) + + @Suppress("UNUSED_VARIABLE", "UNUSED_VALUE", "VARIABLE_WITH_REDUNDANT_INITIALIZER", "UNNECESSARY_NOT_NULL_ASSERTION") +private fun _paint0(drawScope : DrawScope) { +var shapeText: Outline? +var generalPathText: Path? = null +var alphaText = 0.0f +var blendModeText = DrawScope.DefaultBlendMode +with(drawScope) { +// +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0 +alphaStack.add(0, alpha) +alpha *= 0.50857145f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0502510070800781f, 0.0f, 0.0f, 0.0f, +0.0f, 1.8678879737854004f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-0.9455580115318298f, -28.106109619140625f, 0.0f, 1.0f) +))}){ +// _0_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(41.10058f, 35.051105f) + cubicTo(41.127632f, 36.682228f, 37.915836f, 38.192577f, 32.681362f, 39.010254f) + cubicTo(27.446886f, 39.827927f, 20.989925f, 39.827927f, 15.755449f, 39.010254f) + cubicTo(10.520973f, 38.192577f, 7.3091793f, 36.682228f, 7.336233f, 35.051105f) + cubicTo(7.3091793f, 33.419983f, 10.520973f, 31.909634f, 15.755449f, 31.091959f) + cubicTo(20.989925f, 30.274284f, 27.446886f, 30.274284f, 32.681362f, 31.091959f) + cubicTo(37.915836f, 31.909634f, 41.127632f, 33.419983f, 41.10058f, 35.051105f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(24.218403f, 35.051075f), radius = 16.882172f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +60.033390045166016f, 8.07843017578125f, 0.0f, 1.0f) +))}){ +// _0_0_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(-26.263968f, 29.716238f) + cubicTo(-26.248913f, 31.127916f, -28.036179f, 32.43507f, -30.949007f, 33.14274f) + cubicTo(-33.861835f, 33.850407f, -37.45494f, 33.850407f, -40.367767f, 33.14274f) + cubicTo(-43.280594f, 32.43507f, -45.06786f, 31.127916f, -45.052807f, 29.716238f) + cubicTo(-45.06786f, 28.30456f, -43.280594f, 26.997404f, -40.367767f, 26.289736f) + cubicTo(-37.45494f, 25.582067f, -33.861835f, 25.582067f, -30.949007f, 26.289736f) + cubicTo(-28.036179f, 26.997404f, -26.248913f, 28.30456f, -26.263968f, 29.716238f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(173, 176, 170, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(75, 77, 74, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(-26.263968f, 29.716238f) + cubicTo(-26.248913f, 31.127916f, -28.036179f, 32.43507f, -30.949007f, 33.14274f) + cubicTo(-33.861835f, 33.850407f, -37.45494f, 33.850407f, -40.367767f, 33.14274f) + cubicTo(-43.280594f, 32.43507f, -45.06786f, 31.127916f, -45.052807f, 29.716238f) + cubicTo(-45.06786f, 28.30456f, -43.280594f, 26.997404f, -40.367767f, 26.289736f) + cubicTo(-37.45494f, 25.582067f, -33.861835f, 25.582067f, -30.949007f, 26.289736f) + cubicTo(-28.036179f, 26.997404f, -26.248913f, 28.30456f, -26.263968f, 29.716238f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.9023730158805847f, 0.0f, 0.0f, 0.0f, +0.0f, 0.8276500105857849f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +56.55215072631836f, 12.867919921875f, 0.0f, 1.0f) +))}){ +// _0_0_2 +brush = Brush.linearGradient(0.0f to Color(123, 127, 122, 255), 1.0f to Color(123, 127, 122, 0), start = Offset(-35.658386f, 33.416473f), end = Offset(-35.658386f, 28.205938f), tileMode = TileMode.Clamp) +stroke = Stroke(width=1.1571338f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(-26.263968f, 29.716238f) + cubicTo(-26.248913f, 31.127916f, -28.036179f, 32.43507f, -30.949007f, 33.14274f) + cubicTo(-33.861835f, 33.850407f, -37.45494f, 33.850407f, -40.367767f, 33.14274f) + cubicTo(-43.280594f, 32.43507f, -45.06786f, 31.127916f, -45.052807f, 29.716238f) + cubicTo(-45.06786f, 28.30456f, -43.280594f, 26.997404f, -40.367767f, 26.289736f) + cubicTo(-37.45494f, 25.582067f, -33.861835f, 25.582067f, -30.949007f, 26.289736f) + cubicTo(-28.036179f, 26.997404f, -26.248913f, 28.30456f, -26.263968f, 29.716238f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.837548017501831f, 0.0f, 0.0f, 0.0f, +0.0f, 0.8526549935340881f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +54.17810821533203f, 11.006150245666504f, 0.0f, 1.0f) +))}){ +// _0_0_3 +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(-35.12269f, 34.242237f), end = Offset(-35.074745f, 30.962345f), tileMode = TileMode.Clamp) +stroke = Stroke(width=1.1833371f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(-26.263968f, 29.716238f) + cubicTo(-26.248913f, 31.127916f, -28.036179f, 32.43507f, -30.949007f, 33.14274f) + cubicTo(-33.861835f, 33.850407f, -37.45494f, 33.850407f, -40.367767f, 33.14274f) + cubicTo(-43.280594f, 32.43507f, -45.06786f, 31.127916f, -45.052807f, 29.716238f) + cubicTo(-45.06786f, 28.30456f, -43.280594f, 26.997404f, -40.367767f, 26.289736f) + cubicTo(-37.45494f, 25.582067f, -33.861835f, 25.582067f, -30.949007f, 26.289736f) + cubicTo(-28.036179f, 26.997404f, -26.248913f, 28.30456f, -26.263968f, 29.716238f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_4 +shape = Outline.Rectangle(rect = Rect(left = 19.972396850585938f, top = 31.07861328125f, right = 29.012069702148438f, bottom = 37.44365215301514f)) +brush = Brush.linearGradient(0.0f to Color(88, 89, 86, 255), 1.0f to Color(187, 190, 184, 255), start = Offset(24.671595f, 28.222458f), end = Offset(24.528107f, 42.74772f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(7.5809026f, 4.570622f) + lineTo(41.169098f, 4.570622f) + cubicTo(42.08044f, 4.570622f, 42.793243f, 5.1541038f, 42.83585f, 5.972209f) + lineTo(44.167892f, 31.550323f) + cubicTo(44.2261f, 32.668056f, 43.266838f, 33.57063f, 42.147587f, 33.57063f) + lineTo(6.602412f, 33.57063f) + cubicTo(5.483163f, 33.57063f, 4.523898f, 32.668056f, 4.5821066f, 31.550323f) + lineTo(5.9141507f, 5.972209f) + cubicTo(5.9544344f, 5.1986747f, 6.461653f, 4.570622f, 7.5809026f, 4.570622f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(221, 225, 217, 255), 1.0f to Color(202, 205, 198, 255), start = Offset(12.604956f, 7.9690657f), end = Offset(42.17669f, 31.078438f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = Brush.linearGradient(0.0f to Color(143, 143, 143, 255), 1.0f to Color(73, 73, 73, 255), start = Offset(15.9755f, 7.7480407f), end = Offset(40.43357f, 31.167397f), tileMode = TileMode.Clamp) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(7.5809026f, 4.570622f) + lineTo(41.169098f, 4.570622f) + cubicTo(42.08044f, 4.570622f, 42.793243f, 5.1541038f, 42.83585f, 5.972209f) + lineTo(44.167892f, 31.550323f) + cubicTo(44.2261f, 32.668056f, 43.266838f, 33.57063f, 42.147587f, 33.57063f) + lineTo(6.602412f, 33.57063f) + cubicTo(5.483163f, 33.57063f, 4.523898f, 32.668056f, 4.5821066f, 31.550323f) + lineTo(5.9141507f, 5.972209f) + cubicTo(5.9544344f, 5.1986747f, 6.461653f, 4.570622f, 7.5809026f, 4.570622f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(8.910536f, 7.180827f) + lineTo(7.6683393f, 29.226145f) + lineTo(39.31873f, 29.226145f) + lineTo(37.98371f, 7.274256f) + lineTo(8.910536f, 7.180827f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(91, 91, 151, 255), 1.0f to Color(27, 27, 67, 255), start = Offset(27.707052f, 32.38555f), end = Offset(24.378864f, 9.926256f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(0, 0, 121, 255)) +stroke = Stroke(width=0.5f, cap=StrokeCap.Butt, join=StrokeJoin.Round, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(8.910536f, 7.180827f) + lineTo(7.6683393f, 29.226145f) + lineTo(39.31873f, 29.226145f) + lineTo(37.98371f, 7.274256f) + lineTo(8.910536f, 7.180827f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_7 +brush = Brush.linearGradient(0.0f to Color(0, 0, 0, 63), 1.0f to Color(0, 0, 0, 0), start = Offset(26.649012f, 32.219574f), end = Offset(26.64901f, 30.66997f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.9961812f, cap=StrokeCap.Round, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(6.677433f, 31.610788f) + lineTo(42.10591f, 31.610788f) +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_8 +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 179), 1.0f to Color(255, 255, 255, 0), start = Offset(25.110981f, 15.611387f), end = Offset(44.25421f, 53.69208f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.99999964f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(7.4145985f, 5.58134f) + lineTo(41.2601f, 5.543538f) + cubicTo(41.543797f, 5.5432215f, 41.819405f, 5.780788f, 41.842205f, 6.196082f) + lineTo(43.204098f, 30.99933f) + cubicTo(43.26214f, 32.056362f, 42.66435f, 32.785202f, 41.60573f, 32.785202f) + lineTo(7.0817585f, 32.785202f) + cubicTo(6.0231357f, 32.785202f, 5.488744f, 32.05641f, 5.545887f, 30.99933f) + lineTo(6.8699775f, 6.505163f) + cubicTo(6.9086733f, 5.7893324f, 7.0363626f, 5.581762f, 7.4145985f, 5.58134f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.5314286f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_9 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(9.388312f, 7.621363f) + lineTo(8.585783f, 25.491693f) + cubicTo(19.63042f, 23.091063f, 24.007246f, 14.999494f, 37.739815f, 12.344943f) + lineTo(37.578342f, 7.687427f) + lineTo(9.388312f, 7.621363f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(252, 252, 255, 0), start = Offset(19.505947f, 3.0251684f), end = Offset(26.577011f, 25.491693f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.3312369585037231f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6584489941596985f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-5.91933012008667f, 5.728866100311279f, 0.0f, 1.0f) +))}){ +// _0_0_10 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(35.620502f, 3.9384086f) + cubicTo(35.62185f, 4.2392945f, 35.4621f, 4.5179024f, 35.201748f, 4.668735f) + cubicTo(34.941395f, 4.8195677f, 34.620235f, 4.8195677f, 34.359882f, 4.668735f) + cubicTo(34.09953f, 4.5179024f, 33.93978f, 4.2392945f, 33.941128f, 3.9384086f) + cubicTo(33.93978f, 3.6375227f, 34.09953f, 3.358915f, 34.359882f, 3.2080822f) + cubicTo(34.620235f, 3.0572495f, 34.941395f, 3.0572495f, 35.201748f, 3.2080822f) + cubicTo(35.4621f, 3.358915f, 35.62185f, 3.6375227f, 35.620502f, 3.9384086f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(144, 144, 144, 255), 1.0f to Color(190, 190, 190, 0), start = Offset(34.30099f, 3.9384086f), end = Offset(35.520542f, 3.8451097f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.3312369585037231f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6584489941596985f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-5.805729866027832f, 7.834650039672852f, 0.0f, 1.0f) +))}){ +// _0_0_11 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(35.620502f, 3.9384086f) + cubicTo(35.62185f, 4.2392945f, 35.4621f, 4.5179024f, 35.201748f, 4.668735f) + cubicTo(34.941395f, 4.8195677f, 34.620235f, 4.8195677f, 34.359882f, 4.668735f) + cubicTo(34.09953f, 4.5179024f, 33.93978f, 4.2392945f, 33.941128f, 3.9384086f) + cubicTo(33.93978f, 3.6375227f, 34.09953f, 3.358915f, 34.359882f, 3.2080822f) + cubicTo(34.620235f, 3.0572495f, 34.941395f, 3.0572495f, 35.201748f, 3.2080822f) + cubicTo(35.4621f, 3.358915f, 35.62185f, 3.6375227f, 35.620502f, 3.9384086f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(144, 144, 144, 255), 1.0f to Color(190, 190, 190, 0), start = Offset(34.30099f, 3.9384086f), end = Offset(35.520542f, 3.8451097f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.3312369585037231f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6584489941596985f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-5.692130088806152f, 9.834650039672852f, 0.0f, 1.0f) +))}){ +// _0_0_12 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(35.620502f, 3.9384086f) + cubicTo(35.62185f, 4.2392945f, 35.4621f, 4.5179024f, 35.201748f, 4.668735f) + cubicTo(34.941395f, 4.8195677f, 34.620235f, 4.8195677f, 34.359882f, 4.668735f) + cubicTo(34.09953f, 4.5179024f, 33.93978f, 4.2392945f, 33.941128f, 3.9384086f) + cubicTo(33.93978f, 3.6375227f, 34.09953f, 3.358915f, 34.359882f, 3.2080822f) + cubicTo(34.620235f, 3.0572495f, 34.941395f, 3.0572495f, 35.201748f, 3.2080822f) + cubicTo(35.4621f, 3.358915f, 35.62185f, 3.6375227f, 35.620502f, 3.9384086f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(144, 144, 144, 255), 1.0f to Color(190, 190, 190, 0), start = Offset(34.30099f, 3.9384086f), end = Offset(35.520542f, 3.8451097f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.3312369585037231f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6584489941596985f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-5.5785298347473145f, 11.834650039672852f, 0.0f, 1.0f) +))}){ +// _0_0_13 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(35.620502f, 3.9384086f) + cubicTo(35.62185f, 4.2392945f, 35.4621f, 4.5179024f, 35.201748f, 4.668735f) + cubicTo(34.941395f, 4.8195677f, 34.620235f, 4.8195677f, 34.359882f, 4.668735f) + cubicTo(34.09953f, 4.5179024f, 33.93978f, 4.2392945f, 33.941128f, 3.9384086f) + cubicTo(33.93978f, 3.6375227f, 34.09953f, 3.358915f, 34.359882f, 3.2080822f) + cubicTo(34.620235f, 3.0572495f, 34.941395f, 3.0572495f, 35.201748f, 3.2080822f) + cubicTo(35.4621f, 3.358915f, 35.62185f, 3.6375227f, 35.620502f, 3.9384086f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(144, 144, 144, 255), 1.0f to Color(190, 190, 190, 0), start = Offset(34.30099f, 3.9384086f), end = Offset(35.520542f, 3.8451097f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.3312369585037231f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6584489941596985f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-5.464930057525635f, 13.834650039672852f, 0.0f, 1.0f) +))}){ +// _0_0_14 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(35.620502f, 3.9384086f) + cubicTo(35.62185f, 4.2392945f, 35.4621f, 4.5179024f, 35.201748f, 4.668735f) + cubicTo(34.941395f, 4.8195677f, 34.620235f, 4.8195677f, 34.359882f, 4.668735f) + cubicTo(34.09953f, 4.5179024f, 33.93978f, 4.2392945f, 33.941128f, 3.9384086f) + cubicTo(33.93978f, 3.6375227f, 34.09953f, 3.358915f, 34.359882f, 3.2080822f) + cubicTo(34.620235f, 3.0572495f, 34.941395f, 3.0572495f, 35.201748f, 3.2080822f) + cubicTo(35.4621f, 3.358915f, 35.62185f, 3.6375227f, 35.620502f, 3.9384086f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(144, 144, 144, 255), 1.0f to Color(190, 190, 190, 0), start = Offset(34.30099f, 3.9384086f), end = Offset(35.520542f, 3.8451097f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_15 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(22.5f, 30.192665f) + lineTo(22.781715f, 30.192665f) + cubicTo(22.86548f, 30.192667f, 22.9297f, 30.21133f, 22.974377f, 30.248655f) + cubicTo(23.019344f, 30.28569f, 23.041828f, 30.338594f, 23.04183f, 30.40737f) + cubicTo(23.041828f, 30.47644f, 23.019344f, 30.529638f, 22.974377f, 30.566965f) + cubicTo(22.9297f, 30.603998f, 22.86548f, 30.622515f, 22.781715f, 30.622515f) + lineTo(22.669735f, 30.622515f) + lineTo(22.669735f, 30.850885f) + lineTo(22.5f, 30.850885f) + lineTo(22.5f, 30.192665f) + moveTo(22.669735f, 30.315668f) + lineTo(22.669735f, 30.499512f) + lineTo(22.76364f, 30.499512f) + cubicTo(22.796558f, 30.499512f, 22.821981f, 30.491575f, 22.83991f, 30.475704f) + cubicTo(22.85784f, 30.45954f, 22.866804f, 30.436762f, 22.866804f, 30.40737f) + cubicTo(22.866804f, 30.37798f, 22.85784f, 30.355349f, 22.83991f, 30.339476f) + cubicTo(22.821981f, 30.323605f, 22.796558f, 30.315668f, 22.76364f, 30.315668f) + lineTo(22.669735f, 30.315668f) + moveTo(23.461979f, 30.303764f) + cubicTo(23.41025f, 30.303766f, 23.37013f, 30.32287f, 23.341621f, 30.361078f) + cubicTo(23.313112f, 30.399288f, 23.298857f, 30.453074f, 23.298857f, 30.522436f) + cubicTo(23.298857f, 30.591507f, 23.313112f, 30.645145f, 23.341621f, 30.683355f) + cubicTo(23.37013f, 30.721563f, 23.41025f, 30.740667f, 23.461979f, 30.740667f) + cubicTo(23.514002f, 30.740667f, 23.554268f, 30.721563f, 23.582779f, 30.683355f) + cubicTo(23.611286f, 30.645145f, 23.625542f, 30.591507f, 23.625542f, 30.522436f) + cubicTo(23.625542f, 30.453074f, 23.611286f, 30.399288f, 23.582779f, 30.361078f) + cubicTo(23.554268f, 30.32287f, 23.514002f, 30.303766f, 23.461979f, 30.303764f) + moveTo(23.461979f, 30.180761f) + cubicTo(23.567787f, 30.180763f, 23.650671f, 30.211037f, 23.71063f, 30.271582f) + cubicTo(23.770588f, 30.332129f, 23.800568f, 30.415747f, 23.800568f, 30.522436f) + cubicTo(23.800568f, 30.628834f, 23.770588f, 30.712305f, 23.71063f, 30.772852f) + cubicTo(23.650671f, 30.833399f, 23.567787f, 30.86367f, 23.461979f, 30.86367f) + cubicTo(23.356464f, 30.86367f, 23.27358f, 30.833399f, 23.213327f, 30.772852f) + cubicTo(23.15337f, 30.712305f, 23.12339f, 30.628834f, 23.12339f, 30.522436f) + cubicTo(23.12339f, 30.415747f, 23.15337f, 30.332129f, 23.213327f, 30.271582f) + cubicTo(23.27358f, 30.211037f, 23.356464f, 30.180763f, 23.461979f, 30.180761f) + moveTo(23.92842f, 30.192665f) + lineTo(24.117994f, 30.192665f) + lineTo(24.357388f, 30.644117f) + lineTo(24.357388f, 30.192665f) + lineTo(24.518305f, 30.192665f) + lineTo(24.518305f, 30.850885f) + lineTo(24.32873f, 30.850885f) + lineTo(24.089338f, 30.399433f) + lineTo(24.089338f, 30.850885f) + lineTo(23.92842f, 30.850885f) + lineTo(23.92842f, 30.192665f) + moveTo(24.59149f, 30.192665f) + lineTo(24.777096f, 30.192665f) + lineTo(24.92699f, 30.42721f) + lineTo(25.076887f, 30.192665f) + lineTo(25.262936f, 30.192665f) + lineTo(25.01208f, 30.573578f) + lineTo(25.01208f, 30.850885f) + lineTo(24.842344f, 30.850885f) + lineTo(24.842344f, 30.573578f) + lineTo(24.59149f, 30.192665f) +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(74, 74, 74, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_16 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(32.80312f, 13.315819f) + cubicTo(34.47257f, 20.995363f, 29.513748f, 25.45455f, 21.3557f, 20.989296f) + cubicTo(21.982796f, 23.339367f, 23.622335f, 25.369877f, 26.108051f, 26.170364f) + cubicTo(29.996363f, 27.422537f, 34.167355f, 25.283571f, 35.41953f, 21.395262f) + cubicTo(36.407272f, 18.32807f, 35.229874f, 15.16364f, 32.80312f, 13.315819f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(252, 233, 79, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(237, 212, 0, 255)) +stroke = Stroke(width=0.9999996f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(32.80312f, 13.315819f) + cubicTo(34.47257f, 20.995363f, 29.513748f, 25.45455f, 21.3557f, 20.989296f) + cubicTo(21.982796f, 23.339367f, 23.622335f, 25.369877f, 26.108051f, 26.170364f) + cubicTo(29.996363f, 27.422537f, 34.167355f, 25.283571f, 35.41953f, 21.395262f) + cubicTo(36.407272f, 18.32807f, 35.229874f, 15.16364f, 32.80312f, 13.315819f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_17 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-2.4748740196228027f, -2.3864850997924805f, 0.0f, 1.0f) +))}){ +// _0_0_17_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.854446f, 13.970486f) + cubicTo(17.857279f, 14.603931f, 17.520966f, 15.1904745f, 16.972853f, 15.5080185f) + cubicTo(16.42474f, 15.825562f, 15.748619f, 15.825562f, 15.200506f, 15.5080185f) + cubicTo(14.652394f, 15.1904745f, 14.316081f, 14.603931f, 14.318913f, 13.970486f) + cubicTo(14.316081f, 13.33704f, 14.652394f, 12.750497f, 15.200506f, 12.432953f) + cubicTo(15.748619f, 12.11541f, 16.42474f, 12.11541f, 16.972853f, 12.432953f) + cubicTo(17.520966f, 12.750497f, 17.857279f, 13.33704f, 17.854446f, 13.970486f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(254, 233, 100, 255), 1.0f to Color(254, 233, 100, 0), center = Offset(16.08668f, 13.970486f), radius = 1.767767f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_17_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(16.970564f, 11.584001f) + lineTo(13.930592f, 11.85101f) + lineTo(13.611806f, 14.942758f) + lineTo(13.344797f, 11.902786f) + lineTo(10.253049f, 11.584001f) + lineTo(13.29302f, 11.316992f) + lineTo(13.611806f, 8.225244f) + lineTo(13.878815f, 11.265215f) + lineTo(16.970564f, 11.584001f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), center = Offset(13.611812f, 11.5840025f), radius = 3.6239214f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.6315789818763733f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6315789818763733f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +12.969829559326172f, 3.737459897994995f, 0.0f, 1.0f) +))}){ +// _0_0_18 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-2.4748740196228027f, -2.3864850997924805f, 0.0f, 1.0f) +))}){ +// _0_0_18_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.854446f, 13.970486f) + cubicTo(17.857279f, 14.603931f, 17.520966f, 15.1904745f, 16.972853f, 15.5080185f) + cubicTo(16.42474f, 15.825562f, 15.748619f, 15.825562f, 15.200506f, 15.5080185f) + cubicTo(14.652394f, 15.1904745f, 14.316081f, 14.603931f, 14.318913f, 13.970486f) + cubicTo(14.316081f, 13.33704f, 14.652394f, 12.750497f, 15.200506f, 12.432953f) + cubicTo(15.748619f, 12.11541f, 16.42474f, 12.11541f, 16.972853f, 12.432953f) + cubicTo(17.520966f, 12.750497f, 17.857279f, 13.33704f, 17.854446f, 13.970486f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(254, 233, 100, 255), 1.0f to Color(254, 233, 100, 0), center = Offset(16.08668f, 13.970486f), radius = 1.767767f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_18_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(16.970564f, 11.584001f) + lineTo(13.930592f, 11.85101f) + lineTo(13.611806f, 14.942758f) + lineTo(13.344797f, 11.902786f) + lineTo(10.253049f, 11.584001f) + lineTo(13.29302f, 11.316992f) + lineTo(13.611806f, 8.225244f) + lineTo(13.878815f, 11.265215f) + lineTo(16.970564f, 11.584001f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), center = Offset(13.611812f, 11.5840025f), radius = 3.6239214f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.6315789818763733f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6315789818763733f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +9.611074447631836f, 9.83625602722168f, 0.0f, 1.0f) +))}){ +// _0_0_19 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-2.4748740196228027f, -2.3864850997924805f, 0.0f, 1.0f) +))}){ +// _0_0_19_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.854446f, 13.970486f) + cubicTo(17.857279f, 14.603931f, 17.520966f, 15.1904745f, 16.972853f, 15.5080185f) + cubicTo(16.42474f, 15.825562f, 15.748619f, 15.825562f, 15.200506f, 15.5080185f) + cubicTo(14.652394f, 15.1904745f, 14.316081f, 14.603931f, 14.318913f, 13.970486f) + cubicTo(14.316081f, 13.33704f, 14.652394f, 12.750497f, 15.200506f, 12.432953f) + cubicTo(15.748619f, 12.11541f, 16.42474f, 12.11541f, 16.972853f, 12.432953f) + cubicTo(17.520966f, 12.750497f, 17.857279f, 13.33704f, 17.854446f, 13.970486f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(254, 233, 100, 255), 1.0f to Color(254, 233, 100, 0), center = Offset(16.08668f, 13.970486f), radius = 1.767767f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_19_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(16.970564f, 11.584001f) + lineTo(13.930592f, 11.85101f) + lineTo(13.611806f, 14.942758f) + lineTo(13.344797f, 11.902786f) + lineTo(10.253049f, 11.584001f) + lineTo(13.29302f, 11.316992f) + lineTo(13.611806f, 8.225244f) + lineTo(13.878815f, 11.265215f) + lineTo(16.970564f, 11.584001f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), center = Offset(13.611812f, 11.5840025f), radius = 3.6239214f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +0.6315789818763733f, 0.0f, 0.0f, 0.0f, +0.0f, 0.6315789818763733f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +4.484549045562744f, 11.515629768371582f, 0.0f, 1.0f) +))}){ +// _0_0_20 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-2.4748740196228027f, -2.3864850997924805f, 0.0f, 1.0f) +))}){ +// _0_0_20_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(17.854446f, 13.970486f) + cubicTo(17.857279f, 14.603931f, 17.520966f, 15.1904745f, 16.972853f, 15.5080185f) + cubicTo(16.42474f, 15.825562f, 15.748619f, 15.825562f, 15.200506f, 15.5080185f) + cubicTo(14.652394f, 15.1904745f, 14.316081f, 14.603931f, 14.318913f, 13.970486f) + cubicTo(14.316081f, 13.33704f, 14.652394f, 12.750497f, 15.200506f, 12.432953f) + cubicTo(15.748619f, 12.11541f, 16.42474f, 12.11541f, 16.972853f, 12.432953f) + cubicTo(17.520966f, 12.750497f, 17.857279f, 13.33704f, 17.854446f, 13.970486f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(254, 233, 100, 255), 1.0f to Color(254, 233, 100, 0), center = Offset(16.08668f, 13.970486f), radius = 1.767767f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_20_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(16.970564f, 11.584001f) + lineTo(13.930592f, 11.85101f) + lineTo(13.611806f, 14.942758f) + lineTo(13.344797f, 11.902786f) + lineTo(10.253049f, 11.584001f) + lineTo(13.29302f, 11.316992f) + lineTo(13.611806f, 8.225244f) + lineTo(13.878815f, 11.265215f) + lineTo(16.970564f, 11.584001f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), center = Offset(13.611812f, 11.5840025f), radius = 3.6239214f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) + +} +} + + + + private fun innerPaint(drawScope: DrawScope) { + _paint0(drawScope) + + + shape = null + generalPath = null + brush = null + stroke = null + clip = null + alpha = 1.0f + } + + companion object { + /** + * Returns the X of the bounding box of the original SVG image. + * + * @return The X of the bounding box of the original SVG image. + */ + fun getOrigX(): Double { + return 4.079588413238525 + } + + /** + * Returns the Y of the bounding box of the original SVG image. + * + * @return The Y of the bounding box of the original SVG image. + */ + fun getOrigY(): Double { + return 4.070621967315674 + } + + /** + * Returns the width of the bounding box of the original SVG image. + * + * @return The width of the bounding box of the original SVG image. + */ + fun getOrigWidth(): Double { + return 40.660064697265625 + } + + /** + * Returns the height of the bounding box of the original SVG image. + * + * @return The height of the bounding box of the original SVG image. + */ + fun getOrigHeight(): Double { + return 42.21737289428711 + } + + + } + + override val intrinsicSize: Size + get() = Size.Unspecified + + override fun DrawScope.onDraw() { + clipRect { + // Use the original icon bounding box and the current icon dimension to compute + // the scaling factor + val fullOrigWidth = getOrigX() + getOrigWidth() + val fullOrigHeight = getOrigY() + getOrigHeight() + val coef1 = size.width / fullOrigWidth + val coef2 = size.height / fullOrigHeight + val coef = min(coef1, coef2).toFloat() + + // Use the original icon bounding box and the current icon dimension to compute + // the offset pivot for the scaling + var translateX = -getOrigX() + var translateY = -getOrigY() + if (coef1 != coef2) { + if (coef1 < coef2) { + val extraDy = ((fullOrigWidth - fullOrigHeight) / 2.0f).toFloat() + translateY += extraDy + } else { + val extraDx = ((fullOrigHeight - fullOrigWidth) / 2.0f).toFloat() + translateX += extraDx + } + } + val translateXDp = translateX.toFloat().toDp().value + val translateYDp = translateY.toFloat().toDp().value + + // Create a combined scale + translate + clip transform before calling the transcoded painting instructions + withTransform({ + scale(scaleX = coef, scaleY = coef, pivot = Offset.Zero) + translate(translateXDp, translateYDp) + clipRect(left = 0.0f, top = 0.0f, right = fullOrigWidth.toFloat(), bottom = fullOrigHeight.toFloat(), clipOp = ClipOp.Intersect) + }) { + innerPaint(this) + } + } + } +} + diff --git a/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_theme.kt b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_theme.kt new file mode 100644 index 00000000..cd11a5da --- /dev/null +++ b/demo/src/desktopMain/kotlin/org/pushingpixels/aurora/demo/svg/tango/preferences_desktop_theme.kt @@ -0,0 +1,1558 @@ +package org.pushingpixels.aurora.demo.svg.tango + +import androidx.compose.ui.geometry.* +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Fill +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.clipRect +import androidx.compose.ui.graphics.drawscope.translate +import androidx.compose.ui.graphics.drawscope.withTransform +import androidx.compose.ui.graphics.painter.Painter +import java.lang.ref.WeakReference +import java.util.* +import kotlin.math.min + +/** + * This class has been automatically generated using + * Aurora SVG transcoder. + */ +class preferences_desktop_theme : Painter() { + @Suppress("UNUSED_VARIABLE") private var shape: Outline? = null + @Suppress("UNUSED_VARIABLE") private var generalPath: Path? = null + @Suppress("UNUSED_VARIABLE") private var brush: Brush? = null + @Suppress("UNUSED_VARIABLE") private var stroke: Stroke? = null + @Suppress("UNUSED_VARIABLE") private var clip: Shape? = null + private var alpha = 1.0f + private var blendMode = DrawScope.DefaultBlendMode + private var alphaStack = mutableListOf(1.0f) + private var blendModeStack = mutableListOf(DrawScope.DefaultBlendMode) + + @Suppress("UNUSED_VARIABLE", "UNUSED_VALUE", "VARIABLE_WITH_REDUNDANT_INITIALIZER", "UNNECESSARY_NOT_NULL_ASSERTION") +private fun _paint0(drawScope : DrawScope) { +var shapeText: Outline? +var generalPathText: Path? = null +var alphaText = 0.0f +var blendModeText = DrawScope.DefaultBlendMode +with(drawScope) { +// +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0 +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0 +alphaStack.add(0, alpha) +alpha *= 0.54385966f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.232558012008667f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +12.041410446166992f, -9.914664268493652f, 0.0f, 1.0f) +))}){ +// _0_0_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(26.516504f, 39.249554f) + cubicTo(26.53173f, 40.959858f, 24.724045f, 42.543526f, 21.777939f, 43.40089f) + cubicTo(18.831835f, 44.25826f, 15.19768f, 44.25826f, 12.2515745f, 43.40089f) + cubicTo(9.305469f, 42.543526f, 7.497783f, 40.959858f, 7.51301f, 39.249554f) + cubicTo(7.497783f, 37.53925f, 9.305469f, 35.95558f, 12.2515745f, 35.098217f) + cubicTo(15.19768f, 34.24085f, 18.831835f, 34.24085f, 21.777939f, 35.098217f) + cubicTo(24.724045f, 35.95558f, 26.53173f, 37.53925f, 26.516504f, 39.249554f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(17.014757f, 39.249573f), radius = 9.501747f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(31.205997f, 5.2048745f) + lineTo(34.908493f, 5.2048745f) + cubicTo(39.19495f, 5.2048745f, 44.455605f, 6.5223904f, 44.455605f, 7.0610294f) + lineTo(44.455605f, 29.688444f) + cubicTo(44.455605f, 30.227083f, 44.018726f, 30.660715f, 43.476055f, 30.660715f) + lineTo(22.638435f, 30.660715f) + cubicTo(22.095766f, 30.660715f, 21.65889f, 30.227083f, 21.65889f, 29.688444f) + lineTo(21.65889f, 7.0610294f) + cubicTo(21.65889f, 6.5223904f, 26.830568f, 5.2048745f, 31.205997f, 5.2048745f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(214, 214, 214, 255), 1.0f to Color(240, 240, 240, 255), start = Offset(30.881643f, 17.932793f), end = Offset(29.399292f, 10.154616f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0000001f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(31.205997f, 5.2048745f) + lineTo(34.908493f, 5.2048745f) + cubicTo(39.19495f, 5.2048745f, 44.455605f, 6.5223904f, 44.455605f, 7.0610294f) + lineTo(44.455605f, 29.688444f) + cubicTo(44.455605f, 30.227083f, 44.018726f, 30.660715f, 43.476055f, 30.660715f) + lineTo(22.638435f, 30.660715f) + cubicTo(22.095766f, 30.660715f, 21.65889f, 30.227083f, 21.65889f, 29.688444f) + lineTo(21.65889f, 7.0610294f) + cubicTo(21.65889f, 6.5223904f, 26.830568f, 5.2048745f, 31.205997f, 5.2048745f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.61988306f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_2 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Round, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(31.363447f, 6.0663853f) + lineTo(34.751057f, 6.0663853f) + cubicTo(38.672962f, 6.0663853f, 43.486214f, 7.5879025f, 43.486214f, 7.5879025f) + lineTo(43.486214f, 29.657421f) + cubicTo(43.486214f, 29.657421f, 22.62829f, 29.657421f, 22.62829f, 29.657421f) + lineTo(22.62829f, 7.5879025f) + cubicTo(22.62829f, 7.5879025f, 27.360134f, 6.0663853f, 31.363447f, 6.0663853f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_3 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.410797f, 10.508173f) + lineTo(30.405594f, 17.314075f) + lineTo(30.405594f, 29.600058f) + lineTo(33.587574f, 32.428486f) + lineTo(36.50439f, 29.600058f) + lineTo(36.50439f, 17.1373f) + lineTo(33.410797f, 10.508173f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(176, 176, 176, 255), 1.0f to Color(147, 147, 147, 255), start = Offset(32.93856f, 17.93842f), end = Offset(32.93856f, 14.220481f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.410797f, 10.508173f) + lineTo(30.405594f, 17.314075f) + lineTo(30.405594f, 29.600058f) + lineTo(33.587574f, 32.428486f) + lineTo(36.50439f, 29.600058f) + lineTo(36.50439f, 17.1373f) + lineTo(33.410797f, 10.508173f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.46783626f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_4 +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(33.455025f, 27.747002f), end = Offset(33.455025f, 17.31718f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.99999976f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.4229f, 13.510439f) + lineTo(31.417679f, 17.9217f) + lineTo(31.417679f, 28.969769f) + lineTo(33.551254f, 31.023417f) + lineTo(35.492302f, 28.969769f) + lineTo(35.492302f, 17.793346f) + lineTo(33.4229f, 13.510439f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +15.114439964294434f, -11.15211009979248f, 0.0f, 1.0f) +))}){ +// _0_0_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.506096f, 23.251263f) + cubicTo(20.50985f, 23.948053f, 20.064234f, 24.59325f, 19.337984f, 24.942549f) + cubicTo(18.611736f, 25.291845f, 17.715874f, 25.291845f, 16.989626f, 24.942549f) + cubicTo(16.263376f, 24.59325f, 15.81776f, 23.948053f, 15.821514f, 23.251263f) + cubicTo(15.81776f, 22.554472f, 16.263376f, 21.909275f, 16.989626f, 21.559977f) + cubicTo(17.715874f, 21.21068f, 18.611736f, 21.21068f, 19.337984f, 21.559977f) + cubicTo(20.064234f, 21.909275f, 20.50985f, 22.554472f, 20.506096f, 23.251263f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(176, 176, 176, 255), 1.0f to Color(117, 117, 117, 255), center = Offset(18.163805f, 22.632545f), radius = 2.8422909f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.506096f, 23.251263f) + cubicTo(20.50985f, 23.948053f, 20.064234f, 24.59325f, 19.337984f, 24.942549f) + cubicTo(18.611736f, 25.291845f, 17.715874f, 25.291845f, 16.989626f, 24.942549f) + cubicTo(16.263376f, 24.59325f, 15.81776f, 23.948053f, 15.821514f, 23.251263f) + cubicTo(15.81776f, 22.554472f, 16.263376f, 21.909275f, 16.989626f, 21.559977f) + cubicTo(17.715874f, 21.21068f, 18.611736f, 21.21068f, 19.337984f, 21.559977f) + cubicTo(20.064234f, 21.909275f, 20.50985f, 22.554472f, 20.506096f, 23.251263f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.057243f, 10.331398f) + lineTo(28.01911f, 14.132097f) + cubicTo(28.01911f, 14.132097f, 26.162954f, 8.565209f, 26.162954f, 6.0887585f) + cubicTo(26.162954f, 3.6138842f, 27.48878f, 2.6416132f, 28.902992f, 2.6416132f) + cubicTo(28.902992f, 2.6416132f, 37.299885f, 2.6416132f, 37.299885f, 2.6416132f) + cubicTo(38.256462f, 2.6416132f, 39.92944f, 3.0393603f, 40.12831f, 5.9119825f) + cubicTo(40.327187f, 8.784603f, 38.095383f, 14.132097f, 38.095383f, 14.132097f) + lineTo(33.057243f, 10.331398f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(240, 240, 240, 255), 1.0f to Color(201, 201, 201, 255), center = Offset(28.909271f, 3.9674196f), radius = 13.500519f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.057243f, 10.331398f) + lineTo(28.01911f, 14.132097f) + cubicTo(28.01911f, 14.132097f, 26.162954f, 8.565209f, 26.162954f, 6.0887585f) + cubicTo(26.162954f, 3.6138842f, 27.48878f, 2.6416132f, 28.902992f, 2.6416132f) + cubicTo(28.902992f, 2.6416132f, 37.299885f, 2.6416132f, 37.299885f, 2.6416132f) + cubicTo(38.256462f, 2.6416132f, 39.92944f, 3.0393603f, 40.12831f, 5.9119825f) + cubicTo(40.327187f, 8.784603f, 38.095383f, 14.132097f, 38.095383f, 14.132097f) + lineTo(33.057243f, 10.331398f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_7 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(29.915115f, 5.0280943f) + cubicTo(29.915115f, 5.0280943f, 28.099472f, 5.5160723f, 28.41988f, 6.687217f) + cubicTo(28.740288f, 7.8583636f, 31.196747f, 9.712676f, 31.196747f, 9.712676f) + lineTo(35.789257f, 9.712676f) + cubicTo(35.789257f, 9.712676f, 37.89861f, 8.15115f, 38.138916f, 6.9800043f) + cubicTo(38.379223f, 5.8088584f, 36.75048f, 5.0280943f, 36.75048f, 5.0280943f) + lineTo(29.915115f, 5.0280943f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_8 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(29.73834f, 4.055826f) + cubicTo(29.73834f, 4.055826f, 27.922695f, 4.543804f, 28.243105f, 5.714949f) + cubicTo(28.56351f, 6.8860955f, 31.019972f, 8.740409f, 31.019972f, 8.740409f) + lineTo(35.61248f, 8.740409f) + cubicTo(35.61248f, 8.740409f, 37.721832f, 7.178881f, 37.96214f, 6.007736f) + cubicTo(38.202446f, 4.8365903f, 36.573704f, 4.055826f, 36.573704f, 4.055826f) + lineTo(29.73834f, 4.055826f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(139, 139, 139, 255), 1.0f to Color(169, 169, 169, 255), center = Offset(33.095787f, 8.350008f), radius = 5.4947357f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.14035088f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.232558012008667f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +12.041410446166992f, -9.914664268493652f, 0.0f, 1.0f) +))}){ +// _0_0_9 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(26.516504f, 39.249554f) + cubicTo(26.53173f, 40.959858f, 24.724045f, 42.543526f, 21.777939f, 43.40089f) + cubicTo(18.831835f, 44.25826f, 15.19768f, 44.25826f, 12.2515745f, 43.40089f) + cubicTo(9.305469f, 42.543526f, 7.497783f, 40.959858f, 7.51301f, 39.249554f) + cubicTo(7.497783f, 37.53925f, 9.305469f, 35.95558f, 12.2515745f, 35.098217f) + cubicTo(15.19768f, 34.24085f, 18.831835f, 34.24085f, 21.777939f, 35.098217f) + cubicTo(24.724045f, 35.95558f, 26.53173f, 37.53925f, 26.516504f, 39.249554f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(17.014757f, 39.249573f), radius = 9.501747f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_10 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(31.205997f, 5.2048745f) + lineTo(34.908493f, 5.2048745f) + cubicTo(39.19495f, 5.2048745f, 44.455605f, 6.5223904f, 44.455605f, 7.0610294f) + lineTo(44.455605f, 29.688444f) + cubicTo(44.455605f, 30.227083f, 44.018726f, 30.660715f, 43.476055f, 30.660715f) + lineTo(22.638435f, 30.660715f) + cubicTo(22.095766f, 30.660715f, 21.65889f, 30.227083f, 21.65889f, 29.688444f) + lineTo(21.65889f, 7.0610294f) + cubicTo(21.65889f, 6.5223904f, 26.830568f, 5.2048745f, 31.205997f, 5.2048745f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(80, 121, 173, 255), 1.0f to Color(114, 159, 207, 255), start = Offset(30.881643f, 17.932793f), end = Offset(29.399292f, 10.154616f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(52, 101, 164, 255)) +stroke = Stroke(width=1.0000001f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(31.205997f, 5.2048745f) + lineTo(34.908493f, 5.2048745f) + cubicTo(39.19495f, 5.2048745f, 44.455605f, 6.5223904f, 44.455605f, 7.0610294f) + lineTo(44.455605f, 29.688444f) + cubicTo(44.455605f, 30.227083f, 44.018726f, 30.660715f, 43.476055f, 30.660715f) + lineTo(22.638435f, 30.660715f) + cubicTo(22.095766f, 30.660715f, 21.65889f, 30.227083f, 21.65889f, 29.688444f) + lineTo(21.65889f, 7.0610294f) + cubicTo(21.65889f, 6.5223904f, 26.830568f, 5.2048745f, 31.205997f, 5.2048745f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.26315793f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_11 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Round, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(31.363447f, 6.0663853f) + lineTo(34.751057f, 6.0663853f) + cubicTo(38.672962f, 6.0663853f, 43.486214f, 7.5879025f, 43.486214f, 7.5879025f) + lineTo(43.486214f, 29.657421f) + cubicTo(43.486214f, 29.657421f, 22.62829f, 29.657421f, 22.62829f, 29.657421f) + lineTo(22.62829f, 7.5879025f) + cubicTo(22.62829f, 7.5879025f, 27.360134f, 6.0663853f, 31.363447f, 6.0663853f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_12 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.410797f, 10.508173f) + cubicTo(33.410797f, 10.508173f, 30.405594f, 15.439076f, 30.405594f, 17.314075f) + lineTo(30.405594f, 29.600058f) + lineTo(33.587574f, 32.428486f) + lineTo(36.50439f, 29.600058f) + lineTo(36.50439f, 17.1373f) + cubicTo(36.50439f, 15.3873f, 33.410797f, 10.508173f, 33.410797f, 10.508173f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(117, 80, 123, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(92, 53, 102, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.410797f, 10.508173f) + cubicTo(33.410797f, 10.508173f, 30.405594f, 15.439076f, 30.405594f, 17.314075f) + lineTo(30.405594f, 29.600058f) + lineTo(33.587574f, 32.428486f) + lineTo(36.50439f, 29.600058f) + lineTo(36.50439f, 17.1373f) + cubicTo(36.50439f, 15.3873f, 33.410797f, 10.508173f, 33.410797f, 10.508173f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.25146198f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_13 +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(33.455025f, 27.747002f), end = Offset(33.455025f, 17.31718f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.99999976f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.4229f, 13.510439f) + lineTo(31.417679f, 17.9217f) + lineTo(31.417679f, 28.969769f) + lineTo(33.551254f, 31.023417f) + lineTo(35.492302f, 28.969769f) + lineTo(35.492302f, 17.793346f) + lineTo(33.4229f, 13.510439f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +15.114439964294434f, -11.15211009979248f, 0.0f, 1.0f) +))}){ +// _0_0_14 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.506096f, 23.251263f) + cubicTo(20.50985f, 23.948053f, 20.064234f, 24.59325f, 19.337984f, 24.942549f) + cubicTo(18.611736f, 25.291845f, 17.715874f, 25.291845f, 16.989626f, 24.942549f) + cubicTo(16.263376f, 24.59325f, 15.81776f, 23.948053f, 15.821514f, 23.251263f) + cubicTo(15.81776f, 22.554472f, 16.263376f, 21.909275f, 16.989626f, 21.559977f) + cubicTo(17.715874f, 21.21068f, 18.611736f, 21.21068f, 19.337984f, 21.559977f) + cubicTo(20.064234f, 21.909275f, 20.50985f, 22.554472f, 20.506096f, 23.251263f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(117, 80, 123, 255), 1.0f to Color(84, 57, 88, 255), center = Offset(18.1638f, 22.544163f), radius = 5.317898f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(92, 53, 102, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.506096f, 23.251263f) + cubicTo(20.50985f, 23.948053f, 20.064234f, 24.59325f, 19.337984f, 24.942549f) + cubicTo(18.611736f, 25.291845f, 17.715874f, 25.291845f, 16.989626f, 24.942549f) + cubicTo(16.263376f, 24.59325f, 15.81776f, 23.948053f, 15.821514f, 23.251263f) + cubicTo(15.81776f, 22.554472f, 16.263376f, 21.909275f, 16.989626f, 21.559977f) + cubicTo(17.715874f, 21.21068f, 18.611736f, 21.21068f, 19.337984f, 21.559977f) + cubicTo(20.064234f, 21.909275f, 20.50985f, 22.554472f, 20.506096f, 23.251263f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_15 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.057243f, 10.331398f) + lineTo(28.01911f, 14.132097f) + cubicTo(28.01911f, 14.132097f, 26.162954f, 8.565209f, 26.162954f, 6.0887585f) + cubicTo(26.162954f, 3.6138842f, 27.48878f, 2.6416132f, 28.902992f, 2.6416132f) + cubicTo(28.902992f, 2.6416132f, 37.299885f, 2.6416132f, 37.299885f, 2.6416132f) + cubicTo(38.256462f, 2.6416132f, 39.92944f, 3.0393603f, 40.12831f, 5.9119825f) + cubicTo(40.327187f, 8.784603f, 38.095383f, 14.132097f, 38.095383f, 14.132097f) + lineTo(33.057243f, 10.331398f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(200, 213, 230, 255), 1.0f to Color(66, 126, 191, 255), center = Offset(29.969925f, 4.4977713f), radius = 7.488949f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(52, 101, 164, 255)) +stroke = Stroke(width=1.0000001f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.057243f, 10.331398f) + lineTo(28.01911f, 14.132097f) + cubicTo(28.01911f, 14.132097f, 26.162954f, 8.565209f, 26.162954f, 6.0887585f) + cubicTo(26.162954f, 3.6138842f, 27.48878f, 2.6416132f, 28.902992f, 2.6416132f) + cubicTo(28.902992f, 2.6416132f, 37.299885f, 2.6416132f, 37.299885f, 2.6416132f) + cubicTo(38.256462f, 2.6416132f, 39.92944f, 3.0393603f, 40.12831f, 5.9119825f) + cubicTo(40.327187f, 8.784603f, 38.095383f, 14.132097f, 38.095383f, 14.132097f) + lineTo(33.057243f, 10.331398f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.33333334f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_16 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(29.915115f, 5.0280943f) + cubicTo(29.915115f, 5.0280943f, 28.099472f, 5.5160723f, 28.41988f, 6.687217f) + cubicTo(28.740288f, 7.8583636f, 30.696747f, 9.712676f, 31.196747f, 9.712676f) + lineTo(35.789257f, 9.712676f) + cubicTo(36.539257f, 9.650176f, 37.89861f, 8.15115f, 38.138916f, 6.9800043f) + cubicTo(38.379223f, 5.8088584f, 36.75048f, 5.0280943f, 36.75048f, 5.0280943f) + lineTo(29.915115f, 5.0280943f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_17 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(29.73834f, 4.055826f) + cubicTo(29.23834f, 4.055826f, 27.922695f, 4.543804f, 28.243105f, 5.714949f) + cubicTo(28.56351f, 6.8860955f, 30.14274f, 8.740409f, 31.019972f, 8.740409f) + lineTo(35.61248f, 8.740409f) + cubicTo(36.30282f, 8.740409f, 37.721832f, 7.178881f, 37.96214f, 6.007736f) + cubicTo(38.202446f, 4.8365903f, 37.073704f, 4.055826f, 36.573704f, 4.055826f) + lineTo(29.73834f, 4.055826f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(32, 74, 135, 255), 1.0f to Color(20, 46, 85, 255), center = Offset(33.095787f, 8.740406f), radius = 10.427078f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.28654972f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_18 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(33.145634f, 9.68365f) + lineTo(37.83022f, 13.219183f) + lineTo(39.067654f, 9.772038f) + lineTo(37.565052f, 12.246911f) + lineTo(33.145634f, 9.68365f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(33.76435f, 12.7330475f), end = Offset(33.76435f, 8.75459f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.28654972f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_0_19 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(32.79208f, 9.860426f) + lineTo(28.372663f, 13.219183f) + lineTo(26.870062f, 6.5900598f) + lineTo(28.902992f, 11.981746f) + lineTo(32.79208f, 9.860426f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(33.76435f, 12.7330475f), end = Offset(33.76435f, 8.75459f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1 +alphaStack.add(0, alpha) +alpha *= 0.54385966f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.232558012008667f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-6.0782389640808105f, 3.005204916000366f, 0.0f, 1.0f) +))}){ +// _0_1_0 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(26.516504f, 39.249554f) + cubicTo(26.53173f, 40.959858f, 24.724045f, 42.543526f, 21.777939f, 43.40089f) + cubicTo(18.831835f, 44.25826f, 15.19768f, 44.25826f, 12.2515745f, 43.40089f) + cubicTo(9.305469f, 42.543526f, 7.497783f, 40.959858f, 7.51301f, 39.249554f) + cubicTo(7.497783f, 37.53925f, 9.305469f, 35.95558f, 12.2515745f, 35.098217f) + cubicTo(15.19768f, 34.24085f, 18.831835f, 34.24085f, 21.777939f, 35.098217f) + cubicTo(24.724045f, 35.95558f, 26.53173f, 37.53925f, 26.516504f, 39.249554f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(17.014757f, 39.249573f), radius = 9.501747f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_1 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(13.086385f, 18.12474f) + lineTo(16.78888f, 18.12474f) + cubicTo(21.075336f, 18.12474f, 26.33599f, 19.442257f, 26.33599f, 19.980894f) + lineTo(26.33599f, 42.60831f) + cubicTo(26.33599f, 43.14695f, 25.899113f, 43.58058f, 25.356443f, 43.58058f) + lineTo(4.5188212f, 43.58058f) + cubicTo(3.9761531f, 43.58058f, 3.5392747f, 43.14695f, 3.5392747f, 42.60831f) + lineTo(3.5392747f, 19.980894f) + cubicTo(3.5392747f, 19.442257f, 8.710954f, 18.12474f, 13.086385f, 18.12474f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(214, 214, 214, 255), 1.0f to Color(240, 240, 240, 255), start = Offset(12.761994f, 30.852661f), end = Offset(11.279642f, 23.074486f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0000001f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(13.086385f, 18.12474f) + lineTo(16.78888f, 18.12474f) + cubicTo(21.075336f, 18.12474f, 26.33599f, 19.442257f, 26.33599f, 19.980894f) + lineTo(26.33599f, 42.60831f) + cubicTo(26.33599f, 43.14695f, 25.899113f, 43.58058f, 25.356443f, 43.58058f) + lineTo(4.5188212f, 43.58058f) + cubicTo(3.9761531f, 43.58058f, 3.5392747f, 43.14695f, 3.5392747f, 42.60831f) + lineTo(3.5392747f, 19.980894f) + cubicTo(3.5392747f, 19.442257f, 8.710954f, 18.12474f, 13.086385f, 18.12474f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.61988306f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_2 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Round, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(13.243834f, 18.986252f) + lineTo(16.631443f, 18.986252f) + cubicTo(20.55335f, 18.986252f, 25.3666f, 20.507769f, 25.3666f, 20.507769f) + lineTo(25.3666f, 42.57729f) + cubicTo(25.3666f, 42.57729f, 4.508677f, 42.57729f, 4.508677f, 42.57729f) + lineTo(4.508677f, 20.507769f) + cubicTo(4.508677f, 20.507769f, 9.2405205f, 18.986252f, 13.243834f, 18.986252f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_3 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(15.291184f, 23.42804f) + lineTo(12.285981f, 30.233944f) + lineTo(12.285981f, 42.519924f) + lineTo(15.467961f, 45.34835f) + lineTo(18.384777f, 42.519924f) + lineTo(18.384777f, 30.057167f) + lineTo(15.291184f, 23.42804f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(176, 176, 176, 255), 1.0f to Color(147, 147, 147, 255), start = Offset(14.8189125f, 30.85829f), end = Offset(14.8189125f, 27.14035f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(15.291184f, 23.42804f) + lineTo(12.285981f, 30.233944f) + lineTo(12.285981f, 42.519924f) + lineTo(15.467961f, 45.34835f) + lineTo(18.384777f, 42.519924f) + lineTo(18.384777f, 30.057167f) + lineTo(15.291184f, 23.42804f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.46783626f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_4 +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(15.335377f, 40.66687f), end = Offset(15.335377f, 30.23705f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.99999976f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(15.303288f, 26.430305f) + lineTo(13.298065f, 30.841566f) + lineTo(13.298065f, 41.889637f) + lineTo(15.431641f, 43.943283f) + lineTo(17.372688f, 41.889637f) + lineTo(17.372688f, 30.713213f) + lineTo(15.303288f, 26.430305f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-3.0052080154418945f, 1.7677680253982544f, 0.0f, 1.0f) +))}){ +// _0_1_5 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.506096f, 23.251263f) + cubicTo(20.50985f, 23.948053f, 20.064234f, 24.59325f, 19.337984f, 24.942549f) + cubicTo(18.611736f, 25.291845f, 17.715874f, 25.291845f, 16.989626f, 24.942549f) + cubicTo(16.263376f, 24.59325f, 15.81776f, 23.948053f, 15.821514f, 23.251263f) + cubicTo(15.81776f, 22.554472f, 16.263376f, 21.909275f, 16.989626f, 21.559977f) + cubicTo(17.715874f, 21.21068f, 18.611736f, 21.21068f, 19.337984f, 21.559977f) + cubicTo(20.064234f, 21.909275f, 20.50985f, 22.554472f, 20.506096f, 23.251263f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(176, 176, 176, 255), 1.0f to Color(117, 117, 117, 255), center = Offset(18.163805f, 22.632545f), radius = 2.8422909f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.506096f, 23.251263f) + cubicTo(20.50985f, 23.948053f, 20.064234f, 24.59325f, 19.337984f, 24.942549f) + cubicTo(18.611736f, 25.291845f, 17.715874f, 25.291845f, 16.989626f, 24.942549f) + cubicTo(16.263376f, 24.59325f, 15.81776f, 23.948053f, 15.821514f, 23.251263f) + cubicTo(15.81776f, 22.554472f, 16.263376f, 21.909275f, 16.989626f, 21.559977f) + cubicTo(17.715874f, 21.21068f, 18.611736f, 21.21068f, 19.337984f, 21.559977f) + cubicTo(20.064234f, 21.909275f, 20.50985f, 22.554472f, 20.506096f, 23.251263f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_6 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(14.937632f, 23.251265f) + lineTo(9.899495f, 27.051964f) + cubicTo(9.899495f, 27.051964f, 8.04334f, 21.485075f, 8.04334f, 19.008623f) + cubicTo(8.043341f, 16.53375f, 9.369165f, 15.561479f, 10.78338f, 15.561479f) + cubicTo(10.78338f, 15.561479f, 19.180273f, 15.561479f, 19.180273f, 15.561479f) + cubicTo(20.13685f, 15.561479f, 21.809826f, 15.959226f, 22.0087f, 18.831848f) + cubicTo(22.207575f, 21.70447f, 19.975767f, 27.051964f, 19.975767f, 27.051964f) + lineTo(14.937632f, 23.251265f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(240, 240, 240, 255), 1.0f to Color(201, 201, 201, 255), center = Offset(10.789677f, 16.887306f), radius = 13.500521f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(14.937632f, 23.251265f) + lineTo(9.899495f, 27.051964f) + cubicTo(9.899495f, 27.051964f, 8.04334f, 21.485075f, 8.04334f, 19.008623f) + cubicTo(8.043341f, 16.53375f, 9.369165f, 15.561479f, 10.78338f, 15.561479f) + cubicTo(10.78338f, 15.561479f, 19.180273f, 15.561479f, 19.180273f, 15.561479f) + cubicTo(20.13685f, 15.561479f, 21.809826f, 15.959226f, 22.0087f, 18.831848f) + cubicTo(22.207575f, 21.70447f, 19.975767f, 27.051964f, 19.975767f, 27.051964f) + lineTo(14.937632f, 23.251265f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_7 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(11.795503f, 17.94796f) + cubicTo(11.795503f, 17.94796f, 9.979857f, 18.435938f, 10.300266f, 19.607082f) + cubicTo(10.620674f, 20.778229f, 13.077134f, 22.632542f, 13.077134f, 22.632542f) + lineTo(17.669645f, 22.632542f) + cubicTo(17.669645f, 22.632542f, 19.778996f, 21.071014f, 20.019302f, 19.89987f) + cubicTo(20.259607f, 18.728724f, 18.630869f, 17.94796f, 18.630869f, 17.94796f) + lineTo(11.795503f, 17.94796f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_8 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(11.618727f, 16.975693f) + cubicTo(11.618727f, 16.975693f, 9.8030815f, 17.46367f, 10.12349f, 18.634815f) + cubicTo(10.443897f, 19.805962f, 12.900358f, 21.660275f, 12.900358f, 21.660275f) + lineTo(17.492868f, 21.660275f) + cubicTo(17.492868f, 21.660275f, 19.602219f, 20.098747f, 19.842525f, 18.927603f) + cubicTo(20.082832f, 17.756456f, 18.454092f, 16.975693f, 18.454092f, 16.975693f) + lineTo(11.618727f, 16.975693f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(139, 139, 139, 255), 1.0f to Color(169, 169, 169, 255), center = Offset(14.976143f, 21.269875f), radius = 5.4947376f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.14035088f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.232558012008667f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-6.0782389640808105f, 3.005204916000366f, 0.0f, 1.0f) +))}){ +// _0_1_9 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(26.516504f, 39.249554f) + cubicTo(26.53173f, 40.959858f, 24.724045f, 42.543526f, 21.777939f, 43.40089f) + cubicTo(18.831835f, 44.25826f, 15.19768f, 44.25826f, 12.2515745f, 43.40089f) + cubicTo(9.305469f, 42.543526f, 7.497783f, 40.959858f, 7.51301f, 39.249554f) + cubicTo(7.497783f, 37.53925f, 9.305469f, 35.95558f, 12.2515745f, 35.098217f) + cubicTo(15.19768f, 34.24085f, 18.831835f, 34.24085f, 21.777939f, 35.098217f) + cubicTo(24.724045f, 35.95558f, 26.53173f, 37.53925f, 26.516504f, 39.249554f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(0, 0, 0, 255), 1.0f to Color(0, 0, 0, 0), center = Offset(17.014757f, 39.249573f), radius = 9.501747f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_10 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(13.086385f, 18.12474f) + lineTo(16.78888f, 18.12474f) + cubicTo(21.075336f, 18.12474f, 26.33599f, 19.442257f, 26.33599f, 19.980894f) + lineTo(26.33599f, 42.60831f) + cubicTo(26.33599f, 43.14695f, 25.899113f, 43.58058f, 25.356443f, 43.58058f) + lineTo(4.5188212f, 43.58058f) + cubicTo(3.9761531f, 43.58058f, 3.5392747f, 43.14695f, 3.5392747f, 42.60831f) + lineTo(3.5392747f, 19.980894f) + cubicTo(3.5392747f, 19.442257f, 8.710954f, 18.12474f, 13.086385f, 18.12474f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(214, 214, 214, 255), 1.0f to Color(240, 240, 240, 255), start = Offset(12.761994f, 30.852661f), end = Offset(11.279642f, 23.074486f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0000001f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(13.086385f, 18.12474f) + lineTo(16.78888f, 18.12474f) + cubicTo(21.075336f, 18.12474f, 26.33599f, 19.442257f, 26.33599f, 19.980894f) + lineTo(26.33599f, 42.60831f) + cubicTo(26.33599f, 43.14695f, 25.899113f, 43.58058f, 25.356443f, 43.58058f) + lineTo(4.5188212f, 43.58058f) + cubicTo(3.9761531f, 43.58058f, 3.5392747f, 43.14695f, 3.5392747f, 42.60831f) + lineTo(3.5392747f, 19.980894f) + cubicTo(3.5392747f, 19.442257f, 8.710954f, 18.12474f, 13.086385f, 18.12474f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.61988306f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_11 +brush = SolidColor(Color(255, 255, 255, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Round, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(13.243834f, 18.986252f) + lineTo(16.631443f, 18.986252f) + cubicTo(20.55335f, 18.986252f, 25.3666f, 20.507769f, 25.3666f, 20.507769f) + lineTo(25.3666f, 42.57729f) + cubicTo(25.3666f, 42.57729f, 4.508677f, 42.57729f, 4.508677f, 42.57729f) + lineTo(4.508677f, 20.507769f) + cubicTo(4.508677f, 20.507769f, 9.2405205f, 18.986252f, 13.243834f, 18.986252f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_12 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(15.291184f, 23.42804f) + cubicTo(15.291184f, 23.42804f, 12.285981f, 27.845821f, 12.285981f, 30.233944f) + lineTo(12.285981f, 42.519924f) + lineTo(15.467961f, 45.34835f) + lineTo(18.384777f, 42.519924f) + lineTo(18.384777f, 30.057167f) + cubicTo(18.384777f, 28.057167f, 15.291184f, 23.42804f, 15.291184f, 23.42804f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.linearGradient(0.0f to Color(85, 87, 83, 255), 1.0f to Color(124, 127, 121, 255), start = Offset(15.335379f, 28.377787f), end = Offset(15.335379f, 34.388195f), tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(46, 52, 54, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(15.291184f, 23.42804f) + cubicTo(15.291184f, 23.42804f, 12.285981f, 27.845821f, 12.285981f, 30.233944f) + lineTo(12.285981f, 42.519924f) + lineTo(15.467961f, 45.34835f) + lineTo(18.384777f, 42.519924f) + lineTo(18.384777f, 30.057167f) + cubicTo(18.384777f, 28.057167f, 15.291184f, 23.42804f, 15.291184f, 23.42804f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.46783626f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_13 +brush = Brush.linearGradient(0.0f to Color(255, 255, 255, 255), 1.0f to Color(255, 255, 255, 0), start = Offset(15.335377f, 40.66687f), end = Offset(15.335377f, 30.23705f), tileMode = TileMode.Clamp) +stroke = Stroke(width=0.99999976f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(15.303288f, 26.430305f) + lineTo(13.298065f, 30.841566f) + lineTo(13.298065f, 41.889637f) + lineTo(15.431641f, 43.943283f) + lineTo(17.372688f, 41.889637f) + lineTo(17.372688f, 30.713213f) + lineTo(15.303288f, 26.430305f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +withTransform({ +transform( +Matrix(values=floatArrayOf( +1.0f, 0.0f, 0.0f, 0.0f, +0.0f, 1.0f, 0.0f, 0.0f, +0.0f, 0.0f, 1.0f, 0.0f, +-3.0052080154418945f, 1.7677680253982544f, 0.0f, 1.0f) +))}){ +// _0_1_14 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.506096f, 23.251263f) + cubicTo(20.50985f, 23.948053f, 20.064234f, 24.59325f, 19.337984f, 24.942549f) + cubicTo(18.611736f, 25.291845f, 17.715874f, 25.291845f, 16.989626f, 24.942549f) + cubicTo(16.263376f, 24.59325f, 15.81776f, 23.948053f, 15.821514f, 23.251263f) + cubicTo(15.81776f, 22.554472f, 16.263376f, 21.909275f, 16.989626f, 21.559977f) + cubicTo(17.715874f, 21.21068f, 18.611736f, 21.21068f, 19.337984f, 21.559977f) + cubicTo(20.064234f, 21.909275f, 20.50985f, 22.554472f, 20.506096f, 23.251263f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(128, 131, 125, 255), 1.0f to Color(76, 77, 74, 255), center = Offset(18.163805f, 22.36738f), radius = 2.8422909f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(46, 52, 54, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(20.506096f, 23.251263f) + cubicTo(20.50985f, 23.948053f, 20.064234f, 24.59325f, 19.337984f, 24.942549f) + cubicTo(18.611736f, 25.291845f, 17.715874f, 25.291845f, 16.989626f, 24.942549f) + cubicTo(16.263376f, 24.59325f, 15.81776f, 23.948053f, 15.821514f, 23.251263f) + cubicTo(15.81776f, 22.554472f, 16.263376f, 21.909275f, 16.989626f, 21.559977f) + cubicTo(17.715874f, 21.21068f, 18.611736f, 21.21068f, 19.337984f, 21.559977f) + cubicTo(20.064234f, 21.909275f, 20.50985f, 22.554472f, 20.506096f, 23.251263f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +} +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_15 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(14.937632f, 23.251265f) + lineTo(9.899495f, 27.051964f) + cubicTo(9.899495f, 27.051964f, 8.04334f, 21.485075f, 8.04334f, 19.008623f) + cubicTo(8.043341f, 16.53375f, 9.369165f, 15.561479f, 10.78338f, 15.561479f) + cubicTo(10.78338f, 15.561479f, 19.180273f, 15.561479f, 19.180273f, 15.561479f) + cubicTo(20.13685f, 15.561479f, 21.809826f, 15.959226f, 22.0087f, 18.831848f) + cubicTo(22.207575f, 21.70447f, 19.975767f, 27.051964f, 19.975767f, 27.051964f) + lineTo(14.937632f, 23.251265f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(240, 240, 240, 255), 1.0f to Color(201, 201, 201, 255), center = Offset(10.789677f, 16.887306f), radius = 13.500521f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +brush = SolidColor(Color(148, 148, 148, 255)) +stroke = Stroke(width=1.0f, cap=StrokeCap.Butt, join=StrokeJoin.Miter, miter=4.0f) +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(14.937632f, 23.251265f) + lineTo(9.899495f, 27.051964f) + cubicTo(9.899495f, 27.051964f, 8.04334f, 21.485075f, 8.04334f, 19.008623f) + cubicTo(8.043341f, 16.53375f, 9.369165f, 15.561479f, 10.78338f, 15.561479f) + cubicTo(10.78338f, 15.561479f, 19.180273f, 15.561479f, 19.180273f, 15.561479f) + cubicTo(20.13685f, 15.561479f, 21.809826f, 15.959226f, 22.0087f, 18.831848f) + cubicTo(22.207575f, 21.70447f, 19.975767f, 27.051964f, 19.975767f, 27.051964f) + lineTo(14.937632f, 23.251265f) + close() +} +shape = Outline.Generic(generalPath!!) +drawOutline(outline = shape!!, style = stroke!!, brush=brush!!, alpha = alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_16 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(11.795503f, 17.94796f) + cubicTo(11.795503f, 17.94796f, 9.979857f, 18.435938f, 10.300266f, 19.607082f) + cubicTo(10.620674f, 20.778229f, 12.007307f, 22.632542f, 13.077134f, 22.632542f) + lineTo(17.669645f, 22.632542f) + cubicTo(18.546875f, 22.632542f, 19.778996f, 21.071014f, 20.019302f, 19.89987f) + cubicTo(20.259607f, 18.728724f, 18.630869f, 17.94796f, 18.630869f, 17.94796f) + lineTo(11.795503f, 17.94796f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 1.0f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_17 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(11.618727f, 16.975693f) + cubicTo(11.618727f, 16.975693f, 9.8030815f, 17.46367f, 10.12349f, 18.634815f) + cubicTo(10.443897f, 19.805962f, 11.775358f, 21.660275f, 12.900358f, 21.660275f) + lineTo(17.492868f, 21.660275f) + cubicTo(18.242868f, 21.660275f, 19.602219f, 20.098747f, 19.842525f, 18.927603f) + cubicTo(20.082832f, 17.756456f, 18.454092f, 16.975693f, 18.454092f, 16.975693f) + lineTo(11.618727f, 16.975693f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = Brush.radialGradient(0.0f to Color(139, 139, 139, 255), 1.0f to Color(169, 169, 169, 255), center = Offset(14.976143f, 21.269875f), radius = 5.4947376f, tileMode = TileMode.Clamp) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.61988306f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_18 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(14.937632f, 22.720934f) + lineTo(19.622215f, 26.256468f) + lineTo(20.859652f, 22.809322f) + lineTo(19.35705f, 25.284197f) + lineTo(14.937632f, 22.720934f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alphaStack.add(0, alpha) +alpha *= 0.61988306f +blendModeStack.add(0, BlendMode.SrcOver) +blendMode = BlendMode.SrcOver +// _0_1_19 +if (generalPath == null) { + generalPath = Path() +} else { + generalPath!!.reset() +} +generalPath?.run { + moveTo(14.584078f, 22.89771f) + lineTo(10.164659f, 26.256468f) + lineTo(8.662058f, 19.627342f) + lineTo(10.69499f, 25.019032f) + lineTo(14.584078f, 22.89771f) + close() +} +shape = Outline.Generic(generalPath!!) +brush = SolidColor(Color(255, 255, 255, 255)) +drawOutline(outline = shape!!, style=Fill, brush=brush!!, alpha=alpha, blendMode = blendMode) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) +alpha = alphaStack.removeAt(0) +blendMode = blendModeStack.removeAt(0) + +} +} + + + + private fun innerPaint(drawScope: DrawScope) { + _paint0(drawScope) + + + shape = null + generalPath = null + brush = null + stroke = null + clip = null + alpha = 1.0f + } + + companion object { + /** + * Returns the X of the bounding box of the original SVG image. + * + * @return The X of the bounding box of the original SVG image. + */ + fun getOrigX(): Double { + return 3.0392746925354004 + } + + /** + * Returns the Y of the bounding box of the original SVG image. + * + * @return The Y of the bounding box of the original SVG image. + */ + fun getOrigY(): Double { + return 2.141613245010376 + } + + /** + * Returns the width of the bounding box of the original SVG image. + * + * @return The width of the bounding box of the original SVG image. + */ + fun getOrigWidth(): Double { + return 41.91632843017578 + } + + /** + * Returns the height of the bounding box of the original SVG image. + * + * @return The height of the bounding box of the original SVG image. + */ + fun getOrigHeight(): Double { + return 45.121849060058594 + } + + + } + + override val intrinsicSize: Size + get() = Size.Unspecified + + override fun DrawScope.onDraw() { + clipRect { + // Use the original icon bounding box and the current icon dimension to compute + // the scaling factor + val fullOrigWidth = getOrigX() + getOrigWidth() + val fullOrigHeight = getOrigY() + getOrigHeight() + val coef1 = size.width / fullOrigWidth + val coef2 = size.height / fullOrigHeight + val coef = min(coef1, coef2).toFloat() + + // Use the original icon bounding box and the current icon dimension to compute + // the offset pivot for the scaling + var translateX = -getOrigX() + var translateY = -getOrigY() + if (coef1 != coef2) { + if (coef1 < coef2) { + val extraDy = ((fullOrigWidth - fullOrigHeight) / 2.0f).toFloat() + translateY += extraDy + } else { + val extraDx = ((fullOrigHeight - fullOrigWidth) / 2.0f).toFloat() + translateX += extraDx + } + } + val translateXDp = translateX.toFloat().toDp().value + val translateYDp = translateY.toFloat().toDp().value + + // Create a combined scale + translate + clip transform before calling the transcoded painting instructions + withTransform({ + scale(scaleX = coef, scaleY = coef, pivot = Offset.Zero) + translate(translateXDp, translateYDp) + clipRect(left = 0.0f, top = 0.0f, right = fullOrigWidth.toFloat(), bottom = fullOrigHeight.toFloat(), clipOp = ClipOp.Intersect) + }) { + innerPaint(this) + } + } + } +} +