666 lines
21 KiB
Go
666 lines
21 KiB
Go
package ui
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
|
|
"turtlesilicon/pkg/debug"
|
|
"turtlesilicon/pkg/launcher"
|
|
"turtlesilicon/pkg/patching"
|
|
"turtlesilicon/pkg/service"
|
|
"turtlesilicon/pkg/utils"
|
|
|
|
"fyne.io/fyne/v2"
|
|
"fyne.io/fyne/v2/container"
|
|
"fyne.io/fyne/v2/dialog"
|
|
"fyne.io/fyne/v2/widget"
|
|
)
|
|
|
|
// createOptionsComponents initializes all option-related UI components
|
|
func createOptionsComponents() {
|
|
// Load preferences for initial values
|
|
prefs, _ := utils.LoadPrefs()
|
|
|
|
metalHudCheckbox = widget.NewCheck("Enable Metal Hud (show FPS)", func(checked bool) {
|
|
launcher.EnableMetalHud = checked
|
|
debug.Printf("Metal HUD enabled: %v", launcher.EnableMetalHud)
|
|
})
|
|
metalHudCheckbox.SetChecked(launcher.EnableMetalHud)
|
|
|
|
showTerminalCheckbox = widget.NewCheck("Show Terminal", func(checked bool) {
|
|
// Save to preferences
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.ShowTerminalNormally = checked
|
|
utils.SavePrefs(prefs)
|
|
debug.Printf("Show terminal normally: %v", checked)
|
|
})
|
|
showTerminalCheckbox.SetChecked(prefs.ShowTerminalNormally)
|
|
|
|
vanillaTweaksCheckbox = widget.NewCheck("Enable vanilla-tweaks", func(checked bool) {
|
|
launcher.EnableVanillaTweaks = checked
|
|
// Save to preferences
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.EnableVanillaTweaks = checked
|
|
utils.SavePrefs(prefs)
|
|
debug.Printf("Vanilla-tweaks enabled: %v", launcher.EnableVanillaTweaks)
|
|
})
|
|
vanillaTweaksCheckbox.SetChecked(prefs.EnableVanillaTweaks)
|
|
launcher.EnableVanillaTweaks = prefs.EnableVanillaTweaks
|
|
|
|
autoDeleteWdbCheckbox = widget.NewCheck("Auto-delete WDB directory on launch", func(checked bool) {
|
|
launcher.AutoDeleteWdb = checked
|
|
// Save to preferences
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.AutoDeleteWdb = checked
|
|
utils.SavePrefs(prefs)
|
|
debug.Printf("Auto-delete WDB enabled: %v", launcher.AutoDeleteWdb)
|
|
})
|
|
autoDeleteWdbCheckbox.SetChecked(prefs.AutoDeleteWdb)
|
|
launcher.AutoDeleteWdb = prefs.AutoDeleteWdb
|
|
|
|
// Create recommended settings button with help icon
|
|
applyRecommendedSettingsButton = widget.NewButton("Apply recommended settings", func() {
|
|
err := launcher.ApplyRecommendedSettings()
|
|
if err != nil {
|
|
debug.Printf("Failed to apply recommended settings: %v", err)
|
|
// Show error dialog if we have a window reference
|
|
if currentWindow != nil {
|
|
dialog.ShowError(fmt.Errorf("failed to apply recommended settings: %v", err), currentWindow)
|
|
}
|
|
} else {
|
|
debug.Printf("Successfully applied recommended settings")
|
|
// Show success dialog if we have a window reference
|
|
if currentWindow != nil {
|
|
dialog.ShowInformation("Success", "Recommended graphics settings have been applied", currentWindow)
|
|
}
|
|
// Update button state
|
|
updateRecommendedSettingsButton()
|
|
}
|
|
})
|
|
applyRecommendedSettingsButton.Importance = widget.MediumImportance
|
|
|
|
// Create help button for recommended settings
|
|
recommendedSettingsHelpButton = widget.NewButton("?", func() {
|
|
showRecommendedSettingsHelpPopup()
|
|
})
|
|
recommendedSettingsHelpButton.Importance = widget.MediumImportance
|
|
// Initialize button state
|
|
updateRecommendedSettingsButton()
|
|
|
|
// Create Wine registry Option-as-Alt buttons and status
|
|
createWineRegistryComponents()
|
|
|
|
// Create graphics settings components
|
|
createGraphicsSettingsComponents()
|
|
|
|
// Load environment variables from preferences
|
|
if prefs.EnvironmentVariables != "" {
|
|
launcher.CustomEnvVars = prefs.EnvironmentVariables
|
|
}
|
|
|
|
envVarsEntry = widget.NewEntry()
|
|
envVarsEntry.SetPlaceHolder(`Custom environment variables (KEY=VALUE format)`)
|
|
envVarsEntry.SetText(launcher.CustomEnvVars)
|
|
envVarsEntry.OnChanged = func(text string) {
|
|
launcher.CustomEnvVars = text
|
|
// Save to preferences
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.EnvironmentVariables = text
|
|
utils.SavePrefs(prefs)
|
|
debug.Printf("Environment variables updated: %v", launcher.CustomEnvVars)
|
|
}
|
|
}
|
|
|
|
// createPatchingButtons creates all patching-related buttons
|
|
func createPatchingButtons(myWindow fyne.Window) {
|
|
patchTurtleWoWButton = widget.NewButton("Patch TurtleWoW", func() {
|
|
patching.PatchTurtleWoW(myWindow, UpdateAllStatuses)
|
|
})
|
|
unpatchTurtleWoWButton = widget.NewButton("Unpatch TurtleWoW", func() {
|
|
patching.UnpatchTurtleWoW(myWindow, UpdateAllStatuses)
|
|
})
|
|
patchCrossOverButton = widget.NewButton("Patch CrossOver", func() {
|
|
patching.PatchCrossOver(myWindow, UpdateAllStatuses)
|
|
})
|
|
unpatchCrossOverButton = widget.NewButton("Unpatch CrossOver", func() {
|
|
patching.UnpatchCrossOver(myWindow, UpdateAllStatuses)
|
|
})
|
|
}
|
|
|
|
// createServiceButtons creates service-related buttons
|
|
func createServiceButtons(myWindow fyne.Window) {
|
|
startServiceButton = widget.NewButton("Start Service", func() {
|
|
service.StartRosettaX87Service(myWindow, UpdateAllStatuses)
|
|
})
|
|
stopServiceButton = widget.NewButton("Stop Service", func() {
|
|
service.StopRosettaX87Service(myWindow, UpdateAllStatuses)
|
|
})
|
|
}
|
|
|
|
// createLaunchButton creates the legacy launch button
|
|
func createLaunchButton(myWindow fyne.Window) {
|
|
launchButton = widget.NewButton("Launch Game", func() {
|
|
launcher.LaunchGame(myWindow)
|
|
})
|
|
}
|
|
|
|
// createBottomBar creates the bottom bar with Options, GitHub, and PLAY buttons
|
|
func createBottomBar(myWindow fyne.Window) fyne.CanvasObject {
|
|
// Set the current window for popup functionality
|
|
currentWindow = myWindow
|
|
|
|
// Options button
|
|
optionsButton := widget.NewButton("Options", func() {
|
|
showOptionsPopup()
|
|
})
|
|
|
|
// Troubleshooting button
|
|
troubleshootingButton = widget.NewButton("Troubleshooting", func() {
|
|
showTroubleshootingPopup()
|
|
})
|
|
|
|
// GitHub button
|
|
githubButton := widget.NewButton("GitHub", func() {
|
|
githubURL := "https://github.com/tairasu/TurtleSilicon"
|
|
parsedURL, err := url.Parse(githubURL)
|
|
if err != nil {
|
|
debug.Printf("Error parsing GitHub URL: %v", err)
|
|
return
|
|
}
|
|
fyne.CurrentApp().OpenURL(parsedURL)
|
|
})
|
|
playButtonText = widget.NewRichTextFromMarkdown("# PLAY")
|
|
playButtonText.Wrapping = fyne.TextWrapOff
|
|
|
|
playButton = widget.NewButton("", func() {
|
|
launcher.LaunchGame(myWindow)
|
|
})
|
|
playButton.Importance = widget.HighImportance
|
|
playButton.Disable()
|
|
|
|
playButtonWithText := container.NewStack(
|
|
playButton,
|
|
container.NewCenter(playButtonText),
|
|
)
|
|
|
|
leftButtons := container.NewHBox(
|
|
optionsButton,
|
|
troubleshootingButton,
|
|
githubButton,
|
|
)
|
|
|
|
// Create the large play button with fixed size
|
|
buttonWidth := float32(120)
|
|
buttonHeight := float32(80)
|
|
playButtonWithText.Resize(fyne.NewSize(buttonWidth, buttonHeight))
|
|
|
|
// Create a container for the play button that ensures it's positioned at bottom-right
|
|
playButtonContainer := container.NewWithoutLayout(playButtonWithText)
|
|
playButtonContainer.Resize(fyne.NewSize(buttonWidth+40, buttonHeight+20)) // Add padding
|
|
|
|
playButtonWithText.Move(fyne.NewPos(-50, -32))
|
|
|
|
// Use border layout to position elements
|
|
bottomContainer := container.NewBorder(
|
|
nil, // top
|
|
nil, // bottom
|
|
leftButtons, // left
|
|
playButtonContainer, // right - our large play button
|
|
nil, // center
|
|
)
|
|
|
|
return container.NewPadded(bottomContainer)
|
|
}
|
|
|
|
// createWineRegistryComponents creates Wine registry Option-as-Alt buttons and status
|
|
func createWineRegistryComponents() {
|
|
// Create status label to show current state
|
|
optionAsAltStatusLabel = widget.NewRichText()
|
|
|
|
// Create enable button
|
|
enableOptionAsAltButton = widget.NewButton("Enable", func() {
|
|
enableOptionAsAltButton.Disable()
|
|
disableOptionAsAltButton.Disable()
|
|
remapOperationInProgress = true
|
|
|
|
// Show loading state in status label
|
|
fyne.Do(func() {
|
|
optionAsAltStatusLabel.ParseMarkdown("**Remap Option key as Alt key:** Enabling...")
|
|
startPulsingEffect()
|
|
})
|
|
|
|
// Run in goroutine to avoid blocking UI
|
|
go func() {
|
|
defer func() {
|
|
remapOperationInProgress = false
|
|
}()
|
|
|
|
if err := utils.SetOptionAsAltEnabled(true); err != nil {
|
|
debug.Printf("Failed to enable Option-as-Alt mapping: %v", err)
|
|
// Update UI on main thread
|
|
fyne.Do(func() {
|
|
stopPulsingEffect()
|
|
optionAsAltStatusLabel.ParseMarkdown("**Remap Option key as Alt key:** Enable Failed")
|
|
})
|
|
time.Sleep(2 * time.Second) // Show error briefly
|
|
} else {
|
|
debug.Printf("Successfully enabled Option-as-Alt mapping")
|
|
// Update preferences
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.RemapOptionAsAlt = true
|
|
utils.SavePrefs(prefs)
|
|
}
|
|
|
|
// Update UI on main thread
|
|
fyne.Do(func() {
|
|
stopPulsingEffect()
|
|
updateWineRegistryStatusWithMethod(true) // Use Wine command for accurate check after modifications
|
|
})
|
|
}()
|
|
})
|
|
|
|
// Create disable button
|
|
disableOptionAsAltButton = widget.NewButton("Disable", func() {
|
|
enableOptionAsAltButton.Disable()
|
|
disableOptionAsAltButton.Disable()
|
|
remapOperationInProgress = true
|
|
|
|
// Show loading state in status label
|
|
fyne.Do(func() {
|
|
optionAsAltStatusLabel.ParseMarkdown("**Remap Option key as Alt key:** Disabling...")
|
|
startPulsingEffect()
|
|
})
|
|
|
|
// Run in goroutine to avoid blocking UI
|
|
go func() {
|
|
defer func() {
|
|
remapOperationInProgress = false
|
|
}()
|
|
|
|
if err := utils.SetOptionAsAltEnabled(false); err != nil {
|
|
debug.Printf("Failed to disable Option-as-Alt mapping: %v", err)
|
|
// Update UI on main thread
|
|
fyne.Do(func() {
|
|
stopPulsingEffect()
|
|
optionAsAltStatusLabel.ParseMarkdown("**Remap Option key as Alt key:** Disable Failed")
|
|
})
|
|
time.Sleep(2 * time.Second) // Show error briefly
|
|
} else {
|
|
debug.Printf("Successfully disabled Option-as-Alt mapping")
|
|
// Update preferences
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.RemapOptionAsAlt = false
|
|
utils.SavePrefs(prefs)
|
|
}
|
|
|
|
// Update UI on main thread
|
|
fyne.Do(func() {
|
|
stopPulsingEffect()
|
|
updateWineRegistryStatusWithMethod(true) // Use Wine command for accurate check after modifications
|
|
})
|
|
}()
|
|
})
|
|
|
|
// Style the buttons similar to other action buttons
|
|
enableOptionAsAltButton.Importance = widget.MediumImportance
|
|
disableOptionAsAltButton.Importance = widget.MediumImportance
|
|
|
|
// Initialize status and button states
|
|
updateWineRegistryStatus()
|
|
}
|
|
|
|
// updateWineRegistryStatus updates the Wine registry status label and button states
|
|
func updateWineRegistryStatus() {
|
|
updateWineRegistryStatusWithMethod(false)
|
|
}
|
|
|
|
// updateWineRegistryStatusWithMethod updates status with choice of checking method
|
|
func updateWineRegistryStatusWithMethod(useWineCommand bool) {
|
|
if useWineCommand {
|
|
// Use Wine command for accurate check after modifications
|
|
currentWineRegistryEnabled = utils.CheckOptionAsAltEnabled()
|
|
} else {
|
|
// Use fast file-based check for regular status updates
|
|
currentWineRegistryEnabled = utils.CheckOptionAsAltEnabledFast()
|
|
}
|
|
|
|
// Update UI with simple white text
|
|
if currentWineRegistryEnabled {
|
|
optionAsAltStatusLabel.ParseMarkdown("**Remap Option key as Alt key:** Enabled")
|
|
} else {
|
|
optionAsAltStatusLabel.ParseMarkdown("**Remap Option key as Alt key:** Disabled")
|
|
}
|
|
|
|
// Update button states based on current status
|
|
if currentWineRegistryEnabled {
|
|
// If enabled, only show disable button as clickable
|
|
enableOptionAsAltButton.Disable()
|
|
disableOptionAsAltButton.Enable()
|
|
} else {
|
|
// If disabled, only show enable button as clickable
|
|
enableOptionAsAltButton.Enable()
|
|
disableOptionAsAltButton.Disable()
|
|
}
|
|
}
|
|
|
|
// startPulsingEffect starts a pulsing animation for the status label during loading
|
|
func startPulsingEffect() {
|
|
if pulsingActive {
|
|
return // Already pulsing
|
|
}
|
|
|
|
pulsingActive = true
|
|
pulsingTicker = time.NewTicker(500 * time.Millisecond)
|
|
|
|
go func() {
|
|
dots := ""
|
|
|
|
for pulsingActive {
|
|
<-pulsingTicker.C
|
|
if pulsingActive {
|
|
// Cycle through different dot patterns for visual effect
|
|
switch len(dots) {
|
|
case 0:
|
|
dots = "."
|
|
case 1:
|
|
dots = ".."
|
|
case 2:
|
|
dots = "..."
|
|
default:
|
|
dots = ""
|
|
}
|
|
|
|
// Update the label with pulsing dots
|
|
fyne.Do(func() {
|
|
if pulsingActive && optionAsAltStatusLabel != nil {
|
|
// Use the dots directly in the status text
|
|
if strings.Contains(optionAsAltStatusLabel.String(), "Enabling") {
|
|
optionAsAltStatusLabel.ParseMarkdown("**Remap Option key as Alt key:** Enabling" + dots)
|
|
} else if strings.Contains(optionAsAltStatusLabel.String(), "Disabling") {
|
|
optionAsAltStatusLabel.ParseMarkdown("**Remap Option key as Alt key:** Disabling" + dots)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
// stopPulsingEffect stops the pulsing animation
|
|
func stopPulsingEffect() {
|
|
if !pulsingActive {
|
|
return
|
|
}
|
|
|
|
pulsingActive = false
|
|
if pulsingTicker != nil {
|
|
pulsingTicker.Stop()
|
|
pulsingTicker = nil
|
|
}
|
|
}
|
|
|
|
// updateRecommendedSettingsButton updates the state of the recommended settings button
|
|
func updateRecommendedSettingsButton() {
|
|
if applyRecommendedSettingsButton == nil {
|
|
return
|
|
}
|
|
|
|
// Check if all recommended settings are already applied
|
|
if launcher.CheckRecommendedSettings() {
|
|
applyRecommendedSettingsButton.Disable()
|
|
applyRecommendedSettingsButton.SetText("Settings applied")
|
|
} else {
|
|
applyRecommendedSettingsButton.Enable()
|
|
applyRecommendedSettingsButton.SetText("Apply recommended settings")
|
|
}
|
|
|
|
// Help button should always be enabled
|
|
if recommendedSettingsHelpButton != nil {
|
|
recommendedSettingsHelpButton.Enable()
|
|
}
|
|
}
|
|
|
|
// showRecommendedSettingsHelpPopup shows a popup explaining the recommended graphics settings
|
|
func showRecommendedSettingsHelpPopup() {
|
|
if currentWindow == nil {
|
|
return
|
|
}
|
|
|
|
// Create help content
|
|
helpTitle := widget.NewRichTextFromMarkdown("# 📋 Recommended Graphics Settings")
|
|
|
|
// Create individual setting labels for better formatting
|
|
settingsTitle := widget.NewLabel("The following settings will be applied to your Config.wtf file:")
|
|
settingsTitle.TextStyle = fyne.TextStyle{Bold: true}
|
|
|
|
setting1 := widget.NewLabel("• Terrain Distance (farclip): 177 - Reduces CPU overhead - more fps")
|
|
setting2 := widget.NewLabel("• Vertex Animation Shaders (M2UseShaders): Enabled - Prevents graphic glitches")
|
|
setting3 := widget.NewLabel("• Multisampling (gxMultisample): 2x - Makes portraits load properly")
|
|
|
|
settingsContainer := container.NewVBox(
|
|
settingsTitle,
|
|
widget.NewSeparator(),
|
|
setting1,
|
|
setting2,
|
|
setting3,
|
|
widget.NewSeparator(),
|
|
)
|
|
|
|
// Create OK button
|
|
okButton := widget.NewButton("OK", func() {
|
|
// This will be set when the popup is created
|
|
})
|
|
okButton.Importance = widget.MediumImportance
|
|
|
|
// Create help content container
|
|
helpContentContainer := container.NewVBox(
|
|
container.NewCenter(helpTitle),
|
|
widget.NewSeparator(),
|
|
settingsContainer,
|
|
widget.NewSeparator(),
|
|
container.NewCenter(okButton),
|
|
)
|
|
|
|
// Calculate popup size
|
|
windowSize := currentWindow.Content().Size()
|
|
popupWidth := windowSize.Width * 3 / 4
|
|
popupHeight := windowSize.Height * 3 / 4
|
|
|
|
// Create the help popup
|
|
helpPopup := widget.NewModalPopUp(container.NewPadded(helpContentContainer), currentWindow.Canvas())
|
|
helpPopup.Resize(fyne.NewSize(popupWidth, popupHeight))
|
|
|
|
// Set the OK button action to hide the help popup
|
|
okButton.OnTapped = func() {
|
|
helpPopup.Hide()
|
|
}
|
|
|
|
helpPopup.Show()
|
|
}
|
|
|
|
// createGraphicsSettingsComponents creates all graphics settings checkboxes and buttons
|
|
func createGraphicsSettingsComponents() {
|
|
// Load preferences for initial values
|
|
prefs, _ := utils.LoadPrefs()
|
|
|
|
// Create Reduce Terrain Distance setting with help button
|
|
reduceTerrainDistanceCheckbox = widget.NewCheck("", func(checked bool) {
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.ReduceTerrainDistance = checked
|
|
utils.SavePrefs(prefs)
|
|
debug.Printf("Reduce terrain distance: %v", checked)
|
|
updateApplyGraphicsSettingsButton()
|
|
})
|
|
reduceTerrainDistanceCheckbox.SetChecked(prefs.ReduceTerrainDistance)
|
|
|
|
reduceTerrainDistanceHelpButton = widget.NewButton("?", func() {
|
|
showGraphicsSettingHelpPopup("Reduce Terrain Distance", "Sets the draw distance to the lowest setting. This will drastically increase your FPS", "High Performance Impact")
|
|
})
|
|
reduceTerrainDistanceHelpButton.Importance = widget.MediumImportance
|
|
|
|
// Create Set Multisample to 2x setting with help button
|
|
setMultisampleTo2xCheckbox = widget.NewCheck("", func(checked bool) {
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.SetMultisampleTo2x = checked
|
|
utils.SavePrefs(prefs)
|
|
debug.Printf("Set multisample to 2x: %v", checked)
|
|
updateApplyGraphicsSettingsButton()
|
|
})
|
|
setMultisampleTo2xCheckbox.SetChecked(prefs.SetMultisampleTo2x)
|
|
|
|
setMultisampleTo2xHelpButton = widget.NewButton("?", func() {
|
|
showGraphicsSettingHelpPopup("Set Multisample to 2x", "Might reduce your FPS slightly on lower end machines, but makes sure the portraits load properly.", "Medium Performance Impact")
|
|
})
|
|
setMultisampleTo2xHelpButton.Importance = widget.MediumImportance
|
|
|
|
// Create Set Shadow LOD to 0 setting with help button
|
|
setShadowLOD0Checkbox = widget.NewCheck("", func(checked bool) {
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.SetShadowLOD0 = checked
|
|
|
|
// Track if user manually disabled this setting
|
|
if !checked {
|
|
prefs.UserDisabledShadowLOD = true
|
|
} else {
|
|
prefs.UserDisabledShadowLOD = false
|
|
}
|
|
|
|
utils.SavePrefs(prefs)
|
|
debug.Printf("Set shadow LOD to 0: %v (user manually changed)", checked)
|
|
updateApplyGraphicsSettingsButton()
|
|
})
|
|
setShadowLOD0Checkbox.SetChecked(prefs.SetShadowLOD0)
|
|
|
|
setShadowLOD0HelpButton = widget.NewButton("?", func() {
|
|
showGraphicsSettingHelpPopup("Set Shadow LOD to 0", "Turns off all shadows. This will give you ~10% more FPS.", "High Performance Impact")
|
|
})
|
|
setShadowLOD0HelpButton.Importance = widget.MediumImportance
|
|
|
|
// Create Enable libSiliconPatch setting with help button
|
|
libSiliconPatchCheckbox = widget.NewCheck("", func(checked bool) {
|
|
prefs, _ := utils.LoadPrefs()
|
|
prefs.EnableLibSiliconPatch = checked
|
|
|
|
// Track if user manually disabled this setting
|
|
if !checked {
|
|
prefs.UserDisabledLibSiliconPatch = true
|
|
} else {
|
|
prefs.UserDisabledLibSiliconPatch = false
|
|
}
|
|
|
|
utils.SavePrefs(prefs)
|
|
debug.Printf("Enable libSiliconPatch: %v (user manually changed)", checked)
|
|
updateApplyGraphicsSettingsButton()
|
|
})
|
|
libSiliconPatchCheckbox.SetChecked(prefs.EnableLibSiliconPatch)
|
|
|
|
libSiliconPatchHelpButton = widget.NewButton("?", func() {
|
|
showGraphicsSettingHelpPopup("Enable libSiliconPatch", "Hooks into the WoW process and replaces slow X87 instructions with SSE2 instructions that Rosetta can translate much quicker, resulting in an increase in FPS (2x or more). May potentially cause graphical bugs.", "Very High Performance Impact")
|
|
})
|
|
libSiliconPatchHelpButton.Importance = widget.MediumImportance
|
|
|
|
applyGraphicsSettingsButton = widget.NewButton("Apply Graphics Settings", func() {
|
|
err := patching.ApplyGraphicsSettings(currentWindow)
|
|
if err != nil {
|
|
debug.Printf("Failed to apply graphics settings: %v", err)
|
|
if currentWindow != nil {
|
|
dialog.ShowError(fmt.Errorf("failed to apply graphics settings: %v", err), currentWindow)
|
|
}
|
|
} else {
|
|
debug.Printf("Successfully applied graphics settings")
|
|
if currentWindow != nil {
|
|
dialog.ShowInformation("Success", "Graphics settings have been applied", currentWindow)
|
|
}
|
|
// Refresh checkboxes to reflect current state
|
|
refreshGraphicsSettingsCheckboxes()
|
|
}
|
|
})
|
|
applyGraphicsSettingsButton.Importance = widget.MediumImportance
|
|
|
|
// Initialize button state
|
|
updateApplyGraphicsSettingsButton()
|
|
}
|
|
|
|
// updateApplyGraphicsSettingsButton updates the state of the apply graphics settings button
|
|
func updateApplyGraphicsSettingsButton() {
|
|
if applyGraphicsSettingsButton == nil {
|
|
return
|
|
}
|
|
|
|
// Always enable the button since we need to handle both adding and removing settings
|
|
applyGraphicsSettingsButton.Enable()
|
|
applyGraphicsSettingsButton.SetText("Apply Changes")
|
|
}
|
|
|
|
// refreshGraphicsSettingsCheckboxes updates the checkbox states from current preferences
|
|
func refreshGraphicsSettingsCheckboxes() {
|
|
prefs, _ := utils.LoadPrefs()
|
|
|
|
if reduceTerrainDistanceCheckbox != nil {
|
|
reduceTerrainDistanceCheckbox.SetChecked(prefs.ReduceTerrainDistance)
|
|
}
|
|
if setMultisampleTo2xCheckbox != nil {
|
|
setMultisampleTo2xCheckbox.SetChecked(prefs.SetMultisampleTo2x)
|
|
}
|
|
if setShadowLOD0Checkbox != nil {
|
|
setShadowLOD0Checkbox.SetChecked(prefs.SetShadowLOD0)
|
|
}
|
|
if libSiliconPatchCheckbox != nil {
|
|
libSiliconPatchCheckbox.SetChecked(prefs.EnableLibSiliconPatch)
|
|
}
|
|
|
|
// Update the apply button state
|
|
updateApplyGraphicsSettingsButton()
|
|
}
|
|
|
|
// showGraphicsSettingHelpPopup shows a help popup for a specific graphics setting
|
|
func showGraphicsSettingHelpPopup(title, description, impact string) {
|
|
if currentWindow == nil {
|
|
return
|
|
}
|
|
|
|
// Create help content
|
|
helpTitle := widget.NewRichTextFromMarkdown("# " + title)
|
|
|
|
descriptionLabel := widget.NewLabel(description)
|
|
descriptionLabel.Wrapping = fyne.TextWrapWord
|
|
|
|
impactLabel := widget.NewLabel(impact)
|
|
impactLabel.TextStyle = fyne.TextStyle{Bold: true}
|
|
|
|
// Create OK button
|
|
okButton := widget.NewButton("OK", func() {
|
|
// This will be set when the popup is created
|
|
})
|
|
okButton.Importance = widget.MediumImportance
|
|
|
|
// Create help content container
|
|
helpContentContainer := container.NewVBox(
|
|
container.NewCenter(helpTitle),
|
|
widget.NewSeparator(),
|
|
descriptionLabel,
|
|
widget.NewSeparator(),
|
|
impactLabel,
|
|
widget.NewSeparator(),
|
|
container.NewCenter(okButton),
|
|
)
|
|
|
|
// Calculate popup size
|
|
windowSize := currentWindow.Content().Size()
|
|
popupWidth := windowSize.Width * 2 / 3
|
|
popupHeight := windowSize.Height / 2
|
|
|
|
// Create the help popup
|
|
helpPopup := widget.NewModalPopUp(container.NewPadded(helpContentContainer), currentWindow.Canvas())
|
|
helpPopup.Resize(fyne.NewSize(popupWidth, popupHeight))
|
|
|
|
// Set the OK button action to hide the help popup
|
|
okButton.OnTapped = func() {
|
|
helpPopup.Hide()
|
|
}
|
|
|
|
helpPopup.Show()
|
|
}
|