284 lines
8.7 KiB
Python
284 lines
8.7 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
Tool - Settings Utilities
|
|
Provides utilities for managing user settings and preferences
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import json
|
|
import maya.cmds as cmds
|
|
|
|
# Import configuration
|
|
import config
|
|
|
|
class SettingsUtils:
|
|
"""Utilities for managing user settings and preferences"""
|
|
|
|
def __init__(self):
|
|
"""Initialize settings utilities"""
|
|
self.settings_file = os.path.join(config.ASSETS_PATH, "user_settings.json")
|
|
self.default_settings = {
|
|
"general": {
|
|
"language": "zh_CN", # Chinese
|
|
"theme": "dark", # Dark theme
|
|
"auto_save": True, # Auto save
|
|
"save_interval": 10, # Auto save interval (minutes)
|
|
"show_welcome": True # Show welcome message
|
|
},
|
|
"dna": {
|
|
"default_dna_path": config.DNA_FILE_PATH,
|
|
"auto_load_last": True,
|
|
"backup_before_edit": True
|
|
},
|
|
"calibration": {
|
|
"auto_calibrate": True,
|
|
"show_reference": True,
|
|
"show_differences": True
|
|
},
|
|
"binding": {
|
|
"default_method": "smooth", # smooth, rigid, dual_quaternion
|
|
"mirror_weights": True,
|
|
"normalize_weights": True
|
|
},
|
|
"blendshape": {
|
|
"default_export_format": "obj", # obj, ma, fbx
|
|
"auto_connect_controllers": False,
|
|
"create_corrective_shapes": True
|
|
},
|
|
"ui": {
|
|
"font_size": 9,
|
|
"icon_size": "medium", # small, medium, large
|
|
"show_tooltips": True,
|
|
"confirm_on_exit": True
|
|
},
|
|
"performance": {
|
|
"undo_queue_size": 50,
|
|
"viewport_quality": "medium", # low, medium, high
|
|
"use_gpu_acceleration": True
|
|
}
|
|
}
|
|
self.settings = self.load_settings()
|
|
|
|
def load_settings(self):
|
|
"""
|
|
Load settings from file
|
|
|
|
Returns:
|
|
dict: Settings dictionary
|
|
"""
|
|
try:
|
|
if os.path.exists(self.settings_file):
|
|
with open(self.settings_file, "r") as f:
|
|
settings = json.load(f)
|
|
|
|
# Merge default settings, ensuring all necessary keys exist
|
|
merged_settings = self.default_settings.copy()
|
|
self._merge_dict(merged_settings, settings)
|
|
|
|
print(f"Successfully loaded user settings: {self.settings_file}")
|
|
return merged_settings
|
|
else:
|
|
print(f"Settings file not found, using default settings")
|
|
return self.default_settings.copy()
|
|
except Exception as e:
|
|
cmds.warning(f"Error loading settings: {str(e)}")
|
|
return self.default_settings.copy()
|
|
|
|
def save_settings(self, settings=None):
|
|
"""
|
|
Save settings to file
|
|
|
|
Args:
|
|
settings (dict, optional): Settings to save. If None, save current settings.
|
|
|
|
Returns:
|
|
bool: True if successful, False otherwise
|
|
"""
|
|
try:
|
|
if settings is None:
|
|
settings = self.settings
|
|
|
|
# Ensure directory exists
|
|
settings_dir = os.path.dirname(self.settings_file)
|
|
if not os.path.exists(settings_dir):
|
|
os.makedirs(settings_dir)
|
|
|
|
with open(self.settings_file, "w") as f:
|
|
json.dump(settings, f, indent=4)
|
|
|
|
print(f"Successfully saved user settings: {self.settings_file}")
|
|
return True
|
|
except Exception as e:
|
|
cmds.warning(f"Error saving settings: {str(e)}")
|
|
return False
|
|
|
|
def get_setting(self, category, key, default=None):
|
|
"""
|
|
Get a specific setting
|
|
|
|
Args:
|
|
category (str): Setting category
|
|
key (str): Setting key
|
|
default (any, optional): Default value if setting not found
|
|
|
|
Returns:
|
|
any: Setting value
|
|
"""
|
|
try:
|
|
if category in self.settings and key in self.settings[category]:
|
|
return self.settings[category][key]
|
|
return default
|
|
except Exception as e:
|
|
cmds.warning(f"Error getting setting: {str(e)}")
|
|
return default
|
|
|
|
def set_setting(self, category, key, value):
|
|
"""
|
|
Set a specific setting
|
|
|
|
Args:
|
|
category (str): Setting category
|
|
key (str): Setting key
|
|
value (any): Setting value
|
|
|
|
Returns:
|
|
bool: True if successful, False otherwise
|
|
"""
|
|
try:
|
|
if category not in self.settings:
|
|
self.settings[category] = {}
|
|
|
|
self.settings[category][key] = value
|
|
return True
|
|
except Exception as e:
|
|
cmds.warning(f"Error setting setting: {str(e)}")
|
|
return False
|
|
|
|
def reset_settings(self, category=None):
|
|
"""
|
|
Reset settings to default
|
|
|
|
Args:
|
|
category (str, optional): Category to reset. If None, reset all settings.
|
|
|
|
Returns:
|
|
bool: True if successful, False otherwise
|
|
"""
|
|
try:
|
|
if category is None:
|
|
self.settings = self.default_settings.copy()
|
|
elif category in self.settings and category in self.default_settings:
|
|
self.settings[category] = self.default_settings[category].copy()
|
|
else:
|
|
return False
|
|
|
|
return True
|
|
except Exception as e:
|
|
cmds.warning(f"Error resetting settings: {str(e)}")
|
|
return False
|
|
|
|
def get_theme(self):
|
|
"""
|
|
Get current theme
|
|
|
|
Returns:
|
|
str: Theme name
|
|
"""
|
|
return self.get_setting("ui", "theme", "dark")
|
|
|
|
def get_language(self):
|
|
"""
|
|
Get current language
|
|
|
|
Returns:
|
|
str: Language code
|
|
"""
|
|
return self.get_setting("general", "language", "zh_CN")
|
|
|
|
def get_all_settings(self):
|
|
"""
|
|
Get all settings
|
|
|
|
Returns:
|
|
dict: All settings
|
|
"""
|
|
return self.settings.copy()
|
|
|
|
def import_settings(self, file_path):
|
|
"""
|
|
Import settings from file
|
|
|
|
Args:
|
|
file_path (str): Path to settings file
|
|
|
|
Returns:
|
|
bool: True if successful, False otherwise
|
|
"""
|
|
try:
|
|
if not os.path.exists(file_path):
|
|
cmds.warning(f"Settings file not found: {file_path}")
|
|
return False
|
|
|
|
with open(file_path, "r") as f:
|
|
settings = json.load(f)
|
|
|
|
# Merge imported settings
|
|
merged_settings = self.settings.copy()
|
|
self._merge_dict(merged_settings, settings)
|
|
|
|
self.settings = merged_settings
|
|
self.save_settings()
|
|
|
|
print(f"Successfully imported settings: {file_path}")
|
|
return True
|
|
except Exception as e:
|
|
cmds.warning(f"Error importing settings: {str(e)}")
|
|
return False
|
|
|
|
def export_settings(self, file_path):
|
|
"""
|
|
Export settings to file
|
|
|
|
Args:
|
|
file_path (str): Path to save settings file
|
|
|
|
Returns:
|
|
bool: True if successful, False otherwise
|
|
"""
|
|
try:
|
|
# Ensure directory exists
|
|
settings_dir = os.path.dirname(file_path)
|
|
if not os.path.exists(settings_dir):
|
|
os.makedirs(settings_dir)
|
|
|
|
with open(file_path, "w") as f:
|
|
json.dump(self.settings, f, indent=4)
|
|
|
|
print(f"Successfully exported settings: {file_path}")
|
|
return True
|
|
except Exception as e:
|
|
cmds.warning(f"Error exporting settings: {str(e)}")
|
|
return False
|
|
|
|
def _merge_dict(self, target, source):
|
|
"""
|
|
Recursively merge two dictionaries
|
|
|
|
Args:
|
|
target (dict): Target dictionary
|
|
source (dict): Source dictionary
|
|
|
|
Returns:
|
|
dict: Merged dictionary
|
|
"""
|
|
for key, value in source.items():
|
|
if key in target and isinstance(target[key], dict) and isinstance(value, dict):
|
|
self._merge_dict(target[key], value)
|
|
else:
|
|
target[key] = value
|
|
|
|
return target
|