class ProjectSettings(Settings):
'''Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of project.
'''
project = ObjectProperty(None)
'''Reference to :class:`desginer.project_manager.Project`
'''
config_parser = ObjectProperty(None)
'''Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
'''
def load_proj_settings(self):
'''This function loads project settings
'''
self.config_parser = ConfigParser()
file_path = os.path.join(self.project.path, PROJ_CONFIG)
if not os.path.exists(file_path):
if not os.path.exists(os.path.dirname(file_path)):
os.makedirs(os.path.dirname(file_path))
CONFIG_TEMPLATE = '''[proj_name]
name = Project
[arguments]
arg =
[env variables]
env =
'''
f = open(file_path, 'w')
f.write(CONFIG_TEMPLATE)
f.close()
self.config_parser.read(file_path)
_dir = os.path.dirname(designer.__file__)
_dir = os.path.split(_dir)[0]
settings_dir = os.path.join(_dir, 'designer', 'settings')
self.add_json_panel('Shell Environment',
self.config_parser,
os.path.join(settings_dir,
'proj_settings_shell_env.json'))
self.add_json_panel('Project Properties',
self.config_parser,
os.path.join(settings_dir,
'proj_settings_proj_prop.json'))
@ignore_proj_watcher
def on_config_change(self, *args):
'''This function is default handler of on_config_change event.
'''
self.config_parser.write()
super(ProjectSettings, self).on_config_change(*args)
class ProjectSettings(Settings):
'''Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of project.
'''
proj_loader = ObjectProperty(None)
'''Reference to :class:`desginer.project_loader.ProjectLoader`
'''
config_parser = ObjectProperty(None)
'''Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
'''
def load_proj_settings(self):
'''This function loads project settings
'''
self.config_parser = ConfigParser()
file_path = os.path.join(self.proj_loader.proj_dir, PROJ_CONFIG)
if not os.path.exists(file_path):
if not os.path.exists(os.path.dirname(file_path)):
os.makedirs(os.path.dirname(file_path))
CONFIG_TEMPLATE = '''[proj_name]
name = Project
[arguments]
arg =
[env variables]
env =
'''
f = open(file_path, 'w')
f.write(CONFIG_TEMPLATE)
f.close()
self.config_parser.read(file_path)
_dir = os.path.dirname(designer.__file__)
_dir = os.path.split(_dir)[0]
settings_dir = os.path.join(_dir, 'designer', 'settings')
self.add_json_panel('Shell Environment',
self.config_parser,
os.path.join(settings_dir,
'proj_settings_shell_env.json'))
self.add_json_panel('Project Properties',
self.config_parser,
os.path.join(settings_dir,
'proj_settings_proj_prop.json'))
def on_config_change(self, *args):
'''This function is default handler of on_config_change event.
'''
self.config_parser.write()
super(ProjectSettings, self).on_config_change(*args)
def load_config(self):
'''(internal) This function is used for returning a ConfigParser with
the application configuration. It's doing 3 things:
#. Creating an instance of a ConfigParser
#. Loading the default configuration by calling
:meth:`build_config`, then
#. If it exists, it loads the application configuration file,
otherwise it creates one.
:return:
:class:`~kivy.config.ConfigParser` instance
'''
try:
config = ConfigParser.get_configparser('app')
except KeyError:
config = None
if config is None:
config = ConfigParser(name='app')
self.config = config
self.build_config(config)
# if no sections are created, that's mean the user don't have
# configuration.
if len(config.sections()) == 0:
return
# ok, the user have some sections, read the default file if exist
# or write it !
filename = self.get_application_config()
if filename is None:
return config
Logger.debug('App: Loading configuration <{0}>'.format(filename))
if exists(filename):
try:
config.read(filename)
except:
Logger.error('App: Corrupted config file, ignored.')
config.name = ''
try:
config = ConfigParser.get_configparser('app')
except KeyError:
config = None
if config is None:
config = ConfigParser(name='app')
self.config = config
self.build_config(config)
pass
else:
Logger.debug('App: First configuration, create <{0}>'.format(
filename))
config.filename = filename
config.write()
return config
class ProjectSettings(Settings):
"""Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of project.
"""
project = ObjectProperty(None)
"""Reference to :class:`desginer.project_manager.Project`
"""
config_parser = ObjectProperty(None)
"""Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
"""
def load_proj_settings(self):
"""This function loads project settings
"""
self.config_parser = ConfigParser()
file_path = os.path.join(self.project.path, PROJ_CONFIG)
if not os.path.exists(file_path):
if not os.path.exists(os.path.dirname(file_path)):
os.makedirs(os.path.dirname(file_path))
CONFIG_TEMPLATE = """[proj_name]
name = Project
[arguments]
arg =
[env variables]
env =
"""
f = open(file_path, "w")
f.write(CONFIG_TEMPLATE)
f.close()
self.config_parser.read(file_path)
settings_dir = os.path.join(get_kd_data_dir(), "settings")
self.add_json_panel(
"Shell Environment", self.config_parser, os.path.join(settings_dir, "proj_settings_shell_env.json")
)
self.add_json_panel(
"Project Properties", self.config_parser, os.path.join(settings_dir, "proj_settings_proj_prop.json")
)
@ignore_proj_watcher
def on_config_change(self, *args):
"""This function is default handler of on_config_change event.
"""
self.config_parser.write()
super(ProjectSettings, self).on_config_change(*args)
def load_config(self):
'''(internal) This function is used for returning a ConfigParser with
the application configuration. It's doing 3 things:
#. Creating an instance of a ConfigParser
#. Loading the default configuration by calling
:meth:`build_config`, then
#. If it exists, it loads the application configuration file,
otherwise it creates one.
:return:
:class:`~kivy.config.ConfigParser` instance
'''
try:
config = ConfigParser.get_configparser('app')
except KeyError:
config = None
if config is None:
config = ConfigParser(name='app')
self.config = config
self.build_config(config)
# if no sections are created, that's mean the user don't have
# configuration.
if len(config.sections()) == 0:
return
# ok, the user have some sections, read the default file if exist
# or write it !
filename = self.get_application_config()
if filename is None:
return config
Logger.debug('App: Loading configuration <{0}>'.format(filename))
if exists(filename):
try:
config.read(filename)
except:
Logger.error('App: Corrupted config file, ignored.')
config.name = ''
try:
config = ConfigParser.get_configparser('app')
except KeyError:
config = None
if config is None:
config = ConfigParser(name='app')
self.config = config
self.build_config(config)
pass
else:
Logger.debug('App: First configuration, create <{0}>'.format(
filename))
config.filename = filename
config.write()
return config
def _on_answer(self, instance, answer):
if answer == "yes":
config = ConfigParser()
config.read('/sdcard/.mobileinsight.ini')
config.set("mi_general", "privacy", 1)
config.set("NetLogger", "privacy", 1)
config.write()
self.popup.dismiss()
elif answer == "no":
# global disagree_privacy
# disagree_privacy = 1
config = ConfigParser()
config.read('/sdcard/.mobileinsight.ini')
config.set("mi_general", "privacy", 1)
config.set("NetLogger", "privacy", 0)
config.write()
self.popup.dismiss()
class AppSettings(Settings):
'''Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of Kivy Designer.
'''
config_parser = ObjectProperty(None)
'''Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
'''
def __init__(self, **kwargs):
super(AppSettings, self).__init__(*kwargs)
self.app = App.get_running_app()
def pre_load_settings(self):
'''This function loads project settings
'''
self.config_parser = ConfigParser(name='App Settings')
APP_CONFIG = os.path.join(self.app.dir, APP_CONFIG_FILE_NAME)
_dir = self.app.dir
DEFAULT_CONFIG = os.path.join(_dir, APP_CONFIG_FILE_NAME)
if not os.path.exists(APP_CONFIG):
shutil.copyfile(DEFAULT_CONFIG, APP_CONFIG)
self.config_parser.read(APP_CONFIG)
self.config_parser.upgrade(DEFAULT_CONFIG)
def load_settings(self):
_dir_json = os.path.join(self.app.dir, 'settings')
# creates a panel before insert it to update code input theme list
panel = self.create_json_panel(
'App Settings', self.config_parser,
os.path.join(_dir_json, 'app_settings.json'))
uid = panel.uid
if self.interface is not None:
self.interface.add_panel(panel, 'Kivy Designer Settings', uid)
def on_config_change(self, *args):
'''This function is default handler of on_config_change event.
'''
self.config_parser.write()
super(AppSettings, self).on_config_change(*args)
class DesignerSettings(Settings):
'''Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of Kivy Designer.
'''
config_parser = ObjectProperty(None)
'''Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
'''
def load_settings(self):
'''This function loads project settings
'''
self.config_parser = ConfigParser()
DESIGNER_CONFIG = os.path.join(get_kivy_designer_dir(),
DESIGNER_CONFIG_FILE_NAME)
_dir = os.path.dirname(designer.__file__)
_dir = os.path.split(_dir)[0]
DEFAULT_CONFIG = os.path.join(_dir, DESIGNER_CONFIG_FILE_NAME)
if not os.path.exists(DESIGNER_CONFIG):
shutil.copyfile(DEFAULT_CONFIG,
DESIGNER_CONFIG)
self.config_parser.read(DESIGNER_CONFIG)
self.config_parser.upgrade(DEFAULT_CONFIG)
self.add_json_panel('Kivy Designer Settings', self.config_parser,
os.path.join(_dir, 'designer',
'settings', 'designer_settings.json'))
path = self.config_parser.getdefault(
'global', 'python_shell_path', '')
if path == "":
self.config_parser.set('global', 'python_shell_path',
sys.executable)
self.config_parser.write()
def on_config_change(self, *args):
'''This function is default handler of on_config_change event.
'''
self.config_parser.write()
super(DesignerSettings, self).on_config_change(*args)
class DesignerSettings(Settings):
'''Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of Kivy Designer.
'''
config_parser = ObjectProperty(None)
'''Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
'''
def load_settings(self):
'''This function loads project settings
'''
self.config_parser = ConfigParser()
DESIGNER_CONFIG = os.path.join(get_kivy_designer_dir(),
DESIGNER_CONFIG_FILE_NAME)
_dir = os.path.dirname(designer.__file__)
_dir = os.path.split(_dir)[0]
DEFAULT_CONFIG = os.path.join(_dir, DESIGNER_CONFIG_FILE_NAME)
if not os.path.exists(DESIGNER_CONFIG):
shutil.copyfile(DEFAULT_CONFIG, DESIGNER_CONFIG)
self.config_parser.read(DESIGNER_CONFIG)
self.config_parser.upgrade(DEFAULT_CONFIG)
self.add_json_panel(
'Kivy Designer Settings', self.config_parser,
os.path.join(_dir, 'designer', 'settings',
'designer_settings.json'))
path = self.config_parser.getdefault('global', 'python_shell_path', '')
if path == "":
self.config_parser.set('global', 'python_shell_path',
sys.executable)
self.config_parser.write()
def on_config_change(self, *args):
'''This function is default handler of on_config_change event.
'''
self.config_parser.write()
super(DesignerSettings, self).on_config_change(*args)
def on_new(self, *args):
'''Handler for "New Profile" button
'''
new_name = 'new_profile'
i = 1
while os.path.exists(
os.path.join(self.PROFILES_PATH, new_name + str(i) + '.ini')):
i += 1
new_name += str(i)
new_prof_path = os.path.join(self.PROFILES_PATH, new_name + '.ini')
shutil.copy2(os.path.join(self.DEFAULT_PROFILES, 'desktop.ini'),
new_prof_path)
config_parser = ConfigParser()
config_parser.read(new_prof_path)
config_parser.set('profile', 'name', new_name.upper())
config_parser.write()
self.update_panel()
self.settings_changed = True
def on_new(self, *args):
'''Handler for "New Profile" button
'''
new_name = 'new_profile'
i = 1
while os.path.exists(os.path.join(
self.PROFILES_PATH, new_name + str(i) + '.ini')):
i += 1
new_name += str(i)
new_prof_path = os.path.join(
self.PROFILES_PATH, new_name + '.ini')
shutil.copy2(os.path.join(self.DEFAULT_PROFILES, 'desktop.ini'),
new_prof_path)
config_parser = ConfigParser()
config_parser.read(new_prof_path)
config_parser.set('profile', 'name', new_name.upper())
config_parser.write()
self.update_panel()
self.settings_changed = True
def load_config(self):
try:
config = ConfigParser.get_configparser('app')
except KeyError:
config = None
if config is None:
config = ConfigParser(name='app')
self.config = config
self.build_config(config)
# if no sections are created, that's mean the user don't have
# configuration.
if len(config.sections()) == 0:
return
# ok, the user have some sections, read the default file if exist
# or write it !
filename = self.get_application_config()
if filename is None:
return config
Logger.debug('FlexApp: Loading configuration <{0}>'.format(filename))
if exists(filename):
try:
config.read(filename)
except:
Logger.error('FlexApp: Corrupted config file, ignored.')
config.name = ''
try:
config = ConfigParser.get_configparser('app')
except KeyError:
config = None
if config is None:
config = ConfigParser(name='app')
self.config = config
self.build_config(config)
pass
else:
Logger.debug('FlexApp: First configuration, create <{0}>'.format(
filename))
config.filename = filename
config.write()
return config
class DesignerSettings(Settings):
"""Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of Kivy Designer.
"""
config_parser = ObjectProperty(None)
"""Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
"""
def load_settings(self):
"""This function loads project settings
"""
self.config_parser = ConfigParser()
DESIGNER_CONFIG = os.path.join(get_kivy_designer_dir(), DESIGNER_CONFIG_FILE_NAME)
_dir = os.path.dirname(designer.__file__)
_dir = os.path.split(_dir)[0]
if not os.path.exists(DESIGNER_CONFIG):
shutil.copyfile(os.path.join(_dir, DESIGNER_CONFIG_FILE_NAME), DESIGNER_CONFIG)
self.config_parser.read(DESIGNER_CONFIG)
self.add_json_panel(
"Kivy Designer Settings",
self.config_parser,
os.path.join(_dir, "designer", "settings", "designer_settings.json"),
)
path = self.config_parser.getdefault("global", "python_shell_path", "")
if path == "":
self.config_parser.set("global", "python_shell_path", sys.executable)
self.config_parser.write()
def on_config_change(self, *args):
"""This function is default handler of on_config_change event.
"""
self.config_parser.write()
super(DesignerSettings, self).on_config_change(*args)
def set_current_user(self):
config = ConfigParser()
config.read('mysteryonline.ini')
user = User(self.username)
user_handler = CurrentUserHandler(user)
if self.picked_char is not None:
user.set_char(self.picked_char)
user.get_char().load()
else:
try:
user.set_char(characters[str(
config.get('other', 'last_character'))])
user.get_char().load()
except KeyError:
red_herring = characters['RedHerring']
user.set_char(red_herring)
user.get_char().load()
except configparser.NoSectionError:
App.get_running_app().build_config(config)
config.write()
App.get_running_app().set_user(user)
App.get_running_app().set_user_handler(user_handler)
class spacebook(MDApp):
title = 'spacebook'
icon = 'data/images/icon.png'
nav_drawer = ObjectProperty()
lang = StringProperty('en')
def __init__(self, **kvargs):
super(spacebook, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.exit_interval = False
self.dict_language = literal_eval(
open(
os.path.join(self.directory, 'data', 'locales', 'locales.txt')).read()
)
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'data', 'locales')
)
def get_application_config(self):
return super(spacebook, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
config.adddefaultsection('General')
config.setdefault('General', 'language', 'en')
def set_value_from_config(self):
self.config.read(os.path.join(self.directory, 'spacebook.ini'))
self.lang = self.config.get('General', 'language')
def build(self):
self.set_value_from_config()
self.load_all_kv_files(os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen()
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
if not PY2:
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
else:
Builder.load_file(kv_file)
def events_program(self, instance, keyboard, keycode, text, modifiers):
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.set_state("toggle")
self.back_screen(event=keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self, event=None):
if event in (1001, 27):
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
except:
self.manager.current = 'base'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.set_state("toggle")]]
def show_about(self, *args):
self.nav_drawer.set_state("toggle")
self.screen.ids.about.ids.label.text = \
self.translation._(
u'[size=20][b]spacebook[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT\n\n'
u'[size=20][b]Developer[/b][/size]\n\n'
u'[ref=SITE_PROJECT]'
u'[color={link_color}]NAME_AUTHOR[/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=REPO_PROJECT]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_license(self, *args):
self.nav_drawer.set_state("toggle")
if not PY2:
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
else:
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE')).read()
self.manager.current = 'license'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
self.screen.ids.action_bar.title = \
self.translation._('MIT LICENSE')
def select_locale(self, *args):
def select_locale(name_locale):
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(
Lists(
dict_items=dict_info_locales,
events_callback=select_locale, flag='one_select_check'
),
size=(.85, .55)
)
self.window_language.open()
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
class App(KivyApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
# UI
self.title: str = 'Aiventure'
self.sm: Optional[ScreenManager] = None
self.screens: Dict[str, ClassVar] = {}
# AI
self.ai: Optional[AI] = None
self.adventure: Optional[Adventure] = None
# Threading
self.threads: Dict[str, Thread] = {}
# Modules
self.loaded_modules: Dict[str, str] = {}
self.input_filters: List[Callable[[str], str]] = []
self.output_filters: List[Callable[[str], str]] = []
self.display_filter: Optional[Callable[[List[str]], str]] = None
def build(self) -> ScreenManager:
"""
"""
self.init_mods()
self.init_ui()
return self.sm
def build_config(self, _) -> None:
"""
"""
self.config = ConfigParser()
self.config.read('config.ini')
self.config.setdefaults('general', {
'userdir': 'user',
'autosave': True
})
self.config.setdefaults(
'ai', {
'timeout': 20.0,
'memory': 20,
'max_length': 60,
'beam_searches': 1,
'temperature': 0.8,
'top_k': 40,
'top_p': 0.9,
'repetition_penalty': 1.1
})
self.config.setdefaults(
'modules', {
'input_filters': 'aiventure:filters',
'output_filters': 'aiventure:filters',
'display_filter': 'aiventure:filters'
})
self.config.write()
def init_mods(self) -> None:
"""
Initializes the game's module system and loads mods based on the current configuration.
"""
sys.path.append(self.config.get('general', 'userdir'))
for f in self.config.get('modules', 'input_filters').split(','):
domain, module = f.split(':')
Logger.info(f'Modules: Loading {f}.filter_input')
self.input_filters += [
self.load_submodule(domain, module, 'filter_input')
]
for f in self.config.get('modules', 'output_filters').split(','):
domain, module = f.split(':')
Logger.info(f'Modules: Loading {f}.filter_output')
self.output_filters += [
self.load_submodule(domain, module, 'filter_output')
]
domain, module = self.config.get('modules',
'display_filter').split(':')
Logger.info(f'Modules: Loading {f}.filter_display')
self.display_filter = self.load_submodule(domain, module,
'filter_display')
def init_ui(self) -> None:
"""
Initializes the screen manager, loads all screen kivy files and their associated python modules.
"""
self.sm = ScreenManager()
self.screens = {'menu': MenuScreen, 'play': PlayScreen}
for n, s in self.screens.items():
Builder.load_file(f'aiventure/client/uix/{n}.kv')
self.sm.add_widget(s(name=n))
self.sm.current = 'menu'
def get_user_path(self, *args: str) -> str:
"""
Retrieves a path relative to the current user directory.
:param args: The subdirectories / filenames in the user directory.
:return: A path in the current user directory.
"""
return os.path.join(self.config.get('general', 'userdir'), *args)
def get_model_path(self, model: str) -> str:
"""
Gets the path to the currently selected (but not necessarily loaded) AI model.
:param model: The model within the models subdirectory.
:return: The current selected model path.
"""
return self.get_user_path('models', model)
def get_valid_models(self) -> List[str]:
"""
:return: A list of valid model names, inside {userdir}/models
"""
return [
m.name for m in os.scandir(self.get_user_path('models'))
if is_model_valid(m.path)
]
def get_module_path(self, domain: str, module: str) -> str:
return self.get_user_path('modules', domain, f'{module}.py')
def load_module(self, domain: str, module: str) -> Any:
"""
Loads a module and returns it (if it hasn't been loaded already).
:param domain: The module domain.
:param module: The module to load from the given domain.
:return: The loaded module.
"""
k = f'{domain}:{module}'
v = self.loaded_modules.get(k)
if v is None:
v = importlib.import_module(f'.{module}', f'modules.{domain}')
self.loaded_modules[k] = v
return v
def load_submodule(self, domain: str, module: str, submodule: str) -> str:
"""
Loads a submodule (a method, class, or variable from a given module).
:param domain: The module domain.
:param module: The module to load from the given domain.
:param submodule: The submodule to load from the given module.
:return: The loaded submodule.
"""
m = self.load_module(domain, module)
return getattr(m, submodule)
# SAVING AND LOADING
def save_adventure(self) -> None:
"""
Saves the current adventure.
"""
savefile = get_save_name(self.adventure.name)
with open(self.get_user_path('adventures', f'{savefile}.json'),
'w') as json_file:
json.dump(self.adventure.to_dict(), json_file, indent=4)
def load_adventure(self) -> None:
"""
Loads the current adventure.
"""
savefile = get_save_name(self.adventure.name)
with open(self.get_user_path('adventures', f'{savefile}.json'),
'r') as json_file:
self.adventure.from_dict(json.load(json_file))
class DesignerSettings(Settings):
"""Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of Kivy Designer.
"""
config_parser = ObjectProperty(None)
"""Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
"""
def __init__(self, **kwargs):
super(DesignerSettings, self).__init__(*kwargs)
self.register_type("list", SettingList)
self.register_type("shortcut", SettingShortcut)
def load_settings(self):
"""This function loads project settings
"""
self.config_parser = ConfigParser(name="DesignerSettings")
DESIGNER_CONFIG = os.path.join(get_kivy_designer_dir(), DESIGNER_CONFIG_FILE_NAME)
_dir = os.path.dirname(designer.__file__)
_dir = os.path.split(_dir)[0]
DEFAULT_CONFIG = os.path.join(_dir, DESIGNER_CONFIG_FILE_NAME)
if not os.path.exists(DESIGNER_CONFIG):
shutil.copyfile(DEFAULT_CONFIG, DESIGNER_CONFIG)
self.config_parser.read(DESIGNER_CONFIG)
self.config_parser.upgrade(DEFAULT_CONFIG)
# creates a panel before insert it to update code input theme list
panel = self.create_json_panel(
"Kivy Designer Settings",
self.config_parser,
os.path.join(_dir, "designer", "settings", "designer_settings.json"),
)
uid = panel.uid
if self.interface is not None:
self.interface.add_panel(panel, "Kivy Designer Settings", uid)
# loads available themes
for child in panel.children:
if child.id == "code_input_theme_options":
child.items = styles.get_all_styles()
# tries to find python and buildozer path if it's not defined
path = self.config_parser.getdefault("global", "python_shell_path", "")
if path.strip() == "":
self.config_parser.set("global", "python_shell_path", sys.executable)
self.config_parser.write()
buildozer_path = self.config_parser.getdefault("buildozer", "buildozer_path", "")
if buildozer_path.strip() == "":
buildozer_path = find_executable("buildozer")
if buildozer_path:
self.config_parser.set("buildozer", "buildozer_path", buildozer_path)
self.config_parser.write()
self.add_json_panel(
"Buildozer", self.config_parser, os.path.join(_dir, "designer", "settings", "buildozer_settings.json")
)
self.add_json_panel(
"Hanga", self.config_parser, os.path.join(_dir, "designer", "settings", "hanga_settings.json")
)
self.add_json_panel(
"Keyboard Shortcuts", self.config_parser, os.path.join(_dir, "designer", "settings", "shortcuts.json")
)
def on_config_change(self, *args):
"""This function is default handler of on_config_change event.
"""
self.config_parser.write()
super(DesignerSettings, self).on_config_change(*args)
class cScriptConfig(object):
""" Class to manage the initialisation/configuration and access the the settings of an Script settings objects
"""
def __init__(self, oScript):
self.oScript = oScript
self.oConfigParser = KivyConfigParser()
self.oFnConfig = None
self.uCurrentSection = None
self.uDefaultConfigName = u'SCRIPTDEFAULT'
self.aDiscoverScriptList = None
self.oInputKeyboard = None
self.dDefaultSettings = {
"SettingTitle": {
"active": "enabled",
"order": 0,
"type": "title",
"title": "$lvar(560)"
},
"TimeOut": {
"active": "disabled",
"order": 1,
"type": "numericfloat",
"title": "$lvar(6019)",
"desc": "$lvar(6020)",
"section": "$var(ScriptConfigSection)",
"key": "TimeOut",
"default": "1.0"
},
"Host": {
"active": "disabled",
"order": 5,
"type": "string",
"title": "$lvar(6004)",
"desc": "$lvar(6005)",
"section": "$var(ScriptConfigSection)",
"key": "Host",
"default": "192.168.1.2"
},
"Port": {
"active": "disabled",
"order": 6,
"type": "string",
"title": "$lvar(6002)",
"desc": "$lvar(6003)",
"section": "$var(ScriptConfigSection)",
"key": "Port",
"default": "80"
},
"User": {
"active": "disabled",
"order": 7,
"type": "string",
"title": "$lvar(6006)",
"desc": "$lvar(6007)",
"section": "$var(ScriptConfigSection)",
"key": "User",
"default": ""
},
"Password": {
"active": "disabled",
"order": 8,
"type": "string",
"title": "$lvar(6008)",
"desc": "$lvar(6009)",
"section": "$var(ScriptConfigSection)",
"key": "Password",
"default": ""
},
"ConfigChangeButtons": {
"active":
"disabled",
"order":
999,
"type":
"buttons",
"title":
"$lvar(565)",
"desc":
"$lvar(566)",
"section":
"$var(ScriptConfigSection)",
"key":
"configchangebuttons",
"buttons": [{
"title": "$lvar(569)",
"id": "button_add"
}, {
"title": "$lvar(570)",
"id": "button_delete"
}, {
"title": "$lvar(571)",
"id": "button_rename"
}]
},
}
self.dSettingsCombined = {}
def Init(self):
""" Init function, sets the configuration file name and add the default sections """
self.oFnConfig = cFileName(self.oScript.oPathMy) + u'config.ini'
if not self.oFnConfig.Exists():
self.oConfigParser.filename = self.oFnConfig.string
self.CreateSection(uSectionName=self.uDefaultConfigName)
def LoadConfig(self):
""" Loads the config file (only once) """
try:
self.oConfigParser.filename = self.oFnConfig.string
if len(self.oConfigParser._sections) == 0:
if self.oFnConfig.Exists():
self.oScript.ShowDebug(u'Reading Config File')
self.oConfigParser.read(self.oFnConfig.string)
except Exception as e:
self.oScript.ShowError(
u"can\'t load config file: %s" % self.oFnConfig.string, None,
e)
def CreateSection(self, uSectionName):
"""
Adds a new section to the config parser
:param string uSectionName: The name of the section to create
"""
self.oScript.ShowDebug('Adding new section [%s]' % (uSectionName))
self.oConfigParser.add_section(uSectionName)
self.oConfigParser.write()
def GetSettingParFromIni(self, uSectionName, uVarName):
"""
Returns a setting for the configuration ini file
If the entry does not exist, it tries to puls the value from the aInterFaceIniSettings dict of already predifined settings
If not exist there as well, an error will be logged
:rtype: string|None
:param string uSectionName: The name of the section
:param uVarName: The name of the parameter/setting in the section
:return: The value of the setting, empty string if not found
"""
oSetting = self.oScript.GetSettingObjectForConfigName(uSectionName)
uResult = Config_GetDefault_Str(self.oConfigParser, uSectionName,
uVarName, None)
if uResult is None:
uResult = str(oSetting.aScriptIniSettings.queryget(uVarName))
if uResult is None:
uResult = ''
self.oScript.ShowError(u'can\'t find script setting: %s:%s' %
(uSectionName, uVarName))
else:
self.oScript.ShowDebug(u'Returning script setting: %s from %s:%s' %
(uResult, uSectionName, uVarName))
return uResult
def WriteDefinitionConfigPar(self,
uSectionName,
uVarName,
uVarValue,
bNowrite=False,
bForce=False):
""" Writes a variable to the config file
:param string uSectionName: The name of the section
:param string uVarName: The name of the parameter/setting in the section
:param string uVarValue: The value for the setting
:param bool bNowrite: Flag, if we should not immidiatly write the the setting
:param bool bForce: Flag to force write, even if parameter exists in config
"""
self.LoadConfig()
if not self.oConfigParser.has_section(uSectionName):
self.CreateSection(uSectionName=uSectionName)
if self.oConfigParser.has_option(uSectionName, uVarName):
if not bForce:
return
self.oConfigParser.set(uSectionName, uVarName, uVarValue)
if not bNowrite:
self.oConfigParser.write()
for uSettingName in self.oScript.aSettings:
oSetting = self.oScript.aSettings[uSettingName]
if oSetting.uConfigName == uSectionName:
oSetting.aScriptIniSettings[uVarName] = uVarValue
break
def WriteDefinitionConfig(self, uSectionName, dSettings):
"""
writes all vars given in a dictionary to the config file
:param string uSectionName: The name of the section
:param dict dSettings: A dict of all settings to write
"""
for uKey in dSettings:
self.WriteDefinitionConfigPar(uSectionName=uSectionName,
uVarName=uKey,
uVarValue=dSettings[uKey],
bNowrite=True)
self.oConfigParser.write()
def ConfigureKivySettings(self, oKivySetting):
"""
Create the JSON string for all sections and applies it to a kivy settings object
Discover settings are excluded
:param setting oKivySetting:
:return: The KivySetting object
"""
RegisterSettingTypes(oKivySetting)
aSections = self.oConfigParser.sections()
if len(aSections) == 0:
self.CreateSection(uSectionName=self.uDefaultConfigName)
for uSection in aSections:
# the Section list should be applied as a orca var
SetVar(uVarName=u'ScriptConfigSection', oVarValue=uSection)
# Let create a new temporary cSetting object to not harm the existing ones
oSetting = self.oScript.cScriptSettings(self.oScript)
# Read the ini file for this section
oSetting.ReadConfigFromIniFile(uSection)
# Create the setting string
dSettingsJSON = self.CreateSettingJsonCombined(oSetting=oSetting)
uSettingsJSON = SettingDictToString(dSettingsJSON)
uSettingsJSON = ReplaceVars(uSettingsJSON)
oSetting = None
# if there is nothing to configure, then return
if uSettingsJSON == u'{}':
Globals.oNotifications.SendNotification('closesetting_script')
return False
# add the jSon to the Kivy Setting
oKivySetting.add_json_panel(uSection,
self.oConfigParser,
data=uSettingsJSON)
# Adds the action handler
oKivySetting.bind(on_config_change=self.On_ConfigChange)
return oKivySetting
def On_ConfigChange(self, oSettings, oConfig, uSection, uKey, uValue):
""" reacts, if user changes a setting """
if uKey == u'configchangebuttons':
self.uCurrentSection = uSection
if uValue == u'button_add':
SetVar(uVarName=u'SCRIPTINPUT', oVarValue=u'DEVICE_dummy')
self.oInputKeyboard = ShowKeyBoard(u'SCRIPTINPUT',
self.On_InputAdd)
if uValue == u'button_delete':
ShowQuestionPopUp(
uTitle=u'$lvar(5003)',
uMessage=u'Do you really want to delete this setting?',
fktYes=self.On_InputDel,
uStringYes=u'$lvar(5001)',
uStringNo=u'$lvar(5002)')
if uValue == u'button_rename':
SetVar(uVarName=u'SCRIPTINPUT', oVarValue=uSection)
self.oInputKeyboard = ShowKeyBoard(u'SCRIPTINPUT',
self.On_InputRen)
else:
oSetting = self.oScript.GetSettingObjectForConfigName(
uConfigName=uSection)
oSetting.aScriptIniSettings[uKey] = uValue
def On_InputAdd(self, uInput):
""" User pressed the add configuration button """
if uInput == u'':
return
if self.oConfigParser.has_section(uInput):
return
self.oConfigParser.add_section(uInput)
# self.InitializeSection(uInput)
self.oConfigParser.write()
Globals.oTheScreen.AddActionToQueue([{
'string': 'updatewidget',
'widgetname': 'Scriptsettings'
}])
self.ShowSettings()
def On_InputDel(self):
""" User pressed the del configuration button """
self.oConfigParser.remove_section(self.uCurrentSection)
self.oConfigParser.write()
self.ShowSettings()
def On_InputRen(self, uInput):
""" User pressed the rename configuration button """
if uInput == u'':
return
if self.oConfigParser.has_section(uInput):
return
self.oConfigParser._sections[uInput] = self.oConfigParser._sections[
self.uCurrentSection]
self.oConfigParser._sections.pop(self.uCurrentSection)
self.oConfigParser.write()
self.ShowSettings()
def ShowSettings(self):
""" Shows the settings page """
Globals.oTheScreen.AddActionToQueue([{
'string': 'updatewidget',
'widgetname': 'Scriptsettings'
}])
def GetSettingParFromVar2(self, uScriptName, uConfigName, uSettingParName):
"""
Gets a Value for a setting parameter from the orca vars
The Orca vars fpr the parameter are automatically set in the cInterfaceMonitoredSettings class
:rtype: string
:param uScriptName: The name of script to use
:param uConfigName: The nemae of the Config
:param uSettingParName: The name of the parameter
:return: The value of the parameter
"""
return GetVar(uVarName="CONFIG_" + uSettingParName.upper(),
uContext=uScriptName + u'/' + uConfigName)
def CreateSettingJsonCombined(self, oSetting):
"""
Creates a json dict which holds all the setting defintions of
the core interface plus the settinmgs from the discover script (if requested)
:rtype: dict
:param cBaseInterFaceSettings oSetting: an IterFaceSettins Object
:return: a dict of combined settings
"""
if len(self.dSettingsCombined) != 0:
return self.dSettingsCombined
dRet = {}
for uKey in self.dDefaultSettings:
if self.dDefaultSettings[uKey]["active"] != "disabled":
dRet[uKey] = self.dDefaultSettings[uKey]
dScriptJSON = self.oScript.GetConfigJSON()
for uKey in dScriptJSON:
dLine = dScriptJSON[uKey]
iOrder = dLine['order']
for uKey2 in dRet:
if dRet[uKey2]['order'] >= iOrder:
dRet[uKey2]['order'] += 1
dRet[uKey] = dLine
self.dSettingsCombined = dRet
return dRet
class MangoPaint(App):
theme_cls = ThemeManager()
theme_cls.primary_palette = 'Blue'
title = 'Mango Paint'
icon = 'Screens/resources/imgs/mango.jpg'
screen = ObjectProperty(None)
lang = StringProperty('en')
# 해당 클래스가 객체화될때 구동되는 섹션으로 관련된 컴포넌트들을 활성화시켜서 실제 running 되기 직전까지 만들어놓음.
def __init__(self, **kwargs):
super(MangoPaint, self).__init__(**kwargs)
Window.bind(on_keybord=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['gallery']
self.window = Window
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.exit_interval = False
self.name_program = sets.string_lang_title
self.sets = sets
self.dict_language = literal_eval(
open(os.path.join(self.directory, 'Libs', 'locales',
'locales.txt')).read())
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'Libs',
'locales'))
# application 레벨 설정값 정보 관리
def get_application_config(self):
return super(MangoPaint, self).get_application_config(
'{}/Libs/mangopaint.ini'.format(self.directory))
def set_value_from_config(self):
''' mangopaint.ini 로 셋팅값 넣기 '''
self.config.read(os.path.join(self.directory, 'Libs/mangopaint.ini'))
self.lang = self.config.get('General', 'language')
def build_config(self, config):
''' mangopaint.ini 기본 설정값 만들기 '''
config.adddefaultsection('General')
config.setdefault('General', 'language', 'English')
# build 는 App 클래스에서는 App.run()으로 invoke 되며, 메인프로그램을 스타트 시킴.
# 단, 일반 프로그램은 build 함수를 만들지 않는다.
def build(self):
# mangopaint.ini 의 저장된 설정값들을 셋팅하기
self.set_value_from_config()
self.title = sets.string_lang_title[:-1]
self.icon = "Screens/resources/icons/logo.png"
self.load_all_kv_files(os.path.join(self.directory, 'Screens'))
# 메인 베이스가 되는 화면, 각 서브화면들은 screenmanager 로 switch 하면서 사용함
self.start_screen = StartScreen(title_previous=self.name_program,
events_callback=self.events_program,
sets=sets)
self.screen = self.start_screen
self.manager = self.screen.ids.root_manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def load_all_kv_files(self, directory_kv_files):
# i = 0
print('kv-files: ', os.listdir(directory_kv_files))
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
# i = i+1
# print('==========================================================')
# print('kv-file: ', str(i), ': ', kv_file)
if os.path.isfile(kv_file):
with open(kv_file, encoding='utf-8') as kv:
_kv = kv.read()
Builder.load_string(_kv)
# print(_kv) # kivy 파일들 syntax 오류 점검시 필요
# 분기 프로그램 with events_callback로 함수를 파라미터로 전달하여 구동
# 연계할 프로그램명을 호출하고 연이어 프로그램명.kv 까지 동작시킬 터널을 뚫은 후,
# kv파일의 on-이벤트의 events_callback에 파리미터로 전달할 프로그램명을 기술하여
# 최종 원하는 프로그램을 기동할수 있도록 하는 패턴함수임.
def events_program(self, *args):
'''프로그램 이벤트 처리'''
print(args)
if len(args) == 2: # url 사용시
event = args[1]
else: # 프로그램 버튼 클릭시
try:
_args = args[0]
event = _args if isinstance(_args, str) else str(_args) if \
isinstance(_args, dict) else _args.id
except AttributeError:
event = args[1]
# if PY2:
# if isinstance(event, unicode):
# event = event.encode('utf-8')
if event == sets.string_lang_exit_key:
self.exit_program()
elif event == sets.string_lang_exit_key:
self.exit_program()
elif event == sets.string_lang_license:
self.show_license()
elif event == 'search_shop':
self.search_shop()
elif event == 'navigation_drawer':
self.navigation_drawer.toggle_state()
elif event in (1001, 27):
self.back_screen(event=keyboard)
return True
def show_gallery(self, *args):
print('show_gallery2')
self.nav_drawer._toggle()
self.manager.current = 'gallery'
return self.screen
def show_effect(self, *args):
print('show_effect2')
self.nav_drawer._toggle()
self.manager.current = 'effects'
return self.screen
def show_mystudio(self, *args):
print('show_mystudio2')
pass
def show_community(self, *args):
print('show_community2')
pass
def show_purchase(self, *args):
print('show_purchase2')
pass
def show_license(self, *args):
if not PY2:
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
else:
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE')).read()
self.nav_drawer._toggle()
self.manager.current = 'license'
# self.screen.ids.action_bar.title = \
# self.translation._('MIT LICENSE')
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.about.ids.label.text = \
self.translation._(
u'[size=20][b]MangoPaint[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT License\n\n'
u'[size=20][b]mangoPaint develop Team.[/b][/size]\n\n'
u'[ref=www.miraelabs.com]'
u'[color={link_color}]mango-saam, susan han, JM, \n Yoo Jung, Taeyoon Lee, 손정현 [/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=REPO_PROJECT]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
def select_locale(self, *args):
'''사용 가능한 언어 locale 이 있는 창을 표시합니다.
응용 프로그램 언어 설정.'''
def select_locale(name_locale):
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(Lists(dict_items=dict_info_locales,
events_callback=select_locale,
flag='one_select_check'),
size=(.85, .55))
self.window_language.open()
# 메인 화면에서 백 키 클릭시 사용
def back_screen(self, event=None):
if event in (1001, 27):
if self.manager.current == 'gallery':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
except:
self.manager.current = 'gallery'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
# Clock.schedule_interval(check_interval_press, 1)
# toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
def on_pause(self):
''' 이렇게 하면 응용 프로그램이 '일시 중지'로 표시됩니다.
그렇지 않으면 프로그램 시작 다시 '''
return True
def on_resume(self):
print('on_resume')
def on_stop(self):
print('on_stop')
def exit_program(self, *args):
def dismiss(*args):
self.open_dialog = False
def answer_callback(answer):
if answer == sets.string_lang_yes:
sys.exit(0)
dismiss()
if not self.open_dialog:
KDialog(answer_callback=answer_callback,
on_dismiss=dismiss,
separator_color=sets.separator_color,
title_color=get_color_from_hex(
sets.theme_text_black_color),
title=self.name_program).show(
text=sets.string_lang_exit.format(
sets.theme_text_black_color),
text_button_ok=sets.string_lang_yes,
text_button_no=sets.string_lang_no,
param='query',
auto_dismiss=True)
self.open_dialog = True
class UserPrefs(EventDispatcher):
'''
A class to manage user preferences for the RaceCapture app
'''
_schedule_save = None
_prefs_dict = {'range_alerts': {}, 'gauge_settings':{}}
store = None
prefs_file_name = 'prefs.json'
prefs_file = None
config = None
data_dir = '.'
user_files_dir = '.'
def __init__(self, data_dir, user_files_dir, save_timeout=2, **kwargs):
self.data_dir = data_dir
self.user_files_dir = user_files_dir
self.prefs_file = path.join(self.data_dir, self.prefs_file_name)
self.load()
self._schedule_save = Clock.create_trigger(self.save, save_timeout)
def set_range_alert(self, key, range_alert):
'''
Sets a range alert with the specified key
:param key the key for the range alert
:type string
:param range_alert the range alert
:type object
'''
self._prefs_dict["range_alerts"][key] = range_alert
self._schedule_save()
def get_range_alert(self, key, default=None):
'''
Retrives a range alert for the specified key
:param key the key for the range alert
:type key string
:param default the default value, optional
:type default user specified
:return the range alert, or the default value
'''
return self._prefs_dict["range_alerts"].get(key, default)
def set_gauge_config(self, gauge_id, channel):
'''
Stores a gauge configuration for the specified gauge_id
:param gauge_id the key for the gauge
:type gauge_id string
:param channel the configuration for the channel
:type channel object
'''
self._prefs_dict["gauge_settings"][gauge_id] = channel
self._schedule_save()
def get_gauge_config(self, gauge_id):
'''
Get the gauge configuration for the specified gauge_id
:param gauge_id the key for the gauge
:type string
:return the gauge configuration
'''
return self._prefs_dict["gauge_settings"].get(gauge_id, False)
def get_last_selected_track_id(self):
return self.get_pref('track_detection', 'last_selected_track_id')
def get_last_selected_track_timestamp(self):
return self.get_pref_int('track_detection', 'last_selected_track_timestamp')
def set_last_selected_track(self, track_id, timestamp):
self.set_pref('track_detection', 'last_selected_track_id', track_id)
self.set_pref('track_detection', 'last_selected_track_timestamp', timestamp)
@property
def datastore_location(self):
return os.path.join(self.data_dir, 'datastore.sq3')
def save(self, *largs):
'''
Saves the current configuration
'''
with open(self.prefs_file, 'w+') as prefs_file:
data = self.to_json()
prefs_file.write(data)
def set_config_defaults(self):
'''
Set defaults for preferences
'''
# Base system preferences
self.config.adddefaultsection('help')
self.config.adddefaultsection('preferences')
self.config.setdefault('preferences', 'distance_units', 'miles')
self.config.setdefault('preferences', 'temperature_units', 'Fahrenheit')
self.config.setdefault('preferences', 'show_laptimes', 1)
self.config.setdefault('preferences', 'startup_screen', 'Home Page')
default_user_files_dir = self.user_files_dir
self.config.setdefault('preferences', 'config_file_dir', default_user_files_dir)
self.config.setdefault('preferences', 'firmware_dir', default_user_files_dir)
self.config.setdefault('preferences', 'import_datalog_dir', default_user_files_dir)
self.config.setdefault('preferences', 'first_time_setup', '1')
self.config.setdefault('preferences', 'send_telemetry', '0')
self.config.setdefault('preferences', 'record_session', '1')
self.config.setdefault('preferences', 'last_dash_screen', 'gaugeView')
self.config.setdefault('preferences', 'global_help', True)
if platform == 'android':
self.config.setdefault('preferences', 'conn_type', 'Bluetooth')
# Dashboard preferences
self.config.adddefaultsection('dashboard_preferences')
self.config.setdefault('dashboard_preferences', 'pitstoptimer_enabled', 1)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_trigger_speed', 5)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_alert_speed', 25)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_exit_speed', 55)
# Track detection pref
self.config.adddefaultsection('track_detection')
self.config.setdefault('track_detection', 'last_selected_track_id', 0)
self.config.setdefault('track_detection', 'last_selected_track_timestamp', 0)
self.config.adddefaultsection('analysis_preferences')
self.config.setdefault('analysis_preferences', 'selected_sessions_laps', '{"sessions":{}}')
def load(self):
Logger.info('UserPrefs: Data Dir is: {}'.format(self.data_dir))
self.config = ConfigParser()
self.config.read(os.path.join(self.data_dir, 'preferences.ini'))
self.set_config_defaults()
self._prefs_dict = {'range_alerts': {}, 'gauge_settings':{}}
try:
with open(self.prefs_file, 'r') as data:
content = data.read()
content_dict = json.loads(content)
if content_dict.has_key("range_alerts"):
for name, settings in content_dict["range_alerts"].iteritems():
self._prefs_dict["range_alerts"][name] = Range.from_dict(settings)
if content_dict.has_key("gauge_settings"):
for id, channel in content_dict["gauge_settings"].iteritems():
self._prefs_dict["gauge_settings"][id] = channel
except Exception:
pass
def get_pref_bool(self, section, option, default=None):
'''
Retrieve a preferences value as a bool.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default bool
:return bool preference value
'''
try:
return self.config.getboolean(section, option)
except (NoOptionError, ValueError):
return default
def get_pref_float(self, section, option, default=None):
'''
Retrieve a preferences value as a float.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default float
:return float preference value
'''
try:
return self.config.getfloat(section, option)
except (NoOptionError, ValueError):
return default
def get_pref_int(self, section, option, default=None):
'''
Retrieve a preferences value as an int.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default user specified
:return int preference value
'''
try:
return self.config.getint(section, option)
except (NoOptionError, ValueError):
return default
def get_pref(self, section, option, default=None):
'''
Retrieve a preferences value as a string.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default user specified
:return string preference value
'''
try:
return self.config.get(section, option)
except (NoOptionError, ValueError):
return default
def set_pref(self, section, option, value):
'''
Set a preference value
:param section the configuration section for the preference
:type string
:param option the option for the section
:type string
:param value the preference value to set
:type value user specified
'''
self.config.set(section, option, value)
self.config.write()
def to_json(self):
'''
Serialize preferences to json
'''
data = {'range_alerts': {}, 'gauge_settings':{}}
for name, range_alert in self._prefs_dict["range_alerts"].iteritems():
data["range_alerts"][name] = range_alert.to_dict()
for id, channel in self._prefs_dict["gauge_settings"].iteritems():
data["gauge_settings"][id] = channel
return json.dumps(data)
class DesignerSettings(Settings):
'''Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of Kivy Designer.
'''
config_parser = ObjectProperty(None)
'''Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
'''
def __init__(self, **kwargs):
super(DesignerSettings, self).__init__(*kwargs)
self.register_type('list', SettingList)
def load_settings(self):
'''This function loads project settings
'''
self.config_parser = ConfigParser(name='DesignerSettings')
DESIGNER_CONFIG = os.path.join(get_kivy_designer_dir(),
DESIGNER_CONFIG_FILE_NAME)
_dir = os.path.dirname(designer.__file__)
_dir = os.path.split(_dir)[0]
DEFAULT_CONFIG = os.path.join(_dir, DESIGNER_CONFIG_FILE_NAME)
if not os.path.exists(DESIGNER_CONFIG):
shutil.copyfile(DEFAULT_CONFIG, DESIGNER_CONFIG)
self.config_parser.read(DESIGNER_CONFIG)
self.config_parser.upgrade(DEFAULT_CONFIG)
# creates a panel before insert it to update code input theme list
panel = self.create_json_panel(
'Kivy Designer Settings', self.config_parser,
os.path.join(_dir, 'designer', 'settings',
'designer_settings.json'))
uid = panel.uid
if self.interface is not None:
self.interface.add_panel(panel, 'Kivy Designer Settings', uid)
# loads available themes
for child in panel.children:
if child.id == 'code_input_theme_options':
child.items = styles.get_all_styles()
# tries to find python and buildozer path if it's not defined
path = self.config_parser.getdefault('global', 'python_shell_path', '')
if path.strip() == '':
self.config_parser.set('global', 'python_shell_path',
sys.executable)
self.config_parser.write()
buildozer_path = self.config_parser.getdefault('buildozer',
'buildozer_path', '')
if buildozer_path.strip() == '':
buildozer_path = find_executable('buildozer')
if buildozer_path:
self.config_parser.set('buildozer', 'buildozer_path',
buildozer_path)
self.config_parser.write()
self.add_json_panel(
'Buildozer', self.config_parser,
os.path.join(_dir, 'designer', 'settings',
'buildozer_settings.json'))
self.add_json_panel(
'Hanga', self.config_parser,
os.path.join(_dir, 'designer', 'settings', 'hanga_settings.json'))
def on_config_change(self, *args):
'''This function is default handler of on_config_change event.
'''
self.config_parser.write()
super(DesignerSettings, self).on_config_change(*args)
class DesignerSettings(Settings):
'''Subclass of :class:`kivy.uix.settings.Settings` responsible for
showing settings of Kivy Designer.
'''
config_parser = ObjectProperty(None)
'''Config Parser for this class. Instance
of :class:`kivy.config.ConfigParser`
'''
def __init__(self, **kwargs):
super(DesignerSettings, self).__init__(*kwargs)
self.register_type('list', SettingList)
self.register_type('shortcut', SettingShortcut)
def load_settings(self):
'''This function loads project settings
'''
self.config_parser = ConfigParser(name='DesignerSettings')
DESIGNER_CONFIG = os.path.join(get_config_dir(),
DESIGNER_CONFIG_FILE_NAME)
_dir = os.path.dirname(designer.__file__)
_dir = os.path.split(_dir)[0]
DEFAULT_CONFIG = os.path.join(_dir, DESIGNER_CONFIG_FILE_NAME)
if not os.path.exists(DESIGNER_CONFIG):
shutil.copyfile(DEFAULT_CONFIG,
DESIGNER_CONFIG)
self.config_parser.read(DESIGNER_CONFIG)
self.config_parser.upgrade(DEFAULT_CONFIG)
# creates a panel before insert it to update code input theme list
panel = self.create_json_panel('Kivy Designer Settings',
self.config_parser,
os.path.join(_dir, 'designer',
'settings', 'designer_settings.json'))
uid = panel.uid
if self.interface is not None:
self.interface.add_panel(panel, 'Kivy Designer Settings', uid)
# loads available themes
for child in panel.children:
if child.id == 'code_input_theme_options':
child.items = styles.get_all_styles()
# tries to find python and buildozer path if it's not defined
path = self.config_parser.getdefault(
'global', 'python_shell_path', '')
if path.strip() == '':
self.config_parser.set('global', 'python_shell_path',
sys.executable)
self.config_parser.write()
buildozer_path = self.config_parser.getdefault('buildozer',
'buildozer_path', '')
if buildozer_path.strip() == '':
buildozer_path = find_executable('buildozer')
if buildozer_path:
self.config_parser.set('buildozer',
'buildozer_path',
buildozer_path)
self.config_parser.write()
self.add_json_panel('Buildozer', self.config_parser,
os.path.join(_dir, 'designer', 'settings',
'buildozer_settings.json'))
self.add_json_panel('Hanga', self.config_parser,
os.path.join(_dir, 'designer', 'settings',
'hanga_settings.json'))
self.add_json_panel('Keyboard Shortcuts', self.config_parser,
os.path.join(_dir, 'designer', 'settings',
'shortcuts.json'))
def on_config_change(self, *args):
'''This function is default handler of on_config_change event.
'''
self.config_parser.write()
super(DesignerSettings, self).on_config_change(*args)
class name_project(App):
'''Функционал программы.'''
title = 'name_project'
icon = 'icon.png'
nav_drawer = ObjectProperty()
theme_cls = ThemeManager()
theme_cls.primary_palette = 'Blue'
lang = StringProperty('en')
def __init__(self, **kvargs):
super(name_project, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.plugin = ShowPlugins(self)
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.exit_interval = False
self.dict_language = literal_eval(
open(
os.path.join(self.directory, 'data', 'locales', 'locales.txt')).read()
)
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'data', 'locales')
)
def get_application_config(self):
return super(name_project, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
'''Создаёт файл настроек приложения name_project.ini.'''
config.adddefaultsection('General')
config.setdefault('General', 'language', 'en')
def set_value_from_config(self):
'''Устанавливает значения переменных из файла настроек name_project.ini.'''
self.config.read(os.path.join(self.directory, 'name_project.ini'))
self.lang = self.config.get('General', 'language')
def build(self):
self.set_value_from_config()
self.load_all_kv_files(os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen() # главный экран программы
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
if not PY2:
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
else:
Builder.load_file(kv_file)
def events_program(self, instance, keyboard, keycode, text, modifiers):
'''Вызывается при нажатии кнопки Меню или Back Key
на мобильном устройстве.'''
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.toggle_nav_drawer()
self.back_screen(event=keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self, event=None):
'''Менеджер экранов. Вызывается при нажатии Back Key
и шеврона "Назад" в ToolBar.'''
# Нажата BackKey.
if event in (1001, 27):
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
except:
self.manager.current = 'base'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def show_plugins(self, *args):
'''Выводит на экран список плагинов.'''
self.plugin.show_plugins()
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.about.ids.label.text = \
self.translation._(
u'[size=20][b]name_project[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT\n\n'
u'[size=20][b]Developer[/b][/size]\n\n'
u'[ref=SITE_PROJECT]'
u'[color={link_color}]name_author[/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=repo_project_on_github]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_license(self, *args):
if not PY2:
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
else:
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE')).read()
self.nav_drawer._toggle()
self.manager.current = 'license'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen()]]
self.screen.ids.action_bar.title = \
self.translation._('MIT LICENSE')
def select_locale(self, *args):
'''Выводит окно со списком имеющихся языковых локализаций для
установки языка приложения.'''
def select_locale(name_locale):
'''Устанавливает выбранную локализацию.'''
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(
Lists(
dict_items=dict_info_locales,
events_callback=select_locale, flag='one_select_check'
),
size=(.85, .55)
)
self.window_language.open()
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
class UserPrefs(EventDispatcher):
'''
A class to manage user preferences for the RaceCapture app
'''
DEFAULT_DASHBOARD_SCREENS = ['5x_gauge_view', 'laptime_view', 'tach_view', 'rawchannel_view']
DEFAULT_PREFS_DICT = {'range_alerts': {},
'gauge_settings':{},
'screens':DEFAULT_DASHBOARD_SCREENS,
'alerts': {}}
DEFAULT_ANALYSIS_CHANNELS = ['Speed']
prefs_file_name = 'prefs.json'
def __init__(self, data_dir, user_files_dir, save_timeout=0.2, **kwargs):
self._prefs_dict = UserPrefs.DEFAULT_PREFS_DICT
self.config = ConfigParser()
self.data_dir = data_dir
self.user_files_dir = user_files_dir
self.prefs_file = path.join(self.data_dir, self.prefs_file_name)
self.register_event_type("on_pref_change")
self.load()
def on_pref_change(self, section, option, value):
pass
def set_range_alert(self, key, range_alert):
'''
Sets a range alert with the specified key
:param key the key for the range alert
:type string
:param range_alert the range alert
:type object
'''
self._prefs_dict["range_alerts"][key] = range_alert
self.save()
def get_range_alert(self, key, default=None):
'''
Retrives a range alert for the specified key
:param key the key for the range alert
:type key string
:param default the default value, optional
:type default user specified
:return the range alert, or the default value
'''
return self._prefs_dict["range_alerts"].get(key, default)
def get_alertrules(self, channel):
'''
Retrieve the alert_rules for the specified channel. If the
alertrules do not exist for the specified channel, return an empty
default AlertRuleCollection
:return AlertRuleCollection
'''
alertrules = self._prefs_dict['alerts'].get(channel)
if alertrules is None:
alertrules = AlertRuleCollection(channel, [])
self._prefs_dict['alerts'][channel] = alertrules
return alertrules
def set_alertrules(self, channel, alertrules):
self._prefs_dict['alerts'][channel] = alertrules
self.save()
def set_gauge_config(self, gauge_id, config_value):
'''
Stores a gauge configuration for the specified gauge_id
:param gauge_id the key for the gauge
:type gauge_id string
:param config_value the configuration value to set
:type config_value string
'''
self._prefs_dict["gauge_settings"][gauge_id] = config_value
self.save()
def get_gauge_config(self, gauge_id):
'''
Get the gauge configuration for the specified gauge_id
:param gauge_id the key for the gauge
:type string
:return the gauge configuration
'''
return self._prefs_dict["gauge_settings"].get(gauge_id, False)
def get_dashboard_screens(self):
return copy(self._prefs_dict['screens'])
def set_dashboard_screens(self, screens):
self._prefs_dict['screens'] = copy(screens)
self.save()
# Regular preferences below here
def get_last_selected_track_id(self):
return self.get_pref('track_detection', 'last_selected_track_id')
def get_last_selected_track_timestamp(self):
return self.get_pref_int('track_detection', 'last_selected_track_timestamp')
def get_user_cancelled_location(self):
return self.get_pref('track_detection', 'user_cancelled_location')
def set_last_selected_track(self, track_id, timestamp, user_cancelled_location='0,0'):
self.set_pref('track_detection', 'last_selected_track_id', track_id)
self.set_pref('track_detection', 'last_selected_track_timestamp', timestamp)
self.set_pref('track_detection', 'user_cancelled_location', user_cancelled_location)
self.save()
@property
def datastore_location(self):
return os.path.join(self.data_dir, 'datastore.sq3')
def save(self, *largs):
'''
Saves the current configuration
'''
Logger.info('UserPrefs: Saving preferences')
with open(self.prefs_file, 'w+') as prefs_file:
data = self.to_json()
prefs_file.write(data)
def set_config_defaults(self):
'''
Set defaults for preferences
'''
# Base system preferences
self.config.adddefaultsection('help')
self.config.adddefaultsection('preferences')
self.config.setdefault('preferences', 'distance_units', 'miles')
self.config.setdefault('preferences', 'temperature_units', 'Fahrenheit')
self.config.setdefault('preferences', 'show_laptimes', 1)
self.config.setdefault('preferences', 'startup_screen', 'Home Page')
default_user_files_dir = self.user_files_dir
self.config.setdefault('preferences', 'config_file_dir', default_user_files_dir)
self.config.setdefault('preferences', 'export_file_dir', default_user_files_dir)
self.config.setdefault('preferences', 'firmware_dir', default_user_files_dir)
self.config.setdefault('preferences', 'import_datalog_dir', default_user_files_dir)
self.config.setdefault('preferences', 'send_telemetry', '0')
self.config.setdefault('preferences', 'record_session', '1')
self.config.setdefault('preferences', 'global_help', True)
# Connection type for mobile
if is_mobile_platform():
if is_android():
self.config.setdefault('preferences', 'conn_type', 'Bluetooth')
elif is_ios():
self.config.setdefault('preferences', 'conn_type', 'WiFi')
else:
self.config.setdefault('preferences', 'conn_type', 'Serial')
# Dashboard preferences
self.config.adddefaultsection('dashboard_preferences')
self.config.setdefault('dashboard_preferences', 'last_dash_screen', '5x_gauge_view')
self.config.setdefault('dashboard_preferences', 'pitstoptimer_enabled', 1)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_trigger_speed', 5)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_alert_speed', 25)
self.config.setdefault('dashboard_preferences', 'pitstoptimer_exit_speed', 55)
# Track detection pref
self.config.adddefaultsection('track_detection')
self.config.setdefault('track_detection', 'last_selected_track_id', 0)
self.config.setdefault('track_detection', 'last_selected_track_timestamp', 0)
self.config.setdefault('track_detection', 'user_cancelled_location', '0,0')
self.config.adddefaultsection('analysis_preferences')
self.config.setdefault('analysis_preferences', 'selected_sessions_laps', '{"sessions":{}}')
self.config.setdefault('analysis_preferences', 'selected_analysis_channels', ','.join(UserPrefs.DEFAULT_ANALYSIS_CHANNELS))
self.config.adddefaultsection('setup')
self.config.setdefault('setup', 'setup_enabled', 1)
def load(self):
Logger.info('UserPrefs: Data Dir is: {}'.format(self.data_dir))
self.config.read(os.path.join(self.data_dir, 'preferences.ini'))
self.set_config_defaults()
try:
with open(self.prefs_file, 'r') as data:
content = data.read()
content_dict = json.loads(content)
if content_dict.has_key("gauge_settings"):
for id, channel in content_dict["gauge_settings"].iteritems():
self._prefs_dict["gauge_settings"][id] = channel
if content_dict.has_key('screens'):
self._prefs_dict['screens'] = content_dict['screens']
if content_dict.has_key('alerts'):
for channel, alertrules in content_dict['alerts'].iteritems():
self._prefs_dict['alerts'][channel] = AlertRuleCollection.from_dict(alertrules)
except Exception as e:
Logger.error('Error loading preferences, using defaults. {}'.format(e))
def init_pref_section(self, section):
'''
Initializes a preferences section with the specified name.
if the section already exists, there is no effect.
:param section the name of the preference section
:type string
'''
self.config.adddefaultsection(section)
def get_pref_bool(self, section, option, default=None):
'''
Retrieve a preferences value as a bool.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default bool
:return bool preference value
'''
try:
return self.config.getboolean(section, option)
except (NoOptionError, ValueError):
return default
def get_pref_float(self, section, option, default=None):
'''
Retrieve a preferences value as a float.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default float
:return float preference value
'''
try:
return self.config.getfloat(section, option)
except (NoOptionError, ValueError):
return default
def get_pref_int(self, section, option, default=None):
'''
Retrieve a preferences value as an int.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default user specified
:return int preference value
'''
try:
return self.config.getint(section, option)
except (NoOptionError, ValueError):
return default
def get_pref(self, section, option, default=None):
'''
Retrieve a preferences value as a string.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default user specified
:return string preference value
'''
try:
return self.config.get(section, option)
except (NoOptionError, ValueError):
return default
def get_pref_list(self, section, option, default=[]):
"""
Retrieve a preferences value as a list.
return default value if preference does not exist
:param section the configuration section for the preference
:type section string
:param option the option for the section
:type option string
:param default
:type default user specified
:return list of string values
"""
try:
return self.config.get(section, option).split(',')
except (NoOptionError, ValueError):
return default
def set_pref(self, section, option, value):
'''
Set a preference value
:param section the configuration section for the preference
:type string
:param option the option for the section
:type string
:param value the preference value to set
:type value user specified
'''
current_value = None
try:
current_value = self.config.get(section, option)
except NoOptionError:
pass
self.config.set(section, option, value)
self.config.write()
if value != current_value:
self.dispatch('on_pref_change', section, option, value)
def set_pref_list(self, section, option, value):
"""
Set a preference value by list
:param section the configuration section for the preference
:type string
:param option the option for the section
:type string
:param value the preference value to set
:type value list (list of strings)
"""
try:
self.set_pref(section, option, ','.join(value))
except TypeError:
Logger.error('UserPrefs: failed to set preference list for {}:{} - {}'.format(section, option, value))
def to_json(self):
'''
Serialize preferences to json
'''
data = {'range_alerts': {}, 'gauge_settings':{}, 'screens': [], 'alerts': {}}
for name, range_alert in self._prefs_dict["range_alerts"].iteritems():
data["range_alerts"][name] = range_alert.to_dict()
for id, channel in self._prefs_dict["gauge_settings"].iteritems():
data["gauge_settings"][id] = channel
for name, alertrules in self._prefs_dict['alerts'].iteritems():
data['alerts'][name] = alertrules.to_dict()
data['screens'] = self._prefs_dict['screens']
return json.dumps(data, sort_keys=True, indent=2, separators=(',', ': '))
class name_project(App):
title = 'TalantA'
icon = 'icon.png'
nav_drawer = ObjectProperty()
theme_cls = ThemeManager()
theme_cls.primary_palette = 'Brown'
lang = StringProperty('en')
def __init__(self, **kvargs):
super(name_project, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.exit_interval = False
self.dict_language = literal_eval(
open(os.path.join(self.directory, 'data', 'locales',
'locales.txt')).read())
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'data',
'locales'))
def get_application_config(self):
return super(name_project, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
config.adddefaultsection('General')
config.setdefault('General', 'language', 'en')
def set_value_from_config(self):
self.config.read(os.path.join(self.directory, 'name_project.ini'))
self.lang = self.config.get('General', 'language')
def build(self):
self.set_value_from_config()
self.load_all_kv_files(
os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen()
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
if not PY2:
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
else:
Builder.load_file(kv_file)
def events_program(self, instance, keyboard, keycode, text, modifiers):
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.toggle_nav_drawer()
self.back_screen(event=keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self, event=None):
if event in (1001, 27):
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
except:
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'base'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'about'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_help(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'helper'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_browse_art(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'browse'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def toggle_nav(self, *args):
self.nav_drawer.toggle_nav_drawer()
def show_account(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'account'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_sign_up(self, *args):
#self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'signup'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.show_login()]]
def show_login(self, *args):
# self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'login'
self.screen.ids.action_bar.left_action_items = []
def show_events(self, *args):
self.manager.current = 'browse_gallery'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def select_locale(self, *args):
def select_locale(name_locale):
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(Lists(dict_items=dict_info_locales,
events_callback=select_locale,
flag='one_select_check'),
size=(.85, .55))
self.window_language.open()
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
class ConfigScreen(Screen):
s = ObjectProperty(None)
player_keys = 'left right thrust fire special'.split()
def __init__(self, **kw):
super(ConfigScreen, self).__init__(**kw)
self.config = ConfigParser()
self.config.read('config.ini')
self._update_players()
Clock.schedule_once(self._after_build, 1)
def on_leave(self, *args):
Screen.on_leave(self, *args)
self._update_players()
def _update_players(self):
for i, p in enumerate(self.players, start=1):
self._update_player(i, p)
def _update_player(self, i, p):
keys = {}
for key in self.player_keys:
keys[key] = int(self.config.get('player%d' % i, key))
p['keys'] = keys
def _after_build(self, dt=None):
print(os.path.abspath('.'), os.path.isfile("config.json"))
s = self.s
s.register_type('button', SettingButtonItem)
s.add_json_panel('stuff', self.config, 'config.json')
for i in range(1, 6):
player = 'player%d' % i
j = player + '.json'
with open(j, 'wb') as f:
f.write(
json.dumps([{
"type": "button",
"title": a,
"desc": "key for applying '%s'" % a,
"section": player,
"key": a,
} for a in self.player_keys],
indent=4).encode(encoding='utf_8'))
s.add_json_panel(player, self.config, j)
def save(self):
self.config.write()
self.manager.current = 'menu'
players = [
{
'name': 'Player1',
'source': 'imgs/DUCK.GIF', #'weapon': 'gun',
'pos': (50, 50),
'r': 1.0,
'g': 1.0,
'b': 0.75,
'rotation': 45
},
{
'name': 'Player2',
'source': 'imgs/DUCK.GIF', #'weapon': 'gun',
'pos': (50, 200),
'r': 1.0,
'g': 0.5,
'b': 0.75,
'rotation': 45
},
{
'name': 'Player3',
'source': 'imgs/DUCK.GIF', #'weapon': 'gun',
'pos': (250, 50),
'r': 0.5,
'g': 0.2,
'b': 0.75,
'rotation': 45
},
{
'name': 'Player4',
'source': 'imgs/DUCK.GIF', #'weapon': 'gun',
'pos': (350, 50),
'r': 0.5,
'g': 0.5,
'b': 0.98,
'rotation': 45
},
{
'name': 'Player5',
'source': 'imgs/DUCK.GIF', #'weapon': 'gun',
'pos': (450, 50),
'r': 1.0,
'g': 0.1,
'b': 0.99,
'rotation': 45
},
{
'name': 'Player6',
'source': 'imgs/DUCK.GIF', #'weapon': 'gun',
'pos': (550, 50),
'r': 0.35,
'g': 0.99,
'b': 0.99,
'rotation': 45
},
]
for p in players:
p['size_hint'] = (0.02, 0.02)
class cInterFaceConfig(object):
""" Class to manage the initialisation/configuration and access toe the settings of an Interface settings objects
"""
def __init__(self, oInterFace):
self.oInterFace = oInterFace
self.oConfigParser = KivyConfigParser()
self.oFnConfig = None
self.uCurrentSection = None
self.uDefaultConfigName = u'DEVICE_DEFAULT'
self.aDiscoverScriptList = None
self.oInputKeyboard = None
self.dDefaultSettings = {
"SettingTitle": {
"active": "enabled",
"order": 0,
"type": "title",
"title": "$lvar(560)"
},
"Host": {
"active": "disabled",
"order": 1,
"type": "string",
"title": "$lvar(6004)",
"desc": "$lvar(6005)",
"section": "$var(InterfaceConfigSection)",
"key": "Host",
"default": "192.168.1.2"
},
"Port": {
"active": "disabled",
"order": 2,
"type": "string",
"title": "$lvar(6002)",
"desc": "$lvar(6003)",
"section": "$var(InterfaceConfigSection)",
"key": "Port",
"default": "80"
},
"User": {
"active": "disabled",
"order": 3,
"type": "string",
"title": "$lvar(6006)",
"desc": "$lvar(6007)",
"section": "$var(InterfaceConfigSection)",
"key": "User",
"default": "root"
},
"Password": {
"active": "disabled",
"order": 4,
"type": "string",
"title": "$lvar(6008)",
"desc": "$lvar(6009)",
"section": "$var(InterfaceConfigSection)",
"key": "Password",
"default": ""
},
"FNCodeset": {
"active": "disabled",
"order": 5,
"type": "scrolloptions",
"title": "$lvar(6000)",
"desc": "$lvar(6001)",
"section": "$var(InterfaceConfigSection)",
"key": "FNCodeset",
"default": "Select",
"options": ["$var(InterfaceCodesetList)"]
},
"ParseResult": {
"active": "disabled",
"order": 6,
"type": "scrolloptions",
"title": "$lvar(6027)",
"desc": "$lvar(6028)",
"section": "$var(InterfaceConfigSection)",
"key": "ParseResult",
"default": "store",
"options": ["no", "tokenize", "store", "json", "dict", "xml"]
},
"TokenizeString": {
"active": "disabled",
"order": 7,
"type": "string",
"title": "$lvar(6029)",
"desc": "$lvar(6030)",
"section": "$var(InterfaceConfigSection)",
"key": "TokenizeString",
"default": ":"
},
"TimeOut": {
"active": "disabled",
"order": 8,
"type": "numericfloat",
"title": "$lvar(6019)",
"desc": "$lvar(6020)",
"section": "$var(InterfaceConfigSection)",
"key": "TimeOut",
"default": "1.0"
},
"TimeToClose": {
"active": "disabled",
"order": 9,
"type": "numeric",
"title": "$lvar(6010)",
"desc": "$lvar(6011)",
"section": "$var(InterfaceConfigSection)",
"key": "TimeToClose",
"default": "10"
},
"DisableInterFaceOnError": {
"active": "disabled",
"order": 10,
"type": "bool",
"title": "$lvar(529)",
"desc": "$lvar(530)",
"section": "$var(InterfaceConfigSection)",
"key": "DisableInterFaceOnError",
"default": "0"
},
"DisconnectInterFaceOnSleep": {
"active": "disabled",
"order": 11,
"type": "bool",
"title": "$lvar(533)",
"desc": "$lvar(534)",
"section": "$var(InterfaceConfigSection)",
"key": "DisconnectInterFaceOnSleep",
"default": "1"
},
"DiscoverSettingButton": {
"active":
"disabled",
"order":
12,
"type":
"buttons",
"title":
"$lvar(6033)",
"desc":
"$lvar(6034)",
"section":
"$var(InterfaceConfigSection)",
"key":
"DiscoverSettings",
"buttons": [{
"title": "Discover Settings",
"id": "button_discover"
}]
},
"ConfigChangeButtons": {
"active":
"enabled",
"order":
999,
"type":
"buttons",
"title":
"$lvar(565)",
"desc":
"$lvar(566)",
"section":
"$var(InterfaceConfigSection)",
"key":
"configchangebuttons",
"buttons": [{
"title": "$lvar(569)",
"id": "button_add"
}, {
"title": "$lvar(570)",
"id": "button_delete"
}, {
"title": "$lvar(571)",
"id": "button_rename"
}]
}
}
self.dGenericDiscoverSettings = {
"DiscoverScriptName": {
"active": "hidden",
"order": 100,
"scriptsection": "$lvar(539)",
"type": "scrolloptions",
"title": "$lvar(6035)",
"desc": "$lvar(6036)",
"section": "$var(InterfaceConfigSection)",
"key": "DiscoverScriptName",
"default": "",
"options": ["$var(DISCOVERSCRIPTLIST)"]
},
"SaveDiscoveredIP": {
"active": "hidden",
"order": 101,
"scriptsection": "$lvar(539)",
"type": "bool",
"title": "$lvar(6031)",
"desc": "$lvar(6032)",
"section": "$var(InterfaceConfigSection)",
"key": "SaveDiscoveredIP",
"default": "1"
},
"OldDiscoveredIP": {
"active": "hidden",
"order": 102,
"scriptsection": "$lvar(539)",
"type": "string",
"title": "$lvar(6021)",
"desc": "$lvar(6022)",
"section": "$var(InterfaceConfigSection)",
"key": "OldDiscoveredIP",
"default": ""
},
"CheckDiscoverButton": {
"active":
"disabled",
"order":
103,
"scriptsection":
"$lvar(539)",
"type":
"buttons",
"title":
"Check Discover",
"desc":
"$lvar(6034)",
"section":
"$var(InterfaceConfigSection)",
"key":
"CheckDiscover",
"buttons": [{
"title": "Check Discover",
"id": "button_checkdiscover"
}]
},
}
self.dSettingsCombined = {}
def Init(self):
""" Init function, sets the configuration file name and add the default sections """
self.oFnConfig = cFileName(self.oInterFace.oPathMy) + u'config.ini'
if not self.oFnConfig.Exists():
self.CreateSection(uSectionName=self.uDefaultConfigName)
def LoadConfig(self):
""" Loads the config file (only once) """
try:
self.oConfigParser.filename = self.oFnConfig.string
if len(self.oConfigParser._sections) == 0:
if self.oFnConfig.Exists():
self.oInterFace.ShowDebug(u'Reading Config File')
self.oConfigParser.read(self.oFnConfig.string)
else:
if not self.oFnConfig.Exists():
self.oConfigParser.write()
except Exception as e:
self.oInterFace.ShowError(
u"can\'t load config file: %s" % self.oFnConfig.string, None,
e)
def CreateSection(self, uSectionName):
"""
Adds a new section to the config parser
:param string uSectionName: The name of the section to create
"""
self.oInterFace.ShowDebug('Adding new section [%s]' % (uSectionName))
self.oConfigParser.add_section(uSectionName)
self.oConfigParser.write()
def GetSettingParFromIni(self, uSectionName, uVarName):
"""
Returns a setting for the configuration ini file
If the entry does not exist, it tries to puls the value from the aInterFaceIniSettings dict of already predifined settings
If not exist there as well, an error will be logged
:rtype: string|None
:param string uSectionName: The name of the section
:param uVarName: The name of the parameter/setting in the section
:return: The value of the setting, empty string if not found
"""
oSetting = self.oInterFace.GetSettingObjectForConfigName(uSectionName)
uResult = Config_GetDefault_Str(self.oConfigParser, uSectionName,
uVarName, None)
if uResult is None:
uResult = str(oSetting.aInterFaceIniSettings.queryget(uVarName))
if uResult is None:
uResult = ''
self.oInterFace.ShowError(u'can\'t find interface setting: %s:%s' %
(uSectionName, uVarName))
else:
self.oInterFace.ShowDebug(
u'Returning interface setting: %s from %s:%s' %
(uResult, uSectionName, uVarName))
return uResult
def WriteDefinitionConfigPar(self,
uSectionName,
uVarName,
uVarValue,
bNowrite=False,
bForce=False):
""" Writes a variable to the config file
:param string uSectionName: The name of the section
:param string uVarName: The name of the parameter/setting in the section
:param string uVarValue: The value for the setting
:param bool bNowrite: Flag, if we should not immidiatly write the the setting
:param bool bForce: Flag to force write, even if parameter exists in config
"""
self.LoadConfig()
if not self.oConfigParser.has_section(uSectionName):
self.CreateSection(uSectionName=uSectionName)
if self.oConfigParser.has_option(uSectionName, uVarName):
if not bForce:
return
self.oConfigParser.set(uSectionName, uVarName, uVarValue)
if not bNowrite:
self.oConfigParser.write()
for uSettingName in self.oInterFace.aSettings:
oSetting = self.oInterFace.aSettings[uSettingName]
if oSetting.uConfigName == uSectionName:
oSetting.aInterFaceIniSettings[uVarName] = uVarValue
break
def WriteDefinitionConfig(self, uSectionName, dSettings):
"""
writes all vars given in a dictionary to the config file
:param string uSectionName: The name of the section
:param dict dSettings: A dict of all settings to write
"""
for uKey in dSettings:
self.WriteDefinitionConfigPar(uSectionName=uSectionName,
uVarName=uKey,
uVarValue=dSettings[uKey],
bNowrite=True)
self.oConfigParser.write()
def ConfigureKivySettings(self, oKivySetting):
"""
Create the JSON string for all sections and applies it to a kivy settings object
Discover settings are excluded
:param setting oKivySetting:
:return: The KivySetting object
"""
RegisterSettingTypes(oKivySetting)
aSections = self.oConfigParser.sections()
if len(aSections) == 0:
self.CreateSection(uSectionName=self.uDefaultConfigName)
# The Codeset List could be applied as a orca var, so set it to the list
SetVar(uVarName=u'InterfaceCodesetList',
oVarValue=self.oInterFace.CreateCodsetListJSONString())
for uSection in aSections:
# the Section list should be applied as a orca var
SetVar(uVarName=u'InterfaceConfigSection', oVarValue=uSection)
# Let create a new temporary cSetting object to not harm the existing ones
oSetting = self.oInterFace.cInterFaceSettings(self.oInterFace)
# Read the ini file for this section
oSetting.ReadConfigFromIniFile(uSection)
# Create the setting string
dSettingsJSON = self.CreateSettingJsonCombined(
oSetting=oSetting, bIncludeDiscoverSettings=False)
uSettingsJSON = SettingDictToString(dSettingsJSON)
uSettingsJSON = ReplaceVars(uSettingsJSON)
oSetting = None
# if there is nothing to configure, then return
if uSettingsJSON == u'{}':
Globals.oNotifications.SendNotification(
'closesetting_interface')
return False
# add the jSon to the Kivy Setting
oKivySetting.add_json_panel(uSection,
self.oConfigParser,
data=uSettingsJSON)
# Adds the action handler
oKivySetting.bind(on_config_change=self.On_ConfigChange)
return oKivySetting
def On_ConfigChange(self, oSettings, oConfig, uSection, uKey, uValue):
"""
reacts, if user changes a setting
:param setting oSettings: The kivy settings object
:param ConfigParser oConfig: The Kivy config parser
:param string uSection: The section of the change
:param string uKey: The key name
:param string uValue: The value
"""
if uKey == u'configchangebuttons':
self.uCurrentSection = uSection
if uValue == u'button_add':
SetVar(uVarName=u'INTERFACEINPUT', oVarValue=u'DEVICE_dummy')
self.oInputKeyboard = ShowKeyBoard(u'INTERFACEINPUT',
self.On_InputAdd)
if uValue == u'button_delete':
ShowQuestionPopUp(
uTitle=u'$lvar(5003)',
uMessage=u'Do you really want to delete this setting?',
fktYes=self.On_InputDel,
uStringYes=u'$lvar(5001)',
uStringNo=u'$lvar(5002)')
if uValue == u'button_rename':
SetVar(uVarName=u'INTERFACEINPUT', oVarValue=uSection)
self.oInputKeyboard = ShowKeyBoard(u'INTERFACEINPUT',
self.On_InputRen)
elif uKey == u'DiscoverSettings':
Globals.oTheScreen.uConfigToConfig = uSection
Globals.oTheScreen.AddActionShowPageToQueue(
uPageName=u'Page_InterfaceSettingsDiscover')
elif uKey == u'FNCodeset':
oSetting = self.oInterFace.GetSettingObjectForConfigName(
uConfigName=uSection)
oSetting.aInterFaceIniSettings[uKey] = uValue
oSetting.ReadCodeset()
else:
oSetting = self.oInterFace.GetSettingObjectForConfigName(
uConfigName=uSection)
oSetting.aInterFaceIniSettings[uKey] = uValue
# ShowMessagePopUp(uMessage=u'$lvar(5011)')
if uKey == u'FNCodeset':
oSetting.ReadCodeset()
def On_InputAdd(self, uInput):
"""
User pressed the add configuration button
:param string uInput: The Name of the section
:return:
"""
if uInput == u'':
return
if self.oConfigParser.has_section(uInput):
return
self.oConfigParser.add_section(uInput)
self.oConfigParser.write()
Globals.oTheScreen.AddActionToQueue([{
'string': 'updatewidget',
'widgetname': 'Interfacesettings'
}])
self.ShowSettings()
def On_InputDel(self):
""" User pressed the del configuration button """
self.oConfigParser.remove_section(self.uCurrentSection)
self.oConfigParser.write()
self.ShowSettings()
def On_InputRen(self, uInput):
""" User pressed the rename configuration button """
if uInput == u'':
return
if self.oConfigParser.has_section(uInput):
return
self.oConfigParser._sections[uInput] = self.oConfigParser._sections[
self.uCurrentSection]
self.oConfigParser._sections.pop(self.uCurrentSection)
self.oConfigParser.write()
self.ShowSettings()
def ShowSettings(self):
""" Shows the settings page """
Globals.oTheScreen.AddActionToQueue([{
'string': 'updatewidget',
'widgetname': 'Interfacesettings'
}])
def GetSettingParFromVar2(self, uInterFaceName, uConfigName,
uSettingParName):
"""
Gets a Value for a setting parameter from the orca vars
The Orca vars fpr the parameter are automatically set in the cInterfaceMonitoredSettings class
:rtype: string
:param uInterFaceName: The name of interface to use
:param uConfigName: The nemae of the Config
:param uSettingParName: The name of the parameter
:return: The value of the parameter
"""
return GetVar(uVarName="CONFIG_" + uSettingParName.upper(),
uContext=uInterFaceName + u'/' + uConfigName)
def GetSettingParFromVar(self, uLink):
"""
Returns a setting var of a an other interface or config
The Interfca emust already be initalized
syntax should be: linked:interfacename:configname:varname
:rtype: string
:param string uLink: The link: syntax should be: linked:interfacename:configname:varname
:return: The Value of the linked setting, empty string, if not found
"""
aLinks = uLink.split(':')
if len(aLinks) == 4:
uInterFaceName = aLinks[1]
uConfigName = aLinks[2]
uSettingParName = aLinks[3]
Globals.oInterFaces.LoadInterface(uInterFaceName)
oInterface = Globals.oInterFaces.GetInterface(uInterFaceName)
oSetting = oInterface.GetSettingObjectForConfigName(
uConfigName=uConfigName)
oSetting.Discover()
return self.GetSettingParFromVar2(uInterFaceName=uInterFaceName,
uConfigName=uConfigName,
uSettingParName=uSettingParName)
return ""
def CreateSettingJsonCombined(self,
oSetting,
bIncludeDiscoverSettings=True):
"""
Creates a json dict which holds all the setting defintions of
the core interface plus the settings from the discover script (if requested)
:rtype: dict
:param cBaseInterFaceSettings oSetting: an IterFaceSettins Object
:param bool bIncludeDiscoverSettings: If we want to include the discover settings
:return: a dict of combined settings
"""
if len(self.dSettingsCombined) != 0:
return self.dSettingsCombined
dRet = {}
for uKey in self.dDefaultSettings:
if self.dDefaultSettings[uKey]["active"] != "disabled":
dRet[uKey] = self.dDefaultSettings[uKey]
dInterFaceJSON = self.oInterFace.GetConfigJSON()
for uKey in dInterFaceJSON:
dLine = dInterFaceJSON[uKey]
iOrder = dLine['order']
for uKey2 in dRet:
if dRet[uKey2]['order'] >= iOrder:
dRet[uKey2]['order'] += 1
dRet[uKey] = dLine
if 'DiscoverSettingButton' in dRet and bIncludeDiscoverSettings:
dRet.update(self.dGenericDiscoverSettings)
if self.aDiscoverScriptList is None:
self.aDiscoverScriptList = Globals.oScripts.GetScriptListForScriptType(
"DEVICE_DISCOVER")
iLastOrder = 200
for uDiscoverScriptName in self.aDiscoverScriptList:
oScript = Globals.oScripts.LoadScript(uDiscoverScriptName)
dScriptJSONSettings = oScript.cScript.GetConfigJSONforParameters(
oSetting.aInterFaceIniSettings)
iMax = 0
for uKey in dScriptJSONSettings:
uTempKey = uDiscoverScriptName + "_" + uKey
dRet[uTempKey] = dScriptJSONSettings[uKey]
dRet[uTempKey]['key'] = uDiscoverScriptName.upper(
) + "_" + dScriptJSONSettings[uKey]['key']
dRet[uTempKey]['scriptsection'] = uDiscoverScriptName
dRet[uTempKey]['active'] = 'hidden'
iOrder = dRet[uTempKey]['order']
iMax = max(iMax, iOrder)
dRet[uTempKey]['order'] = iOrder + iLastOrder
iLastOrder += iMax
self.dSettingsCombined = dRet
return dRet
class UserPrefs(EventDispatcher):
_schedule_save = None
_prefs_dict = {'range_alerts': {}, 'gauge_settings':{}}
store = None
prefs_file_name = 'prefs.json'
prefs_file = None
config = None
data_dir = '.'
user_files_dir = '.'
def __init__(self, data_dir, user_files_dir, save_timeout=2, **kwargs):
self.data_dir = data_dir
self.user_files_dir = user_files_dir
self.prefs_file = path.join(self.data_dir, self.prefs_file_name)
self.load()
self._schedule_save = Clock.create_trigger(self.save, save_timeout)
def set_range_alert(self, key, range_alert):
self._prefs_dict["range_alerts"][key] = range_alert
self._schedule_save()
def get_range_alert(self, key, default=None):
return self._prefs_dict["range_alerts"].get(key, default)
def set_gauge_config(self, gauge_id, channel):
self._prefs_dict["gauge_settings"][gauge_id] = channel
self._schedule_save()
def get_gauge_config(self, gauge_id):
return self._prefs_dict["gauge_settings"].get(gauge_id, False)
def save(self, *largs):
with open(self.prefs_file, 'w+') as prefs_file:
data = self.to_json()
prefs_file.write(data)
def set_config_defaults(self):
self.config.adddefaultsection('preferences')
self.config.setdefault('preferences', 'distance_units', 'miles')
self.config.setdefault('preferences', 'temperature_units', 'Fahrenheit')
self.config.setdefault('preferences', 'show_laptimes', 1)
self.config.setdefault('preferences', 'startup_screen', 'Home Page')
default_user_files_dir = self.user_files_dir
self.config.setdefault('preferences', 'config_file_dir', default_user_files_dir )
self.config.setdefault('preferences', 'firmware_dir', default_user_files_dir )
self.config.setdefault('preferences', 'first_time_setup', True)
self.config.setdefault('preferences', 'send_telemetry', False)
self.config.setdefault('preferences', 'last_dash_screen', 'gaugeView')
def load(self):
print("the data dir " + self.data_dir)
self.config = ConfigParser()
self.config.read(os.path.join(self.data_dir, 'preferences.ini'))
self.set_config_defaults()
self._prefs_dict = {'range_alerts': {}, 'gauge_settings':{}}
try:
with open(self.prefs_file, 'r') as data:
content = data.read()
content_dict = json.loads(content)
if content_dict.has_key("range_alerts"):
for name, settings in content_dict["range_alerts"].iteritems():
self._prefs_dict["range_alerts"][name] = Range.from_dict(settings)
if content_dict.has_key("gauge_settings"):
for id, channel in content_dict["gauge_settings"].iteritems():
self._prefs_dict["gauge_settings"][id] = channel
except Exception:
pass
def get_pref(self, section, option):
return self.config.get(section, option)
def set_pref(self, section, option, value):
self.config.set(section, option, value)
self.config.write()
def to_json(self):
data = {'range_alerts': {}, 'gauge_settings':{}}
for name, range_alert in self._prefs_dict["range_alerts"].iteritems():
data["range_alerts"][name] = range_alert.to_dict()
for id, channel in self._prefs_dict["gauge_settings"].iteritems():
data["gauge_settings"][id] = channel
return json.dumps(data)
class MainApp(App):
def __init__(self, *args, **kwargs):
super(MainApp, self).__init__(*args, **kwargs)
self.logger = logging.getLogger('kivy.operator.app')
if not os.path.isdir("/sdcard/operator"):
os.makedirs("/sdcard/operator")
self.map = None
self.messaging = None
self.xmpp_client = None
self.user_location_markers = {}
self._last_location_update = 0
Window.bind(on_keyboard=self.on_back_btn)
self.android_setflag()
self.xmpp_config_ok = False
self.start = True
self.confirmation_popup = Popup()
self.lock_btn_presses = []
self.configuration = ConfigParser()
self.configuration.read(CONFIG_PATH)
self.check_config()
def check_config(self):
"""
Checks to see if the config has the required XMPP fields filled out accordingly.
Then, it evaluates the config file to make sure that all fields exist, at least corresponding to the
example config file.
"""
conf = self.configuration
if conf.has_section('xmpp'):
if all(
conf.has_option('xmpp', k) and conf.get('xmpp', k)
for k in MANDATORY_XMPP_OPTIONS):
self.xmpp_config_ok = True
def_conf = ConfigParser()
def_conf.read(DEFAULT_CONFIG_PATH)
for section in def_conf.sections():
if conf.has_section(section):
for option in def_conf.options(section):
if not conf.has_option(section, option) or conf.get(
section, option) is None:
conf.set(section, option,
def_conf.get(section, option))
else:
conf.add_section(section)
for option in def_conf.options(section):
conf.set(section, option, def_conf.get(section, option))
self.configuration = conf
self.configuration.write()
def build(self):
self.root = RootWidget()
if self.xmpp_config_ok:
self.xmpp_client = OperatorXMPPClient(
sz_utils.parse_server(self.configuration.get('xmpp', 'server'),
5222),
self.configuration.get('xmpp', 'username'),
self.configuration.get('xmpp', 'password'),
self.configuration.get('xmpp', 'room'),
self.configuration.getboolean('xmpp', 'filter'))
self.xmpp_client.bind(
on_user_location_update=self.on_user_location_update)
self.xmpp_client.bind(on_message_receive=self.on_message_receive)
self.xmpp_client.bind(on_muc_receive=self.on_muc_receive)
else:
self.logger.warning(
"XMMP config invalid, disabling XMPP operations")
self.map = self.root.ids.map_panel_widget.ids.map_widget
self.messaging = self.root.ids.message_menu
gps.configure(on_location=self.on_gps_location)
gps.start()
return self.root
def on_back_btn(self, window, key, *args):
""" To be called whenever user presses Back/Esc Key """
# If user presses Back/Esc Key
if key == 27:
return self.root.on_back_btn()
return False
def build_config(self, config):
# add default sections here
default_sections = ('miscellaneous', 'xmpp')
for section in default_sections:
if not config.has_section:
config.add_section(section)
# load the custom configuration ini file
custom_config = 'data/settings/config.ini'
if os.path.isfile(custom_config):
self.logger.info(
'loading custom config: {0}'.format(custom_config))
config.update_config(custom_config, overwrite=False)
def build_settings(self, settings):
settings.add_json_panel('XMPP', self.configuration,
'data/settings/xmpp.json')
settings.add_json_panel('Map', self.configuration,
'data/settings/map.json')
def on_message_receive(self, event, msg):
self.messaging.on_message_receive(msg)
def on_muc_receive(self, event, msg):
self.messaging.on_muc_receive(msg)
def on_gps_location(self, **kwargs):
# kwargs on Galaxy S5 contain:
# altitude, bearing, lat, lon, speed
if self.start:
if self.xmpp_client:
self.messaging.get_users()
self.start = False
if not ('lat' in kwargs and 'lon' in kwargs):
return
current_time = time.time()
if current_time - self._last_location_update < self.configuration.getint(
'miscellaneous', 'gps_update_freq'):
return
latitude = kwargs.pop('lat')
longitude = kwargs.pop('lon')
altitude = kwargs.pop('altitude', None)
bearing = kwargs.pop('bearing', None)
speed = kwargs.pop('speed', None)
self.map.update_location((latitude, longitude), altitude, bearing,
speed)
if self.xmpp_client:
self.xmpp_client.update_location((latitude, longitude), altitude,
bearing, speed)
self._last_location_update = current_time
def get_users(self):
return self.xmpp_client.get_users()
def send_message(self, msg, user):
self.xmpp_client.on_message_send(msg, user)
def send_muc(self, msg, group):
self.xmpp_client.on_muc_send(msg, group)
def on_pause(self):
return False
def on_resume(self):
pass
def on_stop(self):
self.map.save_marker_file()
if self.xmpp_client:
self.xmpp_client.shutdown()
def on_user_location_update(self, _, info):
if not self.map.is_ready:
self.logger.warning('map is not ready for user marker')
return
user = info['user']
if user in self.user_location_markers:
self.user_location_markers[user].remove()
if self.xmpp_client:
user_mood = self.xmpp_client.user_moods.get(user, 'calm')
icon_color = {
'angry': 'red',
'calm': 'yellow',
'happy': 'green'
}.get(user_mood, 'yellow')
marker = self.map.create_marker(draggable=False,
title=info['user'],
position=info['location'],
marker_color=icon_color)
self.user_location_markers[user] = marker
def toast_status(self):
return self.configuration.getboolean('xmpp', 'toast_all')
def xmpp_log(self, log_type, log):
if log_type == 'info':
self.xmpp_client.logger.info(log)
def prompt_lock_screen(self):
"""
Popup confirming with the user whether they want to lock the screen.
"""
confirmation_box = BoxLayout(orientation='vertical')
confirmation_box.add_widget(
Label(text='Do you want to lock the screen?'))
box_int = BoxLayout(orientation='horizontal', spacing=50)
affirm_button = Button(text='Yes')
affirm_button.bind(on_release=lambda x: self.lock_screen())
dismiss_button = Button(text='Cancel')
dismiss_button.bind(
on_release=lambda x: self.confirmation_popup.dismiss())
box_int.add_widget(affirm_button)
box_int.add_widget(dismiss_button)
confirmation_box.add_widget(box_int)
self.confirmation_popup = Popup(title='Confirmation',
content=confirmation_box,
size_hint=(.7, None),
size=(500, 500),
auto_dismiss=False)
self.confirmation_popup.open()
@run_on_ui_thread
def lock_screen(self):
"""
Lock the screen by going to a black layout and not allowing input. Will disable after 10 taps.
"""
self.confirmation_popup.dismiss()
flag = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
PythonActivity.mActivity.getWindow().getDecorView(
).setSystemUiVisibility(flag)
mb = True
for child in self.root.walk():
if hasattr(child, 'name'):
if child.name == 'root' and mb:
self.removed = child
child.parent.remove_widget(child)
mb = False
self.bl = BoxLayout(orientation='vertical')
self.bl.add_widget(
Button(size_hint=(1, 1),
background_color=[0, 0, 0, 1],
on_release=lambda x: self.lock_button()))
self.root.add_widget(self.bl)
def lock_button(self):
"""
Registers clicks on the locked screen. Only counts clicks within 10 second gap.
"""
current_time = time.time()
self.lock_btn_presses.append(current_time)
while current_time - self.lock_btn_presses[
0] > self.configuration.getint('miscellaneous',
'lockout_timeout'):
del self.lock_btn_presses[0]
if len(self.lock_btn_presses) == self.configuration.getint(
'miscellaneous', 'lockout_clicks'):
self.root.remove_widget(self.bl)
self.root.add_widget(self.removed)
self.lock_btn_presses = []
@run_on_ui_thread
def android_setflag(self):
PythonActivity.mActivity.getWindow().addFlags(
Params.FLAG_KEEP_SCREEN_ON)
def update_mood(self, mood):
if self.xmpp_client:
self.xmpp_client.update_mood(mood)
class Barsic(MDApp):
title = 'barsic'
icon = 'icon.png'
nav_drawer = ObjectProperty()
action_bar = ObjectProperty()
lang = StringProperty('ru')
date_from = ObjectProperty()
date_to = ObjectProperty()
def __init__(self, **kvargs):
super(Barsic, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.exit_interval = False
self.dict_language = literal_eval(
open(
os.path.join(self.directory, 'data', 'locales', 'locales.txt')).read()
)
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'data', 'locales')
)
self.date_from = datetime.now().date()
self.date_to = self.date_from
def get_application_config(self):
return super(Barsic, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
config.adddefaultsection('General')
config.setdefault('General', 'language', 'en')
def set_value_from_config(self):
self.config.read(os.path.join(self.directory, 'barsic.ini'))
self.lang = self.config.get('General', 'language')
def build(self):
self.set_value_from_config()
self.load_all_kv_files(os.path.join(self.directory, 'uix', 'kv'))
self.screen = StartScreen()
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
self.action_bar = self.screen.ids.action_bar
return self.screen
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
if not PY2:
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
else:
Builder.load_file(kv_file)
def events_program(self, instance, keyboard, keycode, text, modifiers):
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.toggle_nav_drawer()
self.back_screen(event=keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self, event=None):
if event in (1001, 27):
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
except:
self.manager.current = 'base'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.about.ids.label.text = self.translation._(
u'[size=20][b]barsic[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT\n\n'
u'[size=20][b]Developer[/b][/size]\n\n'
u'[ref=SITE_PROJECT]'
u'[color={link_color}]Ivan Bazhenov[/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=https://github.com/sendhello/barsic-android-client]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_zones(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'zones'
self.action_bar.title = 'zones'
self.list_previous_screens.append('zones')
self.screen.ids.action_bar.left_action_items = [['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
def show_short_report(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'short_report'
self.action_bar.title = 'short_report'
self.list_previous_screens.append('short_report')
self.screen.ids.action_bar.left_action_items = [['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
def show_total_report(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'total_report'
self.action_bar.title = 'total_report'
self.action_bar.right_action_items = [['timetable', lambda x: self.screen.ids.total_report.bottom_sheet()]]
self.list_previous_screens.append('total_report')
self.screen.ids.action_bar.left_action_items = [['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
def show_result(self, *args):
self.manager.current = 'result'
self.action_bar.title = 'result'
self.screen.ids.action_bar.left_action_items = [['chevron-left', lambda x: self.back_screen(27)]]
def show_reports(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'report'
self.action_bar.title = 'report'
self.list_previous_screens.append('report')
self.screen.ids.action_bar.left_action_items = [['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
# Загрузка параметров из INI-файла
self.load_checkbox()
def show_parameters(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'parameters'
self.action_bar.title = 'parameters'
self.screen.ids.action_bar.left_action_items = [['chevron-left', lambda x: self.back_screen(27)]]
# # Загрузка параметров из INI-файла
# self.load_checkbox()
def show_license(self, *args):
self.nav_drawer.toggle_nav_drawer()
if not PY2:
self.screen.ids.license.ids.text_license.text = self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
else:
self.screen.ids.license.ids.text_license.text = self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE')).read()
self.manager.current = 'license'
self.action_bar.title = 'license'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
self.screen.ids.action_bar.title = self.translation._('MIT LICENSE')
def select_locale(self, *args):
def select_locale(name_locale):
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(
Lists(
dict_items=dict_info_locales,
events_callback=select_locale, flag='one_select_check'
),
size=(.85, .55)
)
self.window_language.open()
def load_checkbox(self):
"""
Установка чекбоксов в соответствии с настройками INI-файла
"""
# self.root.ids.report.ids.split_by_days.active = self.split_by_days
# self.root.ids.report.ids.finreport_xls.active = self.finreport_xls
# self.root.ids.report.ids.check_client_count_total_xls.active = self.check_client_count_total_xls
# self.root.ids.report.ids.check_cashreport_xls.active = self.check_cashreport_xls
# self.root.ids.report.ids.check_itogreport_xls.active = self.check_itogreport_xls
# self.root.ids.report.ids.agentreport_xls.active = self.agentreport_xls
# self.root.ids.report.ids.use_yadisk.active = self.use_yadisk
# self.root.ids.report.ids.finreport_google.active = self.finreport_google
# self.root.ids.report.ids.finreport_telegram.active = self.finreport_telegram
pass
def click_date_switch(self):
if self.root.ids.report.ids.date_switch.active:
self.date_switch = True
self.root.ids.report.ids.label_date.text = 'Дата:'
self.set_date_to(self.date_from.date() + timedelta(1))
self.root.ids.report.ids.date_to.theme_text_color = 'Secondary'
self.root.ids.report.ids.split_by_days.active = False
self.root.ids.report.ids.split_by_days.disabled = True
self.root.ids.report.ids.split_by_days_text.theme_text_color = 'Secondary'
self.change_checkbox('split_by_days', False)
self.root.ids.report.ids.finreport_google_text.disabled = False
self.root.ids.report.ids.finreport_google.disabled = False
else:
self.date_switch = False
self.root.ids.report.ids.label_date.text = 'Период:'
self.root.ids.report.ids.date_to.theme_text_color = 'Primary'
self.root.ids.report.ids.split_by_days.disabled = False
self.root.ids.report.ids.split_by_days.active = True
self.root.ids.report.ids.split_by_days_text.theme_text_color = 'Primary'
self.change_checkbox('split_by_days', True)
def change_checkbox(self, name, checkbox):
"""
Изменяет состояние элемента конфигурации и записывает в INI-файл
:param name: Имя чекбокса
:param checkbox: Состояние active чекбокса
"""
self.config.set('General', name, str(checkbox))
setattr(self, name, checkbox)
self.config.write()
if name == 'split_by_days' and not checkbox and not self.root.ids.report.ids.date_switch.active:
self.root.ids.report.ids.finreport_google.active = False
self.change_checkbox('finreport_google', False)
self.root.ids.report.ids.finreport_google.disabled = True
self.root.ids.report.ids.finreport_google_text.disabled = True
elif name == 'split_by_days' and checkbox:
self.root.ids.report.ids.finreport_google_text.disabled = False
self.root.ids.report.ids.finreport_google.disabled = False
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
def show_example_alert_dialog(self):
if not self.alert_dialog:
self.alert_dialog = MDDialog(
title="Reset settings?",
text="This will reset your device to its default factory settings.",
buttons=[
MDFlatButton(
text="CANCEL",
text_color=self.app.theme_cls.primary_color,
),
MDFlatButton(
text="ACCEPT",
text_color=self.app.theme_cls.primary_color,
),
],
)
self.alert_dialog.open()
class VKGroups(App, AuthorizationOnVK, GetAndSaveLoginPassword):
'''Функционал программы.'''
title = 'VKGroups'
icon = 'icon.png'
use_kivy_settings = False
nav_drawer = ObjectProperty()
theme_cls = ThemeManager()
theme_cls.primary_palette = 'BlueGrey'
lang = StringProperty('ru')
def __init__(self, **kvargs):
super(VKGroups, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
self.POSSIBLE_FILES = \
['.png', '.jpg', '.jpeg', '.gif', '.zip', '.txt']
self.DEVISE_ONLINE = {
'mobile': 'desktop-mac',
'computer': 'laptop',
0: 'power'
}
self.PATTERN_WHOM_COMMENT = pattern_whom_comment
self.PATTERN_REPLACE_LINK = pattern_replace_link
self.window = Window
self.config = ConfigParser()
# Окно прогресса.
self.load_dialog = ModalView(size_hint=(None, None),
pos_hint={
'x': 5.0 / Window.width,
'y': 5.0 / Window.height
},
background_color=[0, 0, 0, .2],
size=(dp(120), dp(50)),
background=os.path.join(
'data', 'images', 'decorator.png'),
auto_dismiss=False)
# Экземпляр для вывода списка плагинов пользователя.
self.instance_list_user_plugins = ShowPlugins(self)
# Файловый менеджер.
self.window_file_manager = ModalView(
size_hint=(1, 1),
auto_dismiss=False,
on_open=lambda x: self.load_dialog.dismiss())
self.window_file_manager_open = False
self.file_manager = FileManager(
exit_manager=self.exit_manager,
floating_button_color=self.theme_cls.primary_color)
self.window_file_manager.add_widget(self.file_manager)
self.current_screen_tab = None
self.current_tab_manager = None
self.name_press_tab = 'Home_page'
self.file_manager_not_opening = True
self.password_form = None
self.box_posts = None
self.attach_file = []
self.attach_image = []
self.box_for_attach_file = None
self.box_for_attach_image = None
self.group_info = None
self.result_sending_post = None
self.exit_interval = False
self.flag_attach = ''
self.window_user_groups = None
self.window_language = None
self.path_to_avatar = os.path.join(self.directory, 'data', 'images',
'avatar.png')
self.dict_language = ast.literal_eval(
open(os.path.join(self.directory, 'data', 'locales',
'locales')).read())
def get_application_config(self):
return super(VKGroups, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
'''Создаёт файл настроек приложения vkgroups.ini.'''
config.adddefaultsection('General')
config.setdefault('General', 'language', 'ru')
config.setdefault('General', 'theme', 'default')
config.setdefault('General', 'authorization', 0)
config.setdefault('General', 'issues_in_group', 0)
config.setdefault('General', 'count_issues', 20)
config.setdefault('General', 'user_name', 'User')
config.setdefault('General', 'last_group', '99411738')
config.setdefault('General', 'regdata',
"{'login': None, 'password': None}")
config.setdefault('General', 'last_screen', 'load screen')
config.setdefault('General', 'last_path', '/')
config.setdefault('General', 'show_dialog_on_download', 0)
def set_value_from_config(self):
'''Устанавливает значения переменных из файла настроек
vkgroups.ini.'''
self.config.read(os.path.join(self.directory, 'vkgroups.ini'))
self.theme = self.config.get('General', 'theme')
self.language = self.config.get('General', 'language')
self.authorization = self.config.getint('General', 'authorization')
self.last_path = self.config.get('General', 'last_path')
self.last_screen = self.config.get('General', 'last_screen')
self.regdata = \
ast.literal_eval(self.config.get('General', 'regdata'))
self.login = self.regdata['login']
self.password = self.regdata['password']
try:
self.user_name = ast.literal_eval(
self.config.get('General', 'user_name')).decode('utf-8')
except ValueError:
self.user_name = self.config.get('General', 'user_name')
self.group_id = self.config.get('General', 'last_group')
self.count_issues = self.config.getint('General', 'count_issues')
self.issues_in_group = \
self.config.getint('General', 'issues_in_group')
self.show_dialog_on_download = \
self.config.getint('General', 'show_dialog_on_download')
def build(self):
self.set_value_from_config()
self.translation = Translation(self.language, 'kivyissues',
'%s/data/locales' % self.directory)
self.RELATION = {
1: self.translation._('не женат/не замужем'),
2: self.translation._('есть друг/подруга'),
3: self.translation._('помолвлен'),
4: self.translation._('женат/замужем'),
5: self.translation._('всё сложно'),
6: self.translation._('в активном поиске'),
7: self.translation._('влюблён/влюблена'),
8: self.translation._('в гражданском браке'),
0: self.translation._('не указано')
}
self.message_about_files_mismatch = {
'FILE': self.translation._('This file unsupported!'),
'FOTO': self.translation._('This is not image!')
}
self.load_dialog.add_widget(
MDLabel(text=self.translation._(' Загрузка...')))
self.load_all_kv_files(self.directory + '/libs/uix/kv')
self.screen = StartScreen() # главный экран программы
self.navigation_button = self.screen.ids.navigation_button
self.previous = self.navigation_button.ids.previous
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
self.current_screen_tab = self.navigation_button.ids.home_page
if not self.login or not self.password:
self.show_screen_registration()
else: # авторизация на сервере
self._authorization_on_vk(self.login, self.password, self.group_id)
Clock.schedule_interval(self.wait_info_for_home_page_group, 1)
return self.screen
def wait_info_for_home_page_group(self, interval):
'''Ожидает получения данных от сервера после чего устанавливает
значения переменных для экрана Previous.'''
if self.group_info:
self.previous.ids.group_title.source = \
self.group_info['photo_200']
self.previous.ids.group_name.text = \
'[size=17][b]%s[/b][/size]\n[size=14]%s[/size]' % (
self.group_info['name'], self.group_info['status']
)
self.previous.ids.group_link.text = \
'[ref={link}]{link}[/ref]'.format(
link='https://vk.com/%s' % self.group_info['screen_name']
)
self.previous.ids.group_people.text = \
'%s %s' % (
self.translation._('Участники'),
self.group_info['members_count']
)
self.previous.ids.description.text = \
self.group_info['description']
self.nav_drawer.ids.user_name.text = \
'[b]%s[/b]\n[size=12]online[/size]\n' % get_user_name()[0]
Clock.unschedule(self.wait_info_for_home_page_group)
Clock.schedule_once(
lambda kwargs: self.show_form_for_messages(whom_name=''), 1)
self.check_groups_user(name_group=self.group_info['name'],
info_group=self.group_info['status'],
logo_group=self.group_info['photo_200'])
if os.path.exists('%s/data/state.txt' % self.directory):
os.remove('%s/data/state.txt' % self.directory)
def check_state_fields(self, id_instance, text_field):
'''Сохраняет содержимое формы регистрации.'''
if text_field == '':
return
if os.path.exists('%s/data/state.txt' % self.directory):
data_state = ast.literal_eval(
open('%s/data/state.txt' % self.directory).read())
else:
data_state = {}
data_state[id_instance] = text_field
# TODO: добавить шифрование данных.
with open('%s/data/state.txt' % self.directory, 'w') as state_form:
state_form.write(str(data_state))
def check_groups_user(self, **kwargs):
'''Проверяет и добавляет в список новые группы пользователя, которые он посещал.
Данные имеют вид:
{'Имя группы': ['Описание группы', 'ссылка на логотип группы', 'id группы,]}.'''
file_groups_path = '%s/data/groups_user.ini' % self.directory
if not os.path.exists(file_groups_path):
with open(file_groups_path, 'w') as file_groups_user:
file_groups_user.write('{}')
groups_user = ast.literal_eval(
open('%s/data/groups_user.ini' % self.directory,
encoding='utf-8').read())
if not kwargs['name_group'] in groups_user:
groups_user[kwargs['name_group']] = \
[kwargs['info_group'], kwargs['logo_group'], self.group_id]
with open(file_groups_path, 'w',
encoding='utf-8') as file_groups_user:
file_groups_user.write(str(groups_user))
def show_login_and_password(self, selection):
'''
Устанавливает свойства текстовых полей для ввода логина и пароля.
:type selection: <class 'int'>
'''
if selection:
self.password_form.ids.login.password = False
self.password_form.ids.password.password = False
else:
self.password_form.ids.login.password = True
self.password_form.ids.password.password = True
def show_groups_user(self, *args):
'''Выводит окно со списком групп пользователя.'''
def callback_on_button_click(**kwargs):
def on_press(text_button):
# TODO: добавить группу в словарь groups.ini.
field.dismiss()
toast(str(text_button))
field = input_dialog(
title=kwargs['title'],
hint_text='',
text_button_ok=self.translation._('Добавить'),
text_button_cancel=self.translation._('Отмена'),
events_callback=on_press)
def callback_on_item_click(name_item, mode):
description_group, logo_group, id_group = groups_user[name_item]
dialog(title=name_item,
text='%s\nID - %s' % (description_group, str(id_group)))
if not self.window_user_groups:
dict_groups_user = {}
groups_user = ast.literal_eval(
open('%s/data/groups_user.ini' % self.directory,
encoding='utf-8').read())
for name_group in groups_user.keys():
description_group, logo_group, id_group = groups_user[
name_group]
dict_groups_user[name_group] = [description_group, logo_group]
list_user_groups = ListUserGroups()
_list = list_user_groups.ids.groups_list
_list.events_callback = callback_on_item_click
list_user_groups.ids.add_group.on_press = \
lambda **kwargs: callback_on_button_click(
title=self.translation._('Введите ID группы:')
)
_list.two_list_custom_icon(dict_groups_user, IconItemAsync)
self.window_user_groups = card(list_user_groups, size=(.85, .55))
self.window_user_groups.open()
def show_screen_registration(self, fail_registration=False):
'''Окно с формой регистрации.'''
if not self.password_form:
self.password_form = \
PasswordForm(callback=self.check_fields_login_password)
self.password_form.ids.group_id.text = self.group_id
self.screen.ids.load_screen.add_widget(self.password_form)
# Если произошла ошибка регистрации, деактивируем спиннер и чистим
# лейблы статуса авторизации.
if fail_registration:
self.screen.ids.load_screen.ids.spinner.active = False
self.screen.ids.load_screen.ids.status.text = ''
def show_screen_connection_failed(self, text_error):
'''Выводит подпись о не активном соединении и кнопку для повторного
подключения.'''
self.screen.ids.load_screen.ids.spinner.active = False
self.screen.ids.load_screen.ids.status.text = ''
box = BoxLayout(orientation='vertical',
spacing=dp(10),
size_hint_y=None,
height=dp(100),
pos_hint={'center_y': .5})
texts_errors = {
'OAuth2 authorization error':
self.translation._('Повторите попытку позже…'),
'Failed to establish a new connection':
self.translation._('Соединение Интернет отсутствует')
}
_text_error = self.translation._('Неизвестная ошибка…')
for name_error in texts_errors.keys():
if name_error in text_error:
_text_error = texts_errors[name_error]
box.add_widget(
MDLabel(text=_text_error, halign='center', font_style='Subhead'))
box.add_widget(
MDFlatButton(text=self.translation._('Повторить попытку'),
theme_text_color='Custom',
pos_hint={'center_x': .5},
text_color=self.theme_cls.primary_color,
on_release=lambda x: self._authorization_on_vk(
self.login,
self.password,
self.group_id,
from_fail_screen=True)))
self.screen.ids.load_screen.add_widget(box)
@thread
def send_post(self, text):
self.result_sending_post, text_error = \
create_issue(text, self.attach_file, self.attach_image)
@thread
def send_messages(self, text, user_id):
self.result_sending_post, text_error = \
send_message(
user_id=user_id,
files=self.attach_file,
images=self.attach_image,
text=text
)
@thread
def send_comment(self, text, post_id, comment_id):
self.result_sending_post, text_error = \
create_comment(text, self.attach_file, self.attach_image, post_id, comment_id)
def show_result_sending_posts(self, interval):
def unschedule():
Clock.unschedule(self.show_result_sending_posts)
self.result_sending_post = None
toast(message)
self.clear_box_for_attach(remove_all=True)
message = self.translation._('Sent!')
if self.result_sending_post:
# Обновляем списки постов/комментариев.
if self.name_press_tab != 'Home_page':
self.box_posts.update_posts()
unschedule()
elif self.result_sending_post is False:
message = self.translation._('Error while sending!')
unschedule()
def callback_for_input_text(self, **kwargs):
'''Вызывается при событиях из формы ввода текста.'''
self.flag_attach = kwargs.get('flag')
data = kwargs.get('kwargs')
comment_id = int(data.get('comment_id', 0))
post_id = int(data.get('post_id', 0))
user_id = int(
data.get('kwargs').get('user_id')) if 'kwargs' in data else 0
whom_name = data.get('whom_name', '')
text = whom_name + ', ' + self.form_for_messages.ids.text_form.text if whom_name != '' else self.form_for_messages.ids.text_form.text
if self.flag_attach in ('FILE', 'FOTO'):
self.show_manager(self.last_path, self.tap_on_file_in_filemanager)
elif self.flag_attach == 'SEND':
if self.manager.current == 'navigation button' and self.name_press_tab != 'Home_page' or self.manager.current == 'user info':
self.form_for_messages.hide()
if text.isspace() or text != '':
if self.manager.current == 'navigation button' and self.name_press_tab == 'Wall_posts':
self.send_comment(text, post_id, comment_id)
elif self.manager.current == 'user info':
self.send_messages(text, user_id)
else:
self.send_post(text)
self.form_for_messages.clear()
Clock.schedule_interval(self.show_result_sending_posts, 0)
def clear_box_for_attach(self, remove_all=False):
self.attach_file = []
self.attach_image = []
if remove_all:
if self.box_for_attach_image:
self.form_for_messages.remove_widget(self.box_for_attach_image)
if self.box_for_attach_file:
self.form_for_messages.remove_widget(self.box_for_attach_file)
self.box_for_attach_image = None
self.box_for_attach_file = None
def remove_attach(self, select_instance_attach):
'''Удаляет превью файлов и изображений из формы для отправки сообщений.'''
def _remove_attach(interval):
parent_widget.remove_widget(instance_attach)
if self.box_for_attach_file and select_instance_attach in self.box_for_attach_file.children:
parent_widget = self.box_for_attach_file
else:
parent_widget = self.box_for_attach_image
for instance_attach in parent_widget.children:
if instance_attach == select_instance_attach:
Clock.schedule_once(_remove_attach, .25)
break
def add_preview_attached_image(self, path_to_attach):
'''Добавляет превью файлов в форму для отправки сообщений.'''
if os.path.splitext(path_to_attach)[1] not in self.POSSIBLE_FILES[-2:]:
if not self.box_for_attach_image:
self.box_for_attach_image = BoxAttach(spacing=dp(5))
self.form_for_messages.add_widget(self.box_for_attach_image)
self.box_for_attach_image.add_widget(
Icon(source=path_to_attach,
size_hint=(None, None),
size=(dp(60), dp(120)),
on_release=self.remove_attach))
def add_preview_attached_file(self, path_to_attach):
if not self.box_for_attach_file:
self.box_for_attach_file = BoxAttachFile(spacing=dp(5))
self.form_for_messages.add_widget(self.box_for_attach_file)
attach = SingleIconItem(icon='file',
text=os.path.split(path_to_attach)[1],
events_callback=self.remove_attach)
attach.ids._lbl_primary.font_style = 'Caption'
self.box_for_attach_file.add_widget(attach)
def write_last_path_manager(self, path_to_file_folder, path_to_file):
self.config.set('General', 'last_path', path_to_file_folder)
self.config.write()
self.last_path = path_to_file_folder
def tap_on_file_in_filemanager(self, path_to_file):
self.window_file_manager.dismiss()
self.window_file_manager_open = False
path_to_file_folder, name_file = os.path.split(path_to_file)
self.write_last_path_manager(path_to_file_folder, path_to_file)
if os.path.splitext(name_file)[1] not in self.POSSIBLE_FILES:
toast(self.message_about_files_mismatch[self.flag_attach])
else:
if self.flag_attach == 'FILE':
self.attach_file.append(path_to_file)
self.add_preview_attached_file(path_to_file)
else:
self.attach_image.append(path_to_file)
self.add_preview_attached_image(path_to_file)
def set_avatar(self, path_to_avatar):
self.nav_drawer.ids.avatar.source = path_to_avatar
self.nav_drawer.ids.avatar.reload()
def choice_avatar_user(self):
'''Выводит файловый менеджер для выбора аватара
и устанавливает его в качестве аватара пользователя.'''
def on_select(path_to_avatar):
self.window_file_manager.dismiss()
if os.path.splitext(path_to_avatar)[1] \
not in self.POSSIBLE_FILES[:3]:
toast(self.translation._('This is not image!'))
else:
new_path_to_avatar = \
self.directory + '/data/images/avatar.png'
create_previous_portrait(path_to_avatar, new_path_to_avatar)
self.set_avatar(new_path_to_avatar)
toast(self.translation._('Аватар изменён'))
self.nav_drawer.state = 'open'
self.show_manager(self.last_path, on_select)
def show_plugins(self, *args):
self.instance_list_user_plugins.show_plugins()
def show_manager(self, directory, callback=None):
''''Выводит на экран файловый менеджер.'''
if self.file_manager_not_opening:
self.load_dialog.open()
self.file_manager_not_opening = False
self.window_file_manager_open = True
Clock.schedule_once(self.window_file_manager.open, .2)
if callback:
self.file_manager.select_path = callback
self.file_manager.show(directory)
def show_posts(self, instance_tab=None):
self.current_screen_tab.clear_widgets()
if not self.box_posts:
self.box_posts = BoxPosts(_app=self)
self.box_posts.clear()
self.box_posts.show_posts(increment=False)
def events_program(self, instance, keyboard, keycode, text, modifiers):
'''Вызывается при нажатии кнопки Меню или Back Key
на мобильном устройстве.'''
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.toggle_nav_drawer()
self.back_screen(keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self, event=None):
'''Менеджер экранов. Вызывается при нажатии Back Key
и шеврона "Назад" в ToolBar.'''
current_screen = self.manager.current
if not self.window_file_manager_open:
self.clear_box_for_attach()
# Нажата BackKey.
if event in (1001, 27):
# Если информация с сервера о группе ещё не получена -
# идёт авторизация либо данные в процессе загрузки.
if not self.group_info:
return
if self.name_press_tab == 'Wall_posts' and self.form_for_messages.visible and \
not self.window_file_manager_open:
self.form_for_messages.hide()
return
if self.window_file_manager_open:
self.file_manager.back()
return
if current_screen == 'navigation button':
if hasattr(self, 'previous_image'):
if self.previous_image.previous_open:
self.previous_image.dismiss()
return
if self.box_posts and self.box_posts.show_comments:
self.box_posts.show_comments = False
self.show_posts()
return
self.dialog_exit()
return
if current_screen == 'show license':
self.manager.current = self.manager.screens[-1].name
elif current_screen == 'user info':
self.manager.current = 'navigation button'
else:
if not self.login or not self.password:
self.dialog_exit()
return
self.manager.current = self.manager.previous()
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Нажмите еще раз для выхода'))
def show_form_for_messages(self, **kwargs):
'''Выводит форму для ввода комментариев.'''
self.form_for_messages = FormForMessages(
callback=self.callback_for_input_text, kwargs=kwargs)
self.form_for_messages.show(
parent_instance=self.current_screen_tab if self.manager.current == 'navigation button' \
else self.screen.ids.user_info.ids.float_layout
)
if kwargs.get('whom_name') == '':
self.form_for_messages.visible = False
def form_for_messages_hide(self):
if self.form_for_messages.visible and not self.form_for_messages.ids.text_form.focus:
self.form_for_messages.hide()
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.load_screen.ids.status.text = \
self.translation._(
'[size=20][b]VKGroups[/b][/size]\n\n'
'[b]Версия:[/b] {version}\n'
'[b]Лицензия:[/b] MIT\n\n'
'[size=20][b]Разработчики[/b][/size]\n\n'
'[b]Backend:[/b] [ref=https://m.vk.com/fogapod]'
'[color={link_color}]Евгений Ершов[/color][/ref]\n'
'[b]Frontend:[/b] [ref=https://m.vk.com/heattheatr]'
'[color={link_color}]Иванов Юрий[/color][/ref]\n\n'
'[b]Исходный код:[/b] '
'[ref=https://github.com/HeaTTheatR/VKGroups]'
'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.screen.ids.load_screen.ids.spinner.active = False
self.manager.current = 'load screen'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen()]]
def show_license(self, *args):
self.screen.ids.show_license.ids.text_license.text = \
self.translation._('%s') % open(
'%s/license/license_en.txt' %
self.directory, encoding='utf-8').read()
self.nav_drawer._toggle()
self.manager.current = 'show license'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen()]]
self.screen.ids.action_bar.title = \
self.translation._('MIT LICENSE')
def exit_manager(self, *args):
'''Закрывает окно файлового менеджера.'''
self.window_file_manager.dismiss()
self.window_file_manager_open = False
def select_locale(self, *args):
'''Выводит окно со списком имеющихся языковых локализаций для
установки языка приложения.'''
def select_locale(name_locale):
'''Устанавливает выбранную локализацию.'''
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(Lists(dict_items=dict_info_locales,
events_callback=select_locale,
flag='one_select_check'),
size=(.85, .55))
self.window_language.open()
def set_chevron_back_screen(self):
'''Устанавливает шеврон возврата к предыдущему экрану в ToolBar.'''
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(self.manager.current)]]
def download_progress_hide(self, instance_progress, value):
'''Скрывает виджет прогресса загрузки файлов.'''
instance_progress.dismiss()
self.screen.ids.action_bar.right_action_items = \
[['download', lambda x: self.download_progress_show(instance_progress)]]
def download_progress_show(self, instance_progress):
self.screen.ids.action_bar.right_action_items = []
instance_progress.open()
instance_progress.animation_progress_from_fade()
def download_complete(self, result):
self.screen.ids.action_bar.right_action_items = []
if result == 'Done':
toast(self.translation._('Загружено'))
else:
toast(self.translation._('Ошибка загрузки'))
def tap_on_icon_user(self, user_id):
'''Вызывается при тапе по иконке пользователя в списках постов/комментариев.
Получает, устанавливает и выводит на экран информацию о выбранном пользователе.
'''
def unschedule(error=False):
if error:
toast(self.translation._('Данные не получены'))
Clock.unschedule(wait_result)
self.load_dialog.dismiss()
def set_value_for_screen(instance_screen_user_info):
'''Устанавливает значения подписей в экране информации о пользователе.'''
instance_screen_user_info.ids.avatar.source = result['photo_200']
instance_screen_user_info.ids.user_name.text = instance_screen_user_info.ids.user_name.text % (
result['first_name'] + ' ' + result['last_name'],
self.translation._('Последний раз был в сети в ') +
time.strftime("%H:%M",
time.localtime(result['last_seen']['time'])))
instance_screen_user_info.ids.label_user_status.text = \
instance_screen_user_info.ids.label_user_status.text % result['status']
instance_screen_user_info.ids.message_button.bind(
on_release=lambda kwargs: self.show_form_for_messages(
kwargs={'user_id': user_id}))
data = {
'bdate': {
'result': result['bdate'] if 'bdate' in result else None,
'bad_result': self.translation._('скрыта'),
'label_instance':
instance_screen_user_info.ids.label_bdate,
'label_text': self.translation._('Дата рождения')
},
'city': {
'result':
result['city']['title'] if 'city' in result else None,
'bad_result': self.translation._('не указан'),
'label_instance': instance_screen_user_info.ids.label_city,
'label_text': self.translation._('Город')
},
'relation': {
'result':
self.RELATION[result['relation']]
if 'relation' in result else None,
'bad_result':
self.translation._('не указано'),
'label_instance':
instance_screen_user_info.ids.label_marital_status,
'label_text':
self.translation._('Семейное положение')
}
}
for key in data:
text_for_label = data[key]['result'] if data[key][
'result'] else data[key]['bad_result']
data[key]['label_instance'].text = data[key][
'label_instance'].text % (data[key]['label_text'],
text_for_label)
unschedule()
def wait_result(interval):
'''Ожидает информации от сервера.'''
if result:
self.manager.current = 'user info'
set_value_for_screen(self.screen.ids.user_info)
if user_id == int(self.group_id):
return
result = None
self.load_dialog.open()
Clock.schedule_once(wait_result, 0)
result, text_error = get_user_info(user_id=user_id)
if text_error:
unschedule(error=True)
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
with open(os.path.join(directory_kv_files, kv_file),
encoding='utf-8') as kv:
Builder.load_string(kv.read())
def on_tab_press(self, instance_tab):
'''Вызывается при выборе одного из пунктов BottomNavigation.'''
self.clear_box_for_attach()
self.name_press_tab = instance_tab.name
self.current_screen_tab = instance_tab
self.current_tab_manager = instance_tab.parent_widget.ids.tab_manager
if self.current_tab_manager.current == self.name_press_tab:
return
# Вкладка 'Записи группы'.
if self.name_press_tab == 'Wall_posts':
self.show_posts(instance_tab)
self.form_for_messages.hide()
elif self.name_press_tab == 'Home_page':
self.box_posts = None
self.show_form_for_messages(whom_name='')
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
def on_pause(self):
'''Ставит приложение на 'паузу' при сворачивании его в трей.'''
self.config.set('General', 'last_screen', self.manager.current)
self.config.write()
return True
def on_start(self):
'''Вызывается при открытии стартового экрана приложения.'''
# Восстанавливаем форму ввода логина и пароля.
if self.last_screen == 'load screen' and \
not self.login and not self.password:
if os.path.exists('%s/data/state.txt' % self.directory):
data_state = \
ast.literal_eval(open('%s/data/state.txt' % self.directory).read())
self.password_form.ids.login.text = \
data_state['login'] if 'login' in data_state else ''
self.password_form.ids.password.text = \
data_state['password'] if 'password' in data_state else ''
self.password_form.ids.group_id.text = data_state['group']
class StoryBook(Widget):
# This story's title
title = StringProperty(None)
# The story's library
library_parent = StringProperty(None)
# The story's library number
story_number = NumericProperty(None)
# The current set page by name
current_page = StringProperty("title")
# The current set page by number
current_page_no = NumericProperty(0)
# List of all pages by name
pages = ListProperty()
# The parsed story config
story_config = ObjectProperty(None)
# The defaults file
story_config_file = StringProperty(None)
# Where is the title media?
title_media_location = StringProperty(None)
def __init__(self, **kwargs):
"""
Initialize starting values. Set kwargs values.
Set current page to title and page number to 0.
:param kwargs:
title: The title of this story
library: The name of this story's library
story_number: This story's library number
"""
super(StoryBook, self).__init__(**kwargs)
self.title = kwargs['title']
self.library_parent = kwargs['library']
self.story_number = kwargs['number']
self.current_page = "title"
self.current_page_no = 0
self.pages = []
self.story_config_file = ""
def load_story_config(self, library_dir):
self.story_config = ConfigParser()
story_file_loc = library_dir.joinpath(self.title + '.ini')
if not story_file_loc.is_file():
self.story_config.setdefaults('metadata',
get_metadata_defaults(self.title, self.library_parent))
self.story_config.setdefaults('title',
get_page_defaults(self.title))
self.story_config_file = str(story_file_loc)
# Set config from story's config file.
self.story_config.read(str(self.story_config_file))
if self.story_config.get('metadata', 'story') != self.title:
self.story_config.set('metadata', 'story', self.title)
if self.story_config.get('metadata', 'library') != self.library_parent:
self.story_config.set('metadata', 'library', self.library_parent)
# Find the media location for this story's title page
self.title_media_location = self.story_config.get('title', 'media_location')
# Find all the pages
self.pages = ['title'] + [x.strip() for x in self.story_config.get('metadata', 'pages').split(',')]
self.story_config.write()
def start_page(self):
"""
Updates the current page to be the first page
:return:
"""
self.current_page_no = 0
self.current_page = self.pages[0]
def next_page(self):
"""
Updates the current page to be the next page
"""
self.current_page_no = min(self.current_page_no + 1, len(self.pages) - 1)
self.current_page = self.pages[self.current_page_no]
def previous_page(self):
"""
Updates the current page to be the previous page
"""
self.current_page_no = min(self.current_page_no - 1, len(self.pages) - 1)
self.current_page = self.pages[self.current_page_no]
def get_story_value(self, page, value):
return self.story_config.get(page, value)
def get_title_image(self):
media_location = self.get_story_value(self.pages[0], 'media_location')
if len(media_location) == 0:
media_location = 'images/background.png'
return media_location
def get_story_media(self):
media_location = self.get_story_value(self.current_page, 'media_location')
if len(media_location) == 0:
media_location = 'images/background.png'
return media_location
def get_story_text(self):
return self.get_story_value(self.current_page, 'text')
class Settings(object):
__slots__ = [
'cfgfilename', 'background_source', 'max_stacksize', 'color_mode',
'input_channel', 'video_src', 'video_width', 'video_height',
'show_inp', 'show_out', 'show_vec', 'show_z', 'show_help',
'stack_status', 'single_thread', 'show_ihist', 'show_ohist', 'out',
'loop', 'run', 'x_avg', 'y_avg', 'full_avg', 'indzoom', 'indzoominc',
'log', 'logfile', 'loghandle', 'vecx', 'vecy', 'vecoldx', 'vecoldy',
'vecxcenter', 'vecycenter', 'vecxoffset', 'vecyoffset', 'out_xcenter',
'out_xscale', 'out_ycenter', 'out_yscale', 'actuator', 'actuator_parm',
'dout_active', 'override_active', 'joyx', 'joyy', 'joyxaxis',
'joyyaxis', 'joyaaxis', 'joybaxis', 'joyhat', 'joyoldx', 'joyoldy',
'joymaxx', 'joymaxy', 'proc_thread_run', 'proc_fps', 'output_fps',
'recordi', 'recordv', 'imgindx', 'video', 'output_dir', 'image_dst',
'blr_inp', 'blr_out', 'blr_strength', 'equ_inp', 'equ_out', 'dnz_inp',
'dnz_out', 'dnz_inp_str', 'dnz_out_str', 'flt_inp', 'flt_out',
'flt_inp_strength', 'flt_out_strength', 'flt_inp_kernel',
'flt_out_kernel', 'trfilter', 'trslope', 'trtrigger', 'trpre', 'trflt',
'trpref', 'output_file', 'inp_kernel', 'out_kernel', 'flip_x',
'flip_y', 'mode_prc', 'pseudoc', 'dyn_dark', 'gain_inp', 'gain_out',
'offset_inp', 'offset_out', 'stb_inp', 'stb_out', 'vec_zoom', 'green',
'red', 'blue', 'black', 'Config', 'kernels', 'numkernels',
'flt_inp_name', 'flt_out_name', 'rootwidget', 'imagestack',
'disp_image', 'oimage', 'iimage', 'act', 'vecz', 'procthread',
'numframes', 'raspicam', 'timestring', 'cap_prop_frame_width',
'cap_prop_frame_height', 'cap_prop_pos_frames', 'prop_fourcc',
'xorvalue', 'xormask1', 'xormask2', 'mask', 'background',
'actuator_class', 'vectype'
]
def __init__(self):
self.Config = ConfigParser()
self.Config.add_section('Input')
self.Config.add_section('Processor')
self.Config.add_section('Output')
# default values
self.cfgfilename = 'default.conf'
self.background_source = 'assets/background.png'
self.max_stacksize = 255 # Max. No. of frames in stack
self.numframes = 128
self.color_mode = -1 # Greyscale output
self.input_channel = 0 # Greyscale input
self.video_src = 0 # Default camera
self.video_width = 1024
self.video_height = 768
self.show_inp = True
self.show_out = True
self.show_vec = False
self.show_z = True
self.show_help = False
self.stack_status = False
self.single_thread = False
self.show_ihist = False
self.show_ohist = False
self.out = None
self.background = None
self.loop = True
self.run = True
self.raspicam = False
self.xorvalue = False
self.xormask1 = None
self.xormask2 = None
# opencv properties
self.cap_prop_frame_width = 3
self.cap_prop_frame_height = 4
self.cap_prop_pos_frames = 1
self.prop_fourcc = 'YUYV'
# variables for vector display and actuators
self.x_avg = 0
self.y_avg = 0
self.full_avg = 0
self.indzoom = 1
self.indzoominc = 0
self.log = False
self.logfile = 'none'
self.loghandle = None
self.vecx = 0
self.vecy = 0
self.vecoldx = 0
self.vecoldy = 0
self.vecxcenter = 0
self.vecycenter = 0
self.vecxoffset = 0
self.vecyoffset = 0
self.out_xcenter = 0
self.out_ycenter = 0
self.out_xscale = 0
self.out_yscale = 0
self.actuator = False
self.actuator_class = 'Paint'
self.actuator_parm = '127.0.0.1:9003'
self.dout_active = False
self.override_active = True
self.vectype = 1
# joystick Configuration
self.joyx = 0
self.joyy = 0
self.joyxaxis = 2
self.joyyaxis = 3
self.joyaaxis = 0
self.joybaxis = 1
self.joyhat = 0
self.joyoldx = 0
self.joyoldy = 0
self.joymaxx = 32768
self.joymaxy = 32768
# timing settings for processing and display threads
self.proc_thread_run = True
self.proc_fps = 1.0 / 30.0
self.output_fps = 1.0 / 25.0
# settings for transient filter
self.trfilter = False
self.trslope = 1
self.trtrigger = 1
self.trpre = 0
self.trflt = 0
self.trpref = 0
# settings for video and image sequence recording
self.recordi = False
self.recordv = False
self.imgindx = 0
self.video = None
self.output_file = None
self.output_dir = './output/'
self.image_dst = self.output_dir
# switches for image filters and tools
self.blr_inp = False
self.blr_out = False
self.blr_strength = 7
self.equ_inp = 0
self.equ_out = 0
self.dnz_inp = False
self.dnz_out = False
self.dnz_inp_str = 33
self.dnz_out_str = 33
self.flt_inp = 0
self.flt_out = 0
self.flt_inp_strength = 0
self.flt_out_strength = 0
self.flt_inp_kernel = None
self.flt_out_kernel = None
self.flip_x = False
self.flip_y = False
self.inp_kernel = None
self.out_kernel = None
self.mode_prc = 0
self.pseudoc = False
self.dyn_dark = 4
self.gain_inp = 1.0
self.gain_out = 1.0
self.offset_inp = 0
self.offset_out = 0
self.stb_inp = False
self.stb_out = False
self.vec_zoom = 0.1
self.green = (0, 255, 0)
self.red = (0, 0, 255)
self.blue = (255, 0, 0)
self.black = (0, 0, 0)
self.mask = 0
# self.set_defaults()
def gettime(self):
self.timestring = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
return self.timestring
def write_config(self, filename, widget):
if filename is None:
filename = self.cfgfilename
# Section 'Input'
self.Config.set('Input', 'play_mode', widget.playmode_wid.text)
self.Config.set('Input', 'video_src', self.video_src)
self.Config.set('Input', 'video_width', self.video_width)
self.Config.set('Input', 'video_height', self.video_height)
self.Config.set('Input', 'video_codec', self.prop_fourcc)
self.Config.set('Input', 'input', widget.inp_wid.state)
self.Config.set('Input', 'flip_x', widget.flipx_wid.state)
self.Config.set('Input', 'flip_y', widget.flipy_wid.state)
self.Config.set('Input', 'blr_inp', widget.iblur_wid.state)
self.Config.set('Input', 'equ_inp', widget.iequ_wid.text)
self.Config.set('Input', 'dnz_inp', widget.idnz_wid.state)
self.Config.set('Input', 'dnz_inp_str', self.dnz_inp_str)
self.Config.set('Input', 'flt_inp', widget.iflt_wid.text)
self.Config.set('Input', 'flt_inp_strength', self.flt_inp_strength)
self.Config.set('Input', 'stb_inp', widget.istab_wid.state)
self.Config.set('Input', 'gain_inp', widget.igain_wid.value)
self.Config.set('Input', 'offset_inp', widget.ioffset_wid.value)
self.Config.set('Input', 'color_channel', widget.ichan_wid.text)
# Section 'Processor'
self.Config.set('Processor', 'mask', widget.mask_wid.text)
self.Config.set('Processor', 'mode_prc', widget.proc_wid.text)
self.Config.set('Processor', 'dyn_dark', widget.dark_wid.text)
self.Config.set('Processor', 'blr_strength', self.blr_strength)
self.Config.set('Processor', 'stack_size', widget.stack_wid.value)
self.Config.set('Processor', 'ind_zoom', widget.indzoom_wid.value)
self.Config.set('Processor', 'dout', widget.dout_wid.state)
self.Config.set('Processor', 'vectype', widget.vectype_wid.text)
self.Config.set('Processor', 'actuator', widget.actuator_wid.state)
self.Config.set('Processor', 'actuator_class', self.actuator_class)
self.Config.set('Processor', 'actuator_parm', self.actuator_parm)
self.Config.set('Processor', 'override', widget.override_wid.state)
# Section 'Output'
self.Config.set('Output', 'output', widget.out_wid.state)
self.Config.set('Output', 'output_dir', self.output_dir)
self.Config.set('Output', 'recorder', widget.recorder_wid.text)
self.Config.set('Output', 'blr_out', widget.oblur_wid.state)
self.Config.set('Output', 'equ_out', widget.oequ_wid.text)
self.Config.set('Output', 'dnz_out', widget.odnz_wid.state)
self.Config.set('Output', 'dnz_out_str', self.dnz_out_str)
self.Config.set('Output', 'flt_out', widget.oflt_wid.text)
self.Config.set('Output', 'flt_out_strength', self.flt_out_strength)
self.Config.set('Output', 'stb_out', widget.ostab_wid.state)
self.Config.set('Output', 'gain_out', widget.ogain_wid.value)
self.Config.set('Output', 'offset_out', widget.ooffset_wid.value)
self.Config.set('Output', 'color_mode', widget.colors_wid.text)
self.Config.set('Output', 'background_source', self.background_source)
self.Config.set('Output', 'osd', widget.osd_wid.state)
self.Config.set('Output', 'hud', widget.vec_wid.state)
self.Config.set('Output', 'trf_mode', widget.trf_wid.text)
self.Config.set('Output', 'trf_trig', self.trtrigger)
self.Config.read(filename)
self.Config.write()
def read_parms(self, filename):
if os.path.isfile(filename):
self.Config.read(filename)
# Section 'Input'
self.video_src = self.Config.get('Input', 'video_src')
self.video_width = int(self.Config.get('Input', 'video_width'))
self.video_height = int(self.Config.get('Input', 'video_height'))
self.prop_fourcc = self.Config.get('Input', 'video_codec')
self.dnz_inp_str = float(self.Config.get('Input', 'dnz_inp_str'))
self.flt_inp_strength = float(
self.Config.get('Input', 'flt_inp_strength'))
# Section 'Processor'
self.blr_strength = int(
self.Config.get('Processor', 'blr_strength'))
self.actuator_class = self.Config.get('Processor',
'actuator_class')
self.actuator_parm = self.Config.get('Processor', 'actuator_parm')
# Section 'Output'
self.output_dir = self.Config.get('Output', 'output_dir')
self.dnz_out_str = float(self.Config.get('Output', 'dnz_out_str'))
self.flt_out_strength = float(
self.Config.get('Output', 'flt_out_strength'))
self.background_source = self.Config.get('Output',
'background_source')
self.trtrigger = self.Config.get('Output', 'trf_trig')
else:
print('File ' + str(filename) + ' does not exist.')
def read_ui_parms(self, filename, widget):
if os.path.isfile(filename):
self.Config.read(filename)
# Section 'Input'
widget.playmode_wid.text = self.Config.get('Input', 'play_mode')
widget.inp_wid.state = self.Config.get('Input', 'input')
widget.flipx_wid.state = self.Config.get('Input', 'flip_x')
widget.flipy_wid.state = self.Config.get('Input', 'flip_y')
widget.iblur_wid.state = self.Config.get('Input', 'blr_inp')
widget.iequ_wid.text = self.Config.get('Input', 'equ_inp')
widget.idnz_wid.state = self.Config.get('Input', 'dnz_inp')
widget.iflt_wid.text = self.Config.get('Input', 'flt_inp')
widget.istab_wid.state = self.Config.get('Input', 'stb_inp')
widget.igain_wid.value = float(self.Config.get(
'Input', 'gain_inp'))
widget.ioffset_wid.value = float(
self.Config.get('Input', 'offset_inp'))
widget.ichan_wid.text = self.Config.get('Input', 'color_channel')
# Section 'Processor'
widget.mask_wid.text = self.Config.get('Processor', 'mask')
widget.proc_wid.text = self.Config.get('Processor', 'mode_prc')
widget.dark_wid.text = self.Config.get('Processor', 'dyn_dark')
widget.vectype_wid.text = self.Config.get('Processor', 'vectype')
widget.stack_wid.value = int(
self.Config.get('Processor', 'stack_size'))
widget.indzoom_wid.value = float(
self.Config.get('Processor', 'ind_zoom'))
widget.dout_wid.state = self.Config.get('Processor', 'dout')
widget.actuator_wid.state = self.Config.get(
'Processor', 'actuator')
widget.override_wid.state = self.Config.get(
'Processor', 'override')
# Section 'Output'
widget.out_wid.state = self.Config.get('Output', 'output')
widget.recorder_wid.text = self.Config.get('Output', 'recorder')
widget.oblur_wid.state = self.Config.get('Output', 'blr_out')
widget.oequ_wid.text = self.Config.get('Output', 'equ_out')
widget.odnz_wid.state = self.Config.get('Output', 'dnz_out')
widget.oflt_wid.text = self.Config.get('Output', 'flt_out')
widget.ostab_wid.state = self.Config.get('Output', 'stb_out')
widget.ogain_wid.value = float(
self.Config.get('Output', 'gain_out'))
widget.ooffset_wid.value = float(
self.Config.get('Output', 'offset_out'))
widget.colors_wid.text = self.Config.get('Output', 'color_mode')
widget.osd_wid.state = self.Config.get('Output', 'osd')
widget.vec_wid.state = self.Config.get('Output', 'hud')
widget.trf_wid.text = self.Config.get('Output', 'trf_mode')
else:
print('File ' + str(filename) + ' does not exist.')
class wfpiconsole(App):
# Define App class observation dictionary properties
Obs = DictProperty ([('rapidSpd','--'), ('rapidDir','----'), ('rapidShift','-'),
('WindSpd','-----'), ('WindGust','--'), ('WindDir','---'),
('AvgWind','--'), ('MaxGust','--'), ('RainRate','---'),
('TodayRain','--'), ('YesterdayRain','--'), ('MonthRain','--'),
('YearRain','--'), ('Radiation','----'), ('UVIndex','----'),
('peakSun','-----'), ('outTemp','--'), ('outTempMin','---'),
('outTempMax','---'), ('inTemp','--'), ('inTempMin','---'),
('inTempMax','---'), ('Humidity','--'), ('DewPoint','--'),
('Pres','---'), ('MaxPres','---'), ('MinPres','---'),
('PresTrend','----'), ('FeelsLike','----'), ('StrikeDeltaT','-----'),
('StrikeDist','--'), ('StrikeFreq','----'), ('Strikes3hr','-'),
('StrikesToday','-'), ('StrikesMonth','-'), ('StrikesYear','-')
])
Astro = DictProperty ([('Sunrise',['-','-',0]), ('Sunset',['-','-',0]), ('Dawn',['-','-',0]),
('Dusk',['-','-',0]), ('sunEvent','----'), ('sunIcon',['-',0,0]),
('Moonrise',['-','-']), ('Moonset',['-','-']), ('NewMoon','--'),
('FullMoon','--'), ('Phase','---'), ('Reformat','-'),
])
MetData = DictProperty ([('Weather','Building'), ('Temp','--'), ('Precip','--'),
('WindSpd','--'), ('WindDir','--'), ('Valid','--')
])
Sager = DictProperty ([('Forecast','--'), ('Issued','--')])
System = DictProperty ([('Time','-'), ('Date','-')])
Version = DictProperty ([('Latest','-')])
# Define App class configParser properties
BarometerMax = ConfigParserProperty('-','System', 'BarometerMax','wfpiconsole')
BarometerMin = ConfigParserProperty('-','System', 'BarometerMin','wfpiconsole')
IndoorTemp = ConfigParserProperty('-','Display','IndoorTemp', 'wfpiconsole')
# BUILD 'WeatherFlowPiConsole' APP CLASS
# --------------------------------------------------------------------------
def build(self):
# Load user configuration from wfpiconsole.ini and define Settings panel
# type
self.config = ConfigParser(allow_no_value=True,name='wfpiconsole')
self.config.optionxform = str
self.config.read('wfpiconsole.ini')
self.settings_cls = SettingsWithSidebar
# Force window size if required based on hardware type
if self.config['System']['Hardware'] == 'Pi4':
Window.size = (800,480)
Window.borderless = 1
Window.top = 0
elif self.config['System']['Hardware'] == 'Other':
Window.size = (800,480)
# Initialise real time clock
Clock.schedule_interval(partial(system.realtimeClock,self.System,self.config),1.0)
# Initialise Sunrise and Sunset time, Moonrise and Moonset time, and
# MetOffice or DarkSky weather forecast
astro.SunriseSunset(self.Astro,self.config)
astro.MoonriseMoonset(self.Astro,self.config)
forecast.Download(self.MetData,self.config)
# Generate Sager Weathercaster forecast
Thread(target=sagerForecast.Generate, args=(self.Sager,self.config), name="Sager", daemon=True).start()
# Initialise websocket connection
self.WebsocketConnect()
# Check for latest version
Clock.schedule_once(partial(system.checkVersion,self.Version,self.config,updateNotif))
# Initialise Station class, and set device status to be checked every
# second
self.Station = Station()
Clock.schedule_interval(self.Station.getDeviceStatus,1.0)
# Schedule function calls
Clock.schedule_interval(self.UpdateMethods,1.0)
Clock.schedule_interval(partial(astro.sunTransit,self.Astro,self.config),1.0)
Clock.schedule_interval(partial(astro.moonPhase ,self.Astro,self.config),1.0)
# BUILD 'WeatherFlowPiConsole' APP CLASS SETTINGS
# --------------------------------------------------------------------------
def build_settings(self,settingsScreen):
# Register setting types
settingsScreen.register_type('ScrollOptions', SettingScrollOptions)
settingsScreen.register_type('FixedOptions', SettingFixedOptions)
settingsScreen.register_type('ToggleTemperature', SettingToggleTemperature)
# Add required panels to setting screen. Remove Kivy settings panel
settingsScreen.add_json_panel('Display', self.config, data = settings.JSON('Display'))
settingsScreen.add_json_panel('Primary Panels', self.config, data = settings.JSON('Primary'))
settingsScreen.add_json_panel('Secondary Panels', self.config, data = settings.JSON('Secondary'))
settingsScreen.add_json_panel('Units', self.config, data = settings.JSON('Units'))
settingsScreen.add_json_panel('Feels Like', self.config, data = settings.JSON('FeelsLike'))
self.use_kivy_settings = False
# OVERLOAD 'on_config_change' TO MAKE NECESSARY CHANGES TO CONFIG VALUES
# WHEN REQUIRED
# --------------------------------------------------------------------------
def on_config_change(self,config,section,key,value):
# Update current weather forecast and Sager Weathercaster forecast when
# temperature or wind speed units are changed
if section == 'Units' and key in ['Temp','Wind']:
if self.config['Station']['Country'] == 'GB':
forecast.ExtractMetOffice(self.MetData,self.config)
else:
forecast.ExtractDarkSky(self.MetData,self.config)
if key == 'Wind' and 'Dial' in self.Sager:
self.Sager['Dial']['Units'] = value
self.Sager['Forecast'] = sagerForecast.getForecast(self.Sager['Dial'])
# Update "Feels Like" temperature cutoffs in wfpiconsole.ini and the
# settings screen when temperature units are changed
if section == 'Units' and key == 'Temp':
for Field in self.config['FeelsLike']:
if 'c' in value:
Temp = str(round((float(self.config['FeelsLike'][Field])-32) * 5/9))
self.config.set('FeelsLike',Field,Temp)
elif 'f' in value:
Temp = str(round(float(self.config['FeelsLike'][Field])*9/5 + 32))
self.config.set('FeelsLike',Field,Temp)
self.config.write()
panels = self._app_settings.children[0].content.panels
for Field in self.config['FeelsLike']:
for panel in panels.values():
if panel.title == 'Feels Like':
for item in panel.children:
if isinstance(item,Factory.SettingToggleTemperature):
if item.title.replace(' ','') == Field:
item.value = self.config['FeelsLike'][Field]
# Update barometer limits when pressure units are changed
if section == 'Units' and key == 'Pressure':
Units = ['mb','hpa','inhg','mmhg']
Max = ['1050','1050','31.0','788']
Min = ['950','950','28.0','713']
self.config.set('System','BarometerMax',Max[Units.index(value)])
self.config.set('System','BarometerMin',Min[Units.index(value)])
# Update primary and secondary panels displayed on CurrentConditions
# screen
if section in ['PrimaryPanels','SecondaryPanels']:
for Panel,Type in App.get_running_app().config['PrimaryPanels'].items():
if Panel == key:
self.CurrentConditions.ids[Panel].clear_widgets()
self.CurrentConditions.ids[Panel].add_widget(eval(Type + 'Panel')())
break
# Update button layout displayed on CurrentConditions screen
if section == 'SecondaryPanels':
ii = 0
self.CurrentConditions.buttonList = []
Button = ['Button' + Num for Num in ['One','Two','Three','Four','Five','Six']]
for Panel, Type in App.get_running_app().config['SecondaryPanels'].items():
self.CurrentConditions.ids[Button[ii]].clear_widgets()
if Type and Type != 'None':
self.CurrentConditions.ids[Button[ii]].add_widget(eval(Type + 'Button')())
self.CurrentConditions.buttonList.append([Button[ii],Panel,Type,'Primary'])
ii += 1
# Change 'None' for secondary panel selection to blank in config
# file
if value == 'None':
self.config.set(section,key,'')
self.config.write()
panels = self._app_settings.children[0].content.panels
for panel in panels.values():
if panel.title == 'Secondary Panels':
for item in panel.children:
if isinstance(item,Factory.SettingOptions):
if item.title.replace(' ','') == key:
item.value = ''
break
# CONNECT TO THE SECURE WEATHERFLOW WEBSOCKET SERVER
# --------------------------------------------------------------------------
def WebsocketConnect(self):
Server = 'wss://ws.weatherflow.com/swd/data?api_key=' + self.config['Keys']['WeatherFlow']
self._factory = WeatherFlowClientFactory(Server,self)
reactor.connectTCP('ws.weatherflow.com',80,self._factory,)
# SEND MESSAGE TO THE WEATHERFLOW WEBSOCKET SERVER
# --------------------------------------------------------------------------
def WebsocketSendMessage(self,Message):
Message = Message.encode('utf8')
proto = self._factory._proto
if Message and proto:
proto.sendMessage(Message)
# DECODE THE WEATHERFLOW WEBSOCKET MESSAGE
# --------------------------------------------------------------------------
def WebsocketDecodeMessage(self,Msg):
# Extract type of received message
Type = Msg['type']
# Start listening for device observations and events upon connection of
# websocket based on device IDs specified in user configuration file
if Type == 'connection_opened':
if self.config['Station']['TempestID']:
self.WebsocketSendMessage('{"type":"listen_start",' +
' "device_id":' + self.config['Station']['TempestID'] + ',' +
' "id":"Sky"}')
self.WebsocketSendMessage('{"type":"listen_rapid_start",' +
' "device_id":' + self.config['Station']['TempestID'] + ',' +
' "id":"rapidWind"}')
elif self.config['Station']['SkyID']:
self.WebsocketSendMessage('{"type":"listen_start",' +
' "device_id":' + self.config['Station']['SkyID'] + ',' +
' "id":"Sky"}')
self.WebsocketSendMessage('{"type":"listen_rapid_start",' +
' "device_id":' + self.config['Station']['SkyID'] + ',' +
' "id":"rapidWind"}')
if self.config['Station']['OutAirID']:
self.WebsocketSendMessage('{"type":"listen_start",' +
' "device_id":' + self.config['Station']['OutAirID'] + ',' +
' "id":"OutdoorAir"}')
if self.config['Station']['InAirID']:
self.WebsocketSendMessage('{"type":"listen_start",' +
' "device_id":' + self.config['Station']['InAirID'] + ',' +
' "id":"IndoorAir"}')
# Extract observations from obs_st websocket message
elif Type == 'obs_st':
Thread(target=websocket.Tempest, args=(Msg,self), name="Tempest", daemon=True).start()
# Extract observations from obs_sky websocket message
elif Type == 'obs_sky':
Thread(target=websocket.Sky, args=(Msg,self), name="Sky", daemon=True).start()
# Extract observations from obs_air websocket message based on device
# ID
elif Type == 'obs_air':
if self.config['Station']['InAirID'] and Msg['device_id'] == int(self.config['Station']['InAirID']):
Thread(target=websocket.indoorAir, args=(Msg,self), name="indoorAir", daemon=True).start()
if self.config['Station']['OutAirID'] and Msg['device_id'] == int(self.config['Station']['OutAirID']):
Thread(target=websocket.outdoorAir, args=(Msg,self), name="outdoorAir", daemon=True).start()
# Extract observations from rapid_wind websocket message
elif Type == 'rapid_wind':
websocket.rapidWind(Msg,self)
# Extract observations from evt_strike websocket message
elif Type == 'evt_strike':
websocket.evtStrike(Msg,self)
# UPDATE 'WeatherFlowPiConsole' APP CLASS METHODS AT REQUIRED INTERVALS
# --------------------------------------------------------------------------
def UpdateMethods(self,dt):
# Get current time in station timezone
Tz = pytz.timezone(self.config['Station']['Timezone'])
Now = datetime.now(pytz.utc).astimezone(Tz)
Now = Now.replace(microsecond=0)
# At 5 minutes past each hour, download a new forecast for the Station
# location
if (Now.minute,Now.second) == (5,0):
forecast.Download(self.MetData,self.config)
# At the top of each hour update the on-screen forecast for the Station
# location
if self.config['Station']['Country'] == 'GB':
if Now.hour > self.MetData['Time'].hour or Now.date() > self.MetData['Time'].date():
forecast.ExtractMetOffice(self.MetData,self.config)
self.MetData['Time'] = Now
elif self.config['Keys']['DarkSky']:
if Now.hour > self.MetData['Time'].hour or Now.date() > self.MetData['Time'].date():
forecast.ExtractDarkSky(self.MetData,self.config)
self.MetData['Time'] = Now
# Once dusk has passed, calculate new sunrise/sunset times
if Now >= self.Astro['Dusk'][0]:
self.Astro = astro.SunriseSunset(self.Astro,self.config)
# Once moonset has passed, calculate new moonrise/moonset times
if Now > self.Astro['Moonset'][0]:
self.Astro = astro.MoonriseMoonset(self.Astro,self.config)
# At midnight, update Sunset, Sunrise, Moonrise and Moonset Kivy Labels
if self.Astro['Reformat'] and Now.replace(second=0).time() == time(0,0,0):
self.Astro = astro.Format(self.Astro,self.config,"Sun")
self.Astro = astro.Format(self.Astro,self.config,"Moon")
class hodl_mobile(App):
def show_popup(self):
p = Theme_Popup()
p.open()
'''Функционал программы.'''
title = 'hodl_mobile'
icon = 'icon.png'
nav_drawer = ObjectProperty()
theme_cls = ThemeManager()
theme_cls.primary_palette = 'Blue'
lang = StringProperty('en')
cont = StringProperty()
def __init__(self, **kvargs):
super(hodl_mobile, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.plugin = ShowPlugins(self)
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.window_contacts = None
self.exit_interval = False
self.dict_language = literal_eval(
open(os.path.join(self.directory, 'data', 'locales',
'locales.txt')).read())
self.dict_contacts = literal_eval(
open(os.path.join(self.directory, 'data', 'contacts.txt')).read())
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'data',
'locales'))
def get_application_config(self):
return super(hodl_mobile, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
'''Создаёт файл настроек приложения hodl_mobile.ini.'''
config.adddefaultsection('General')
config.setdefault('General', 'language', 'en')
def set_value_from_config(self):
'''Устанавливает значения переменных из файла настроек hodl_mobile.ini.'''
self.config.read(os.path.join(self.directory, 'hodl_mobile.ini'))
self.lang = self.config.get('General', 'language')
def build(self):
self.set_value_from_config()
self.load_all_kv_files(
os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen() # main screen
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
def events_program(self, instance, keyboard, keycode, text, modifiers):
'''On menu button press.'''
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.toggle_nav_drawer()
self.back_screen(event=keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self):
'''Менеджер экранов. Вызывается при нажатии Back Key
и шеврона "Назад" в ToolBar.'''
# Нажата BackKey.
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
except:
self.manager.current = 'base'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def select_locale(self, *args):
'''Выводит окно со списком имеющихся языковых локализаций для
установки языка приложения.'''
def select_locale(name_locale):
'''Устанавливает выбранную локализацию.'''
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(Lists(dict_items=dict_info_locales,
events_callback=select_locale,
flag='one_select_check'),
size=(.85, .55))
self.window_language.open()
def show_plugins(self, *args):
'''Выводит на экран список плагинов.'''
self.plugin.show_plugins()
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.about.ids.label.text = \
self.translation._(
u'[size=20][b]hodl_mobile[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT\n\n'
u'[size=20][b]Developer[/b][/size]\n\n'
u'HODL is a cryptocurrency with smart contracts.\n\n'
u'[ref=SITE_PROJECT]'
u'[color={link_color}]NAME_AUTHOR[/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=https://github.com/hodleum/hodl_mobile.git]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
self.screen.ids.action_bar.title = \
self.translation._('About')
def show_buy_new_tokens(self, *args):
self.manager.current = 'buy_new_tokens'
self.screen.ids.action_bar.title = \
self.translation._('Buy tokens')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_trade()]]
def show_scan(self, *args):
self.manager.current = 'scan'
self.screen.ids.action_bar.title = \
self.translation._('Scan')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_main()]]
def show_find_new_contact(self, *args):
self.manager.current = 'find_new_contact'
self.screen.ids.action_bar.title = \
self.translation._('Find new contact')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_contacts()]]
def show_new_transaction(self, *args):
self.manager.current = 'new_transaction'
self.screen.ids.action_bar.title = \
self.translation._('New transaction')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_main()]]
def show_tokens_info(self, *args):
self.manager.current = 'tokens_info'
self.screen.ids.action_bar.title = \
self.translation._('DVT')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_trade()]]
def show_back_tokens_info(self, *args):
self.manager.current = 'tokens_info'
self.screen.ids.action_bar.title = \
self.translation._('DVT')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_trade()]]
def show_choose_from_contacts(self, *args):
def select_contact(name_contact):
for contact in self.dict_contacts.keys():
if name_contact == self.dict_contacts[contact]:
self.window_contacts.dismiss()
self.cont = name_contact
text_cont = name_contact
print(text_cont)
self.window_contacts.dismiss()
dict_info_contacts = {}
for contact in self.dict_contacts.keys():
dict_info_contacts[self.dict_contacts[contact]] = \
['contact', contact == self.cont]
if not self.window_contacts:
self.window_contacts = card(Lists(dict_items=dict_info_contacts,
events_callback=select_contact,
flag='one_select_check'),
size=(.85, .55))
self.window_contacts.open()
def show_invoicecreation(self, *args):
self.manager.current = 'invoicecreation'
self.screen.ids.action_bar.title = \
self.translation._('Invoice creation')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_main()]]
def show_set(self, *args):
self.manager.current = 'set'
self.nav_drawer._toggle()
self.screen.ids.action_bar.title = \
self.translation._('Settings')
def show_trade(self, *args):
self.manager.current = 'trade'
self.nav_drawer._toggle()
self.screen.ids.action_bar.title = \
self.translation._('Trade')
def show_new_wallet(self, *args):
self.manager.current = 'new_wallet'
self.nav_drawer._toggle()
self.screen.ids.action_bar.title = \
self.translation._('New wallet')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_main()]]
def show_back_trade(self, *args):
self.manager.current = 'trade'
self.screen.ids.action_bar.title = \
self.translation._('Trade')
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def show_buy_more1(self, *args):
self.manager.current = 'buy_more1'
self.screen.ids.action_bar.title = \
self.translation._('Buy')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_trade()]]
def show_sell1(self, *args):
self.manager.current = 'sell1'
self.screen.ids.action_bar.title = \
self.translation._('Sell')
self.screen.ids.action_bar.left_action_items = \
[['arrow-left', lambda x: self.show_back_trade()]]
def show_contacts(self, *args):
self.manager.current = 'contacts'
self.nav_drawer._toggle()
self.screen.ids.action_bar.title = \
self.translation._('Contacts')
def show_back_contacts(self, *args):
self.manager.current = 'contacts'
self.screen.ids.action_bar.title = \
self.translation._('Contacts')
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def show_main(self, *args):
self.manager.current = 'base'
self.nav_drawer._toggle()
self.screen.ids.action_bar.title = \
self.translation._('Home screen')
def show_back_main(self, *args):
self.manager.current = 'base'
self.screen.ids.action_bar.title = \
self.translation._('Home screen')
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def show_network(self, *args):
self.manager.current = 'network'
self.nav_drawer._toggle()
self.screen.ids.action_bar.title = \
self.translation._('Network')
def show_license(self, *args):
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
self.nav_drawer._toggle()
self.manager.current = 'license'
self.screen.ids.action_bar.title = \
self.translation._('MIT LICENSE')
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def change_theme(self, value):
self.theme_cls.primary_palette = value
return value
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
def to_start(self):
self.screen = StartScreen()
return self.screen
class cBaseScript(object):
''' basic script class to inherit all scrpts from '''
def __init__(self):
self.bIsInit = False
self.uMyPath = u''
self.uScriptName = u''
self.uScriptFile = u''
self.iMyVersion = ToIntVersion('1.0.0')
self.fOrcaVersion = ToIntVersion('1.0.0')
self.uType = u'Generic'
self.uSubType = u'Generic'
self.aScriptIniSettings = QueryDict()
self.oConfigParser = KivyConfigParser()
self.uDefaultConfigName = ""
self.uConfigFileName = ""
self.uSection = ""
def RunScript(self, args):
''' Dummy '''
pass
def Init(self,oParORCA,uScriptName,uScriptFile):
''' Initializes the script '''
self.bIsInit = True
self.uScriptName = uScriptName
self.uScriptFile = uScriptFile
self.uDefaultConfigName = uScriptName
self.uMyPath = AdjustPathToOs(oORCA.uScriptsPath+'/'+self.uScriptName)
if not os.path.exists(self.uMyPath):
CreateDir(self.uMyPath)
oORCA.oTheScreen.oLanguage.LoadXmlFile("SCRIPT", uScriptName)
self.uConfigFileName = AdjustPathToOs(self.uMyPath+u'/config.ini')
oRepManagerEntry=cRepManagerEntry()
oRepManagerEntry.uFileName=uScriptFile
if oRepManagerEntry.ParseFromSourceFile():
self.iMyVersion = oRepManagerEntry.oRepEntry.iVersion
self.fOrcaVersion = oRepManagerEntry.oRepEntry.iMinOrcaVersion
#OrcaVersion defines for what Orca Version the Interface has been developed
self.ShowDebug(u'Init')
if not FileExists(self.uConfigFileName):
self.CreateAndInitializeIniFile()
oRepManagerEntry=cRepManagerEntry()
oRepManagerEntry.uFileName=uScriptFile
if oRepManagerEntry.ParseFromSourceFile():
self.iMyVersion = oRepManagerEntry.oRepEntry.iVersion
self.fOrcaVersion = oRepManagerEntry.oRepEntry.iMinOrcaVersion
#OrcaVersion defines for what Orca Version the Script has been developed
self.ReadConfigFromIniFile(self.uDefaultConfigName)
def InitializeSection(self,uSection):
''' Initializes a section in the config.ini file for the script '''
self.ReadConfigFromIniFile(uSection)
def CreateAndInitializeIniFile(self):
''' Creates the ini file '''
self.oConfigParser.add_section(self.uDefaultConfigName)
self.InitializeSection(self.uDefaultConfigName)
self.oConfigParser.write()
def LoadConfig(self):
''' loads a config from the ini file '''
self.oConfigParser.filename=self.uConfigFileName
if len(self.oConfigParser._sections)==0:
if FileExists(self.uConfigFileName):
self.ShowDebug(u'Reading Config File')
self.oConfigParser.read(self.uConfigFileName)
def GetConfigJSONStringforSection(self,uSection):
''' dummy '''
return u'{}'
def ReadConfigFromIniFile(self,uConfigName):
''' reads a config from the ini file '''
self.uSection = uConfigName
try:
SetVar('ScriptConfigSection',uConfigName)
self.LoadConfig()
oIniDef = json.loads(self.GetConfigJSONStringforSection(uConfigName))
for oLine in oIniDef:
uType = oLine.get("type")
uKey = oLine.get("key")
uDefault = oLine.get("default")
if uType == "scrolloptions" or uType == "string":
uPre = "u" + uKey
self.aScriptIniSettings[uPre]=Config_getdefault(self.oConfigParser,self.uSection, uKey,uDefault)
elif uType == "numeric" or uType == "numericslider":
uPre= "i" + uKey
self.aScriptIniSettings[uPre]=ToInt(Config_getdefault(self.oConfigParser,self.uSection, uKey,uDefault))
elif uType == "numericfloat" :
uPre= "f" + uKey
self.aScriptIniSettings[uPre]=ToFloat(Config_getdefault(self.oConfigParser,self.uSection, uKey,uDefault))
elif uType == "bool":
uPre = "b" + uKey
self.aScriptIniSettings[uPre]=ToBool(Config_getdefault(self.oConfigParser,self.uSection, uKey,uDefault))
elif uType == "title":
pass
else:
self.ShowError(u'Cannot read config name (base), wrong attribute:'+self.uConfigFileName + u' Section:'+self.uSection+" " +oLine["type"])
except Exception as e:
self.ShowError(u'Cannot read config name (base):'+self.uConfigFileName + u' Section:'+self.uSection,e)
return
def DeInit(self):
''' deinitializes the ini file '''
self.ShowDebug(u'DeInit')
def OnPause(self):
''' called by system, if the device goes on pause '''
self.ShowInfo(u'OnPause')
def OnResume(self):
''' called by system, if the device resumes '''
self.ShowInfo(u'OnResume')
def ShowWarning(self,uMsg):
''' creates a warning debug line '''
uRet=u'Script '+self.uScriptName+u': '+ uMsg
Logger.warning (uRet)
return uRet
def ShowDebug(self,uMsg):
''' creates a debug line '''
uRet=u'Script '+self.uScriptName+u': '+ uMsg
Logger.debug (uRet)
return uRet
def ShowInfo(self,uMsg):
''' creates a info debug line '''
uRet=u'Script '+self.uScriptName+u': '+ uMsg
Logger.info (uRet)
return uRet
def ShowError(self,uMsg,oException=None):
''' creates a error debug line '''
iErrNo = 0
if oException!=None:
if hasattr(oException,'errno'):
iErrNo=oException.errno
if iErrNo is None:
iErrNo=12345
uRet=LogErrorSmall (u'Script '+self.uScriptName+u': '+ uMsg + " (%d) " % (iErrNo),oException)
return uRet
def _ReadConfig(self):
''' reads the config for the settings dialog '''
oConfig = KivyConfigParser()
oConfig.read(self.uConfigFileName)
return oConfig
def ConfigScriptSettings(self,oScriptSetting):
''' for here we need a separate config object '''
self.oConfigParser=self._ReadConfig()
oScriptSetting.register_type('buttons' , SettingButtons)
oScriptSetting.register_type('numericslider' , SettingNumericSlider)
oScriptSetting.register_type('numericfloat' , SettingNumeric)
oScriptSetting.register_type('scrolloptions' , SettingScrollOptions)
SetVar('ScriptConfigSection',self.uDefaultConfigName)
uSettingsJSON=self.GetConfigJSONStringforSection(self.uDefaultConfigName)
self.ReadConfigFromIniFile(self.uDefaultConfigName)
if uSettingsJSON==u'{}':
return self.On_SettingsClose(None)
uSettingsJSON=ReplaceVars(uSettingsJSON)
oScriptSetting.add_json_panel(self.uDefaultConfigName,self.oConfigParser, data=uSettingsJSON)
oScriptSetting.bind(on_close=self.On_SettingsClose)
return oScriptSetting
def On_SettingsClose(self,instance):
''' Dispatched when the user closes the settings dialog '''
oORCA.DispatchSystemKey('buttonclosesetting_script')
return True
def ShowSettings(self):
''' shows the settings dialog '''
oORCA.oTheScreen.AddActionToQueue([{'string':'updatewidget','widgetname':'Scriptsettings'}])
class Gllearn(MDApp):
title = 'Gllearn'
icon = '.data/images/icon.png'
nav_drawer = ObjectProperty()
lang = StringProperty('ru')
lang_games = StringProperty('en')
__version__ = '0.6'
def __init__(self, **kvargs):
super(Gllearn, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.window_game_language = None
self.exit_interval = False
self.dict_language = literal_eval(
open(os.path.join(self.directory, 'data', 'locales',
'locales.txt')).read())
self.translation = Translation(
self.lang, 'Gllearn',
os.path.join(self.directory, 'data', 'locales'))
self.translation_game = Translation(
self.lang_games, 'Games',
os.path.join(self.directory, 'data', 'locales'))
self.snake_words_with_color = [{
word: get_random_color(alpha=1.0)
for word in words
} for words in [
s.split(' ')
for s in self.translation_game._('snake_rounds').split(' | ')
]]
self.current_round_snake = 0
def set_value_from_config(self):
self.config.read(os.path.join(self.directory, 'gllearn.ini'))
self.lang = self.config.get('General', 'language')
self.lang_games = self.config.get('Games', 'language')
def build(self):
self.theme_cls.primary_palette = "Indigo"
self.set_value_from_config()
self.load_all_kv_files(
os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen()
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
def events_program(self, instance, keyboard, keycode, text, modifiers):
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.set_state()
self.back_screen(event=keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self, event=None):
if event in (1001, 27):
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
self.manager.transition.direction = 'right'
except Exception:
self.manager.current = 'base'
self.manager.transition.direction = 'right'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.set_state()]]
def back_screen_on_game(self, event=None):
if event in (1001, 27):
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
self.manager.transition.direction = 'down'
except Exception:
self.manager.current = 'base'
self.manager.transition.direction = 'down'
self.screen.ids.action_bar.title = self.title
Clock.unschedule(self.show_snake)
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.set_state()]]
def show_about(self, *args):
self.nav_drawer.set_state()
self.screen.ids.about.ids.label.text = \
self.translation._(
u'[size=20][b]Gllearn[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT\n\n'
u'[size=20][b]Developer[/b][/size]\n\n'
u'[ref=SITE_PROJECT]'
u'[color={link_color}]Minnakhmetov Musa Albertovich[/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=https://github.com/katustrica/Gllearn]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=self.__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
self.manager.transition.direction = 'left'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_words(self, *args):
self.screen.ids.action_bar.title = f'Змейка полиглот {self.current_round_snake+1} lvl'
self.manager.current = 'words'
self.manager.transition.direction = 'up'
self.screen.ids.action_bar.left_action_items = [[
'chevron-left', lambda x: self.back_screen_on_game(27)
]]
Clock.schedule_once(self.show_snake, 8)
def next_snake_words(self, *args):
Clock.unschedule(self.show_snake)
self.screen.ids.action_bar.title = f'Змейка полиглот {self.current_round_snake+1} lvl'
self.manager.current = 'words'
self.manager.transition.direction = 'down'
self.screen.ids.action_bar.left_action_items = [[
'chevron-left', lambda x: self.back_screen_on_game(27)
]]
Clock.schedule_once(self.show_snake, 8)
def show_snake(self, *args):
self.manager.current = 'snake'
self.manager.transition.direction = 'up'
self.screen.ids.action_bar.left_action_items = [[
'chevron-left', lambda x: self.back_screen_on_game(27)
]]
def show_translator(self, *args):
self.manager.current = 'translator'
self.screen.ids.action_bar.title = f'Переводчик'
self.manager.transition.direction = 'up'
self.screen.ids.action_bar.left_action_items = [[
'chevron-left', lambda x: self.back_screen_on_game(27)
]]
def show_license(self, *args):
self.nav_drawer.set_state()
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
self.manager.current = 'license'
self.manager.transition.direction = 'left'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
self.screen.ids.action_bar.title = \
self.translation._('MIT LICENSE')
def select_locale(self, *args):
def select_locale(name_locale):
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(Lists(dict_items=dict_info_locales,
events_callback=select_locale,
flag='one_select_check'),
size=(.85, .55))
self.window_language.open()
def select_game_locale(self, *args):
def select_game_locale(name_locale):
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang_games = locale
self.config.set('Games', 'language', self.lang_games)
self.config.write()
self.translation_game.switch_lang(name_locale)
self.snake_words_with_color = [{
word: get_random_color(alpha=1.0)
for word in words
} for words in [
s.split(' ') for s in self.translation_game._(
'snake_rounds').split(' | ')
]]
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang_games]
if not self.window_game_language:
self.window_game_language = card(Lists(
dict_items=dict_info_locales,
events_callback=select_game_locale,
flag='one_select_check'),
size=(.85, .55))
self.window_game_language.open()
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
self.translation_game.switch_lang(lang)
class Project_Test_APP(App):
'''Функционал программы.'''
title = 'Project_Test_APP'
icon = 'icon.png'
nav_drawer = ObjectProperty()
theme_cls = ThemeManager()
theme_cls.primary_palette = 'Blue'
lang = StringProperty('en')
def __init__(self, **kvargs):
super(Project_Test_APP, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.plugin = ShowPlugins(self)
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.exit_interval = False
self.dict_language = literal_eval(
open(os.path.join(self.directory, 'data', 'locales',
'locales.txt')).read())
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'data',
'locales'))
def get_application_config(self):
return super(Project_Test_APP, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
'''Создаёт файл настроек приложения project_test_app.ini.'''
config.adddefaultsection('General')
config.setdefault('General', 'language', 'en')
def set_value_from_config(self):
'''Устанавливает значения переменных из файла настроек project_test_app.ini.'''
self.config.read(os.path.join(self.directory, 'project_test_app.ini'))
self.lang = self.config.get('General', 'language')
def build(self):
self.set_value_from_config()
self.load_all_kv_files(
os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen() # главный экран программы
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
if not PY2:
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
else:
Builder.load_file(kv_file)
def events_program(self, instance, keyboard, keycode, text, modifiers):
'''Вызывается при нажатии кнопки Меню или Back Key
на мобильном устройстве.'''
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.toggle_nav_drawer()
self.back_screen(event=keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self, event=None):
'''Менеджер экранов. Вызывается при нажатии Back Key
и шеврона "Назад" в ToolBar.'''
# Нажата BackKey.
if event in (1001, 27):
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
except:
self.manager.current = 'base'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def show_plugins(self, *args):
'''Выводит на экран список плагинов.'''
self.plugin.show_plugins()
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.about.ids.label.text = \
self.translation._(
u'[size=20][b]Project_Test_APP[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT\n\n'
u'[size=20][b]Developer[/b][/size]\n\n'
u'[ref=SITE_PROJECT]'
u'[color={link_color}]flytrue[/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=https://github.com/flytrue/testapp]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_license(self, *args):
if not PY2:
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
else:
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE')).read()
self.nav_drawer._toggle()
self.manager.current = 'license'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen()]]
self.screen.ids.action_bar.title = \
self.translation._('MIT LICENSE')
def select_locale(self, *args):
'''Выводит окно со списком имеющихся языковых локализаций для
установки языка приложения.'''
def select_locale(name_locale):
'''Устанавливает выбранную локализацию.'''
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(Lists(dict_items=dict_info_locales,
events_callback=select_locale,
flag='one_select_check'),
size=(.85, .55))
self.window_language.open()
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
class Program(App, prog_class.ShowPlugin, prog_class.ShowThemesForum,
prog_class.ShowSectionsForum, prog_class.ShowSendMailForm,
prog_class.ShowTopicsForum, prog_class.ShowListMail,
prog_class.ShowFileDetails, prog_class.ShowUploadForm,
prog_class.ShowFiles, prog_class.ShowUserProfile,
ConnectionToServer):
"""Функционал программы."""
# Языковая локализация - переменные с префиксом core.string_lang_.
# Используются в классах библиотеки programclass. В текущем классе -
# без ключевого слова self, так как были импортированы из programdata
exec(open("{}/Data/Language/{}.txt".format(
core.prog_path, language)).read().replace(
"#key_text_color", core.theme_key_text_color.encode("u8")).replace(
"#text_color", core.theme_text_color.encode("u8")).replace(
"#link_color", core.theme_link_color.encode("u8")))
# TODO: Константа CONST_SCREEN используется модулем kdialog для
# вычесления ширины диалогового окна (Window.size[0] / CONST_SCREEN).
# size_hint_x для этих целей неуместен. Например, при размере экрана
# 600x300 и параметре size_hint_x=.5 окно будет слишком
# узким и наоборот - 300x600 и тот же параметр size_hint_x - покажут окно
# занимаемое бОльшую плоскость экрана.
WIDTH, HEIGHT = Window.size
if WIDTH <= HEIGHT:
CONST_SCREEN = 1.2
else:
CONST_SCREEN = 2
window_text_size = 15
update = None # нет обновлений
messages_unread = None # количество новых сообщений
open_dialog = False # если True - открыто диалоговое окно
number_user = None # номер участника на сайте
cookie = None
site = "http://m.dimonvideo.ru"
previous_screen = None
def __init__(self, **kvargs):
super(Program, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
# Для области видимомти в programclass.
self.FadeTransition = FadeTransition
self.Screen = Screen
self.Clock = Clock
# ----------------------------------
self.parsing_xml = parsing_xml
self.get_page = get_page
self.set_cookie = set_cookie
self.Manifest = Manifest
self.core = core
# ----------------------------------
self.sendmail = sendmail
self.setattachtoforum = setattachtoforum
# ----------------------------------
self.KDialog = KDialog
self.FileChooser = FileChooser
self.SelectColor = SelectColor
self.CustomSpinner = CustomSpinner
self.PageSendMail = PageSendMail
self.ScrollButton = ScrollButton
self.ThemesForum = ThemesForum
self.AboutDialog = AboutDialog
self.UploadFiles = UploadFiles
self.MessageViewer = MessageViewer
self.MailList = MailList
self.BugReporter = BugReporter
self.ImageViewer = ImageViewer
self.customspinner = customspinner
self._urllib = _urllib
self.traceback = traceback
# ----------------------------------
self.clipboard = clipboard
# ----------------------------------
self.theme_decorator_window = core.theme_decorator_window
def get_application_config(self):
return super(Program, self).get_application_config(
"{}/program.ini".format(core.prog_path))
def build_config(self, config):
config.adddefaultsection("General")
config.setdefault("General", "showonstartpage", u"Новости сайта")
config.setdefault("General", "language", u"Русский")
config.setdefault("General", "showwarning", "1")
config.setdefault("General", "resmessages", "1")
config.setdefault("General", "authorization", "0")
config.setdefault("General", "progresstextsize", "15")
config.setdefault("General", "downloadkey", "0")
config.setdefault("General", "downloadfolder",
{0: 'Downloads', 1: ''})
config.setdefault("General", "user_reg",
{"login": "******", "password": "******"})
config.adddefaultsection("Network")
config.setdefault("Network", "authoconnect", "0")
config.setdefault("Network", "checkattachtoforum", "1")
config.setdefault("Network", "loadscr", "0")
config.setdefault("Network", "authoupdate", "1")
config.adddefaultsection("Mail")
config.setdefault("Mail", "messagesread", "1")
config.setdefault("Mail", "intervalscanmess", "10")
config.adddefaultsection("Theme")
config.setdefault("Theme", "theme", "blue_orange")
config.setdefault("Theme", "edittheme", "0")
config.setdefault("Theme", "createtheme", "0")
def build_settings(self, settings):
general_settings = open("{}/Data/Settings/general.json".format(
core.prog_path)).read()
general_data = general_settings % (
core.string_lang_setting_show_on_home_page,
core.string_lang_setting_show_on_home_page_title,
core.string_lang_setting_show_on_home_page_desc,
core.string_lang_setting_news,
core.string_lang_setting_show_on_home_page_themes,
core.string_lang_setting_language,
core.string_lang_setting_language_title,
core.string_lang_setting_language_desc,
core.string_lang_setting_language_russian,
core.string_lang_setting_language_english,
core.string_lang_setting_font,
core.string_lang_setting_font_title,
core.string_lang_setting_font_desc,
core.string_lang_setting_download,
core.string_lang_setting_download_title,
core.string_lang_setting_download_desc) % \
self.downloadfolder[self.downloadkey]
network_settings = open("{}/Data/Settings/network.json".format(
core.prog_path)).read()
network_data = network_settings % (
core.string_lang_setting_connect,
core.string_lang_setting_connect_title,
core.string_lang_setting_connect_desc,
core.string_lang_setting_update,
core.string_lang_setting_update_title,
core.string_lang_setting_update_desc,
core.string_lang_setting_checkattachtoforum_title,
core.string_lang_setting_checkattachtoforum_desc,
core.string_lang_setting_loadscr_title,
core.string_lang_setting_loadscr_desc)
mail_settings = open("{}/Data/Settings/mail.json".format(
core.prog_path)).read()
mail_data = mail_settings % (
core.string_lang_setting_mail,
core.string_lang_setting_mail_title,
core.string_lang_setting_mail_desc,
core.string_lang_setting_mail_interval_title,
core.string_lang_setting_mail_interval_desc)
theme_settings = open("{}/Data/Settings/theme.json".format(
core.prog_path)).read()
theme_data = theme_settings % (
core.string_lang_setting_chek_themes,
core.string_lang_setting_chek_themes_title,
core.string_lang_setting_chek_themes_desc,
'", "'.join(os.listdir("{}/Data/Themes".format(core.prog_path))),
core.string_lang_setting_edit_themes_title,
core.string_lang_setting_edit_themes_desc,
core.string_lang_setting_create_themes_title,
core.string_lang_setting_create_themes_desc)
settings.add_json_panel(core.string_lang_general,
self.config, data=general_data)
settings.add_json_panel(core.string_lang_internet,
self.config, data=network_data)
settings.add_json_panel(core.string_lang_mail[:-1],
self.config, data=mail_data)
settings.add_json_panel(core.string_lang_theme,
self.config, data=theme_data)
def on_config_change(self, config, section, key, value):
"""Вызывается при выборе одного из пункта настроек программы."""
def select_callback(*args):
file_manager.body.dismiss()
self.downloadfolder[1] = file_manager.select_folder
config.set("General", "downloadkey", "1")
config.set("General", "downloadfolder", str(self.downloadfolder))
config.write()
# TODO: обновить описание раздела на путь к выбранной директориии.
if key == "downloadkey" and int(value): # "Настройки загрузок"
file_manager = \
FileChooser(select_callback=select_callback, filter="folder",
title=core.string_lang_select_folder,
background_image=self.core.theme_decorator_window,
auto_dismiss=False, size=(.85, .9),)
elif key == "downloadkey" and not int(value):
self.downloadfolder[1] = ""
config.set("General", "downloadkey", "0")
config.set("General", "downloadfolder", str(self.downloadfolder))
config.write()
elif key == "checkattachtoforum": # "Проверка формы аттача"
self.checkattachtoforum = int(value)
elif key == "progresstextsize": # "Настойка размера шрифта"
self.window_text_size = int(value)
elif key == "edittheme": # "Правка палитры установленной темы"
self.edit_pallete_theme()
def on_pause(self):
"""Ставит приложение на 'паузу' при выхоже из него.
В противном случае запускает программу по заново"""
return True
def build(self):
self.title = core.string_lang_title[:-1] # заголовок окна программы
self.icon = "Data/Images/logo.png" # иконка окна программы
self.use_kivy_settings = False
self.config = ConfigParser()
self.config.read("{}/program.ini".format(core.prog_path))
self.beep = SoundLoader.load("Data/mess_unread.wav")
self.set_variable_from_settings()
# Домашняя страница клиента.
self.start_screen = \
StartScreen(name_buttons_menu=core.name_buttons_menu,
buttons_menu=core.buttons_menu,
buttons_group=core.buttons_group,
previous="Data/Images/logo.png",
title_previous=core.string_lang_title[:-1],
title_image="Data/Images/DV.png",
overflow_image="Data/Images/overflow_image.png",
previous_image="Data/Images/previous_image.png",
events_callback=self.events_program)
self.screen = self.start_screen
Clock.schedule_once(self.read_license, 3)
return self.start_screen
def edit_pallete_theme(self):
print("edit_pallete_theme")
def set_variable_from_settings(self):
self.messagesread = self.config.getint(
"Mail", "messagesread")
self.intervalscanmess = self.config.getint(
"Mail", "intervalscanmess")
self.loadscr = self.config.getint(
"Network", "loadscr")
self.checkattachtoforum = self.config.getint(
"Network", "checkattachtoforum")
self.authoupdate = self.config.getint(
"Network", "authoupdate")
self.authoconnect = self.config.getint(
"Network", "authoconnect")
self.downloadkey = self.config.getint(
"General", "downloadkey")
self.downloadfolder = eval(self.config.get(
"General", "downloadfolder"))
self.window_text_size = self.config.getint(
"General", "progresstextsize")
self.language = core.select_locale[self.config.get(
"General", "language")]
self.showonstartpage = self.config.get(
"General", "showonstartpage")
self.authorization = self.config.getint(
"General", "authorization")
self.resmessages = self.config.getint(
"General", "resmessages")
_user_reg = eval(self.config.get(
"General", "user_reg"))
try:
self.user_reg = {"login": _user_reg["login"].decode("hex"),
"password": _user_reg["password"].decode("hex")}
except TypeError:
self.user_reg = {"login": _user_reg["login"],
"password": _user_reg["password"]}
except AttributeError: # Python 3
self.user_reg = {"login": _user_reg["login"],
"password": bytes.fromhex(
_user_reg["password"]).decode('utf-8')}
def read_license(self, *args):
def dialog_answer_handler(*args):
"""Функция обработки сигналов диалогового окна.
type answer: str;
param answer: имя нажатой кнопки или введенного текта;
"""
if len(args) == 1: # нажата кнопка
answer = args[0]
if answer == core.string_lang_yes:
open("{}/README.md".format(core.prog_path), "w").write(
re.sub('\[.*?]', '', license).replace("\n\n\n", "\n"))
self.open_dialog = False
# Устанавливаем подпись на домашней странице клиента -
# "Мобильный клиент сайта dimonvideo.ru"
self.start_screen.mobile_client_label.text = \
core.string_lang_mobile_client_label
# Автоматическое подключение при старте.
if self.authoconnect \
and self.user_reg["login"] != "login" \
and self.user_reg["password"] != "password":
Clock.schedule_once(self.connect, 0)
elif answer == core.string_lang_no:
sys.exit(1)
else: # нажата ссылка
link = args[1]
webbrowser.open(link)
# Если пользователь уже был авторизирован.
if self.authorization or os.path.exists("{}/README.md".format(
core.prog_path)):
if self.authoconnect and self.user_reg["login"] != "login" and \
self.user_reg["password"] != "password":
self.connect()
else:
self.start_screen.mobile_client_label.text = \
core.string_lang_mobile_client_label
else:
self.open_dialog = True
license = \
core.string_lang_license.replace(
"--------------------------------------------------------"
"-----------------------", "").split(
"[color={}]ОПИСАНИЕ ".format(core.theme_key_text_color))[0]
# Спрашиваем, согласен ли пользователь с условиями.
self.create_window(callback=dialog_answer_handler, size_x=1.2,
text=license, button_ok=core.string_lang_yes,
button_no=core.string_lang_no, param="query")
def events_program(self, *args):
"""Вызывается при выборе одного из пунктов меню программы."""
if self.open_dialog:
return
if len(args) == 2: # нажата ссылка
event = args[1].encode("utf-8")
else: # нажата кнопка
try:
_args = args[0]
event = _args if isinstance(_args, str) else _args.id
except AttributeError: # ввод текста в форму отправки сообщений
return
#if not self.cookie and event == core.string_lang_item_menu_profile:
# self.create_window(core.string_lang_authorization_client)
# return
# ------------------------------ВОЙТИ----------------------------------
if event == core.string_lang_item_menu_connect:
self.connect()
# -----------------------------ПРОФИЛЬ---------------------------------
if event == core.string_lang_item_menu_profile:
progress = self.create_window(core.string_lang_info_your,
param="loaddialog")
Clock.schedule_once(lambda *args: self.show_user_profile(
progress, self.user_reg["login"]), 0.1)
# ----------------------------ACTION BAR-------------------------------
elif event == "previous" or event in (1000, 27):
self.back_screen()
# -----------------------------НАСТРОЙКИ------------------------------
elif event == core.string_lang_item_menu_settings:
self.open_settings()
# -----------------------------ЛИЦЕНЗИЯ-------------------------------
elif event == core.string_lang_item_menu_license:
self.create_window(
callback=self.show_license, size_x=1.2,
text=core.string_lang_license.split(
"[color={}]Нажав ".format(
core.theme_text_color))[0].replace(
"\n--------------------------------------------"
"-----------------------------------", ""),
button_ok=core.string_lang_on_russian,
button_no=core.string_lang_on_english, param="query",
dismiss=True)
# ----------------------------О ПРОГРАММЕ------------------------------
elif event == core.string_lang_item_menu_about:
self.show_about()
elif event == core.string_lang_item_menu_exit:
sys.exit(0)
# ------------------------------ФОРУМ----------------------------------
elif event == "forum":
progress = self.create_window(text=core.string_lang_load_topics,
param="loaddialog")
Clock.schedule_once(
lambda *args: self.show_sections_forum(
progress, core.api.ROOT_PARTITION_FORUM), 1)
# ----------------------ДОБАВИТЬ ФАЙЛ НА СЕРВЕР------------------------
elif event == "upload":
self.show_upload_form()
# ----------------------------СООБЩЕНИЯ--------------------------------
elif event == "mail":
def _show_list_mail(*args):
progress = \
self.create_window(text=core.directions[args[0][0].id][1],
param="loaddialog")
Clock.schedule_once(
lambda *arg: self.show_list_mail(progress, args[0]), 2)
# Просим авторизацию.
if not self.cookie:
self.create_window(text=core.string_lang_authorization_client)
return
# Выводим папки для просмотра и функции для манипуляции с почтой.
scroll_mail = \
ScrollButton(
events_callback=lambda *args: _show_list_mail(args),
button_list=core.sections_mail, dismiss=True,
background_image=core.theme_decorator_window)
scroll_mail.show(title=core.string_lang_mail)
# ----------------------------СТАТЬИ-------------------------------
elif event == "articles":
progress = self.create_window(text=core.string_lang_load_topics)
Clock.schedule_once(
lambda *args: self.show_file_details(
progress, "articles"), 0.1)
# ---------------------------ПЛАГИНЫ--------------------------------
elif event == core.string_lang_plugin:
self.show_plugins()
# ----------------------------ФАЙЛЫ---------------------------------
elif event == "files":
self.show_sections_files()
return True
def back_screen(self):
"""Показываем предыдущий и удаляем из списка текущий экран."""
if len(self.screen.screen_manager.screens) != 1:
self.screen.screen_manager.screens.pop()
self.screen.screen_manager.current = \
self.screen.screen_manager.screen_names[-1]
# Устанавливаем имя предыдущего экрана.
self.screen.action_previous.title = self.screen.screen_manager.current
def create_window(self, text, title=core.string_lang_title,
button_ok=None, button_no=None, button_cancel=None,
background=core.theme_decorator_window, param="info",
callback=p, dismiss=False, size_x=CONST_SCREEN,
font_size=window_text_size, password=False):
window = KDialog(answer_callback=callback, base_font_size=font_size,
background_image=background, size_hint_x=size_x)
window.show(title=title, image="Data/Images/loading.gif",
text=text, param=param, auto_dismiss=dismiss,
text_button_ok=button_ok, text_button_no=button_no,
text_button_cancel=button_cancel, password=password)
return window
def create_text_topics_or_comments(self, text_topics_or_comments,
dict_info_topics_or_comments,
current_number_page, number_posts,
next_answers, flag):
"""Вызывается из класса ShowTopicsForum и ShowFileDetails
для формирования текста страниц форума/комментариев/статей/описания
к файлам.
:param text_topics_or_comments: сырой текст страницы, полученный от
сервера;
:param dict_info_topics_or_comments:
информация о каждом посте/комментена станице вида
{"id": ["12345", ...],
"author": ["name_author", ...],
"date": ["12345", ...]}
:type current_number_page: int;
:param current_number_page: выбраная страница;
:type numbers_pages_forum: int;
:param numbers_pages_forum: количество страниц форума/комментариев;
:type next_answers: str;
:param type next_answers: "0", "20", "40", "60", ... - вывод следующей
двадцатки топиков
:type flag: str or None;
:param flag: имя раздела, если выводим комментарии к файлу;
Returns: (str, str, list):
- форматированый текст модулем textmarker.py страницы форума или
комментвриев;
- строку, пагинатор страниц, маркированую для MarkupLabel;
- список ссылок на странице, вида [('адрес_ссылки', 'имя_ссылки'),];
"""
_mark_links = []
_next_answers = next_answers
_list_topics_or_comments = text_topics_or_comments.split("</text>")
list_topics_or_comments = []
text_topics_or_comments = ""
online = ""
for i, author in enumerate(dict_info_topics_or_comments["author"]):
# Парсинг топика/комментария.
topic_or_comment_parse, mark_links, mark_links_scr = \
self.parse_text(_list_topics_or_comments[i].decode("cp1251"))
_mark_links += mark_links.items()
if flag: # для комментариев
_time = dict_info_topics_or_comments["date"][i]
else:
_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(
int(dict_info_topics_or_comments["date"][i])))
_next_answers += 1
if not flag: # для форума
try:
if dict_info_topics_or_comments["online"][i] == "0":
online = "|[color=#f70000]Offline[/color]|"
else:
online = "|[color=#00d700]Online[/color]|"
except KeyError: # для комментариев
online = ""
# Если топик пользователя, добавляем пункт "Удалить" и
# подсвечивает другим цветом ник.
if author == self.user_reg["login"]:
author_color = core.theme_key_text_color
item_delete = "[color={}][ref=Post_id: {}]{}[/ref][/color]|" \
"".format(core.theme_link_color,
dict_info_topics_or_comments["id"][i],
core.string_lang_delete)
else:
author_color = core.theme_link_color
item_delete = ""
# #1 Author | online | Ответ | Копировать | Удалить
# 26.01.16 10:45
#
# Текст топика...
topic_or_comment_parse = \
"#{} [color={author_color}][ref={author}]{author}[/ref]" \
"[/color] {}|[color={link_color}][ref={answer}-|-{author}" \
"-|-{i}]{answer}[/ref][/color]|[color={link_color}]" \
"[ref={copy}-|-{author}-|-{i}]{copy}[/ref][/color]|" \
"{delete}\n{}\n-------------\n{}\n-------------".format(
str(_next_answers), online, _time, topic_or_comment_parse,
author=author, answer=core.string_lang_answer, i=str(i),
copy=core.string_lang_copy, delete=item_delete,
author_color=author_color,
link_color=core.theme_link_color)
text_topics_or_comments += topic_or_comment_parse
list_topics_or_comments.append(topic_or_comment_parse)
# Если топиков менбше 20-ти.
number_posts = 1 if not number_posts else number_posts
current_number_page = 1 if not current_number_page \
else current_number_page
# Список для хранения номеров страниц.
list_pages = paginator(number_posts, current_number_page)
# Формируем нумерацию страниц и помечаем выбраную.
build_pages = ""
for number_page in list_pages:
try:
number_page = \
int(number_page.replace("[", "").replace("]", ""))
if current_number_page == number_page:
color = core.theme_key_text_color
else:
color = core.theme_link_color
except ValueError:
color = core.theme_link_color
build_pages += \
"[color={}][ref=Page_number: {number_page}]{number_page}" \
"[/ref] ".format(color, number_page=number_page)
return text_topics_or_comments, list_topics_or_comments, \
build_pages, _mark_links
def refs_callback(self, *args):
"""Обрабатывает события при клике на страницах корневых разделов
тем форума или списка файлов."""
# Выводим следующую страницу тем форума или списка файлов.
if "Page_number" in args[0]:
callback_load_new_page = args[5]
select_number_page = args[0].split(": ")[1]
callback_load_new_page(select_number_page)
return
# Выбран файл из списка на экране или ссылка "Комментариев:" под ним.
if not args[1]:
select_name_file = args[0]
self.load_file_details(None, select_name_file)
return
try:
forum_name = args[0] # "Python"
themes_id = args[1][forum_name] # "141", "1728141632" (tid, id)
if len(args[2].items()):
forum_id = args[2][forum_name] # "id_форума"
else:
forum_id = themes_id
forum_flag = args[3] # "themes" or "topics"
forum_id_posts = args[4] # {'1728141632': '9767', ...}
self.tid_forum = forum_id
# Количество ответов в форуме.
try:
number_posts = forum_id_posts[themes_id]
except KeyError:
number_posts = None
if forum_flag == "topics":
progress = \
self.create_window(text=core.string_lang_load_themes_answer)
Clock.schedule_once(lambda *arg: self.show_topics_forum(
progress, forum_name, themes_id, 0, int(number_posts) / 20,
1), 1)
else:
progress = \
self.create_window(text=core.string_lang_load_themes)
Clock.schedule_once(lambda *arg: self.show_themes_forum(
progress, forum_name, forum_flag, themes_id,
core.api.THEMES_FORUM), 1)
except KeyError:
# Клик на ник пользователя в разделе "Последний ответ".
user_name = args[0]
self.send_mail_or_show_profile(user_name)
def send_mail_or_show_profile(self, user_name, instance_open_mail=None):
"""Выводит окно с кнопками показа профиля или формы для отправки
сообщения выбранного пользователя.
type instance_open_mail: <class 'messageviewer.MessageViewer'>;
param instance_open_mail: открытое окно с текстом просматриваемого
сообщения;
"""
def _send_mail_or_show_profile(*args):
name_button = args[0][0] # "Профиль"/"Сообщение"
if name_button == core.string_lang_item_menu_profile:
progress = \
self.create_window(text=core.string_lang_info_your)
Clock.schedule_once(lambda *arg: self.show_user_profile(
progress, user_name, instance_open_mail), 1)
elif name_button == core.string_lang_write_message_status:
self.send_mail(user_name)
self.create_window(
callback=lambda *args: _send_mail_or_show_profile(args),
param="query", dismiss=True,
text=core.string_lang_username.format(user_name),
button_ok=core.string_lang_item_menu_profile,
button_cancel=core.string_lang_write_message_status)
def error_read_page(self, progress=None):
if progress:
progress.body.dismiss()
self.create_window(text=core.string_lang_error_read_page)
self.open_dialog = False
def get_news(self):
"""Возвращает текст новостей сайта или False, если их нет."""
news = get_page(core.api.GET_NEWS, self.cookie)
if not news:
self.error_read_page()
return
news = core.dict_search_templates["name"].findall(news)[0]
if news != "":
return news
else:
if platform != "android":
print("Новостей нет!")
print("------------------------------------")
return False
def download_file(self, link_text, link_address):
def download_cancel(self, *args):
setattr(retrieve_progress_load, "flag", 0)
progress_load.body.dismiss()
path_to_folder = self.downloadfolder[self.downloadkey]
if not os.path.exists(path_to_folder):
os.mkdir(path_to_folder)
progress_load = \
ProgressLoad(retrieve_callback=retrieve_progress_load,
events_callback=download_cancel,
text_button_cancel=core.string_lang_button_cancel,
text_already_loaded=core.string_lang_already_loaded,
text_total_size=core.string_lang_total_size)
progress_load.show(link_address,
"{}/{}".format(path_to_folder,
os.path.split(link_address)[1]))
def update_page_on_forum(self, next_answers=0, current_number_page=0,
*args):
# После добавления/удаления ответа в форум закрываем текущую страницу
# и удаляем ее из списка экранов, чтобы с последующим вызовом
# функции self.show_topics_forum была выведена обновленая
# страница форума с последним ответом.
name_forum = args[0]
forum_id = args[1]
number_posts = args[2]
flag = args[3] # если None - обновляем последнюю страницу форума -
# добавление нового поста, если True - текущую - удаление поста
self.screen.screen_manager.screens.pop()
self.screen.screen_manager.current = \
self.screen.screen_manager.screen_names[-1]
progress = self.create_window(text=core.string_lang_forum_update)
if not flag: # если происходит добавление поста в форум
next_answers = number_posts * 20
current_number_page = number_posts
if isinstance(flag, str): # раздел файлов, например "articles"
flag = flag
Clock.schedule_once(lambda *args: self.show_topics_forum(
progress, name_forum, forum_id, next_answers, number_posts,
current_number_page, flag), 1)
def update_program(self):
"""Проверяет наличие обновлений на сервере github,com.
Проверяестя версия программы, версии плагинов, наличие измененных
программых файлов."""
if platform != "android":
print("Проверка обновлений:")
print("------------------------------------")
temp_path = "{}/Data/temp".format(core.prog_path)
if not os.path.exists(temp_path):
os.mkdir(temp_path)
update_file = urllib.urlopen(
"https://github.com/HeaTTheatR/HeaTDV4A/raw/master/"
"Data/uploadinfo.ini").read()
open("{}/uploadinfo.ini".format(temp_path), "w").write(
update_file)
config_update = ConfigParser()
config_update.read("{}/uploadinfo.ini".format(temp_path))
info_list_update = []
new_version_program = \
config_update.getfloat("info_update", "new_version_program")
updated_files_program = \
eval(config_update.get("info_update", "updated_files_program"))
dict_official_plugins_program = \
config_update.items("plugin_update")
official_plugins_program = dict(dict_official_plugins_program)
install_user_plugins = self.started_plugins
current_version_program = __version__
if platform != "android":
print("Проверка версии программы ...")
print("Проверка актуальности плагинов ...")
for plugin in install_user_plugins.keys():
try:
info_official_plugin = eval(official_plugins_program[plugin])
if info_official_plugin[plugin]['plugin-version'] > \
install_user_plugins[plugin]['plugin-version']:
info_list_update.append(info_official_plugin)
if platform != "android":
print("Плагин '{}' обновился до версии '{}'!".format(
plugin, info_official_plugin[plugin][
'plugin-version']))
except KeyError:
continue
if platform != "android":
print("Проверка обновлений завершена ...")
print("------------------------------------")
print()
if len(info_list_update) or new_version_program > \
current_version_program:
self.update = True
if platform != "android":
print("Доступны обновления!")
print("------------------------------------")
print()
else:
if platform != "android":
print("Обновлений нет!")
print("------------------------------------")
print()
def set_password(self):
"""Установка данных пользователя."""
def write_password(data):
_user_reg = {"login": data[0].encode("hex"),
"password": data[1].encode("hex")}
self.open_dialog = False
# Если данные не введены.
if _user_reg["login"] == "" or _user_reg["password"] == "":
return
else:
self.config.set("General", "user_reg", _user_reg)
self.config.write()
self.user_reg["login"] = data[0]
self.user_reg["password"] = data[1]
registration_form.body.dismiss()
self.Clock.schedule_once(lambda *args: self.connect(args), 0.2)
self.open_dialog = True
registration_form = \
self.create_window(callback=write_password, size_x=self.CONST_SCREEN,
text=core.string_lang_input_password, password=True,
button_ok=core.string_lang_yes, param="logpass")
def parse_text(self, html_text):
"""Маркировка в тексте ссылок, спойлеров, программного кода.
Returns: (str, dict);
- отмаркерованый текст страницы;
- {'адрес_ссылки': 'имя ссылки', ...};
"""
def replace(text):
parse_text = text.replace(
"** ", "**", 1)
parse_text = parse_text.replace(
" **", "**", 1)
parse_text = parse_text.replace(
"-------------", "\n-------------\n")
parse_text = parse_text.replace(
"======================", "\n======================\n")
parse_text = parse_text.replace(
"======================", "#-----------SEPARATOR")
parse_text = parse_text.replace(
"============", "#-----------SEPARATOR")
parse_text = parse_text.replace(
"<![CDATA[", "")
parse_text = parse_text.replace(
"{}{}{}".format(
core.mark_tag["refs"][0], core.string_lang_show_comments,
core.mark_tag["refs"][1]),
"-------------\n{}{}{}".format(
core.mark_tag["refs"][0],
core.string_lang_show_comments,
core.mark_tag["refs"][1]))
parse_text = parse_text.replace("\t", "").strip()
return parse_text
text = TextMarker(core.mark_tag["refs"], core.mark_tag["spoiler"],
core.mark_tag["code"], core.mark_tag["scr"],
core.language_code, html_text)
text_with_mark_scr = text.mark_image(html_text.encode("utf-8"))
text_with_mark_code = text.mark_code(text_with_mark_scr)
text_with_mark_links = text.mark_links(text_with_mark_code)
parse_message = html_parser(text_with_mark_links)
text_with_mark_spoilers = text.mark_spoilers(parse_message)
parse_text = replace(text_with_mark_spoilers)
return parse_text, text.dict_link, text.dict_link_scr
def set_screen_message_viewer(self, name_screen, text_for_screen,
list_links, list_links_scr, build_pages,
flag, dict_info=None, events_callback=None,
load_scr=True):
"""Открывает новый экран MessageViewer."""
if not dict_info:
dict_info = {}
background = "Data/Images/background.png"
list_text_button = [self.core.string_lang_answer_on_mail,
self.core.string_lang_delete,
self.core.string_lang_in_archive]
background_code = [0.06666666666666667, 0.0784313725490196,
0.08235294117647059, 1.0]
foreground_code = [0.43137254901960786, 0.49019607843137253,
0.5686274509803921, 1.0]
border_code = [1.0, 0.7725490196078432, 0.09803921568627451, 1.0]
message_viewer = self.MessageViewer(
event_callback=events_callback,
text_message=text_for_screen,
load_scr=load_scr,
spoilers_mark_tag=core.mark_tag["spoiler"],
code_mark_tag=core.mark_tag["code"],
links_mark_tag=core.mark_tag["refs"],
scr_mark_tag=core.mark_tag["scr"],
message_links=dict(list_links),
message_links_scr=list_links_scr,
forum=flag, dict_info=dict_info,
list_text_button=list_text_button,
background_code=background_code,
foreground_code=foreground_code,
border_code=border_code,
size_hint=(.9, .89),
number_page=build_pages,
background=background,
button_add_answer_background_normal="Data/Images/button_blue.png",
button_add_answer_background_down="Data/Images/button_orange.png",
text_button_add_answer=self.core.string_lang_add_answer_in_forum)
if flag != "mail":
screen = self.Screen(name=name_screen)
screen.add_widget(message_viewer)
self.screen.screen_manager.add_widget(screen)
self.screen.screen_manager.transition = self.FadeTransition()
self.screen.screen_manager.current = name_screen
self.screen.action_previous.title = name_screen
return message_viewer
def scan_new_messages(self, interval):
messages = get_page(core.api.NUMBER_UNREAD_MESS, self.cookie)
if messages:
total_unread_messages = \
core.dict_search_templates["unread"].findall(messages)[0]
if int(total_unread_messages) > int(self.resmessages):
self.resmessages = total_unread_messages
self.alert_new_messages(total_unread_messages)
self.config.set("General", "resmessages",
total_unread_messages)
self.config.write()
def alert_new_messages(self, total_unread_messages):
self.beep.play()
self.create_window(text=core.string_lang_new_messages.format(
total_unread_messages))
def show_license(self, *args):
def show_license(progress, on_language):
text_license = open("LICENSE/GNU_LICENSE_{}.rst".format(
core.dict_language[on_language])).read()
message = KDialog(underline_color="a6b4bcff",
base_font_size=self.window_text_size,
background_image=core.theme_decorator_window)
message.show(title="GNU_LICENSE:", text=text_license, rst=True,
size_rst=(.9, .7))
progress.body.dismiss()
if len(args) > 1: # выбраны ссылки в тексте
click_link = args[1]
webbrowser.open(click_link)
return
else:
on_language = args[0] # кнопки 'На русском/На английском'
progress = self.create_window(text=core.string_lang_wait)
Clock.schedule_once(lambda *args: show_license(progress, on_language),2)
def show_about(self):
def events_callback(instance_label, text_link):
def answer_callback(answer):
if answer in [core.string_lang_click_dimonvideo_redirect,
core.string_lang_click_ptyhon_redirect,
core.string_lang_click_kivy_redirect]:
webbrowser.open(answer.replace("www.", r"http:\\"))
if text_link in ["HeaTTheatR", "Virtuos86", "dimy44"]:
Clock.schedule_once(
lambda *args: self.send_mail_or_show_profile(text_link),
0.1)
else:
self.create_window(
callback=answer_callback, param="query",
text=core.text_for_about[text_link]["text"],
button_ok=core.text_for_about[text_link]["ok"],
button_cancel=core.text_for_about[text_link]["cancel"])
AboutDialog(events_callback=events_callback,
background_image=core.theme_decorator_window,
name_program=core.string_lang_about_name_program,
logo_program="Data/Images/logo.png",
info_program=core.info_program)
class keepupthepaceMD(MDApp):
title = 'keepupthepaceMD'
icon = 'icon.png'
nav_drawer = properties.ObjectProperty()
lang = properties.StringProperty('en')
#load saved profiles and instantiate the default one
listofprofiles, myProfile = persistence.getDefaultProfileFromShelf()
# define the properties that will be updated in the user interface
knbmi = properties.StringProperty('0')
kbbmi = properties.StringProperty('0')
krmr1918 = properties.StringProperty('0')
krmr1984 = properties.StringProperty('0')
krmr1990 = properties.StringProperty('0')
krmrml1918 = properties.StringProperty('0')
krmrml1984 = properties.StringProperty('0')
krmrml1990 = properties.StringProperty('0')
khbe1918 = properties.StringProperty('0')
khbe1984 = properties.StringProperty('0')
khbe1990 = properties.StringProperty('0')
kqfp = properties.StringProperty('0')
kefp = properties.StringProperty('0')
# initialize a profile to test the app, if none loaded
if not (isinstance(myProfile, profile.Profile)):
myProfile = profile.Profile('not coming from shelf')
myProfile.isdefault = True
myProfile.age = 35
myProfile.gender = enumandconst.Gender.FEMALE
myProfile.weightIntegerPart = 60
myProfile.weightDecimalPart = 0
myProfile.heightIntegerPart = 1
myProfile.heightDecimalPart = 68
myProfile.metricChoice = enumandconst.MetricChoice.ISO
myProfile.computeAll()
else:
myProfile.computeAll()
# initialize all the MET tables
bicycling = c01.Bicycling
conditionningExercises = c02.ConditionningExercises
dancing = c03.Dancing
fishingHunting = c04.FishingHunting
homeActivity = c05.HomeActivity
homeRepair = c06.HomeRepair
inactivity = c07.Inactivity
lawnGarden = c08.LawnGarden
miscellaneous = c09.Miscellaneous
musicPlaying = c10.MusicPlaying
occupation = c11.Occupation
running = c12.Running
selfcare = c13.SelfCare
sexualActivity = c14.SexualActivity
sports = c15.Sports
transportation = c16.Transportation
walking = c17.Walking
waterActivities = c18.WaterActivities
winterActivites = c19.WinterActivities
religiousActivities = c20.ReligiousActivities
volunteeractivities = c21.VolunteerActivities
def __init__(self, **kvargs):
super(keepupthepaceMD, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.exit_interval = False
self.gender_menu = None
self.dict_language = literal_eval(
open(os.path.join(self.directory, 'data', 'locales',
'locales.txt')).read())
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'data',
'locales'))
self.listOfMetTables = [
self.translation._('01-Bicycling'),
self.translation._('02-Conditionning Exercises'),
self.translation._('03-Dancing'),
self.translation._('04-Fishing & Hunting'),
self.translation._('05-Home Activity'),
self.translation._('06-Home Repair'),
self.translation._('07-Inactivity'),
self.translation._('08-Lawn Garden'),
self.translation._('09-Miscellaneous'),
self.translation._('10-Music Playing'),
self.translation._('11-Occupation'),
self.translation._('12-Runing'),
self.translation._('13-Self Care'),
self.translation._('14-Sexual Activity'),
self.translation._('15-Sports'),
self.translation._('16-Transportation'),
self.translation._('17-Walking'),
self.translation._('18-Water Activities'),
self.translation._('19-Winter Activities'),
self.translation._('20-Religious Activities'),
self.translation._('21-Volunteer Activities')
]
def get_application_config(self):
return super(keepupthepaceMD, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
config.adddefaultsection('General')
config.setdefault('General', 'language', 'en')
def set_value_from_config(self):
self.config.read(os.path.join(self.directory, 'keepupthepacemd.ini'))
self.lang = self.config.get('General', 'language')
def build(self):
LabelBase.register(name="Arial", fn_regular="Arial.ttf")
theme_font_styles.append('Arial')
self.theme_cls.font_styles["Arial"] = [
"Arial",
16,
False,
0.15,
]
self.set_value_from_config()
self.load_all_kv_files(
os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen()
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def refreshValuesToDisplayOnScreen(self):
'''
Refresh the values to display whenever it's needed
'''
self.kbbmi = self.myProfile.displaybBMI()
self.knbmi = self.myProfile.displaynBMI()
self.krmr1918, self.krmr1984, self.krmr1990 = self.myProfile.displayRMR(
)
self.krmrml1918, self.krmrml1984, self.krmrml1990 = self.myProfile.displayRMRml(
)
self.khbe1918, self.khbe1984, self.khbe1990 = self.myProfile.displayHBE(
)
self.kqfp, self.kefp = self.myProfile.displayFAT()
def doThingsBetweenScreen(self):
'''
save profiles when leaving some selectted tabs
'''
self.myProfile.computeAll()
persistence.saveprofiles()
self.refreshValuesToDisplayOnScreen()
def on_stop(self):
persistence.saveprofiles()
def on_pause(self):
persistence.saveprofiles()
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
def events_program(self, instance, keyboard, keycode, text, modifiers):
if keyboard == 27:
if self.nav_drawer.state == 'open':
self.nav_drawer.toggle_nav_drawer()
self.back_screen(event=keyboard)
return True
def back_screen(self, event=None):
if event == 27:
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.doThingsBetweenScreen()
self.manager.current = self.list_previous_screens.pop()
except:
self.manager.current = 'base'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
def show_metrics(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'metrics'
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
self.screen.ids.action_bar.right_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_onelist(self, *args):
self.list_previous_screens.append('compendiumlist')
self.manager.current = 'onelist'
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
self.screen.ids.action_bar.right_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_compendium(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'compendiumlist'
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
self.screen.ids.action_bar.right_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.about.ids.label.text = \
self.translation._(
u'[size=20][b]keepupthepaceMD[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT\n\n'
u'[size=20][b]Developer[/b][/size]\n\n'
u'[ref=SITE_PROJECT]'
u'[color={link_color}]NAME_AUTHOR[/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=REPO_PROJECT]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
self.screen.ids.action_bar.right_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_license(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.license.ids.text_license.text = \
self.translation._('%s') % open(
os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
self.manager.current = 'license'
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer.toggle_nav_drawer()]]
self.screen.ids.action_bar.right_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
self.screen.ids.action_bar.title = \
self.translation._('MIT LICENSE')
def select_locale(self, *args):
def select_locale(name_locale):
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(Lists(dict_items=dict_info_locales,
events_callback=select_locale,
flag='one_select_check'),
size=(.85, .55))
self.window_language.open()
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
class Migren(App):
title = 'Дневник головной боли'
icon = 'icon.png'
nav_drawer = ObjectProperty()
theme_cls = ThemeManager()
theme_cls.primary_palette = 'Grey'
lang = StringProperty('en')
def __init__(self, **kvargs):
super(Migren, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.soft_input_mode = 'below_target'
self.list_previous_screens = ['base']
self.window = Window
self.plugin = ShowPlugins(self)
self.config = ConfigParser()
self.manager = None
self.window_language = None
self.exit_interval = False
self.dict_language = literal_eval(
open(
os.path.join(self.directory, 'data', 'locales', 'locales.txt')).read()
)
self.translation = Translation(
self.lang, 'Ttest', os.path.join(self.directory, 'data', 'locales')
)
def get_application_config(self):
return super(Migren, self).get_application_config(
'{}/%(appname)s.ini'.format(self.directory))
def build_config(self, config):
config.adddefaultsection('General')
config.setdefault('General', 'language', 'en')
def set_value_from_config(self):
self.config.read(os.path.join(self.directory, 'migren.ini'))
self.lang = self.config.get('General', 'language')
def build(self):
self.set_value_from_config()
self.load_all_kv_files(os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen()
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def load_all_kv_files(self, directory_kv_files):
for kv_file in os.listdir(directory_kv_files):
kv_file = os.path.join(directory_kv_files, kv_file)
if os.path.isfile(kv_file):
with open(kv_file, encoding='utf-8') as kv:
Builder.load_string(kv.read())
def events_program(self, instance, keyboard, keycode, text, modifiers):
if keyboard in (1001, 27):
if self.nav_drawer.state == 'open':
self.nav_drawer.toggle_nav_drawer()
self.back_screen(event=keyboard)
elif keyboard in (282, 319):
pass
return True
def back_screen(self, event=None):
if event in (1001, 27):
if self.manager.current == 'base':
self.dialog_exit()
return
try:
self.manager.current = self.list_previous_screens.pop()
except:
self.manager.current = 'base'
self.screen.ids.action_bar.title = self.title
self.screen.ids.action_bar.left_action_items = \
[['menu', lambda x: self.nav_drawer._toggle()]]
def add_note(self, *args):
#self.screen.ids.base.add_name_previous_screen()
#self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'note'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def add_note2(self, *args):
#self.screen.ids.base.add_name_previous_screen()
#self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'note2'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def add_note3(self, *args):
#self.screen.ids.base.add_name_previous_screen()
#self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'note3'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def show_diary(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.manager.current = 'diary'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
def send_email(self, *args):
addr_from = "*****@*****.**" # Отправитель
password = "******" # Пароль
msg = MIMEMultipart() # Создаем сообщение
msg['From'] = addr_from # Адресат
msg['To'] = self.screen.ids.diary.ids.mail_to.text # Получатель
msg['Subject'] = self.screen.ids.diary.ids.theme.text # Тема сообщения
users_name = self.screen.ids.diary.ids.user_name.text.replace(' ', '_')
name = 'diary.xls'
filepath = os.path.join(os.getcwd(), name)
filename = os.path.basename(filepath)
if os.path.isfile(filepath):
rb = xlrd.open_workbook(filepath, formatting_info=True)
wb = copy(rb)
wb.save(users_name+'_diary.xls')
os.remove(filepath)
name = users_name+'_diary.xls'
filepath = os.path.join(os.getcwd(), name)
filename = os.path.basename(filepath)
body = 'Дневник головной боли:\n\nПациент: '+ self.screen.ids.diary.ids.user_name.text + '\n'+\
'Комментарий пациента: ' + self.screen.ids.diary.ids.comment.text + '\n\n' +\
'Адресс для обратной связи: ' + self.screen.ids.diary.ids.add_mail.text # Текст сообщения
msg.attach(MIMEText(body, 'plain')) # Добавляем в сообщение текст
if os.path.isfile(filepath): # Если файл существует
ctype, encoding = mimetypes.guess_type(filepath) # Определяем тип файла на основе его расширения
if ctype is None or encoding is not None: # Если тип файла не определяется
ctype = 'application/octet-stream' # Будем использовать общий тип
maintype, subtype = ctype.split('/', 1) # Получаем тип и подтип
with open(filepath, 'rb') as fp:
file = MIMEBase(maintype, subtype) # Используем общий MIME-тип
file.set_payload(fp.read()) # Добавляем содержимое общего типа (полезную нагрузку)
fp.close()
encoders.encode_base64(file) # Содержимое должно кодироваться как Base64
file.add_header('Content-Disposition', 'attachment', filename=filename) # Добавляем заголовки
msg.attach(file) # Присоединяем файл к сообщению
server = smtplib.SMTP_SSL('smtp.yandex.ru', 465) # Создаем объект SMTP
server.login(addr_from, password) # Получаем доступ
server.send_message(msg) # Отправляем сообщение
server.quit() # Выходим
rb = xlrd.open_workbook(filepath, formatting_info=True)
wb = copy(rb)
wb.save(users_name+'_old_diary.xls')
self.create_new_table(name)
toast(self.translation._('Дневник отправлен'))
self.screen.ids.diary.ids.mail_to.text = ''
self.screen.ids.diary.ids.theme.text = ''
self.screen.ids.diary.ids.comment.text = ''
def create_new_table(self, name, *args):
font0 = xlwt.Font()
font0.name = 'Times New Roman'
font0.bold = True
style0 = xlwt.XFStyle()
style0.font = font0
style1 = xlwt.XFStyle()
style1.num_format_str = 'D-MMM-YY'
sheet = str(datetime.now())
sheet = sheet[0:10]
wb = xlwt.Workbook()
ws = wb.add_sheet(sheet)
Col = ws.col(0)
Col.width = 256 * 21
ws.write(0, 0, 'Дата и время', style0)
Col = ws.col(1)
Col.width = 256 * 41
ws.write(0, 1, 'Тип боли', style0)
Col = ws.col(2)
Col.width = 256 * 41
ws.write(0, 2, 'Локализация боли', style0)
Col = ws.col(3)
Col.width = 256 * 23
ws.write(0, 3, 'Продолжительность боли', style0)
Col = ws.col(4)
Col.width = 256 * 65
ws.write(0, 4, 'Комментарий пациента', style0)
wb.save(name)
def show_plugins(self, *args):
self.plugin.show_plugins()
def show_about(self, *args):
self.nav_drawer.toggle_nav_drawer()
self.screen.ids.about.ids.label.text = \
self.translation._(
u'[size=20][b]PyConversations[/b][/size]\n\n'
u'[b]Version:[/b] {version}\n'
u'[b]License:[/b] MIT\n\n'
u'[size=20][b]Developer[/b][/size]\n\n'
u'[ref=SITE_PROJECT]'
u'[color={link_color}]Pechka and Bomj[/color][/ref]\n\n'
u'[b]Source code:[/b] '
u'[ref=https://github.com/NikolaevVR/Migrebot]'
u'[color={link_color}]GitHub[/color][/ref]').format(
version=__version__,
link_color=get_hex_from_color(self.theme_cls.primary_color)
)
self.manager.current = 'about'
self.screen.ids.action_bar.left_action_items = \
[['chevron-left', lambda x: self.back_screen(27)]]
# def show_license(self, *args):
# self.screen.ids.license.ids.text_license.text = \
# self.translation._('%s') % open(
# os.path.join(self.directory, 'LICENSE'), encoding='utf-8').read()
# self.nav_drawer._toggle()
# self.manager.current = 'license'
# self.screen.ids.action_bar.left_action_items = \
# [['chevron-left', lambda x: self.back_screen()]]
# self.screen.ids.action_bar.title = \
# self.translation._('MIT LICENSE')
# self.screen.ids.action_bar.left_action_items = \
# [['chevron-left', lambda x: self.back_screen(27)]]
def select_locale(self, *args):
def select_locale(name_locale):
for locale in self.dict_language.keys():
if name_locale == self.dict_language[locale]:
self.lang = locale
self.config.set('General', 'language', self.lang)
self.config.write()
dict_info_locales = {}
for locale in self.dict_language.keys():
dict_info_locales[self.dict_language[locale]] = \
['locale', locale == self.lang]
if not self.window_language:
self.window_language = card(
Lists(
dict_items=dict_info_locales,
events_callback=select_locale, flag='one_select_check'
),
size=(.85, .55)
)
self.window_language.open()
def dialog_exit(self):
def check_interval_press(interval):
self.exit_interval += interval
if self.exit_interval > 5:
self.exit_interval = False
Clock.unschedule(check_interval_press)
if self.exit_interval:
sys.exit(0)
Clock.schedule_interval(check_interval_press, 1)
toast(self.translation._('Press Back to Exit'))
def on_lang(self, instance, lang):
self.translation.switch_lang(lang)
