def __init__(self, serverip, serverport, team, nick, **kwargs):
Builder.load_file(utils.kvPath.format('game_screen'))
super(GameScreen, self).__init__(**kwargs) # init with the name
game = SpylightGame(serverip, serverport, team, nick, self)
self.add_widget(game)
self.app = kwargs['app']
def __init__(self, title, *args, **kwargs):
"""
@title - tytul (nazwa) cwiczenia
"""
Builder.load_file("kv/genericlevels.kv")
Screen.__init__(self, *args, **kwargs)
self.title = title
def __init__(self, sm, ctrl, playlist, **kwargs):
Builder.load_file("playlist.kv")
self.sm = sm
self.playlist = playlist
self.ctrl = ctrl
super(
PlayListScreen, self).__init__(**kwargs)
def build(self):
Builder.load_file('bouncing.kv')
self.title = 'Two bouncing balls'
root = RootWidget()
Clock.schedule_interval(root.update1, 1.0/60)
Clock.schedule_interval(root.update2, 1.0/60)
return root
def __init__(self, ctrl, **kwargs):
Builder.load_file("playing.kv")
self.ctrl = ctrl
super(PlayingScreen, self).__init__(**kwargs)
Clock.schedule_interval(self._update_progress, 1/25)
self.volume_slider.value = self.ctrl.volume
self.init_display()
def build(self):
self.title = "Pong"
Builder.load_file('ui.kv')
self.ponggame = PongGame()
self.ponggame.serve_ball()
return self.ponggame
def __init__(self, *largs):
self.resources = list(self.search_data_files())
resource_add_path(dirname(__file__))
Builder.load_file(join(dirname(__file__), 'map.kv'))
super(MapServer, self).__init__(*largs)
self.timeout = 0
self.timemsg = 0
self.players = {}
# init client table
for client in self.controler.clients:
self.players[client] = {
'client': client,
'name': self.controler.get_client_name(client),
'ready': False,
'done': False,
'place': self.controler.metadata[client]['place'],
'count': 0
}
#store mapitems and thumbs in order to display them on main screen
#or remove them from clients
self.mapitems = {} #filename: [client, index]
self.thumbs = {} #index: [client, pos]
#get map layers list from json
self.load_json()
def __init__(self, n_procesadores, **kwargs): Builder.load_file(kwargs['archivo']) Screen.__init__(self, **kwargs) self.procesadores = None self.tabla_procesos = None self.popup_proceso = None self.inicializar(n_procesadores) self.tabla_procesos = self.tabla_procesos or TablaProcesosGUI(self.sistema.procesos) self.procesadores = self.procesadores or [ProcesadorGUI(p, self.tabla_procesos) for p in self.sistema.procesadores] self.popup_proceso = self.popup_proceso or ProcesoPopup(self.sistema) self.ids.titulo.text = "Simulacion para "+self.name self.popup_recurso = RecursoPopup(self.sistema) self.tabla_recursos = TablaRecursosGUI(self.sistema.recursos) self.ejecutando = False self.paso = False for p in self.procesadores: self.ids.procesadores.add_widget(p) self.c_procesos.add_widget(self.tabla_procesos) self.c_recursos.add_widget(self.tabla_recursos) self.sistema.asignar_vista(self)
def loadNextLevel(self):
global level, parts
if level is not 0:
# remove old level
game.remove_widget(self.levelObject)
# unload old level file
Builder.unload_file('lvl/level'+str(level)+'.kv')
# increment level
level += 1
print('KivyKloetze::loadNextLevel::loading', level)
# load new level file
Builder.load_file('lvl/level'+str(level)+'.kv')
Builder.sync()
# add new level object to game stage
self.levelObject = LevelObject()
game.add_widget(self.levelObject)
# count parts in new level
countParts = 0
for c in self.levelObject.children:
if hasattr(c, 'shapeIsActive'):
if c.shapeIsTool is False:
countParts += 1
print('KivyKloetze::loadNextLevel::parts count', countParts)
# correct parts count
parts = countParts
def FromFile(cls, filename, use_cache = False):
Logger.info('From File with ' + str(filename))
if not use_cache:
Logger.info(' From File without cache')
from os.path import split
from kivy.resources import resource_add_path
import sys
resource_add_path(split(filename)[0])
sys.path.append(split(filename)[0])
name, filename = find_template_path(filename)
#Add filename dir to ressources folder to facilitate relativ import
#Load & return all templates from a file as a list. Take an optionnal filter
from kivy.lang import Builder
# Remove any former trace of the file
if use_cache and filename in templateList.templates:
res = templateList[filename]
res = [r.blank() for r in res]
else:
Builder.unload_file(filename)
# Now create a widget
try:
Builder.load_file(filename)
res = cls._process_file_build(filename)
templateList[filename] = res
except Exception, E:
from utils import alert
from utils import log
import traceback
alert(str(E))
Logger.error('[Error] While trying to import Template %s'%filename)
log(E, traceback.print_exc())
res = list()
def load_all_kv_files(start="./gui"):
pattern = re.compile(r".*?\.kv")
kv_files = []
for root, dirs, files in os.walk(start):
kv_files += [root + "/" + kv_file for kv_file in files if pattern.match(kv_file)]
for kv_file in kv_files:
Builder.load_file(kv_file)
def build(self):
Builder.load_file("LogBufferPanel.kv")
Builder.load_file("Maps.kv")
this = ThisGUI()
this.log_buffer.buffer1.contents = "This is buffer 1"
this.log_buffer.buffer2.contents = "This is buffer 2"
return this
def build(self):
self.title = "Plateformer"
Builder.load_file('ui.kv')
self.platformergame = PlatformerGame()
Clock.schedule_interval(self.platformergame.update_game, 1.0/60)
return self.platformergame
def build_scene(self, scene):
Builder.load_file('prepare.kv')
Builder.load_file('result.kv')
scene.prepare = self.build_prepare()
scene.lwin = self.build_result(self.pdata.lwin)
scene.draw = self.build_result(self.pdata.draw)
scene.rwin = self.build_result(self.pdata.rwin)
def __init__(self, *args, **kwargs):
super(RepoWatcherApp, self).__init__(*args, **kwargs)
Builder.load_file('%(pp)s%(ps)sassets%(ps)sthemes%(ps)sCompact.kv' %
{'pp': settings.PROJECT_PATH,
'ps': settings.PATH_SEPERATOR})
self.layout = RepoWatcher(initialize=True)
self.icon = ICON_PATH
self.title = "Git Watcher UI"
def load_all_kv_files(start="bcitp/screens/kv"):
pattern = re.compile(r".*?\.kv")
kv_files = []
for root, dirs, files in os.walk(start):
kv_files += [root + "/" +
file_ for file_ in files if pattern.match(file_)]
for file_ in kv_files:
Builder.load_file(file_)
def __init__(self, sm, ctrl, playlist, **kwargs):
Builder.load_file("playlist.kv")
self.sm = sm
self.playlist = playlist
self.ctrl = ctrl
super(PlayListScreen, self).__init__(**kwargs)
self.items_per_page = 10
self.num_pages = 1
self.current_page = 1
def __init__(self, ctrl, playlist, store, **kwargs):
Builder.load_file('filebrowser.kv')
self.ctrl = ctrl
self.playlist = playlist
super(ZenFileBrowser, self).__init__(**kwargs)
self._init(store)
# Hack to make the ScrollView easier to do large scrolls on OSX
sv = self.filechooser.layout.children[0].children[0]
sv.bar_width = 15
sv.scroll_type = ['bars', 'content']
def load_kv(self):
self.loaded = False
for f in Builder.files:
if 'valid.kv' in f:
self.loaded=True
break
else :
self.loaded=False
if self.loaded == False:
Builder.load_file('tuto_assets/valid.kv')
def __init__(self, *args, **kwargs):
Builder.load_file("kv/menu.kv")
Builder.load_file("kv/cards.kv")
Screen.__init__(self, *args, **kwargs)
self.prev_exercise_bt.bind(on_release=lambda bt: self.scroll_to_prev())
self.next_exercise_bt.bind(on_release=lambda bt: self.scroll_to_next())
self.goto_exercise_bt.bind(on_release=lambda bt: self.goto_exercise())
def load_kv_files():
# search through our kv directory and load all ui files
dirname = os.path.join(os.path.dirname(__file__), 'kv')
for root, dirs, files in os.walk(dirname):
for filename in files:
f, ext = os.path.splitext(filename)
if ext != '.kv':
continue
full = os.path.join(root, filename)
Builder.load_file(full)
def build(self):
# The 'build' method is called when the app is run.
Builder.load_file("ltcctrl.kv")
status = StatusDisplay()
backend = LTCbackend(status.set_state)
self.bind(on_stop=backend.close)
self.bind(on_start=backend.start)
sens0 = IOIndicator(backend.core.sensor[0])
sens1 = IOIndicator(backend.core.sensor[3])
sens5 = IOIndicator(backend.core.sensor[2])
sens6 = IOIndicator(backend.core.sensor[1])
sens7 = IOIndicator(backend.core.sensor[5])
sens8 = IOIndicator(backend.core.sensor[6])
sens9 = IOIndicator(backend.core.sensor[7])
sens4 = IOIndicator(backend.core.sensor[4])
relay1 = IOIndicator(backend.relay.shorepower)
relay2 = IOIndicator(backend.relay.relay)
input_panel = InterfaceKitPanel()
relay_panel = InterfaceKitPanel()
input_panel.add_widget(sens8)
input_panel.add_widget(sens7)
input_panel.add_widget(sens0)
input_panel.add_widget(sens1)
input_panel.add_widget(sens5)
relay_panel.add_widget(sens4)
relay_panel.add_widget(relay2)
relay_panel.add_widget(sens6)
relay_panel.add_widget(relay1)
relay_panel.add_widget(sens9)
backend.core.add_callback(status.on_attach, 'attach')
backend.core.add_callback(status.on_detach, 'detach')
backend.core.add_callback(status.on_error, 'error')
backend.relay.add_callback(status.on_attach, 'attach')
backend.relay.add_callback(status.on_detach, 'detach')
backend.relay.add_callback(status.on_error, 'error')
backend.relay.relay.add_callback(status.on_ignite, 'value')
ctrl = LTCctrl(backend.ignite, backend.shorepower, status.set_state)
backend.relay.shorepower.add_callback(ctrl.on_shorepower, "value")
backend.relay.relay.add_callback(ctrl.on_ignite, "value")
ltc = LTC()
ltc.toplayout.add_widget(ctrl)
ltc.toplayout.add_widget(status)
ltc.indicators.add_widget(relay_panel)
ltc.indicators.add_widget(input_panel)
return ltc
def __init__(self, **kw):
super(MoaApp, self).__init__(**kw)
Builder.load_file(path.join(path.dirname(__file__),
'data', 'moa_style.kv'))
def add_data_directory(*largs):
if not self.data_directory:
return
resources.resource_add_path(path.expanduser(self.data_directory))
self.fbind('data_directory', add_data_directory)
add_data_directory()
def main():
init_config()
KivyConfig.set('graphics', 'width', settings.width)
KivyConfig.set('graphics', 'height', settings.height)
for root, _dirs, files in os.walk(stylesdir):
files = [os.path.join(root, f) for f in files if re.match(fnmatch.translate('*.kv'), f)]
for f in files:
Logger.debug('loading style file: %s' % f)
Builder.load_file(f)
TunerApp().run()
def __init__(self, **kwargs):
name = self.__class__.__name__
self.name = name[:-6] if name.endswith('Screen') else name
setattr(App.instance, name, lambda: App.instance.pushScreen(self.name))
try:
Logger.debug('NamedScreen: Loading %s.kv' % name)
Builder.load_file(name + '.kv', rulesonly=True)
except IOError:
Logger.debug('NamedScreen: File %s.kv not found' % name)
Screen.__init__(self, **kwargs)
def build(self) :
Builder.load_file("style.kv")
self.store = Store("config.json")
root = ScreenNexus()
screens = [ MainScreen(), AddScreen(), ExportScreen() ]
if not self.store.data.has_key("user") :
screens.insert(0, InitScreen())
for screen in screens :
root.add_widget(screen)
return root
def load_kivy_file(self, screen_name):
scr_mod_name, scr_cls_name = self.screen_data[screen_name]
path_list = ['pentai', 'gui', 'screens', '%s_screen.kv' % scr_mod_name]
kv_path = os.path.join(*path_list)
try:
Builder.load_file(kv_path)
self.loaded_kv_files.add(screen_name)
except IOError:
pass
def fin():
simulator.clean_queue()
from kivy.lang import Builder
files = list(Builder.files)
for filename in files:
Builder.unload_file(filename)
kivy_style_filename = os.path.join(kivy_data_dir, 'style.kv')
if not kivy_style_filename in Builder.files:
Builder.load_file(kivy_style_filename, rulesonly=True)
def build(self):
filename = self.options["filename"]
if isdir(filename):
directory = filename
filename = join(filename, "presentation.kv")
else:
directory = dirname(filename)
sys.path += [directory]
resource_add_path(directory)
template_fn = join(directory, "templates.kv")
if exists(template_fn):
Builder.load_file(template_fn)
return Builder.load_file(filename)
def build(self):
# Cargamos el archivo con la interfaz
Builder.load_file('kv/ticket.kv')
# Creamos el screen manager con la WipeTransition
sm = ScreenManager(transition=WipeTransition())
# Agregamos las pantallas fijas del sistema
sm.add_widget(SplashScreen(name='splash'))
sm.add_widget(MenuScreen(name='menu'))
sm.add_widget(FormScreen(name='formulario'))
sm.add_widget(LoginScreen(name='login'))
sm.add_widget(AyudaScreen(name='ayuda'))
sm.add_widget(ControlScreen(name='menu_control'))
return sm
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.screen = Builder.load_file('main.kv')
from functools import partial
from kivy.uix.popup import Popup
from kivy.properties import ListProperty, NumericProperty
from kivy.uix.dropdown import DropDown
from kivy.uix.label import Label
from kivy.uix.image import Image
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.recycleview import RecycleView
from kivy.uix.widget import Widget
from sql_interactions import *
from capture_app_info import *
import setup
import zip_find
Builder.load_file('menubar.kv')
Builder.load_file('screens.kv')
class MenuContainer(AnchorLayout):
#constructor
def __init__(self, **kwargs):
super(MenuContainer, self).__init__(**kwargs)
#load the login popup when the app starts
Clock.schedule_once(self.getStartupPopup, 0)
def getStartupPopup(self, inst):
pop = Popup(title='SnowGuru', title_align='center',content=Image(source='mountain.jpg'),
from kivy.app import App
from kivy.base import runTouchApp
from kivy.properties import (
ObjectProperty,
ListProperty,
StringProperty,
NumericProperty,
)
from kivy.lang import Builder
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.textinput import TextInput
Builder.load_file(str(Path(__file__).parent / 'logging_console.kv'))
class ConsoleOutput(TextInput):
max_text_size = 10000
_add_text_is_in_progress = False
def __init__(self, **kwargs):
super(ConsoleOutput, self).__init__(**kwargs)
app = App.get_running_app()
def is_locked(self):
return ((self.parent.height >= self.height) or
(self.parent.scroll_y <= 0.05))
def build(self):
self.title = "Layout Hints Demo"
self.root = Builder.load_file('hints_demo.kv')
return self.root
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.uix.screenmanager import SwapTransition, Screen
from kivy.utils import get_hex_from_color, get_color_from_hex
from kivymd.color_definitions import colors
from kivymd.uix.boxlayout import MDBoxLayout
from kivymd.uix.button import MDFlatButton, MDRaisedButton, MDIconButton
from kivymd.uix.card import MDCard
from kivymd.uix.dialog import MDDialog
from kivymd.uix.label import MDLabel
from widgets import utils
from widgets.Window import Window
from widgets.MenuIconTextButton import MenuIconTextButton
Builder.load_file("widgets/homepage/HomePage.kv")
class DeleteDialogContent(BoxLayout):
"""Content for the delete project popup dialog"""
new_text = StringProperty()
# Card widget for each project each ObjectProperty belongs to one aspect of the widget
class ProjectCard(MDCard):
"""
Card that represents each project
"""
project_filename = ObjectProperty()
home_page = ObjectProperty()
project = StringProperty()
from kivy import Logger
from kivy.clock import Clock
from kivy.lang import Builder
from kivy.properties import ObjectProperty, BooleanProperty
from kivy.properties import StringProperty
from kivy.uix.boxlayout import BoxLayout
from ia_scribe.cameras import camera_system
from ia_scribe.scribe_globals import LOADING_IMAGE
from ia_scribe.uix.behaviors.tooltip import TooltipControl
from ia_scribe.uix.screens.calibration.widget.foldout_widget import \
CalibrationWidgetFoldout
from ia_scribe.uix.components.file_chooser import FileChooser
from ia_scribe.uix.components.poppers.popups import ScribeLearnMorePopup, InfoPopup
Builder.load_file(join(dirname(__file__), 'calibration_widget.kv'))
class CalibrationWidget(BoxLayout):
screen_manager = ObjectProperty(None)
scribe_widget = ObjectProperty(None)
callibration_screen = ObjectProperty(None)
loading_image = StringProperty(LOADING_IMAGE)
left_port = StringProperty()
right_port = StringProperty()
target_screen = ObjectProperty('capture_screen')
target_extra = ObjectProperty(allownone=True)
use_tooltips = BooleanProperty(False)
"""Pass this value to `use_tooltips` of every TooltipControl child widget.
"""
with open(os.path.join(path, filename[0])) as stream:
with open('nowyplik.gpx', 'w+') as plik:
plik.write(stream.read())
self.dismiss_popup()
def show_load(self):
content = LoadDialog(load=self.load, cancel=self.dismiss_popup)
self._popup = Popup(title="Wczytanie pliku",
content=content,
size_hint=(0.9, 0.9))
self._popup.open()
kv = Builder.load_file("main.kv")
sm = WindowManager()
screens = [
MainWindow(name="main"),
WiecejWykresow(name="ww"),
WiecejStatystyk(name="ws")
]
for screen in screens:
sm.add_widget(screen)
sm.current = "main"
class MyApp(App):
def build(self):
def build(self):
self.title = "Dynamic Labels"
self.root = Builder.load_file('dynamic_labels.kv')
return self.root
from kivy.uix.floatlayout import FloatLayout
from kivy.properties import ObjectProperty, ListProperty, StringProperty
from kivy.uix.screenmanager import ScreenManager, Screen, CardTransition
from kivy.clock import Clock, mainthread
from kivy.uix.popup import Popup
from kivy.uix.spinner import Spinner
import kivy.garden.contextmenu
# https://stackoverflow.com/questions/55133377/pycharm-error-kivy-garden-knob-import-successfully-but-not-active-on-script
# https://kivy.org/doc/stable/api-kivy.garden.html
from kivy import Config
Config.set('graphics', 'multisamples', '0')
""" kv File """
Builder.load_file('maingui.kv')
""" Constants """
up_in = CardTransition(mode="push", direction="up", duration=".25")
""" Variables """
prj_list = ['Proj_1', 'proj-2', '3-jorp', '4_jorp']
# prj_list = []
""" Layouts """
class ProjectGridLayout(GridLayout):
def show_labels(self, var):
self.clear_widgets()
self.main_scrn.clear_widgets() # Clear all widgets in main_scrn
app = App.get_running_app() # name of running app like #homepath
sm = app.root.ids.main_mng # path from #homepath to #main_mng (ScreenManager Lvl 1)
def build(self):
"""Build Kivy GUI."""
self.title = 'Dynamic Labels'
self.root = Builder.load_file('dynamic_labels.kv')
self.create_labels()
return self.root
def build(self):
""" build the Kivy app from the kv file """
Window.size = (600, 400)
self.title = "Convert Miles to Kilometers"
self.root = Builder.load_file('miles_to_km.kv')
return self.root
from threading import Thread
import thread
import time
#ListView
from kivy.uix.listview import ListView
from kivy.adapters.listadapter import ListAdapter
#source
from parsePdb import ParsePdb
from parsePdb import Variable
from Utils import PdbFile
from Utils import Chain
#Kivy file
Builder.load_file(os.path.dirname(__file__) + "/LabpiLoad.kv")
# global Variable
ItemId = 0
loadPymol = False
class LoadScreen(Screen):
root_path = os.path.dirname(__file__)
boxlist_1 = ObjectProperty(None)
boxlist_2 = ObjectProperty(None)
list_adapter_receptor = ObjectProperty(None)
list_adapter_ligand = ObjectProperty(None)
pymol = ObjectProperty(None)
from kivy.uix.scrollview import ScrollView
import file_work as fw
from control.btn import Btn
from control.dropDownMenu import DropDownMenu
from control.layout import Separator10
from control.lbl import Lbl, ResultsLbl
from control.scheme import Scheme
from control.sideConfigurations import Algorithm, Input, Plot, Results
from design import Design
from process import Process
# engine = KivyEngine()
kivy.require('1.10.1')
Builder.load_file('view/main.kv')
class Main(Screen):
theme = Design().default_theme
SCHEME_HEIGHT = 150
MAX_FONT_SIZE = 16
HEIGHT_COEFNT = 2
CLOCK = .01
RESUL_TIME = 3
RESULT_NO = 3
SIDE_CONF_WIDTH = 768
def __init__(self, **kwargs):
super(Main, self).__init__(**kwargs)
self.side_config_algorithm = Algorithm()
def build(self):
self.title = "Box Layout Demo"
self.root = Builder.load_file("box_layout.kv")
return self.root
from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen, NoTransition
from kivy.lang import Builder
from kivy.properties import ObjectProperty
from model.session import Session
from model.user import User
from model.role import Administrator
from model.object import Directory
from model.assignment import Assignment
from model.privilege import Privilege
from controller.session import LoginScreen
from controller.object import DirectoryScreen
from commands import *
presentation = Builder.load_file("view/main.kv")
class ScreenManagement(ScreenManager):
main_screen = ObjectProperty(None)
class MainScreen(Screen):
pass
class MainApp(App):
session = Session()
admin_user = User("admin", "12345")
admin_role = Administrator()
from kivy.app import App
from kivy.lang import Builder
from kivy.clock import mainthread
from kivymd.uix.card import MDCard
from kivymd.uix.label import MDLabel
from kivy.properties import StringProperty
from kivy.uix.boxlayout import BoxLayout
from kivymd.uix.button import MDFlatButton
from kivy.uix.behaviors import ButtonBehavior
Builder.load_file('components/book_card.kv')
class BookCard(MDCard):
title_content = StringProperty('')
def __init__(self,
book=None,
download_button_func=None,
remove_button_func=None,
**kwargs):
super(BookCard, self).__init__(**kwargs)
self.title_content = book.title
self.book = book
self.is_opened = False
self.download_button_func = download_button_func
self.remove_button_func = remove_button_func
def open_or_close_card(self):
from persimmon.view.pins import InputPin, OutputPin
from persimmon.view.blocks import Block
from kivy.properties import ObjectProperty
from kivy.lang import Builder
from sklearn.model_selection import cross_val_score
Builder.load_file('view/blocks/crossvalidationblock.kv')
class CrossValidationBlock(Block):
data_input = ObjectProperty()
estimator_input = ObjectProperty()
cross_val_input = ObjectProperty()
cross_out = ObjectProperty()
def function(self):
X = self.data_input.val.iloc[:, :-1]
y = self.data_input.val.iloc[:, -1]
self.cross_out.val = cross_val_score(self.estimator_input.val,
X,
y,
cv=self.cross_val_input.val)
def build(self):
self.root = Builder.load_file('final_test.kv')
self.create_widgets()
return self.root
def build(self): #build the code for the app)
return Builder.load_file(
__file__.replace("\\main.py", "") +
"\\formatting.kv") #load the user interface formatting file
from kivy.uix.slider import Slider
from kivy.animation import Animation
from kivy.properties import ListProperty, NumericProperty
from kivy.clock import Clock
from kivy.graphics import Color, Rectangle
from kivy.metrics import dp, sp
from kivy.core.window import Window
from random import random
# Set background color
Window.clearcolor = (0, 0, 0, 1)
# Import kv files
from kivy.lang import Builder
Builder.load_file('assets/kv/speed.kv')
from kivy.core.text import LabelBase
KIVY_FONTS = [{
"name": "InterUI",
"fn_regular": "assets/fonts/Inter-UI-Regular.otf",
"fn_bold": "assets/fonts/Inter-UI-Bold.otf",
}]
for font in KIVY_FONTS:
LabelBase.register(**font)
speed = 1
speeDir = True
leverLeft = True
second = 'asd'
def build(self):
self.title = "Harry Potter Trivial Pursuit"
self.root = Builder.load_file('trivial_pursuit.kv')
self.status = "Start the game by rolling the category dice."
self.score = "Score: "
return self.root
from kivy.animation import Animation
from kivy.uix.modalview import ModalView
from kivy.uix.popup import PopupException
from kivy.clock import Clock
from kivymd.textfields import MDTextField
from kivymd.theming import ThemableBehavior, ThemeManager
from kivymd.elevationbehavior import RectangularElevationBehavior
from kivymd.button import MDFlatButton
from kivyic import path
from kivyic.fileexplorer import FileExplorer, get_home_directory
from functools import partial
Builder.load_file(path + '/dialog.kv')
__all__ = ['ICDialog', 'FileExplorerDialog', 'DialogOKDismiss']
__version__ = '0.1'
# BUG - helper text and hint text can not be set from python, only in kv, NEED TO TEST
class InputDialog(MDTextField):
"""
A text input field to be inserted into a dialog box
"""
pass
class ICDialog(ThemableBehavior, RectangularElevationBehavior, ModalView):
"""
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.boxlayout import BoxLayout
from kivy.core.window import Window
from string import punctuation, ascii_uppercase, ascii_lowercase, digits
from random import sample, shuffle, randint
import pyperclip
Builder.load_file("Password.kv")
class MyLayout(BoxLayout):
def checkbox_click(self, parameters):
numbers = digits
symbols = punctuation
capital = ascii_uppercase
small = ascii_lowercase
initial_password = ""
if parameters == "easy":
initial_password = sample(small, randint(2, 5)) + sample(
capital, randint(3, 5))
elif parameters == "normal":
initial_password = sample(small, randint(2, 3)) + sample(capital, randint(2, 4)) + \
sample(numbers, randint(3, 5))
elif parameters == "hard":
initial_password = sample(small, randint(2, 3)) + sample(capital, randint(2, 3)) + \
sample(numbers, randint(3, 4)) + sample(symbols, randint(3, 5))
shuffle(initial_password)
global final_password
final_password = "".join(initial_password)
self.ids.password.text = f"Your Password: {final_password}"
from kivy.uix.widget import Widget
from kivy.properties import NumericProperty, ListProperty
from kivy.lang import Builder
from kivy.clock import Clock
from kivy.graphics import Color, Ellipse, Line, Rectangle, Point, GraphicException
from contextlib import contextmanager
import pygame
import sys, os
Builder.load_file("uix\joystick\joystick.kv")
class Joystick(Widget):
#StencilView?
jx = 0.
jy = 0.
deadzone = NumericProperty(.05)
pos = ListProperty([0, 0])
def __init__(self, *args, **kwargs):
self.hwx = 0.
self.hwy = 0.
pass
super(Joystick, self).__init__(**kwargs)
def hwjoystick_refresh(self, *args):
pygame.event.pump()
def build(self):
"""Build the Kivy GUI"""
self.title = 'Dynamic Widgets'
self.root = Builder.load_file('dynamic_widgets.kv')
self.create_widgets()
return self.root
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.screenmanager import ScreenManager, Screen
import json, glob, random
from datetime import datetime
from pathlib import Path
from hoverable import HoverBehavior
from kivy.uix.image import Image
from kivy.uix.behaviors import ButtonBehavior
Builder.load_file('design.kv')
class LoginScreen(Screen):
def sign_up(self):
self.manager.current = "sign_up_screen"
def login(self, uname, pword):
with open("users.json") as file:
users = json.load(file)
if uname in users and users[uname]['password'] == pword:
self.manager.current = 'login_screen_success'
else:
self.ids.login_wrong.text = "Wrong username or password"
class RootWidget(ScreenManager):
pass
class SignUpScreen(Screen):
def invalidLogin():
pop = Popup (title='Invalid Login',
content=Label (text='Invalid username or password.'),
size_hint=(None, None), size=(400, 400))
pop.open ()
def invalidForm():
pop = Popup (title='Invalid Form',
content=Label (text='Please fill in all inputs with valid information.'),
size_hint=(None, None), size=(400, 400))
pop.open ()
kv = Builder.load_file ("my.kv")
sm = WindowManager ()
db = DataBase ("users.txt")
screens = [LoginWindow (name="login"), CreateAccountWindow (name="create"), MainWindow (name="main")]
for screen in screens:
sm.add_widget (screen)
sm.current = "login"
class MyMainApp (App):
def build(self):
return sm
"""
The UsernameScreen class extends the Screen class and creates
a new screen displaying a reddit user's profile.
"""
def get_userprofile(self):
"""
get_userprofile() function passes the username in the inputbox
:return:
"""
userprofile = get_redditor_info(self.ids.username_input.text)
if userprofile is None:
self.ids.userprofile_output.text = "Error, user not found."
else:
self.ids.userprofile_output.text = userprofile
class ScreenManagement(ScreenManager):
pass
presentation = Builder.load_file("API.kv")
class APIApp(App):
def build(self):
return presentation
APIApp().run()
super(ResultsWindow, self).__init__(**kwargs)
self.scroller = ScrollView(effect_cls=scrolling)
self.grid = GridLayout(cols=1,
row_default_height='110dp',
row_force_default=True,
spacing=0,
padding=0,
size_hint_y=None)
self.res_list1 = MainWindow().return_results()
for i in self.res_list1:
self.grid.add_widget(
Label(text=' '.join(i),
font_size=15,
text_size=(1000, None),
size_hint_y=None))
self.scroller.add_widget(self.grid)
self.add_widget(self.scroller)
kv = Builder.load_file("js.kv")
class JobSeek(App):
def build(self):
return kv
if __name__ == "__main__":
JobSeek().run()
def build(self):
"""Build the Kivy-GUI"""
Window.size = (800, 300)
self.title = 'Temperature Converter'
self.root = Builder.load_file('extension_temperature_converter.kv')
return self.root
