Best solution to work with swing dialogs

[Genie23]

Hello,

For my application project, I will need dialog boxes. Knowing that Compose doesn't integrate any, I looked for those used in Java, and I found my happiness in the javax.swing library.

However, I am not sure to use them correctly in a Compose project. My goal is to create a class with methods calling these dialog boxes and returning (if necessary) the result.

Actually, I have done this :

package fr.genie23.tools

import java.awt.Component
import java.io.File
import javax.swing.JFileChooser
import javax.swing.JOptionPane
import javax.swing.filechooser.FileNameExtensionFilter

class Dialog {
    companion object {
        fun message(title:String, message:String, type:Int = JOptionPane.INFORMATION_MESSAGE) {
            JOptionPane.showMessageDialog((null as Component?), message, title, type)
        }

        fun confirm(title:String, message:String, type:Int = JOptionPane.INFORMATION_MESSAGE):Boolean {
            return JOptionPane.showConfirmDialog((null as Component?), message, title, JOptionPane.YES_NO_OPTION, type) == JOptionPane.OK_OPTION
        }

        fun fileChooser(isLoad:Boolean = false, title:String = "Choisissez un fichier", extensions:Array<FileNameExtensionFilter>? = null): List<File>? {
            val fileChooser = JFileChooser()
            fileChooser.dialogTitle = title
            fileChooser.isMultiSelectionEnabled = isLoad
            if(extensions != null) {
                fileChooser.isAcceptAllFileFilterUsed = false
                for(extension in extensions) {
                    fileChooser.addChoosableFileFilter(extension)
                }
            }
            else {
                fileChooser.isAcceptAllFileFilterUsed = true
            }
            var returned:Int;
            if(isLoad) {
                returned = fileChooser.showOpenDialog((null as Component?))
            }
            else {
                returned = fileChooser.showSaveDialog((null as Component?))
            }
            if(returned == JFileChooser.APPROVE_OPTION) {
                if(isLoad) {
                    return fileChooser.selectedFiles.filter { it.canRead() }
                }
                else {
                    if(!fileChooser.fileFilter.accept(fileChooser.selectedFile)) {
                        val ext = (fileChooser.fileFilter as FileNameExtensionFilter).extensions[0]
                        fileChooser.selectedFile.renameTo(File(fileChooser.selectedFile.absolutePath + ".$ext"))
                    }
                    if(!fileChooser.selectedFile.canRead() or confirm("Fichier exisitant", "Voulez-vous remplacer le fichier ${fileChooser.selectedFile.name}", JOptionPane.WARNING_MESSAGE)) {
                        return listOf(fileChooser.selectedFile)
                    }
                    else {
                        return null
                    }
                }
            }
            return null
        }
    }
}

On Windows, it works well :

ut on macOS my Dialog.message function takes a long time to run and the output is not what I expected :

The call to the Dialog.message method (located in the onclick action of my button) :

Dialog.message(title = "Test", message = "Message de test", type = JOptionPane.INFORMATION_MESSAGE)

In fact, instead of the icon of the dialog box (which should be the JOptionPane.INFORMATION_MESSAGE in my example), it puts me the icon of my application, and I don't understand why. Indeed, I don't load it at any time in my program.

So I'm thinking that I'm not doing it the right way, and I hope you can enlighten me on how to use them.

[darvld]

The notepad example has a working example on how to use Swing dialogs.

However, bear in mind that you're using Swing, which means you won't get "native-looking" dialogs or components. I've struggled with this myself and I found that, unless you need something very specific (like a file browsing dialog), it's better to use Compose's Dialog functions and create your own alert dialog: it'll look better and be uniform across platforms.

[Genie23]

So, I looked again at the tutorial which mentions the java.awt.FileDialog dialog box, I copied and pasted the function in my main.kt file :

@Composable
private fun FileDialog(
    parent: Frame? = null,
    onCloseRequest: (result: String?) -> Unit
) = AwtWindow(
    create = {
        object : FileDialog(parent, "Choose a file", LOAD) {
            override fun setVisible(value: Boolean) {
                super.setVisible(value)
                if (value) {
                    onCloseRequest(file)
                }
            }
        }
    },
    dispose = FileDialog::dispose
)

If I use it as in the example, everything is fine, the file selection window opens correctly (however, it looks like a native dialog box too) :

Then I use it in main.kt when I click on a button in my window :

                Button(
                    onClick = {
                        FileDialog {
                            println(it)
                        }
                    }
                ) {
                    Text("Ajouter un fichier à la fusion")
                }

But when I try to launch my application (runDistributable task), I get the following error :

11:31:01: Executing task 'runDistributable'...


> Task :compileKotlin FAILED
1 actionable task: 1 executed
e: D:\Utilisateurs\sphin\Documents\Kotlin_Projects\PDF_Assembler\src\main\kotlin\main.kt: (50, 25): @Composable invocations can only happen from the context of a @Composable function

FAILURE: Build failed with an exception.

I did try to add an @composable annotation to various places in my code:

• Above the Button creation -> syntax error (the composable annotation was not in its place)
• Above the declaration of main() -> compile-time error :

> Task :compileKotlin FAILED
1 actionable task: 1 executed
e: D:\Utilisateurs\sphin\Documents\Kotlin_Projects\PDF_Assembler\src\main\kotlin\main.kt: (25, 5): Composable main functions are not currently supported
e: D:\Utilisateurs\sphin\Documents\Kotlin_Projects\PDF_Assembler\src\main\kotlin\main.kt: (51, 25): @Composable invocations can only happen from the context of a @Composable function

FAILURE: Build failed with an exception.

• At the level of my onclick -> another compile-time error :

                Button(
                    onClick = @Composable
                    {
                        FileDialog {
                            println(it)
                        }
                    }
                ) {
                    Text("Ajouter un fichier à la fusion")
                }

> Task :compileKotlin FAILED
1 actionable task: 1 executed
e: D:\Utilisateurs\sphin\Documents\Kotlin_Projects\PDF_Assembler\src\main\kotlin\main.kt: (50, 21): Type inference failed. Expected type mismatch: inferred type is @Composable () -> Unit but () -> Unit was expected

FAILURE: Build failed with an exception.

That's why I had given up the idea of using the awt ^_^' dialogs.

But I will look at the example you linked

[akurasov]

I believe it is not a good option to call Dialog() from callback. It should be called from Composition tree under some conditions. And these conditions should be managed from callbacks.

[Genie23]

Something like this :

    // outside Window() { ... }
    val showDialog = mutableStateOf(false)
    // ...
                // inside Window() { ... }
                if(showDialog.value) {
                    fileDialog {
                        showDialog.value = false
                    }
                }
                Button(
                    onClick = {
                        showDialog.value = true
                    }
                ) {
                    Text("Ajouter un fichier à la fusion")
                }

?

It's true, I just tested it, it works. It will force me to take new development habits, but if it works, it's not the end of the world :)

[akurasov]

it's not the end of the world :)
definitely not) On this positive note I'll close the ticket)

[akurasov]

It is not a good option to call Dialog() from callback. It should be called from Composition tree under some conditions. And these conditions should be managed from callbacks.