def build(self):
Window.bind(mouse_pos=self.change_color)
return Builder.load_string(
"""
BoxLayout:
button: button
layout: layout
orientation: 'vertical'
RelativeLayout:
id: layout
Button:
id: button
text: ti.text
size_hint: .15, .15
pos_hint: {'center': (.5, .5)}
TextInput:
id: ti
text: 'Some text'
size_hint_y: None
height: self.font_size * 2
"""
)
def __init__(self, **kwargs):
super(MDBottomNavigation, self).__init__(**kwargs)
self.previous_tab = None
self.widget_index = 0
self._refresh_tabs()
Window.bind(on_resize=self.on_resize)
Clock.schedule_once(lambda x: self.on_resize(), 2)
def __init__(self, **kwargs):
self._win = None
if 'min_state_time' not in kwargs:
self.min_state_time = float(
Config.get('graphics', 'min_state_time'))
if 'container' not in kwargs:
c = self.container = Builder.load_string(_grid_kv)
else:
c = None
if 'allow_sides' not in kwargs:
self.allow_sides = False
if 'do_scroll_x' not in kwargs:
self.do_scroll_x = False
if 'size_hint' not in kwargs:
if 'size_hint_x' not in kwargs:
self.size_hint_x = None
if 'size_hint_y' not in kwargs:
self.size_hint_y = None
super(DropDown, self).__init__(**kwargs)
if c is not None:
super(DropDown, self).add_widget(c)
self.on_container(self, c)
Window.bind(
on_key_down=self.on_key_down,
size=self._reposition)
self.fbind('size', self._reposition)
def __init__(self, **kwargs):
self.time = datetime.timedelta(seconds=0)
self.is_running = True
self.color = 'red'
super(Timer, self).__init__(**kwargs)
Window.bind(on_key_down=self.check_keyboard_event)
self.start_clock()
def __init__(self, **kwargs):
self.slides = []
super(Slides, self).__init__(**kwargs)
Window.bind(on_keyboard=self.on_keyboard)
Clock.schedule_interval(self.increase_time, 1 / 30.0)
Clock.schedule_once(self.init, 0)
self.add_widget(SlidesForeground(slides=self))
def __init__(self, figure, **kwargs):
Window.bind(mouse_pos=self._on_mouse_pos)
self.bind(size=self._on_size_changed)
self.bind(pos=self._on_pos_changed)
self.entered_figure = True
self.figure = figure
super(FigureCanvasKivy, self).__init__(figure=self.figure, **kwargs)
def __init__(self, **kwargs):
super(LayoutFunctioning, self).__init__(**kwargs)
# Enable send_btn after some seconds
self.cb_disablesend = lambda dt: self.disablesend(False)
Clock.schedule_once(self.cb_disablesend, self.send_disabled_t)
# When previously saw finish screen
if self.master_kanji.cur_framenum == -1:
self.master_kanji.nextkanji()
self.reinitscreen(0)
else:
self.reinitscreen(self.master_kanji.dbcurrent("nextKanji"))
# First time opening app show explanation story
if self.master_kanji.cur_framenum == 0:
print("First time app")
self.master_kanji.story_show = True
# Link button to website
print("!!! DEBUG UTF-8 !!!")
#print(self.master_kanji.cur_framekanji)
print(type(self.master_kanji.cur_framekanji))
self.ww_link = "http://kanji.koohii.com/study/kanji/{}".format(self.master_kanji.cur_framekanji) # "TODO")
# Keyboard height
#Clock.schedule_once(lambda dt: self.storykeybheight())
print("Keyboard binding")
Window.bind(on_keyboard=self.storykeybheight)
print("--- INIT LayoutFunctioning COMPLETED ---\n")
def build(self):
from kivy.garden.smaa import SMAA
Window.bind(on_keyboard=self._on_keyboard_handler)
self.smaa = SMAA()
self.effects = [self.smaa, Widget()]
self.effect_index = 0
self.label = Label(text='SMAA', top=Window.height)
self.effect = effect = self.effects[0]
self.root = FloatLayout()
self.root.add_widget(effect)
if 0:
from kivy.graphics import Color, Rectangle
wid = Widget(size=Window.size)
with wid.canvas:
Color(1, 1, 1, 1)
Rectangle(size=Window.size)
effect.add_widget(wid)
if 1:
#from kivy.uix.image import Image
#root.add_widget(Image(source='data/logo/kivy-icon-512.png',
# size=(800, 600)))
filenames = sys.argv[1:]
if not filenames:
filenames = glob(join(dirname(__file__), '*.svg'))
for filename in filenames:
svg = SvgWidget(filename)
effect.add_widget(svg)
effect.add_widget(self.label)
svg.scale = 5.
svg.center = Window.center
if 0:
wid = Scatter(size=Window.size)
from kivy.graphics import Color, Triangle, Rectangle
with wid.canvas:
Color(0, 0, 0, 1)
Rectangle(size=Window.size)
Color(1, 1, 1, 1)
w, h = Window.size
cx, cy = w / 2., h / 2.
Triangle(points=[cx - w * 0.25, cy - h * 0.25,
cx, cy + h * 0.25,
cx + w * 0.25, cy - h * 0.25])
effect.add_widget(wid)
if 0:
from kivy.uix.button import Button
from kivy.uix.slider import Slider
effect.add_widget(Button(text='Hello World'))
effect.add_widget(Slider(pos=(200, 200)))
control_ui = Builder.load_string(smaa_ui)
self.root.add_widget(control_ui)
def build(self):
sm = ScreenManager(transition=WipeTransition())
sm.add_widget(MainWindow(name='mainwindow'))
sm.add_widget(StandardWidgets(name='inputstation'))
Window.bind(on_keyboard=self.hook_keyboard)
self.content = content = BoxLayout()
sc = Trainccs()
#~ spinner = Spinner(
#~ text='About',
#~ values=('About',),
#~ size_hint=(None, None),
#~ size=(100, 44),
#~
#~ )
#~ pos_hint={'center_x': 0.5, 'center_y': 0.5})
#~ sc.add_widget(spinner)
sc.content.add_widget(sm)
return sc
def __init__(self, **kwargs):
Builder.load_string(FLYIN_PANEL_LAYOUT)
super(FlyinPanel, self).__init__(**kwargs)
self.hide_decay = Clock.create_trigger(lambda dt: self.hide(), self.SESSION_HIDE_DELAY)
Window.bind(mouse_pos=self.on_mouse_pos)
Window.bind(on_motion=self.on_motion)
Clock.schedule_once(lambda dt: self.show())
def on_start(self):
self.spacing = 0.5 * self.root.width
self.background = self.root.ids.background
self.bird = self.root.ids.bird
Clock.schedule_interval(self.update, 1.0/500.0)
Window.bind(on_key_down=self.on_key_down)
self.background.on_touch_down = self.user_action
def __init__(self, **kwargs):
pos = kwargs.pop('pos', (-100,-100))
super(Launcher, self).__init__(source='docklauncher512x512.png',
size_hint=(None,None),
allow_stretch=True,
**kwargs)
#icons sizes
self.selected_scale = 1.5
self.unselected_scale = .3
print 'Launcher image size: ', self.size
#for mouse over event
Window.bind(mouse_pos=self.mouse_over)
self.animin = Animation(width=100, height=100, duration=.3)
self.animax = Animation(width=400, height=400, duration=.3)
'''
self.animin = Animation(scale_x=1, scale_y=1, duration=.3)
self.animax = Animation(scale_x=2, scale_y=2, duration=.3)
'''
self.animin.bind(on_complete=self.on_minimized)
self.animax.bind(on_complete=self.on_maximized)
self.state = 'minimizing'
self.animin.start(self)
def __init__(self, **kwargs):
super(CreateAccountDialog, self).__init__(**kwargs)
self.action = kwargs.get('action')
_trigger_size_dialog = Clock.create_trigger(self._size_dialog)
Window.bind(size=_trigger_size_dialog,
rotation=_trigger_size_dialog)
_trigger_size_dialog()
def __init__(self, **kwargs):
self.writing = False
Window.bind(mouse_pos=self.update_pos)
self._keyboard = Window.request_keyboard(self._keyboard_closed,self)
self._keyboard.bind(on_key_down=self._on_keyboard_down)
super(MyPaintWidget, self).__init__(**kwargs)
self.connect()
def setUp(self):
'''Prepare the graphic test, with:
- Window size fixed to 320x240
- Default kivy configuration
- Without any kivy input
'''
# use default kivy configuration (don't load user file.)
from os import environ
environ['KIVY_USE_DEFAULTCONFIG'] = '1'
# force window size + remove all inputs
from kivy.config import Config
Config.set('graphics', 'width', '320')
Config.set('graphics', 'height', '240')
for items in Config.items('input'):
Config.remove_option('input', items[0])
# bind ourself for the later screenshot
from kivy.core.window import Window
self.Window = Window
Window.bind(on_flip=self.on_window_flip)
# ensure our window is correctly created
Window.create_window()
Window.register()
Window.initialized = True
Window.canvas.clear()
Window.close = lambda *s: True
def __init__(self, **kwargs):
super(RaceCaptureApp, self).__init__(**kwargs)
# We do this because when this app is bundled into a standalone app
# by pyinstaller we must reference all files by their absolute paths
# sys._MEIPASS is provided by pyinstaller
if getattr(sys, 'frozen', False):
self.base_dir = sys._MEIPASS
else:
self.base_dir = os.path.dirname(os.path.abspath(__file__))
#RaceCapture serial I/O
self._rc_api = RcpApi(on_disconnect=self._on_rcp_disconnect)
#self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
#self._keyboard.bind(on_key_down=self._on_keyboard_down)
self.settings = SystemSettings(self.user_data_dir, base_dir=self.base_dir)
self._databus = DataBusFactory().create_standard_databus(self.settings.systemChannels)
self.settings.runtimeChannels.data_bus = self._databus
HelpInfo.settings = self.settings
Window.bind(on_keyboard=self._on_keyboard)
self.register_event_type('on_tracks_updated')
self.processArgs()
self.settings.appConfig.setUserDir(self.user_data_dir)
self.trackManager = TrackManager(user_dir=self.settings.get_default_data_dir(), base_dir=self.base_dir)
self.setup_telemetry()
def on_start(self):
Logger.debug("%s: on_start %s" % (APP, datetime.now()))
from kivy.core.window import Window
Window.bind(on_keyboard=self.on_keypress)
if platform == 'android':
android.map_key(android.KEYCODE_BACK, 1001)
import android.activity as python_activity
python_activity.bind(on_new_intent=self.on_new_intent)
self.on_new_intent(activity.getIntent())
self.server_url = self.config.get('general', 'server_url')
self.root.bind(
on_touch_down=lambda *a: setattr(self, 'delay_image_loading', True),
on_touch_up=lambda *a: setattr(self, 'delay_image_loading', False))
imagedir = ImageDir(server_url=self.server_url)
wp = 'with_previous'
imagedir.bind(
on_navigate_top=lambda *a: setattr(self.root, wp, False),
on_navigate_down=lambda *a: setattr(self.root, wp, True),
on_img_selected=self.load_carousel,
path=lambda w,v: setattr(self.root, 'title', v),
on_loading_start=lambda *a: setattr(self.root, 'loading', True),
on_loading_stop=lambda *a: setattr(self.root, 'loading', False))
self.imagedir = imagedir
self.root.container.add_widget(imagedir)
self.root.bind(on_touch_down=lambda *a: Loader.pause(),
on_touch_up=lambda *a: Loader.resume())
Loader.max_upload_per_frame = 1 # Maximize interactivity
def start_screen(self):
"""Displays the start screen with the title and play button. Also sets the initial difficulty variables."""
self.clear_widgets()
#create the logo
self.logo = Label(text='Expression Collector',font_size=0.1*Window.height)
self.logo.center_x = Window.width/2
self.logo.center_y = Window.height/2
self.add_widget(self.logo)
#create the playbtn
self.playbtn = Button(text='play',font_size=0.05*Window.height,background_color=[0,0,0,0])
self.playbtn.center_x = Window.width/2
self.playbtn.center_y = Window.height/2 - 0.1*Window.height
self.playbtn.bind(on_release=self.play)
self.add_widget(self.playbtn)
#create the howtoplaybtn 100 px under the playbtn
self.howtoplaybtn = Button(text='how to play',font_size=0.05*Window.height,background_color=[0,0,0,0])
self.howtoplaybtn.center_x = Window.width/2
self.howtoplaybtn.center_y = self.playbtn.center_y - 100
self.howtoplaybtn.bind(on_release=self.howtoplay)
self.add_widget(self.howtoplaybtn)
#make bindings to make start screen fluid
Window.bind(size=self.adjust_start_widgets)
#create initial difficulty variables
self.MINUTE = 0 #it has been 0 minutes so far
self.MAX_NUMBER = 2 # the biggest number that can be part of an expression
self.MAX_LENGTH = 2 #the maximum number of numbers in an expression
self.AVAILABLE_OPERATORS = ['+','-'] #at first just + and - operators are available
self.sound = SoundLoader.load('startscreen.wav')
self.sound.loop = True
self.sound.play()
def play(self,*args):
"""Goes from the start screen to the game screen. Creates the playerexpr, grid, and random Exprs."""
#Delete the logo and button
self.remove_widget(self.logo)
self.remove_widget(self.playbtn)
self.remove_widget(self.howtoplaybtn)
#Delete start screen music, load game music
self.sound.stop()
self.sound = SoundLoader.load('game.wav')
self.sound.loop = True
self.sound.play()
#create the grid
global grid
grid = Grid()
grid.adjust_grid() #Adjust/draw the grid to the initial window size
Window.bind(size=grid.adjust_grid) #bind Window.size -> grid.adjust_grid
self.add_widget(grid)
#create the playerexpr
global playerexpr
playerexpr = PlayerExpr(value=1,text='1',color=[1,1,1,1],font_size=grid.cell_height)
self.add_widget(playerexpr)
Clock.schedule_interval(playerexpr.check_collisions,1/30.0) #Check for collisions with PlayerExpr
Clock.schedule_interval(self.create_expr,2) #create Expr objects for the game
Clock.schedule_interval(self.make_harder,60) #make the game harder every 60 seconds
#play bindings
Window.bind(size=self.reposition_children) #bind window resizing to repositioning all of its children
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 __init__(self):
super(TextAdventureGame, self).__init__()
self.backgroundWidget = Widget()
with self.backgroundWidget.canvas.before:
pass
# Color(76. / 256., 230. / 256., 0., .5)
# Rectangle(pos=(0, 0), size=Window.size)
self.char = Character()
self.world = self.createLandscape()
self.world = self.generateTerrain(self.world)
for i in range(randint(3, 6)):
self.createRoom(self.world)
self.worldWithCharacter = list(self.world)
self.worldWithCharacter = self.placeChar(self.worldWithCharacter, self.char)
self.worldLabel = Label(
color=(76. / 256., 146. / 256., 0., 1.),
text=self.joinRoom(self.world),
markup=True,
center_x=Window.width / 2,
center_y=Window.height / 2,
font_name="assets/fonts/DejaVuSansMono.ttf",
font_size="20sp"
)
self.worldLabel.size = self.worldLabel.texture_size
with self.worldLabel.canvas:
Color(146. / 256., 76. / 256., 0., 1.)
Rectangle(pos=self.worldLabel.pos, size=self.worldLabel.size)
self.add_widget(self.backgroundWidget)
self.add_widget(self.worldLabel)
Window.bind(on_key_down=self.on_key_down)
def build(self): Window.bind(on_key_down=self.on_key_down) root = Widget() self.container = Container(ws_count=7) # here we add an instance of container to the window, ws_count shows number of workspaces we need root.add_widget(self.container) return root
def on_code_input_focus(self, *args):
'''Focus on CodeInput, to enable/disable keyboard listener
'''
if args[1]:
Window.bind(on_keyboard=self.on_keyboard)
else:
Window.unbind(on_keyboard=self.on_keyboard)
def __init__(self, **kwargs):
super(RaceCaptureApp, self).__init__(**kwargs)
if kivy.platform == 'ios' or kivy.platform == 'macosx':
kivy.resources.resource_add_path(os.path.join(os.path.dirname(os.path.realpath(__file__)), "data"))
# We do this because when this app is bundled into a standalone app
# by pyinstaller we must reference all files by their absolute paths
# sys._MEIPASS is provided by pyinstaller
if getattr(sys, 'frozen', False):
self.base_dir = sys._MEIPASS
else:
self.base_dir = os.path.dirname(os.path.abspath(__file__))
self.settings = SystemSettings(self.user_data_dir, base_dir=self.base_dir)
self._databus = DataBusFactory().create_standard_databus(self.settings.systemChannels)
self.settings.runtimeChannels.data_bus = self._databus
# RaceCapture communications API
self._rc_api = RcpApi(on_disconnect=self._on_rcp_disconnect, settings=self.settings)
HelpInfo.settings = self.settings
#Ensure soft input mode text inputs aren't obstructed
Window.softinput_mode = 'below_target'
#Capture keyboard events for handling escape / back
Window.bind(on_keyboard=self._on_keyboard)
self.register_event_type('on_tracks_updated')
self.processArgs()
self.settings.appConfig.setUserDir(self.user_data_dir)
self.trackManager = TrackManager(user_dir=self.settings.get_default_data_dir(), base_dir=self.base_dir)
self.setup_telemetry()
def on_listen_key(self, instance, value, *args):
"""Enable/disable keyboard listener
"""
if value:
Window.bind(on_key_down=self._on_key_down)
else:
Window.unbind(on_key_down=self._on_key_down)
def build(self):
Builder.load_string(textwrap.dedent(
'''
<CustomButtonClass@Button>:
description_a: ''
description_b: ''
text: root.description_a + ' <newline> ' + root.description_b
halign:'center'
size_hint:(1, 0.1)
<MyListView>:
size_hint:(0.5, 0.5)
ListView:
item_strings: [str(index) for index in range(10)]
<OtherNamedScreen>:
GridLayout:
cols: 2
MyListView
ScrollView:
ContainerForButtons:
cols:1
row_default_height:150
size_hint_y: None
'''))
Window.bind(on_keyboard=self.check_what_key_was_pressed)
self.screen_mgr = ScreenManager()
first = Screen(name='First')
self.screen_mgr.add_widget(first)
first.add_widget(Button(text="click me", bind=self.swap_screen))
self.screen_mgr.add_widget(OtherNamedScreen(name='Second'))
return self.screen_mgr
def __init__(self, **kwargs):
super(MainScreen, self).__init__(**kwargs)
Window.bind(on_keyboard=self.Android_back_click)
self.size_hint=(None, None)
self.size=(Window.width, Window.height)
self.pos_hint={'center_x':.5, 'center_y':.5}
self.buildMainScreen()
def load_level_in_set(self, set_id=None, level_id_in_set=1):
"""
Load given level in given set with checking.
:param set_id: id of the set to load.
:param level_id_in_set: id of the level to load.
:rtype: void
"""
if not set_id or not self.level_service.does_set_exist(set_id):
set_id = self.level_service.get_last_set_unlocked()
self.clear_widgets()
self.current_set_id = set_id
self.current_level_id_in_set = level_id_in_set
# display popup if level need popup
open_pop_up(self, 'open_level', set_id, level_id_in_set)
self.level = Level(
self.level_event_dispatcher,
set_id,
level_id_in_set
)
self.add_widget(self.level)
self.update_menu_level_bar()
Window.bind(on_resize=self.update_menu_level_bar)
def __init__(self, **kwargs):
self.dataDir = ""
super(TestGame, self).__init__(**kwargs)
Clock.schedule_once(self.init_game)
self.entIDs = []
self.mainTools = self.ids['gamescreenmanager'].ids['main_screen'].ids['mainTools']
self.mainTools.setRef(self)
self.mainTools.setTool("poly")
self.startID = -1
self.finishID = -1
self.selectedShapeID = None
self.space = None
self.serials = None
self.scripty = None
self.todelete = []
self.jointEnts = {}
self.selectedListIndex = 0
self.lastlist = None
self.touches = {}#0: {"active": False, "pos": (0, 0), "screenpos": (0, 0)}}
self.atlas = Atlas('assets/myatlas.atlas')
try:
self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
self._keyboard.bind(on_key_down=self._on_keyboard_down)
except:
print 'Python python no keyboard'
size = Window.size
with self.canvas.before:
#Color(0.5, 0.65, 0.95)
self.bgrect = Rectangle(source='sprites/bgm.jpg', size=size)
Window.bind(on_resize=self.redogb)
def build(self):
Window.bind(on_key_down=self.on_key_down)
self.loadData()
self.activeTrack = None
self.currentLayer = 0
self.appstructure = FloatLayout()
width, height = Window.size
self.menu = Menu()
self.menu.onNewTrack(self.newTrack)
self.menu.onNewPoint(self.newPoint)
self.menu.onDeletePoint(self.deletePoint)
self.menu.onSetClass(self.setClass)
self.menu.onFindUnclassified(self.jumpToUnclassified)
self.menu.onShowStats(self.showStats)
self.menu.onSave(self.save)
self.core = Scatter(auto_bring_to_front=False)
self.core.add_widget(self.getCurrentLayer().getContents())
self.appstructure.add_widget(self.core)
self.appstructure.add_widget(self.menu.getContents())
self.zoomSlider = Slider(orientation='vertical', min=1, max=10, size_hint=(0.05,1),pos_hint={'x':0.95})
self.zoomSlider.bind(on_touch_move=self.on_touch_move)
self.zoomSlider.bind(on_touch_down=self.on_touch_down)
self.zoomSlider.bind(on_touch_up=self.on_touch_up)
self.appstructure.add_widget(self.zoomSlider)
self.imagelabel = Label(text=self.getCurrentLayer().getSource(), size_hint=(1,0.05), pos_hint={'y':0})
self.appstructure.add_widget(self.imagelabel)
self.zooming = False
return self.appstructure
def __init__(self, **kwargs):
super(EditPDFApp, self).__init__(**kwargs)
# ドラッグ&ドロップ
Window.bind(on_dropfile=self._on_dropfile)
def __init__(self, *args, **kwargs):
Window.bind(mouse_pos=self.on_mouse_pos)
super(ExtendedButtonBehavior, self).__init__(*args, **kwargs)
def __init__(self, parent):
super().__init__()
self.parent_class = parent
self.parent_class.add_widget(self, index=7)
self.selected_widget = None
Window.bind(on_resize=self.move_resize)
def __init__(self, init_value='', size=None, range=(None, None), **kwargs):
super(NumberPad, self).__init__(**kwargs)
if size is None:
self.size_hint = (1, 1)
else:
self.size_hint = (None, None)
if size is None:
self.size = (200, 200)
self._font_size = 16
else:
self.size = tuple(size)
self._font_size = self.size[0] / 15
if range is None:
self.range = (None, None)
else:
self.range = range
self._vbox = BoxLayout(orientation='vertical')
self._vbox.padding = (8, 8, 8, 8)
self._hbox1 = BoxLayout(orientation='horizontal', size_hint_y=0.2)
# self._labValue=Label(text='Value',size_hint_x=0.2)
self._hbox11 = BoxLayout(orientation='horizontal')
self._inpValue = TextInput(readonly=True,
multiline=False,
size_hint_x=0.8,
font_size=self._font_size)
self._btnClose = Button(text=chr(0x274C),
size_hint_x=0.1,
font_size=self._font_size)
self._hbox11.add_widget(self._inpValue)
self._hbox11.add_widget(self._btnClose)
# self._hbox1.add_widget(self._labValue)
self._hbox1.add_widget(self._hbox11)
self._vbox.add_widget(self._hbox1)
btns = [['7', '8', '9', '+', 'DEL'], ['4', '5', '6', '-', 'AC'],
['1', '2', '3', '*', '='], ['0', 'e', '.', '/', 'ENT']]
self._grid = GridLayout(rows=4, cols=5)
self._btns = {}
for one_row in btns:
for b in one_row:
self._btns[b] = Button(text=b, font_size=self._font_size)
self._grid.add_widget(self._btns[b])
if b in [
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
'e', '.', '+', '-', '*', '/'
]:
self._btns[b].bind(
on_release=functools.partial(self.set_value, b))
elif b == 'DEL':
self._btns[b].bind(on_release=self.delete)
elif b == 'AC':
self._btns[b].bind(on_release=self.clear)
elif b == '=':
self._btns[b].bind(on_release=self.equal)
elif b == 'ENT':
self._btns[b].bind(on_release=self.accept)
self._vbox.add_widget(self._grid)
Window.bind(on_key_down=self.key_action)
self.content = self._vbox
self.auto_dismiss = False
self.title = "Enter a number"
self._response = None
self._value1 = None
self._value2 = None
self._operation = None
self._last = None
self._callback_close = None
self._callback_escape = None
self._caller = None
if init_value:
self._inpValue.text = init_value
self._init_value = init_value
# check validity of the input
self._regex = re.compile(
'^[-+]?([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][-+]?[0-9]?)?$')
# title_label = self.children[0].children[2]
# title_label.height = 0
self.separator_height = 0
def on_pre_enter(self):
Window.bind(on_request_close=self.confirmacao)
def __init__(self, **kvargs):
super(VKGroups, self).__init__(**kvargs)
Window.bind(on_keyboard=self.events_program)
self.POSSIBLE_FILES = \
['.png', '.jpg', '.jpeg', '.gif', '.zip', '.txt']
self.DEVISE_ONLINE = {
'mobile': 'desktop-mac',
'computer': 'laptop',
0: 'power'
}
self.PATTERN_WHOM_COMMENT = pattern_whom_comment
self.PATTERN_REPLACE_LINK = pattern_replace_link
self.window = Window
self.config = ConfigParser()
# Окно прогресса.
self.load_dialog = ModalView(size_hint=(None, None),
pos_hint={
'x': 5.0 / Window.width,
'y': 5.0 / Window.height
},
background_color=[0, 0, 0, .2],
size=(dp(120), dp(50)),
background=os.path.join(
'data', 'images', 'decorator.png'),
auto_dismiss=False)
# Экземпляр для вывода списка плагинов пользователя.
self.instance_list_user_plugins = ShowPlugins(self)
# Файловый менеджер.
self.window_file_manager = ModalView(
size_hint=(1, 1),
auto_dismiss=False,
on_open=lambda x: self.load_dialog.dismiss())
self.window_file_manager_open = False
self.file_manager = FileManager(
exit_manager=self.exit_manager,
floating_button_color=self.theme_cls.primary_color)
self.window_file_manager.add_widget(self.file_manager)
self.current_screen_tab = None
self.current_tab_manager = None
self.name_press_tab = 'Home_page'
self.file_manager_not_opening = True
self.password_form = None
self.box_posts = None
self.attach_file = []
self.attach_image = []
self.box_for_attach_file = None
self.box_for_attach_image = None
self.group_info = None
self.result_sending_post = None
self.exit_interval = False
self.flag_attach = ''
self.window_user_groups = None
self.window_language = None
self.path_to_avatar = os.path.join(self.directory, 'data', 'images',
'avatar.png')
self.dict_language = ast.literal_eval(
open(os.path.join(self.directory, 'data', 'locales',
'locales')).read())
def __init__(self,**kwargs):
super().__init__(**kwargs)
Window.bind(on_keyboard=self.on_key)
def __init__(self, **kwargs):
super().__init__(**kwargs)
Window.bind(on_resize=self.check_position_caller)
self.register_event_type("on_dismiss")
self.menu = self.ids.md_menu
Clock.schedule_once(self.set_menu_properties, 2)
def _bind_keyboard(self):
super()._bind_keyboard()
Window.bind(on_textedit=self.window_on_textedit)
def on_focus(self, instance, value):
if value:
Window.bind(on_keyboard=self._on_keyboard)
else:
Window.unbind(on_keyboard=self._on_keyboard)
self.dispatch('on_text_validate')
def on_parent(self, *args):
if self.parent:
Window.bind(on_key_down=self._on_keyboard_down)
else:
Window.unbind(on_key_down=self._on_keyboard_down)
def __init__(self, **kwargs):
super(Quiz, self).__init__(**kwargs)
Window.bind(on_key_down=self._on_keyboard_down)
def enable_user_interaction(self, *args):
self.user_touch = True
Window.bind(on_key_down=self.on_keyboard_down)
def build(self):
Window.bind(size=self._resize_)
self.label = Label(text='Greetings Earthlings')
self.set_background_color()
return self.label
def __init__(self):
super().__init__(source=BURGER_NORMAL, size_hint=(None, None))
Window.bind(mouse_pos=self._on_mouse_pos)
self.bind(state=self._on_state, pos=self._on_mouse_pos)
def __init__(self, **kwargs):
super().__init__(**kwargs)
Clock.schedule_once(lambda x: self._add_circles())
Window.bind(on_resize=self._on_resize)
def build(self):
Clock.schedule_interval(self._print_fps, 1)
Window.bind(on_keyboard=self._reload_keypress)
return Builder.load_file(self.options['filename'])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._drop_widgets = []
Window.bind(on_dropfile=self.on_dropfile)
def __init__(self, **kwargs):
super(KivyApp, self).__init__(**kwargs)
Window.bind(on_keyboard=self.onBack)
def on_pre_enter(self, *args):
Window.bind(on_keyboard=self.voltar)
def __init__(self, **kwargs):
super(Neuron, self).__init__(**kwargs)
self.draw()
self.bind(pos=self.redraw, size=self.redraw)
Window.bind(mouse_pos=self.on_mouse_pos)
def bind_mouse_motion(self, the_widget, which_function):
if self.motion_is_bound_to_window is False:
Window.bind(mouse_pos=self.on_motion)
self.motion_is_bound_to_window = True
def __init__(self, **kwargs):
super().__init__(**kwargs)
Window.bind(on_resize=self._get_orientation)
self.register_event_type("on_progress_finish")
Clock.schedule_once(self._update)
def _update(self, *args):
self._get_orientation()
Window.bind(on_touch_down=self._window_touch_down)
Window.bind(on_touch_up=self._window_touch_up)
Window.bind(on_touch_move=self._window_touch_move)
if msmqueue_event.open_queue(1, 0):
while msmqueue_event.peek(500):
msg = msmqueue_event.recv_from_queue()
if msg:
continue
else:
break
msmqueue_event.close_queue()
window_width, window_height = Window.size
Window.top = 30
Window.left = 30
Window.size = (1200, 900)
Window.bind(on_request_close=empty_queue)
class EndEventScroll(ScrollView):
def on_scroll_stop(self, *args, **kwargs):
result = super(EndEventScroll, self).on_scroll_stop(*args, **kwargs)
if self.scroll_y < 0 and hasattr(self, 'on_end_event'):
self.on_end_event()
return result
class ScrolllabelLabel(ScrollView):
text = StringProperty('')
def __init__(self,**kwargs):
super(SManager, self).__init__(**kwargs)
cfg.logger.setLevel(logging.INFO)
Window.bind(on_keyboard=self.hook_keyboard)
def on_pre_enter(self):
Window.bind(on_request_close = self.stop)
Window.bind(on_keyboard = self.close_by_keyboard)
def build(self):
Window.bind(on_dropfile=self._on_file_drop)
self.loadConfig()
return
def __init__(self, **kwargs):
super(SpriteEditorWidget, self).__init__(**kwargs)
self.root = BoxLayout(orientation='horizontal')
self.add_widget(self.root)
self.viewer = SpriteEditorViewer(owner=self, size_hint=(.7, 1))
self.progress = SpriteEditorProgress(max=100,
pos_hint={
'x': 0,
'y': 0.98
},
size=(100, dp(10)),
size_hint=(1, None))
self.viewer.add_widget(self.progress)
self.viewer.padding = [4, 4]
self.root.add_widget(self.viewer)
tool_stack = StackLayout(size=(dp(200), 50), size_hint=(None, 1))
tool_stack.orientation = "tb-lr"
tool_stack.padding = [4, 4]
tool_stack.spacing = 4
self.root.add_widget(tool_stack)
self.tool_stack = tool_stack
self._create_toggle_button('Toggle Grid', self.toggle_grid_press)
self.select_button = self._create_tool_button('Select Region',
self.select_press)
self._create_tool_button('Copy Region to Clipboard',
self.copy_region_press)
self._create_tool_label("Extract:")
self._create_tool_button('Sprite', self.create_sprite_press)
self._create_tool_button('Unique Colors', self.find_unique_press)
self._create_tool_button('Unique Sprite', self.highlight_unique_press)
self._create_tool_button('Transparent Sprite',
self.extract_transparent_press)
self._create_tool_label("Overlay:")
self._create_toggle_button('Unique Colors', self.overlay_unique_press)
self._create_toggle_button('Transparent Sprite',
self.overlay_transparent_press)
self.overlay_updater: Optional[Callable] = None
self._create_tool_label("Region Info:")
self.x_label = self._create_info_label("x")
self.y_label = self._create_info_label("y")
self.sel_x_label = self._create_info_label("sel x")
self.sel_y_label = self._create_info_label("sel y")
self.sel_width_label = self._create_info_label("sel width")
self.sel_height_label = self._create_info_label("sel height")
self.viewer.selection.bind(on_update=self._on_overlay_update)
Window.bind(on_resize=self.on_window_resize)
Window.clearcolor = (0.136, 0.191, 0.25, 1)
Window.bind(on_dropfile=self._on_drop_file)
self.root.size = (Window.width, Window.height)
if len(sys.argv) > 1:
self.load_image(sys.argv[1])
def __init__(self, **kwargs):
super(DesignerActionGroup, self).__init__(**kwargs)
self.__class__.instances.append(weakref.proxy(self))
self.register_event_type('on_enter') # Registering the event
Window.bind(mouse_pos=self.on_mouse_pos)
