def login_worker(self, loginText, passwordText):
url = host + 'oauth/token'
app = App.get_running_app()
app.username = loginText
app.password = passwordText
response = post(url,
data={
'username':
app.username,
'password':
app.password,
'grant_type':
'password',
'client_id':
2,
'client_secret':
'XEh8Q8JKmOvTNX2g7QXtrRLzwSO1XQuWpge04zRB'
})
rj = response.json()
if response.status_code is not 200:
self.resetForm()
self.ids['status'].text = rj.get('message')
else:
Config.read('xenon.ini')
Config.set('auth', 'access_token', rj.get('access_token'))
Config.set('auth', 'refresh_token', rj.get('refresh_token'))
Config.write()
self.manager.current = 'connected'
return
def get_general_conf(name):
Config = configparser.ConfigParser()
Config.read('./conf/config.conf')
myprior = {}
for sec in Config.sections():
if sec == name:
myprior = ConfigSectionMap(sec, Config)
return myprior
def on_start(self):
Config.read(self.get_application_config())
config_file_version = \
int(Config.getdefault('General', 'config_version', 0))
if config_file_version < self.config_version:
self.config.write()
self.osc_service = OSCClient(self)
def SysInit(self):
BASEPATH = ''
userSystem = platform.system()
Logger.info('SYS_INFO: system %s' % str(platform.uname()))
if userSystem == 'Window':
pass
elif userSystem == 'Linux': #and re.search('arm',platform.machine())!=None:
#basepath
if getattr(sys, 'frozen', False):
BASEPATH = os.path.dirname(sys.executable) + '/'
else:
BASEPATH = ''
self.sysArgs['BASEPATH'] = BASEPATH
#filepath
self.sysArgs['FILEPATH'] = os.path.abspath('..') + '/'
#size
self.sysArgs['WIDTH'] = Window.width
self.sysArgs['HEIGHT'] = Window.height
#open shortcut
self.sysArgs['DESKTOP'] = False
#keyboard mode
Window.softinput_mode = 'below_target'
else: #elif userSystem=='Darwin':
#basepath
if getattr(sys, 'frozen', False):
BASEPATH = os.path.dirname(sys.executable) + '/'
else:
BASEPATH = ''
self.sysArgs['BASEPATH'] = BASEPATH
#file path
filepath = os.path.expanduser('~') + '/.DaytimeLog'
if not os.path.exists(filepath):
os.mkdir(filepath)
self.sysArgs['FILEPATH'] = filepath + '/'
#window size
Window.size = 375, 667
self.sysArgs['WIDTH'] = kivy.metrics.dp(375)
self.sysArgs['HEIGHT'] = kivy.metrics.dp(667)
#open shortcut
self.sysArgs['DESKTOP'] = True
Logger.info('SYS_INFO: shortcut %s' % str(self.sysArgs['DESKTOP']))
#database
self.dataBase = DBDaytimeLog(self.sysArgs['FILEPATH'])
self.sysArgs['DB'] = self.dataBase
#ScreenManager
self.screenManager = MyScreenManager(transition=NoTransition())
self.sysArgs['SM'] = self.screenManager
#window
self.sysArgs['WINDOW'] = Window
#config file
Config.read(BASEPATH + 'includes/config.ini')
#config logs
Config.set('kivy', 'log_dir', self.sysArgs['FILEPATH'])
#config logo
#Config.set('kivy','window_icon', BASEPATH+'includes/icons/DaytimeLog.png')
self.icon = 'includes/icons/DaytimeLog.png'
def main() :
try :
current_path, current_file= os.path.split( __file__ )
cfg_filename= os.path.normpath( os.path.join( current_path, './SpaceshipSim.ini' ) )
Config.read( cfg_filename )
if __name__ == '__android__' :
Config.set( 'graphics', 'fullscreen', 'auto' )
SpaceshipSim().run()
except Exception, e :
Logger.exception( str( e ) )
raise
def on_enter(self, *args):
Config.read("xenon.ini")
if Config.get('app', 'datadir') is '':
appdata = Path(environ['APPDATA'] + '/StepMania 5')
if appdata.exists():
Config.set('app', 'datadir', appdata)
Config.write()
else: # user has provided their own folder
pass
if Config.get('app', 'sm5dir') is '':
self.settings()
def get_settings(keys, section='General'):
Config.read(SETTINGS_FILE)
results = {}
if not type(keys) in (list, tuple):
keys = (keys, )
for key in keys:
try:
results[key] = Config.get(section, key)
except (NoSectionError, NoOptionError):
results[key] = None
return results if len(results) > 1 else results[keys[0]]
def build(self):
Window.clearcolor = (0.333, 0.466, 0.2, 1)
self.icon = 'icon.png'
manager = ScreenManager()
manager.add_widget(Login(name='login'))
manager.add_widget(Connected(name='connected'))
manager.add_widget(Initializing(name='initializing'))
manager.add_widget(Settings(name='settings'))
manager.add_widget(SubmitScores(name='submitscores'))
Config.read('xenon.ini')
if Config.get('auth', 'access_token') is not '0':
manager.transition = NoTransition()
manager.current = 'initializing'
return manager
def load_settings(self, **kwargs):
"""Load graphics configuration settings. Does not actually apply settings.
filename - optional string argument. This will try to open the file with that filename instead.
If no argument is used, the function will use the built-in Kivy configuration (or default values if it can't be found.)
"""
# Open the config file for reading.
self.config_filename = kwargs.get('filename', None)
if self.config_filename:
Config.read(self.config_filename)
# If a file wasn't used, use Kivy's Config object, or use a default if it isn't found.
self.temporary_fullscreen = Config.getdefault('graphics', 'fullscreen',
'auto')
class KnitCount(App):
icon = 'icon.png'
title = "Knit Counter :: by Doyousketch2"
Config.read('config.ini')
row = Config.getint('settings', 'row')
rowstr = str(row)
def build(self):
pass
def build(self, *args, **kwargs):
self.draw_fps = True
self.fps = Fps()
self.time = 0.
self.last_time = 0.
self.time_mult = 1.
self.time_mult_pause = None
Clock.schedule_interval(self.update, 0)
self.event_once = None
self.root = Space()
Config.read('config.ini')
# For my window header
# dx, dy = -1, -32
dx, dy = 0, 0
if Config.get('graphics', 'position') != 'auto':
Window.left, Window.top, Window.size = Config.getint('graphics', 'left') + dx, \
Config.getint('graphics', 'top') + dy, \
(Config.getint('graphics', 'width'), \
Config.getint('graphics', 'height'),)
if Config.getboolean('graphics', 'maximize'):
Window.maximize()
Window.show()
self.root.bind(on_touch_down=self.on_touch_down,
on_touch_move=self.on_touch_move,
on_touch_up=self.on_touch_up)
if self.filename:
Clock.schedule_once(
partial(
import_module(self.filename).set_state, self.root, self),
1)
return self.root
def load_default_config(from_file=False):
Config.window_icon = path.join(getcwd(), 'data/images/icon.png')
Config.set('kivy', 'exit_on_escape', '0')
Config.set('graphics', 'resizable', '0')
try:
Logger.info('[MachineWerkz] setting defaults')
default_config = {
'fx_folder': path.join(getcwd(), 'data/audio/fx'),
'music_folder': path.join(getcwd(), 'data/audio/music'),
'cols': "10",
'rows': "18",
'square_unit': "50"
}
except Exception as e:
raise e
square_unit = int(default_config['square_unit'])
rows = int(default_config['rows'])
cols = int(default_config['cols'])
ini = path.join(getcwd(), 'machinewerkz.ini')
if path.isfile(ini) and from_file is True:
Config.read(ini)
Logger.info('[MachineWerkz] loading configuration')
music_folder = Config.get('machinewerkz', 'music_folder')
playlist = music_list(music_dir=music_folder)
fx = fx_dict(Config.get('machinewerkz', 'fx_folder'))
rows = int(Config.get('machinewerkz', 'rows'))
cols = int(Config.get('machinewerkz', 'cols'))
else:
playlist = music_list(default_config['music_folder'])
fx = fx_dict(default_config['fx_folder'])
return {
'square_unit': square_unit,
'rows': rows,
'cols': cols,
'music': playlist,
'fx': fx
}
def load(self, filename):
for k, v in self.__defaults.items():
self.config.setdefaults(k, v)
self.config.read(filename)
self.config.write()
Config.read(filename)
Logger.info('Settings: Loaded setting file: %s', filename)
Logger.debug('Settings: Setting up panel')
self.panel = self.widget.create_json_panel('Settings',
self.config,
data=self.windgetconfigdata)
self.widget.children[0].add_widget(self.panel)
Logger.debug('Settings: Setting options')
self.setPanelOptions('port', SerialAdapter.getPortNames())
self.setPanelOptions('bytesize', SerialAdapter.BYTESIZE.keys())
self.setPanelOptions('parity', SerialAdapter.PARITY.keys())
self.setPanelOptions('stopbits', SerialAdapter.STOPBITS.keys())
def build(self):
Config.read('config.ini')
Config.get('kivy', 'keyboard_mode')
Config.get('graphics', 'width')
Config.get('graphics', 'height')
Config.get('graphics', 'resizable')
Config.get('graphics', 'fullscreen')
self.theme_cls.theme_style = Config.get('theme', 'style')
self.theme_cls.primary_palette = Config.get('theme', 'palette')
Config.write()
#self.theme_cls.theme_style = 'Light'
#self.theme_cls.primary_palette = 'Blue'
self.screen = MainScreen()
#Permets de definir le nom de la fenetre
self.title = 'eXode'
return self.screen
def build(self):
#load kv file
Builder.load_file('layout/sns.kv')
Builder.load_file('layout/sns_popup.kv')
Builder.load_file('layout/channel_view.kv')
Builder.load_file('layout/scrollLayoutView.kv')
Builder.load_file('layout/channel_list_layout.kv')
Builder.load_file('layout/post_status.kv')
self.sns = SNS(name='sns')
#self.channel = Channel(name='channel')
#self.sns.snsdata.append({'content':"Hi", 'title':'Testing1'})
self.load_channel()
self.transition = SlideTransition(duration=.35)
root = ScreenManager(transition=self.transition)
root.add_widget(self.sns)
Config.read('config.ini')
Config.set('graphics', 'height','1280')
Config.set('graphics', 'width','720')
Config.set('kivy','log_level','debug')
Config.set('kivy','log_dir','logs')
Config.set('kivy','log_enable ','1')
Config.set('kivy','log_name','kivy_%y-%m-%d_%_.txt')
Config.write()
self.choose_status_index = 0
Clock.schedule_interval(self.sns.save_status_feedback,5)
time.clock()
#for s in sp.home_timeline(10):
#self.sns.insert_status(s)
return root
def setup_base():
from kivy.config import Config
Config.read(os.environ['KIVY_CONFIG_FILE'])
for i in os.listdir("logs"):
if os.path.isfile(os.path.join(Config.get("kivy", "log_dir"), i)) and 'kivy' in i:
os.remove(os.path.join(Config.get("kivy", "log_dir"), i))
from kivy.logger import Logger
Logger.info(globals.baseSysConfig.get("main", "name") + ": " + globals.baseSysConfig.get("main", "parent_name") +
"'s logger has been setup")
from kivy.lang.builder import Builder
Builder.load_file(os.path.join(globals.baseSysPath, "HexOSBase/data/kv_files/window.kv"))
Logger.info(globals.baseSysConfig.get("main", "parent_name") + ": window.kv has loaded")
if not os.path.exists(globals.HexOSPath):
Logger.error("HexOSBase: HexOS is not installed, queuing install")
Clock.schedule_once(lambda *args: os_changes.install(), 0)
elif globals.baseSysConfig.get("HexOS", "test_os"):
Clock.schedule_once(lambda *args: os_changes.try_update_for_testing(), 0)
import configparser
config = configparser.ConfigParser()
config.read('./config/global-config.ini')
private_config = configparser.ConfigParser()
private_config.read('./config/private-config.ini')
from kivy.config import Config
Config.read(config['kivy']['config_file'])
import sys
import settings
# Environment festlegen
env = sys.argv[1] if len(sys.argv) > 1 else 'raspberrypi'
# Environment in globale Liste schreiben
settings.myList["env"] = env
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.popup import Popup
from kivy.uix.label import Label
from kivy.uix.image import Image
from kivy.clock import mainthread
from kivy.core.window import Window #Für Keyboard Shortscuts
import _shared.data as data
import configparser
cparser = configparser.ConfigParser()
cparser.read(['default_config.ini', 'config.ini'])
def print(*text):
if len(text) == 0:
text = ['']
Logger.debug(f'{__file__}: {" ".join(str(text))}')
data.init('client')
Config.read(os.path.join(cparser.get('directories', 'client'), 'kivy.ini'))
style = Builder.load_file(
os.path.join(cparser.get('directories', 'client'), 'style.kv'))
sm = ScreenManager(transition=NoTransition())
keys = [
'q,w,e,r,t,z,u,i,o,p', 'a,s,d,f,d,g,h,j,k,l', 'y,x,c,v,b,n,m',
'.,@,del,SPEICHERN'
]
focused = None
times = {}
badge_ = None
user = None
itemlayout = None
registration_fields = None
timeout = None
from kivy.core.window import Window
import game_and_analysis_serialisation as serialisationWrapper
from kivy.config import Config
class MyChessApp(App):
def build(self):
return chesswindow.ChessWindow()
def on_start(self):
return super().on_start()
def on_stop(self):
self.stopThreads()
serialisationWrapper.saveGamesToDisk(self.root.controller.savedGames)
return super().on_stop()
def stopThreads(self):
if(self.root.boardGUI.hasEval()):
self.root.boardGUI.stopEval()
self.root.controller.evalWrapper.stop()
for analysis in self.root.controller.listAnalysis:
analysis.stop()
if __name__ == '__main__':
Config.read("config.ini")
Config.write()
Window.size = (1024, 768)
MyChessApp().run()
kivy.require('1.10.1')
from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.gridlayout import GridLayout
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.screenmanager import ScreenManager, Screen
from functools import partial
from kivy.lang import Builder
from kivy.core.window import Window
from kivy.uix.video import Video
#Configuration Files
from kivy.config import Config
Config.read('test.txt')
Config.set('kivy', 'exit_on_escape', '1')
Window.size = (1000, 65)
Config.set('graphics', 'position', 'custom')
Config.write()
#Make Dem Screens!!
Builder.load_string("""
<LoginScreen>:
BoxLayout:
TextInput:
id: login
TextInput:
id: passw
password: True
Button:
text: "Login"
import os
import sys
import urllib
from darksky import forecast
from kivy.app import App
from kivy.config import Config
from kivy.lang import Builder
from kivy.clock import Clock
from kivy.metrics import sp
from kivy.uix.widget import Widget
from kivy.uix.label import Label
from kivy.properties import (NumericProperty, ReferenceListProperty,
ObjectProperty)
Config.read('weather.config')
class MainWidget(Widget):
def __init__(self):
super(MainWidget, self).__init__()
self.get_location()
self.weather = forecast(Config.get('darksky', 'api_key'),
*self.location,
units=Config.get('darksky', 'units'))
def get_location(self):
mmdb_file = Config.get('geolite2', 'db')
if os.path.isfile(mmdb_file):
# get my IP
def start(self):
Clock.schedule_interval(self.update_am, 1)
def update_am(self, dt):
self.counter += 1
self.ids.lbl_am_counter.text = f'You have [b][size=30][color=18dc2c]' \
f'{self.counter}[/color][/size][/b] ' \
f'antimatter'
self.ids.lbl_am_sec_counter.text = f'You are getting [b]{self.counter}[/b] ' \
f'antimatter per second'
class RootWidget(ScreenManager):
def __init__(self, **kwargs):
super().__init__(**kwargs)
class IdleVisionApp(App):
def build(self):
return RootWidget()
if __name__ == '__main__':
# Load custom kivy config file
Config.read('config/kv-config.ini')
# Load Kivy template file
kv = Builder.load_file('kv-files/main.kv')
IdleVisionApp().run()
# Kivy版本号
kivy.require('1.11.1')
# ======================================== 查找文件 ========================================
# 查找文件
from common.util.yushirui_find_file_or_dir import yushirui_find_file_or_dir
# ======================================== 指定配置文件 ========================================
# 查找配置文件
config_path = yushirui_find_file_or_dir('config/kivy_config.ini')
# 读取配置，支持中文
from kivy.config import Config
# 读取配置文件
Config.read(config_path)
# ======================================== 设置字体 ========================================
# 查找字体文件
font_path = yushirui_find_file_or_dir('font/simkai.ttf')
# 设置字体
from kivy.core.text import LabelBase
# 注册字体
LabelBase.register('.', font_path)
# ======================================== 设置资源目录 ========================================
# 查找资源目录
resource_dir_path = yushirui_find_file_or_dir('res')
# 设置资源目录
from kivy.resources import resource_add_path
from kivy.uix.button import Button
from kivy.uix.slider import Slider
from kivy.uix.textinput import TextInput
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.widget import Widget
from kivy.uix.label import Label
from kivy.uix.anchorlayout import AnchorLayout
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.gridlayout import GridLayout
from functools import partial
import random
import mysql.connector
Config.read('3t.cfg')
class Cell(Button):
pos_x = 0
pos_y = 0
blocked = False
def __init__(self, p_x, p_y):
super(Cell, self).__init__()
self.pos_x = p_x
self.pos_y = p_y
class WinCond():
winner = ''
import site
import threading
import os, time
import traceback
import queue
from os.path import join, dirname
from subprocess import Popen
from kivy.config import Config
TESTING = "KGUI_TESTING" in os.environ
os.nice(10)
# Read custom Kivy config. This needs an absolute path otherwise
# config will only be loaded when working directory is the parent directory
if TESTING:
Config.read(join(dirname(__file__), "config_test.ini"))
else:
Config.read(join(dirname(__file__), "config.ini"))
os.environ['KIVY_WINDOW'] = 'sdl2'
os.environ['KIVY_GL_BACKEND'] = 'sdl2'
os.environ['KIVY_METRICS_DENSITY'] = str(Config.getint('graphics', 'width')/600)
from kivy import kivy_data_dir
from kivy.app import App
from kivy.base import ExceptionHandler, ExceptionManager
from kivy.clock import Clock
from kivy.config import Config
from kivy.lang import Builder
from kivy.properties import (OptionProperty, BooleanProperty, DictProperty,
NumericProperty, ListProperty, StringProperty)
from .elements import UltraKeyboard, CriticalErrorPopup, ErrorPopup
# Installed -------------------------------------------------------------------
from kivy.config import Config
from kivy.lang import Builder
from kivy.core.window import Window
from kivy.utils import get_color_from_hex
# Coded -----------------------------------------------------------------------
from respyratorgui import logapp, LOG_DIR, gui_colors, gui_imgs, gui_txts
#from respyratorgui.settings import LOG_DIR, logapp
#from respyratorgui.guiconfig import gui_colors, gui_imgs, gui_txts
# Program ---------------------------------------------------------------------
LOG = 'KIVYGUI:'
KIVY_DIR = Path(__file__).resolve().parents[0]
KIVY_CONFIG = KIVY_DIR / 'kivyconfig.ini'
if KIVY_CONFIG.exists():
Config.read(str(KIVY_CONFIG))
logapp.debug(f'{LOG} Kivy configuration completed')
# Remove all kivylogs .txt files
[kvlog.unlink() for kvlog in LOG_DIR.iterdir() if kvlog.suffix == '.txt']
else:
logapp.error(f'{LOG} Kivy not well configured')
# COLORs
colors = {k: get_color_from_hex(v) for k, v in gui_colors.items()}
# IMGs
imgs = gui_imgs
# TXTs
txts = gui_txts
# Background Window color
Window.clearcolor = colors['brand']
logapp.debug(f'{LOG} Window background to {Window.clearcolor}')
from kivy.config import Config
Config.read('e:\\config.ini')
Config.write()
import kivy
kivy.require('1.4.1')
from kivy.config import Config
Config.read('gol.ini')
Config.set('graphics', 'width', '256')
Config.set('graphics', 'height', '256')
from kivy.app import App
from kivy.clock import Clock
from kivy.core.window import Window
from board_widget import BoardWidget
from population import Population
class GameOfLifeApp(App):
_board = None
_population = None
def build(self):
self._population = Population(cols=256, rows=256)
self._board = BoardWidget(width=256, height=256, population = self._population)
Clock.schedule_interval(self.callback, 0.1)
return self._board
def callback(self, dt):
self._population.evolve()
self._board.update_graphics()
import os
import requests
from kivy.app import App
from kivy.config import Config
from kivy.core.window import Window
from kivy.uix.screenmanager import ScreenManager
from kivysrc.main_screen import MainScreen
from kivysrc.file_browser import AlertDialog
from settings import MAIN_SCREEN, APP_HEIGHT, APP_WIDTH, CHECK_URL
Config.read(os.path.expanduser('~/.kivy/config.ini'))
Config.set('graphics', 'resizeable', '0')
Config.set('graphics', 'width', str(APP_WIDTH))
Config.set('graphics', 'height', str(APP_HEIGHT))
Config.set('kivy', 'keyboard_mode', 'system')
Config.set('graphics', 'keyboard_mode', 'en_US')
Config.set('graphics', 'log_level', 'info')
Config.write()
Window.size = (int(APP_WIDTH), int(APP_HEIGHT))
class ImageConverterTool(App):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.main_screen = MainScreen(name=MAIN_SCREEN)
screens = [self.main_screen]
import datetime
from datetime import datetime
# from RPi import GPIO
# import automationhat
# On import les modules necessaires
import time
from time import sleep
import smtplib
import subprocess
import socket
from kivy.config import Config
Config.read("/home/pi/Downloads/config.ini")
Builder.load_file('screen.kv')
##############################################################
# Input Output Declaration
##############################################################
# if automationhat.is_automation_hat():
# automationhat.light.power.write(1)
# else:
# automationhat.light.power.write(0)
##################################################################
# Main Screen Manager
# Kivy imports
from kivy.app import App
from kivy.config import Config
from kivy.factory import Factory
from kivy.properties import ObjectProperty
# Kivy Widgets
from kivy.uix.image import Image
from kivy.uix.tabbedpanel import TabbedPanel
from kivy.uix.floatlayout import FloatLayout
# Others
import logging
from kivy.lang import Builder
logger = logging.getLogger(__name__)
Config.read('whitewater/config.ini')
class ViewApp(App):
background = ObjectProperty()
def build(self):
print('Building main view')
self.title = 'Whitewater'
self.background = Image(source='whitewater/background.png').texture
class Backdrop(FloatLayout):
""" Class on top of blackboard where the main control panel and buttons are
displayed. Unaffected by zoom/movement of the underlying scatter. """
play_button = ObjectProperty()
def __init__(self, grid_widget: GridWidget):
Config.read("config.ini")
super(TransportAppView, self).__init__()
self._update_callback = None
self._grid_widget = grid_widget
import kivy
from kivy.app import App
from kivy.uix.image import AsyncImage
from kivy.uix.gridlayout import GridLayout
from kivy.clock import Clock
from kivy.lang import Builder
import requests,sys
import os
from kivy.config import Config
from time import sleep
import brainz, getplaying
from kivy.loader import Loader
from kivy.properties import ObjectProperty
Config.read('config.ini')
Config.set('graphics', 'top', 660)
Config.set('graphics','left',1100)
Config.set('graphics', 'width', '500')
Config.set('graphics', 'height', '200')
Config.set('graphics', 'borderless', 'True')
Config.set('graphics','resizable',0)
Config.write()
output_filename = "scrobble-output.txt"
class MainLayout(GridLayout):
cols = 2
def __init__(self,**kwargs):
super(MainLayout,self).__init__(**kwargs)
self.img = 'unknown.png'
# kivy dependencies
from kivy.config import Config
Config.read('config.ini')
from kivy.app import App
from kivy.lang import Builder
from kivy.properties import ObjectProperty
from kivy.uix.boxlayout import BoxLayout
# project dependencies
from settings import *
from playerdata import PlayerData
from prepare import PrepareScene
from result import ResultScene
class TopLayout(BoxLayout):
scene = ObjectProperty(None)
# top layer(scene transitioning) buttons' event handlers
def show_prepare(self):
self._swich_scene(self.scene.prepare)
def show_lwin(self):
self._swich_scene(self.scene.lwin)
def show_draw(self):
self._swich_scene(self.scene.draw)
def show_rwin(self):
self._swich_scene(self.scene.rwin)
