add colors module
This commit is contained in:
parent
be5d2ee715
commit
ff59b0cc9c
|
|
@ -2,6 +2,10 @@
|
|||
|
||||
## 0.20.25
|
||||
|
||||
* `Colors`:
|
||||
* `Common`:
|
||||
* Module inited
|
||||
|
||||
## 0.20.24
|
||||
|
||||
**Since this version depdendencies of klock and krypto replaced with `com.soywiz.korge:korlibs-time` and `com.soywiz.korge:korlibs-crypto`**
|
||||
|
|
|
|||
|
|
@ -0,0 +1,40 @@
|
|||
plugins {
|
||||
id "org.jetbrains.kotlin.multiplatform"
|
||||
id "org.jetbrains.kotlin.plugin.serialization"
|
||||
id "com.android.library"
|
||||
}
|
||||
|
||||
apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
|
||||
|
||||
kotlin {
|
||||
sourceSets {
|
||||
jvmMain {
|
||||
dependencies {
|
||||
api project(":micro_utils.coroutines")
|
||||
}
|
||||
}
|
||||
androidMain {
|
||||
dependencies {
|
||||
api project(":micro_utils.coroutines")
|
||||
api libs.android.fragment
|
||||
}
|
||||
dependsOn jvmMain
|
||||
}
|
||||
|
||||
linuxX64Main {
|
||||
dependencies {
|
||||
api libs.okio
|
||||
}
|
||||
}
|
||||
mingwX64Main {
|
||||
dependencies {
|
||||
api libs.okio
|
||||
}
|
||||
}
|
||||
linuxArm64Main {
|
||||
dependencies {
|
||||
api libs.okio
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,138 @@
|
|||
package dev.inmo.micro_utils.colors.common
|
||||
|
||||
import kotlinx.serialization.Serializable
|
||||
import kotlin.jvm.JvmInline
|
||||
import kotlin.math.floor
|
||||
|
||||
/**
|
||||
* Wrapper for RGBA colors. Receiving [UInt] in main constructor. Each part in main constructor
|
||||
* configured with `0x00 - 0xff` range. Examples:
|
||||
*
|
||||
* * Red: `0xff0000ffu`
|
||||
* * Red (0.5 capacity): `0xff000088u`
|
||||
*
|
||||
* Anyway it is recommended to use
|
||||
*/
|
||||
@Serializable
|
||||
@JvmInline
|
||||
value class HEXAColor (
|
||||
val uint: UInt
|
||||
) : Comparable<HEXAColor> {
|
||||
val hexa: String
|
||||
get() = "#${uint.toString(16).padStart(8, '0')}"
|
||||
val hex: String
|
||||
get() = hexa.take(7)
|
||||
val shortHex: String
|
||||
get() = "#${r.shortPart()}${g.shortPart()}${b.shortPart()}"
|
||||
val shortHexa: String
|
||||
get() = "$shortHex${a.shortPart()}"
|
||||
val rgbInt: Int
|
||||
get() = (uint shr 2).toInt()
|
||||
val alphaOfOne: Float
|
||||
get() = (uint and 0xffu).toFloat() / 256f
|
||||
|
||||
val r: Int
|
||||
get() = ((uint and 0xff000000u) / 0x1000000u).toInt()
|
||||
val g: Int
|
||||
get() = ((uint and 0x00ff0000u) / 0x10000u).toInt()
|
||||
val b: Int
|
||||
get() = ((uint and 0x0000ff00u) / 0x100u).toInt()
|
||||
val a: Int
|
||||
get() = ((uint and 0x000000ffu)).toInt()
|
||||
val aOfOne: Float
|
||||
get() = a.toFloat() / (0xff)
|
||||
init {
|
||||
require(uint in 0u ..0xffffffffu)
|
||||
}
|
||||
|
||||
constructor(r: Int, g: Int, b: Int, a: Int) : this(
|
||||
((r * 0x1000000).toLong() + g * 0x10000 + b * 0x100 + a).toUInt()
|
||||
) {
|
||||
require(r in 0 ..0xff)
|
||||
require(g in 0 ..0xff)
|
||||
require(b in 0 ..0xff)
|
||||
require(a in 0 ..0xff)
|
||||
}
|
||||
|
||||
constructor(r: Int, g: Int, b: Int, aOfOne: Float = 1f) : this(
|
||||
r = r, g = g, b = b, a = (aOfOne * 0xff).toInt()
|
||||
)
|
||||
|
||||
override fun toString(): String {
|
||||
return hexa
|
||||
}
|
||||
|
||||
override fun compareTo(other: HEXAColor): Int = (uint - other.uint).coerceIn(Int.MIN_VALUE.toUInt(), Int.MAX_VALUE.toLong().toUInt()).toInt()
|
||||
|
||||
fun copy(
|
||||
r: Int = this.r,
|
||||
g: Int = this.g,
|
||||
b: Int = this.b,
|
||||
aOfOne: Float = this.aOfOne
|
||||
) = HEXAColor(r, g, b, aOfOne)
|
||||
fun copy(
|
||||
r: Int = this.r,
|
||||
g: Int = this.g,
|
||||
b: Int = this.b,
|
||||
a: Int
|
||||
) = HEXAColor(r, g, b, a)
|
||||
|
||||
companion object {
|
||||
/**
|
||||
* Parsing color from [color]
|
||||
*
|
||||
* Supported formats samples (on Red color based):
|
||||
*
|
||||
* * `#f00`
|
||||
* * `#f00f`
|
||||
* * `#ff0000`
|
||||
* * `#ff0000ff`
|
||||
* * `rgb(255, 0, 0)`
|
||||
* * `rgba(255, 0, 0, 1)`
|
||||
*/
|
||||
fun parseStringColor(color: String): HEXAColor = when {
|
||||
color.startsWith("#") -> color.removePrefix("#").let { color ->
|
||||
when (color.length) {
|
||||
3 -> color.map { "$it$it" }.joinToString(separator = "", postfix = "ff")
|
||||
4 -> color.take(3).map { "$it$it" }.joinToString(separator = "", postfix = color.takeLast(1).let { "${it}0" })
|
||||
6 -> "${color}ff"
|
||||
8 -> color
|
||||
else -> error("Malfurmed color string: $color. It is expected that color started with # will contains 3, 6 or 8 valuable parts")
|
||||
}
|
||||
}
|
||||
color.startsWith("rgb(") -> color
|
||||
.removePrefix("rgb(")
|
||||
.removeSuffix(")")
|
||||
.replace(Regex("\\s"), "")
|
||||
.split(",")
|
||||
.map { it.toInt().toString(16) }
|
||||
.joinToString("", postfix = "ff")
|
||||
color.startsWith("rgba(") -> color
|
||||
.removePrefix("rgba(")
|
||||
.removeSuffix(")")
|
||||
.replace(Regex("\\s"), "")
|
||||
.split(",").let {
|
||||
it.take(3).map { it.toInt().toString(16) } + (it.last().toFloat() * 0xff).toInt().toString(16)
|
||||
}
|
||||
.joinToString("")
|
||||
else -> color
|
||||
}.lowercase().toUInt(16).let(::HEXAColor)
|
||||
|
||||
/**
|
||||
* Parsing color from [color]
|
||||
*
|
||||
* Supported formats samples (on Red color based):
|
||||
*
|
||||
* * `#f00`
|
||||
* * `#ff0000`
|
||||
* * `#ff0000ff`
|
||||
* * `rgb(255, 0, 0)`
|
||||
* * `rgba(255, 0, 0, 1)`
|
||||
*/
|
||||
operator fun invoke(color: String) = parseStringColor(color)
|
||||
|
||||
private fun Int.shortPart(): String {
|
||||
return (floor(toFloat() / 16)).toInt().toString(16)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,150 @@
|
|||
package dev.inmo.micro_utils.colors.common
|
||||
|
||||
import kotlin.math.floor
|
||||
import kotlin.math.round
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
class HexColorTests {
|
||||
class TestColor(
|
||||
val color: HEXAColor,
|
||||
val shortHex: String?,
|
||||
val shortHexa: String?,
|
||||
val hex: String,
|
||||
val hexa: String,
|
||||
val r: Int,
|
||||
val g: Int,
|
||||
val b: Int,
|
||||
val a: Int,
|
||||
)
|
||||
val testColors: List<TestColor>
|
||||
get() = listOf(
|
||||
TestColor(
|
||||
color = HEXAColor(uint = 0xff0000ffu),
|
||||
shortHex = "#f00",
|
||||
shortHexa = "#f00f",
|
||||
hex = "#ff0000",
|
||||
hexa = "#ff0000ff",
|
||||
r = 0xff,
|
||||
g = 0x00,
|
||||
b = 0x00,
|
||||
a = 0xff,
|
||||
),
|
||||
TestColor(
|
||||
color = HEXAColor(uint = 0x00ff00ffu),
|
||||
shortHex = "#0f0",
|
||||
shortHexa = "#0f0f",
|
||||
hex = "#00ff00",
|
||||
hexa = "#00ff00ff",
|
||||
r = 0x00,
|
||||
g = 0xff,
|
||||
b = 0x00,
|
||||
a = 0xff,
|
||||
),
|
||||
TestColor(
|
||||
color = HEXAColor(0x0000ffffu),
|
||||
shortHex = "#00f",
|
||||
shortHexa = "#00ff",
|
||||
hex = "#0000ff",
|
||||
hexa = "#0000ffff",
|
||||
r = 0x00,
|
||||
g = 0x00,
|
||||
b = 0xff,
|
||||
a = 0xff,
|
||||
),
|
||||
TestColor(
|
||||
color = HEXAColor(0xff000088u),
|
||||
shortHex = "#f00",
|
||||
shortHexa = "#f008",
|
||||
hex = "#ff0000",
|
||||
hexa = "#ff000088",
|
||||
r = 0xff,
|
||||
g = 0x00,
|
||||
b = 0x00,
|
||||
a = 0x88,
|
||||
),
|
||||
TestColor(
|
||||
color = HEXAColor(0x00ff0088u),
|
||||
shortHex = "#0f0",
|
||||
shortHexa = "#0f08",
|
||||
hex = "#00ff00",
|
||||
hexa = "#00ff0088",
|
||||
r = 0x00,
|
||||
g = 0xff,
|
||||
b = 0x00,
|
||||
a = 0x88,
|
||||
),
|
||||
TestColor(
|
||||
color = HEXAColor(0x0000ff88u),
|
||||
shortHex = "#00f",
|
||||
shortHexa = "#00f8",
|
||||
hex = "#0000ff",
|
||||
hexa = "#0000ff88",
|
||||
r = 0x00,
|
||||
g = 0x00,
|
||||
b = 0xff,
|
||||
a = 0x88,
|
||||
),
|
||||
TestColor(
|
||||
color = HEXAColor(0xff000022u),
|
||||
shortHex = "#f00",
|
||||
shortHexa = "#f002",
|
||||
hex = "#ff0000",
|
||||
hexa = "#ff000022",
|
||||
r = 0xff,
|
||||
g = 0x00,
|
||||
b = 0x00,
|
||||
a = 0x22,
|
||||
),
|
||||
TestColor(
|
||||
HEXAColor(0x00ff0022u),
|
||||
"#0f0",
|
||||
"#0f02",
|
||||
"#00ff00",
|
||||
"#00ff0022",
|
||||
0x00,
|
||||
0xff,
|
||||
0x00,
|
||||
0x22,
|
||||
),
|
||||
TestColor(
|
||||
color = HEXAColor(0x0000ff22u),
|
||||
shortHex = "#00f",
|
||||
shortHexa = "#00f2",
|
||||
hex = "#0000ff",
|
||||
hexa = "#0000ff22",
|
||||
r = 0x00,
|
||||
g = 0x00,
|
||||
b = 0xff,
|
||||
a = 0x22,
|
||||
),
|
||||
)
|
||||
|
||||
@Test
|
||||
fun baseTest() {
|
||||
testColors.forEach {
|
||||
assertEquals(it.hex, it.color.hex)
|
||||
assertEquals(it.hexa, it.color.hexa)
|
||||
assertEquals(it.shortHex, it.color.shortHex)
|
||||
assertEquals(it.shortHexa, it.color.shortHexa)
|
||||
assertEquals(it.r, it.color.r)
|
||||
assertEquals(it.g, it.color.g)
|
||||
assertEquals(it.b, it.color.b)
|
||||
assertEquals(it.a, it.color.a)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testHexParseColor() {
|
||||
testColors.forEach {
|
||||
assertEquals(it.color, HEXAColor.parseStringColor(it.hexa))
|
||||
assertEquals(it.color.copy(aOfOne = 1f), HEXAColor.parseStringColor(it.hex))
|
||||
it.shortHex ?.let { _ ->
|
||||
assertEquals(it.color.copy(aOfOne = 1f), HEXAColor.parseStringColor(it.shortHex))
|
||||
}
|
||||
it.shortHexa ?.let { _ ->
|
||||
assertEquals(it.color.copy(a = floor(it.color.a.toFloat() / 16).toInt() * 0x10), HEXAColor.parseStringColor(it.shortHexa))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -42,6 +42,7 @@ String[] includes = [
|
|||
":serialization:mapper",
|
||||
":startup:plugin",
|
||||
":startup:launcher",
|
||||
":colors:common",
|
||||
|
||||
":resources",
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue