mirror of
https://invent.kde.org/marcoa/a-la-karte.git
synced 2026-02-09 21:13:08 +00:00
638 lines
23 KiB
QML
638 lines
23 KiB
QML
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
// SPDX-FileCopyrightText: 2026 A-La-Karte Contributors
|
|
|
|
import QtQuick
|
|
import QtQuick.Controls as QQC2
|
|
import QtQuick.Layouts
|
|
import QtQuick.Dialogs
|
|
import org.kde.kirigami as Kirigami
|
|
import org.kde.kirigamiaddons.formcard as FormCard
|
|
import org.kde.alakarte
|
|
|
|
Kirigami.Dialog {
|
|
id: dialog
|
|
|
|
property var game: null
|
|
property bool isEditing: game !== null
|
|
|
|
ListModel {
|
|
id: envModel
|
|
}
|
|
|
|
signal gameCreated(var game)
|
|
signal gameUpdated(var game)
|
|
|
|
title: isEditing ? i18n("Edit Game") : i18n("Add New Game")
|
|
standardButtons: Kirigami.Dialog.NoButton
|
|
|
|
width: Math.min(parent.width - Kirigami.Units.gridUnit * 4, Kirigami.Units.gridUnit * 30)
|
|
height: Math.min(parent.height - Kirigami.Units.gridUnit * 4, implicitHeight)
|
|
|
|
x: Math.round((parent.width - width) / 2)
|
|
y: Math.round((parent.height - height) / 2)
|
|
|
|
customFooterActions: [
|
|
Kirigami.Action {
|
|
text: isEditing ? i18n("Apply") : i18n("Add")
|
|
icon.name: isEditing ? "dialog-ok-apply" : "list-add"
|
|
enabled: nameField.text.trim() !== "" && executableField.text.trim() !== "" && (runnerCombo.currentIndex !== 3 || runnerPathField.text.trim() !== "")
|
|
onTriggered: {
|
|
let runnerValue = dialog.runnerFromIndex(runnerCombo.currentIndex)
|
|
let runnerPathValue = runnerPathField.text.trim()
|
|
let prefixPathValue = prefixPathField.text.trim()
|
|
if (runnerValue === "") {
|
|
runnerPathValue = ""
|
|
prefixPathValue = ""
|
|
}
|
|
if (isEditing) {
|
|
game.name = nameField.text.trim()
|
|
game.developer = developerField.text.trim()
|
|
game.launchCommand = executableField.text.trim()
|
|
game.workingDirectory = workingDirField.text.trim()
|
|
game.launchEnv = dialog.envModelToMap()
|
|
game.launchRunner = runnerValue
|
|
game.launchRunnerPath = runnerPathValue
|
|
game.launchPrefixPath = prefixPathValue
|
|
if (selectedCoverPath !== "") {
|
|
App.setCoverFromFile(game, selectedCoverPath)
|
|
}
|
|
App.saveLibrary()
|
|
gameUpdated(game)
|
|
} else {
|
|
let newGame = App.createGame(nameField.text.trim(), executableField.text.trim())
|
|
if (newGame) {
|
|
newGame.developer = developerField.text.trim()
|
|
newGame.workingDirectory = workingDirField.text.trim()
|
|
newGame.launchEnv = dialog.envModelToMap()
|
|
newGame.launchRunner = runnerValue
|
|
newGame.launchRunnerPath = runnerPathValue
|
|
newGame.launchPrefixPath = prefixPathValue
|
|
if (selectedCoverPath !== "") {
|
|
App.setCoverFromFile(newGame, selectedCoverPath)
|
|
}
|
|
App.saveLibrary()
|
|
gameCreated(newGame)
|
|
}
|
|
}
|
|
dialog.close()
|
|
}
|
|
},
|
|
Kirigami.Action {
|
|
text: i18n("Cancel")
|
|
icon.name: "dialog-cancel"
|
|
onTriggered: dialog.close()
|
|
}
|
|
]
|
|
|
|
property string selectedCoverPath: ""
|
|
|
|
readonly property bool anyMenuOpen: runnerCombo && runnerCombo.popup && runnerCombo.popup.visible
|
|
|
|
function closeCurrentMenu() {
|
|
if (runnerCombo && runnerCombo.popup && runnerCombo.popup.visible) {
|
|
runnerCombo.popup.close()
|
|
}
|
|
}
|
|
|
|
function isDescendant(item, ancestor) {
|
|
let p = item
|
|
while (p) {
|
|
if (p === ancestor || (ancestor.contentItem && p === ancestor.contentItem)) return true
|
|
if (p.visualParent !== undefined && p.visualParent !== null) {
|
|
if (dialog.isDescendant(p.visualParent, ancestor)) return true
|
|
} else if (p.popup !== undefined && p.popup !== null && p.popup.visualParent !== undefined && p.popup.visualParent !== null) {
|
|
if (dialog.isDescendant(p.popup.visualParent, ancestor)) return true
|
|
}
|
|
p = p.parent
|
|
}
|
|
return false
|
|
}
|
|
|
|
function focusNextInChain(forward) {
|
|
let w = applicationWindow()
|
|
if (!w || !w.activeFocusItem) return
|
|
let next = w.activeFocusItem
|
|
for (let i = 0; i < 50; i++) {
|
|
next = next.nextItemInFocusChain(forward)
|
|
if (!next) return
|
|
if (dialog.isDescendant(next, dialog)) {
|
|
next.forceActiveFocus()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
function activateFocused() {
|
|
let w = applicationWindow()
|
|
if (!w || !w.activeFocusItem) return
|
|
let item = w.activeFocusItem
|
|
|
|
if (typeof item.toggle === "function") {
|
|
item.toggle()
|
|
return
|
|
}
|
|
if (item.checkable !== undefined && item.checkable && item.checked !== undefined) {
|
|
item.checked = !item.checked
|
|
return
|
|
}
|
|
if (typeof item.clicked === "function") {
|
|
item.clicked()
|
|
return
|
|
}
|
|
}
|
|
|
|
function envModelToMap() {
|
|
let result = ({})
|
|
for (let i = 0; i < envModel.count; i++) {
|
|
let row = envModel.get(i)
|
|
let k = (row.key || "").trim()
|
|
if (k === "") continue
|
|
if (k.indexOf("=") !== -1) continue
|
|
result[k] = String(row.value || "")
|
|
}
|
|
return result
|
|
}
|
|
|
|
function setEnvVar(key, value) {
|
|
let k = (key || "").trim()
|
|
if (k === "") return
|
|
for (let i = 0; i < envModel.count; i++) {
|
|
let row = envModel.get(i)
|
|
if ((row.key || "").trim() === k) {
|
|
envModel.setProperty(i, "value", String(value || ""))
|
|
return
|
|
}
|
|
}
|
|
envModel.append({ key: k, value: String(value || "") })
|
|
}
|
|
|
|
function runnerFromIndex(idx) {
|
|
if (idx === 1) return "wine"
|
|
if (idx === 2) return "proton"
|
|
if (idx === 3) return "custom"
|
|
return ""
|
|
}
|
|
|
|
function runnerToIndex(runner) {
|
|
let r = (runner || "").trim().toLowerCase()
|
|
if (r === "wine") return 1
|
|
if (r === "proton") return 2
|
|
if (r === "custom") return 3
|
|
return 0
|
|
}
|
|
|
|
function loadFields() {
|
|
selectedCoverPath = ""
|
|
envModel.clear()
|
|
if (isEditing && game) {
|
|
nameField.text = game.name || ""
|
|
developerField.text = game.developer || ""
|
|
executableField.text = game.launchCommand || ""
|
|
workingDirField.text = game.workingDirectory || ""
|
|
|
|
runnerCombo.currentIndex = dialog.runnerToIndex(game.launchRunner)
|
|
runnerPathField.text = game.launchRunnerPath || ""
|
|
prefixPathField.text = game.launchPrefixPath || ""
|
|
|
|
let env = game.launchEnv || ({})
|
|
let keys = Object.keys(env)
|
|
keys.sort()
|
|
for (let i = 0; i < keys.length; i++) {
|
|
let k = keys[i]
|
|
envModel.append({ key: k, value: String(env[k]) })
|
|
}
|
|
} else {
|
|
nameField.text = ""
|
|
developerField.text = ""
|
|
executableField.text = ""
|
|
workingDirField.text = ""
|
|
|
|
runnerCombo.currentIndex = 0
|
|
runnerPathField.text = ""
|
|
prefixPathField.text = ""
|
|
}
|
|
}
|
|
|
|
Connections {
|
|
target: GamepadManager
|
|
function onNavigateUp() {
|
|
let app = applicationWindow()
|
|
if (app && app.currentConfirmDialog && app.currentConfirmDialog()) return
|
|
if (!dialog.opened) return
|
|
let w = applicationWindow()
|
|
if (!w || !w.activeFocusItem) return
|
|
if (!dialog.isDescendant(w.activeFocusItem, dialog)) return
|
|
dialog.focusNextInChain(false)
|
|
}
|
|
function onNavigateDown() {
|
|
let app = applicationWindow()
|
|
if (app && app.currentConfirmDialog && app.currentConfirmDialog()) return
|
|
if (!dialog.opened) return
|
|
let w = applicationWindow()
|
|
if (!w || !w.activeFocusItem) return
|
|
if (!dialog.isDescendant(w.activeFocusItem, dialog)) return
|
|
dialog.focusNextInChain(true)
|
|
}
|
|
function onNavigateLeft() {
|
|
let app = applicationWindow()
|
|
if (app && app.currentConfirmDialog && app.currentConfirmDialog()) return
|
|
if (!dialog.opened) return
|
|
let w = applicationWindow()
|
|
if (!w || !w.activeFocusItem) return
|
|
if (!dialog.isDescendant(w.activeFocusItem, dialog)) return
|
|
dialog.focusNextInChain(false)
|
|
}
|
|
function onNavigateRight() {
|
|
let app = applicationWindow()
|
|
if (app && app.currentConfirmDialog && app.currentConfirmDialog()) return
|
|
if (!dialog.opened) return
|
|
let w = applicationWindow()
|
|
if (!w || !w.activeFocusItem) return
|
|
if (!dialog.isDescendant(w.activeFocusItem, dialog)) return
|
|
dialog.focusNextInChain(true)
|
|
}
|
|
function onSelectPressed() {
|
|
let app = applicationWindow()
|
|
if (app && app.currentConfirmDialog && app.currentConfirmDialog()) return
|
|
if (!dialog.opened) return
|
|
let w = applicationWindow()
|
|
if (!w || !w.activeFocusItem) return
|
|
if (!dialog.isDescendant(w.activeFocusItem, dialog)) return
|
|
dialog.activateFocused()
|
|
}
|
|
}
|
|
|
|
ColumnLayout {
|
|
spacing: 0
|
|
|
|
FormCard.FormCard {
|
|
Layout.fillWidth: true
|
|
|
|
FormCard.FormTextFieldDelegate {
|
|
id: nameField
|
|
label: i18n("Name")
|
|
text: ""
|
|
placeholderText: i18n("Game title")
|
|
onAccepted: developerField.forceActiveFocus()
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormTextFieldDelegate {
|
|
id: developerField
|
|
label: i18n("Developer")
|
|
text: ""
|
|
placeholderText: i18n("Optional")
|
|
onAccepted: executableField.forceActiveFocus()
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormTextFieldDelegate {
|
|
id: executableField
|
|
label: i18n("Executable")
|
|
text: ""
|
|
placeholderText: i18n("/path/to/game or command")
|
|
onAccepted: if (nameField.text.trim() !== "" && text.trim() !== "") {
|
|
dialog.customFooterActions[0].trigger()
|
|
}
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormButtonDelegate {
|
|
text: i18n("Browse...")
|
|
icon.name: "document-open"
|
|
onClicked: fileDialog.open()
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormTextFieldDelegate {
|
|
id: workingDirField
|
|
label: i18n("Working Directory")
|
|
text: ""
|
|
placeholderText: i18n("Optional")
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormCard {
|
|
Layout.fillWidth: true
|
|
Layout.topMargin: Kirigami.Units.largeSpacing
|
|
|
|
FormCard.FormHeader {
|
|
title: i18n("Compatibility")
|
|
}
|
|
|
|
Item {
|
|
Layout.fillWidth: true
|
|
Layout.margins: Kirigami.Units.largeSpacing
|
|
|
|
RowLayout {
|
|
anchors.left: parent.left
|
|
anchors.right: parent.right
|
|
spacing: Kirigami.Units.largeSpacing
|
|
|
|
QQC2.Label {
|
|
text: i18n("Runner")
|
|
Layout.alignment: Qt.AlignVCenter
|
|
}
|
|
|
|
QQC2.ComboBox {
|
|
id: runnerCombo
|
|
Layout.fillWidth: true
|
|
model: [i18n("Native"), i18n("Wine"), i18n("Proton"), i18n("Custom")]
|
|
}
|
|
}
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormTextFieldDelegate {
|
|
id: runnerPathField
|
|
label: i18n("Runner Path")
|
|
text: ""
|
|
placeholderText: runnerCombo.currentIndex === 2 ? i18n("Auto-detect Proton") : (runnerCombo.currentIndex === 1 ? i18n("Use system Wine") : i18n("Required for Custom"))
|
|
enabled: runnerCombo.currentIndex !== 0
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormButtonDelegate {
|
|
text: i18n("Browse Runner...")
|
|
icon.name: "document-open"
|
|
enabled: runnerCombo.currentIndex !== 0
|
|
onClicked: runnerFileDialog.open()
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormTextFieldDelegate {
|
|
id: prefixPathField
|
|
label: i18n("Prefix Path")
|
|
text: ""
|
|
placeholderText: i18n("Default (AppDataLocation/prefixes/<gameId>)")
|
|
enabled: runnerCombo.currentIndex === 1 || runnerCombo.currentIndex === 2
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormButtonDelegate {
|
|
text: i18n("Browse Prefix...")
|
|
icon.name: "document-open-folder"
|
|
enabled: runnerCombo.currentIndex === 1 || runnerCombo.currentIndex === 2
|
|
onClicked: prefixFolderDialog.open()
|
|
}
|
|
}
|
|
|
|
FormCard.FormCard {
|
|
Layout.fillWidth: true
|
|
Layout.topMargin: Kirigami.Units.largeSpacing
|
|
|
|
FormCard.FormHeader {
|
|
title: i18n("Environment Variables")
|
|
}
|
|
|
|
FormCard.FormTextDelegate {
|
|
text: i18n("These variables are applied only when launching this game from A-La-Karte.")
|
|
textItem.wrapMode: Text.WordWrap
|
|
textItem.font: Kirigami.Theme.smallFont
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormButtonDelegate {
|
|
text: i18n("Add Variable")
|
|
icon.name: "list-add"
|
|
onClicked: envModel.append({ key: "", value: "" })
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormButtonDelegate {
|
|
text: i18n("Preset: MangoHud")
|
|
description: i18n("Sets MANGOHUD=1")
|
|
icon.name: "games-hint"
|
|
onClicked: dialog.setEnvVar("MANGOHUD", "1")
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormButtonDelegate {
|
|
text: i18n("Preset: GameMode")
|
|
description: i18n("Sets GAMEMODERUN=1")
|
|
icon.name: "speedometer"
|
|
onClicked: dialog.setEnvVar("GAMEMODERUN", "1")
|
|
}
|
|
|
|
FormCard.FormDelegateSeparator {}
|
|
|
|
FormCard.FormButtonDelegate {
|
|
text: i18n("Clear Variables")
|
|
icon.name: "edit-clear"
|
|
enabled: envModel.count > 0
|
|
onClicked: envModel.clear()
|
|
}
|
|
|
|
Item {
|
|
Layout.fillWidth: true
|
|
Layout.margins: Kirigami.Units.largeSpacing
|
|
|
|
ColumnLayout {
|
|
anchors.left: parent.left
|
|
anchors.right: parent.right
|
|
spacing: Kirigami.Units.smallSpacing
|
|
|
|
Repeater {
|
|
model: envModel
|
|
|
|
RowLayout {
|
|
Layout.fillWidth: true
|
|
spacing: Kirigami.Units.smallSpacing
|
|
|
|
QQC2.TextField {
|
|
Layout.fillWidth: true
|
|
Layout.preferredWidth: 1
|
|
placeholderText: i18n("KEY")
|
|
text: key
|
|
onTextChanged: envModel.setProperty(index, "key", text)
|
|
}
|
|
|
|
QQC2.TextField {
|
|
Layout.fillWidth: true
|
|
Layout.preferredWidth: 2
|
|
placeholderText: i18n("VALUE")
|
|
text: value
|
|
onTextChanged: envModel.setProperty(index, "value", text)
|
|
}
|
|
|
|
QQC2.ToolButton {
|
|
icon.name: "list-remove"
|
|
onClicked: envModel.remove(index)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FormCard.FormCard {
|
|
Layout.fillWidth: true
|
|
Layout.topMargin: Kirigami.Units.largeSpacing
|
|
|
|
FormCard.FormHeader {
|
|
title: i18n("Cover Art")
|
|
}
|
|
|
|
Item {
|
|
Layout.fillWidth: true
|
|
Layout.preferredHeight: Kirigami.Units.gridUnit * 8
|
|
Layout.margins: Kirigami.Units.largeSpacing
|
|
|
|
RowLayout {
|
|
anchors.fill: parent
|
|
spacing: Kirigami.Units.largeSpacing
|
|
|
|
Rectangle {
|
|
Layout.preferredWidth: Kirigami.Units.gridUnit * 5
|
|
Layout.preferredHeight: Kirigami.Units.gridUnit * 7
|
|
radius: Kirigami.Units.smallSpacing
|
|
color: Kirigami.Theme.alternateBackgroundColor
|
|
border.color: Kirigami.Theme.disabledTextColor
|
|
border.width: 1
|
|
|
|
Image {
|
|
anchors.fill: parent
|
|
anchors.margins: 2
|
|
source: selectedCoverPath !== "" ? "file://" + selectedCoverPath :
|
|
(isEditing && game && game.coverUrl.toString() !== "" ? game.coverUrl : "")
|
|
fillMode: Image.PreserveAspectCrop
|
|
|
|
Kirigami.Icon {
|
|
anchors.centerIn: parent
|
|
source: "image-x-generic"
|
|
width: Kirigami.Units.iconSizes.large
|
|
height: width
|
|
visible: parent.status !== Image.Ready
|
|
opacity: 0.5
|
|
}
|
|
}
|
|
}
|
|
|
|
ColumnLayout {
|
|
Layout.fillWidth: true
|
|
spacing: Kirigami.Units.smallSpacing
|
|
|
|
QQC2.Button {
|
|
text: i18n("Choose Cover...")
|
|
icon.name: "document-open"
|
|
onClicked: coverDialog.open()
|
|
}
|
|
|
|
QQC2.Button {
|
|
text: i18n("Fetch from SteamGridDB")
|
|
icon.name: "download"
|
|
enabled: App.steamGridDB.enabled && App.steamGridDB.apiKey.length > 0 &&
|
|
nameField.text.trim() !== "" && !App.steamGridDB.busy
|
|
visible: App.steamGridDB.enabled
|
|
onClicked: {
|
|
if (isEditing && game) {
|
|
App.steamGridDB.fetchCover(game)
|
|
}
|
|
}
|
|
}
|
|
|
|
QQC2.Button {
|
|
text: i18n("Clear Cover")
|
|
icon.name: "edit-clear"
|
|
visible: selectedCoverPath !== "" || (isEditing && game && game.coverUrl.toString() !== "")
|
|
onClicked: {
|
|
selectedCoverPath = ""
|
|
if (isEditing && game) {
|
|
game.coverUrl = ""
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FormCard.FormCard {
|
|
Layout.fillWidth: true
|
|
Layout.topMargin: Kirigami.Units.largeSpacing
|
|
|
|
FormCard.FormHeader {
|
|
title: i18n("Help")
|
|
}
|
|
|
|
FormCard.FormTextDelegate {
|
|
text: i18n("To launch an executable, enter its full path:\n\"/path/to/game\"\n\nTo open a file with the default application:\nxdg-open \"/path/to/file\"\n\nIf the path contains spaces, wrap it in quotes.")
|
|
textItem.wrapMode: Text.WordWrap
|
|
textItem.font: Kirigami.Theme.smallFont
|
|
}
|
|
}
|
|
}
|
|
|
|
FileDialog {
|
|
id: fileDialog
|
|
title: i18n("Select Executable")
|
|
fileMode: FileDialog.OpenFile
|
|
onAccepted: {
|
|
let path = selectedFile.toString().replace("file://", "")
|
|
if (path.includes(" ")) {
|
|
executableField.text = "\"" + path + "\""
|
|
} else {
|
|
executableField.text = path
|
|
}
|
|
}
|
|
}
|
|
|
|
FileDialog {
|
|
id: coverDialog
|
|
title: i18n("Select Cover Image")
|
|
fileMode: FileDialog.OpenFile
|
|
nameFilters: [i18n("Image files (*.png *.jpg *.jpeg *.webp)"), i18n("All files (*)")]
|
|
onAccepted: {
|
|
selectedCoverPath = selectedFile.toString().replace("file://", "")
|
|
}
|
|
}
|
|
|
|
FileDialog {
|
|
id: runnerFileDialog
|
|
title: i18n("Select Runner Executable")
|
|
fileMode: FileDialog.OpenFile
|
|
onAccepted: {
|
|
runnerPathField.text = selectedFile.toString().replace("file://", "")
|
|
}
|
|
}
|
|
|
|
FolderDialog {
|
|
id: prefixFolderDialog
|
|
title: i18n("Select Prefix Folder")
|
|
onAccepted: {
|
|
prefixPathField.text = selectedFolder.toString().replace("file://", "")
|
|
}
|
|
}
|
|
|
|
function saveCoverImage(game) {
|
|
if (selectedCoverPath === "") return
|
|
|
|
// Copy cover to app data directory
|
|
let coversPath = StandardPaths.writableLocation(StandardPaths.AppDataLocation) + "/covers"
|
|
let fileName = game.id + ".jpg"
|
|
let destPath = coversPath + "/" + fileName
|
|
|
|
// Use App to copy the file and set cover URL
|
|
App.setCoverFromFile(game, selectedCoverPath)
|
|
}
|
|
|
|
onOpened: {
|
|
loadFields()
|
|
nameField.forceActiveFocus()
|
|
}
|
|
|
|
onGameChanged: loadFields()
|
|
}
|