mirror of
https://github.com/shlomif/PySolFC.git
synced 2025-04-05 00:02:29 -04:00
947 lines
32 KiB
Python
947 lines
32 KiB
Python
#!/usr/bin/env python
|
|
# -*- mode: python; coding: utf-8; -*-
|
|
# ---------------------------------------------------------------------------##
|
|
#
|
|
# Copyright (C) 1998-2003 Markus Franz Xaver Johannes Oberhumer
|
|
# Copyright (C) 2003 Mt. Hood Playing Card Co.
|
|
# Copyright (C) 2005-2009 Skomoroh
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# ---------------------------------------------------------------------------##
|
|
|
|
import os
|
|
import sys
|
|
import traceback
|
|
|
|
import configobj
|
|
|
|
import pysollib.settings
|
|
from pysollib.mfxutil import USE_PIL, \
|
|
get_default_resampling, print_err
|
|
from pysollib.mygettext import _
|
|
from pysollib.mygettext import myGettext
|
|
from pysollib.pysoltk import STATUSBAR_ITEMS, TOOLBAR_BUTTONS, TOOLKIT
|
|
from pysollib.resource import CSI
|
|
|
|
import validate
|
|
|
|
# ************************************************************************
|
|
# * Options
|
|
# ************************************************************************
|
|
|
|
_global_settings = {
|
|
'mouse_button1': 1,
|
|
'mouse_button2': 2,
|
|
'mouse_button3': 3,
|
|
}
|
|
|
|
|
|
def calcCustomMouseButtonsBinding(binding_format):
|
|
assert _global_settings['mouse_button1']
|
|
return binding_format.format(
|
|
mouse_button1=_global_settings['mouse_button1'],
|
|
mouse_button2=_global_settings['mouse_button2'],
|
|
mouse_button3=_global_settings['mouse_button3'],
|
|
)
|
|
|
|
|
|
configspec = '''
|
|
[general]
|
|
last_version = list
|
|
player = string
|
|
confirm = boolean
|
|
update_player_stats = boolean
|
|
autofaceup = boolean
|
|
autodrop = boolean
|
|
autodeal = boolean
|
|
quickplay = boolean
|
|
shuffle = boolean
|
|
undo = boolean
|
|
bookmarks = boolean
|
|
hint = boolean
|
|
free_hint = boolean
|
|
highlight_piles = boolean
|
|
highlight_cards = boolean
|
|
highlight_samerank = boolean
|
|
highlight_not_matching = boolean
|
|
peek_facedown = boolean
|
|
stuck_notification = boolean
|
|
mahjongg_show_removed = boolean
|
|
mahjongg_create_solvable = integer(0, 2)
|
|
shisen_show_hint = boolean
|
|
shisen_show_matching = boolean
|
|
animations = integer(0, 5)
|
|
redeal_animation = boolean
|
|
win_animation = boolean
|
|
flip_animation = boolean
|
|
compact_stacks = boolean
|
|
shadow = boolean
|
|
shade = boolean
|
|
shrink_face_down = boolean
|
|
shade_filled_stacks = boolean
|
|
demo_logo = boolean
|
|
demo_logo_style = string
|
|
pause_text_style = string
|
|
redeal_icon_style = string
|
|
dialog_icon_style = string
|
|
tree_icon_style = string
|
|
button_icon_style = string
|
|
tile_theme = string
|
|
default_tile_theme = string
|
|
toolbar = integer(0, 4)
|
|
toolbar_land = integer(0, 4)
|
|
toolbar_port = integer(0, 4)
|
|
toolbar_style = string
|
|
toolbar_relief = string
|
|
toolbar_compound = string
|
|
toolbar_size = integer(0, 2)
|
|
statusbar = boolean
|
|
num_recent_games = integer(10, 100)
|
|
last_gameid = integer
|
|
game_holded = integer
|
|
wm_maximized = boolean
|
|
wm_fullscreen = boolean
|
|
splashscreen = boolean
|
|
date_format = string
|
|
mouse_type = string
|
|
mouse_undo = boolean
|
|
negative_bottom = boolean
|
|
randomize_place = boolean
|
|
use_cardset_bottoms = boolean
|
|
dragcursor = boolean
|
|
save_games_geometry = boolean
|
|
game_geometry = int_list(min=2, max=2)
|
|
topmost_dialogs = boolean
|
|
sound = boolean
|
|
sound_mode = integer(0, 1)
|
|
sound_sample_volume = integer(0, 128)
|
|
sound_sample_buffer_size = integer(1, 4)
|
|
music = boolean
|
|
tabletile_name = string
|
|
tabletile_scale_method = integer
|
|
center_layout = boolean
|
|
recent_gameid = int_list
|
|
favorite_gameid = int_list
|
|
visible_buttons = string_list
|
|
visible_status = string_list
|
|
translate_game_names = boolean
|
|
solver_presets = string_list
|
|
solver_show_progress = boolean
|
|
solver_max_iterations = integer
|
|
solver_iterations_output_step = integer
|
|
solver_preset = string
|
|
display_win_message = boolean
|
|
language = string
|
|
table_zoom = list
|
|
|
|
[sound_samples]
|
|
move = boolean
|
|
autodrop = boolean
|
|
drop = boolean
|
|
nomove = boolean
|
|
gameperfect = boolean
|
|
deal = boolean
|
|
gamelost = boolean
|
|
autopilotwon = boolean
|
|
flip = boolean
|
|
undo = boolean
|
|
gamefinished = boolean
|
|
areyousure = boolean
|
|
startdrag = boolean
|
|
autoflip = boolean
|
|
autopilotlost = boolean
|
|
turnwaste = boolean
|
|
gamewon = boolean
|
|
droppair = boolean
|
|
redo = boolean
|
|
dealwaste = boolean
|
|
extra = boolean
|
|
|
|
[fonts]
|
|
sans = list
|
|
small = list
|
|
fixed = list
|
|
canvas_default = list
|
|
canvas_small = list
|
|
canvas_fixed = list
|
|
canvas_large = list
|
|
|
|
[colors]
|
|
piles = string
|
|
text = string
|
|
table = string
|
|
hintarrow = string
|
|
cards_1 = string
|
|
cards_2 = string
|
|
samerank_1 = string
|
|
samerank_2 = string
|
|
not_matching = string
|
|
|
|
[timeouts]
|
|
highlight_samerank = float(0.2, 9.9)
|
|
raise_card = float(0.2, 9.9)
|
|
demo = float(0.2, 9.9)
|
|
highlight_cards = float(0.2, 9.9)
|
|
hint = float(0.2, 9.9)
|
|
highlight_piles = float(0.2, 9.9)
|
|
|
|
[cardsets]
|
|
0 = string_list(min=2, max=2)
|
|
1 = string_list(min=2, max=2)
|
|
1_1 = string_list(min=2, max=2)
|
|
2 = string_list(min=2, max=2)
|
|
3 = string_list(min=2, max=2)
|
|
4 = string_list(min=2, max=2)
|
|
5 = string_list(min=2, max=2)
|
|
6 = string_list(min=2, max=2)
|
|
7 = string_list(min=2, max=2)
|
|
8 = string_list(min=2, max=2)
|
|
9 = string_list(min=2, max=2)
|
|
10 = string_list(min=2, max=2)
|
|
11_3 = string_list(min=2, max=2)
|
|
11_4 = string_list(min=2, max=2)
|
|
11_5 = string_list(min=2, max=2)
|
|
11_6 = string_list(min=2, max=2)
|
|
11_7 = string_list(min=2, max=2)
|
|
11_8 = string_list(min=2, max=2)
|
|
11_9 = string_list(min=2, max=2)
|
|
11_10 = string_list(min=2, max=2)
|
|
12 = string_list(min=2, max=2)
|
|
scale_cards = boolean
|
|
scale_x = float
|
|
scale_y = float
|
|
auto_scale = boolean
|
|
spread_stacks = boolean
|
|
preserve_aspect_ratio = boolean
|
|
resampling = integer(0, 10)
|
|
'''.splitlines()
|
|
|
|
|
|
class Options:
|
|
GENERAL_OPTIONS = [
|
|
('last_version', 'list'),
|
|
('player', 'str'),
|
|
('confirm', 'bool'),
|
|
('update_player_stats', 'bool'),
|
|
('autofaceup', 'bool'),
|
|
('autodrop', 'bool'),
|
|
('autodeal', 'bool'),
|
|
('quickplay', 'bool'),
|
|
('shuffle', 'bool'),
|
|
('undo', 'bool'),
|
|
('bookmarks', 'bool'),
|
|
('hint', 'bool'),
|
|
('free_hint', 'bool'),
|
|
('highlight_piles', 'bool'),
|
|
('highlight_cards', 'bool'),
|
|
('highlight_samerank', 'bool'),
|
|
('highlight_not_matching', 'bool'),
|
|
('peek_facedown', 'bool'),
|
|
('stuck_notification', 'bool'),
|
|
('mahjongg_show_removed', 'bool'),
|
|
('mahjongg_create_solvable', 'int'),
|
|
('shisen_show_hint', 'bool'),
|
|
('shisen_show_matching', 'bool'),
|
|
('accordion_deal_all', 'bool'),
|
|
('pegged_auto_remove', 'bool'),
|
|
('animations', 'int'),
|
|
('redeal_animation', 'bool'),
|
|
('win_animation', 'bool'),
|
|
('flip_animation', 'bool'),
|
|
('compact_stacks', 'bool'),
|
|
('shadow', 'bool'),
|
|
('shade', 'bool'),
|
|
('shrink_face_down', 'bool'),
|
|
('shade_filled_stacks', 'bool'),
|
|
('demo_logo', 'bool'),
|
|
('demo_logo_style', 'str'),
|
|
('pause_text_style', 'str'),
|
|
('redeal_icon_style', 'str'),
|
|
('dialog_icon_style', 'str'),
|
|
('tree_icon_style', 'str'),
|
|
('button_icon_style', 'str'),
|
|
('tile_theme', 'str'),
|
|
('default_tile_theme', 'str'),
|
|
('toolbar', 'int'),
|
|
('toolbar_land', 'int'),
|
|
('toolbar_port', 'int'),
|
|
('toolbar_style', 'str'),
|
|
('toolbar_relief', 'str'),
|
|
('toolbar_compound', 'str'),
|
|
('toolbar_size', 'int'),
|
|
('statusbar', 'bool'),
|
|
# ('statusbar_game_number', 'bool'),
|
|
# ('statusbar_stuck', 'bool'),
|
|
# ('num_cards', 'bool'),
|
|
# ('helpbar', 'bool'),
|
|
('num_recent_games', 'int'),
|
|
('last_gameid', 'int'),
|
|
('game_holded', 'int'),
|
|
('wm_maximized', 'bool'),
|
|
('wm_fullscreen', 'bool'),
|
|
('splashscreen', 'bool'),
|
|
('date_format', 'str'),
|
|
('mouse_type', 'str'),
|
|
('mouse_undo', 'bool'),
|
|
('negative_bottom', 'bool'),
|
|
('randomize_place', 'bool'),
|
|
('use_cardset_bottoms', 'bool'),
|
|
# ('save_cardsets', 'bool'),
|
|
('dragcursor', 'bool'),
|
|
('save_games_geometry', 'bool'),
|
|
('topmost_dialogs', 'bool'),
|
|
('sound', 'bool'),
|
|
('sound_mode', 'int'),
|
|
('sound_sample_volume', 'int'),
|
|
('sound_music_volume', 'int'),
|
|
('sound_sample_buffer_size', 'int'),
|
|
('music', 'bool'),
|
|
('tabletile_name', 'str'),
|
|
('tabletile_scale_method', 'int'),
|
|
('center_layout', 'bool'),
|
|
('translate_game_names', 'bool'),
|
|
('solver_presets', 'list'),
|
|
('solver_show_progress', 'bool'),
|
|
('solver_max_iterations', 'int'),
|
|
('solver_iterations_output_step', 'int'),
|
|
('solver_preset', 'string'),
|
|
('mouse_button1', 'int'),
|
|
('mouse_button2', 'int'),
|
|
('mouse_button3', 'int'),
|
|
# ('toolbar_vars', 'list'),
|
|
# ('recent_gameid', 'list'),
|
|
# ('favorite_gameid', 'list'),
|
|
('display_win_message', 'bool'),
|
|
('language', 'str'),
|
|
# ('table_zoom', 'list'),
|
|
('fontscale', 'str'),
|
|
# ('fontsizefactor', 'float'),
|
|
]
|
|
|
|
def __init__(self):
|
|
self._config = None # configobj.ConfigObj instance
|
|
self._config_encoding = 'utf-8'
|
|
|
|
self.version_tuple = pysollib.settings.VERSION_TUPLE # XXX
|
|
self.saved = 0 # XXX
|
|
|
|
self.last_version = (2, 20, 1)
|
|
# options menu:
|
|
self.player = _("Unknown")
|
|
self.confirm = True
|
|
self.update_player_stats = True
|
|
self.autofaceup = True
|
|
self.autodrop = False
|
|
self.autodeal = True
|
|
self.quickplay = True
|
|
self.shuffle = True
|
|
self.undo = True
|
|
self.bookmarks = True
|
|
self.hint = True
|
|
self.free_hint = False
|
|
self.highlight_piles = True
|
|
self.highlight_cards = True
|
|
self.highlight_samerank = True
|
|
self.highlight_not_matching = True
|
|
self.peek_facedown = False
|
|
self.stuck_notification = False
|
|
self.mahjongg_show_removed = False
|
|
self.mahjongg_create_solvable = 2 # 0 - none, 1 - easy, 2 - hard
|
|
self.accordion_deal_all = True
|
|
self.pegged_auto_remove = True
|
|
if TOOLKIT == 'kivy':
|
|
self.mahjongg_create_solvable = 1 # 0 - none, 1 - easy, 2 - hard
|
|
self.shisen_show_hint = True
|
|
self.shisen_show_matching = False
|
|
self.animations = 3 # default to Medium
|
|
self.redeal_animation = True
|
|
self.win_animation = True
|
|
if TOOLKIT == 'kivy':
|
|
self.redeal_animation = False
|
|
self.win_animation = False
|
|
self.flip_animation = True
|
|
self.compact_stacks = True
|
|
self.shadow = True
|
|
self.shade = True
|
|
self.shrink_face_down = True
|
|
self.shade_filled_stacks = True
|
|
self.demo_logo = True
|
|
self.demo_logo_style = 'komika'
|
|
self.pause_text_style = 'komika'
|
|
self.redeal_icon_style = 'modern'
|
|
self.dialog_icon_style = 'remix'
|
|
self.tree_icon_style = 'remix'
|
|
self.button_icon_style = 'none'
|
|
self.tile_theme = 'default'
|
|
self.default_tile_theme = 'default'
|
|
self.toolbar = 1 # 0 == hide, 1,2,3,4 == top, bottom, left, right
|
|
# used with 'kivy' version in addition:
|
|
self.toolbar_land = 4 # (landscape)
|
|
self.toolbar_port = 2 # (portrait)
|
|
# 0 == hide,
|
|
# 1,2,3,4 == top, bottom, left, right
|
|
# self.toolbar_style = 'default'
|
|
self.toolbar_style = 'remix'
|
|
self.toolbar_relief = 'flat'
|
|
self.toolbar_compound = 'none' # icons only
|
|
self.toolbar_size = 0
|
|
self.toolbar_vars = {}
|
|
for w in TOOLBAR_BUTTONS:
|
|
self.toolbar_vars[w] = True # show all buttons
|
|
self.statusbar_vars = {}
|
|
for w, x in STATUSBAR_ITEMS:
|
|
self.statusbar_vars[w] = True
|
|
self.statusbar = True
|
|
# self.statusbar_game_number = False # show game number in statusbar
|
|
# self.statusbar_stuck = False # show stuck indicator
|
|
# self.num_cards = False
|
|
# self.helpbar = False
|
|
self.splashscreen = True
|
|
self.date_format = '%m-%d'
|
|
self.mouse_button1 = 1
|
|
self.mouse_button2 = 2
|
|
self.mouse_button3 = 3
|
|
# mouse_type: 'drag-n-drop' or 'sticky-mouse' or 'point-n-click'
|
|
if TOOLKIT == 'kivy':
|
|
self.mouse_type = 'point-n-click'
|
|
else:
|
|
self.mouse_type = 'drag-n-drop'
|
|
self.mouse_undo = False # use mouse for undo/redo
|
|
self.negative_bottom = True
|
|
self.translate_game_names = True
|
|
self.display_win_message = True
|
|
self.language = ''
|
|
self.table_zoom = [1.0, 0.0, 0.0]
|
|
self.fontscale = 'default' # (kivy, platform defaults)
|
|
# self.fontsizefactor = 1.0
|
|
# sound
|
|
self.sound = True
|
|
self.sound_mode = 1
|
|
self.sound_sample_volume = 75
|
|
self.sound_music_volume = 100
|
|
self.sound_sample_buffer_size = 1 # 1 - 4 (1024 - 4096 bytes)
|
|
self.music = True
|
|
self.sound_samples = {
|
|
'areyousure': True,
|
|
'autodrop': True,
|
|
'autoflip': True,
|
|
'autopilotlost': True,
|
|
'autopilotwon': True,
|
|
'deal': True,
|
|
'dealwaste': True,
|
|
'droppair': True,
|
|
'drop': True,
|
|
'extra': True,
|
|
'flip': True,
|
|
'move': True,
|
|
'nomove': True,
|
|
'redo': True,
|
|
'startdrag': True,
|
|
'turnwaste': True,
|
|
'undo': True,
|
|
'gamefinished': False,
|
|
'gamelost': False,
|
|
'gameperfect': False,
|
|
'gamewon': False,
|
|
}
|
|
# fonts
|
|
self.fonts = {
|
|
"default": None,
|
|
# "default": ("helvetica", 12),
|
|
"sans": ("times", 12), # for html
|
|
"fixed": ("courier", 12), # for html & log
|
|
"small": ("helvetica", 12),
|
|
"canvas_default": ("helvetica", 12),
|
|
# "canvas_card": ("helvetica", 12),
|
|
"canvas_fixed": ("courier", 12),
|
|
"canvas_large": ("helvetica", 16),
|
|
"canvas_small": ("helvetica", 10),
|
|
}
|
|
# colors
|
|
self.colors = {
|
|
'table': '#008200',
|
|
'text': '#ffffff',
|
|
'piles': '#ffc000',
|
|
'cards_1': '#ffc000',
|
|
'cards_2': '#0000ff',
|
|
'samerank_1': '#ffc000',
|
|
'samerank_2': '#0000ff',
|
|
'hintarrow': '#303030',
|
|
'not_matching': '#ff0000',
|
|
}
|
|
# delays
|
|
self.timeouts = {
|
|
'hint': 1.0,
|
|
'demo': 1.0,
|
|
'raise_card': 1.0,
|
|
'highlight_piles': 1.0,
|
|
'highlight_cards': 1.0,
|
|
'highlight_samerank': 1.0,
|
|
}
|
|
# additional startup information
|
|
self.num_recent_games = 15
|
|
self.recent_gameid = []
|
|
self.favorite_gameid = []
|
|
if TOOLKIT == 'kivy':
|
|
self.favorite_gameid = [2, 7, 8, 19, 140, 116, 152, 176, 181,
|
|
194, 207, 706, 721, 756, 903, 5034,
|
|
11004, 14405, 14410, 15411, 22225]
|
|
self.last_gameid = 0 # last game played
|
|
self.game_holded = 0 # gameid or 0
|
|
self.wm_maximized = 1
|
|
self.wm_fullscreen = 0
|
|
self.save_games_geometry = False
|
|
self.topmost_dialogs = True
|
|
# saved games geometry (gameid: (width, height))
|
|
self.games_geometry = {}
|
|
self.game_geometry = (0, 0) # game geometry before exit
|
|
self.offsets = {} # cards offsets
|
|
#
|
|
self.randomize_place = False
|
|
self.use_cardset_bottoms = False
|
|
# self.save_cardsets = True
|
|
self.dragcursor = True
|
|
#
|
|
self.scale_cards = False
|
|
self.scale_x = 1.0
|
|
self.scale_y = 1.0
|
|
self.auto_scale = True
|
|
self.spread_stacks = False
|
|
self.center_layout = True
|
|
self.preserve_aspect_ratio = True
|
|
self.tabletile_scale_method = 0
|
|
self.resampling = 0
|
|
if USE_PIL:
|
|
self.resampling = int(get_default_resampling())
|
|
|
|
# solver
|
|
self.solver_presets = [
|
|
'none',
|
|
'abra-kadabra',
|
|
'blue-yonder',
|
|
'conspiracy-theory',
|
|
'cookie-monster',
|
|
'cool-jives',
|
|
'crooked-nose',
|
|
'fools-gold',
|
|
'good-intentions',
|
|
'hello-world',
|
|
'john-galt-line',
|
|
'looking-glass',
|
|
'one-big-family',
|
|
'rin-tin-tin',
|
|
'slick-rock',
|
|
'the-last-mohican',
|
|
'video-editing',
|
|
'yellow-brick-road',
|
|
]
|
|
self.solver_show_progress = True
|
|
self.solver_max_iterations = 100000
|
|
self.solver_iterations_output_step = 100
|
|
self.solver_preset = 'video-editing'
|
|
|
|
def setDefaults(self, top=None):
|
|
WIN_SYSTEM = pysollib.settings.WIN_SYSTEM
|
|
# toolbar
|
|
# if WIN_SYSTEM == 'win32':
|
|
# self.toolbar_style = 'crystal'
|
|
# fonts
|
|
if WIN_SYSTEM == 'win32':
|
|
self.fonts["sans"] = ("times new roman", 12)
|
|
self.fonts["fixed"] = ("courier new", 10)
|
|
elif WIN_SYSTEM == 'x11':
|
|
self.fonts["sans"] = ("helvetica", -12)
|
|
# tile theme
|
|
if WIN_SYSTEM == 'win32':
|
|
self.tile_theme = self.default_tile_theme = 'winnative'
|
|
if sys.getwindowsversion() >= (5, 1): # xp
|
|
self.tile_theme = 'xpnative'
|
|
elif WIN_SYSTEM == 'x11':
|
|
self.tile_theme = 'clam'
|
|
self.default_tile_theme = 'default'
|
|
elif WIN_SYSTEM == 'aqua':
|
|
self.tile_theme = self.default_tile_theme = 'aqua'
|
|
#
|
|
sw, sh, sd = 0, 0, 8
|
|
if top:
|
|
sw, sh, sd = (top.winfo_screenwidth(),
|
|
top.winfo_screenheight(),
|
|
top.winfo_screendepth())
|
|
# bg
|
|
if sd > 8:
|
|
self.tabletile_name = "Felt Green" # name
|
|
else:
|
|
self.tabletile_name = None
|
|
# cardsets
|
|
c = "Standard"
|
|
m = "Crystal Mahjongg"
|
|
if sw < 800 or sh < 600:
|
|
c = "2000"
|
|
if TOOLKIT == 'kivy':
|
|
c = "Standard"
|
|
m = "Gnome Mahjongg 1"
|
|
|
|
# if sw > 1024 and sh > 768:
|
|
# c = 'Dondorf'
|
|
if USE_PIL:
|
|
self.cardset = {
|
|
0: {0: ("Neo", "")},
|
|
CSI.TYPE_FRENCH: {0: ("Neo", ""), 1: ("Neo", "")},
|
|
CSI.TYPE_HANAFUDA: {0: ("Louie Mantia Hanafuda", "")},
|
|
CSI.TYPE_MAHJONGG: {0: ("Uni Mahjongg", "")},
|
|
CSI.TYPE_TAROCK: {0: ("Neo Tarock", "")},
|
|
CSI.TYPE_HEXADECK: {0: ("Neo Hex", "")},
|
|
CSI.TYPE_MUGHAL_GANJIFA: {0: ("Mughal Ganjifa XL", "")},
|
|
# CSI.TYPE_NAVAGRAHA_GANJIFA: {0: ("Navagraha Ganjifa", "")},
|
|
CSI.TYPE_NAVAGRAHA_GANJIFA:
|
|
{0: ("Dashavatara Ganjifa XL", "")},
|
|
CSI.TYPE_DASHAVATARA_GANJIFA:
|
|
{0: ("Dashavatara Ganjifa XL", "")},
|
|
CSI.TYPE_TRUMP_ONLY: {0: ("Next Matrix", "")},
|
|
CSI.TYPE_MATCHING: {0: ("Neo", "")},
|
|
CSI.TYPE_PUZZLE: {3: ("Dojouji Ukiyo E (3x3)", ""),
|
|
4: ("Knave of Hearts (4x4)", ""),
|
|
5: ("Victoria Falls (5x5)", ""),
|
|
6: ("Hokusai Ukiyo E (6x6)", ""),
|
|
7: ("Blaren (7x7)", ""),
|
|
8: ("Mid Winter's Eve (8x8)", ""),
|
|
9: ("The Card Players (9x9)", ""),
|
|
10: ("Players Trumps (10x10)", "")},
|
|
CSI.TYPE_ISHIDO: {0: ("Simple Ishido XL", "")},
|
|
}
|
|
else:
|
|
self.cardset = {
|
|
# game_type: (cardset_name, back_file)
|
|
0: {0: (c, "")},
|
|
CSI.TYPE_FRENCH: {0: (c, ""), 1: (c, "")},
|
|
CSI.TYPE_HANAFUDA: {0: ("Kintengu", "")},
|
|
CSI.TYPE_MAHJONGG: {0: (m, "")},
|
|
CSI.TYPE_TAROCK: {0: ("Vienna 2K", "")},
|
|
CSI.TYPE_HEXADECK: {0: ("Hex A Deck", "")},
|
|
CSI.TYPE_MUGHAL_GANJIFA: {0: ("Mughal Ganjifa", "")},
|
|
# CSI.TYPE_NAVAGRAHA_GANJIFA: {0: ("Navagraha Ganjifa", "")},
|
|
CSI.TYPE_NAVAGRAHA_GANJIFA: {0: ("Dashavatara Ganjifa", "")},
|
|
CSI.TYPE_DASHAVATARA_GANJIFA: {0: ("Dashavatara Ganjifa", "")},
|
|
CSI.TYPE_TRUMP_ONLY: {0: ("Matrix", "")},
|
|
CSI.TYPE_MATCHING: {0: (c, "")},
|
|
CSI.TYPE_PUZZLE: {3: ("Dojouji Ukiyo E (3x3)", ""),
|
|
4: ("Knave of Hearts (4x4)", ""),
|
|
5: ("Victoria Falls (5x5)", ""),
|
|
6: ("Hokusai Ukiyo E (6x6)", ""),
|
|
7: ("Blaren (7x7)", ""),
|
|
8: ("Mid Winter's Eve (8x8)", ""),
|
|
9: ("The Card Players (9x9)", ""),
|
|
10: ("Players Trumps (10x10)", "")},
|
|
CSI.TYPE_ISHIDO: {0: ("Simple Ishido", "")},
|
|
}
|
|
|
|
# not changeable options
|
|
def setConstants(self):
|
|
if 'shuffle' not in self.toolbar_vars:
|
|
# new in v.1.1
|
|
self.toolbar_vars['shuffle'] = True
|
|
if isinstance(self.mahjongg_create_solvable, bool):
|
|
# changed in v.1.1
|
|
self.mahjongg_create_solvable = 2
|
|
pass
|
|
|
|
def copy(self):
|
|
opt = Options()
|
|
opt.__dict__.update(self.__dict__)
|
|
opt.setConstants()
|
|
return opt
|
|
|
|
def save(self, filename):
|
|
config = self._config
|
|
|
|
self.last_version = self.version_tuple
|
|
|
|
# general
|
|
for key, t in self.GENERAL_OPTIONS:
|
|
val = getattr(self, key)
|
|
if isinstance(val, str):
|
|
if sys.version_info < (3,):
|
|
val = str(val, 'utf-8')
|
|
config['general'][key] = val
|
|
|
|
config['general']['recent_gameid'] = self.recent_gameid
|
|
config['general']['favorite_gameid'] = self.favorite_gameid
|
|
config['general']['table_zoom'] = self.table_zoom
|
|
visible_buttons = [b for b in self.toolbar_vars
|
|
if self.toolbar_vars[b]]
|
|
config['general']['visible_buttons'] = visible_buttons
|
|
visible_status = [b for b in self.statusbar_vars
|
|
if self.statusbar_vars[b]]
|
|
config['general']['visible_status'] = visible_status
|
|
if 'none' in config['general']['solver_presets']:
|
|
config['general']['solver_presets'].remove('none')
|
|
|
|
# sound_samples
|
|
config['sound_samples'] = self.sound_samples
|
|
|
|
# fonts
|
|
for key, val in self.fonts.items():
|
|
if key == 'default':
|
|
continue
|
|
if val is None:
|
|
continue
|
|
config['fonts'][key] = val
|
|
|
|
# colors
|
|
config['colors'] = self.colors
|
|
|
|
# timeouts
|
|
config['timeouts'] = self.timeouts
|
|
|
|
# cardsets
|
|
for key, val in self.cardset.items():
|
|
for key2, val2 in val.items():
|
|
if key2 > 0:
|
|
config['cardsets'][str(key) + "_" + str(key2)] = val2
|
|
else:
|
|
config['cardsets'][str(key)] = val2
|
|
for key in ('scale_cards', 'scale_x', 'scale_y',
|
|
'auto_scale', 'spread_stacks',
|
|
'preserve_aspect_ratio', 'resampling'):
|
|
config['cardsets'][key] = getattr(self, key)
|
|
|
|
# games_geometry
|
|
config['games_geometry'].clear()
|
|
for key, val in self.games_geometry.items():
|
|
config['games_geometry'][str(key)] = val
|
|
config['general']['game_geometry'] = self.game_geometry
|
|
|
|
# offsets
|
|
for key, val in self.offsets.items():
|
|
config['offsets'][key] = val
|
|
|
|
config.write()
|
|
# config.write(sys.stdout); print
|
|
|
|
def _getOption(self, section, key, t):
|
|
config = self._config
|
|
try:
|
|
if config[section][key] is None:
|
|
# invalid value
|
|
return None
|
|
if t == 'bool':
|
|
val = config[section].as_bool(key)
|
|
elif t == 'int':
|
|
val = config[section].as_int(key)
|
|
elif t == 'float':
|
|
val = config[section].as_float(key)
|
|
elif t == 'list':
|
|
val = config[section][key]
|
|
assert isinstance(val, (list, tuple))
|
|
else: # str
|
|
val = config[section][key]
|
|
except KeyError:
|
|
val = None
|
|
except Exception:
|
|
print_err('load option error: %s: %s' % (section, key))
|
|
traceback.print_exc()
|
|
val = None
|
|
return val
|
|
|
|
def load(self, filename):
|
|
|
|
# create ConfigObj instance
|
|
try:
|
|
config = configobj.ConfigObj(filename,
|
|
configspec=configspec,
|
|
encoding=self._config_encoding)
|
|
except configobj.ParseError:
|
|
traceback.print_exc()
|
|
config = configobj.ConfigObj(configspec=configspec,
|
|
encoding=self._config_encoding)
|
|
self._config = config
|
|
|
|
# create sections
|
|
for section in (
|
|
'general',
|
|
'sound_samples',
|
|
'fonts',
|
|
'colors',
|
|
'timeouts',
|
|
'cardsets',
|
|
'games_geometry',
|
|
'offsets',
|
|
):
|
|
if section not in config:
|
|
config[section] = {}
|
|
|
|
# add initial comment
|
|
if not os.path.exists(filename):
|
|
config.initial_comment = ['-*- coding: %s -*-' %
|
|
self._config_encoding]
|
|
return
|
|
|
|
# validation
|
|
vdt = validate.Validator()
|
|
res = config.validate(vdt)
|
|
# from pprint import pprint; pprint(res)
|
|
if isinstance(res, dict):
|
|
for section, data in res.items():
|
|
if data is True:
|
|
continue
|
|
for key, value in data.items():
|
|
if value is False:
|
|
config[section][key] = None
|
|
|
|
# general
|
|
for key, t in self.GENERAL_OPTIONS:
|
|
val = self._getOption('general', key, t)
|
|
if val == 'None':
|
|
setattr(self, key, None)
|
|
elif val is not None:
|
|
setattr(self, key, val)
|
|
|
|
pysollib.settings.TRANSLATE_GAME_NAMES = self.translate_game_names
|
|
|
|
recent_gameid = self._getOption('general', 'recent_gameid', 'list')
|
|
if recent_gameid is not None:
|
|
try:
|
|
self.recent_gameid = [int(i) for i in recent_gameid]
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
favorite_gameid = self._getOption('general', 'favorite_gameid', 'list')
|
|
if favorite_gameid is not None:
|
|
try:
|
|
self.favorite_gameid = [int(i) for i in favorite_gameid]
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
table_zoom = self._getOption('general', 'table_zoom', 'list')
|
|
if table_zoom is not None:
|
|
try:
|
|
self.table_zoom = [float(i) for i in table_zoom]
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
visible_buttons = self._getOption('general', 'visible_buttons', 'list')
|
|
if visible_buttons is not None:
|
|
for key in TOOLBAR_BUTTONS:
|
|
self.toolbar_vars[key] = (key in visible_buttons)
|
|
visible_status = self._getOption('general', 'visible_status', 'list')
|
|
if visible_status is not None:
|
|
for key, label in STATUSBAR_ITEMS:
|
|
self.statusbar_vars[key] = (key in visible_status)
|
|
|
|
myGettext.language = self.language
|
|
|
|
# solver
|
|
solver_presets = self._getOption('general', 'solver_presets', 'list')
|
|
if solver_presets is not None:
|
|
if 'none' not in solver_presets:
|
|
solver_presets.insert(0, 'none')
|
|
self.solver_presets = solver_presets
|
|
|
|
# sound_samples
|
|
for key in self.sound_samples:
|
|
val = self._getOption('sound_samples', key, 'bool')
|
|
if val is not None:
|
|
self.sound_samples[key] = val
|
|
|
|
# fonts
|
|
for key in self.fonts:
|
|
if key == 'default':
|
|
continue
|
|
val = self._getOption('fonts', key, 'str')
|
|
if val is not None:
|
|
try:
|
|
val[1] = int(val[1])
|
|
except Exception:
|
|
traceback.print_exc()
|
|
else:
|
|
val = tuple(val)
|
|
self.fonts[key] = val
|
|
|
|
# colors
|
|
for key in self.colors:
|
|
val = self._getOption('colors', key, 'str')
|
|
if val is not None:
|
|
self.colors[key] = val
|
|
|
|
# timeouts
|
|
for key in self.timeouts:
|
|
val = self._getOption('timeouts', key, 'float')
|
|
if val is not None:
|
|
self.timeouts[key] = val
|
|
|
|
# cardsets
|
|
for key in self.cardset:
|
|
for key2 in self.cardset[key]:
|
|
if key2 > 0:
|
|
val = self._getOption('cardsets',
|
|
str(key) + "_" + str(key2), 'list')
|
|
else:
|
|
val = self._getOption('cardsets', str(key), 'list')
|
|
if val is not None:
|
|
try:
|
|
self.cardset[int(key)][int(key2)] = val
|
|
except Exception:
|
|
traceback.print_exc()
|
|
for key, t in (('scale_cards', 'bool'),
|
|
('scale_x', 'float'),
|
|
('scale_y', 'float'),
|
|
('auto_scale', 'bool'),
|
|
('spread_stacks', 'bool'),
|
|
('preserve_aspect_ratio', 'bool'),
|
|
('resampling', 'int')):
|
|
val = self._getOption('cardsets', key, t)
|
|
if val is not None:
|
|
setattr(self, key, val)
|
|
|
|
# games_geometry
|
|
for key, val in config['games_geometry'].items():
|
|
try:
|
|
val = [int(i) for i in val]
|
|
assert len(val) == 2
|
|
self.games_geometry[int(key)] = val
|
|
except Exception:
|
|
traceback.print_exc()
|
|
game_geometry = self._getOption('general', 'game_geometry', 'list')
|
|
if game_geometry is not None:
|
|
try:
|
|
self.game_geometry = tuple(int(i) for i in game_geometry)
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
# cards offsets
|
|
for key, val in config['offsets'].items():
|
|
try:
|
|
val = [int(i) for i in val]
|
|
assert len(val) == 2
|
|
self.offsets[key] = val
|
|
except Exception:
|
|
traceback.print_exc()
|
|
|
|
# mouse buttons swap
|
|
def _positive(button):
|
|
return max([button, 1])
|
|
_global_settings['mouse_button1'] = _positive(self.mouse_button1)
|
|
_global_settings['mouse_button2'] = _positive(self.mouse_button2)
|
|
_global_settings['mouse_button3'] = _positive(self.mouse_button3)
|
|
|
|
def calcCustomMouseButtonsBinding(self, binding_format):
|
|
"""docstring for calcCustomMouseButtonsBinding"""
|
|
def _positive(button):
|
|
return max([button, 1])
|
|
return binding_format.format(
|
|
mouse_button1=_positive(self.mouse_button1),
|
|
mouse_button2=_positive(self.mouse_button2),
|
|
mouse_button3=_positive(self.mouse_button3),
|
|
)
|