def __init__(self, **kwargs): super(ThemeManager, self).__init__(**kwargs) self._win_size = Window.size Window.bind(on_resize=lambda *x: setattr(self, '_win_size', Window.size), on_rotate=lambda *x: setattr(self, '_win_size', Window.size)) for font in FONTS: LabelBase.register(**font)
def build(self):
# register fonts
for font in settings.KIVY_FONTS:
LabelBase.register(**font)
self.bsm = BackgroundScreenManager()
return self.bsm
def build(self):
"""
Build and return the root widget.
"""
self.settings_cls = SettingsWithSpinner
Window.size = (1920, 1080)
Window.minimum_width = 1280
Window.minimum_height = 800
#Window.clearcolor = (1, 0, 0, 1)
#Window.fullscreen = True
print(Window.dpi)
print(Window.size)
with open("classes.json") as f:
self.class_data = json.load(f)
class_picker = self.root.ids["class_spinner"]
class_picker.values = self.class_data.keys()
class_picker.bind(text=self.on_class_change)
class_picker.text = self.class_data.keys()[0]
#Register custom fonts
for font in common.FONTS:
LabelBase.register(**font)
return self.root
def start():
for font in G.kivy_fonts:
LabelBase.register(**font)
Window.size = (900, 600)
Builder.load_string(kv_text)
G.app = ScrollApp()
G.app.run()
def set_regular(family, *filenames):
for f in filenames:
try:
LabelBase.register(family, f)
break
except IOError:
continue
else:
raise IOError, 'No appropriate fonts for Kivy UI'
def main():
from kivy.core.window import Window
Window.clearcolor = get_color_from_hex('#101216')
LabelBase.register(
name='Roboto',
fn_regular='fonts/Roboto-Thin.ttf',
fn_bold='fonts/Roboto-Medium.ttf'
)
ClockApp().run()
def pymterm_main():
args = args_parser().parse_args()
try:
sys.argv = sys.argv[:1]
cfg = session_config.SessionConfig(args)
except:
logging.exception('load configuration failed')
args_parser().print_help()
sys.exit(1)
if cfg.render and cfg.render == 'console':
from term.terminal_console import TerminalConsoleApp
TerminalConsoleApp(cfg).start()
elif cfg.render and cfg.render == 'kivy':
from kivy.config import Config
Config.set('kivy', 'exit_on_escape', 0)
Config.set('graphics', 'height', '660')
os.environ['KIVY_NO_FILELOG'] = ''
os.environ['KIVY_NO_CONSOLELOG'] = ''
from kivy.core.text import LabelBase
FONTS = {'WenQuanYi':'wqy-microhei-mono.ttf',
'YaHei Consolas':'YaHei Consolas Hybrid 1.12.ttf',
'NotoSans':'NotoSansMonoCJKsc-Regular.otf'}
for f_name in FONTS:
font_path = os.path.join(os.path.dirname(__file__), '..', 'data', 'fonts', FONTS[f_name])
logging.getLogger('term_kivy_app').debug(font_path)
LabelBase.register(f_name, font_path)
from term_kivy.term_kivy import TerminalKivyApp
#from kivy.logger import Logger
#Logger.setLevel(logging.ERROR)
TerminalKivyApp(cfg).start()
elif cfg.render and cfg.render in session_config.PYGLET_RENDERS:
from term_pyglet.term_pyglet import TerminalPygletApp
TerminalPygletApp(cfg).start()
else:
from term_pygui.term_pygui import TerminalPyGUIApp
TerminalPyGUIApp(cfg).start()
import playimg as plimg
import playword as plword
from playword import *
import time
from kivy.properties import StringProperty
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.properties import ObjectProperty, NumericProperty, ListProperty
from kivy.uix.actionbar import ActionBar, ActionItem, ActionView, ActionPrevious, ActionGroup, ActionButton
from kivy.uix.widget import Widget
from kivy.uix.boxlayout import BoxLayout
#키비폰트 정하기
from kivy.core.text import LabelBase, DEFAULT_FONT
from kivy.resources import resource_add_path
resource_add_path('c:/windows/fonts')
LabelBase.register(DEFAULT_FONT, 'H2GTRE.TTF')
from kivy.lang import Builder
with open(f"{dirname(__file__)}/switch.kv", 'rt',
encoding='utf-8') as f: # Note the name of the .kv
Builder.load_string(f.read())
from kivy.uix.button import Button
from kivy.uix.spinner import Spinner
from kivy.uix.widget import Widget
import pandas as pd
##맷립 임포트
import matplotlib
matplotlib.use(r'module://kivy.garden.matplotlib.backend_kivy')
import matplotlib.pyplot as plt
#비디오목록
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.screenmanager import ScreenManager, Screen, FadeTransition
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.relativelayout import RelativeLayout
from kivy.uix.label import Label
from kivy.uix.image import Image
from kivy.core.window import Window
from kivy.uix.widget import Widget
from kivy.clock import Clock
import numpy as np
from kivy.properties import StringProperty, ListProperty, DictProperty, ObjectProperty, NumericProperty, BooleanProperty
from kivy.core.text import LabelBase
LabelBase.register(name = "Avenir",
fn_regular = "assets/avenir.ttf")
LabelBase.register(name = "paraaminobenzoic",
fn_regular = "assets/paraaminobenzoic.ttf")
emulate_rotary_dial = True
import SubiSearch
import SubiPlay
from RotaryDial import RotaryDial
from arduinoSerial import ArduinoSerial
def timing(f):
"""
Used to benchmark code to discover bottlenecks. Important since the target
platform is Pi Zero
Usage:
def passEnter(self):
psw =str(self.root.ids["parola"].text)
if len(psw)>0:
self.psw=psw
else:
self.psw=None
self.showError()
def showError(self):
m=MModalView()
m.open()
#self.root.ids["kullanici"].focus=True
def exitOnClick(self,instance=None,val=None):
uyariModal = KModalView(labeltext=" Uygulamadan çıkmak\nistediğinizden emin misiniz?")
uyariModal.open()
def build(self):
Window.bind(on_keyboard=self.hook_kb)
def hook_kb(self, win, key, *largs):
if key == 27:
self.exitOnClick()
return True
elif key in (282, 319):
print "setting panel goster"
return True
return False
def tester(self):
print "working"
if __name__ == '__main__':
Window.clearcolor=(0.3,1,0.3,1)
LabelBase.register(name="ky",fn_regular="esantial.ttf")
LoginApp().run()
# 查找配置文件
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
# 添加资源目录
resource_add_path(os.path.abspath(resource_dir_path))
# ======================================== kivy应用 ========================================
# app应用
from kivy.app import App
# ======================================== kivy组件 ========================================
self.game_end = 1
if self.game_end:
#self.root.ids.b13.color = [0, 0, 0, 1]
self.game_buttons[12].background_color = [0.5, 0, 0, 1]
self.root.ids.info_label.text = font_s + 'BINGO!' + font_e
self.game_end = 0
def reset(self):
for btn in self.game_buttons:
btn.background_color = C('#2ecc71')
btn.color = [1, 1, 1, 1]
self.index = [0]*game_pole
self.root.ids.info_label.text = ''
def drop_select(self, value):
self.root.ids.open_butt.text = text_choise + value
self.game_select = self.game_data[self.games_index[value]][1:]
self.reset()
self.update_button()
if __name__ in ('__main__', '__android__'):
Config.set('graphics', 'width', '540')
Config.set('graphics', 'height', '960') # 9:16
Config.set('graphics', 'resizable', '1')
Config.set('input', 'mouse', 'mouse,disable_multitouch')
LabelBase.register(name='PT Sans Narrow',
fn_regular='PTN57F.ttf')
MainApp().run()
Color(rgb=(1,1,1))
self.rect=Rectangle(source='background.jpeg',pos=self.welcome.main_grid.pos, size=self.welcome.main_grid.size)
with self.welcome.side_panel.canvas.before:
Color(rgb=(1,1,1))
self.rect1=Rectangle(source='background.jpeg',pos=self.welcome.side_panel.pos, size=self.welcome.side_panel.size)
return self.all_screens
def _update1(self,instance,value):
self.rect.pos=instance.pos
self.rect.size=instance.size
def _update2(self,instance,value):
self.rect1.pos=instance.pos
self.rect1.size=instance.size
def _start_thread(self):
self.welcome.rateo1.text=self.welcome.dis('vijayawada',3)
self.welcome.rateo2.text=self.welcome.dis('guntur',3)
self.welcome.rateo3.text=self.welcome.dis1()
def on_pause(self):
return True
def on_start(self):
k=threading.Thread(target=self._start_thread,args=())
k.start()
#loading extra fonts to the app
LabelBase.register(name='Montez',fn_regular='Montez-Regular.ttf')
LabelBase.register(name='fff',fn_regular='FFF.ttf',)
#running app
builder().run()
#padding and spacing should be given dynamically
from pygments.formatters.html import HtmlFormatter
from pygments.lexers.python import Python3Lexer
import pygments.token as pygtoken
from pygments.style import Style
import configparser
import inspect
import time
import os
config_parser = configparser.ConfigParser()
config_parser.read("config.ini")
font_directory = config_parser["Paths"]["font_dir"]
from kivy.core.text import LabelBase
LabelBase.register(name="Inconsolata",
fn_regular=font_directory+"\\Inconsolata.ttf")
class OrangeStyle(Style):
default_style = ""
styles = {
pygtoken.Comment: "#8F8F8F",
pygtoken.Keyword: "#FF9500",
pygtoken.Number: "#3B9696",
pygtoken.String: "#21D191",
pygtoken.Name: "#DEDEDE",
pygtoken.Name.Variable: "#DEDEDE",
pygtoken.Name.Function: "#DEDEDE",
pygtoken.Name.Class: "#DEDEDE",
pygtoken.Operator: "#FF9500",
pygtoken.Text: "#DEDEDE",
from MySingleton import MySingleton
from TripManager import TripManager
from BusLocationGetter import BusLocationGetter
from VehiclePositionExporter import VehiclePositonExporter
import pygame.mixer
import zipfile
import datetime
import requests
import time
import os
import subprocess
os.environ['KIVY_GL_BACKEND'] = 'gl'
# 日本語使用するためfont
LabelBase.register(DEFAULT_FONT, r'./font/FONT')
# ServletAPIbaseURL
base_url = "http://FQCN/BusApplicationServerSide"
# ユーザデータ保存用
user_file = os.getcwd()+ r'/savedata/userdata.txt'
voice_file = os.getcwd()+ r'/Voicedata/voicedata.txt'
pass_phrase = 'PASS PHRASE'
cipher = AESCipher(pass_phrase)
volume_data =os.getcwd() + r"/Voicedata/soundvolume.txt"
if os.path.exists(volume_data) == False:
fw = open(volume_data, 'w')
# Valuation
from es_gui.apps.valuation.home import ValuationHomeScreen
from es_gui.apps.valuation.batchrunscreen import BatchRunScreen
from es_gui.apps.valuation.results_viewer import ValuationResultsViewer
from es_gui.apps.valuation.wizard import ValuationWizard
# Behind-the-meter
from es_gui.apps.btm.home import BehindTheMeterHomeScreen
from es_gui.apps.btm.cost_savings import CostSavingsWizard
from es_gui.apps.btm.results_viewer import BtmResultsViewer
# Font registration.
LabelBase.register(name='Exo 2',
fn_regular=os.path.join('es_gui', 'resources', 'fonts',
'Exo_2', 'Exo2-Regular.ttf'),
fn_bold=os.path.join('es_gui', 'resources', 'fonts',
'Exo_2', 'Exo2-Bold.ttf'),
fn_italic=os.path.join('es_gui', 'resources', 'fonts',
'Exo_2', 'Exo2-Italic.ttf'))
LabelBase.register(name='Open Sans',
fn_regular=os.path.join('es_gui', 'resources', 'fonts',
'Open_Sans',
'OpenSans-Regular.ttf'),
fn_bold=os.path.join('es_gui', 'resources', 'fonts',
'Open_Sans', 'OpenSans-Bold.ttf'),
fn_italic=os.path.join('es_gui', 'resources', 'fonts',
'Open_Sans', 'OpenSans-Italic.ttf'))
LabelBase.register(name='Modern Pictograms',
fn_regular=os.path.join('es_gui', 'resources', 'fonts',
from kivy.uix.widget import Widget
from kivy.uix.popup import Popup
from kivy.uix.relativelayout import RelativeLayout
from kivy.properties import (ObjectProperty, DictProperty, StringProperty,
NumericProperty, ReferenceListProperty)
from kivy.resources import resource_add_path, resource_find
from kivy.extras.highlight import KivyLexer
from kivy.core.text import LabelBase, DEFAULT_FONT
from kivy.clock import Clock
from kivy.config import ConfigParser
from pygments import lexers
__file__ = sys.argv[0]
resource_add_path(str(Path(__file__).parent / "resources"))
LabelBase.register(DEFAULT_FONT, "fonts/NotoSansCJKjp-Regular.otf")
LabelBase.register("code_input", "fonts/NotoSansMonoCJKjp-Regular.otf")
class IconBase:
icon = StringProperty("")
padding_left = NumericProperty(0)
padding_top = NumericProperty(0)
padding_right = NumericProperty(0)
padding_bottom = NumericProperty(0)
padding = ReferenceListProperty(padding_left, padding_top, padding_right,
padding_bottom)
class IconWidget(IconBase, Widget):
pass
'''
from kivy.lang import Builder
from kivy.metrics import dp
from kivy.properties import ObjectProperty, StringProperty, NumericProperty, \
ListProperty, OptionProperty
from kivy.uix.behaviors import ButtonBehavior
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.gridlayout import GridLayout
import material_resources as m_res #
from ripplebehavior import RectangularRippleBehavior #
from theming import ThemableBehavior #
from kivy.core.text import LabelBase
from kivy.uix.image import AsyncImage
LabelBase.register(name="OpenSans", fn_regular="Roboto-Regular.ttf")
Builder.load_string('''
#:import m_res material_resources
<MDList>
cols: 1
size_hint_y: None
height: self._min_list_height
padding: 0, self._list_vertical_padding
<BaseListItem>
size_hint_y: None
canvas:
Color:
rgba: self.theme_cls.divider_color if root.divider is not None else (0, 0, 0, 0)
Line:
points: (root.x ,root.y, root.x+self.width, root.y)\
Config.set('graphics', 'height', '500')
Config.set('graphics', 'position', 'custom')
Config.set('graphics', 'left', 800)
Config.set('graphics', 'top', 100)
from kivy.lang import Builder
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.floatlayout import FloatLayout
from kivy.core.window import Window
from kivy.uix.popup import Popup
from kivy.core.text import LabelBase
from kivy.properties import ObjectProperty
from sources.database import DataBase
from sources.forms import *
LabelBase.register(name="Arial",
fn_regular="static/fonts/arial-unicode-ms.ttf")
LabelBase.register(name="Symbola", fn_regular="static/fonts/Symbola_hint.ttf")
LabelBase.register(name="WISHFUL", fn_regular="static/fonts/WISHFULWAVES.ttf")
LabelBase.register(name="Glitch",
fn_regular="static/fonts/CFGlitchCity-Regular.ttf")
LabelBase.register(name="Pixel", fn_regular="static/fonts/pixelplay.ttf")
class A_Error(FloatLayout):
def close(self):
close_popup()
class Invalid_Form(FloatLayout):
def close(self):
close_form()
sw_seconds = 0
def update(self, nap):
if self.sw_started:
self.sw_seconds += nap
self.root.ids.time.text = strftime('[b]%H[/b]:%M:%S')
m, s = divmod(self.sw_seconds, 60)
self.root.ids.stopwatch.text = ('%02d:%02d.[size=40]%02d[/size]' %
(int(m), int(s), int(s * 100 % 100)))
def start_stop(self):
self.root.ids.start_stop.text = 'Start' if self.sw_started else 'Stop'
self.sw_started = not self.sw_started
def reset(self):
if self.sw_started:
self.root.ids.start_stop.text = 'Start'
self.sw_started = False
self.sw_seconds = 0
def on_start(self):
Clock.schedule_interval(self.update, 0)
if __name__ == '__main__':
Window.clearcolor = get_color_from_hex('#101216')
LabelBase.register(name='Rubik',
fn_regular='Rubik-Medium.ttf',
fn_bold='Rubik-Bold.ttf')
ClockApp().run()
# -*- encoding: utf-8 -*-
"""
@文件:main.py
@说明: 主程序
"""
# 字体初始化----------------------------------------
from kivy.core.text import LabelBase, DEFAULT_FONT
from kivymd.font_definitions import theme_font_styles
# 注册字体
font_file = __file__[: __file__.rfind("\\") + 1] + "siyuan.ttf"
LabelBase.register(name="SiYuan", fn_regular=font_file)
theme_font_styles.append("SiYuan")
LabelBase.register(DEFAULT_FONT, "./siyuan.ttf")
# --------------------------------------------------------------------------------
# 设置窗口大小----------------------------------------
from kivy.utils import platform
from kivy.core.window import Window
if platform == "win" or platform == "linux":
Window.size = (335, 600)
# --------------------------------------------------------------------------------
from kivymd.app import MDApp
from kivy.lang import Builder
from kivy.uix.screenmanager import ScreenManager
from kivymd.uix.snackbar import Snackbar
from Config import config, config_dict
def changeFont(self):
try:
LabelBase.register(DEFAULT_FONT, self.ids["text_font"].text)
except Exception:
self.ids["text_font"].text = "can't load font."
modal=ModalView(size_hint=(0.8,0.2))
def quit(inst):
exit()
def cancel(inst):
if modal:
modal.dismiss()
if self.root.current=="game_screen":
self.root.current_screen.newGame()
btnyes.bind(on_release=quit)
btnno.bind(on_release=cancel)
cnt.add_widget(lbl)
cnt.add_widget(btnyes)
cnt.add_widget(btnno)
modal.add_widget(cnt)
modal.open()
return
if screen=="end_screen":
self.level=1
self.root.current=screen
if self.root.current=="main_screen":
if self.snd.state=="stop":
self.snd.play()
else:
self.snd.stop()
if __name__=="__main__":
LabelBase.register(name="rb",fn_regular="robot.ttf")
LabelBase.register(name="sml",fn_regular="sml.ttf")
PuzzleGameApp().run()
from kivy.core.text import LabelBase
import sys
import os
# from kivy.core.tex
#You added this, remove it if it doesn't work
def resource_path(relative):
if hasattr(sys, "_MEIPASS"):
return os.path.join(sys._MEIPASS, relative)
return os.path.join(relative)
LabelBase.register(name="courier new",
fn_regular=resource_path(os.path.join('', 'Courier New.ttf')))
LabelBase.DEFAULT = "courier new"
# C:/Users/Jonathan/PycharmProjects/EloTab/
from kivy.app import App
from kivy.uix.button import Button
from kivy.uix.textinput import TextInput
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.label import Label
from kivy.core.text import LabelBase
#font file needs to be in the folder
LabelBase.register(name="Dodger", fn_regular="dodger3condital.ttf")
LabelBase.register(name="Roboto", fn_regular="RobotoSlab-Regular.ttf")
import serial
import threading
import serial.tools.list_ports
import pyglet
import multiprocessing
from apscheduler.schedulers.background import BackgroundScheduler
import os
SERIAL_PORT = ""
def port_listB():
try:
comlist = serial.tools.list_ports.comports()
connected = []
for element in comlist:
connected.append(element.device)
print("Connected COM ports: " + str(connected))
label2.text = "Connected COM ports: " + str(connected)
except:
label2.text = 'serial problem'
import re
import codecs
import time
import math
import glob
import pygame.mixer
import datetime
from calendar import Calendar
from dateutil.relativedelta import relativedelta
# ファイルのパス(main.pyがあるフォルダの中にあるファイルの絶対パス)
# file_path = os.path.dirname(os.path.abspath(__file__))
# フォントの設定
resource_add_path('fonts')
LabelBase.register(DEFAULT_FONT, 'ipaexg.ttf')
# 各種データ一時保存用
class Holder():
status = ""
class PopupList(BoxLayout):
schedule = StringProperty("")
cancel = ObjectProperty(None)
delete = ObjectProperty(None)
save = ObjectProperty(None)
@classmethod
def set_label(self, txt):
from kivy.app import App
from kivy.lang import Builder
from kivy.config import Config
from kivy.uix.screenmanager import ScreenManager
from kivy.core.text import LabelBase
from model import Board, Problem
from view import SudokuScreen
from view.widget import *
Config.set('graphics', 'width', '320')
Config.set('graphics', 'height', '480')
Builder.load_file('kv/sudoku.kv')
LabelBase.register(
'SeoulNamsan',
fn_regular='static/font/SeoulNamsanM.ttf',
fn_bold='static/font/SeoulNamsanB.ttf')
problem = Problem.loads(
"800523910162489075350170420425008009690000"
"057700600234037062041540317692016954003",
"87452391616248937535917642842573816969324185"
"7781695234937862541548317692216954783",
9)
board = Board(problem)
sm = ScreenManager()
sm.switch_to(SudokuScreen(board_model=board))
super(MainLayout, self).__init__(**kwargs)
def return_to_page(self, page):
self.ids.manager.current = page
class PharmacyApp(App):
theme_cls = ThemeManager()
def build(self):
return MainLayout()
def on_pause(self):
return True
def on_stop(self):
pass
if __name__ == '__main__':
# windows full screen
Window.maximize()
LabelBase.register(name='PICTO', fn_regular='includes/modernpics.otf')
LabelBase.register(name='rap', fn_regular='includes/raphaelicons-webfont.ttf')
IconFonts().register('default_font', 'includes/ionicons/ionicons.ttf',
join(dirname(__file__), 'includes/ionicons/ionicons.fontd'))
IconFonts().register('fontawesome', 'includes/fontaweasome/fontawesome-webfont.ttf',
join(dirname(__file__), 'includes/fontaweasome/font-awesome.fontd'))
PharmacyApp().run()
from kivy.uix.image import Image
from kivy.uix.button import Button
from kivy.core.window import Window
from kivy.uix.floatlayout import FloatLayout
from kivy.adapters.listadapter import ListAdapter
from kivy.uix.listview import ListView, ListItemButton
from kivy.core.text import LabelBase
Window.clearcolor = (1, 1, 1, 1)
KIVY_FONTS = [{
"name": "Soft Elegance",
"fn_regular": "fonts/Soft Elegance.ttf",
}]
for font in KIVY_FONTS:
LabelBase.register(**font)
class MainApp(App):
def build(self):
''''Initialisation de l'app (text et bouton)'''
self.fenetre = FloatLayout()
self.date = 'Aujourd\'hui'
self.label_ville_depart = 'Ville de départ' #pour les test : 'Ville de départ !' en temp normal
self.ville_depart = None #pour les test : None en temp normal
self.arret_depart = None #pour les test : None en temp normal
self.status_ville_depart = None #permet de gerer si c'est pour le bouton de depart ou d'arriver
self.label_ville_arriver = 'Ville d\'arriver' #pour les test : 'Ville d\'arriver !' en temp normal
self.ville_arriver = None #pour les test : None en temp normal
self.arret_arriver = None #pour les test : None en temp normal
self.init_list_adapter_alphabet()
self.init_list_adapter_ville([])
def createTickets(self, parts, font_color, border_color):
# Шрифт
LabelBase.register(name='CG', fn_regular=paths['font'])
with self.canvas:
Color(0, 0, 0, 1) #black
# Базовые размеры
w = 595
h = 842
# Отступ
margin = 28
marginY = 369
# Промежуток
middleX = 9
middleY = 65
# Размеры билета
ticketX = 567
ticketY = 369
# Размеры ячейки
cell = 128
# Фон
Color(1, 1, 1, 1) #white
self.canvas.add(Rectangle(size=[w, h], pos=[0, 0]))
# Изображение
imageX = 111
imageY = 45
# Билеты
tickets = [None] * int(len(parts) / 8)
for i in range(len(tickets)):
tickets[i] = [None] * 8
num = 0
for i in range(len(parts)):
if (num / 8 == 1):
num = 0
tickets[int(i / 8)][num] = parts[i]
num += 1
# trigger запускает отрисовку второго билета на листе
trigger = 0
for i in range(len(tickets)):
Color(0, 0, 0, 1) #black
self.canvas.add(
Line(rectangle=(0, marginY * trigger, w, ticketY),
width=1))
for num in range(len(tickets[i])):
# Ряд в билете
j = 1
j += int(num / 4)
# Формирование содержимого ячейки
name = CoreLabel(font_name='CG',
text=str(tickets[i][num]),
font_size=45)
name.refresh()
name = name.texture
Color(rgba=border_color)
self.canvas.add(
Line(rectangle=(margin + (cell + middleX) *
(num - (j - 1) * 4),
margin + (cell + middleY) * (j - 1) +
marginY * trigger, cell, cell),
width=3))
Color(rgba=font_color)
self.canvas.add(
Rectangle(size=name.size,
pos=(margin + (cell + middleX) *
(num - (j - 1) * 4) + cell / 2 -
name.size[0] / 2, margin +
(cell + middleY) * (j - 1) + cell / 2 -
name.size[1] / 2 + marginY * trigger),
texture=name))
# Добавление логотипов на билет
self.canvas.add(
Rectangle(source=paths['logo'],
size=(imageX, imageY),
pos=(ticketX / 3 - imageX / 2,
margin + cell + middleY / 2 - imageY / 2 +
marginY * trigger)))
self.canvas.add(
Rectangle(source=paths['logo'],
size=(imageX, imageY),
pos=((ticketX / 3) * 2 - imageX / 2,
margin + cell + middleY / 2 - imageY / 2 +
marginY * trigger)))
trigger = 1
# -*- coding: utf-8 -*
import os
import kivy
from kivy.app import App
from kivy.core.window import Window
from kivy.factory import Factory
from kivy.uix.boxlayout import BoxLayout
# 日本語フォント表示対応
from kivy.core.text import LabelBase, DEFAULT_FONT
from kivy.resources import resource_add_path
resource_add_path('{}\\{}'.format(os.environ['SYSTEMROOT'], 'Fonts'))
LabelBase.register(DEFAULT_FONT, 'MSGOTHIC.ttc')
# kvファイルを画面ごとに分離してバラで読み込む
from kivy.lang import Builder
Builder.load_file(
"C:\Users\AOKI\Anaconda3\envs\reinforcement\Lib\site-packages\kivy\lang\window1.kv"
)
Builder.load_file(
"C:\Users\AOKI\Anaconda3\envs\reinforcement\Lib\site-packages\kivy\lang\window2.kv"
)
class MainRoot(BoxLayout):
window1 = None
window2 = None
if platform == 'android':
resource_add_path('/system/fonts/')
set_regular(DEFAULT_FONT,
'DroidSansJapanese.ttf',
'MTLmr3m.ttf',
'MTLc3m.ttf',
'NotoSansJP-Regular.otf',
'SomcUDGothic-Regular.ttf',
'LCMincho.ttf',
'DroidSansFallback.ttf')
else:
Config.set('graphics', 'width', '480')
Config.set('graphics', 'height', '854')
resource_add_path('/Users/user/Library/Fonts')
LabelBase.register(DEFAULT_FONT, 'NotoSansCJKjp-Thin.otf')
class Sticker(BoxLayout):
placeString = StringProperty()
question = NumericProperty()
resultString = StringProperty()
dismissString = StringProperty()
remainTimeString = StringProperty()
remainTimeColor = ListProperty()
score = NumericProperty()
def __init__(self, **kwargs):
super(Sticker, self).__init__(**kwargs)
self.placeString = '指定なし'
self.daioki = 1
Clock.schedule_interval(self.update_time, 0)
def update_time(self, nap):
self.root.ids.time.text = strftime('[b]%H[/b]:%M:%S')
if self.sw_started:
self.sw_seconds += nap
minutes, seconds = divmod(self.sw_seconds, 60)
self.root.ids.stopwatch.text = (
'%02d:%02d.[size=40]%02d[/size]' %
(int(minutes), int(seconds), int(seconds * 100 % 100)))
def start_stop(self):
self.root.ids.start_stop.text = 'Start' if self.sw_started else 'Stop'
self.sw_started = not self.sw_started
def reset(self):
if self.sw_started:
self.root.ids.start_stop.text = 'Start'
self.sw_started = False
self.sw_seconds = 0
if __name__ == '__main__':
Window.clearcolor = get_color_from_hex('#101216')
LabelBase.register(name='Roboto',
fn_regular='fonts/Roboto-Thin.ttf',
fn_bold='fonts/Roboto-Medium.ttf')
ClockApp().run()
Config.set("graphics","width","450")
Config.set("graphics","height","600")
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.screenmanager import ScreenManager,SlideTransition
from index import MainScreen
from home import HomeScreen
from kivy.core.window import Window
from addpanel import *
from kivy.core.text import LabelBase
Builder.load_file("loaderscreen.kv")
class UmutRssManager(ScreenManager):
pass
class UmutrssApp(App):
use_kivy_settings = False
def build(self):
self.root=UmutRssManager(transition=SlideTransition())
Window.bind(on_keyboard=self.hook_kb)
return self.root
def hook_kb(self, win, key, *largs):
if key == 27:
if self.root:
prev = self.root.previous()
self.root.current = prev
return True
return False
if __name__ == '__main__':
LabelBase.register(name="ubu",fn_regular="ubuntu.ttf")
LabelBase.register(name="ifont",fn_regular="Byom-Icons-Trial.ttf")
UmutrssApp().run()
orientation:"vertical"
size_hint:.1,.8
pos_hint:{"top":1}
Button:
text:"`"
Button:
text:"D"
Button:
text:"E"
Button:
text:"i"
AnchorLayout:
anchor_x:"left"
acnhor_y:"top"
AsyncImage:
size_hint:0.9,.8
id:_img
source:"rotational.jpg"
AnchorLayout:
anchor_x:"center"
anchor_y:"bottom"
BoxLayout:
size_hint:.1,0.1
FButton:
text:"H"
FButton:
text:"G"
''')
if __name__ == '__main__':
LabelBase.register(name="ifont",fn_regular="PWSmallIcons.ttf")
runTouchApp(kv)
from kivy.uix.button import Button
from kivy.properties import ObjectProperty
from kivy.uix.floatlayout import FloatLayout
from kivy.adapters.dictadapter import DictAdapter
from kivy.adapters.listadapter import ListAdapter
from kivy.base import EventLoop
import time
from kivy.clock import Clock
import json
from kivy.uix.popup import Popup
from kivy.logger import Logger
import datetime
from kivy.core.text import LabelBase
LabelBase.register(name="FreeMono",
fn_regular="FontFiles/FreeMono.ttf",
fn_bold="FontFiles/FreeMonoBold.ttf",
fn_italic="FontFiles/FreeMonoOblique.ttf",
fn_bolditalic="FontFiles/FreeMonoBoldOblique.ttf")
from kivy.uix.rst import RstDocument
from kivy.uix.tabbedpanel import TabbedPanelItem
Builder.load_file('newprojectform.kv')
Builder.load_file('generalmenu.kv')
# global variable
PERSON = ''
class LoginPage(AnchorLayout):
def __init__(self, **kwargs):
super(LoginPage, self).__init__(**kwargs)
from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.boxlayout import BoxLayout
from kivy.clock import Clock
from kivy.resources import resource_add_path
from kivy.core.text import LabelBase, DEFAULT_FONT
resource_add_path("font")
LabelBase.register(DEFAULT_FONT, "Cica-Bold.ttf")
from kivy.config import Config
Config.set('graphics', 'width', '1280')
Config.set('graphics', 'height', '720')
Config.set('input', 'mouse', 'mouse,disable_multitouch')
import os
from kivy.lang import Builder
from src.buttonzone import *
from src.cmdzone import *
from src.stackzone import *
kvfiles = [
'ButtonZone.kv',
'CmdZone.kv',
'StackZone.kv',
'denomination.kv',
]
kv_path = 'kv'
import kivy
from kivy.core.text import LabelBase
from kivy.app import App
from kivy.uix.button import Button
from kivy.uix.popup import Popup
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.properties import ObjectProperty, StringProperty, BooleanProperty
from PIL import Image, ImageEnhance
import sys
LabelBase.register(name='Nunito', fn_regular= 'assets/fonts/Nunito-Regular.ttf',
fn_bold= 'assets/fonts/Nunito-Bold.ttf')
class VBoxWidget(BoxLayout):
def __init__(self, **kwargs):
# make sure we aren't overriding any important functionality
super(VBoxWidget, self).__init__(**kwargs)
def filter_one(self, source_image):
source_image = App.get_running_app().source_image
image = Image.open(source_image)
enhance_value = 1.5
image = ImageEnhance.Contrast(image).enhance(enhance_value)
image.save("images/new_image.png")
image = "images/new_image.png"
self.source_image.source = "images/new_image.png"
self.source_image.reload()
from kivy.core.text import LabelBase
from kivy.core.window import Window
from kivy.utils import get_color_from_hex
FONT_DIR = 'fonts/'
LabelBase.register(name='Roboto',
fn_regular=FONT_DIR + 'Roboto-Regular.ttf',
fn_italic=FONT_DIR + 'Roboto-Italic.ttf',
fn_bold=FONT_DIR + 'Roboto-Bold.ttf',
fn_bolditalic=FONT_DIR + 'Roboto-BoldItalic.ttf')
BACKGROUND_COLOR = '#101215'
Window.clearcolor = get_color_from_hex(BACKGROUND_COLOR)
# create an animation object. This object could be stored
# and reused each call or reused across different widgets.
# += is a sequential step, while &= is in parallel
#print("hello")
animation = Animation(pos=(instance.parent.width - 500, -20),
duration=3.)
animation = animation + Animation(pos=(0, -20), duration=3.)
# apply the animation on the button, passed in the "instance" argument
# Notice that default 'click' animation (changing the button
# color while the mouse is down) is unchanged.
animation.repeat = True
animation.start(instance)
def click(self, instance):
#print(instance.children)
instance.children[0].trigger_action()
if __name__ == "__main__":
LabelBase.register(name="Broadway", fn_regular="fonts/BroadwayFlat.ttf")
LabelBase.register(name="Baskerville",
fn_regular="fonts/BaskervilleBoldfont.ttf")
LabelBase.register(name="BodoniFLF-Bold",
fn_regular="fonts/BodoniFLF-Bold.ttf")
LabelBase.register(name="arb", fn_regular="fonts/ArialRoundedBold.ttf")
LabelBase.register(name="crimson", fn_regular="fonts/Crimson-Roman.ttf")
LabelBase.register(name="ComicSansMS3", fn_regular="fonts/comicz.ttf")
LabelBase.register(name="brush", fn_regular="fonts/BRUSHSCI.ttf")
BusIO().run()
"name": "BebasNeue",
"fn_regular": "fonts/BebasNeue-Regular.otf",
"fn_bold": "fonts/BebasNeue-Bold.otf",
}, {
"name": "SourceSansPro",
"fn_regular": "fonts/SourceSansPro-Regular.otf",
"fn_bold": "fonts/SourceSansPro-Bold.otf",
}, {
"name": "OstrichSans",
"fn_regular": "fonts/OstrichSans-Regular.ttf",
"fn_bold": "fonts/OstrichSans-Bold.otf",
}
]
for font in KIVY_FONTS:
LabelBase.register(**font)
class JournalInterfaceManager(BoxLayout):
def __init__(self, **kwargs):
super(JournalInterfaceManager, self).__init__(**kwargs)
self.windows = {}
self.current_window = None
# initially load the journal window as main window
journal_menu = Journal()
self.add_window("home", journal_menu)
self.load_window("home")
self.windows['home'].get_top_mistakes()
import kivy
import time
from datetime import time
from kivy.app import App
from kivy.core.text import LabelBase
from kivy.uix.label import Label
from kivy.core.window import Window
from kivy.utils import get_color_from_hex
from kivy.clock import Clock
from time import gmtime, strftime
Window.clearcolor = get_color_from_hex('#101216')
LabelBase.register(name="Roboto",
fn_regular="Roboto-Thin.ttf",
fn_bold="Roboto-Medium.ttf")
class ClockApp(App):
def update_time(self, nap):
self.root.ids.time.text = strftime('[b]%H[/b]:%M:%S')
def on_start(self):
Clock.schedule_interval(self.update_time, 1)
pass
if __name__ == '__main__':
ClockApp().run()
from kivy.uix.widget import Widget
from kivy.core.window import Window
Window.clearcolor = get_color_from_hex('#101216')
Window.size = (600,150)
import pygame
pygame.init()
pygame.mixer.init()
MUSIC_DIR = 'music/'
TTF_DIR = "ttf/"
LabelBase.register(
name="Roboto",
fn_regular = TTF_DIR + "Roboto-Regular.ttf",
fn_bold = TTF_DIR + "Roboto-Bold.ttf",
fn_italic = TTF_DIR + "Roboto-Italic.ttf",
fn_bolditalic = TTF_DIR + "Roboto-BoldItalic.ttf")
animations = {
0:'in_back',
1:'in_bounce',
2:'in_circ',
3:'in_cubic',
4:'in_elastic',
5:'in_expo',
6:'in_out_back',
7:'in_out_bounce',
8:'in_out_circ',
9:'in_out_cubic',
10:'in_out_elastic',
Config.set('kivy', 'default_font', scribe_globals.DEFAULT_FONT_FILES)
# Add resources paths
from kivy.resources import resource_add_path
if getattr(sys, 'frozen', False):
resource_add_path(scribe_globals.APP_WORKING_DIR)
resource_add_path(scribe_globals.ASSETS_DIR)
resource_add_path(scribe_globals.IMAGES_DIR)
resource_add_path(scribe_globals.SOUNDS_DIR)
# Register app's fonts
from kivy.core.text import LabelBase
LabelBase.register(name='DroidSans',
fn_regular=join(scribe_globals.FONTS_DIR, 'DroidSans.ttf'),
fn_italic=join(scribe_globals.FONTS_DIR,
'DroidSans-Italic.ttf'),
fn_bold=join(scribe_globals.FONTS_DIR,
'DroidSans-Bold.ttf'),
fn_bolditalic=join(scribe_globals.FONTS_DIR,
'DroidSans-BoldItalic.ttf'))
LabelBase.register(name='FreeSans',
fn_regular=join(scribe_globals.FONTS_DIR, 'FreeSans.ttf'))
LabelBase.register(name='FreeSansTTScribe',
fn_regular=join(scribe_globals.FONTS_DIR,
'FreeSansTTScribe.ttf'))
LabelBase.register(name='CourierNewTTScribe',
fn_regular=join(scribe_globals.FONTS_DIR,
'Courier-New.ttf'))
# Register app's widgets
import ia_scribe.factory_registers
def update(self, nap):
# wall clock
self.root.ids.time.text = strftime('[b]%H[/b]:%M:%S')
# timer
if self.sw_started:
self.sw_seconds += nap
minutes, seconds = divmod(self.sw_seconds, 60)
self.root.ids.stopwatch.text = (
'%02d:%02d.[size=40]%02d[/size]' %
(int(minutes), int(seconds),
int(seconds * 100 % 100)))
def start_stop(self):
self.root.ids.start_stop.text = ('Start'
if self.sw_started else 'Stop')
self.sw_started = not self.sw_started
def reset(self):
if self.sw_started:
self.root.ids.start_stop.text = 'Start'
self.sw_started = False
self.sw_seconds = 0
if __name__ == '__main__':
Window.clearcolor = get_color_from_hex('#101216')
LabelBase.register(name='Roboto',
fn_regular = data_dir + 'Roboto-Thin.ttf',
fn_bold = data_dir + 'Roboto-Medium.ttf')
ClockApp().run()
# -*- coding: utf-8 -*-
import sys, random
sys.dont_write_bytecode = True
import types
from kivy.clock import Clock
from kivy.core.text import LabelBase, DEFAULT_FONT
from kivy.resources import resource_add_path
LabelBase.register(DEFAULT_FONT, "ipaexg.ttf")
from kivy.app import App
from kivy.core.window import Window
Window.size = (480, 720)
from dataclasses import dataclass
from kivy.factory import Factory
# 処理一時停止のための機能
def start_coro(coro):
def step_coro(*args, **kwargs):
try:
coro.send((
args,
kwargs,
))(step_coro)
except StopIteration:
pass
try:
coro.send(None)(step_coro)
except StopIteration:
pass
self.is_recording = False
self.root.ids.begin_end_recording.text = \
('[font=Modern Pictograms][size=120]'
'e[/size][/font]\nBegin recording')
return
init_recorder()
recorder.start()
self.is_recording = True
self.root.ids.begin_end_recording.text = \
('[font=Modern Pictograms][size=120]'
'%[/size][/font]\nEnd recording')
def begin_playback(self):
restart_player()
def delete_file(self):
reset_player()
File(storage_path).delete()
if __name__ == '__main__':
Logger.info('App: storage path == "%s"' % storage_path)
Config.set('graphics', 'width', '600')
Config.set('graphics', 'height', '900')
LabelBase.register(name='Modern Pictograms',
fn_regular='modernpics.ttf')
RecorderApp().run()
self.root.ids.stopwatch.text = (
'%02d:%02d.[size=40]%02d[/size]' %
(int(minutes), int(seconds),
int(seconds * 100 % 100))
)
def start_stop(self):
self.root.ids.start_stop.text = ('Start' if self.sw_started else 'Stop')
self.sw_started = not self.sw_started
def reset(self):
if self.sw_started:
self.root.ids.start_stop.text = 'Start'
self.sw_started = not self.sw_started
self.root.ids.stopwatch.text = '00:00.[size=40]00[/size]'
self.sw_seconds = 0
if __name__ == "__main__":
LabelBase.register(name='Roboto',
fn_regular='fonts/roboto/Roboto-Thin.ttf',
fn_bold='fonts/roboto/Roboto-Medium.ttf')
Window.clearcolor = get_color_from_hex('#101216')
ClockApp().run()
self.root.time_prop.text = strftime('[b]%H[/b]:%M:%S')
self.root.ids.stopwatch.text = (
'%02d:%02d.[size=40]%02d[/size]' %
(int(minutes), int(seconds),
int(seconds * 100 % 100))
)
def on_start(self):
Clock.schedule_interval(self.update_time, 0)
def start_stop(self):
self.root.ids.start_stop.text = ('Start' if self.sw_started else 'Stop')
self.sw_started = not self.sw_started
def reset(self):
if self.sw_started:
self.root.ids.start_stop.text = 'Start'
self.sw_started = False
self.sw_seconds = 0
if __name__ == "__main__":
from kivy.core.window import Window
from kivy.utils import get_color_from_hex
Window.clearcolor = get_color_from_hex('#101216')
LabelBase.register(name="Roboto",
fn_regular="Roboto-Thin.ttf",
fn_bold='Roboto-Medium.ttf')
ClockApp().run()
from random import sample
from string import ascii_lowercase
#アプリケーションの生成に必要
from kivy.app import App
from kivy.lang import Builder
from kivy.uix.boxlayout import BoxLayout
#フォントの読み込みに必要
from kivy.core.text import LabelBase, DEFAULT_FONT
from kivy.resources import resource_add_path
# デフォルトに使用するフォントを変更する
resource_add_path('./fonts')
#resource_add_path('/storage/emulated/0/kivy/calc/fonts')
LabelBase.register(DEFAULT_FONT,
'mplus-2c-regular.ttf') #日本語が使用できるように日本語フォントを指定する
kv = """
<Row@BoxLayout>:
#canvasへの色つけ
canvas.before:
Color:
rgba: 0.5, 0.5, 0.5, 1
Rectangle:
size: self.size
pos: self.pos
value: ''
Label:
text: root.value #それぞれのボタンを押して反映される値
#テストクラスで呼べるようにする
class EndGameScreen(Screen):
pass
class ScoreMenu(Screen):
scroll=ObjectProperty(None)
list=None
def on_pre_enter(self, *args):
super(ScoreMenu,self).on_pre_enter(*args)
if self.scroll.children.__len__()>0:
self.scroll.clear_widgets()
self.scroll.add_widget(MiLabel(text="Math6 Game Top 20",font_size="60px",color=Clr("#ead9ed")))
cnt=self.list.__len__()
if cnt>20:
cnt=20
for i in range(cnt):
lbl=MiLabel(text=str(i+1)+"."+self.list[i]["ad"]+" "+self.list[i]["puan"])
self.scroll.add_widget(lbl)
self.scroll.bind(minimum_height=self.scroll.setter("height"))
sm=ScreenManager()
if __name__ == '__main__':
Builder.load_file("kymath.kv")
LabelBase.register(name="rt",fn_regular="Roboto-Light.ttf")
LabelBase.register(name="myfont",fn_regular="byom.ttf")
sm.add_widget(MenuScreen())
sm.add_widget(GameScreen())
sm.add_widget(EndGameScreen())
sm.add_widget(ScoreMenu())
KyMathApp().run()
on_release:
root.manager.current = 'quiz'
root.manager.transition.direction = 'left'
""")
# Declare screen manager and screens
class ScrnMngr(ScreenManager):
# category_tracker = ['Balay', 'Pamilya-timbaya']
category_tracker = ['Balay', 'kan-anan']
class Portal(Screen):
pass
class QuizTestApp(MDApp):
def build(self):
# Create the screen manager
sm = ScrnMngr()
q = QuizPage(cat = sm.category_tracker[0], subcat = sm.category_tracker[1], name = "quiz")
sm.add_widget(Portal())
sm.add_widget(q)
return sm
#Registering Font
LabelBase.register(name="Mont",
fn_regular= "font/Mont-ExtraLightDemo.otf",
fn_bold = "font/Mont-HeavyDEMO.otf"
)
if __name__ == '__main__':
QuizTestApp().run()
from kivy.core.text import LabelBase
from kivy.core.window import Window
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.checkbox import CheckBox
from kivy.uix.gridlayout import GridLayout
from kivy.uix.image import Image
from kivy.uix.label import Label
from kivy.uix.scrollview import ScrollView
from kivy.uix.textinput import TextInput
reload(sys)
sys.setdefaultencoding('utf-8')
LabelBase.register(name="NotoSans",
fn_regular="NotoSans-hinted/NotoSansUI-Regular.ttf",
fn_bold="NotoSans-hinted/NotoSansUI-Bold.ttf",
fn_italic="NotoSans-hinted/NotoSansUI-Italic.ttf",
fn_bolditalic="NotoSans-hinted/NotoSansUI-BoldItalic.ttf")
Config.set('graphics', 'default_font',
'[‘Roboto’, ‘data/fonts/uming.ttc’, ‘data/fonts/uming.ttc’, ‘data/fonts/uming.ttc’, ‘data/fonts/uming.ttc’]')
'''
Coordinate Key: This is for color value
A1=0 A2=21----A3=22 A4=43----A5=44 A6=65----A7=66 A8=87----A9=88 A10=109----A11=110 A12=131----A13=132 A14=153----A15=154 A16=175----A17=176 A18=197
| | | | | | | | | | | | | | | | | |
B1=1 B2=20 B3=23 B4=42 B5=45 B6=64 B7=67 B8=86 B9=89 B10=108 B11=111 B12=130 B13=133 B14=152 B15=155 B16=174 B17=177 B18=196
| | | | | | | | | | | | | | | | | |
C1=2 C2=19 C3=24 C4=41 C5=46 C6=63 C7=68 C8=85 C9=90 C10=107 C11=112 C12=129 C13=134 C14=151 C15=156 C16=173 C17=178 C18=195
| | | | | | | | | | | | | | | | | |
D1=3 D2=18 D3=25 D4=40 D5=47 D6=62 D7=69 D8=84 D9=91 D10=106 D11=113 D12=128 D13=135 D14=150 D15=157 D16=172 D17=179 D18=194
}
}
for report in reports:
report_dict[report["report_type"]]["Text"] = report["report_text"]
report_dict[
report["report_type"]]["Time Stamp"] = report["time_stamp"]
self.flyer_open_panel.ids.perf_report.text = report_dict[
"Performance"]["Text"]
self.flyer_open_panel.ids.orgdev.text = report_dict["OrgDev"]["Text"]
self.flyer_open_panel.ids.rewards.text = report_dict["Rewards"]["Text"]
def changePassword(self, *args):
password_field_1 = self.flyer_open_panel.ids.flyer_password_changer.ids.password_new_1.text
password_field_2 = self.flyer_open_panel.ids.flyer_password_changer.ids.password_new_2.text
if password_field_1 == password_field_2:
self.password = password_field_1
Elijah.changePassword(self.user_id, self.password)
#print "Changed password to %s" %self.password
if __name__ == '__main__':
Window.clearcolor = get_color_from_hex('#0088D6')
regular_font = os.path.join('fonts', 'RionaSans-Regular.ttf')
bold_font = os.path.join('fonts', 'RionaSans-Bold.ttf')
italic_font = os.path.join('fonts', 'RionaSans-Italic.ttf')
LabelBase.register(name='Riona',
fn_regular=regular_font,
fn_bold=bold_font,
fn_italic=italic_font)
FlyerApp().run()
self.ipfetched=True
def reset(self):
if self.sw_started:
self.root.ids.start_stop.text = 'Start'
self.sw_started = False
self.sw_seconds = 0
def restart(self):
print ("Restarting..")
def start_debug(self):
print ("Enter debug mode")
self.debug=True
def testme(self):
print ("Testing")
if __name__ == '__main__':
Window.clearcolor = get_color_from_hex('#101216')
LabelBase.register(name='Roboto',
fn_regular='Roboto-Light.ttf',
fn_bold='Roboto-Medium.ttf')
ClockApp().run()
def Init():
resource_add_path(os.path.abspath("./resource"))
LabelBase.register(define.FONT_COMMON, "./font/simkai.ttf")
LabelBase.register(define.FONT_HEI, "./font/simhei.ttf")
from kivy.app import App
from kivy.core.text import LabelBase
from tparty.game_logic import getGameLogic
from tparty.screens import GameScreenManager
import pybox2d
# register font
LabelBase.register(name="SuperMario256",
fn_regular="data/fonts/SuperMario256.ttf",
fn_bold="data/fonts/SuperMario256.ttf",
fn_italic="data/fonts/SuperMario256.ttf",
fn_bolditalic="data/fonts/SuperMario256.ttf")
class TabletPartyApp(App):
def build(self):
gameScreenManager = GameScreenManager()
gameLogic = getGameLogic()
gameLogic.gameScreenManager = gameScreenManager
return gameScreenManager # #canvas.before:
# #Rectangle:
# # pos: self.pos
# # size: self.size
# # #source: 'data/images/rounded.png'background_color: (0,0,0,0)
#Image:
# source: 'data/images/rounded.png'
#Set Window size
Config.set('graphics', 'height', '500') # Set height to 500
Config.set('graphics', 'width', '1000') # Set width to 1000
Config.set('graphics', 'resizable',
'0') # Does not allow to set height and width by user
Config.set('input', 'mouse', 'mouse,disable_multitouch'
) # Disables kivy's multitouch simulation in the app
#Adding a font to kivy for the outputs
KIVY_FONTS = [{
"name": "Consola",
"fn_regular": "data/fonts/consola.ttf",
}]
for font in KIVY_FONTS:
LabelBase.register(**font)
# Class that contains all the functionality of the application
class NoiseMakerFunc(FloatLayout):
# This function will send the deauthentication packet and print to the program
def outputPacket(self, nssid, sendiface, client, packet):
self.ids.resultOutput.text += 'Deauth sent via: ' + sendiface + ' to BSSID: ' + nssid + ' for Client: ' + client + "\n"
sendp(packet) # Sends the deauthentication packet
return
# This function will define the deauthentication packet and refer to the send function
def SendPacket(self):
try:
def CreateBase(self,Parent,WidgetIndex,Class):
try:
self.oParent = Parent
self.iWidgetIndex = WidgetIndex
self.iPosX = self.iPosXInit/self.oDef.fRationX
self.iPosY = self.iPosYInit/self.oDef.fRationY
self.iWidth = self.iWidthInit/self.oDef.fRationX
self.iHeight = self.iHeightInit/self.oDef.fRationY
self.iFontSize = self.iFontSizeInit/self.oDef.fRationX
if self.iWidgetType==oWidgetType.BackGround:
self.iGapX = 0
self.iGapY = 0
self.iHeight = oORCA.iAppHeight
self.iWidth = oORCA.iAppWidth
iKivyPosX = self.iPosX+self.iGapX
iKivyPosY = oORCA.iAppHeight-self.iHeight-self.iPosY-self.iGapY
self.AddArg('pos',(iKivyPosX,iKivyPosY ))
self.AddArg('size',(self.iWidth,self.iHeight))
if not self.tBackGroundColor==[0.0,0.0,0.0,0.0]:
self.AddArg('background_color',self.tBackGroundColor)
if not self.bEnabled:
self.AddArg('opacity',0)
if self.bHasText:
self.AddArg('halign', self.uhTextAlign)
self.AddArg('valign', self.uvTextAlign)
self.AddArg('color', self.tTextColor)
self.AddArg('foreground_color', self.tTextColor)
self.AddArg('italic', self.bItalic)
self.AddArg('bold', self.bBold)
if not self.bNoTextSize:
self.AddArg('text_size', (self.iWidth,self.iHeight))
self.AddArg('font_name', self.uFontIndex)
self.AddArg('text' , self.uCaption)
self.SetCaption2(self.uCaption)
#self.oObject.shorten= True
if self.iFontSize > 0:
# a further unicode bug in kivy: font_size just except strings not unicode strings
self.AddArg('font_size',str(self.iFontSize)+'px')
# Fonts are loaded at initialisation, but if we load elements at runtime, the font might not be registered
if not self.uFontIndex in oORCA.oTheScreen.aUsedFonts:
oFont=oORCA.oTheScreen.aFonts[self.uFontIndex]
Logger.debug (u'Register Font at runtime: '+self.uFontIndex)
LabelBase.register(oFont.uName, oFont.uFileNameNormal, oFont.uFileNameItalic, oFont.uFileNameBold, oFont.uFileNameBoldItalic)
oORCA.oTheScreen.aUsedFonts[self.uFontIndex]=oFont
if not Class=='':
self.oObject = Class(**self.aKwArgs)
self.oObject.oOrcaWidget = self
if oORCA.bShowBorders:
if (not isinstance(self.oObject, Layout)) and (not self.iWidgetType == oWidgetType.Knob):
self.oBorder = cBorder(**self.aKwArgs)
self.oObject.add_widget(self.oBorder)
return True
except Exception as e:
LogError(u'Can''t create widget:'+self.uName,e)
return False
def changeFont(self):
try:
LabelBase.register(DEFAULT_FONT, self.ids["text_font"].text)
except Exception:
self.ids["text_font"].text = "can't load font."
