[GH-8] Implement RGB SeekBars

andcolorpicker/src/main/java/codes/side/andcolorpicker/cmyk/CMYKColorPickerSeekBar.kt

@@ -95,15 +95,15 @@ class CMYKColorPickerSeekBar @JvmOverloads constructor(
   }
 
   override fun setMin(min: Int) {
-    if (min != 0) {
-      throw IllegalArgumentException("Current mode supports 0 min value only")
+    if (modeInitialized && min != mode.minProgress) {
+      throw IllegalArgumentException("Current mode supports ${mode.minProgress} min value only")
     }
     super.setMin(min)
   }
 
   override fun setMax(max: Int) {
-    if (max != 100) {
-      throw IllegalArgumentException("Current mode supports 100 max value only")
+    if (modeInitialized && max != mode.maxProgress) {
+      throw IllegalArgumentException("Current mode supports ${mode.maxProgress} max value only")
     }
     super.setMax(max)
   }

andcolorpicker/src/main/java/codes/side/andcolorpicker/converter/ColorConverterHub.kt

@@ -14,6 +14,10 @@ object ColorConverterHub {
       ColorKey.CMYK,
       IntegerCMYKColorConverter()
     )
+    registerConverter(
+      ColorKey.RGB,
+      IntegerRGBColorConverter()
+    )
   }
 
   fun getConverterByKey(key: ColorKey): ColorConverter {

andcolorpicker/src/main/java/codes/side/andcolorpicker/converter/IntegerRGBColorConverter.kt

@@ -0,0 +1,37 @@
+package codes.side.andcolorpicker.converter
+
+import codes.side.andcolorpicker.model.Color
+import codes.side.andcolorpicker.model.IntegerRGBColor
+
+class IntegerRGBColorConverter : ColorConverter {
+
+  override fun convertToOpaqueColorInt(color: Color): Int {
+    TODO("Not yet implemented")
+  }
+
+  override fun convertToColorInt(color: Color): Int {
+    require(color is IntegerRGBColor) { "Unsupported color type supplied" }
+
+    return android.graphics.Color.rgb(
+      color.floatR.toInt(),
+      color.floatG.toInt(),
+      color.floatB.toInt()
+    )
+  }
+
+  override fun convertToPureHueColorInt(color: Color): Int {
+    TODO("Not yet implemented")
+  }
+
+  override fun setFromColorInt(color: Color, value: Int) {
+    require(color is IntegerRGBColor) { "Unsupported color type supplied" }
+
+    color.copyValuesFrom(
+      intArrayOf(
+        android.graphics.Color.red(value),
+        android.graphics.Color.green(value),
+        android.graphics.Color.blue(value)
+      )
+    )
+  }
+}

andcolorpicker/src/main/java/codes/side/andcolorpicker/model/IntegerHSLColor.kt

@@ -174,7 +174,7 @@ class IntegerHSLColor : IntegerColor(
         return ordinal
       }
 
-    // TODO: Adapt for non-zero min valies
+    // TODO: Adapt for non-zero min values
     val normalizedDefaultValue: Float
       get() {
         return defaultValue / maxValue.toFloat()

andcolorpicker/src/main/java/codes/side/andcolorpicker/model/IntegerRGBColor.kt

@@ -1,13 +1,157 @@
 package codes.side.andcolorpicker.model
 
-class IntegerRGBColor : IntegerColor(COMPONENTS_COUNT) {
+class IntegerRGBColor : IntegerColor(
+  COMPONENTS_COUNT,
+  DEFAULT_RGB_VALUES
+) {
   companion object {
     private const val TAG = "IntegerRGBColor"
-    private const val COMPONENTS_COUNT = 3
+    private val COMPONENTS_COUNT = Component.values().size
+
+    private val DEFAULT_RGB_VALUES = Component
+      .values().map { it.defaultValue }.toIntArray()
   }
 
   override val colorKey = ColorKey.RGB
 
   override val alpha: Float
-    get() = TODO("Not yet implemented")
+    get() {
+      return intA / Component.A.maxValue.toFloat()
+    }
+  var intA: Int
+    get() {
+      return intValues[Component.A.index]
+    }
+    set(value) {
+      setValue(
+        Component.A.index,
+        value,
+        Component.A.minValue,
+        Component.A.maxValue
+      )
+    }
+
+  var floatR: Float
+    get() {
+      return intR.toFloat()
+    }
+    set(value) {
+      intR = value.toInt()
+    }
+  var intR: Int
+    get() {
+      return intValues[Component.R.index]
+    }
+    set(value) {
+      setValue(
+        Component.R.index,
+        value,
+        Component.R.minValue,
+        Component.R.maxValue
+      )
+    }
+
+  var floatG: Float
+    get() {
+      return intG.toFloat()
+    }
+    set(value) {
+      intG = value.toInt()
+    }
+  var intG: Int
+    get() {
+      return intValues[Component.G.index]
+    }
+    set(value) {
+      setValue(
+        Component.G.index,
+        value,
+        Component.G.minValue,
+        Component.G.maxValue
+      )
+    }
+
+  var floatB: Float
+    get() {
+      return intB.toFloat()
+    }
+    set(value) {
+      intB = value.toInt()
+    }
+  var intB: Int
+    get() {
+      return intValues[Component.B.index]
+    }
+    set(value) {
+      setValue(
+        Component.B.index,
+        value,
+        Component.B.minValue,
+        Component.B.maxValue
+      )
+    }
+
+  override fun clone(): IntegerRGBColor {
+    return super.clone() as IntegerRGBColor
+  }
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (javaClass != other?.javaClass) return false
+    if (!super.equals(other)) return false
+
+    other as IntegerRGBColor
+
+    if (colorKey != other.colorKey) return false
+
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result = super.hashCode()
+    result = 31 * result + colorKey.hashCode()
+    return result
+  }
+
+  // TODO: Make Component top-level?
+  // TODO: Make tree?
+  // TODO: Use range?
+  enum class Component(
+    val defaultValue: Int,
+    val minValue: Int,
+    val maxValue: Int
+  ) {
+    R(
+      0,
+      0,
+      255
+    ),
+    G(
+      0,
+      0,
+      255
+    ),
+    B(
+      0,
+      0,
+      255
+    ),
+    A(
+      255,
+      0,
+      255
+    );
+
+    // TODO: Review approach
+    val index: Int
+      get() {
+        return ordinal
+      }
+
+    // TODO: Adapt for non-zero min values
+    val normalizedDefaultValue: Float
+      get() {
+        return defaultValue / maxValue.toFloat()
+      }
+  }
 }

andcolorpicker/src/main/java/codes/side/andcolorpicker/model/factory/RGBColorFactory.kt

@@ -0,0 +1,13 @@
+package codes.side.andcolorpicker.model.factory
+
+import codes.side.andcolorpicker.model.IntegerRGBColor
+
+class RGBColorFactory : ColorFactory<IntegerRGBColor>() {
+  override fun create(): IntegerRGBColor {
+    return IntegerRGBColor()
+  }
+
+  override fun createColorFrom(color: IntegerRGBColor): IntegerRGBColor {
+    return color.clone()
+  }
+}