302 lines
9.7 KiB
Python
302 lines
9.7 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
"""OSD Neo2
|
|
========
|
|
On screen display for learning the keyboard layout Neo2
|
|
|
|
Copyright (c) 2009-2010 Martin Zuther (http://www.mzuther.de/)
|
|
|
|
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/>.
|
|
|
|
Thank you for using free software!
|
|
|
|
"""
|
|
|
|
# Here follows a plea in German to keep the comments in English so
|
|
# that you may understand them, dear visitor ...
|
|
#
|
|
# Meine Kommentare in den Quellcodes sind absichtlich auf Englisch
|
|
# gehalten, damit Leute, die im Internet nach Lösungen suchen, den
|
|
# Code nachvollziehen können. Daher bitte ich darum, zusätzliche
|
|
# Kommentare ebenfalls auf Englisch zu schreiben. Vielen Dank!
|
|
|
|
import ConfigParser
|
|
import gettext
|
|
import locale
|
|
import os
|
|
import types
|
|
|
|
# initialise localisation settings
|
|
module_path = os.path.dirname(os.path.realpath(__file__))
|
|
gettext.bindtextdomain('OSDneo2', os.path.join(module_path, 'po/'))
|
|
gettext.textdomain('OSDneo2')
|
|
_ = gettext.lgettext
|
|
|
|
class Settings:
|
|
"""Store user and application settings in one place and make them available.
|
|
"""
|
|
def __init__(self):
|
|
"""Initialise user settings and application information.
|
|
|
|
Keyword arguments:
|
|
None
|
|
|
|
Return value:
|
|
None
|
|
|
|
"""
|
|
# common application copyrights and information (only set here, private)
|
|
self.__application__ = 'OSD Neo2'
|
|
self.__cmd_line__ = 'OSDneo2'
|
|
self.__version__ = '0.13'
|
|
self.__years__ = '2009-2010'
|
|
self.__authors__ = 'Martin Zuther'
|
|
self.__license_short__ = 'GPL version 3 (or later)'
|
|
self.__license_long__ = """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/>.
|
|
|
|
Thank you for using free software!"""
|
|
self.__description__ = _('On screen display for learning the keyboard layout Neo2')
|
|
|
|
# set INI file path
|
|
self.__config_file_path__ = os.path.expanduser('~/.OSDneo2')
|
|
|
|
# if not found otherwise, INI file can be accessed
|
|
self.__can_access_config_file__ = True
|
|
|
|
# if INI file doesn't exist or cannot be read, ...
|
|
if not os.access(self.__config_file_path__, os.F_OK | os.R_OK):
|
|
print _('File "%s" not found.\nUsing default settings') % \
|
|
self.__config_file_path__
|
|
# ... try to create it
|
|
try:
|
|
configfile = open(self.__config_file_path__, 'w')
|
|
configfile.close()
|
|
# failed to create INI file
|
|
except IOError, e:
|
|
self.__can_access_config_file__ = False
|
|
print _('No read access to file "%s".\nChanged settings cannot be stored.') % \
|
|
self.__config_file_path__
|
|
|
|
# if INI file cannot be accessed, read or written to, ...
|
|
if self.__can_access_config_file__ and not os.access( \
|
|
self.__config_file_path__, os.F_OK | os.R_OK | os.W_OK):
|
|
# ... then notify the user
|
|
self.__can_access_config_file__ = False
|
|
print _('No write access to file "%s".\nChanged settings cannot be stored.') % \
|
|
self.__config_file_path__
|
|
|
|
# read application settings from INI file
|
|
self.__settings__ = ConfigParser.RawConfigParser()
|
|
self.__settings__.read(self.__config_file_path__)
|
|
|
|
|
|
def __repr__(self):
|
|
"""Return all the contents of the INI file as string.
|
|
|
|
Keyword arguments:
|
|
None
|
|
|
|
Return value:
|
|
Formatted string containing all settings from the INI file
|
|
|
|
"""
|
|
output = ''
|
|
# sort and output sections
|
|
for section in self.sections():
|
|
output += '\n[%s]\n' % section
|
|
# sort and output settings
|
|
for item in self.items(section):
|
|
output += '%s: %s\n' % (item[0], item[1])
|
|
# dump the whole thing
|
|
return output.lstrip('\n')
|
|
|
|
|
|
def get(self, section, setting, default):
|
|
"""Get an application setting.
|
|
|
|
Keyword arguments:
|
|
section -- string that specifies the section to be queried
|
|
setting -- string that specifies the setting to be queried
|
|
value -- string that specifies a default value
|
|
|
|
Return value:
|
|
String containing the specified application setting
|
|
|
|
"""
|
|
# return default value if INI file can't be accessed
|
|
if not self.__can_access_config_file__:
|
|
return default
|
|
|
|
try:
|
|
value = self.__settings__.get(section, setting)
|
|
except (ConfigParser.NoOptionError, ConfigParser.NoSectionError):
|
|
value = default
|
|
if type(default) != types.NoneType:
|
|
self.set(section, setting, default)
|
|
return value
|
|
|
|
|
|
def set(self, section, setting, value):
|
|
"""Set an application setting.
|
|
|
|
Keyword arguments:
|
|
section -- string that specifies the section to be changed
|
|
setting -- string that specifies the setting to be changed
|
|
value -- string that specifies the new value
|
|
|
|
Return value:
|
|
None
|
|
|
|
"""
|
|
# do nothing if INI file can't be accessed
|
|
if not self.__can_access_config_file__:
|
|
return
|
|
|
|
assert (type(value) == types.StringType) or \
|
|
(type(value) == types.UnicodeType)
|
|
|
|
if section not in self.sections():
|
|
self.__settings__.add_section(section)
|
|
|
|
old_value = self.get(section, setting, None)
|
|
|
|
if value != old_value:
|
|
self.__settings__.set(section, setting, value)
|
|
|
|
configfile = open(self.__config_file_path__, 'w')
|
|
configfile.write(self.__repr__())
|
|
configfile.close()
|
|
|
|
|
|
def items(self, section):
|
|
"""Get all application setting names of a section
|
|
|
|
Keyword arguments:
|
|
section -- string that specifies the section to be queried
|
|
|
|
Return value:
|
|
List containing application setting names of the given section
|
|
|
|
"""
|
|
items = self.__settings__.items(section)
|
|
items.sort()
|
|
return items
|
|
|
|
|
|
def sections(self):
|
|
"""Get all sections.
|
|
|
|
Keyword arguments:
|
|
None
|
|
|
|
Return value:
|
|
List containing all section names
|
|
|
|
"""
|
|
sections = self.__settings__.sections()
|
|
sections.sort()
|
|
return sections
|
|
|
|
|
|
def get_variable(self, variable):
|
|
"""Return application describing variable as string.
|
|
|
|
Keyword arguments:
|
|
variable -- variable to query
|
|
|
|
Return value:
|
|
Formatted string containing variable's value (or None for
|
|
invalid queries)
|
|
|
|
"""
|
|
# list of variable names that may be queried (as a security measure)
|
|
valid_variable_names = ('application', 'cmd_line', 'version', \
|
|
'years', 'authors', 'license_short', \
|
|
'license_long', 'description')
|
|
|
|
if variable in valid_variable_names:
|
|
return eval('self.__%s__' % variable)
|
|
else:
|
|
return None
|
|
|
|
|
|
def get_description(self, long):
|
|
"""Return application description as string.
|
|
|
|
Keyword arguments:
|
|
long -- Boolean indication whether to output long version of description
|
|
|
|
Return value:
|
|
Formatted string containing application description
|
|
|
|
"""
|
|
if long:
|
|
description = '%(application)s v%(version)s' % \
|
|
{'application':self.get_variable('application'), \
|
|
'version':self.get_variable('version')}
|
|
description += '\n' + '=' * len(description) + '\n'
|
|
description += '%(description)s' % \
|
|
{'description':self.get_variable('description')}
|
|
else:
|
|
description = '%(application)s %(version)s' % \
|
|
{'application':self.get_variable('application'), \
|
|
'version':self.get_variable('version')}
|
|
|
|
return description
|
|
|
|
|
|
def get_copyrights(self):
|
|
"""Return application copyrights as string.
|
|
|
|
Keyword arguments:
|
|
None
|
|
|
|
Return value:
|
|
Formatted string containing application copyrights
|
|
|
|
"""
|
|
return '(c) %(years)s %(authors)s' % \
|
|
{'years':self.get_variable('years'),\
|
|
'authors':self.get_variable('authors')}
|
|
|
|
|
|
def get_license(self, long):
|
|
"""Return application license as string.
|
|
|
|
Keyword arguments:
|
|
long -- Boolean indication whether to output long version of description
|
|
|
|
Return value:
|
|
Formatted string containing application license
|
|
|
|
"""
|
|
if long:
|
|
return self.get_variable('license_long')
|
|
else:
|
|
return self.get_variable('license_short')
|
|
|
|
|
|
# make everything available ("from Settings import *")
|
|
settings = Settings()
|