turns-00051.parquet:9651
94c345a82689e189ecb1cabfdegenerate_repetitionAbsentFinal dense release
USER
ok the windows app when deployed will not in the programs folder but act more like a portable app. So the preferences file will once built sit beside the exe
ASSISTANT
Thanks for clarifying your requirement that the preferences file will reside next to the executable in a portable setup. This means you'll want to write to a file located in the same directory as the application executable instead of using a typical application data directory.
### Implementation Steps
1. **Get the Current Executable Path**: You can determine the path of the executable and create or read the `preferences.txt` file from there.
2. **Read and Write Logic**: Adjust the file operations to refer to this location instead of using the documents directory.
### Updated Code
Here’s how to implement these changes in your `home_screen.dart` file:
#### `home_screen.dart`
```dart
import 'package:fluent_ui/fluent_ui.dart';
import 'package:flutter/services.dart'; // For rootBundle
import 'dart:async';
import 'dart:io';
import 'package:path/path.dart' as path; // For path manipulation
class HomeScreen extends StatefulWidget {
const HomeScreen({super.key});
@override
State<HomeScreen> createState() => _HomeScreenState();
}
class _HomeScreenState extends State<HomeScreen> {
List<String> _dropdownItems = [];
String? _selectedLanguage;
late File preferencesFile;
@override
void initState() {
super.initState();
_loadLanguages();
_setupPreferencesFile(); // Set up the preferences file path
_loadPreferences();
}
void _setupPreferencesFile() {
// Get the current executable path and set the preferences file path
final String exePath = path.dirname(Platform.resolvedExecutable);
preferencesFile = File('$exePath/preferences.txt');
}
Future<void> _loadPreferences() async {
try {
if (await preferencesFile.exists()) {
final String preferences = await preferencesFile.readAsString();
List<String> lines = preferences.split('\n');
if (lines.isNotEmpty) {
String? languageCode = lines[0].split('=').last.trim();
// Check if the loaded language code exists in _dropdownItems
if (_dropdownItems.contains(languageCode)) {
setState(() {
_selectedLanguage = languageCode; // Set the selected language
});
} else {
print("Language from preferences not found in dropdown items. Defaulting to 'en'.");
setState(() {
_selectedLanguage = 'en'; // Default to 'en' if not found
});
}
}
} else {
// If file does not exist, use default language
print("Preferences file does not exist. Defaulting to 'en'.");
setState(() {
_selectedLanguage = 'en';
});
}
} catch (e) {
print("Error loading preferences: $e");
setState(() {
_selectedLanguage = 'en'; // Default to 'en' in case of error
});
}
}
Future<void> _loadLanguages() async {
final Directory dir = Directory('assets/lang'); // Path to the directory
try {
var files = dir.listSync(); // Get the list of files
setState(() {
_dropdownItems = files
.map((file) => file.uri.pathSegments.last) // Get the filename
.map((filename) =>
filename.substring(0, 2)) // Take the first 2 characters
.toSet() // Use set to avoid duplicates
.toList();
// Ensure 'en' is available in dropdownItems
if (!_dropdownItems.contains('en')) {
_dropdownItems.add('en');
}
});
} catch (e) {
print("Error loading languages: $e");
}
}
Future<void> _savePreferences() async {
if (_selectedLanguage != null) {
// Prepare the content
String content = 'lang=$_selectedLanguage\n';
// Write the content to the preferences file
try {
await preferencesFile.writeAsString(content, mode: FileMode.write);
print("Preferences saved: $content"); // Debugging: Print saved content
} catch (e) {
print("Error saving preferences: $e");
}
}
}
@override
Widget build(BuildContext context) {
return ScaffoldPage(
content: Container(
color: const Color.fromARGB(255, 107, 23, 23), // Background color of the main container
child: Column(
children: [
Container(
height: 40, // Height of the top container
color: Colors.black, // Background color
child: Row(
children: [
const Expanded(
child: Center(
child: Text(
'Header',
style: TextStyle(
color: Colors.white, // Text color
fontSize: 22, // Font size
),
),
),
),
// DropDownButton
Padding(
padding: const EdgeInsets.only(right: 10.0),
child: DropDownButton(
title: Text(_selectedLanguage ?? 'Select Language'),
items: _dropdownItems.map((String langCode) {
return MenuFlyoutItem(
text: Text(langCode),
onPressed: () {
setState(() {
_selectedLanguage = langCode; // Update selection
});
},
);
}).toList(),
),
),
],
),
),
Expanded(
child: Container(
color: Colors.blue, // Background color of the remaining area
child: const Center(
child: Text(
'Main Content Area',
style: TextStyle(
color: Colors.white, // Text color for the main content
fontSize: 26, // Font size for the main content
),
),
),
),
),
],
),
),
);
}
// This function can be called when the app closes
void onClose() async {
await _savePreferences();
}
}
```
### How It Works:
1. **Setup Preferences File Path**: The `_setupPreferencesFile` method initializes the `preferencesFile` variable with the path where the executable is located. This is done using `Platform.resolvedExecutable` to get the path to the currently running executable.
2. **Load Preferences**: The `_loadPreferences` method now reads from the `preferences.txt` file in the same directory as the executable.
3. **Save Preferences**: The `_savePreferences` method writes the currently selected dropdown item to the `preferences.txt` file.
### Update `main.dart`
Make sure the `onClose` method in your `MyHomePage` class is still correctly set to call the `onClose` method in `HomeScreen`:
```dart
@override
void onWindowClose() async {
bool isPreventClose = await windowManager.isPreventClose();
if (isPreventClose) {
final homeScreenState = context.findAncestorStateOfType<_HomeScreenState>();
showDialog(
context: context,
builder: (_) {
return ContentDialog(
title: const Text('Confirm close'),
content: const Text('Are you sure you want to close the app?'),
actions: [
FilledButton(
child: const Text('Yes'),
onPressed: () async {
Navigator.pop(context);
await homeScreenState?.onClose(); // Call onClose to save preferences
windowManager.destroy();
},
),
FilledButton(
child: const Text('No'),
onPressed: () {
Navigator.pop(context);
},
)
],
);
},
);
}
}
```
### Conclusion
With this implementation, the preferences will be saved next to the executable, allowing for a portable app experience. Make sure to test the code to verify that the preferences are written and read correctly. If you have any further modifications or questions, feel free to ask!