add toolchains support and offer configuration options dynamically

src/main/kotlin/io/xmake/project/toolkit/Toolkit.kt

@@ -23,7 +23,6 @@ data class Toolkit(
     var isRegistered: Boolean = false
     @get:Transient
     var isValid: Boolean = true
-
     @get:Transient
     val isOnRemote: Boolean
         get() = with(host) { type == ToolkitHostType.WSL || type == ToolkitHostType.SSH }

src/main/kotlin/io/xmake/project/toolkit/ToolkitChangedNotifier.kt

@@ -0,0 +1,16 @@
+package io.xmake.project.toolkit
+
+import com.intellij.util.messages.Topic
+
+interface ToolkitChangedNotifier {
+
+    fun toolkitChanged(toolkit: Toolkit?)
+
+    companion object {
+        @Topic.ProjectLevel
+        val TOOLKIT_CHANGED_TOPIC: Topic<ToolkitChangedNotifier> = Topic.create(
+            "toolkit changed",
+            ToolkitChangedNotifier::class.java
+        )
+    }
+}

src/main/kotlin/io/xmake/project/toolkit/ToolkitManager.kt

@@ -199,7 +199,7 @@ class ToolkitManager(private val scope: CoroutineScope) : PersistentStateCompone
         this.storage = state
     }
 
