def build(self):
## SM = ScreenManager(transition=NoTransition())
## SM.add_widget(ClusterDetailsScreen(name='cluster details'))
global SM
window=RelativeLayout()
SM = ClusterDetailsScreen()
window.add_widget(SM)
picto = SM.ids['pictoPanel']
bubble = SM.ids['bubblePanel']
specs = SM.ids['specsPanel']
#'left_top', 'left_mid', 'left_bottom',
#'top_left', 'top_mid', 'top_right',
#'right_top', 'right_mid', 'right_bottom',
#'bottom_left', 'bottom_mid', 'bottom_right'
c1=Comment("capabilities of\nthe cluster in\nlayman's terms", \
(10,100),(152,89),'top_mid')
c2=Comment("adequate size +\nuniform strokes =\nreadable font", \
(20,390),(175,90),'bottom_left')
c3=Comment("1 square falling into \nplace = 4 nodes\nchanging status", \
(150,230),(207,80),'right_bottom')
c4=Comment("1 circle = 1 job with\ndiameter, position, color,\nand transparency\nreflecting job\ncharacteristics", \
(420,200),(245,120),'right_bottom')
c5=Comment("The circles rise like\nbubbles as they\napproach completion,\nfinally floating away\nwhen they finish.", \
(690,360),(198,140),'bottom_left')
c6=Comment("scrolling banner with\nhyperlinks that direct\nto the user's website", \
(100,10),(230,80),'right_bottom')
c7=Comment("Bar graphs depict\ndifferences more\nclearly than pie\n charts[2].", \
(210,500),(170,110),'bottom_right')
c8=Comment("Click on a circle\nto see job details.", \
(710,230),(180,60),'left_mid')
c9=Comment("color-blind-\nfriendly palette", \
(420,450),(160,60),'right_bottom')
comments=[c1,c2,c3,c4,c5,c6,c7,c8,c9]
for x in comments:
window.add_widget(x)
specs.ids['details'].text = SM.importText('melete.rst')
SM.ids['banner'].text = SM.importText('users.rst')
Clock.schedule_once(self.scrollBanner)
Clock.schedule_once(c1.appear,12)
Clock.schedule_once(c2.appear,24)
Clock.schedule_once(c3.appear,36)
Clock.schedule_once(c4.appear,48)
Clock.schedule_once(c5.appear,60)
Clock.schedule_once(c6.appear,72)
Clock.schedule_once(c7.appear,84)
Clock.schedule_once(c8.appear,96)
Clock.schedule_once(c9.appear,108)
Clock.schedule_interval(self.scrollBanner, 60)
Clock.schedule_interval(picto.addNodes, .1)
Clock.schedule_interval(picto.moreNodes, 5)
Clock.schedule_once(bubble.addJobs)
Clock.schedule_interval(bubble.progress, 6.1)
return window
class FIT3140Ui(BoxLayout): def __init__(self, maze, robotController, **kwargs): super(self.__class__,self).__init__(**kwargs) self.app = kivy.app.App.get_running_app() self.maze = maze self.robotController = robotController self.robot = self.robotController.robot self.mazeViewFloat = RelativeLayout() self.mazeView = MazeView(self.maze, self.robot, self.mazeViewFloat) self.mazeViewFloat.add_widget(self.mazeView) self.workspaceLayout = BoxLayout(orientation="vertical", size_hint=(1, .9))#will contain a 'begin' button and label self.beginButton = Button(text="Begin", size_hint=(1, .1))#run the tree self.beginButton.bind(on_press=self.app.runProgram) self.workspace = FCodeWorkspace() self.workspaceLayout.add_widget(self.workspace) self.workspaceLayout.add_widget(self.beginButton) #add all the things to the main screen self.add_widget(Palette(workspace=self.workspace))#add the palette self.add_widget(self.workspaceLayout)#add the workspace self.add_widget(self.mazeViewFloat)#add the maze
def add_widget(self, widget, index=0):
slide = RelativeLayout(size=self.size, x=self.x - self.width, y=self.y)
slide.add_widget(widget)
super(Carousel, self).add_widget(slide, index)
if index != 0:
self.slides.insert(index - len(self.slides), widget)
else:
self.slides.append(widget)
def __init__(self, **kwargs):
super(ChessboardUI, self).__init__(**kwargs)
game = kwargs.get('game', None)
# left numbers
left_box = BoxLayout(orientation='vertical', size_hint_x=None, width=dp(30))
for n in range(8, -1, -1):
if n == 0:
left_box.add_widget(Label())
break
left_box.add_widget(Label(text=str(n), color=(0,0,0,1)))
# right numbers
right_box = BoxLayout(orientation='vertical', size_hint_x=None, width=dp(30))
for n in range(8, -1, -1):
if n == 0:
right_box.add_widget(Label(size_hint_y=None, height=dp(30)))
break
right_box.add_widget(GridLabelOpponent(text=str(n), color=(0,0,0,1)))
main_box = BoxLayout(orientation='vertical')
merge_layers = RelativeLayout()
background_grid = ChessboardGrid()
self.actual_board = Chessboard(game=game)
self.actual_board.bind(move_made=self.set_moves)
merge_layers.add_widget(background_grid)
merge_layers.add_widget(self.actual_board)
bottom_box = BoxLayout(size_hint_y=None, height=dp(30))
for c in ('a','b','c','d','e','f','g','h'):
bottom_box.add_widget(Label(text=c, color=(0,0,0,1)))
top_box = BoxLayout(size_hint_y=None, height=dp(30))
for c in ('','a','b','c','d','e','f','g','h',''):
if not c:
top_box.add_widget(Label(size_hint_x=None, width=dp(30)))
continue
top_box.add_widget(GridLabelOpponent(text=c))
main_box.add_widget(merge_layers)
main_box.add_widget(bottom_box)
except_top = BoxLayout()
except_top.add_widget(left_box)
except_top.add_widget(main_box)
except_top.add_widget(right_box)
self.orientation = 'vertical'
self.add_widget(top_box)
self.add_widget(except_top)
self.labels = [bottom_box, top_box, left_box, right_box]
self.bind(minimize=self.min, all_moves=self.change_board_moves)
def buildUI(self):
bottomBox = RelativeLayout() # 1024,188
self.screenManager = KYRScreenManager(size=(1024,512), size_hint=(None,None))
self.info = TextInput(text=self.infoText, multiline=True, readonly=True, size=(1014,30), size_hint=(None,None), pos=(6,152))
btnMenu = Button(text='menu', size=(200,140), size_hint=(None,None), pos=(6,6))
bottomBox.add_widget(self.info)
bottomBox.add_widget(btnMenu)
self.add_widget(self.screenManager)
self.add_widget(bottomBox)
def __init__(self):
super(MainWidget, self).__init__()
songpath1 = 'together-we-are.wav'
songpath2 = 'lionhearted.wav'
self.selection = Selection()
song1 = Song(songpath1, song1_structure, self.selection)
song2 = Song(songpath2, song2_structure, self.selection)
self.beatgen = BeatwiseGenerator()
self.beatgen.add_song(song1)
self.beatgen.add_song(song2)
audio = Audio()
audio.add_generator(self.beatgen)
self.selection.beatgen = self.beatgen
self.clock = ClassClock()
self.conductor = Conductor(self.clock)
self.scheduler = Scheduler(self.conductor)
self.conductor.set_bpm(128)
#info = Label(text = "text", pos=(0, 500), text_size=(100,100), valign='top')
#self.add_widget(info)
# root = ScrollView(size_hint=(None, None), size=(800, 600),
# pos_hint={'center_x': .5, 'center_y': .5})
# self.add_widget(root)
#self.rel = AnchorLayout(size_hint=(None, None), width=9000, pos_hint={'center_x': .5, 'center_y': .5},
# anchor_x='left', anchor_y='top')
self.rel = RelativeLayout(size_hint=(None, None), width=9000, pos_hint={'center_x': .5, 'center_y': .5})
self.add_widget(self.rel)
# anchor = AnchorLayout(anchor_x='left', anchor_y='top')
# self.rel.add_widget(anchor)
layout = GridLayout(cols=1, padding=50, spacing=50, size_hint=(None, None), width=9000, row_force_default=True,
row_default_height=100)
self.rel.add_widget(layout)
for song in self.beatgen.get_songs():
container = RelativeLayout()
layout.add_widget(container)
container.add_widget(song)
self.nowline = Nowline(self.scheduler)
self.rel.add_widget(self.nowline)
self.beatgen.nowline = self.nowline
class ColorPickerBox(RelativeLayout):
def __init__(self, popupwindow, **kwargs):
super(ColorPickerBox, self).__init__(**kwargs)
self.popupwindow = popupwindow
self.generator = RelativeLayout(
size_hint = (None, None),
width = "400dp",
height = "200dp",
pos = ["50dp", "100dp"] #"50dp"
)
self.acw = AutonomousColorWheel(self)
self.generator.add_widget(self.acw)
self.gpi = ColoredTextInput(pos = ["230dp", "80dp"])
self.generator.add_widget(self.gpi)
self.add_widget(self.generator)
self.create_btn = Button(
size_hint = [None, None],
size = ["100dp","30dp"],
pos = ["320dp","10dp"]
)
self.create_btn.bind(on_release=self.create_group)
self.cancel_btn = Button(
size_hint = [None, None],
size = ["100dp","30dp"],
pos = ["200dp","10dp"]
)
self.cancel_btn.bind(on_release=self.cancel_creation)
self.add_widget(self.cancel_btn)
self.add_widget(self.create_btn)
def create_group(self, instance):
print("creation")
self.popupwindow.change_group()
self.popupwindow.dismiss()
def cancel_creation(self, instance):
print("cancel creation")
self.popupwindow.dismiss()
def color_change(self, rgba):
self.gpi.back_color = rgba
def add_widget(self, widget, index=0):
#replacing index by z-index
#a = RelativeLayout.add_widget(self, widget, getattr(widget,'z',0))
#Duplicate pointer to template
widget.template = self
#Re order them according to z elt:
cs = self.children[:]
cs.append(widget)
cs.sort(key= lambda x: getattr(x,'z',0))
self.clear_widgets()
for c in cs:
RelativeLayout.add_widget(self,c)
self.children = cs
def buildUI(self):
bottomBox = RelativeLayout() # 1024,188
self.screenManager = KYRScreenManager(size=(1068,450), size_hint=(None,None), pos=(25,224))
self.info = Info(text=self.infoText, multiline=True,
readonly=True, size=(1064,30), size_hint=(None,None), pos=(25,167))
btnMenu = Button(text='menu', size=(196,120), size_hint=(None,None), pos=(28,16), opacity = .5)
self.inventory = GridLayout(orientation='vertical',cols=5,pos=(333,-562),spacing=15)
bottomBox.add_widget(self.info)
bottomBox.add_widget(btnMenu)
self.add_widget(self.inventory)
self.add_widget(self.screenManager)
self.add_widget(bottomBox)
self.buildInventory()
class GameOver(Popup):
def __init__(self, root_widget, **kw):
super(GameOver, self).__init__(**kw)
self.root_widget = root_widget
self.title = 'GAME OVER'
self.layout = RelativeLayout()
self.btn_new_game = Button(text='New Game', size_hint=(.5,.1), pos_hint={'center_x':.25, 'center_y': .05})
self.btn_new_game.bind(on_press=self.new_game)
self.btn_exit = Button(text='Exit', size_hint=(.5,.1), pos_hint={'center_x':.75, 'center_y': .05})
self.btn_exit.bind(on_press=self.root_widget.close_app)
self.lbl_score = Label(size_hint=(.5,.1), pos_hint={'center_x':.5, 'center_y': .4})
self.lbl_high_score = Label(size_hint=(.5,.1), pos_hint={'center_x':.5, 'center_y': .7})
self.layout.add_widget(self.lbl_score)
self.layout.add_widget(self.lbl_high_score)
self.layout.add_widget(self.btn_new_game)
self.layout.add_widget(self.btn_exit)
self.content = self.layout
self.size_hint = (None, None)
self.size = (400, 400)
def set_score(self, score):
high_score = load_data('data/score.txt')
if score > high_score:
high_score = score
write_data('data/score.txt', score)
self.lbl_score.text = 'Score: %s' % score
self.lbl_high_score.text = 'High Score: %s' % high_score
def new_game(self, *args):
self.dismiss()
self.root_widget.new_game()
def _generateMap(self): layout = RelativeLayout() self.mapImg=Image(source='resources/images/map.png',allow_stretch = True, keep_ratio = False) self.mapPin = MapPin( parent=self.mapImg,view = self,allow_stretch = False, source='resources/images/pin.png', size=(20,34)) self.mapImg.add_widget(self.mapPin) layout.add_widget(self.mapImg) print "Scheduling." # Clock.schedule_interval(self._updateMapImg, 2) Clock.schedule_interval(self._timeseriesGenerated, 2) return layout
class Region:
def __init__(self, loader, region_config):
self.loader = loader
self.widget = RelativeLayout()
self.objects = set()
for tile in region_config.tiles:
self.widget.add_widget(tile.image)
for ID in region_config.object_IDs:
self.load_object(ID)
self._to_cleanup = []
def update(self, dt):
for obj in self.objects:
obj.signals.update.send(dt)
while self._to_cleanup:
obj = self._to_cleanup.pop()
self.objects.remove(obj)
# TODO consider using weakref.finalize
try:
self.widget.remove_widget(obj.widget._kivy_widget)
except AttributeError:
pass
def load_object(self, ID):
obj = self.loader.load(ID)
obj.signals.destroy.connect(self.cleanup)
self.objects.add(obj)
try:
# TODO clean up this widget stuff
self.widget.add_widget(obj.widget._kivy_widget)
except AttributeError:
pass
def cleanup(self, obj):
self._to_cleanup.append(obj)
class BiscuitsApp(App):
def __init__(self):
super().__init__()
self.widget = RelativeLayout()
self._scene = None
self.input = Input()
self.game = BiscuitsGame(self)
@property
def scene(self):
return self._scene
@scene.setter
def scene(self, scene):
if self._scene:
self._scene.unload()
self.widget.remove_widget(self._scene.widget)
self._scene = scene
self.widget.add_widget(scene.widget)
def load_scene(self, loadpoint_ID):
loadpoint = loadpoints[loadpoint_ID]
if loadpoint.type == 'dead':
self.scene = DeadScene(self)
elif loadpoint.type == 'start':
self.scene = StartScene(self)
elif loadpoint.type == 'comic':
self.scene = ComicScene(self, loadpoint)
else:
self.scene = self.game.load(loadpoint)
def update(self, dt):
self.input.update(dt)
self.scene.update(dt)
def build(self):
EventLoop.ensure_window()
self.load_scene('Loadpoint 1a')
Clock.schedule_interval(self.update, 1.0 / 60.0)
return self.widget
def addButton(self,text='',btntxt = '',callback=None):
entrysize = [0,0]
horiz = RelativeLayout(size_hint= (1.0,None))#orientation = 'lr-tb',padding=(5,5,5,5))
newtext = Label(text=text,markup=True, size_hint= (1.0,None) )
newtext.texture_update()
newtext.size = newtext.texture_size
newtext.size_hint = (None,None)
entrysize = [ entrysize[0] + newtext.width , max(entrysize[1],newtext.height) ]
#horiz.center = (Window.width/2,-entrysize[1]/2)
#(Window.width/2-entrysize[0]/2-5, -entrysize[1]/2) #- newtext.width
btn = Button(text=btntxt)
if callback is not None: btn.bind(on_press=callback)
btn.size_hint = (None,None)
btn.texture_update()
btn.size = btn.texture_size
print newtext.size, btn.size
btn.width += 10
btn.height += 10
entrysize = [ entrysize[0] + btn.width , max(entrysize[1], btn.height) ]
horiz.size=(entrysize[0],entrysize[1]+7)
btn.center = (Window.width/2 + btn.width/2+5, btn.height/2+5) #- newtext.width
newtext.center = (Window.width/2 - newtext.width/2-5,btn.height/2+5)#(Window.width/2-newtext.width/2-5,-entrysize[1]/2)
#horiz.size = (entrysize[0], entrysize[1])
print entrysize
#horiz.center = (Window.width/2,-entrysize[1]/2)
horiz.add_widget(newtext)
horiz.add_widget(btn)
self.verticality += entrysize[1]+7
self.size = (Window.width,self.verticality)
self.add_widget(horiz)
print self.verticality
class ButtonPad(Widget):
def __init__(self, **kw):
super(ButtonPad, self).__init__(**kw)
self.listeners = []
self.layout = RelativeLayout()
self.add_widget(self.layout)
btn_ids = ['A', 'B', 'X', 'Y']
btn_pos = [(.8, .5), (.5, .2), (.5, .8), (.2, .5)]
btn_colors = [[.7,0,0,1],[.9,.7,0,1],[0,.3,.7,1],[0,.7,0,1]]
for i in range(4):
btn = Button(id=btn_ids[i], size_hint=(.2, .2),
background_color=btn_colors[i],
background_normal='img/btn-normal.png',
background_down='img/btn-down.png',
pos_hint={'center_x': btn_pos[i][0], 'center_y': btn_pos[i][1]})
btn.bind(on_press=self.btn_press)
self.layout.add_widget(btn)
with self.canvas.before:
Color(1, 1, 1, 1)
self.rect = Rectangle(pos=self.pos, size=self.size, source='img/bpad.png')
self.bind(pos=self._update_rect)
self.bind(size=self._update_rect)
# self.polling = kw['polling'] if 'polling' in kw else .01
# Clock.schedule_interval(self.send_input, self.polling)
def _update_rect(self, *args):
self.rect.pos = self.pos
self.rect.size = self.size
self.layout.pos = self.pos
self.layout.size = self.size
def btn_press(self, btn):
self.notify('bpad_input', btn=btn.id)
def notify(self, event_name, *args, **kw):
for listener in self.listeners:
if event_name in listener.handlers:
getattr(listener, event_name)(*args, **kw)
# def send_input(self, dt):
# self.notify('bpad_input', input=self.input)
def request_address(self, currency):
lay = RelativeLayout()
lbl = Label(text="""
Note: A gateway will be opened and the appearing vaddres \n
can be used ONE TIME to send assets to, which will \n
then appear on the linked address outside the Versum Ecosystem""",\
size_hint=(0.75,0.1),pos_hint={"x":0.125,"y":0.8})
lay.add_widget(lbl)
btn = Button(text="Open Gateway",size_hint=(0.5,0.1),pos_hint={"x":0.25,"y":0.1},\
on_press=lambda x: self.get_address(currency))
lay.add_widget(btn)
self.raddress = TextInput(size_hint=(0.6,0.1),pos_hint={"x":0.2,"y":0.3},\
hint_text="Recipient Address")
lay.add_widget(self.raddress)
self.vaddress = Label(size_hint=(0.5,0.1),pos_hint={"x":0.25,"y":0.5})
lay.add_widget(self.vaddress)
btn2 = Button(text="Copy",size_hint=(0.1,0.1),pos_hint={"x":0.85,"y":0.5},\
on_press=lambda x: self.copy_add(self.vaddress.text))
lay.add_widget(btn2)
self.sendbox = Popup(title="Withdraw",content=lay, size_hint=(0.5,0.5))
self.sendbox.open()
def vsend(self):
"""
Open the withdraw screen for actual currency
"""
assets = {}
if not self.veth_amount.text and not self.vbtc_amount.text and not self.vltc_amount.text:
self.notification("Enter an amount to send.")
return
if self.vbtc_amount.text:
assets["BTC"] = float(self.vbtc_amount.text)
self.vbtc_amount.text = ""
if self.vltc_amount.text:
assets["LTC"] = float(self.vltc_amount.text)
self.vltc_amount.text = ""
if self.veth_amount.text:
assets["ETH"] = float(self.veth_amount.text)
self.veth_amount.text = ""
lay = RelativeLayout()
lbl = Label(text="""
Note: Only send assets to addresses inside the Versum Ecosystem,\n
if you need to send funds outside of Versum, open a Gateway at first.""",\
size_hint=(0.75,0.1),pos_hint={"x":0.125,"y":0.8})
lay.add_widget(lbl)
btn = Button(text="Send",size_hint=(0.5,0.1),pos_hint={"x":0.25,"y":0.1},\
on_press=lambda *args: self.make_payment(assets,*args))
lay.add_widget(btn)
self.to_addr = TextInput(size_hint=(0.6,0.1),pos_hint={"x":0.2,"y":0.3},\
hint_text="Recipient Address")
lay.add_widget(self.to_addr)
self.sendbox = Popup(title="vSend", content=lay, size_hint=(0.5, 0.5))
self.sendbox.open()
def create_histo_layout(self, qty, name, confirmations, time):
Layout = RelativeLayout(bcolor=(1, 0.2, 1, 1))
if qty > 0:
text = "Incoming " + str(
qty) + " " + str(name) + "\n"
Layout.add_widget(
Image(source="gui/versumwallet/histo_green.png",
size_hint=(1, 0.9),
allow_stretch=True,
keep_ratio=False))
elif qty < 0:
text = "Outgoing " + str(
qty) + " " + str(name) + "\n"
Layout.add_widget(
Image(source="gui/versumwallet/histo_red.png",
size_hint=(1, 0.9),
allow_stretch=True,
keep_ratio=False))
text += str(time) + "\n"
text += "Confirmations: " + str(confirmations)
title = Label(text=text, color=(0, 0, 0, 1), halign="left")
Layout.add_widget(title)
return Layout
class HorseTrack(RelativeLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.horse_pos = 0, 0
self.events = []
def load(self):
self.horse = Horse()
self.move_layout = RelativeLayout()
self.animation_layout = RelativeLayout()
self.add_widget(self.move_layout)
self.move_layout.add_widget(self.animation_layout)
self.animation_layout.add_widget(self.horse)
self.make_events()
self.next_anim()
def next_anim(self, *args):
print(self.horse.pos)
self.events.pop(0)()
def make_events(self, amount=30, random=20):
times = amount #+randint(0,random)
start = self.horse.pos[0]
finish = self.horse.pos[0]
diff = finish - start
print(start, finish, "=", diff)
base_time = 30 / times
for i in range(times):
base_x = i * 100
x = base_x + randint(-60, 60)
y = gauss(0, 10)
t = gauss(base_time, 3)
print(x, y)
self.events.append(self.move_to(x, y, t))
def move_to(self, x, y, t):
anim = Animation(x=x, y=y, d=t, t="in_out_quint")
anim.bind(on_complete=self.next_anim)
return partial(anim.start, self.move_layout)
def addChampionsToScrollView(self, championList, scrollLayout):
for champName in championList:
iconLayout = RelativeLayout(size_hint_x=0.1)
champIcon = Image(size_hint_y=0.8,
pos_hint={'center_y': 0.5},
allow_stretch=True,
source="images\\championImages\\" + champName +
"\\" + champName.lower().replace(" ", "_") +
"_icon.png")
nameButton = Button(text=champName,
font_size='22sp',
height=50,
size_hint_x=0.9,
size_hint_y=None)
# this method binds the button to the lambda method with early binding and then passes the button's text as the name
nameButton.bind(
on_press=lambda champName=champName: self.
switchToChampionInformation(championName=champName.text))
iconLayout.add_widget(champIcon)
scrollLayout.add_widget(iconLayout)
scrollLayout.add_widget(nameButton)
def show_priv_key(self):
with open(rpc) as rpcfile:
data = rpcfile.read().split("\n")
rpcuser = data[0][8:]
rpcpassword = data[1][12:]
rpchost = 'localhost'
rpcport = '6804'
chainname = "testchain"
api = Savoir(rpcuser, rpcpassword, rpchost, rpcport, chainname)
privkey = api.dumpwallet("C:\\Users\\" + os.getenv('username') +
"\\Desktop\\wallet.txt")
lay = RelativeLayout()
lbl = Label(text="""
Note: Your wallet file has been dumped!\n
You can view it in C:\\Users\\"""+os.getenv('username')+"""\\Desktop\\wallet.txt\n
Do not share any of your private keys with anyone!\n""",\
size_hint=(0.75,0.1),pos_hint={"x":0.125,"y":0.6})
lay.add_widget(lbl)
self.sendbox = Popup(title="New Paper Wallet",
content=lay,
size_hint=(0.5, 0.5))
self.sendbox.open()
class ColorApp(App):
def build(self):
self.layout = RelativeLayout()
self.btn = Button(background_color=(1, 0, 0, 1))
self.layout.add_widget(self.btn)
self.btn2 = Button(text='Change color',
pos_hint={
'center_x': .5,
'center_y': .1
},
size_hint=(.4, .1))
self.btn2.bind(on_press=self.change_color)
self.layout.add_widget(self.btn2)
Clock.schedule_interval(self.change_color, 1)
return self.layout
def change_color(self, event):
color = (random.uniform(0, 1), random.uniform(0,
1), random.uniform(0,
1), 1)
self.btn.background_color = color
def make(self):
self.orientation = "vertical"
Window.size = (512, 600)
layout_uno = RelativeLayout(size=(512, 512), size_hint=(None, None))
img = Image(source='bg_image.png', pos=(0, 0))
layout_uno.add_widget(img)
self.hmap = Map()
self.hmap.pos = (0, 0)
self.hmap.size = (512, 512)
self.hmap.make()
layout_uno.add_widget(self.hmap)
self.add_widget(layout_uno)
layout_dos = BoxLayout(orientation="horizontal")
gen_button = Button(text="Generate")
gen_button.bind(on_release=self.generate)
self.switch_button = Button(text="Change LOD")
layout_dos.add_widget(gen_button)
layout_dos.add_widget(self.switch_button)
self.add_widget(layout_dos)
def build(self):
map_widget = Map()
map_widget.size = [3000, 3000]
map_widget.redraw(index=self.quad_index)
btn_prev = Button(text='PREV',
on_press=partial(self.setMapIndex, map_widget, -1))
btn_next = Button(text='NEXT',
on_press=partial(self.setMapIndex, map_widget, 1))
layout = BoxLayout(size_hint=(1, None), height=50)
layout.add_widget(btn_prev)
layout.add_widget(btn_next)
root = BoxLayout(orientation='vertical')
rl = RelativeLayout()
rl.add_widget(map_widget)
root.add_widget(rl)
root.add_widget(layout)
return root
def build():
layout = RelativeLayout()
ed = TextInput(text="teste")
ed =ed.global
ed.size_hint = None, None
ed.height = 300
ed.width = 400
ed.y = 250
ed.x = 90
btn = Button(text="Clique aqui")
btn.size_hint = None, None
btn.width = 200
btn.height = 50
btn.y = 150
btn.x = 200
btn.on_press= click()
layout.add_widget(ed)
layout.add_widget(btn)
return layout
def build(self):
layout = RelativeLayout(size=(2000, 2000))
hex_grid = HexCanvas(self.width, self.height, self.rows, self.columns,
self.selection_color, self.grid_color,
self.grid_width)
hex_grid.selection_mesh.vertices = hex_vertices(
hex_grid.grid, self.selected_hex)
self.selection_mesh = hex_grid.selection_mesh
grid = hex_grid.grid
self.grid = grid
# label the hexes with square coordinates for developer reference
for i in range(0, len(hex_grid.hexes)):
h = hex_grid.hexes[i]
label = Label(text=str(h[0]) + ',' + str(h[1]),
width=10,
height=10,
color=(0.3, 0.3, 0.3, 1),
x=grid.hex_center(h).x - 5,
y=grid.hex_center(h).y - 5)
hex_grid.add_widget(label)
layout.add_widget(hex_grid)
return layout
def build(self):
layout = RelativeLayout()
layout.add_widget(Console())
self.scroll_widget = Builder.load_string("""
ClickableScrollView:
size_hint: 0.6, 0.45
pos_hint: {'right': 1}
do_scroll_x: False
effect_cls: 'ScrollEffect'
Label:
id: label
size_hint: None, None
size: self.texture_size
font_name: 'Fantasque'
font_size: str(int(root.width / 0.6 * 15 / 1706)) + 'pt'
line_height: 1.15
markup: True
color: 1, 1, 1, 1
""")
self.scroll_widget.opacity = 0
self.scroll_widget.ids.label.text = ''
layout.add_widget(self.scroll_widget)
return layout
def build(self):
for i in range(49):
button = Button(background_normal='')
self.buttons.append(button)
img_button = Button(background_normal='')
self.img_buttons.append(img_button)
float_button = RelativeLayout()
float_button.add_widget(button)
float_button.add_widget(img_button)
self.float_buttons.append(float_button)
self.grid_name.add_widget(float_button)
for i in range(5):
next_button = Button(background_normal='',
size_hint=(None, None),
size=(50, 50))
self.next_buttons.append(next_button)
self.box_name.add_widget(next_button)
self.update()
def count_total(self):
self.clear_widgets()
unit = config.units[self.slider.current_unit]
time_to = '21:50:58' # TODO: Temporary var, change to real time
if self.slider.value > 0:
total_time = unit[1] * int(self.slider.value)
self.slider.time_label.text = f'Обучение продлится: {total_time} сек до {time_to}'
for i, res_cost in enumerate(unit[2]):
total_res = res_cost * int(self.slider.value)
if res_cost > 0:
res_box = BoxLayout(orientation='horizontal',
size_hint_x=.5)
help_lay_res = RelativeLayout()
help_lay_res.add_widget(
Image(source=f'{config.resources[res_list[i]][2]}',
size=(30, 30),
pos_hint=({
'right': 1
}),
size_hint=(None, 1)))
add_lay = GridLayout(cols=2,
size_hint=(1, 1),
pos_hint=({
'center_x': .5,
'center_y': .5
}))
add_lay.add_widget(help_lay_res)
add_lay.add_widget(BuildResLabel(text=f'{total_res}'))
res_box.add_widget(add_lay)
self.add_widget(res_box)
anim_opacity_up.start(self)
anim_opacity_up.start(self.slider.total_res_label)
anim_opacity_up.start(self.slider.time_label)
else:
anim_opacity_down.start(self)
anim_opacity_down.start(self.slider.total_res_label)
anim_opacity_down.start(self.slider.time_label)
class RpgGame(Widget):
player_object = None
game_objects = []
toolbar = None
label = None
def __init__(self, **kwargs):
super(RpgGame, self).__init__(**kwargs)
self.toolbar = RelativeLayout(pos=(100, 50))
label = Label(text='')
self.label = label
self.toolbar.add_widget(label)
self.add_widget(self.toolbar)
self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
self._keyboard.bind(on_key_down=self._on_keyboard_down)
def _keyboard_closed(self):
self._keyboard.unbind(on_key_down=self._on_keyboard_down)
self._keyboard = None
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
self.player_object.entity.move(keycode[1])
move_anim = Animation(pos=self.player_object.entity.draw_coord, duration=1)
move_anim.bind(on_start=self.player_object.start_sprite_anim)
move_anim.bind(on_complete=self.player_object.stop_sprite_anim)
move_anim.start(self.player_object)
return True
def set_player(self, player):
self.player_object = player
def add_object(self, obj):
self.add_widget(obj)
self.game_objects.append(obj)
def update(self, dt):
self.label.text = str(self.player_object.entity)
def display_preset_info(self, preset):
self.info_panel.clear_widgets()
if preset == None:
return
manager.CURRENT_PRESET = preset.name
self.show_presets()
self.info_panel.add_widget(
Label(text=(preset.name), color=(1, 1, 1, 1), font_size=25))
for key in preset.attributes:
attr_layout = RelativeLayout(size=(100, 30), size_hint=(1, None))
attr_layout.add_widget(
EditableLabel(text=('' + key[0] + ' ' + key[1] + ' ' +
preset.attributes[key]),
size=(300, 30),
attr_category=key[2],
size_hint=(None, None),
pos_hint={
"center_x": .5,
"center_y": .5
},
color=(1, 1, 1, 1),
font_size=14))
self.info_panel.add_widget(attr_layout)
self.info_panel.button_layout = RelativeLayout(size=(100, 30),
size_hint=(1, None))
self.info_panel.button_layout.add_widget(
HoverButton(font_size=20,
text='New Attribute',
size=(500, 30),
size_hint=(None, None),
pos_hint={"center_x": .5},
button_up=DD_LCHRC[0],
button_down=DD_LCHRC[1],
on_press=self.add_new_label))
self.info_panel.add_widget(self.info_panel.button_layout)
def display_user_info(self, user):
self.clear()
editable = manager.ADMIN
manager.CURRENT_USER = user
manager.menu.show_searched_users()
self.layout.add_widget(
Label(text=(user), color=(1, 1, 1, 1), font_size=25))
for attr in database.get_user_attrs(user):
if "password" in attr.name.lower():
color = (1, 1, 1, 1)
bold = manager.menu.get_search_mode(
) != 'name' and manager.menu.get_search_term() != ""
if self.color_dark(attr.name, attr.value):
color = (1, 1, 1, .7)
bold = False
attr_layout = RelativeLayout(size=(100, 30),
size_hint=(1, None))
label = Label(text=("" + attr.name + " " + attr.operator +
" " + attr.value),
color=color,
size=(300, 30),
bold=bold,
size_hint=(None, None),
pos_hint={
"center_x": .5,
"center_y": .2
},
font_size=14)
label.name = attr.name
label.val = attr.value
attr_layout.add_widget(label)
self.attribute_labels.append(label)
self.layout.add_widget(attr_layout)
else:
self.create_attr_label(attr, editable)
class FileChooserWindow(ModalView):
def __init__(self, load_callback, **kwargs):
self.load_callback = load_callback
super(FileChooserWindow, self).__init__(**kwargs)
self.layout = RelativeLayout()
fc = FileChooserListView(filters=["*.csv", "*.xlsx", "*.txt"],
size_hint=(.8, 1))
fc.bind(on_submit=self.file_chosen)
self.layout.add_widget(fc)
exit_btn = Button(text='Exit',
size_hint=(.1, .1),
pos_hint={
'center_x': .9,
'center_y': .9
})
exit_btn.bind(on_press=self.dismiss)
self.layout.add_widget(exit_btn)
self.add_widget(self.layout)
def file_chosen(self, event, filename, *args):
self.load_callback(filename[0])
def base_energy():
scroll = ScrollView(do_scroll_x=False, scroll_x=.5, scroll_y=1)
main_rel_layout = RelativeLayout(height=500, width=600, size_hint=(1, 1))
generators_lay = GridLayout(rows=2, padding=20)
generators_desc = BoxLayout(size_hint_y=1)
generators_stack = GridLayout(rows=1, size_hint=(1, 0.5))
# generators stack content
dev_item1 = BoxLayout(padding=5)
dev_item2 = BoxLayout(padding=5)
dev_item3 = BoxLayout(padding=5)
dev_item4 = BoxLayout(padding=5)
dev_item1.add_widget(GenImage())
dev_item2.add_widget(GenImage())
dev_item3.add_widget(GenImage())
dev_item4.add_widget(GenImage())
generators_stack.add_widget(dev_item1)
generators_stack.add_widget(dev_item2)
generators_stack.add_widget(dev_item3)
generators_stack.add_widget(dev_item4)
# generators stack content
# generators description content
generators_desc.add_widget(Label(text='Описание генераторов'))
# generators description content
generators_lay.add_widget(generators_stack)
generators_lay.add_widget(generators_desc)
main_rel_layout.add_widget(generators_lay)
scroll.add_widget(main_rel_layout)
return scroll
def __init__(self, **kwargs):
super(FileChooserPopup, self).__init__(**kwargs)
self.title = 'Select features file'
layout = RelativeLayout()
file_chooser_list_view = FileChooserListView(filters=['*.txt', '*.data'], size_hint=(1, 0.8), pos_hint={'x': 0, 'y': 0.2})
file_chooser_list_view.bind(selection=self.file_chooser_selection_do)
self.text_input = TextInput(text='', readonly=True, size_hint=(1, 0.1), pos_hint={'x': 0, 'y': 0.1})
layout.add_widget(file_chooser_list_view)
layout.add_widget(self.text_input)
layout.add_widget(Button(text='Select', italic=True, on_release=self.dismiss, size_hint=(0.25, 0.1), pos_hint={'x': 0.25, 'y': 0}))
layout.add_widget(Button(text='Cancel', italic=True, on_release=self.cancel_btn_do, size_hint=(0.25, 0.1), pos_hint={'x': 0.5, 'y': 0}))
self.content = layout
class ScrollableLabel(ScrollView):
def __init__(self, **kwargs):
super(ScrollableLabel, self).__init__(**kwargs)
######################################
self.ParentLayout = FloatLayout()
self.ScrollWindow = RelativeLayout()
self.ScrollLabel = Label()
self.text = StringProperty('')
######################################
self.ScrollWindow.size_hint = (None, None)
######################################
def Set_ScrollWindow(self):
self.ScrollWindow.clear_widgets()
self.clear_widgets()
self.width = self.ScrollWindow.width
self.height = self.ScrollWindow.height
self.x = 0
self.y = 0
self.do_scroll_x = False
self.do_scroll_y = True
self.ParentLayout.add_widget(self.ScrollWindow)
self.ScrollWindow.add_widget(self)
self.ScrollLabel.halign = 'left'
self.ScrollLabel.valign = 'top'
self.ScrollLabel.padding_x = 6
self.ScrollLabel.padding_y = 4
self.ScrollLabel.x = 0
self.ScrollLabel.y = 0
self.ScrollLabel.size_hint = (None, None)
self.ScrollLabel.size = (self.width, 0)
self.ScrollLabel.text_size = (self.width, None)
self.ScrollLabel.color = (0, 0, 0, 1)
self.ScrollLabel.texture_update()
self.ScrollLabel.height = self.ScrollLabel.texture_size[1]
self.add_widget(self.ScrollLabel)
class KivyCardPile(CardPile):
def __init__(self, name, player):
super(KivyCardPile,self).__init__(name, player)
self.displayed=False
self.lock = threading.Lock()
def initDisplay(self,xpos,ypos,scale,parentlayout,orientation):
#ignores orientation
self.displayed=True
self.xpos=int(xpos)
self.ypos=int(ypos)
self.scale=scale
self.layout= RelativeLayout()
parentlayout.add_widget(self.layout)
self.updateDisplay()
def updateDisplay(self):
self.layout.clear_widgets()
card=self.peek()
offset=0
if card.state == eCardState.good:
offset=10
card2=self.peekpeek()
card2.scatter.scale=self.scale
card2.scatter.pos=(self.xpos,self.ypos)
self.layout.add_widget(card2.scatter)
card.scatter.scale=self.scale
card.scatter.pos=(int(self.xpos+offset),int(self.ypos-offset))
self.layout.add_widget(card.scatter)
def dealCard(self,newCardList,newState):
if self.displayed:
#Display the card underneath (the next top one)
self.layout.clear_widgets()
card=self.peekpeek()
card.scatter.scale=self.scale
card.scatter.pos=(self.xpos,self.ypos)
self.layout.add_widget(card.scatter)
super(KivyCardPile,self).dealCard(newCardList,newState)
def append(self,card):
#self.lock.acquire()
print card
super(KivyCardPile,self).append(card)
offset=0
if card.state == eCardState.good:
offset=10
if self.displayed:
card.setDest(self.xpos+offset,self.ypos-offset,self.scale,self,True)
def bringToFront(self):
parent = self.layout.parent
parent.remove_widget(self.layout)
parent.add_widget(self.layout)
def __init__(self, **kwargs):
super(Alert_dept, self).__init__(**kwargs)
layout = RelativeLayout()
drop = DropDown()
self.msg = TextInput(hint_text="Message to be received",
size_hint=(0.75, .3),
pos_hint={
'x': 0.07,
'y': 0.55
})
self.hi = TextInput(hint_text="Enter message to send",
size_hint=(0.75, .3),
pos_hint={
'x': 0.07,
'y': 0.2
})
sendbutton = Button(text='SEND',
size_hint=(.1, .1),
pos_hint={
'x': 0.37,
'y': 0.07
})
sendbutton.bind(on_press=lambda x: self.sendmsg())
#endbutton = Button(text='HANG UP', size_hint=(.2,.1),pos_hint={'x':0.1,'y':0.05})
#endbutton.bind(on_press=lambda x:self.hangup())
#testbtn = Button(text = 'Change', size_hint = (.2,.1),pos_hint={'x':0.1,'y':0.05})
#testbtn.bind(on_press = lambda x:self.switch_next())
self.spinner = Spinner(text='Mechanical',
values=('Electrical', 'Mechanical',
'Maintenance'),
size_hint=(.15, .09),
pos_hint={
'x': 0.05,
'y': 0.9
})
self.spinner.bind(on_text=self.show_selected_value)
layout.add_widget(self.msg)
layout.add_widget(self.hi)
layout.add_widget(sendbutton)
layout.add_widget(self.spinner)
#layout.add_widget(endbutton)
#layout.add_widget(testbtn)
self.add_widget(layout)
def drawOverallLayout(self):
layout = RelativeLayout()
title = Label(text="LoL Champion Visualizer", size_hint=(1, 0.2), font_size='40sp', pos_hint ={'middle':1, 'top':1})
newDataButton = Button(text="Search For New Champions", size_hint=(0.5, 0.8), font_size='32sp', pos_hint ={'left':1, 'middle':1})
existingDataButton = Button(text="Use Existing Data", size_hint=(0.5, 0.8), font_size='32sp', pos_hint ={'right':1, 'middle':1})
#on_press=self.changeToSearchGui()
newDataButton.bind(on_press=lambda a:self.screen_transition_newData())
existingDataButton.bind(on_press=lambda a:self.screen_transition_existingData())
layout.add_widget(title)
layout.add_widget(newDataButton)
layout.add_widget(existingDataButton)
return layout
def build(self):
layout = RelativeLayout(size=(500, 500))
self.cam = Camera(play=True, resolution=(1500, 1500))
self.button = Button(text='Detect a face!',
size_hint=(.5, .07),
pos=(450, 100))
self.button.bind(on_press=self.on_press_button)
self.button_sketch = Button(text='Create a sketch!',
size_hint=(.5, .07),
pos=(450, 10))
self.button_paint = Button(text='Create a painting',
size_hint=(.5, 0.07),
pos=(450, 190))
self.button_sketch.bind(on_press=self.on_press_sketch_button)
self.button_paint.bind(on_press=self.on_press_paint_button)
layout.add_widget(self.cam)
layout.add_widget(self.button)
layout.add_widget(self.button_sketch)
layout.add_widget(self.button_paint)
return layout
def build(self):
widget = RelativeLayout()
test_button = TestObject('1', size_hint=(0.25, 0.2), pos_hint={'x': 0, 'y': 0})
test_button2 = TestObject('2', size_hint=(0.2, 0.1), pos_hint={'x': 0.4, 'y': 0})
test_button3 = TestObject('3', size_hint=(0.5, 0.5), pos_hint={'x': 0.5, 'y': 0.5})
test_button4 = TestObject('4', size_hint=(0.2, 0.2), pos_hint={'x': 0.6, 'y': 0.6}, layer=1, blocking=False)
test_button5 = TestObject('5', size_hint=(0.2, 0.1), pos=(0.6 * 1706, 0.75 * 960))
test_button6 = TestObject('6', size_hint=(0.2, 0.2), pos_hint={'x': 0.65, 'y': 0.7}, layer=2, blocking=False)
widget.add_widget(test_button)
widget.add_widget(test_button2)
widget.add_widget(test_button3)
test_button3.add_widget(test_button5)
widget.add_widget(test_button4)
widget.add_widget(test_button6)
return widget
class MainScreen(BasicScreen):
def __init__(self, background_img, **kwargs):
super(MainScreen, self).__init__(name='MainScreen', background_img=background_img, **kwargs)
self.main_layout = RelativeLayout(id='MainLayout', orientation='vertical', size_hint=(1, 1))
self.main_title = Label(id='MainTitle', text='BoardGameApp', font_size=30, pos_hint={'y': 0.8}, size_hint_y=0.2)
self.maps_button = Button(id='MapsButton', text='Show map', size_hint=(0.5, 0.18),
pos_hint={'x': 0.25, 'y': 0.38},
on_press=lambda a: App.get_running_app().root.switch_screen('MapScreen'))
self.games_button = Button(id='GamesButton', text='Show games', size_hint=(0.5, 0.18),
pos_hint={'x': 0.25, 'y': 0.2},
on_press=lambda a: App.get_running_app().root.switch_screen('ListGamesScreen'))
self.main_layout.add_widget(self.main_title)
self.main_layout.add_widget(self.maps_button)
self.main_layout.add_widget(self.games_button)
self.add_widget(self.main_layout)
def request_address(self, currency):
url = gateways_ip + currency + "/get/raddress"
data = json.dumps({
"vaddress":
json.load(open(path + "wallet.json", "r"))["address"]
})
resp = post(url, data).text
if resp != "Error" and len(resp) < 50: #server is up
lay = RelativeLayout()
lbl = Label(text="""
Note: Use the displayed address ONLY ONCE to depsit funds.\n
Do not deposit currencys other than """ + currency,\
size_hint=(0.75,0.1),pos_hint={"x":0.125,"y":0.8})
lay.add_widget(lbl)
self.raddress = Label(text=resp,
size_hint=(0.5, 0.1),
pos_hint={
"x": 0.25,
"y": 0.5
})
lay.add_widget(self.raddress)
btn = Button(text="Copy",size_hint=(0.1,0.1),pos_hint={"x":0.8,"y":0.5},\
on_press=lambda x: self.copy_add(self.raddress.text))
lay.add_widget(btn)
self.sendbox = Popup(title="Deposit",
content=lay,
size_hint=(0.5, 0.5))
self.sendbox.open()
else: #server is down
lay = RelativeLayout()
lbl = Label(text="Seems like the Gateway is currently down. Sorry!",\
size_hint=(0.75,0.1),pos_hint={"x":0.125,"y":0.8})
lay.add_widget(lbl)
self.sendbox = Popup(title="Deposit",
content=lay,
size_hint=(0.5, 0.5))
self.sendbox.open()
class ViewSuccess(Screen):
def __init__(self, secretary, screen_manager, previous_screen, home, **kwargs):
super().__init__(**kwargs)
self.main_layout = RelativeLayout()
self.label_screen = Label(text="Results", size_hint=(0.5, .15), pos_hint={'x':0.25, 'y': .85},
font_size=UiConstants.UiConstants.labe_main_screen, color=[0, 0, 0, 1],
font_name="fonts/RobotoMono-Bold.ttf",)
self.text_input_show_results = TextInput(size_hint=(.7, .6), pos_hint={'x': 0.15, 'y': .24},
background_normal="backgrounds/input-background.jpg")
self.button_start_new_sequence = Button(text="Run another sequence", size_hint=(.5, .1),
pos_hint={'x': 0.25, 'y': .0},
background_normal="backgrounds/next-button.jpg",
background_down="backgrounds/next-button-pressed.jpg",
font_name="fonts/RobotoMono-Bold.ttf",
font_size=UiConstants.UiConstants.label_font_size,
on_release=lambda btn: self.next_sequence(home))
self.screen_manager = screen_manager
self.secretary = secretary
self.main_layout.add_widget(self.label_screen)
self.main_layout.add_widget(self.text_input_show_results)
self.main_layout.add_widget(self.button_start_new_sequence)
Clock.schedule_once(self.custom_init, 1)
def custom_init(self, *args):
self.add_widget(self.main_layout)
def on_pre_enter(self, *args):
self.render_output_file(text_input=self.text_input_show_results, secretary=self.secretary)
def load_file(self, secretary):
print(secretary.output_file_path + secretary.output_file_name)
result_file_path = os.path.join(secretary.output_file_path, secretary.output_file_name)
file = open(result_file_path, "r")
if file.mode == 'r':
file_content = file.read()
return file_content
else:
return
def render_output_file(self, text_input, secretary):
text_input.text = self.load_file(secretary=secretary)
def next_sequence(self, home):
self.screen_manager.current= "Sequence Type"
def showDeletePopup(self):
# Creates the layout where everything will be positioned
layout = RelativeLayout()
# Button to delete a profile when clicked
deleteBtn = Button(text='Delete',
size_hint=(None, None),
border=(20, 20, 20, 20),
size=(250, 60),
pos_hint={
'center_x': .5,
'center_y': .25
})
# Label to clarify a profile is going to be deleted.
deletePrompt = Label(
text='Are you sure you want to delete the profile?',
font_size=15,
pos_hint={
'center_x': .5,
'center_y': .85
})
# The currently selected profile to be deleted
deleteName = Label(text=cont.getProfileInfo(0),
font_size=18,
pos_hint={
'center_x': .5,
'center_y': .68
})
# Binds the delete button to call a helper method to delete a profile
deleteBtn.bind(on_release=self.deleteProfile)
# Adds each of the widgets to the relative layout
layout.add_widget(deleteBtn)
layout.add_widget(deletePrompt)
layout.add_widget(deleteName)
# Creates a new popup, stores it inside of the screen, then opens the popup
self.deletePop = Popup(title='Delete Profile',
content=layout,
size=(400, 200),
size_hint=(None, None))
self.deletePop.open()
def create_widgets(self, title, image_source, price):
item_card = MDCard(size=(300, 240),
border_radius=20,
radius=[
20,
],
elevation=10)
#item_card.md_bg_color = [1, 0.54, 0, .3]
card_layout = RelativeLayout()
image = AsyncImage(source=image_source,
size_hint=(.5, .5),
pos_hint={
"center_x": .3,
"center_y": .5
})
item_title = MDLabel(text=title,
halign="center",
theme_text_color="ContrastParentBackground",
font_style="H5",
pos_hint={
"center_x": .7,
"center_y": .7
})
item_price = MDLabel(text=price,
halign="center",
theme_text_color="Secondary",
pos_hint={
"center_x": .7,
"center_y": .6
})
order = MDRaisedButton(text="Order",
size_hint=(.5, None),
pos_hint={
"center_x": .68,
"center_y": .15
})
card_layout.add_widget(image)
card_layout.add_widget(item_title)
card_layout.add_widget(item_price)
card_layout.add_widget(order)
item_card.add_widget(card_layout)
self.list_menu.add_widget(item_card)
class MapLayout(RelativeLayout):
currentSize = 0
sizeOption = (1, 2, 4)
def __init__(self, **kwargs):
super(MapLayout, self).__init__(**kwargs)
self.mainContainer = RelativeLayout(size_hint=(None, None), size=mainWindowSize)
self.mainContainer.currentSize = self.currentSize
self.mainContainer.sizeOption = self.sizeOption
self.filterContainer = RelativeLayout(size_hint=(None, None), size=mainWindowSize)
self.mapBound = ScrollView(size_hint=(None, None), size=mainWindowSize)
self.MapArray = []
self.MapArray.append(Image(source="peta/content/Base Map 1.png", allow_stretch=True))
self.MapArray.append(Image(source="peta/content/Base Map 2.png", allow_stretch=True))
self.MapArray.append(Image(source="peta/content/Base Map 3.png", allow_stretch=True))
self.FilterArray = []
self.FilterArray.append(Image(source="peta/content/peta-batas-wilayah.png", allow_stretch=True, opacity=0.5))
self.FilterArray.append(Image(source="peta/content/peta-jalan.png", allow_stretch=True, opacity=0.5))
self.FilterArray.append(Image(source="peta/content/peta-air-bersih.png", allow_stretch=True, opacity=0.6))
self.FilterArray.append(Image(source="peta/content/peta-gorong-gorong.png", allow_stretch=True, opacity=0.5))
self.FilterArray.append(Image(source="peta/content/peta-sarana-publik.png", allow_stretch=True, opacity=0.9))
self.filterContainer.add_widget(self.FilterArray[0])
self.mainContainer.add_widget(self.MapArray[0])
self.mainContainer.add_widget(self.filterContainer)
self.mapBound.add_widget(self.mainContainer)
def addJalan(self):
# self.mainContainer.add_widget(self.FilterArray[1])
self.filterContainer.add_widget(self.FilterArray[1])
def removeJalan(self):
# self.mainContainer.remove_widget(self.FilterArray[1])
self.filterContainer.remove_widget(self.FilterArray[1])
def addAir(self):
# self.mainContainer.add_widget(self.FilterArray[2])
self.filterContainer.add_widget(self.FilterArray[2])
def removeAir(self):
# self.mainContainer.remove_widget(self.FilterArray[2])
self.filterContainer.remove_widget(self.FilterArray[2])
def addGorong(self):
# self.mainContainer.add_widget(self.FilterArray[3])
self.filterContainer.add_widget(self.FilterArray[3])
def removeGorong(self):
# self.mainContainer.remove_widget(self.FilterArray[3])
self.filterContainer.remove_widget(self.FilterArray[3])
def addSarana(self):
# self.mainContainer.add_widget(self.FilterArray[4])
self.filterContainer.add_widget(self.FilterArray[4])
def removeSarana(self):
# self.mainContainer.remove_widget(self.FilterArray[4])
self.filterContainer.remove_widget(self.FilterArray[4])
def resetMap(self):
self.filterContainer.clear_widgets()
self.mainContainer.clear_widgets()
self.filterContainer.add_widget(self.FilterArray[0])
self.mainContainer.add_widget(self.MapArray[0])
self.mainContainer.add_widget(self.filterContainer)
self.mainContainer.currentSize = 0
anim = Animation(width=mainWindowSize[0], height=mainWindowSize[1], duration=0.01, t="in_out_sine")
anim.start(self.mainContainer)
anim.start(self.filterContainer)
def zoomingIn(self):
if self.mainContainer.currentSize + 1 < len(self.mainContainer.sizeOption):
self.mainContainer.currentSize += 1
anim = Animation(
width=mainWindowSize[0] * self.mainContainer.sizeOption[self.mainContainer.currentSize],
height=mainWindowSize[1] * self.mainContainer.sizeOption[self.mainContainer.currentSize],
duration=0.4,
t="in_out_sine",
)
anim.start(self.mainContainer)
anim.start(self.filterContainer)
if self.mainContainer.currentSize == 1:
self.mainContainer.clear_widgets()
self.mainContainer.add_widget(self.MapArray[1])
self.mainContainer.add_widget(self.filterContainer)
elif self.mainContainer.currentSize == 2:
self.mainContainer.clear_widgets()
self.mainContainer.add_widget(self.MapArray[2])
self.mainContainer.add_widget(self.filterContainer)
# log
gv.logger.log_button("zoom in to :" + str(self.mainContainer.currentSize))
print self.mainContainer.currentSize
def zoomingOut(self):
if self.mainContainer.currentSize > 0:
self.mainContainer.currentSize -= 1
anim = Animation(
width=mainWindowSize[0] * self.mainContainer.sizeOption[self.mainContainer.currentSize],
height=mainWindowSize[1] * self.mainContainer.sizeOption[self.mainContainer.currentSize],
duration=0.4,
t="in_out_sine",
)
anim.start(self.mainContainer)
anim.start(self.filterContainer)
if self.mainContainer.currentSize == 1:
self.mainContainer.clear_widgets()
self.mainContainer.add_widget(self.MapArray[1])
self.mainContainer.add_widget(self.filterContainer)
elif self.mainContainer.currentSize == 2:
self.mainContainer.clear_widgets()
self.mainContainer.add_widget(self.MapArray[2])
self.mainContainer.add_widget(self.filterContainer)
# log
gv.logger.log_button("zoom out to :" + str(self.mainContainer.currentSize))
print self.mainContainer.currentSize
class KYRScreen(Screen):
spriteList = ListProperty()
locationEvent = DictProperty() # all location-based events for the room, including room changes
player = ObjectProperty()
isCurrent = BooleanProperty(False)
playerLocation = ListProperty((200,200))
bg = StringProperty()
music = ObjectProperty()
startLocations = DictProperty()
direction = StringProperty('top')
def __init__(self, **kwargs):
super(KYRScreen, self).__init__(**kwargs)
self.field = RelativeLayout()
#sprites = self.loadSprites()
#self.buildSprites(sprites)
def on_isCurrent(self, instance, value):
if value:
self.turnOn()
else:
self.turnOff()
def turnOn(self):
print 'turning on {}'.format(self)
self.getStartLocation()
self.buildPlayer(self.playerLocation)
self.loadBackground()
self.loadWidgets()
self.toggleMusic('on')
def turnOff(self):
print 'turning off {}'.format(self)
self.parent.playerLocation = self.playerLocation
self.unloadWidgets()
self.toggleMusic('off')
def getStartLocation(self):
self.playerLocation = self.startLocations[self.direction]
def loadBackground(self):
print 'loading bg', self.bg
tex = CImage.load(self.bg, keep_data=True).texture
self.buildBackground(tex)
def buildBackground(self, tex):
with self.field.canvas.before:
Rectangle(texture = tex, pos=(0,0), size=(1024,512))
def loadWidgets(self):
self.add_widget(self.field)
def unloadWidgets(self):
self.field.remove_widget(self.player)
self.remove_widget(self.field)
def toggleMusic(self, value):
if value == 'on':
if self.music:
print("Sound found at %s" % self.music.source)
print("Sound is %.3f seconds" % self.music.length)
self.music.loop = True
self.music.play()
elif value == 'off':
if self.music:
self.music.stop()
def changePlayerImage(self, direction):
if direction == 'up':
self.player.source = 'assets/art/Clyde_up.zip'
elif direction == 'down':
self.player.source = 'assets/art/Clyde_down.zip'
elif direction == 'left':
self.player.source = 'assets/art/Clyde_left.zip'
elif direction == 'right':
self.player.source = 'assets/art/Clyde_right.zip'
def on_transition_state(self, instance, value):
pass
def buildPlayer(self, playerLocation):
self.player = AGSprite(source = 'assets/art/brandon-right.zip', size=(96,192))
#self.player.anim_delay = (-1)
self.player.pos = playerLocation
self.field.add_widget(self.player)
def loadSprites(self):
# look in sprite list for sprite in specific room, return sprite list for room
directory = {'room number': 'sprite list'}
sprites = directory['room number']
return sprites
def buildSprites(self, sprites):
for sprite in sprites:
self.field.add_widget(sprite)
self.spriteList.append(sprite)
def checkCollision(self):
pass
def didCollision(self):
pass
def add_widget(self, widget, index=0):
slide = RelativeLayout(size=self.size, x=self.x, y=self.y)
slide.add_widget(widget)
super(BrowsingCard, self).add_widget(slide, index)
self.slide = widget
self.slide.bind(height=self._update_height)
class MainWidget(BaseWidget):
def __init__(self):
super(MainWidget, self).__init__()
songpath1 = 'together-we-are.wav'
songpath2 = 'lionhearted.wav'
self.selection = Selection()
song1 = Song(songpath1, song1_structure, self.selection)
song2 = Song(songpath2, song2_structure, self.selection)
self.beatgen = BeatwiseGenerator()
self.beatgen.add_song(song1)
self.beatgen.add_song(song2)
audio = Audio()
audio.add_generator(self.beatgen)
self.selection.beatgen = self.beatgen
self.clock = ClassClock()
self.conductor = Conductor(self.clock)
self.scheduler = Scheduler(self.conductor)
self.conductor.set_bpm(128)
#info = Label(text = "text", pos=(0, 500), text_size=(100,100), valign='top')
#self.add_widget(info)
# root = ScrollView(size_hint=(None, None), size=(800, 600),
# pos_hint={'center_x': .5, 'center_y': .5})
# self.add_widget(root)
#self.rel = AnchorLayout(size_hint=(None, None), width=9000, pos_hint={'center_x': .5, 'center_y': .5},
# anchor_x='left', anchor_y='top')
self.rel = RelativeLayout(size_hint=(None, None), width=9000, pos_hint={'center_x': .5, 'center_y': .5})
self.add_widget(self.rel)
# anchor = AnchorLayout(anchor_x='left', anchor_y='top')
# self.rel.add_widget(anchor)
layout = GridLayout(cols=1, padding=50, spacing=50, size_hint=(None, None), width=9000, row_force_default=True,
row_default_height=100)
self.rel.add_widget(layout)
for song in self.beatgen.get_songs():
container = RelativeLayout()
layout.add_widget(container)
container.add_widget(song)
self.nowline = Nowline(self.scheduler)
self.rel.add_widget(self.nowline)
self.beatgen.nowline = self.nowline
def on_update(self):
self.scheduler.on_update()
def on_touch_down(self, touch):
return super(MainWidget, self).on_touch_down(touch)
def on_key_down(self, keycode, modifiers):
(idx, char) = keycode
if char == 'backspace':
self.selection.set_state('NORMAL')
elif char == 'c':
self.selection.set_state('CUT')
elif char == 'l':
self.selection.set_state('LINK')
elif char == 'g':
self.selection.set_state('GO')
# elif char == 'q':
# pass
elif char == 'w':
self.beatgen.next_beat -= 32
elif char == 'e':
self.beatgen.next_beat += 32
elif char == 'spacebar':
#self.clock.toggle()
# print self.scheduler.cond.get_tick()
self.beatgen.toggle()
elif char == 'right':
self.rel.x -= 100
elif char == 'left':
self.rel.x += 100
elif char == 'up':
self.rel.y -= 100
elif char == 'down':
self.rel.y += 100
class BiscuitsGame:
def __init__(self, app):
# TODO pretty sure this causes circular references that prevent
# garbage collection of the whole scene
self.app = app
self.world = World()
self.widget = RelativeLayout()
self.objects_layer = RelativeLayout()
object_configs = dict(map.objects)
object_configs['player'] = Config(type='Player',
body=Config(x=0, y=0, w=1, h=1))
scene = WorldScene(object_configs, self.world, app)
self.scene = scene
# TODO figure out a nice way to get rid of this
self.tilewidth = map.tilewidth
self.tileheight = map.tileheight
self.region = None
self.region_cache = {}
player = scene.objects.load('player')
self.player = player
self.world.add(player)
self.hud = HUDWidget(size_hint=(1, .05), pos_hint={'top': 1})
# TODO move debug to app
debug = DebugWidget(player, size_hint=(1, .05))
self.widget.add_widget(self.objects_layer)
self.widget.add_widget(player.widget._kivy_widget)
self.widget.add_widget(self.hud)
self.widget.add_widget(debug)
def load(self, loadpoint):
# Unload the current region
# TODO would be stellar if weak references could account
# for all of this
if self.region:
self.objects_layer.remove_widget(self.region.widget)
for obj in self.region.objects:
# TODO use weakref
self.world.remove(obj)
region_config = loadpoint.region
try:
self.region = self.region_cache[region_config.ID]
except KeyError:
self.region = Region(self.scene.objects, region_config)
self.region_cache[region_config.ID] = self.region
# TODO can use weakref to pass reference to add_widget()?
# would be awesome for maintaining ownership!
self.objects_layer.add_widget(self.region.widget)
self.player.set_position(loadpoint.x, loadpoint.y, loadpoint.direction)
for obj in self.region.objects:
# TODO use weakref
obj.signals.destroy.connect(self.world.remove)
self.world.add(obj)
return self
def update(self, dt):
if self.region:
self.region.update(dt)
self.player.signals.update.send(dt)
self.hud.coins = self.player.coins.balance
self.hud.keys = self.player.keys.balance
self.hud.health = self.player.life.amount
self.track_player()
def unload(self):
pass
def track_player(self):
x = math.floor((self.player.body.bb.x + 0.5) * self.tilewidth)
y = math.floor((self.player.body.bb.y + 0.5) * self.tileheight)
self.objects_layer.x = self.widget.center_x - x
self.objects_layer.y = self.widget.center_y - y
"""main.py: Main module."""
from kivy.base import runTouchApp
from kivy.uix.relativelayout import RelativeLayout
from dpad import Dpad
from buttonpad import ButtonPad
from gameobject import GameObject
__author__ = "Victor RENÉ"
__copyright__ = "Copyright 2014, Kivy widget library"
__license__ = "MIT"
__version__ = "1.0"
__maintainer__ = "Victor RENÉ"
__email__ = "*****@*****.**"
__status__ = "Production"
if __name__ == '__main__':
layout = RelativeLayout()
d = Dpad(size_hint=(.15, .2), pos_hint={'center_x': .1, 'center_y': .5})
layout.add_widget(d)
b = ButtonPad(size_hint=(.15, .2), pos_hint={'center_x': .9, 'center_y': .5})
layout.add_widget(b)
go = GameObject(size_hint=(.075, .1), pos_hint={'center_x': .5, 'center_y': .5})
d.listeners.append(go)
b.listeners.append(go)
layout.add_widget(go)
runTouchApp(layout)
from kivy.animation import Animation
from kivy.base import runTouchApp
from kivy.uix.relativelayout import RelativeLayout
from adventuremap import AdventureMap
from room import Room
if __name__ == '__main__':
layout = RelativeLayout()
m = AdventureMap(size_hint=(1, 1), pos_hint={'center_x': .5, 'center_y': .5})
m.rooms[(0, 0)] = Room()
m.rooms[(1, 1)] = Room(state='explored', walls=[None, 'full', None, 'full'])
m.rooms[(1, 0)] = Room()
m.rooms[(0, 1)] = Room(state='revealed', walls=['full', 'full', None, 'full'])
m.rooms[(0, 2)] = Room()
m.rooms[(2, 0)] = Room()
m.rooms[(2, 2)] = Room()
m.rooms[(1, 2)] = Room()
m.rooms[(2, 1)] = Room()
layout.add_widget(m)
m.draw_rooms()
# anim = Animation(health=0, duration=2.) + Animation(health=12, duration=2.)
# anim.repeat = True
# anim.start(m)
runTouchApp(layout)
from kivy.animation import Animation
from kivy.base import runTouchApp
from kivy.uix.relativelayout import RelativeLayout
from resourcebar import ResourceBar
if __name__ == '__main__':
layout = RelativeLayout()
rb = ResourceBar(size_hint=(.6, .2),
pos_hint={'center_x': .5, 'center_y': .5})
layout.add_widget(rb)
anim1 = Animation(fill_pct=1.) + Animation(fill_pct=0.)
anim1.repeat = True
anim1.start(rb)
anim2 = Animation(slant_pct=-1.) + Animation(slant_pct=1.)
anim2.repeat = True
anim2.start(rb)
runTouchApp(layout)
def mList(self, argv=None):
if argv is None:
argv = []
genreList = ["Action", "Adult", "Adventure", "Comedy", "Doujinshi", "Drama", "Ecchi", "Fantasy",
"Gender Bender",
"Harem", "Historical", "Horror", "Josei", "Martial Arts", "Mature", "Mecha", "Mystery", "One Shot",
"Psychological", "Romance", "School Life", "Sci-fi", "Seinen", "Shoujo", "Shounen",
"Slice of Life",
"Smut", "Sports", "Supernatural", "Tragedy", "Webtoons", "Yaoi", "Yuri"]
try:
opts, args = getopt(argv[0:], "g:s:b:a:p:",
["genre=", "status=", "before=", "after=", "popularity="])
except:
raise Exception('Invalid argument usage\n')
genres = []
genreFlag = 0
statusFlag = 0
beforeFlag = 0
afterFlag = 0
popFlag = 0
popSetting = ''
for opt, arg in opts:
if opt in ("-g", "--genre"):
if arg not in genreList:
raise Exception(
arg + " is not a valid genre. " + "Genres are: " + '["Action","Adult","Adventure","Comedy","Doujinshi","Drama","Ecchi","Fantasy","Gender Bender","Harem","Historical","Horror","Josei","Martial Arts","Mature","Mecha","Mystery","One Shot","Psychological","Romance","School Life","Sci-fi","Seinen","Shoujo","Shounen","Slice of Life","Smut","Sports","Supernatural","Tragedy","Webtoons","Yaoi","Yuri"]' + "\n")
genres.append(unicode(arg))
genreFlag = 1
elif opt in ("-s", "--status"):
statusFlag = 1
status = int(arg)
if status != 1 and status != 2:
raise Exception('invalid status: should be 1 for "ongoing" or 2 for "completed"\n')
elif opt in ("-b", "--before"):
beforeFlag = 1
beforeDate = date.fromtimestamp(float(arg))
elif opt in ("-a", "--after"):
afterFlag = 1
afterDate = date.fromtimestamp(float(arg))
elif opt in ("-p", "--popularity"):
popFlag = 1
if arg not in ("Low", "Medium", "High"):
raise Exception("Must select 'low', 'medium', or 'high' for popularity option.\n")
else:
popSetting = arg
else:
raise Exception("Misc arg error\n")
if not self.manList:
try:
conn = HTTPSConnection("www.mangaeden.com")
conn.request("GET", "/api/list/0/")
r1 = conn.getresponse()
except:
exceptionPopup = Popup(title='Connectivity Error:', size_hint=[0.75, 0.75],
content=Label(text='Cannot connect to the internet\nor MangaEden may be down.',
font_size=30))
self.spinEnd()
exceptionPopup.open()
return
self.manList = loads(r1.read())
yList = []
if popFlag == 1:
popArray = []
for m in self.manList['manga']:
popArray.append(int(m['h']))
if platform in ('win', 'linux', 'macosx'):
firstThirdPercentile = scoreatpercentile(popArray, 33)
secondThirdPercentile = scoreatpercentile(popArray, 67)
elif platform == 'android':
firstThirdPercentile = 4055.64
secondThirdPercentile = 35938.48
for entries in self.manList['manga']:
addit = 1
if genreFlag:
for g in genres:
if g not in entries['c']:
addit = 0
if statusFlag:
if status != entries['s']:
addit = 0
if beforeFlag:
if not entries.has_key('ld'):
addit = 0
else:
if date.fromtimestamp(entries['ld']) > beforeDate:
addit = 0
if afterFlag:
if not entries.has_key('ld'):
addit = 0
else:
if date.fromtimestamp(entries['ld']) < afterDate:
addit = 0
if popFlag:
if popSetting == "Low":
if entries['h'] > firstThirdPercentile:
addit = 0
elif popSetting == "Medium":
if entries['h'] <= firstThirdPercentile or entries['h'] >= secondThirdPercentile:
addit = 0
elif popSetting == "High":
if entries['h'] < secondThirdPercentile:
addit = 0
if addit == 1:
yList.append([entries['a'], entries['t']])
if yList:
spinResult = choice(yList)
self.targetURL = "http://www.mangaeden.com/en/en-manga/" + quote_plus(spinResult[0])
self.spinEnd()
resultLabel = Label(text=spinResult[1], pos_hint={'center_x': 0.5, 'center_y': 0.6}, size_hint=[1, 0.75],
font_size=30)
goButton = Button(text='View on MangaEden', valign='middle', halign='center', font_size=20,
size_hint=[0.4, 0.125], pos_hint={'center_x': 0.25, 'center_y': 0.1})
copyButton = Button(text='Copy to clipboard', valign='middle', halign='center', font_size=20,
size_hint=[0.4, 0.125], pos_hint={'center_x': 0.75, 'center_y': 0.1})
def callBrowser(instance):
self.openInBrowser()
return instance
def callCopy(instance):
if platform in ('win', 'linux', 'macosx'):
copy(spinResult[1])
elif platform == 'android':
Context = autoclass('android.content.Context')
Looper = autoclass('android.os.Looper')
PythonActivity = autoclass('org.renpy.android.PythonActivity')
activity = PythonActivity.mActivity
ClipData = autoclass('android.content.ClipData')
if not self.loopPrepared:
Looper.prepare()
self.loopPrepared = True
clipboard = activity.getSystemService(Context.CLIPBOARD_SERVICE)
clip = ClipData.newPlainText('myclip', spinResult[1])
clipboard.setPrimaryClip(clip)
return instance
goButton.bind(on_release=callBrowser)
copyButton.bind(on_release=callCopy)
popLayout = RelativeLayout()
popLayout.add_widget(resultLabel)
popLayout.add_widget(goButton)
popLayout.add_widget(copyButton)
ResultPopup = Popup(title='Result:', size_hint=[0.75, 0.75], content=popLayout)
ResultPopup.open()
else:
self.spinEnd("No Results. Try again?")
class VisualizationApp(App):
def __init__(self):
self.scale = 1
super().__init__()
self.visualization_widgets = {}
self.edges = {}
Clock.schedule_interval(self.update, 1/30)
def set_repo(self):
try:
self.repo = pygit2.Repository('/tmp/testrepo')
except KeyError:
pass
def build(self):
self.layout = RelativeLayout()
self.edge_widget = Widget()
self.layout.add_widget(self.edge_widget)
Clock.schedule_interval(lambda t: self.rescan(), 2)
kbd = Window.request_keyboard(lambda: None, self.edge_widget, 'text')
kbd.bind(on_key_down=self._on_keyboard_down)
self.option_widgets = []
# Finding objects to show
self.add_option('a', 'all', 'All', (1, 1, 1))
self.add_option('i', 'index', 'Idx', (1, 1/2, 1))
self.add_option('f', 'list-refs', 'reF', (1/2, 1, 1))
self.add_option('l', 'reflog', 'Log', (1, 1/2, 1/2), default=False)
# Filer shown objects
self.add_option('b', 'blobs', 'Blb', (1/2, 1/2, 1/2))
self.add_option('t', 'trees', 'Tre', (1/2, 1, 1/2))
self.add_option('c', 'commits', 'Com', (1/2, 1/2, 1))
self.add_option('r', 'refs', 'Ref', (1/2, 1, 1), default=False)
return self.layout
def add_option(self, shortcut, ident, name, color, default=True):
self.options[ident] = default
widget = OptionWidget(
self, shortcut, ident, name, color,
pos=(0, 20 * len(self.option_widgets)),
)
self.option_widgets.append(widget)
self.layout.add_widget(widget)
def add_object_widget(self, blob):
widget = ObjectWidget(
blob,
x=self.layout.width/2, y=self.layout.height/2,
)
widget.scale = self.scale
self.layout.add_widget(widget, 0)
self.visualization_widgets[blob.hex] = widget
return widget
def add_ref_widget(self, ref):
widget = RefWidget(
ref,
x=self.layout.width/2, y=self.layout.height/2,
)
self.layout.add_widget(widget, 0)
self.visualization_widgets[ref.name] = widget
return widget
def add_edge(self, cls, a, b):
try:
return self.edges[a, b]
except KeyError:
edge = cls(
self.visualization_widgets[a], self.visualization_widgets[b],
self.edge_widget.canvas,
)
self.edges[a, b] = edge
return edge
def update(self, t):
for blob in self.visualization_widgets.values():
for other in self.visualization_widgets.values():
fx, fy = self.interaction(blob, other)
# Attraction to center
cx = ((self.layout.width/2 - blob.x) / self.layout.width * 10)
cy = ((self.layout.height/2 - blob.y) / self.layout.height * 10)
if blob.reachable:
fx += cx ** 3
fy += cy ** 3
else:
fx -= cx * 30
fy -= cy * 30
if not blob._touches:
blob.x += fx * t * self.scale ** 2
blob.y += fy * t * self.scale ** 2
if blob.reachable:
threshold = blob.radius
else:
threshold = -blob.radius - 5
if blob.x < threshold:
blob.x = threshold
if blob.y < threshold:
blob.y = threshold
if blob.x > self.layout.width - threshold:
blob.x = self.layout.width - threshold
if blob.y > self.layout.height - threshold:
blob.y = self.layout.height - threshold
def interaction(self, obj, obj2):
fx = fy = 0
if obj is obj2:
return 0, 0
dx = (obj.x - obj2.x) / self.scale
dy = (obj.y - obj2.y) / self.scale
distance = math.sqrt(dx ** 2 + dy ** 2)
if not distance:
rx = random.random() - 0.5
ry = random.random() - 0.5
obj.x += rx * obj.radius * 5
obj.y += ry * obj.radius * 5
return 0, 0
ndx = dx / distance
ndy = dy / distance
if distance < 20:
fx += ndx * 1e3
fy += ndy * 1e3
else:
# Repulsion
repulsion = 1e7 / distance ** 3
fx += ndx * repulsion
fy += ndy * repulsion
edge = self.edges.get((obj.name, obj2.name))
if edge:
dfx, dfy = edge.force(distance, ndx, ndy, dx, dy)
fx += dfx
fy += dfy
edge = self.edges.get((obj2.name, obj.name))
if edge:
dfx, dfy = edge.force(distance, -ndx, -ndy, -dx, -dy)
fx -= dfx
fy -= dfy
#if obj2.reachable:
# obj.reachable = max(obj.reachable, obj2.reachable) * 0.9
return fx, fy
def rescan(self):
try:
self.repo
except AttributeError:
self.set_repo()
try:
self.repo
except AttributeError:
print('no repo')
return
print('rescan')
#self.edge_widget.canvas.before.clear()
unvisited_widgets = set(self.visualization_widgets)
unvisited_edges = set(self.edges)
visited = set()
to_position = set()
def _reach(widget):
if not widget.reachable:
to_position.add(widget)
return widget
def _add_edge(cls, a, b):
edge = self.add_edge(cls, a, b)
unvisited_edges.discard((a, b))
return edge
def _scan(obj):
if isinstance(obj, pygit2.Commit) and not self.options['commits']:
return
if isinstance(obj, pygit2.Tree) and not self.options['trees']:
return
if isinstance(obj, pygit2.Blob) and not self.options['blobs']:
return
if obj.hex in visited:
return _reach(self.visualization_widgets[obj.hex])
else:
visited.add(obj.hex)
if obj.hex in unvisited_widgets:
unvisited_widgets.discard(obj.hex)
else:
self.add_object_widget(obj)
if isinstance(obj, pygit2.Tree):
for entry in obj:
child = self.repo[entry.hex]
if _scan(child):
_add_edge(TreeContentEdge, obj.hex, child.hex)
elif isinstance(obj, pygit2.Commit):
if _scan(obj.tree):
_add_edge(CommitTreeEdge, obj.hex, obj.tree.hex)
for parent in obj.parents:
if _scan(parent):
_add_edge(CommitParentEdge, obj.hex, parent.hex)
return _reach(self.visualization_widgets[obj.hex])
def _scan_ref(ref_name):
try:
ref = self.repo.lookup_reference(ref_name)
except (KeyError, ValueError):
return
if self.options['refs']:
if ref.name in visited:
return _reach(self.visualization_widgets[ref.name])
else:
visited.add(ref.name)
if ref.name in unvisited_widgets:
unvisited_widgets.discard(ref.name)
else:
self.add_ref_widget(ref)
target = ref.target
if isinstance(target, str):
target_widget = _scan_ref(target)
else:
target_widget = _scan(self.repo[target])
if self.options['refs']:
if target_widget:
_add_edge(RefEdge, ref.name, target_widget.name)
if self.options['reflog']:
for item in ref.log():
if item.oid_old != pygit2.Oid(hex='0'*40):
target_widget = _scan(self.repo[item.oid_old])
if target_widget:
_add_edge(RefLogEdge, ref.name, target_widget.name)
return _reach(self.visualization_widgets[ref.name])
_scan_ref('HEAD')
if self.options['index']:
for entry in self.repo.index:
_scan(self.repo[entry.id])
if self.options['all']:
for oid in self.repo:
_scan(self.repo[oid])
if self.options['list-refs']:
for ref in self.repo.listall_references():
_scan_ref(ref)
for old_id in unvisited_widgets:
self.visualization_widgets[old_id].fade_out()
del self.visualization_widgets[old_id]
#self.visualization_widgets[old_id].reachable = False
for old_name in unvisited_edges:
self.edges[old_name].remove()
self.edges.pop(old_name)
for widget in to_position:
widget.reachable = True
positions = []
for other in self.visualization_widgets:
edge = self.edges.get((widget.name, other))
if edge:
fx, fy = edge.force(0, 0, 0, 0, 0)
positions.append((edge.b.x + fx*5, edge.b.y + fy*5))
edge = self.edges.get((other, widget.name))
if edge:
fx, fy = edge.force(0, 0, 0, 0, 0)
positions.append((edge.a.x - fx*5, edge.a.y - fy*5))
if not positions:
widget.x = self.layout.width / 2
widget.y = self.layout.height / 2
else:
widget.x = sum(p[0] for p in positions) / len(positions)
widget.y = sum(p[1] for p in positions) / len(positions)
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
num, letter = keycode
if letter in ('=', '+'):
self.update_scale(1.1)
if letter in ('-', '_'):
self.update_scale(0.9)
for option in self.option_widgets:
if option.shortcut == letter:
option.toggle()
def update_scale(self, factor):
self.scale *= factor
for widget in self.visualization_widgets.values():
widget.scale = self.scale
from kivy.uix.relativelayout import RelativeLayout
from dotmatrix import DotMatrix
__author__ = "Victor RENÉ"
__copyright__ = "Copyright 2014, Kivy widget library"
__license__ = "MIT"
__version__ = "1.0"
__maintainer__ = "Victor RENÉ"
__email__ = "*****@*****.**"
__status__ = "Production"
def rotate_text(wgt, dt):
wgt.text = wgt.text[1:] + wgt.text[:1]
if __name__ == '__main__':
layout = RelativeLayout()
dm_tiny = DotMatrix(size_hint=(.8, .2), pos_hint={'center_x': .5, 'center_y': .7},
font='font_3x5', dot_style='square', dot_on=(.3,.7,.9,1), dot_off=(0,.1,.3,1))
dm_tiny.text = ' ABCDEFGHIJ +-. 0123456789 =*/ '
layout.add_widget(dm_tiny)
dm_big = DotMatrix(size_hint=(.8, .2), pos_hint={'center_x': .5, 'center_y': .3},
font='font_5x7')
dm_big.text = ' ABCDEFGHIJ +-. 0123456789 =*/ '
layout.add_widget(dm_big)
Clock.schedule_interval(partial(rotate_text, dm_big), 1)
runTouchApp(layout)
class Main(App):
height = 720
width = (height/16) * 9
Window.size = (width,height)
def build(self):
self.itu_lat = 55.6593807
self.itu_lon = 12.5910774
self.obs_dic = None
self.old_time = 0.0
self.weatherbox = AnchorLayout(anchor_x = 'center', anchor_y = 'bottom')
self.Layout = RelativeLayout()
self.mapview = MapView(zoom=11, lat=self.itu_lat, lon=self.itu_lon)
mapview = self.mapview
self.Layout.add_widget(mapview)
# add map layer
self.jsonmap = GeoJsonMapLayer(source='5_mile_airport.json')
self.mapview.add_layer(self.jsonmap)
self.overlay = AnchorLayout(anchor_x='right', anchor_y='top')
lowerLeft = AnchorLayout(anchor_x='left', anchor_y='bottom')
self.lowerLeftStack = StackLayout(orientation='lr-bt',size_hint=(0.15,0.15))
lowerLeft.add_widget(self.lowerLeftStack)
btnre = Button(background_normal='refocus_normal.png', background_down='refocus_down.png', size_hint = (2,1))
btnre.bind(on_press=self.resetloc)
btnnf = ToggleButton(background_normal='nofly_normal.png', background_down='nofly_down.png',size_hint = (2,1))
btnnf.bind(on_press=self.nofly)
self.lowerLeftStack.add_widget(btnre)
self.lowerLeftStack.add_widget(btnnf)
btn = ToggleButton(background_normal='Settings B.png', background_down="Settings G.png")
btn.bind(on_press= self.show_dropdown)
self.settings = StackLayout(size_hint=(0.2,0.2))
self.settings.add_widget(btn)
self.overlay.add_widget(self.settings)
self.Layout.add_widget(lowerLeft)
self.Layout.add_widget(self.overlay)
marker = MapMarker(anchor_x = 0.5, anchor_y = 0.5, lat=self.itu_lat, lon=self.itu_lon)
self.mapview.add_marker(marker)
return self.Layout
def resetloc(self,instance):
self.mapview.center_on(self.itu_lat,self.itu_lon)
def nofly(self,instance):
if instance.state == 'down':
self.mapview.remove_layer(self.jsonmap)
else:
self.mapview.add_layer(self.jsonmap)
def show_dropdown(self,instance):
if instance.state == 'down':
size = (1,0.5)
btn1 = ToggleButton(text='Weather', size_hint = size)
btn2 = Button(text='Level',size_hint = size)
btn3 = Button(text='Nearby\nusers', size_hint = size)
btn1.bind(on_press = self.show_weather_data)
self.settings.add_widget(btn1)
self.settings.add_widget(btn2)
self.settings.add_widget(btn3)
else:
for child in self.settings.children[:]:
if child.text != "":
self.settings.remove_widget(child)
def show_weather_data(self,instance):
weatherbox = self.weatherbox
if instance.state == 'down':
layout = BoxLayout(orientation='vertical', size_hint = (0.2,0.1) )
clat = self.mapview.lat
clon = self.mapview.lon
ctime = time.time()
if(self.obs_dic == None or ctime > (self.old_time + 0.5)):
self.old_time = ctime
self.obs_dic = api.loc_weather(clat,clon)
weList = self.obs_dic['weather']
we = weList[0]
wi = self.obs_dic['wind']
l1 = Label(text = 'Current weather: ' + we['main'], color = (0.,0.,0.,1))
main = self.obs_dic['main']
k = main['temp']
#Conversion from imperial to metric
temp = k-273.15
l2 = Label(text = 'temp: ' + str(temp) + ' ' + u'\u00B0' + 'C', color = (0.,0.,0.,1))
hu = main['humidity']
l3 = Label(text = 'humidity: ' + str(hu) + '%', color = (0.,0.,0.,1))
pre = main['pressure']
l4 = Label(text = 'pressure' + str(pre) + ' hPa', color = (0.,0.,0.,1))
wispeed = wi['speed']
widir = wi['deg']
l5 = Label(text = 'wind speed: ' + str(wispeed) + 'm/s', color = (0.,0.,0.,1))
l6 = Label(text = 'wind direction '+ str(widir) + u'\u00B0', color = (0.,0.,0.,1))
Tdp = temp - ((100-hu)/5)
l7 = Label(text = 'dew point: ' + str(Tdp) + ' ' + u'\u00B0' + 'C', color = (0.,0.,0.,1))
layout.add_widget(l1)
layout.add_widget(l2)
layout.add_widget(l3)
layout.add_widget(l4)
layout.add_widget(l5)
layout.add_widget(l6)
layout.add_widget(l7)
weatherbox.add_widget(layout)
weatherbox.add_widget
self.Layout.add_widget(weatherbox)
else:
for c in self.weatherbox.children[:]:
for child in c.children[:]:
c.remove_widget(child)
self.weatherbox.remove_widget(c)
self.overlay.remove_widget(weatherbox)
class Data(Screen):
def __init__(self, **kwargs):
super(Data, self).__init__(**kwargs)
## TOGGLE BUTTON FUNCTION ##
self.mataPencarianButton = Button(
background_normal="data/lib/data-mata-pencaharian.png",
background_down="data/lib/data-mata-pencaharian-hit.png",
state="normal",
size_hint=(None, None),
size=(159, 165),
)
self.pemelukAgamaButton = Button(
background_normal="data/lib/data-pemeluk-agama.png",
background_down="data/lib/data-pemeluk-agama-hit.png",
state="normal",
size_hint=(None, None),
size=(159, 165),
)
self.dataPendidikanButton = Button(
background_normal="data/lib/data-pendidikan.png",
background_down="data/lib/data-pendidikan-hit.png",
state="normal",
size_hint=(None, None),
size=(159, 165),
)
self.dataUmurButton = Button(
background_normal="data/lib/data-struktur-umur.png",
background_down="data/lib/data-struktur-umur-hit.png",
state="normal",
size_hint=(None, None),
size=(159, 165),
)
self.infografik = []
self.infografik.append(
Image(
source="data/content/data-mata-pencaharian-info.png",
allow_stretch=True,
size_hint=(0.9, 0.9),
pos_hint={"x": 0, "y": 0},
)
) # 0
self.infografik.append(
Image(
source="data/content/data-pemeluk-agama-info.png",
allow_stretch=True,
size_hint=(0.9, 0.9),
pos_hint={"x": 0, "y": 0},
)
) # 1
self.infografik.append(
Image(
source="data/content/data-tingkat-pendidikan-info.png",
allow_stretch=True,
size_hint=(0.9, 0.9),
pos_hint={"x": 0, "y": 0},
)
) # 2
self.infografik.append(
Image(
source="data/content/data-struktur-umur-info.png",
allow_stretch=True,
size_hint=(0.9, 0.9),
pos_hint={"x": 0, "y": 0},
)
) # 3
self.infografik.append(Image(source="data/content/BG01c.png", allow_stretch=True)) # 4
self.mataPencarianButton.bind(on_release=self.mataPencarian)
self.pemelukAgamaButton.bind(on_release=self.pemelukAgama)
self.dataPendidikanButton.bind(on_release=self.dataPendidikan)
self.dataUmurButton.bind(on_release=self.dataStrukturUmur)
## Button Container ##
self.bLayout = BoxLayout(
size_hint=(None, None),
orientation="horizontal",
width=720,
height=650,
# pos_hint= {'y':0.05, 'x': 0.5},
pos=(610, 40),
)
self.bLayout.add_widget(self.mataPencarianButton)
self.bLayout.add_widget(self.pemelukAgamaButton)
self.bLayout.add_widget(self.dataPendidikanButton)
self.bLayout.add_widget(self.dataUmurButton)
self.dataLayout = RelativeLayout()
self.dataLayout.add_widget(self.infografik[4])
self.add_widget(self.dataLayout)
self.add_widget(self.bLayout)
self.zoomIdx = 0
## Filter Button function method ##
def mataPencarian(self, button=None, **args):
self.dataLayout.clear_widgets()
self.dataLayout.add_widget(self.infografik[0])
# log
gv.logger.log_button("view :" + "Mata Pencaharian")
def pemelukAgama(self, button=None, **args):
self.dataLayout.clear_widgets()
self.dataLayout.add_widget(self.infografik[1])
# log
gv.logger.log_button("view :" + "Pemeluk Agama")
def dataPendidikan(self, button=None, **args):
self.dataLayout.clear_widgets()
self.dataLayout.add_widget(self.infografik[2])
# log
gv.logger.log_button("view :" + "Pendidikan")
def dataStrukturUmur(self, button=None, **args):
self.dataLayout.clear_widgets()
self.dataLayout.add_widget(self.infografik[3])
# log
gv.logger.log_button("view :" + "Struktur Umur")
def reset(self):
self.dataLayout.clear_widgets()
self.dataLayout.add_widget(self.infografik[4])
def add_widget(self, *args, **kwargs):
slide = RelativeLayout(size=self.size, x=self.x - self.width, y=self.y)
slide.add_widget(*args, **kwargs)
super(Carousel, self).add_widget(slide)
self.slides.append(slide)
