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