Use properties delegates on states and minor fixes (#50)

ffgiraldez · web-flow · commit 67d7a8c12188 · 2022-11-17T17:19:10.000Z
diff --git a/app/src/main/java/com/godaddy/android/colorpicker/HarmonyColorPickerScreen.kt b/app/src/main/java/com/godaddy/android/colorpicker/HarmonyColorPickerScreen.kt
@@ -35,7 +35,7 @@ fun HarmonyColorPickerScreen(navController: NavController) {
             }
         )
         var currentColor by remember {
-            mutableStateOf(HsvColor.from(Color.Black))
+            mutableStateOf(HsvColor.from(Color.Red))
         }
         var extraColors by remember {
             mutableStateOf(emptyList<HsvColor>())
diff --git a/app/src/main/java/com/godaddy/android/colorpicker/SampleColorPickerActivity.kt b/app/src/main/java/com/godaddy/android/colorpicker/SampleColorPickerActivity.kt
@@ -18,8 +18,10 @@ import androidx.compose.material.Text
 import androidx.compose.material.TextButton
 import androidx.compose.material.TopAppBar
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.ExperimentalGraphicsApi
@@ -38,8 +40,8 @@ class SampleColorPickerActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
         setContent {
             ComposeColorPickerTheme {
-                val openDialog = remember { mutableStateOf(false) }
-                val currentColor = remember {
+                var openDialog by remember { mutableStateOf(false) }
+                var currentColor by remember {
                     mutableStateOf(HsvColor.from(Color.Black))
                 }
                 Surface(color = MaterialTheme.colors.background) {
@@ -54,32 +56,32 @@ class SampleColorPickerActivity : ComponentActivity() {
                         Text(
                             text = "Dialog",
                             modifier = Modifier.clickable {
-                                openDialog.value = true
+                                openDialog = true
                             }.padding(8.dp).fillMaxWidth()
                         )
                     }
                 }
-                if (openDialog.value) {
+                if (openDialog) {
                     AlertDialog(
                         onDismissRequest = {
-                            openDialog.value = false
+                            openDialog = false
                         },
                         text = {
                             ClassicColorPicker(
-                                color = currentColor.value,
+                                color = currentColor,
                                 modifier = Modifier
                                     .height(300.dp)
                                     .padding(16.dp),
                                 onColorChanged = { hsvColor: HsvColor ->
                                     // Triggered when the color changes, do something with the newly picked color here!
-                                    currentColor.value = hsvColor
+                                    currentColor = hsvColor
                                 }
                             )
                         },
                         confirmButton = {
                             TextButton(
                                 onClick = {
-                                    openDialog.value = false
+                                    openDialog = false
                                 }
                             ) {
                                 Text("Confirm")
@@ -88,7 +90,7 @@ class SampleColorPickerActivity : ComponentActivity() {
                         dismissButton = {
                             TextButton(
                                 onClick = {
-                                    openDialog.value = false
+                                    openDialog = false
                                 }
                             ) {
                                 Text("Dismiss")
diff --git a/color-picker/src/commonMain/kotlin/com/godaddy/android/colorpicker/harmony/HarmonyColorPicker.kt b/color-picker/src/commonMain/kotlin/com/godaddy/android/colorpicker/harmony/HarmonyColorPicker.kt
@@ -131,7 +131,7 @@ private fun HarmonyColorPickerWithMagnifiers(
 
     ) {
         val updatedOnColorChanged by rememberUpdatedState(onColorChanged)
-        val diameterPx = remember(constraints.maxWidth) {
+        val diameterPx by remember(constraints.maxWidth) {
             mutableStateOf(constraints.maxWidth)
         }
 
@@ -145,7 +145,7 @@ private fun HarmonyColorPickerWithMagnifiers(
         fun updateColorWheel(newPosition: Offset, animate: Boolean) {
             // Work out if the new position is inside the circle we are drawing, and has a
             // valid color associated to it. If not, keep the current position
-            val newColor = colorForPosition(newPosition, IntSize(diameterPx.value, diameterPx.value), hsvColorUpdated.value)
+            val newColor = colorForPosition(newPosition, IntSize(diameterPx, diameterPx), hsvColorUpdated.value)
             if (newColor != null) {
                 animateChanges = animate
                 updatedOnColorChanged(newColor)
@@ -168,9 +168,9 @@ private fun HarmonyColorPickerWithMagnifiers(
         }
 
         Box(inputModifier.fillMaxSize()) {
-            ColorWheel(hsvColor = hsvColor, diameter = diameterPx.value)
+            ColorWheel(hsvColor = hsvColor, diameter = diameterPx)
             HarmonyColorMagnifiers(
-                diameterPx.value,
+                diameterPx,
                 hsvColor,
                 animateChanges,
                 currentlyChangingInput,
diff --git a/desktop/src/jvmMain/kotlin/ClassicColorPickerScreen.kt b/desktop/src/jvmMain/kotlin/ClassicColorPickerScreen.kt
@@ -16,7 +16,7 @@ import com.godaddy.android.colorpicker.HsvColor
 fun ClassicColorPickerScreen() {
     Column {
         var currentColor by remember {
-            mutableStateOf(HsvColor.from(Color.Black))
+            mutableStateOf(HsvColor.from(Color.Red))
         }
         ColorPreviewInfo(currentColor = currentColor.toColor())
         ClassicColorPicker(
diff --git a/desktop/src/jvmMain/kotlin/HarmonyColorPickerScreen.kt b/desktop/src/jvmMain/kotlin/HarmonyColorPickerScreen.kt
@@ -33,43 +33,43 @@ fun HarmonyColorPickerScreen() {
         var currentColor by remember {
             mutableStateOf(HsvColor.from(Color.Red))
         }
-        val extraColors = remember {
+        var extraColors by remember {
             mutableStateOf(emptyList<HsvColor>())
         }
         ColorPaletteBar(
             modifier = Modifier.fillMaxWidth().wrapContentHeight(),
-            colors = listOf(currentColor).plus(extraColors.value)
+            colors = listOf(currentColor).plus(extraColors)
         )
-        val expanded = remember {
+        var expanded by remember {
             mutableStateOf(false)
         }
-        val harmonyMode = remember {
+        var harmonyMode by remember {
             mutableStateOf(ColorHarmonyMode.ANALOGOUS)
         }
         TextButton(onClick = {
-            expanded.value = true
+            expanded = true
         }) {
-            Text(harmonyMode.value.name)
+            Text(harmonyMode.name)
         }
-        DropdownMenu(expanded.value, onDismissRequest = {
-            expanded.value = false
+        DropdownMenu(expanded, onDismissRequest = {
+            expanded = false
         }) {
             ColorHarmonyMode.values().forEach {
                 DropdownMenuItem(onClick = {
-                    harmonyMode.value = it
-                    expanded.value = false
+                    harmonyMode = it
+                    expanded = false
                 }) {
                     Text(it.name)
                 }
             }
         }
         HarmonyColorPicker(
-            harmonyMode = harmonyMode.value,
+            harmonyMode = harmonyMode,
             modifier = Modifier.defaultMinSize(minHeight = 300.dp, minWidth = 300.dp),
             color = currentColor,
             onColorChanged = { hsvColor ->
                 currentColor = hsvColor
-                extraColors.value = hsvColor.getColors(harmonyMode.value)
+                extraColors = hsvColor.getColors(harmonyMode)
             }
         )
     }
diff --git a/desktop/src/jvmMain/kotlin/Main.kt b/desktop/src/jvmMain/kotlin/Main.kt
@@ -1,4 +1,3 @@
-
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Column
@@ -14,8 +13,10 @@ import androidx.compose.material.TabRow
 import androidx.compose.material.Text
 import androidx.compose.material.TopAppBar
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -34,29 +35,29 @@ fun main() = application {
                     })
                     // Here is how to add a Color Picker to your compose tree:
 
-                    val currentColorPicker = remember { mutableStateOf(ColorPicker.CLASSIC) }
+                    var currentColorPicker by remember { mutableStateOf(ColorPicker.CLASSIC) }
                     TabRow(
-                        currentColorPicker.value.ordinal,
+                        currentColorPicker.ordinal,
                         tabs = {
                             Text(
                                 "Classic Picker",
                                 modifier =
                                 Modifier.clickable {
-                                    currentColorPicker.value = ColorPicker.CLASSIC
+                                    currentColorPicker = ColorPicker.CLASSIC
                                 }.padding(16.dp),
                                 textAlign = TextAlign.Center
                             )
                             Text(
                                 "Harmony Picker",
                                 modifier = Modifier.clickable {
-                                    currentColorPicker.value = ColorPicker.HARMONY
+                                    currentColorPicker = ColorPicker.HARMONY
                                 }.padding(16.dp),
                                 textAlign = TextAlign.Center
                             )
                         },
                         contentColor = Color.White
                     )
-                    when (currentColorPicker.value) {
+                    when (currentColorPicker) {
                         ColorPicker.CLASSIC -> {
                             ClassicColorPickerScreen()
                         }

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ fun HarmonyColorPickerScreen(navController: NavController) {`
`35`	`35`	`}`
`36`	`36`	`)`
`37`	`37`	`var currentColor by remember {`
`38`		`- mutableStateOf(HsvColor.from(Color.Black))`
	`38`	`+ mutableStateOf(HsvColor.from(Color.Red))`
`39`	`39`	`}`
`40`	`40`	`var extraColors by remember {`
`41`	`41`	`mutableStateOf(emptyList<HsvColor>())`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ import com.godaddy.android.colorpicker.HsvColor`
`16`	`16`	`fun ClassicColorPickerScreen() {`
`17`	`17`	`Column {`
`18`	`18`	`var currentColor by remember {`
`19`		`- mutableStateOf(HsvColor.from(Color.Black))`
	`19`	`+ mutableStateOf(HsvColor.from(Color.Red))`
`20`	`20`	`}`
`21`	`21`	`ColorPreviewInfo(currentColor = currentColor.toColor())`
`22`	`22`	`ClassicColorPicker(`
Original file line number	Diff line number	Diff line change
`@@ -33,43 +33,43 @@ fun HarmonyColorPickerScreen() {`
`33`	`33`	`var currentColor by remember {`
`34`	`34`	`mutableStateOf(HsvColor.from(Color.Red))`
`35`	`35`	`}`
`36`		`- val extraColors = remember {`
	`36`	`+ var extraColors by remember {`
`37`	`37`	`mutableStateOf(emptyList<HsvColor>())`
`38`	`38`	`}`
`39`	`39`	`ColorPaletteBar(`
`40`	`40`	`modifier = Modifier.fillMaxWidth().wrapContentHeight(),`
`41`		`- colors = listOf(currentColor).plus(extraColors.value)`
	`41`	`+ colors = listOf(currentColor).plus(extraColors)`
`42`	`42`	`)`
`43`		`- val expanded = remember {`
	`43`	`+ var expanded by remember {`
`44`	`44`	`mutableStateOf(false)`
`45`	`45`	`}`
`46`		`- val harmonyMode = remember {`
	`46`	`+ var harmonyMode by remember {`
`47`	`47`	`mutableStateOf(ColorHarmonyMode.ANALOGOUS)`
`48`	`48`	`}`
`49`	`49`	`TextButton(onClick = {`
`50`		`- expanded.value = true`
	`50`	`+ expanded = true`
`51`	`51`	`}) {`
`52`		`- Text(harmonyMode.value.name)`
	`52`	`+ Text(harmonyMode.name)`
`53`	`53`	`}`
`54`		`- DropdownMenu(expanded.value, onDismissRequest = {`
`55`		`- expanded.value = false`
	`54`	`+ DropdownMenu(expanded, onDismissRequest = {`
	`55`	`+ expanded = false`
`56`	`56`	`}) {`
`57`	`57`	`ColorHarmonyMode.values().forEach {`
`58`	`58`	`DropdownMenuItem(onClick = {`
`59`		`- harmonyMode.value = it`
`60`		`- expanded.value = false`
	`59`	`+ harmonyMode = it`
	`60`	`+ expanded = false`
`61`	`61`	`}) {`
`62`	`62`	`Text(it.name)`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`	`HarmonyColorPicker(`
`67`		`- harmonyMode = harmonyMode.value,`
	`67`	`+ harmonyMode = harmonyMode,`
`68`	`68`	`modifier = Modifier.defaultMinSize(minHeight = 300.dp, minWidth = 300.dp),`
`69`	`69`	`color = currentColor,`
`70`	`70`	`onColorChanged = { hsvColor ->`
`71`	`71`	`currentColor = hsvColor`
`72`		`- extraColors.value = hsvColor.getColors(harmonyMode.value)`
	`72`	`+ extraColors = hsvColor.getColors(harmonyMode)`
`73`	`73`	`}`
`74`	`74`	`)`
`75`	`75`	`}`