def show_screen(self, name, mode="next"):
screenmanager = self.root
if mode == "next":
screenmanager.transition.direction = "left"
elif mode == "previous":
screenmanager.transition.direction = "right"
else:
raise Exception("Invalid show_screen mode")
if screenmanager.has_screen(name):
screenmanager.current = name
return False
screen = self.open_json(self.screen_json_path)[name]
path = relpath(screen["path"])
kv_path = join(path, screen["kv"])
exec(
f"from {self.path_to_import(path)}.{screen['py']} import {screen['cls']}"
)
Builder.load_file(kv_path)
screen_wid = eval(f"Factory.{screen['cls']}(name='{name}')")
screen_wid.bind(on_leave=self.unload_screen)
screenmanager.add_widget(screen_wid)
screenmanager.current = name
return True
def __init__(self, actor):
kv_path = os.path.join(os.path.dirname(__file__), 'view.kv')
Builder.load_file(kv_path)
super().__init__()
self.actor = actor
self.troops = {}
self.tiles = {}
self.map_modes = {
'faction': {},
'fertility': {},
}
self.current_map_mode = None
self.focus_center = (0, 0)
self.focus_radius = 5
self.console = Console(pos=self.pos,
height=self.height,
width=100,
size_hint=(None, None))
self.console.commands['exit'] = self.toggle_console
self.target = Target(pos=(0, 0))
self.target_anim = None
self.bind(size=self.on_size)
self.console.ids.input.bind(focus=self._con_open_keyboard)
self._open_keyboard()
Clock.schedule_once(lambda dt: self.center_camera())
def build(self):
Window.clearcolor = (1, 1, 1, 1)
Builder.load_file('main_screen.kv')
return BaseScreen()
def build(self):
for kv in [
"home", "lobby", "session", "config", "cfgsections", "widgets"
]:
Builder.load_file(kv + ".kv")
return Builder.load_file("app.kv")
def gen_screens(self):
self.root = BoxLayout()
self.root.add_widget(Builder.load_file(self.config['general']['kv_folder']\
+'left.kv'))
smwindow = Builder.load_file(self.config['general']['kv_folder']+\
'center.kv')
self.sm = ScreenManager(transition=NoTransition())
self.sm.add_widget(HomeScreen())
self.sm.add_widget(NewLabel())
self.sm.add_widget(AutoScan())
self.sm.add_widget(ItemLookup())
self.sm.add_widget(QuickLabel())
self.root.add_widget(self.sm)
self.sm.current = 'HomeScreen'
self.sm.get_screen("HomeScreen").bind(on_leave=self.leave_screen)
self.sm.get_screen("NewLabel").bind(on_leave=self.leave_screen)
self.sm.get_screen("AutoScan").bind(on_leave=self.leave_screen)
self.sm.get_screen("ItemLookup").bind(on_leave=self.leave_screen)
self.sm.get_screen("QuickLabel").bind(on_leave=self.leave_screen)
def __init__(self, db: DBMuziek, **kwargs):
for file in glob.glob(os.path.join(os.path.dirname(__file__), 'layouts', '*.kv')):
Builder.load_file(file)
super().__init__(**kwargs)
self._db = db
self.root = None
def __init__(self):
kv_path = os.path.join(os.path.dirname(__file__), 'game_setup.kv')
Builder.load_file(kv_path)
super().__init__(name='game_setup')
self.players = {}
self.add_player('test_player')
def __init__(self, **kwargs):
self.set_dirs()
kv_dir = self.dirs.get('kv_dir')
kv_file = os.path.join(kv_dir, self.kv_file)
if kv_file not in Builder.files:
Builder.load_file(kv_file)
super().__init__(**kwargs)
def read_modules(self, passed_ob):
path = Path("Modules/Windows")
files = os.listdir(path)
print(files)
modules = []
for current_file in files:
if not current_file[-3] == '.':
if not current_file == 'GuideLines.txt':
if not current_file == "__pycache__":
file_name = current_file[1:]
button_text = file_name.replace('_', ' ')
modules.append(str(file_name))
modulename = file_name + "Screens"
KVFile = str("Modules/Windows/{}/{}.kv").format(
current_file, file_name)
package = str("Modules.Windows.{}.{}").format(
current_file, modulename)
my_module = importlib.import_module(package)
Builder.load_file(KVFile)
EntryClass = getattr(my_module, modulename)
LoadScreen = EntryClass(name=modulename)
passed_ob.parent.add_widget(LoadScreen)
button = Button(text=button_text)
button.bind(on_press=partial(self.SwitchScreen,
passed_ob, modulename))
passed_ob.ids.ButtonGrid.add_widget(button)
print('Current Modules Loaded:')
print(modules)
def build(self):
Clock.schedule_interval(self.update_list, 1)
global screenMGR
screenMGR = ScreenManager()
screenMGR.add_widget(Builder.load_file("UI//home.kv"))
screenMGR.add_widget(Builder.load_file("UI//newnote.kv"))
# screenMGR.current = "new_note"
self.notes_list()
return screenMGR
def __init__(self,*args,**kwargs):
super(Game,self).__init__(*args,**kwargs)
Builder.load_file('game.kv') ## load the game's assigned layout file ##
self.tree = Tree()
self.tree.o_xs = 'self.center_x / 2'
self.tree.o_ys = 'self.center_y / 2'
self.add_widget(self.tree)
Clock.schedule_interval(self.update,1.0/40)
def configure_app(self):
"""Set all application configurations.
Use this once when launch the application.
"""
Builder.load_file(str(self.WIDGETS_DIR / 'task.kv'))
self.on_color_scheme()
self.configure_window()
self.set_screen()
self.set_pomodoro_values()
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 load_theme_kv(self, path):
"""
path must be similar to "/optional/mywidget{}.kv" to be parsed by format.
"""
try:
Builder.load_file(path.format(self.theme))
except FileNotFoundError as err:
print("""Erreur lors de l'ouverture du fichier {} : {}
Chargement du fichier kv par défaut.""".format(path.format(self.theme), err))
Builder.load_file(path.format("default"))
def importWidgets(dirName, returnLayouts=False):
gameLayouts = []
widgetsDir = abspath(f"{__file__}/../{dirName}")
widgetDirs = (f for f in scandir(widgetsDir)
if f.is_dir() and f.name != "__pycache__")
for widgetDir in widgetDirs:
Builder.load_file(join(widgetDir.path, "widget.kv"))
module = import_module(f"kivygames.{dirName}.{widgetDir.name}")
if returnLayouts:
gameLayouts.append(getattr(module, "layout")())
return gameLayouts if returnLayouts else None
def build(self):
Builder.load_file('select.kv')
manager = ScreenManager()
global ECHO_SERVER
ECHO_SERVER = Select(name='select')
manager.add_widget(ECHO_SERVER)
manager.add_widget(Login(name='login'))
manager.add_widget(Lobby(name='lobby'))
return manager
def __init__(self, **kwargs):
Builder.load_file('views/students_view.kv')
super().__init__(**kwargs)
self.detail_list = DetailList(headers=[
"ID", "Name of student", "Gender of student", 'Date of joining',
"gr #", "Father's name", "Mother's name", "Address",
"Phone number (Mother)", "Phone number (Father)", "Date of birth",
"Aadhar Card number", "Official Class", "Goes to goverment school",
"Mother' main occupation", "Father' main occupation", "Status",
"Comment"
])
Clock.schedule_once(lambda dt: self.add_widget(self.detail_list))
def build(self):
# load main UI styles
Builder.load_file(os.path.join(os.path.dirname(__file__), 'ui.kv'))
# scrollview covering the entire window
root = ScrollView(size_hint=(1, None),
size=(Window.width, Window.height))
Window.bind(height=root.setter('height'))
view = ExamView()
root.add_widget(view)
return root
def import_kivy_rule(files):
"""Import a kivy rule file only if it was not already imported.
Check for full file name.
Args:
files (iterable): kivy rule files
"""
if Builder:
if isinstance(files, str):
files = (files,)
for file in files:
if os.path.basename(file) in (os.path.os.path.basename(f) for f in Builder.files):
continue
Builder.load_file(file)
def __init__(self, gui):
self.gui = gui
self.fa = FileActions()
self.triaItems = []
self.fileStoragePath = self.fa.join(
self.gui.homeDirPath, 'triangulation.data'
) #self.fa.join(self.gui.homeDirPath, 'triangulation.data')
Builder.load_file('layoutTrianAddDialog.kv')
self.loadTriaItems()
self.listBuild()
self.aisBroadcasting = False
self.hdg = 0.0
self.lat = 0.0
self.lon = 0.0
def add_monitors(self):
monitors = self.config['monitors'].values()
if not monitors:
self.root.add_widget(Label(text='No monitors'))
return self.root
config = self.config['shinobi']
monitor_urls = [
'/%s/monitor/%s/%s' % (
config['apiKey'], config['groupKey'], mid
) for mid in monitors
]
server_url = config['server'].rstrip('/')
if config['layout'] == 'auto':
layout = self.auto_layout(len(monitors))
else:
layout = Builder.load_file('layouts/%s.kv' % config['layout'])
self.monitor_widgets = [
widget for widget in layout.walk(restrict=True)
if isinstance(widget, ShinobiMonitor)
]
for url, monitor in zip(monitor_urls, self.monitor_widgets):
monitor.serverURL = server_url
monitor.monitorPath = url
monitor.start()
self.root.add_widget(layout)
return self.root
def build(self):
self.theme_cls.primary_palette = "Amber"
self.theme_cls.theme_style = 'Dark'
screen = Screen()
self.help_str = Builder.load_file('settings.kv')
screen.add_widget(self.help_str)
return screen
def build(self):
Window.size = 360, 640
self.theme_cls.theme_style = 'Dark'
KV = Builder.load_file('calculator.kv')
sc = ScreenManager()
cl = Calc()
sc.add_widget(cl)
return sc
def build(self):
#Builder.load_file("loopsutd.kv")
print("I'm building!")
if is_master:
self.use_kivy_settings = False
return Builder.load_file('touchscreenUI.kv')
else:
return self._otherbuild()
class CalcGridLayout(GridLayout):
Builder.load_file('eiei.kv')
def calculate(self, calculation):
if calculation:
try:
self.display.text = str(eval(calculation))
except Exception:
self.display.text = "Error"
class main(App):
global SymbolsList, SpadesCard, HeartCard, ClubCard, DiamondCard, Card, Solution, countDeck
Builder.load_file("GUItest.kv")
def build(self):
sm = ScreenManager()
sm.add_widget(start(name='start'))
sm.add_widget(play(name='play'))
return sm
def build(self):
if platform == 'android':
from android import loadingscreen
loadingscreen.hide_loading_screen()
self.theme_cls.primary_palette = "Pink"
self.theme_cls.secondary_palette = "Dark"
ui = Builder.load_file('main_screen.kv')
Logger.debug("Logger is started")
return ui
def __init__(self):
self.kv = Builder.load_file("GUI.kv")
self.gui = GUI(self.kv)
global ValidDays
ValidDays = ['Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes']
global ValidHours
for i in range(7, 23):
ValidHours.append(str(i) + ':00')
global dataManager
dataManager = DataManager()
def __init__(self):
super(Main, self).__init__()
self.theme_cls.primary_palette = "Amber"
self.title = "Four in a row"
self.root = Builder.load_file("style.kv")
self.current_widget = MDBoxLayout()
self.start_widget = StartWidget(self.start_game, self.change_theme)
self.theme_widget = ThemeWidget(self, self.return_back)
self.current_widget.add_widget(self.start_widget)
def build(self):
screen = Screen()
self.help_str = Builder.load_file("main.kv")
screen.add_widget(self.help_str)
users_tables = MDDataTable(
pos_hint={
'center_x': 0.5,
'center_y': 0.5
},
size_hint=(1, 1),
use_pagination=True,
check=True,
column_data=[
("Nom", dp(30)),
("Prenom", dp(30)),
("Code", dp(30)),
("Tel", dp(30)),
("Nombre d'étudiants", dp(30)),
],
row_data=self.users,
)
users_tables.bind(on_check_press=self.user_check_press)
users_tables.bind(on_row_press=self.row_press)
students_tables = MDDataTable(pos_hint={
'center_x': 0.5,
'center_y': 0.5
},
size_hint=(1, 1),
use_pagination=True,
check=True,
column_data=[
("Nom", dp(30)),
("Prenom", dp(30)),
("Code", dp(30)),
("Tel", dp(30)),
("code paraints", dp(30)),
],
row_data=self.students)
students_tables.bind(on_check_press=self.check_press)
students_tables.bind(on_row_press=self.row_press)
self.help_str.ids.screen_manager.get_screen(
'manage_users').children[0].add_widget(users_tables)
self.help_str.ids.screen_manager.get_screen(
'manage_students').add_widget(students_tables)
return screen
from kivy.app import App
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.gridlayout import GridLayout
from kivy.lang.builder import Builder
from player import Player
Builder.load_file('sprites.kv')
class Fleet(GridLayout):
pass
class GalaxyInvaders(FloatLayout):
pass
class GalaxyInvadersApp(App):
def build(self):
return GalaxyInvaders()
if __name__ == '__main__':
GalaxyInvadersApp().run()