-    fun loadToolkit(toolkit: Toolkit) {
+    private fun loadToolkit(toolkit: Toolkit) {
         scope.launch(Dispatchers.IO) {
             toolkit.host.loadTarget()
             joinAll()

src/main/kotlin/io/xmake/project/toolkit/ui/ToolkitComboBox.kt

@@ -1,6 +1,7 @@
 package io.xmake.project.toolkit.ui
 
 import ai.grazie.utils.tryRunWithException
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.project.ProjectManager
 import com.intellij.openapi.ui.ComboBox
@@ -10,6 +11,7 @@ import com.intellij.openapi.ui.validation.validationErrorIf
 import com.intellij.ui.PopupMenuListenerAdapter
 import com.intellij.ui.SortedComboBoxModel
 import io.xmake.project.toolkit.Toolkit
+import io.xmake.project.toolkit.ToolkitChangedNotifier
 import io.xmake.project.toolkit.ToolkitManager
 import java.awt.event.ItemEvent
 import java.util.*
@@ -174,9 +176,13 @@ class ToolkitComboBox(toolkitProperty: KMutableProperty0<Toolkit?>) : ComboBox<T
         toolkitChangedListeners.add(listener)
     }
 
+    val publisher: ToolkitChangedNotifier = ApplicationManager.getApplication().messageBus
+        .syncPublisher(ToolkitChangedNotifier.TOOLKIT_CHANGED_TOPIC)
+
     fun addToolkitChangedListener(action: (Toolkit?) -> Unit) {
         toolkitChangedListeners.add(object : ToolkitChangedListener {
             override fun onToolkitChanged(toolkit: Toolkit?) {
+                publisher.toolkitChanged(toolkit)
                 action(toolkit)
             }
         })

src/main/kotlin/io/xmake/run/XMakeRunConfiguration.kt

@@ -17,6 +17,8 @@ import io.xmake.project.toolkit.ToolkitManager
 import io.xmake.project.xmakeConsoleView
 import io.xmake.shared.xmakeConfiguration
 import io.xmake.utils.SystemUtils
+import io.xmake.utils.info.XMakeInfoManager
+import io.xmake.utils.info.xmakeInfo
 import org.jdom.Element
 import kotlin.io.path.Path
 
@@ -33,10 +35,13 @@ class XMakeRunConfiguration(
     var runTarget: String = "default"
 
     @OptionTag(tag = "platform")
-    var runPlatform: String = SystemUtils.platform()
+    var runPlatform: String = if (platforms.contains(SystemUtils.platform())) SystemUtils.platform() else ""
 
     @OptionTag(tag = "architecture")
-    var runArchitecture: String = getArchitecturesByPlatform(runPlatform).first()
+    var runArchitecture: String = getArchitecturesByPlatform(runPlatform).firstOrNull() ?: ""
+
+    @OptionTag(tag = "toolchain")
+    var runToolchain: String = toolchains.firstOrNull() ?: ""
 
     @OptionTag(tag = "mode")
     var runMode: String = "release"
@@ -105,6 +110,8 @@ class XMakeRunConfiguration(
         runToolkit = runToolkit?.let { toolkit ->
             ToolkitManager.getInstance().findRegisteredToolkitById(toolkit.id)
         }
+        // Todo: Optimize to avoid probing delay.
+        XMakeInfoManager.getInstance(project).probeXMakeInfo(runToolkit)
     }
 
     override fun checkConfiguration() {
@@ -144,29 +151,20 @@ class XMakeRunConfiguration(
         return null
     }
 
-    companion object {
-
-        // the platforms
-        val platforms = arrayOf("macosx", "linux", "windows", "android", "iphoneos", "watchos", "mingw")
+    val platforms: Array<String>
+        get() = project.xmakeInfo.architectures.keys.toTypedArray()
 
-        // the modes
-        val modes = arrayOf("release", "debug")
+    val toolchains: Array<String>
+        get() = project.xmakeInfo.toolchains.keys.toTypedArray()
 
-        /*        // the architectures
-                val architectures: Array<String>
-                    get() = getArchitecturesByPlatform(runPlatform)*/
-
-        // get architectures by platform
-        fun getArchitecturesByPlatform(platform: String) = when (platform) {
-            "macosx", "linux", "mingw" -> arrayOf("x86_64", "i386", "arm64")
-            "windows" -> arrayOf("x86", "x64")
-            "iphoneos" -> arrayOf("arm64", "armv7", "armv7s", "x86_64", "i386")
-            "watchos" -> arrayOf("armv7s", "i386")
-            "android" -> arrayOf("armv7-a", "armv5te", "armv6", "armv8-a", "arm64-v8a")
-            else -> arrayOf()
-        }
+    val modes: Array<String>
+        get() = project.xmakeInfo.buildModes.map { it.substringAfter('.') }.toTypedArray()
 
+    fun getArchitecturesByPlatform(platform: String): Array<String> {
+        return (project.xmakeInfo.architectures[platform]?.toTypedArray() ?: emptyArray())
+    }
 
+    companion object {
         private val Log = Logger.getInstance(XMakeRunConfiguration::class.java.getName())
     }
 }

src/main/kotlin/io/xmake/run/XMakeRunConfigurationEditor.kt

@@ -18,9 +18,6 @@ import io.xmake.project.target.TargetManager
 import io.xmake.project.toolkit.Toolkit
 import io.xmake.project.toolkit.ui.ToolkitComboBox
 import io.xmake.project.toolkit.ui.ToolkitListItem
-import io.xmake.run.XMakeRunConfiguration.Companion.getArchitecturesByPlatform
-import io.xmake.run.XMakeRunConfiguration.Companion.modes
-import io.xmake.run.XMakeRunConfiguration.Companion.platforms
 import io.xmake.shared.xmakeConfiguration
 import io.xmake.utils.execute.SyncDirection
 import io.xmake.utils.execute.transferFolderByToolkit
@@ -47,13 +44,17 @@ class XMakeRunConfigurationEditor(
     private val targetsModel = DefaultComboBoxModel<String>()
     private val targetsComboBox = ComboBox(targetsModel).apply { item = runConfiguration.runTarget }
 
-    private val platformsModel = DefaultComboBoxModel(platforms)
+    private val platformsModel = DefaultComboBoxModel(runConfiguration.platforms)
     private val platformsComboBox = ComboBox(platformsModel).apply { item = runConfiguration.runPlatform }
 
-    private val architecturesModel = DefaultComboBoxModel(getArchitecturesByPlatform(runConfiguration.runPlatform))
+    private val architecturesModel =
+        DefaultComboBoxModel(runConfiguration.getArchitecturesByPlatform(runConfiguration.runPlatform))
     private val architecturesComboBox = ComboBox(architecturesModel).apply { item = runConfiguration.runArchitecture }
 
-    private val modesModel = DefaultComboBoxModel(modes)
+    private val toolchainsModel = DefaultComboBoxModel(runConfiguration.toolchains)
+    private val toolchainsComboBox = ComboBox(toolchainsModel).apply { item = runConfiguration.runToolchain }
+
+    private val modesModel = DefaultComboBoxModel(runConfiguration.modes)
     private val modesComboBox = ComboBox(modesModel).apply { item = runConfiguration.runMode }
 
     private val runArguments = RawCommandLineEditor()
@@ -80,12 +81,15 @@ class XMakeRunConfigurationEditor(
 
         // reset targets
         targetsModel.removeAllElements()
+
         targetsModel.selectedItem = configuration.runTarget
 
         platformsComboBox.item = configuration.runPlatform
 
         architecturesComboBox.item = configuration.runArchitecture
 
+        toolchainsComboBox.item = configuration.runToolchain
+
         modesComboBox.item = configuration.runMode
 
         // reset run arguments
@@ -116,6 +120,8 @@ class XMakeRunConfigurationEditor(
 
         configuration.runArchitecture = architecturesComboBox.item
 
+        configuration.runToolchain = toolchainsComboBox.item
+
         configuration.runMode = modesComboBox.item
 
         configuration.runArguments = runArguments.text
@@ -168,7 +174,7 @@ class XMakeRunConfigurationEditor(
                 row {
                     cell(platformsComboBox).applyToComponent {
                         addItemListener {
-                            val architectures = getArchitecturesByPlatform(selectedItem as String)
+                            val architectures = runConfiguration.getArchitecturesByPlatform(selectedItem as String)
                             with(architecturesModel) {
                                 removeAllElements()
                                 addAll(architectures.toMutableList())
@@ -186,6 +192,14 @@ class XMakeRunConfigurationEditor(
                     cell(architecturesComboBox).align(AlignX.FILL)
                 }
             }.resizableColumn()
+            panel {
+                row {
+                    label("Toolchain:")
+                }
+                row {
+                    cell(toolchainsComboBox).align(AlignX.FILL)
+                }
+            }.resizableColumn()
             panel {
                 row {
                     label("Mode:")

src/main/kotlin/io/xmake/shared/XMakeConfiguration.kt

@@ -92,6 +92,7 @@ class XMakeConfiguration(val project: Project) {
                     configuration.runPlatform,
                     "-a",
                     configuration.runArchitecture,
+                    "--toolchain=${configuration.runToolchain}",
                     "-m",
                     configuration.runMode,
                     "--policies=run.autobuild"

src/main/kotlin/io/xmake/utils/info/XMakeInfoActivity.kt

@@ -0,0 +1,21 @@
+package io.xmake.utils.info
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.startup.ProjectActivity
+import io.xmake.project.toolkit.Toolkit
+import io.xmake.project.toolkit.ToolkitChangedNotifier
+
+class XMakeInfoActivity : ProjectActivity {
+    override suspend fun execute(project: Project) {
+        ApplicationManager.getApplication().messageBus.connect()
+            .subscribe(
+                ToolkitChangedNotifier.TOOLKIT_CHANGED_TOPIC,
+                object : ToolkitChangedNotifier {
+                    override fun toolkitChanged(toolkit: Toolkit?) {
+                        XMakeInfoManager.getInstance(project).probeXMakeInfo(toolkit)
+                    }
+                }
+            )
+    }
+}