Migrate GUI from JavaFX to Kotlin Compose, adjust CLI

Author: SKocur

.gitignore

@@ -2,4 +2,5 @@
 output/
 .gradle/
 build/
-out/
+out/
+.kotlin

CONTRIBUTING.md

@@ -28,12 +28,14 @@ We use GitHub issues to track public bugs. Report a bug by [opening a new issue]
 People *love* thorough bug reports. I'm not even kidding.
 
 ### Used technologies
-* Kotlin
-* Gradle
-* JavaFX
-* RxJava 3
-* For testing: Jupiter JUnit
-* IDE: IntelliJ IDEA
+* **Kotlin** - Primary programming language
+* **Gradle** - Build system and dependency management
+* **Compose Multiplatform** - Modern declarative UI framework (replaced JavaFX)
+* **Material Design 3** - UI design system and components
+* **Coroutines** - Asynchronous programming and threading
+* **JCommander** - Command-line argument parsing
+* **Jupiter JUnit** - Unit testing framework
+* **IDE**: IntelliJ IDEA
 
 ### How to develop ImageCipher?
 1. Choose issue that is opened and not associated to anyone **or** propose something to develop.

README.md

@@ -6,32 +6,72 @@
 Steganography software for encrypting text into image that uses modified version of LSB (Least Significant Bit) algorithm. Project is part of this [Medium article](https://medium.com/@szymonkocur/how-i-redesigned-lsb-steganography-algorithm-ee45503dd47).
 
 ## Usage:
-### Window option
-#### To encrypt text into image:
-1. Find a photo to use for encryption.
-2. Enter the name of that photo in place of "image_name".
-3. Enter text to encrypt.
-4. Click "Encrypt".
-5. Enjoy!
-
-#### To decrypt text from image:
-1. Enter name of image with encrypted message.
-2. Click "Decrypt".
-3. Enjoy!
-
-### Command line arguments:
-`-EM arg` or `--encryption-mode arg` - sets encryption mode to one of the following: 
-* if `arg` is equal to 1, then SingleColorEncryption will be used
-* if `arg` is equal to 2, then MultiColorEncryptio will be used
-* if `arg` is equal to 3, then LowLevelBitEncryption will be used
-* if `arg` is equal to 4, then RSAEncryption will be used. WARNING: EXPERIMENTAL IMPLEMENTATION
-
-`-DM arg` or `--decryption-mode arg` - sets decryption mode with `arg` option analogically used as above (of course it will decrypt specific algorithm)
-
-`-f fileName` or `--file-name fileName` - sets image name (or path to it) which will store encrypted data
-
-#### Example:
-`java -jar Image-Cipher.jar -DM 3 -f my_awesome_image_with_embedded_data.file`
+
+### GUI Application
+Launch desktop application:
+```bash
+./gradlew :app:run
+```
+Or run the compiled JAR:
+```bash
+java -jar app.jar
+```
+
+### Command Line Interface
+
+The CLI has been redesigned with intuitive parameters and comprehensive help:
+
+```bash
+# Show help
+java -jar app.jar --help
+
+# Show version
+java -jar app.jar --version
+```
+
+#### Encryption Examples:
+```bash
+# Encrypt text into image (interactive input)
+java -jar app.jar --encrypt single-color --input photo.jpg
+
+# Encrypt specific text
+java -jar app.jar -e multi-color -i image.png -t "Secret message"
+
+# Encrypt with output file
+java -jar app.jar -e low-level-bit -i input.jpg -t "Hidden data" -o encrypted.png
+
+# Encrypt from stdin
+java -jar app.jar -e single-color -i photo.jpg -t :stdin
+```
+
+#### Decryption Examples:
+```bash
+# Decrypt text from image
+java -jar app.jar --decrypt single-color --input encrypted.jpg
+
+# Decrypt with verbose output
+java -jar app.jar -d multi-color -i hidden.png --verbose
+
+# Decrypt low-level bit data
+java -jar app.jar -d low-level-bit -i steganographic.png
+```
+
+#### Available Algorithms:
+- **single-color**: Basic LSB steganography in single color channel
+- **multi-color**: Enhanced LSB using multiple color channels  
+- **low-level-bit**: Advanced bit-level manipulation
+- **rsa**: RSA encryption with steganography (experimental, encryption only)
+
+#### CLI Parameters:
+- `-h, --help` - Show help message with examples
+- `-e, --encrypt <algorithm>` - Encrypt text using specified algorithm
+- `-d, --decrypt <algorithm>` - Decrypt text using specified algorithm
+- `-i, --input, --image <file>` - Input image file path
+- `-o, --output <file>` - Output image file (encryption only)
+- `-t, --text <text>` - Text to encrypt (use `:stdin` for interactive input)
+- `-c, --certificate <file>` - Certificate file for RSA encryption
+- `-v, --verbose` - Enable detailed output
+- `--version` - Show version information
 
 ### Before encryption
 ![Demo](images/github-logo.jpeg)

app/build.gradle.kts

@@ -1,56 +1,56 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-    kotlin("jvm") version "2.2.0"
-    id("org.openjfx.javafxplugin") version "0.1.0"
+    kotlin("jvm") version "2.1.0"
+    kotlin("plugin.compose") version "2.1.0"
+    id("org.jetbrains.compose") version "1.7.1"
     application
     java
 }
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_21
-    targetCompatibility = JavaVersion.VERSION_21
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }
 
 group = "com.imagecipher"
 version = "1.0.0"
 
 repositories {
     mavenCentral()
+    google()
+    maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
 }
 
 application {
-    mainClass.set("com.skocur.imagecipher.MainKt")
-    applicationDefaultJvmArgs = listOf(
-        "--add-modules", "javafx.controls,javafx.fxml",
-        "--add-exports", "javafx.graphics/com.sun.javafx.application=ALL-UNNAMED"
-    )
+    mainClass.set("com.imagecipher.app.MainKt")
 }
 
 tasks {
     jar {
         manifest {
-            attributes["Start-Class"] = "com.skocur.imagecipher.MainKt"
+            attributes["Main-Class"] = "com.imagecipher.app.MainKt"
         }
         duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+        from(configurations.runtimeClasspath.get().map { if (it.isDirectory) it else zipTree(it) })
     }
 }
 dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-stdlib:2.2.0")
