def __init__(self, **kwargs):
LabelBase.register(name='SukhumvitSet',
fn_regular=APP_FOLDER_NAME +
'\\lib\\resources\\SukhumvitSet-Medium.ttf',
fn_italic=APP_FOLDER_NAME +
'\\lib\\resources\\SukhumvitSet-Medium.ttf',
fn_bold=APP_FOLDER_NAME +
'\\lib\\resources\\SukhumvitSet-Bold.ttf',
fn_bolditalic=APP_FOLDER_NAME +
'\\lib\\resources\\SukhumvitSet-Bold.ttf')
theme_font_styles.append('SukhumvitSet')
self.theme_cls.font_styles['SukhumvitSet'] = [
'SukhumvitSet',
16,
False,
0.15,
]
self.theme_cls.primary_palette = 'Blue'
super().__init__(**kwargs)
#self.dialog_change_theme = None
#self.toolbar = None
self.snackbar = None
def set(family, *filenames):
for f in filenames:
try:
LabelBase.register(family, f)
break
except BaseException:
pass
def build(self):
# importando e lendo manualmente o arquivo .kv para forçar a codificação utf-8
# e corrigir problemas de caracteres incompatíveis
Builder.load_string(open("splashscoreapp.kv", encoding="utf-8").read(), rulesonly=True)
#registra nova fonte personalizada
LabelBase.register(name='CursedTimer',fn_regular='font/CursedTimerUlil-Aznm.ttf')
return Manager()
def build(self):
KIVY_FONTS = [
{
"name": "Y2",
"fn_regular": "resources/fonts/GothamBook.otf"
}
]
for font in KIVY_FONTS:
LabelBase.register(**font)
self.root = self.create_screens()
self.title = "Internbot - 1.2.0"
self.root.bind(size=self._update_rect, pos=self._update_rect)
self.root.bind(on_close=self.play_close)
with self.root.canvas.before:
self.rect = Rectangle(size=self.root.size, pos=self.root.pos, source='resources/images/DWTWNSLC.png')
self.open_sound = SoundLoader.load('resources/sounds/open.mp3')
self.close_sound = SoundLoader.load('resources/sounds/close.mp3')
self.icon = 'resources/images/y2.icns'
self.open_sound.play()
self.__controller = None
return self.root
def __init__(self, **kwargs):
super(main_display, self).__init__(**kwargs)
resource_add_path('./fonts')
LabelBase.register(DEFAULT_FONT, 'ARIALUNI.TTF')
Window.clearcolor = (1, 1, 1, 1)
session = ObjectProperty()
headers = ObjectProperty()
self.cols = 1
search_bar = Builder.template('Search_Bar', size_hint=(1, 0.06))
self.add_widget(search_bar)
info_display = GridLayout(cols=1, spacing=10, size_hint_y=None)
info_display.bind(minimum_height=info_display.setter('height'))
self.session, self.headers, search_result = self.search('')
if search_result != []:
for novel in search_result:
novel_info_view = Builder.template('Novel_Info',
**novel,
cols=1,
size_hint_y=None)
info_display.add_widget(novel_info_view)
tag_box = GridLayout(cols=4, size_hint=(1, None))
for tag in novel['tags']:
tag_button = Button(text=tag)
tag_box.add_widget(tag_button)
info_display.add_widget(tag_box)
scrollView_page = ScrollView(size=(Window.width,
Window.height * 0.94))
scrollView_page.add_widget(info_display)
else:
scrollView_page = ScrollView(size=(Window.width,
Window.height * 0.94))
scrollView_page.add_widget(info_display)
self.add_widget(scrollView_page)
def register_fonts(self):
for font in FONTS:
LabelBase.register(**font)
for iconfont in ICON_FONTS:
create_fontdict_file(**iconfont)
register_iconfont(**iconfont)
def build(self):
# register fonts
for font in settings.KIVY_FONTS:
LabelBase.register(**font)
self.bsm = BackgroundScreenManager()
return self.bsm
def build(self):
Window.clearcolor = (1, 1, 1, 1)
self.register_font()
LabelBase.register(name="Cabin", fn_regular="fonts/Cabin-Regular.ttf")
self.container = Container()
self.container.version_text.text = self.version_text
return self.container
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 build(self):
if hasattr(sys, '_MEIPASS'):
resource_add_path(os.path.join(sys._MEIPASS, 'resources'))
else:
resource_add_path('resources')
LabelBase.register(
name='SourceCodePro',
fn_regular=resource_find('fonts/SourceCodePro-Regular.ttf'))
layout = Builder.load_string(layout_pc.kv)
self._writing_layout = Builder.load_string(
layout_pc.write_lesson_panel)
self._reading_layout = Builder.load_string(layout_pc.read_lesson_panel)
self._content_block = layout.ids[LayoutIds.content_panel]
self.icon = resource_find('images/cw_typist.ico')
action_previous = layout.ids[LayoutIds.action_previous]
action_previous.app_icon = resource_find('images/cw_typist.png')
Window.size = (dp(1200), dp(500))
Window.clearcolor = (0.15, 0.15, 0.15, 1)
Window.bind(on_key_down=self.key_down_handler)
Window.bind(on_key_up=self.key_up_handler)
self._key_lock = False
self.title = f'CW Typist v{cw_typist_version.version}'
self._bind_lesson_buttons(layout)
self._bind_file_menu(layout)
self._bind_sound_menu(layout)
self._bind_help_menu(layout)
self._bind_write_layout(self._writing_layout)
self._bind_read_layout(self._reading_layout)
self.switch_to_write(None)
return layout
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 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 gui_run():
resource_add_path('../resources')
LabelBase.register(DEFAULT_FONT, 'ipaexg.ttf')
Config.set('kivy','window_icon','../DetExploit.ico')
run_on = platform.system()
if run_on == 'Windows':
detexploit().run()
else:
exit(1)
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 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')
class AutomacaoApp(App):
# conn = conex.Conexao("192.168.0.107",5000)
LabelBase.register(name='Roboto',
fn_regular='font/Roboto-Thin.ttf',
fn_bold ='font/Roboto-Medium.ttf')
LabelBase.register(name='Metro',
fn_regular='font/Flaticon.ttf')
def callback(self,instance):
if instance.state == "down":
# self.conn.enviar("acender")
# dadosRecebidos = self.conn.receber()
#
# while(dadosRecebidos == "1"):
# self.conn.enviar("acender")
# dadosRecebidos = self.conn.receber()
# sleep(randint(0,9))
instance.text=u'[b]L[/b]ampada\n[font=Metro]\uf106[/font]\nON'
else:
# self.conn.enviar("apagar")
# dadosRecebidos = self.conn.receber()
#
# while(dadosRecebidos == "0"):
# self.conn.enviar("apagar")
# dadosRecebidos = self.conn.receber()
# sleep(randint(0,9))
instance.text=u'[b]L[/b]ampada\n[font=Metro]\uf106[/font]\nOFF'
#
# def update(self,nap):
# self.conn.enviar("ler")
# dadosRecebidos = self.conn.receber()
# dados = dadosRecebidos.split("|")
# self.root.ids.termometro.text=u'[font=Metro]\uf101[/font]\n'+dados[0]+u' C'
# self.root.ids.luminosidade.text=u'[b]L[/b]umin. [font=Metro]\uf105[/font]\n'+dados[3]+'%'
# self.root.ids.distancia.text=u'[b]D[/b]istancia [font=Metro]\uf108[/font]\n '+dados[4]+' M'
# if dados[2] == "1":
# u'[b]P[/b]orta [font=Metro]\uf103[/font]\nFechada'
# else:
# u'[b]P[/b]orta [font=Metro]\uf103[/font]\nAberta'
#
# if dados[1] == "1":
# self.root.ids.presenca.text=u'[b]P[/b]resenca [font=Metro]\uf104[/font]\n[size=50]+[/size]'
# else:
# self.root.ids.presenca.text=u'[b]P[/b]resenca [font=Metro]\uf104[/font]\n[size=50]+[/size]'
# def on_start(self):
# Clock.schedule_interval(self.update,5)
def build(self):
self.root.ids.lampada.bind(on_press=self.callback)
pass
def initialize_fonts():
KIVY_FONTS = [
{
"name": "Cursive",
"fn_regular": "./resources/cursive.ttf"
}
]
for font in KIVY_FONTS:
LabelBase.register(**font)
class BusKillApp(App):
global bk
bk = packages.buskill.BusKill()
# register font aiases so we don't have to specify their full file path
# when setting font names in our kivy language .kv files
LabelBase.register(
"Roboto",
#os.path.join( bk.EXE_DIR, 'fonts', 'Roboto-Regular.ttf' ),
os.path.join('fonts', 'Roboto-Regular.ttf'),
)
LabelBase.register(
"RobotoMedium",
#os.path.join( bk.EXE_DIR, 'fonts', 'Roboto-Medium.ttf' ),
os.path.join('fonts', 'Roboto-Medium.ttf'),
)
LabelBase.register(
"mdicons",
#os.path.join( bk.EXE_DIR, 'fonts', 'MaterialIcons-Regular.ttf' ),
os.path.join('fonts', 'MaterialIcons-Regular.ttf'),
)
# does rapid-fire UI-agnostic cleanup stuff when the GUI window is closed
def close(self, *args):
bk.close()
def build(self):
global bk
self.bk = bk
# this doesn't work in Linux, so instead we just overwrite the built-in
# kivy icons with ours, but that's done in the linux build script
# * https://github.com/kivy/kivy/issues/2202
self.icon = 'buskill-icon-150.png'
# is the OS that we're running on supported?
if self.bk.IS_PLATFORM_SUPPORTED:
# yes, this platform is supported; show the main window
Window.bind(on_request_close=self.close)
return MainWindow()
else:
# the current platform isn't supported; show critical error window
msg = buskill.ERR_PLATFORM_NOT_SUPPORTED
print(msg)
logger.error(msg)
crit = CriticalError()
crit.showError(buskill.ERR_PLATFORM_NOT_SUPPORTED)
return crit
def __init__(self, **kvargs):
super(MainApp, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
Window.softinput_mode = 'below_target'
LabelBase.register(name="Roboto", fn_regular="./data/droid.ttf")
self.list_previous_screens = ['base']
self.window = Window
self.config = ConfigParser()
self.manager = None
self.exit_interval = False
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 build(self):
root = os.path.join(os.path.dirname(__file__))
# Register shiny font
font_path = os.path.join(root, 'assets', 'FuturaRenner-Regular.ttf')
LabelBase.register("Futura", font_path)
# Set images directory
resource_add_path(os.path.join(root, "images"))
Factory.register(cls=BoxLastLayout, classname="BoxLastLayout")
return FlightPanel(DEFAULT_HOST, 27257)
def build(self):
LabelBase.register(name="JetBrainsMono",
fn_regular="GreatVibes-Regular.ttf")
theme_font_styles.append('JetBrainsMono')
self.theme_cls.font_styles["JetBrainsMono"] = [
"JetBrainsMono",
60,
False,
0.15,
]
return Builder.load_string(KV)
def createCoins(self, parts, shape, color):
# Шрифт
LabelBase.register(name='CG', fn_regular=paths['font'])
with self.canvas:
Color(0, 0, 0, 1) #black
# Базовые размеры
w = 595
h = 842
# Размеры жетона
x = 94
y = 94
# Отступ от края листа
margin = 70
# Фон
Color(1, 1, 1, 1) #white
self.canvas.add(Rectangle(size=[w, h], pos=[0, 0]))
# Жетоны
for i in range(len(parts)):
# Ряд жетонов на листе
row = 1
row += int(i / 6)
# Надпись на жетоне
name = CoreLabel(font_name='CG', text=parts[i], font_size=45)
name.refresh()
name = name.texture
Color(0, 0, 0, 1) #black
if shape == 'round':
self.canvas.add(
Line(circle=(x * (i - (row - 1) * 6) + margin, y * row,
47),
width=1))
if shape == 'square':
self.canvas.add(
Line(rectangle=(x * (i - (row - 1) * 6) + margin -
x / 2, y * row - y / 2, 94, 94),
width=1))
Color(rgba=color)
self.canvas.add(
Rectangle(size=name.size,
pos=[(x * (i - (row - 1) * 6) + margin) -
(name.size[0] / 2),
y * row - name.size[1] / 2],
texture=name))
def build(self):
self.theme_cls.theme_style = 'Light'
self.theme_cls.primary_palette = "Red"
LabelBase.register(name="JetBrainsMono",
fn_regular="JetBrainsMono-Regular.ttf")
theme_font_styles.append('JetBrainsMono')
self.theme_cls.font_styles["JetBrainsMono"] = [
"JetBrainsMono",
16,
False,
0.15,
]
return Controller()
def _register_icon_font_if_its_not():
try:
import kivymd.font_definitions
except ImportError:
from kivy.core.text import LabelBase
if 'Icons' in LabelBase._fonts:
return
LabelBase.register(
'Icons',
str(kivymd_copy_dir.joinpath(
'kivymd',
'fonts',
'materialdesignicons-webfont.ttf')))
def loadFonts():
font_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'fonts/')
KIVY_FONTS = [{
"name": "uasquare",
"fn_regular": os.path.join(font_path, "uasquare.ttf"),
"fn_bold": os.path.join(font_path, "uasquare.ttf"),
"fn_italic": os.path.join(font_path, "uasquare.ttf"),
"fn_bolditalic": os.path.join(font_path, "uasquare.ttf"),
}]
for font in KIVY_FONTS:
LabelBase.register(**font)
def configure():
import settings
kivy.require(settings.KIVY_VERSION_REQUIRE)
Config.set('kivy', 'log_level', settings.KIVY_LOG_LEVEL)
if getattr(settings, 'KIVY_GRAPHICS_WIDTH') is not None:
Config.set('graphics', 'width', settings.KIVY_GRAPHICS_WIDTH)
if getattr(settings, 'KIVY_GRAPHICS_HEIGHT') is not None:
Config.set('graphics', 'height', settings.KIVY_GRAPHICS_HEIGHT)
for font in settings.KIVY_FONTS:
LabelBase.register(**font)
with open("version.txt") as f:
settings.VERSION = f.read().split("%")[0]
def Register(self):
Logger.debug(u'Register Font: ' + self.oFnNormal)
uFnNormal = self.oFnNormal.string
uFnItalic = self.oFnItalic.string
uFnBold = self.oFnBold.string
uFnBoldItalic = self.oFnBoldItalic.string
if uFnNormal == '': uFnNormal = None
if uFnItalic == '': uFnItalic = None
if uFnBold == '': uFnBold = None
if uFnBoldItalic == '': uFnBoldItalic = None
LabelBase.register(self.uName, uFnNormal, uFnItalic, uFnBold,
uFnBoldItalic)
def get_fontstyle():
fontname = get_font()
filename = resource_find(fontname)
if not filename and not fontname.endswith('.ttf'):
fontname = '{}.ttf'.format(fontname)
filename = resource_find(fontname)
try:
LabelBase.register(name=fontname, fn_regular=filename)
theme_font_styles.append(fontname)
get_app().theme_cls.font_styles[fontname] = [
fontname,
int(get_app().settings_controller.screen.fontsize.text), False,
0.15
]
return fontname
except:
return "Body1"
class MyForm(BoxLayout): # 此处类定义虽然为空，但会将my.kv的GUI定义的相关“程序”引入，即相当于在此定义
text_input = ObjectProperty() # 在类中添加text_input属性，对应kv文件中用于外部引用的名称，最终指向对应id的GUI部件
label_output = ObjectProperty() # 在类中添加label_output属性，对应kv文件中用于外部引用的名称，最终指向对应id的GUI部件
agent = Agent()
translate_res = None
# 加载字体资源（使用中文）
kivy.resources.resource_add_path("./fonts")
font_zh = kivy.resources.resource_find("msyh.ttc")
# 通过labelBase
LabelBase.register("msyh_labelBase", "msyh.ttc")
kivy.core.text.Label.register("msyh_label", "msyh.ttc")
def button_act(self, action=None):
print('Start ...')
if action is None:
self.translate_res = self.text_input.text # 获取text_input所指向GUI部件的text值，
elif action == 'Translate':
t = self.target_lang.text
if t == 'Target':
self.translate_res = self.text_input.text
else:
self.translate_res = self.agent.translate(text=self.text_input.text, source='auto', target=t)
elif action == 'Audio':
text = self.agent.transcribe()
t = self.target_lang.text
if t == 'Target':
t = 'en' # default
self.translate_res = self.agent.translate(text=text, source='auto', target=t)
elif action == 'Speech':
# 语音输出翻译结果
try:
assert self.translate_res is not None
self.agent.speech(self.translate_res)
print('Finish speeching ...')
except:
print('No speeching content.')
pass
else:
raise NotImplementedError
print(self.translate_res) # 打印结果到控制台
if self.translate_res is not None:
if action == 'Speech':
pass
else:
# 显示翻译结果到UI界面
self.label_output.text = self.translate_res
print('Finish translating ...')
pass
return
def clean_label(self,):
# 清除label文本
self.label_output.text = "" # (Waiting ...)
self.translate_res = None
return
def build(self):
LabelBase.register(name="Arial", fn_regular="Arial.ttf")
theme_font_styles.append('Arial')
self.theme_cls.font_styles["Arial"] = [
"Arial",
16,
False,
0.15,
]
self.set_value_from_config()
self.load_all_kv_files(
os.path.join(self.directory, 'libs', 'uix', 'kv'))
self.screen = StartScreen()
self.manager = self.screen.ids.manager
self.nav_drawer = self.screen.ids.nav_drawer
return self.screen
def loadFonts():
LabelBase.register(
name="QuickSand",
fn_regular="fonts/QuickSand/Quicksand-Regular.otf",
# fn_bold="fonts/QuickSand-Bold.otf"
)
LabelBase.register(name="Cantarell",
fn_regular="fonts/Cantarell/Cantarell-Regular.ttf",
fn_bold="fonts/Cantarell/Cantarell-Bold.ttf")
LabelBase.register(name="OpenSans",
fn_regular="fonts/OpenSans/OpenSans-Regular.ttf",
fn_bold="fonts/OpenSans/OpenSans-Bold.ttf")
LabelBase.register(name="Amble",
fn_regular="fonts/Amble/Amble-Regular.ttf",
fn_bold="fonts/Amble/Amble-Bold.ttf")
LabelBase.register(name="Roboto",
fn_regular="fonts/Roboto/Roboto-Regular.ttf",
fn_bold="fonts/Roboto/Roboto-Bold.ttf")
def Register(self) -> None:
"""
Registers Font in the app system
:return: None
"""
Logger.debug(u'Register Font: ' + self.oFnNormal)
uFnNormal: Optional[str] = self.oFnNormal.string
uFnItalic: [str, None] = self.oFnItalic.string
uFnBold: [str, None] = self.oFnBold.string
uFnBoldItalic: [str, None] = self.oFnBoldItalic.string
if uFnNormal == '': uFnNormal = None
if uFnItalic == '': uFnItalic = None
if uFnBold == '': uFnBold = None
if uFnBoldItalic == '': uFnBoldItalic = None
LabelBase.register(self.uName, uFnNormal, uFnItalic, uFnBold,
uFnBoldItalic)
return None
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()
def changeFont(self):
try:
LabelBase.register(DEFAULT_FONT, self.ids["text_font"].text)
except Exception:
self.ids["text_font"].text = "can't load font."
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()
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()
"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()
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()
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()
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.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 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()
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([])
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',
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)
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.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
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()
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))
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()
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/
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()
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'
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()
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
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)