+    implementation(compose.desktop.currentOs)
+    implementation(compose.material3)
+    implementation(compose.materialIconsExtended)
+    
+    implementation("org.jetbrains.kotlin:kotlin-stdlib:2.1.0")
     implementation("org.jetbrains:annotations:24.0.0")
+    
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-swing:1.6.4")
 
     implementation("org.jcommander:jcommander:2.0")
 
-    implementation("org.openjfx:javafx-controls:21")
-    implementation("org.openjfx:javafx-fxml:21")
-    implementation("org.openjfx:javafx-swing:21")
-
     implementation("com.fasterxml.jackson.core:jackson-databind:2.15.2")
     implementation("com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:2.15.2")
 
-    implementation("org.kordamp.bootstrapfx:bootstrapfx-core:0.4.0")
-    implementation("com.jfoenix:jfoenix:9.0.10")
-
     implementation("io.reactivex.rxjava3:rxjava:3.1.6")
 
     implementation("com.squareup.retrofit2:retrofit:2.9.0")
@@ -75,5 +75,5 @@ tasks.test {
     useJUnitPlatform()
 }
 kotlin {
-    jvmToolchain(21)
+    jvmToolchain(17)
 }

app/src/main/kotlin/com/imagecipher/app/CommandArgs.kt

@@ -8,26 +8,76 @@ class CommandArgs {
     var parameters: MutableList<String> = mutableListOf()
 
     @Parameter(
-        names = ["-EM", "--enryption-mode"],
-        description = "Encryption mode: 1 - SingleColorEncryption, 2 - MultiColorEncryption, 3 - LowLevelBitEncryption, 4 - RSAEncryption"
+        names = ["-h", "--help"],
+        description = "Show this help message",
+        help = true
     )
-    var encryptionMode: Int = 0 // If 0, then message will not be encrypted
+    var help: Boolean = false
 
     @Parameter(
-        names = ["-DM", "--decryption-mode"],
-        description = "Decryption mode: options as in encryption mode"
+        names = ["-e", "--encrypt"],
+        description = "Encryption algorithm: single-color, multi-color, low-level-bit, rsa"
     )
-    var decryptionMode: Int = 0 // If 0, then message will not be decrypted
+    var encryptAlgorithm: String? = null
 
     @Parameter(
-        names = ["-f", "--file-name"],
-        description = "Path to file which will store encrypted data"
+        names = ["-d", "--decrypt"],
+        description = "Decryption algorithm: single-color, multi-color, low-level-bit"
     )
-    var originalFileName: String? = null
+    var decryptAlgorithm: String? = null
 
     @Parameter(
-        names = ["-cf", "--certificate-file"],
-        description = "Path to file that contains certificate"
+        names = ["-i", "--input", "--image"],
+        description = "Path to input image file",
+        required = false
     )
-    var certificateFileName: String? = null
+    var imageFile: String? = null
+
+    @Parameter(
+        names = ["-o", "--output"],
+        description = "Path to output image file (for encryption only)"
+    )
+    var outputFile: String? = null
+
+    @Parameter(
+        names = ["-t", "--text"],
+        description = "Text to encrypt (use :stdin to read from standard input)"
+    )
+    var textToEncrypt: String? = null
+
+    @Parameter(
+        names = ["-c", "--certificate"],
+        description = "Path to certificate file (for RSA encryption only)"
+    )
+    var certificateFile: String? = null
+
+    @Parameter(
+        names = ["-v", "--verbose"],
+        description = "Enable verbose output"
+    )
+    var verbose: Boolean = false
+
+    @Parameter(
+        names = ["--version"],
+        description = "Show version information"
+    )
+    var version: Boolean = false
+
+    // Legacy support - keep old parameters but mark as deprecated
+    val encryptionMode: Int
+        get() = when (encryptAlgorithm?.lowercase()) {
+            "single-color" -> 1
+            "multi-color" -> 2
+            "low-level-bit" -> 3
+            "rsa" -> 4
+            else -> 0
+        }
+
+    val decryptionMode: Int
+        get() = when (decryptAlgorithm?.lowercase()) {
+            "single-color" -> 1
+            "multi-color" -> 2
+            "low-level-bit" -> 3
+            else -> 0
+        }
 }