class TicTacToeApp(App):
game = ObjectProperty(None)
sm = ObjectProperty(None)
winning_screen = ObjectProperty(None)
def build(self):
menu = MenuScreen(name="Menu")
self.winning_screen = FinalScreen(name="Win")
self.sm = ScreenManager()
self.game = GameScreen(False, name="Tic Tac Toe")
self.sm.add_widget(menu)
self.sm.add_widget(self.game)
self.sm.add_widget(self.winning_screen)
#Clock.schedule_interval(game.botTurn, 0.5)
return self.sm
#return Symbol()
def new_game(self, human):
if self.sm.has_screen("Tic Tac Toe"):
self.sm.remove_widget(self.game)
self.game = GameScreen(human, name="Tic Tac Toe")
self.sm.add_widget(self.game)
self.sm.current = "Tic Tac Toe"
def display_winner(self, winner):
self.winning_screen.update_winner(winner)
self.sm.current = "Win"
class MyScreen(Singleton):
def __init__(self):
self.screenMgr = ScreenManager(size=WH)
self.name = "Root Screen"
self.transition = WipeTransition()
# or self.transition = SlideTransition(direction="down")
self.emptyScreen = Screen(name = "empty screen")
#self.emptyScreen.add_widget(Label(text="empty.screen"))
self.add_screen(self.emptyScreen)
self.current_screen(self.emptyScreen)
def prev_screen(self):
prev_screen = self.screenMgr.previous()
if prev_screen:
self.screenMgr.current = prev_screen
def add_screen(self, screen):
if screen.name not in self.screenMgr.screen_names:
self.screenMgr.add_widget(screen)
def current_screen(self, screen):
if self.screenMgr.current != screen.name:
if not self.screenMgr.has_screen(screen.name):
self.add_screen(screen)
self.screenMgr.current = screen.name
def remove_screen(self, screen):
if screen.name in self.screenMgr.screen_names:
self.screenMgr.remove_widget(screen)
self.prev_screen()
def get_current_screen(self):
return self.screenMgr.current_screen
class MyScreen(Singleton):
def __init__(self):
self.screenMgr = ScreenManager(size=WH)
self.name = "Root Screen"
self.transition = WipeTransition()
# or self.transition = SlideTransition(direction="down")
self.emptyScreen = Screen(name="empty screen")
#self.emptyScreen.add_widget(Label(text="empty.screen"))
self.add_screen(self.emptyScreen)
self.current_screen(self.emptyScreen)
def prev_screen(self):
prev_screen = self.screenMgr.previous()
if prev_screen:
self.screenMgr.current = prev_screen
def add_screen(self, screen):
if screen.name not in self.screenMgr.screen_names:
self.screenMgr.add_widget(screen)
def current_screen(self, screen):
if True or self.screenMgr.current != screen.name and self.screenMgr.has_screen(
screen.name):
self.screenMgr.current = screen.name
def remove_screen(self, screen):
if screen.name in self.screenMgr.screen_names:
self.screenMgr.remove_widget(screen)
self.prev_screen()
def get_current_screen(self):
return self.screenMgr.current
class SwitchBoard(GridLayout):
'''
Holds a bunch of Screens inside a screen manager an can switch with a UI
'''
def __init__(self, app, screens, *args, **kwargs):
'''
params:-
app : Visualliser : The parent of this
screens : (Screen, ...) : Screens to be added onto the UI
'''
super().__init__(*args, **kwargs)
self.app = app
self.cols = 1
self.rows = 2
self.screen_manager = ScreenManager()
self.screen_manager.transition = SwapTransition()
# Add screens to the screen manager
for screen in screens:
self.screen_manager.add_widget(screen)
self.add_widget(self.screen_manager)
# Add the UI buttons
ui = GridLayout(rows=1, size_hint_y=None, height=20)
ui.add_widget(Button(on_press=lambda a: self.switch_screen( str(int(self.screen_manager.current) - 1)) ))
ui.add_widget(Button(on_press=lambda a: self.switch_screen( str(int(self.screen_manager.current) + 1)) ))
self.add_widget(ui)
def switch_screen(self, name):
'''
params:-
name : str : Name of the screen you want to change to
returns:-
None : Changes the window to the new board
'''
if self.screen_manager.has_screen(name):
self.screen_manager.current = name
class CalendarWidgetM(RelativeLayout):
""" Basic calendar widget """
def __init__(self, as_popup=False, touch_switch=False, *args, **kwargs):
super(CalendarWidgetM, self).__init__(*args, **kwargs)
self.as_popup = as_popup
self.touch_switch = touch_switch
self.prepare_data()
monthlyWrkHours.getHolidays()
self.init_ui()
def init_ui(self):
self.left_arrow = arrowBtn(text="<", on_press=self.go_prev,
pos_hint={"top": 1, "left": 0}, size_hint=(.1, .1))
self.right_arrow = arrowBtn(text=">", on_press=self.go_next,
pos_hint={"top": 1, "right": 1}, size_hint=(.1, .1))
self.add_widget(self.left_arrow)
self.add_widget(self.right_arrow)
# Title
self.title_label = monthBtn(text=self.title, pos_hint={"top": 1, "center_x": .5}, size_hint=(None, 0.15), halign=("center"))
monthlyPopup.month = self.title
self.add_widget(self.title_label)
# ScreenManager
self.sm = ScreenManager(pos_hint={"top": .9}, size_hint=(1, .9))
self.add_widget(self.sm)
self.create_month_scr(self.quarter[1], toogle_today=True)
def create_month_scr(self, month, toogle_today=False):
""" Screen with calendar for one month """
monthlyWrkHours.calArtistLeave(self.active_date[2], str(self.active_date[1]).zfill(2), str(self.active_date[0]).zfill(2))
#self.active_date[0] = day, self.active_date[1] = month, self.active_date[2] = year
scr = Screen()
m = self.month_names_eng[self.active_date[1] - 1]
scr.name = "%s-%s" % (m, self.active_date[2]) # like march-2015
# Grid for days
grid_layout = GridLayout(cols=7, rows=7, size_hint=(1, 1), pos_hint={"top": 1}, spacing = 2)
scr.add_widget(grid_layout)
# Days abbrs
for i in range(7):
if i >= 5: # weekends
l = WeekEndLabel(text=self.days_abrs[i])
else: # work days
l = WrkDayLabel(text=self.days_abrs[i])
grid_layout.add_widget(l)
global aboveSWH, belowSWH, holidays, artistHolidays
# Buttons with days numbers
for week in month:
for day in week:
if day[1] >= 6: # weekends
self.tbtn = CalNormalButton(text=str(day[0]), background_color=(0.5, 0.5, 0.5, 1), color=(1, 1, 1, 1))
else:
self.tbtn = CalNormalButton(text=str(day[0]), background_color=(255, 255, 255, 1), color=(0, 0, 0, 1))
for i in range(len(aboveSWH)):
if self.active_date[2] == aboveSWH[i][2]:
if self.active_date[1] == aboveSWH[i][1]:
if self.tbtn.text == str(aboveSWH[i][0]):
self.tbtn.background_color=(0, 255, 0, 0.7)
for i in range(len(belowSWH)):
if self.active_date[2] == belowSWH[i][2]:
if self.active_date[1] == belowSWH[i][1]:
if self.tbtn.text == str(belowSWH[i][0]):
self.tbtn.background_color=(255, 0, 0, 0.7)
for i in range(len(reg)):
if self.active_date[2] == reg[i][2]:
if self.active_date[1] == reg[i][1]:
if self.tbtn.text == str(reg[i][0]):
self.tbtn.ids.calLbl.text = 'R'
for i in range(len(leaves)):
if self.active_date[2] == leaves[i][2]:
if self.active_date[1] == leaves[i][1]:
if day[0] == (leaves[i][0]):
self.tbtn.background_color=(255, 195, 0, 0.7)
for i in range(len(holidays)):
if self.active_date[2] == holidays[i][2]:
if self.active_date[1] == holidays[i][1]:
if day[0] == holidays[i][0]:
self.tbtn.background_color=(0, 0, 255, 0.7)
self.tbtn.bind(on_press=self.get_btn_value)
"""if toogle_today:
# Down today button
if day[0] == self.active_date[0] and day[2] == 1:
self.tbtn.state = "down"""
# Disable buttons with days from other months
if day[2] == 0:
self.tbtn.text = " "
self.tbtn.disabled = True
self.tbtn.background_color = (255, 255, 255, 1)
grid_layout.add_widget(self.tbtn)
self.sm.add_widget(scr)
def prepare_data(self):
""" Prepare data for showing on widget loading """
# Get days abbrs and month names lists
self.month_names = cal_data.get_month_names()
self.month_names_eng = cal_data.get_month_names_eng()
self.days_abrs = cal_data.get_days_abbrs()
# Today date
self.active_date = cal_data.today_date_list()
# Set title
self.title = "%s - %s" % (self.month_names[self.active_date[1] - 1],
self.active_date[2])
# Quarter where current month in the self.quarter[1]
self.get_quarter()
def get_quarter(self):
""" Get caledar and months/years nums for quarter """
self.quarter_nums = cal_data.calc_quarter(self.active_date[2],
self.active_date[1])
self.quarter = cal_data.get_quarter(self.active_date[2],
self.active_date[1])
def get_btn_value(self, inst):
""" Get day value from pressed button """
from pages import userPage, infoPopup, table, monthlyPopup
global id
self.active_date[0] = int(inst.text)
formatted_date = "{}:{}:{}".format(str(self.active_date[0]).zfill(2), str(self.active_date[1]).zfill(2), self.active_date[2])
print(formatted_date)
getInfo.date = formatted_date
userPage.date = formatted_date
infoPopup.date = formatted_date
#infoPopup.InfoTab().popInfo(formatted_date)
table.date = formatted_date
monthlyPopup.date = formatted_date
if self.as_popup:
self.parent_popup.dismiss()
#getInfo.getUserInfo(id, formatted_date)
def go_prev(self, inst):
""" Go to screen with previous month """
monthlyWrkHours.calArtistLeave(self.quarter_nums[0][0], self.quarter_nums[0][1], self.active_date[0])
# Change active date
self.active_date = [self.active_date[0], self.quarter_nums[0][1],
self.quarter_nums[0][0]]
# Name of prev screen
n = self.quarter_nums[0][1] - 1
prev_scr_name = "%s-%s" % (self.month_names_eng[n],
self.quarter_nums[0][0])
# If it's doen't exitst, create it
if not self.sm.has_screen(prev_scr_name):
self.create_month_scr(self.quarter[0])
self.sm.current = prev_scr_name
self.sm.transition.direction = "left"
self.get_quarter()
self.title = "%s - %s" % (self.month_names[self.active_date[1] - 1],
self.active_date[2])
self.title_label.text = self.title
# assign title to monthlyPopup
monthlyPopup.month = self.title
def go_next(self, inst):
""" Go to screen with next month """
monthlyWrkHours.calArtistLeave(self.quarter_nums[2][0], self.quarter_nums[2][1], self.active_date[0])
# Change active date
self.active_date = [self.active_date[0], self.quarter_nums[2][1],
self.quarter_nums[2][0]]
# Name of prev screen
n = self.quarter_nums[2][1] - 1
next_scr_name = "%s-%s" % (self.month_names_eng[n],
self.quarter_nums[2][0])
# If it's doen't exitst, create it
if not self.sm.has_screen(next_scr_name):
self.create_month_scr(self.quarter[2])
self.sm.current = next_scr_name
self.sm.transition.direction = "right"
self.get_quarter()
self.title = "%s - %s" % (self.month_names[self.active_date[1] - 1],
self.active_date[2])
self.title_label.text = self.title
# assign title to monthlyPopup
monthlyPopup.month = self.title
def on_touch_move(self, touch):
""" Switch months pages by touch move """
if self.touch_switch:
# Left - prev
if touch.dpos[0] < -30:
self.go_prev(None)
# Right - next
elif touch.dpos[0] > 30:
self.go_next(None)
class Car(MDApp):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.title = "Infernus"
self.theme_cls.primary_palette = "DeepOrange"
self.theme_cls.theme_style = "Light"
self.sm = ScreenManager()
self.has_animated_card = False
self.has_animated_background = False
def login(self, usr, passwd):
if (usr.text == "salman97" and passwd.text == "salman"):
#Snackbar(text="Welcome " + usr.text + "!").show()
toast("Welcome " + usr.text + "!")
self.manage_screens("home_screen", "add")
self.change_screen("home_screen")
else:
toast("Incorrect username and/or password!")
#Snackbar(text="Incorrect username and/or password!").show()
def animate_background(self, widget):
if self.has_animated_background == False:
anim = Animation(size_hint_y=1) + Animation(size_hint_y=0.5)
anim.start(widget.ids.bx)
def animate_card(self, widget):
# {"center_x": 0.5, "center_y": 0.6}
if self.has_animated_card == False:
anim = Animation(pos_hint={
"center_x": 0.5,
"center_y": 0.6
},
duration=0.5)
anim.start(widget)
self.has_animated_card = True
def change_screen(self, screen_name):
if self.sm.has_screen(screen_name):
self.sm.current = screen_name
def manage_screens(self, screen_name, action):
scns = {
"login_screen": Factory.LoginScreen,
"home_screen": Factory.HomeScreen,
"explore_screen": Factory.ExploreScreen
}
try:
if action == "remove":
if self.sm.has_screen(screen_name):
self.sm.remove_widget(self.sm.get_screen(screen_name))
#print("Screen ["+screen_name+"] removed")
elif action == "add":
if self.sm.has_screen(screen_name):
pass
#print("Screen [" + screen_name + "] already exists")
else:
self.sm.add_widget(scns[screen_name](name=screen_name))
#print(screen_name + " added")
#print("Screen ["+screen_name+"] added")
except:
print(traceback.format_exc())
print("Traceback ^.^")
def on_pause(self):
return True
def on_resume(self):
pass
def build(self):
print('hello')
self.bind(on_start=self.post_build_init)
self.sm.add_widget(Factory.LoginScreen())
self.sm.add_widget(Factory.HomeScreen())
self.sm.current = "login_screen"
return self.sm
def post_build_init(self, ev):
win = self._app_window
win.bind(on_keyboard=self._key_handler)
def _key_handler(self, *args):
key = args[1]
# 1000 is "back" on Android
# 27 is "escape" on computers
if key in (1000, 27):
try:
self.sm.current = "login_screen"
except Exception as e:
print(e)
return True
elif key == 1001:
try:
self.sm.current = "login_screen"
except Exception as e:
print(e)
return True
class JewelApp(App):
score = NumericProperty(0)
score_multiplier = NumericProperty(1)
score_combo = NumericProperty(0)
timer = NumericProperty(LEVEL_TIME)
level_time = NumericProperty(LEVEL_TIME)
timer_next = NumericProperty(0)
no_touch = BooleanProperty(False)
highscores = ListProperty([0, 0, 0])
background_rgb = ListProperty([0, 0, 0])
sidebar_warning_color = ListProperty([0, 0, 0, 0])
time = NumericProperty(0)
score_levels = ListProperty([0])
gameover_graph = ObjectProperty()
timer_hint = NumericProperty(0)
def build(self):
self.textures = {}
self.load_sounds()
self.highscore_fn = join(self.user_data_dir, 'highscore.dat')
from kivy.base import EventLoop
EventLoop.ensure_window()
# load textures
for fn in ('gem', 'gem_selected', 't5', 't10', 'tarea', 'tline', 'star'):
texture = CoreImage(join('data', '{}.png'.format(fn)), mipmap=True).texture
self.textures[fn] = texture
self.root = ScreenManager(transition=SlideTransition())
self.bind(score_combo=self.check_game_over,
timer=self.check_game_over,
timer_next=self.check_game_over)
self.ui_jewel = JewelUI(name='jewel')
self.root.add_widget(self.ui_jewel)
self.start()
Clock.schedule_interval(self.update_time, 1 / 20.)
#Clock.schedule_interval(self._stats, 1 / 60.)
#self._stats()
if False:
def debug_leaks(*args):
import gc; gc.collect()
print 'collect()', len(gc.get_objects())
import objgraph;
#print len(objgraph.by_type('PropertyStorage'))
objgraph.show_growth()
#print objgraph.typestats(objgraph.get_leaking_objects())
#objgraph.show_most_common_types()
Clock.schedule_interval(debug_leaks, 1.)
# load highscores
if not exists(self.highscore_fn):
return
try:
with open(self.highscore_fn) as fd:
version, highscores = json.load(fd)
if version == HIGHSCORE_VERSION:
self.highscores = highscores
except:
pass
def save_highscore(self):
highscores = self.highscores + [self.score]
highscores.sort()
highscores = list(reversed(highscores))[:3]
self.highscores = highscores
with open(self.highscore_fn, 'w') as fd:
json.dump([HIGHSCORE_VERSION, self.highscores], fd)
def start(self):
if not self.board.first_run:
self.board.reset()
self.score = 0
self.score_combo = 0
self.score_multiplier = 1
self.timer = LEVEL_TIME
self.level_time = LEVEL_TIME
self.start_time = self.timer_hint = time()
self.no_touch = False
self.score_levels = [0]
self.audio_warning_index = -1
self.root.current = 'jewel'
Clock.schedule_interval(self.update_timer, 1 / 20.)
self.bind(score_multiplier=self.update_background)
self.update_background()
self.show_text('Level 1')
def update_background(self, *args):
index = (self.score_multiplier - 1) % len(BACKGROUND_COLORS)
c = BACKGROUND_COLORS[index]
Animation(background_rgb=c).start(self)
def game_over(self):
self.no_touch = True
self.timer = 0
self.board.gameover()
self.sound('end')
Clock.unschedule(self.update_timer)
def check_game_over(self, *args):
if any([self.score_combo, self.timer, self.timer_next]):
return
if self.no_touch:
self.save_highscore()
if not self.root.has_screen('gameover'):
self.gameover = GameOver(name='gameover')
self.root.add_widget(GameOver(name='gameover'))
self.root.current = 'gameover'
def update_time(self, dt):
self.time += dt
def update_timer(self, dt):
self.sound_played = []
current_time = time()
self.timer = self.level_time - (current_time - self.start_time)
should_hint = current_time - self.timer_hint
if should_hint > HINT_TIME:
self.timer_hint = current_time
if self.score_combo == 0:
self.board.highlight_move()
t = self.timer + self.timer_next
if t < 10:
a = abs(sin(self.time * 3))
self.sidebar_warning_color = [1, .1, .1,
((10. - t) / 10.) * .3 + a * .5]
audio_warning_index = 10 - int(t)
if audio_warning_index != self.audio_warning_index:
self.play_sound('warning',
volume=(audio_warning_index / 15.))
self.audio_warning_index = audio_warning_index
else:
self.sidebar_warning_color = [0, 0, 0, 0]
self.audio_warning_index = -1
if self.timer > 0:
return
if self.timer_next == 0:
self.game_over()
return
# next level!
self.score_multiplier += 1
self.start_time = time()
self.level_time = self.timer_next
self.timer = self.level_time - (time() - self.start_time)
self.timer_next = self.property('timer_next').defaultvalue
self.score_levels.append(0)
self.board.levelup()
self.show_text('Level {}'.format(self.score_multiplier))
self.sound('levelup')
def add_score(self, ix, iy, pattern, count):
x, y = self.board.index_to_pos(ix, iy)
m = self.score_multiplier
score = 0
if pattern == 'classic':
score += count * 50
elif pattern == '4j':
score += count * 100
elif pattern == '5j':
score += count * 150
elif pattern == '2axes':
score += count * 200
elif pattern == 'area':
score += count * 500
elif pattern == 'line':
score += count * 1000
elif pattern == 'combo':
score += self.score_combo * 1000
score *= m
self.score += score
self.score_levels[-1] += score
if score == 0:
return
js = self.board.jewel_size
label = ScoreLabel(text='{}'.format(score), origin=(x + js / 2, y + js / 2))
self.ui_jewel.add_widget(label)
def increase_timer_next(self, t):
if self.no_touch:
return
self.timer_next = min(LEVEL_TIME, t + self.timer_next)
def reset_combo(self):
self.score_combo = 0
self.timer_hint = time()
def show_text(self, text):
ttext = TitleText(text=text)
self.ui_jewel.add_widget(ttext)
def load_sounds(self):
self.music = SoundLoader.load('data/audio/Tetra_-_Hunters.ogg')
self.music.volume = .35
self.music.loop = True
self.music.play()
self.sounds = {}
self.load_sound('move', 'move.ogg', count=5)
self.load_sound('levelup', 'levelup.ogg')
self.load_sound('end', 'end.ogg')
self.load_sound('time5', 'time5.ogg', count=2)
self.load_sound('time10', 'time10.ogg', count=2)
self.load_sound('warning', 'warning.ogg')
self.load_sound('explode-line', 'explode-line.ogg', count=2)
self.load_sound('explode-area', 'explode-area.ogg', count=2)
def load_sound(self, action, fn, count=1):
sounds = [SoundLoader.load('data/audio/{}'.format(fn)) for x in range(count)]
self.sounds[action] = sounds
def play_sound(self, action, volume=1.):
if action in self.sound_played:
return
self.sound_played.append(action)
sounds = self.sounds[action]
sound = sounds.pop(0)
sound.volume = volume
sound.play()
sounds.append(sound)
def sound(self, action):
# no sound for explode yet.
if action == 'explode':
action = 'move'
self.play_sound(action)
'''
class JewelApp(App):
score = NumericProperty(0)
score_multiplier = NumericProperty(1)
score_combo = NumericProperty(0)
timer = NumericProperty(LEVEL_TIME)
level_time = NumericProperty(LEVEL_TIME)
timer_next = NumericProperty(0)
no_touch = BooleanProperty(False)
highscores = ListProperty([0, 0, 0])
background_rgb = ListProperty([0, 0, 0])
sidebar_warning_color = ListProperty([0, 0, 0, 0])
time = NumericProperty(0)
score_levels = ListProperty([0])
gameover_graph = ObjectProperty()
timer_hint = NumericProperty(0)
def build(self):
self.textures = {}
self.load_sounds()
self.highscore_fn = join(self.user_data_dir, 'highscore.dat')
from kivy.base import EventLoop
EventLoop.ensure_window()
# load textures
for fn in ('gem', 'gem_selected', 't5', 't10', 'tarea', 'tline',
'star'):
texture = CoreImage(join('data', '{}.png'.format(fn)),
mipmap=True).texture
self.textures[fn] = texture
self.root = ScreenManager(transition=SlideTransition())
self.bind(score_combo=self.check_game_over,
timer=self.check_game_over,
timer_next=self.check_game_over)
self.ui_jewel = JewelUI(name='jewel')
self.root.add_widget(self.ui_jewel)
self.start()
Clock.schedule_interval(self.update_time, 1 / 20.)
#Clock.schedule_interval(self._stats, 1 / 60.)
#self._stats()
if False:
def debug_leaks(*args):
import gc
gc.collect()
print 'collect()', len(gc.get_objects())
import objgraph
#print len(objgraph.by_type('PropertyStorage'))
objgraph.show_growth()
#print objgraph.typestats(objgraph.get_leaking_objects())
#objgraph.show_most_common_types()
Clock.schedule_interval(debug_leaks, 1.)
# load highscores
if not exists(self.highscore_fn):
return
try:
with open(self.highscore_fn) as fd:
version, highscores = json.load(fd)
if version == HIGHSCORE_VERSION:
self.highscores = highscores
except:
pass
def save_highscore(self):
highscores = self.highscores + [self.score]
highscores.sort()
highscores = list(reversed(highscores))[:3]
self.highscores = highscores
with open(self.highscore_fn, 'w') as fd:
json.dump([HIGHSCORE_VERSION, self.highscores], fd)
def start(self):
if not self.board.first_run:
self.board.reset()
self.score = 0
self.score_combo = 0
self.score_multiplier = 1
self.timer = LEVEL_TIME
self.level_time = LEVEL_TIME
self.start_time = self.timer_hint = time()
self.no_touch = False
self.score_levels = [0]
self.audio_warning_index = -1
self.root.current = 'jewel'
Clock.schedule_interval(self.update_timer, 1 / 20.)
self.bind(score_multiplier=self.update_background)
self.update_background()
self.show_text('Level 1')
def update_background(self, *args):
index = (self.score_multiplier - 1) % len(BACKGROUND_COLORS)
c = BACKGROUND_COLORS[index]
Animation(background_rgb=c).start(self)
def game_over(self):
self.no_touch = True
self.timer = 0
self.board.gameover()
self.sound('end')
Clock.unschedule(self.update_timer)
def check_game_over(self, *args):
if any([self.score_combo, self.timer, self.timer_next]):
return
if self.no_touch:
self.save_highscore()
if not self.root.has_screen('gameover'):
self.gameover = GameOver(name='gameover')
self.root.add_widget(GameOver(name='gameover'))
self.root.current = 'gameover'
def update_time(self, dt):
self.time += dt
def update_timer(self, dt):
self.sound_played = []
current_time = time()
self.timer = self.level_time - (current_time - self.start_time)
should_hint = current_time - self.timer_hint
if should_hint > HINT_TIME:
self.timer_hint = current_time
if self.score_combo == 0:
self.board.highlight_move()
t = self.timer + self.timer_next
if t < 10:
a = abs(sin(self.time * 3))
self.sidebar_warning_color = [
1, .1, .1, ((10. - t) / 10.) * .3 + a * .5
]
audio_warning_index = 10 - int(t)
if audio_warning_index != self.audio_warning_index:
self.play_sound('warning', volume=(audio_warning_index / 15.))
self.audio_warning_index = audio_warning_index
else:
self.sidebar_warning_color = [0, 0, 0, 0]
self.audio_warning_index = -1
if self.timer > 0:
return
if self.timer_next == 0:
self.game_over()
return
# next level!
self.score_multiplier += 1
self.start_time = time()
self.level_time = self.timer_next
self.timer = self.level_time - (time() - self.start_time)
self.timer_next = self.property('timer_next').defaultvalue
self.score_levels.append(0)
self.board.levelup()
self.show_text('Level {}'.format(self.score_multiplier))
self.sound('levelup')
def add_score(self, ix, iy, pattern, count):
x, y = self.board.index_to_pos(ix, iy)
m = self.score_multiplier
score = 0
if pattern == 'classic':
score += count * 50
elif pattern == '4j':
score += count * 100
elif pattern == '5j':
score += count * 150
elif pattern == '2axes':
score += count * 200
elif pattern == 'area':
score += count * 500
elif pattern == 'line':
score += count * 1000
elif pattern == 'combo':
score += self.score_combo * 1000
score *= m
self.score += score
self.score_levels[-1] += score
if score == 0:
return
js = self.board.jewel_size
label = ScoreLabel(text='{}'.format(score),
origin=(x + js / 2, y + js / 2))
self.ui_jewel.add_widget(label)
def increase_timer_next(self, t):
if self.no_touch:
return
self.timer_next = min(LEVEL_TIME, t + self.timer_next)
def reset_combo(self):
self.score_combo = 0
self.timer_hint = time()
def show_text(self, text):
ttext = TitleText(text=text)
self.ui_jewel.add_widget(ttext)
def load_sounds(self):
self.music = SoundLoader.load('data/audio/Tetra_-_Hunters.ogg')
self.music.volume = .35
self.music.loop = True
self.music.play()
self.sounds = {}
self.load_sound('move', 'move.ogg', count=5)
self.load_sound('levelup', 'levelup.ogg')
self.load_sound('end', 'end.ogg')
self.load_sound('time5', 'time5.ogg', count=2)
self.load_sound('time10', 'time10.ogg', count=2)
self.load_sound('warning', 'warning.ogg')
self.load_sound('explode-line', 'explode-line.ogg', count=2)
self.load_sound('explode-area', 'explode-area.ogg', count=2)
def load_sound(self, action, fn, count=1):
sounds = [
SoundLoader.load('data/audio/{}'.format(fn)) for x in range(count)
]
self.sounds[action] = sounds
def play_sound(self, action, volume=1.):
if action in self.sound_played:
return
self.sound_played.append(action)
sounds = self.sounds[action]
sound = sounds.pop(0)
sound.volume = volume
sound.play()
sounds.append(sound)
def sound(self, action):
# no sound for explode yet.
if action == 'explode':
action = 'move'
self.play_sound(action)
'''
class LeaveDetLayout(BoxLayout):
def __init__(self, **args):
super(LeaveDetLayout, self).__init__(**args)
self.artistDetList = usersListManip.getUserInfo()
self.setup()
self.init_ui()
def init_ui(self):
self.sm1 = ScreenManager(pos_hint={"top": .9}, size_hint=(1, .9))
self.ids.dateInfo.add_widget(self.sm1)
self.sm2 = ScreenManager(pos_hint={"top": 1}, size_hint=(1, 1))
self.ids.details.add_widget(self.sm2)
self.ids.artistlist.rows = len(self.artistDetList['artistId'])
self.ids.artistlist.bind(
minimum_height=self.ids.artistlist.setter('height'))
for a in self.artistDetList['artistName']:
artistLbl = ArtistLabel(text="{}".format(a),
size_hint_y=None,
color=(0, 0, 0, 1),
height=30)
self.ids.artistlist.add_widget(artistLbl)
self.create_leave_scr()
def create_leave_scr(self):
Det = leaveData.getDetails(
self.months.index(self.dispMonth) + 1, self.dispYear,
self.artistDetList['artistId'])
#print(Det)
days = DaysScreen()
days.name = self.ids.monthName.text
daysNum = DaysGrid(rows=2)
daysNum.cols = self.numOfDays[1]
for i in range(1, self.numOfDays[1] + 1):
dayNumLbl = DaysNumLabel(
text='{}'.format(i),
color=(0, 0, 0, 1),
)
daysNum.add_widget(dayNumLbl)
weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
l = 0
w = self.numOfDays[0]
while l < (self.numOfDays[1]):
wd = weekdays[w]
weekDaysLbl = DaysLabel(text='{}'.format(wd), color=(0, 0, 0, 1))
if wd == 'Sun':
weekDaysLbl.set_bgGray()
l += 1
w += 1
if w == 7:
w = 0
if l > (self.numOfDays[1] + 1):
break
daysNum.add_widget(weekDaysLbl)
days.add_widget(daysNum)
self.sm1.add_widget(days)
# starting to add chart
charts = ChartScreen()
charts.name = self.ids.monthName.text
self.chartScroll = ChartScroll(size_hint=(1, 1))
#self.chartScroll.bind(scroll_y=lambda x:self.scroll_sync) #.ids.scroll_a.scroll_y
self.chartScroll.bind(scroll_y=self.scroll_sync)
leaveGrid = ChartGrid()
leaveGrid.bind(minimum_height=leaveGrid.setter('height'))
leaveGrid.size_hint = (1, None)
leaveGrid.rows = len(self.artistDetList['artistId'])
leaveGrid.cols = self.numOfDays[1]
leaveGrid.padding = (0, 1, 0, 0)
def callback(wid, touch):
global detail
det = wid.text.split(".")
detail = [det[0], det[1]]
def opCall(wid, touch):
global opDetail
det = wid.text.split(".")
opDetail = [det[0], det[1]]
for r in range(leaveGrid.rows):
#print(Det[r]['leaveDates'][0])
leaveDates = Det[r]['leaveDates']
planned = Det[r]['planned']
requests = Det[r]['leave_requests']
permissions = Det[r]['permission']
l = 0
w = self.numOfDays[0]
for c in range(leaveGrid.cols):
curDate = "{}-{}-{}".format(
self.dispYear,
str(self.months.index(self.dispMonth) + 1).zfill(2),
str(c + 1).zfill(2))
lvBtn = LeaveButton(text='{}.{}'.format(Det[r]['id'], curDate),
size_hint_y=None,
height=30)
lvBtn.bind(on_touch_down=opCall)
wd = weekdays[w]
try:
if curDate in leaveDates:
lvBtn.setUP()
except Exception as e:
print(e)
pass
if curDate in planned:
lvBtn.setP()
if curDate in permissions:
lvBtn.setPE()
if curDate in requests:
lvBtn = PermissionButton(
text='{}.{}'.format(Det[r]['id'], curDate))
lvBtn.bind(on_touch_down=callback)
if wd == 'Sun':
lvBtn.set_bgGray()
l += 1
w += 1
if w == 7:
w = 0
if l > (self.numOfDays[1] + 1):
break
leaveGrid.add_widget(lvBtn)
self.chartScroll.add_widget(leaveGrid)
charts.add_widget(self.chartScroll)
self.sm2.add_widget(charts)
def setup(self):
self.months = calendar_data.get_month_names()
self.today = datetime.today()
self.dispMonth = self.months[self.today.month - 1]
self.dispYear = self.today.year
self.numOfDays = monthrange(self.dispYear, self.today.month)
self.ids.monthName.text = "{} - {}".format(self.dispMonth,
self.dispYear)
def go_prev(self):
self.dispMonth = self.months[self.months.index(self.dispMonth) - 1]
if self.dispMonth == self.months[-1]:
self.dispYear -= 1
self.numOfDays = monthrange(self.dispYear,
self.months.index(self.dispMonth) + 1)
self.ids.monthName.text = "{} - {}".format(self.dispMonth,
self.dispYear)
if not self.sm1.has_screen(
self.ids.monthName.text) and not self.sm2.has_screen(
self.ids.monthName.text):
print("creating screen1")
self.create_leave_scr()
self.sm1.current = self.ids.monthName.text
self.sm2.current = self.ids.monthName.text
self.sm1.transition.direction = "left"
self.sm2.transition.direction = "left"
def go_next(self):
if self.months.index(self.dispMonth) == 11:
self.dispMonth = self.months[0]
self.dispYear += 1
self.numOfDays = monthrange(self.dispYear,
self.months.index(self.dispMonth) + 1)
self.ids.monthName.text = "{} - {}".format(self.dispMonth,
self.dispYear)
if not self.sm1.has_screen(self.ids.monthName.text):
print("creating screen1")
self.create_leave_scr()
self.sm1.current = self.ids.monthName.text
self.sm1.transition.direction = "right"
if not self.sm2.has_screen(self.ids.monthName.text):
print("creating screen2")
self.create_leave_scr()
self.sm2.current = self.ids.monthName.text
self.sm2.transition.direction = "right"
return 0
self.dispMonth = self.months[self.months.index(self.dispMonth) + 1]
self.numOfDays = monthrange(self.dispYear,
self.months.index(self.dispMonth) + 1)
self.ids.monthName.text = "{} - {}".format(self.dispMonth,
self.dispYear)
if not self.sm1.has_screen(self.ids.monthName.text):
print("creating screen")
self.create_leave_scr()
self.sm1.current = self.ids.monthName.text
self.sm1.transition.direction = "right"
if not self.sm2.has_screen(self.ids.monthName.text):
print("creating screen")
self.create_leave_scr()
self.sm2.current = self.ids.monthName.text
self.sm2.transition.direction = "right"
def scroll_sync(self, instance, value):
self.ids.scroll_a.scroll_y = self.chartScroll.scroll_y
class Logotouch(App):
connected = BooleanProperty(False)
def build_config(self, config):
config.setdefaults('server', {
'host': 'logotouch.erasme.org',
'db': '0' })
def build(self):
from kivy.core.window import Window
Window.bind(on_keyboard=self._on_window_keyboard)
self.user_email = '*****@*****.**'
self.user_name = 'Mathieu Virbel'
self.rpc = None
self.game_screen = None
self.sm = ScreenManager(transition=SlideTransition())
self.screen_welcome = WelcomeScreen(name='welcome')
self.sm.add_widget(self.screen_welcome)
self.connect()
#self.create_session_with_corpus(0)
return self.sm
def create_session(self):
if not hasattr(self, 'screen_create_session'):
self.screen_create_session = CreateSessionScreen(name='create')
self.sm.add_widget(self.screen_create_session)
self.sm.current = 'create'
def join_session(self):
if not hasattr(self, 'screen_join_session'):
self.screen_join_session = JoinSessionScreen(name='join')
self.sm.add_widget(self.screen_join_session)
self.sm.current = 'join'
def create_session_with_corpus(self, corpus_id):
if not hasattr(self, 'screen_download_corpus'):
self.screen_download_corpus = DownloadScreen(name='download',
title=_('Game is starting'),
action=_('Creating session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus)
self.sm.current = 'download'
self.g_corpus_id = corpus_id
self.rpc.new_session(self.user_email, corpus_id,
callback=self._on_create_session)
def create_session_new_corpus(self):
if not hasattr(self, 'screen_download_corpus'):
self.screen_download_corpus = DownloadScreen(name='download',
title=_('Game is starting'),
action=_('Creating session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus)
self.sm.current = 'download'
from time import time
self.rpc.new_corpus(
'Corpus {}'.format(time()),
self.user_name,
self.user_email,
callback=self._on_create_corpus)
def _on_create_corpus(self, result, error=None):
if error is not None:
return
self.create_session_with_corpus(result)
def join_session_from_enc(self, enc):
try:
sessid = basedec(enc)
if not hasattr(self, 'screen_download_corpus2'):
self.screen_download_corpus2 = \
DownloadScreen(name='download2',
title=_('Game is starting'),
action=_('Joining session'),
progression=33)
self.sm.add_widget(self.screen_download_corpus2)
self.sm.current = 'download2'
self.rpc.join_session(self.user_email, sessid,
callback=self._on_join_session)
except:
self.screen_join_session.error = _('Invalid session code')
self.sm.current = 'join'
self.screen_join_session.disptach('on_enter')
def add_sentence(self, data):
self.rpc.add_sentence(self.g_sessid, data)
def get_sentences(self, callback):
self.rpc.get_sentences(self.g_sessid, callback=callback)
def _on_join_session(self, result, error=None):
if error is not None:
self.screen_join_session.error = _('Error while joining the session: {}').format(error)
self.sm.current = 'join'
return
if result is None:
self.screen_join_session.error = _('Unknow session code')
self.sm.current = 'join'
return
self.g_sessid = result['sessid']
self.g_corpus_id = result['corpusid']
self.g_sentences_count = result['sentences_count']
self.rpc.bind_session(self.g_sessid)
self.sm.current_screen.action = _('Downloading Corpus')
self.sm.current_screen.progression = 66
self.rpc.get_corpus(self.g_corpus_id, callback=self._on_corpus)
def _on_create_session(self, result, error=None):
if error is not None:
return
self.g_sessid = result
self.g_sentences_count = 0
self.rpc.bind_session(self.g_sessid)
self.sm.current_screen.action = _('Downloading Corpus')
self.sm.current_screen.progression = 66
self.rpc.get_corpus(self.g_corpus_id, callback=self._on_corpus)
def _on_corpus(self, result, error=None):
if error is not None:
# TODO
return
self.g_corpus = result
self.sm.current_screen.progression = 100
Clock.schedule_once(self._start_game, 0.1)
def _start_game(self, *args):
self.game_screen = GameScreen(name='game',
sessid=self.g_sessid, corpus=self.g_corpus,
sentences_count=self.g_sentences_count)
if self.sm.has_screen('game'):
self.sm.remove_widget(self.sm.get_screen('game'))
self.sm.add_widget(self.game_screen)
self.sm.current = 'game'
def connect(self):
self.rpc = ThreadedRpcClient(
host=self.config.get('server', 'host'),
on_session_broadcast=self._on_session_broadcast)
def disconnect(self):
pass
def help_gesture(self):
popup = HelpGesturePopup()
popup.open()
def _on_window_keyboard(self, window, *largs):
key = largs[0]
if key != 27:
return
self.do_back()
def do_back(self):
# if there is a modal view in the window, avoid to check it
from kivy.core.window import Window
if any([isinstance(x, ModalView) for x in Window.children]):
return
if self.sm.current != 'welcome':
self.sm.current = 'welcome'
return True
def _on_session_broadcast(self, sessid, message):
if str(self.g_sessid) != str(sessid):
print 'Dropped message, invalid sessid {} (we accept {})'.format(
sessid, self.g_sessid)
return
if self.game_screen:
self.game_screen.on_broadcast(message)
class CalendarWidgetS(RelativeLayout):
""" Basic calendar widget """
def __init__(self, as_popup=False, touch_switch=False, *args, **kwargs):
super(CalendarWidgetS, self).__init__(*args, **kwargs)
self.as_popup = as_popup
self.touch_switch = touch_switch
#self.selectedDates = []
self.prepare_data()
self.init_ui()
def init_ui(self):
self.left_arrow = Button(text="<", on_press=self.go_prev,
pos_hint={"top": 1, "left": 0}, size_hint=(.1, .1))
self.right_arrow = Button(text=">", on_press=self.go_next,
pos_hint={"top": 1, "right": 1}, size_hint=(.1, .1))
self.add_widget(self.left_arrow)
self.add_widget(self.right_arrow)
# Title
self.title_label = Label(text=self.title, pos_hint={"top": 1, "center_x": .5}, size_hint=(None, 0.15), halign=("center"))
self.add_widget(self.title_label)
# ScreenManager
self.sm = ScreenManager(pos_hint={"top": .9}, size_hint=(1, .9))
self.add_widget(self.sm)
self.create_month_scr(self.quarter[1], toogle_today=True)
def create_month_scr(self, month, toogle_today=False):
""" Screen with calendar for one month """
scr = Screen()
m = self.month_names_eng[self.active_date[1] - 1]
scr.name = "%s-%s" % (m, self.active_date[2]) # like march-2015
# Grid for days
grid_layout = GridLayout(cols=7, rows=7, size_hint=(1, 1), pos_hint={"top": 1})
scr.add_widget(grid_layout)
# Days abbrs
for i in range(7):
if i >= 5: # weekends
l = Label(text=self.days_abrs[i], color=(1, 0, 0, 1))
else: # work days
l = Label(text=self.days_abrs[i], text_size=(self.size[0], None), halign="center")
grid_layout.add_widget(l)
global holiday, halfday
# Buttons with days numbers
for week in month:
for day in week:
if day[1] >= 6: # weekends
self.tbtn = ToggleBtn(text=str(day[0]), color=(0, 0, 0, 1))
else:
self.tbtn = ToggleBtn(text=str(day[0]), color=(0, 0, 0, 1))
for i in range(len(holiday)):
if self.active_date[2] == holiday[i][2]:
if self.active_date[1] == holiday[i][1]:
if day[0] == holiday[i][0]:
self.tbtn.background_color=(128, 0, 128, 1)
for i in range(len(halfday)):
if self.active_date[2] == halfday[i][2]:
if self.active_date[1] == halfday[i][1]:
if day[0] == halfday[i][0]:
self.tbtn.background_color=(0, 255, 255, 0.5)
self.tbtn.bind(on_press=self.get_btn_value)
if toogle_today:
# Down today button
if day[0] == self.active_date[0] and day[2] == 1:
self.tbtn.state = "down"
# Disable buttons with days from other months
if day[2] == 0:
self.tbtn.text = " "
self.tbtn.disabled = True
self.tbtn.background_color = (0, 0, 0, 0.1)
grid_layout.add_widget(self.tbtn)
self.sm.add_widget(scr)
def prepare_data(self):
""" Prepare data for showing on widget loading """
# Get days abbrs and month names lists
self.month_names = cal_data.get_month_names()
self.month_names_eng = cal_data.get_month_names_eng()
self.days_abrs = cal_data.get_days_abbrs()
# Today date
self.active_date = cal_data.today_date_list()
# Set title
self.title = "%s - %s" % (self.month_names[self.active_date[1] - 1],
self.active_date[2])
# Quarter where current month in the self.quarter[1]
self.get_quarter()
def get_quarter(self):
""" Get caledar and months/years nums for quarter """
self.quarter_nums = cal_data.calc_quarter(self.active_date[2],
self.active_date[1])
self.quarter = cal_data.get_quarter(self.active_date[2],
self.active_date[1])
def get_btn_value(self, inst):
""" Get day value from pressed button """
self.active_date[0] = int(inst.text)
selected = [self.active_date[0], self.active_date[1], self.active_date[2]]
global selectedDates
if selected in selectedDates:
selectedDates.remove(selected)
else:
selectedDates.append(selected)
if self.as_popup:
self.parent_popup.dismiss()
#getInfo.openPopup()
def go_prev(self, inst):
""" Go to screen with previous month """
# Change active date
self.active_date = [self.active_date[0], self.quarter_nums[0][1],
self.quarter_nums[0][0]]
# Name of prev screen
n = self.quarter_nums[0][1] - 1
prev_scr_name = "%s-%s" % (self.month_names_eng[n],
self.quarter_nums[0][0])
# If it's doen't exitst, create it
if not self.sm.has_screen(prev_scr_name):
self.create_month_scr(self.quarter[0])
self.sm.current = prev_scr_name
self.sm.transition.direction = "left"
self.get_quarter()
self.title = "%s - %s" % (self.month_names[self.active_date[1] - 1],
self.active_date[2])
self.title_label.text = self.title
def go_next(self, inst):
""" Go to screen with next month """
# Change active date
self.active_date = [self.active_date[0], self.quarter_nums[2][1],
self.quarter_nums[2][0]]
# Name of prev screen
n = self.quarter_nums[2][1] - 1
next_scr_name = "%s-%s" % (self.month_names_eng[n],
self.quarter_nums[2][0])
# If it's doen't exitst, create it
if not self.sm.has_screen(next_scr_name):
self.create_month_scr(self.quarter[2])
self.sm.current = next_scr_name
self.sm.transition.direction = "right"
self.get_quarter()
self.title = "%s - %s" % (self.month_names[self.active_date[1] - 1],
self.active_date[2])
self.title_label.text = self.title
def on_touch_move(self, touch):
""" Switch months pages by touch move """
if self.touch_switch:
# Left - prev
if touch.dpos[0] < -30:
self.go_prev(None)
# Right - next
elif touch.dpos[0] > 30:
self.go_next(None)
class ChatApp(App):
"""聊天小程序"""
def build(self):
self.sm = ScreenManager(transition=SlideTransition())
self.contact = ChatContact(name='contact')
self.client = ChatClient(name='client')
self.server = ChatServer(name='server')
self.user_setting = UserSetting(name='user')
self.load_user_setting()
self.sm.add_widget(self.user_setting)
# self.sm.add_widget(self.client)
# self.sm.add_widget(self.server)
# self.sm.add_widget(self.contact)
# sm.current = 'client'
# self.server.start_server() # 自动打开服务器监听
return self.sm
def to_server(self, direction):
"""显示服务端"""
if not self.sm.has_screen('server'):
self.sm.add_widget(self.server)
self.sm.transition.direction = direction
self.sm.current = 'server'
def to_client(self, direction):
"""显示客户端"""
if not self.sm.has_screen('client'):
self.sm.add_widget(self.client)
self.sm.transition.direction = direction
self.sm.current = 'client'
def to_contact(self, direction):
"""显示客户端"""
if not self.sm.has_screen('contact'):
self.sm.add_widget(self.contact)
self.sm.transition.direction = direction
self.sm.current = 'contact'
def load_user_setting(self):
"""加载用户配置"""
if not exists(self.user_fn):
self.user_setting.data = []
self.user_setting.is_new = True
return
with open(self.user_fn) as fd:
data = json.load(fd)
self.user_setting.data = data
self.user_setting.is_new = False
def save_user_setting(self):
"""保存用户配置"""
is_new = self.user_setting.is_new
if self.user_setting.is_new: # 新建用户
# 获取用户昵称
if len(self.user_setting.ids.ti_nickname.text) == 0:
self.user_setting.ids.ti_nickname.focus = True
return
else:
self.user_setting.data[
'name'] = self.user_setting.ids.ti_nickname.text
self.user_setting.ids.ti_nickname.text = ''
self.user_setting.is_new = False
# self.to_client('left')
_thread.start_new_thread(self.thread_open_client, (is_new, ))
def thread_open_client(self, is_new):
"""打开程序线程"""
popup = Popup(title='Create Keys ...',
content=ProgressBar(max=100),
size_hint=(.8, .2))
popup.open()
if is_new:
# 生成密钥
key = RSA.generate(1024)
rsa_prikey = key.exportKey('PEM').decode('utf-8')
rsa_pubkey = key.publickey().exportKey('PEM').decode('utf-8')
self.user_setting.data['prikey'] = rsa_prikey
self.user_setting.data['pubkey'] = rsa_pubkey
time.sleep(.1)
popup.title = 'Save setting ...'
popup.content.value = 20
with open(self.user_fn, 'w') as fd:
json.dump(self.user_setting.data, fd)
time.sleep(.1)
popup.title = 'Using setting ...'
popup.content.value = 40
user_info['name'] = self.user_setting.data['name']
user_info['pubkey'] = self.user_setting.data['pubkey']
time.sleep(.1)
popup.title = 'Start server ...'
popup.content.value = 60
if self.server.start_server():
time.sleep(.1)
popup.title = 'Start succeed ...'
popup.content.value = 80
time.sleep(.1)
popup.title = 'Open client ...'
popup.content.value = 100
self.to_client('left')
popup.dismiss()
else:
time.sleep(.1)
popup.title = 'Start failed ...'
popup.content.value = 80
time.sleep(.1)
popup.title = 'Open server ...'
popup.content.value = 100
self.to_server('left')
popup.dismiss()
def send_message(self):
"""发送信息"""
message = self.client.ids.ti_message.text
if len(message) == 0: # 输入为空 返回
return
if self.client.ids.t_address.text != 'All Nodes':
t_name, url = self.client.ids.t_address.text.split(
' @ ') # 获取用户名和链接
if self.post_request(url, message):
messages.append(
'To [%s] \n ' % t_name + '[ %s ]\n ' % message +
time.strftime("%H:%M:%S %Y-%m-%d", time.localtime()))
self.client.ids.ti_message.text = ''
else:
messages.append('To [%s] \n ' % t_name + 'Failed!!! ')
else: # 发送给所有节点
for node in nodes:
t_name = node['name']
url = node['address']
if self.post_request(url, message):
messages.append(
'To [%s] \n ' % t_name + '[ %s ]\n ' % message +
time.strftime("%H:%M:%S %Y-%m-%d", time.localtime()))
self.client.ids.ti_message.text = ''
else:
messages.append('To [%s] \n ' % t_name + 'Failed!!! ')
def post_request(self, url, data):
"""发送POST请求"""
try:
conn = HTTPConnection(url)
params = urllib.parse.urlencode({'data': data})
headers = {
'Content-type': 'application/x-www-form-urlencoded',
'Accept': 'text/plain'
}
conn.request('POST', "/", params, headers)
r1 = conn.getresponse()
data = json.loads(r1.read())
# print(data)
if data['result'] == 'OK':
return True
except Exception as e:
logs.append("Error: %s\n" % str(e) +
time.strftime("%H:%M:%S %Y-%m-%d", time.localtime()))
return False
def open_help(self):
"""打开帮助弹窗"""
pass
def encrypt_message(self, message):
"""加密信息"""
pass
@property
def user_fn(self):
return join('./', 'user.json')
class SwitchContainer(MDBoxLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
#管理器
self.screen_manager = ScreenManager()
self.add_widget(self.screen_manager)
self.page_list = []
#事件循环
self.event = Clock.schedule_interval(self.Start, 5)
def AddPage(self, page_name, page):
'''
说明: 添加一个页面来显示
args{
page_name: 屏幕的名字
page:要显示的内容(控件,非Screen)
}
return:
'''
screen = Screen(name=page_name)
screen.add_widget(page)
self.page_list.append(page_name)
self.screen_manager.add_widget(screen)
self.screen_manager.current = page_name
def DeletePage(self, page_name):
'''
说明:
args{
page_name: 要移除的屏幕的名字
}
return:
'''
if self.screen_manager.has_screen(page_name):
page = self.screen_manager.get_screen(page_name)
self.screen_manager.remove_widget(page)
self.page_list.remove(page_name)
def DeleteAll(self):
'''
说明: 移除全部屏幕
args{
}
return:
'''
while len(self.page_list):
self.DeletePage(self.page_list[0])
def Start(self, *args):
'''
说明: 循环事件
args{
}
return:
'''
if len(self.page_list) > 1:
index = (self.page_list.index(self.screen_manager.current) +
1) % len(self.page_list)
self.screen_manager.current = self.page_list[index]
class DWMBarberShop(App):
selected_attrs = []
def viewing(self, bx):
count = 0
for entry in data:
if count > 10:
return
s = ", ".join(entry)
s = s + "\n"
bx.add_widget(Label(text=s))
count += 1
def them_buttons(self, ref, ref2):
self.ref2 = ref2
a = [
"Hair Style Name",
"Normal Price (N$)",
"Barber",
"Weather",
"Environment Noise Level",
"Head Shape",
"Customer Reaction",
"Discount Percent",
"Age Group",
"Pre Hair Length",
"Physical Height (m)",
"Body Mass (kg)", # in age group +/- 5
"Date (DDMMYYYY)",
"Client Skin Tone",
"Styling Time (minutes)", # in style +/- 10
]
for n in a:
ref.add_widget(Button(text=n, on_release=self.btn_action))
def btn_action(self, bt):
self.selected_attrs.append(bt.text)
self.ref2.add_widget(Label(text=bt.text))
def show_patterns(self):
s = ""
for n in self.selected_attrs:
s += f'"{n}" '
import os
a = os.path.join(os.getcwd(), "correlation_.py")
f = a + " " + s
print(f)
subprocess.Popen(f, close_fds=True, shell=True)
def open_visualisation(self, p):
subprocess.Popen("python " + p, close_fds=True)
def build(self):
self.sm = ScreenManager()
self.sm.add_widget(MainScreen(name="main"))
return self.sm
def manage_screens(self, screen_name, action):
scns = {
"main": MainScreen,
"correlation_attributes": Factory.CorrelationAttributes,
"view_data": Factory.ViewData,
}
if action == "remove":
if self.sm.has_screen(screen_name):
self.sm.remove_widget(self.sm.get_screen(screen_name))
# print("Screen ["+screen_name+"] removed")
elif action == "add":
if self.sm.has_screen(screen_name):
print("Screen [" + screen_name + "] already exists")
else:
self.sm.add_widget(scns[screen_name](name=screen_name))
print(screen_name + " added")
# print("Screen ["+screen_name+"] added")
def change_screen(self, screen_name):
if self.sm.has_screen(screen_name):
self.sm.current = screen_name
else:
print("Screen [" + screen_name + "] does not exist.")
class Emp(MDApp):
job_list = ListProperty() # contains data needed to display job list cards
category_list = ListProperty(
) # contains data needed to display job list cards
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.title = "Namibia Job Hunt"
self.theme_cls.primary_palette = "DeepPurple"
self.theme_cls.theme_style = "Light"
self.sm = ScreenManager()
self.has_animated_card = False
self.has_animated_background = False
def account_action(self, email, passwd, username=None, action=None):
print(email, passwd, username, action)
if action == "register":
pass
# register the user
elif action == "login":
# login the user
pass
self.manage_screens("home_screen", "add")
self.change_screen("home_screen")
def animate_background(self, widget):
if self.has_animated_background == False:
anim = Animation(size_hint_y=1) + Animation(size_hint_y=0.5)
anim.start(widget.ids.bx)
print("background animated")
else:
print("background already animated")
def animate_card(self, widget):
# {"center_x": 0.5, "center_y": 0.6}
if self.has_animated_card == False:
anim = Animation(pos_hint={
"center_x": 0.5,
"center_y": 0.6
},
duration=2)
anim.start(widget)
self.has_animated_card = True
print("card animated")
else:
print("card already animated")
def change_screen(self, screen_name):
if self.sm.has_screen(screen_name):
self.sm.current = screen_name
else:
print("Screen [" + screen_name + "] does not exist.")
def manage_screens(self, screen_name, action):
scns = {
"login_screen": Factory.LoginScreen,
"registration_screen": Factory.RegistrationScreen,
"home_screen": Factory.HomeScreen,
"job_list_screen": Factory.JobListScreen
}
try:
if action == "remove":
if self.sm.has_screen(screen_name):
self.sm.remove_widget(self.sm.get_screen(screen_name))
print("Screen [" + screen_name + "] removed")
elif action == "add":
if self.sm.has_screen(screen_name):
print("Screen [" + screen_name + "] already exists")
else:
self.sm.add_widget(scns[screen_name](name=screen_name))
print(screen_name + " added")
print("Screen [" + screen_name + "] added")
except:
print(traceback.format_exc())
print("Traceback ^.^")
def on_pause(self):
return True
def on_resume(self):
pass
def build(self):
self.bind(on_start=self.post_build_init)
self.sm.add_widget(Factory.LoginScreen())
# self.sm.add_widget(HomeScreen(name="home_screen"))
# self.sm.current = "login_screen"
return self.sm
def post_build_init(self, ev):
win = self._app_window
win.bind(on_keyboard=self._key_handler)
def _key_handler(self, *args):
key = args[1]
# 1000 is "back" on Android
# 27 is "escape" on computers
if key in (1000, 27):
try:
self.sm.current_screen.dispatch("on_back_pressed")
except Exception as e:
print(e)
return True
elif key == 1001:
try:
self.sm.current_screen.dispatch("on_menu_pressed")
except Exception as e:
print(e)
return True
class Main(MDApp):
def build(self):
global screens
Builder.load_file("tmlayout.kv")
self.sm = ScreenManager(transition=NoTransition())
screens = list()
screens.append(Main_info(name="MainInfo"))
screens.append(sub_new_activity(name="subNewActivity"))
screens.append(activity_timer(name="activitytimer"))
for i in range(len(screens)):
self.sm.add_widget(screens[i])
screens[i].uxids_dict_add(screens)
print("potato" + str(screens))
self.theme_cls.primary_palette = "Blue"
print("0current Screen: " + str(self.sm.current_screen) + " | has the next screen? " +str(self.sm.has_screen("MainInfo")))
self.sm.switch_to(screens[0])
return self.sm
class ProjetoApp(App):
construir_medidas_com_historico = False
dados = Dados()
# dados.gera_data_bases()
icon = "imagens/icone.png"
kv_file = "projeto.kv"
def on_start(self):
pass
def build(self):
self.manager = ScreenManager()
self.constroi_tela_home()
self.constroi_tela_inserir_constantes("simples")
self.constroi_tela_inserir_constantes("duplo")
self.constroi_tela_sobre()
# self.constroi_tela_historico()
self.manager.ids["circuito_simples_botao_ok"].bind(
on_release=self.button_circuito_botao_ok("simples"))
self.manager.ids["circuito_duplo_botao_ok"].bind(
on_release=self.button_circuito_botao_ok("duplo"))
# self.manager.current = "circuito_simples"
return self.manager
def vai_para_tela(self, nome: str):
def dentro(*args):
self.manager.current = nome
return dentro
def button_circuito_botao_ok(self, tipo: str):
def funcao_dentro(*args):
self.ler_entrada_dados(tipo)
self.tela_anterior = f"circuito_{tipo}"
return funcao_dentro
def button_circuito_duplo_botao_ok(self, button):
self.ler_entrada_dados("duplo")
self.tela_anterior = "circuito_duplo"
def button_circuito_simples_botao_ok(self, button):
self.ler_entrada_dados("simples")
self.tela_anterior = "circuito_simples"
def button_voltar_home(self, button):
self.manager.current = "home"
def button_voltar_home_e_apaga_insercoes(self, tipo):
distancias = [""] * 3
constantes = [tipo] + [""] * len(NOMES_CONSTANTES[tipo][:-2]) + ["0"]
def funcao_interna(*argsv):
self.constroi_telas_a_partir_do_historico(constantes, distancias)
self.manager.current = "home"
return funcao_interna
def button_home_circuito_duplo(self, button):
self.construir_medidas_com_historico = False
self.constroi_tela_inserir_constantes("duplo")
def button_home_circuito_simples(self, button):
self.construir_medidas_com_historico = False
self.constroi_tela_inserir_constantes("simples")
def button_home_historico(self, button):
self.constroi_tela_historico()
def button_botoes_historico(self, button):
key = button.key
dados = self.dados.ler_do_banco_dados()[key]
# print(f"Botao {key}, Valor: {dados}")
constantes, distancias = dados
self.constroi_telas_a_partir_do_historico(constantes[2:],
distancias[1:])
def button_inserir_distancias_botao_voltar(self, button):
self.manager.current = self.tela_anterior
def button_inserir_distancias_botao_ok(self, button):
self.ler_entrada_distancias()
def button_home_sair(self, *args, **kwargs):
# print("chamou")
tela: TelaHome = self.manager.get_screen("home")
tela.confirmacao_saida()
return True
def button_historico_botao_limpar(self, button):
# print("limpando banco de dados")
box = BoxLayout(orientation="vertical", padding="10sp", spacing="10sp")
botoes = BoxLayout(padding="10sp", spacing="10sp")
pop = Popup(title="Deseja Limpar o Histórico?",
content=box,
title_size="25sp",
size_hint=(.5, .35))
pop.opacity = .85
imagem = Image(source="./imagens/atencao.png")
def limpa_e_recarrega_hitorico(*args):
self.dados.gera_data_bases()
self.constroi_tela_historico()
pop.dismiss()
sim = PopButton(text="sim",
font_size="20sp",
on_release=limpa_e_recarrega_hitorico)
nao = PopButton(text="nao", font_size="20sp", on_release=pop.dismiss)
botoes.add_widget(sim)
botoes.add_widget(nao)
box.add_widget(imagem)
box.add_widget(botoes)
pop.open()
# self.dados.gera_data_bases()
# self.constroi_tela_historico()
def button_relatorio_voltar(self, button):
self.manager.current = self.tela_anterior
def constroi_telas_a_partir_do_historico(self, constantes, distancias):
tipo = constantes[0]
nome = f"circuito_{tipo}" + "_{}"
nomes_constantes = NOMES_CONSTANTES[tipo]
for txt, cons in zip(constantes[1:], nomes_constantes[1:]):
if cons == "CONDUTORES_SIMETRICOS":
self.manager.ids[nome.format(cons)].active = int(txt)
continue
self.manager.ids[nome.format(cons)].text = str(txt)
self.manager.current = f"circuito_{tipo}"
self.construir_medidas_com_historico = True
self._distancias = distancias
def constroi_tela_home(self):
screen = TelaHome(name="home")
home = TelaHomeWidget(Window.size)
for chave, valor in home.ids.items():
self.manager.ids[chave] = valor
screen.add_widget(home)
self.manager.add_widget(screen)
self.manager.ids["home_circuito_simples"].bind(
on_release=self.button_home_circuito_simples)
self.manager.ids["home_circuito_duplo"].bind(
on_release=self.button_home_circuito_duplo)
self.manager.ids["home_historico"].bind(
on_release=self.button_home_historico)
self.manager.ids["home_sobre"].bind(
on_release=self.vai_para_tela("sobre"))
self.manager.ids["home_sair"].bind(on_release=self.button_home_sair)
def constroi_tela_historico(self):
nome_tela = "historico"
if self.manager.has_screen(nome_tela):
screen = self.manager.get_screen(nome_tela)
screen.canvas.clear()
else:
screen = Screen(name=nome_tela)
self.manager.add_widget(screen)
historico = HistoricoWidget(Window.size, self.dados)
try:
historico.ids['historico_botao_voltar'].bind(
on_release=self.button_voltar_home)
historico.ids['historico_botao_limpar'].bind(
on_release=self.button_historico_botao_limpar)
except:
pass
for chave, valor in historico.ids.items():
if valor.__class__.__name__.endswith("HistoricoButton"):
valor.bind(on_press=self.button_botoes_historico)
screen.add_widget(historico)
self.manager.current = nome_tela
def constroi_tela_inserir_constantes(self, tipo):
assert isinstance(tipo, str)
nome_tela = f"circuito_{tipo}"
if self.manager.has_screen(nome_tela):
self.manager.current = nome_tela
return
screen = Screen(name=nome_tela)
nomes = NOMES_CONSTANTES[tipo]
tela_inserir = TelaInserirWidget(
Window.size,
nome_tela,
nomes[1:],
titulo=f"Dados para Circuito {tipo}".title())
screen.add_widget(tela_inserir)
self.manager.add_widget(screen)
for chave, valor in tela_inserir.ids.items():
self.manager.ids[chave] = valor
self.manager.ids[f"{nome_tela}_botao_voltar"].bind(
on_release=self.button_voltar_home)
def constroi_tela_inserir_medidas(self, numero_condutores):
nome_tela = "inserir_distancias"
if self.manager.has_screen(nome_tela):
screen = self.manager.get_screen(nome_tela)
screen.canvas.clear()
else:
screen = Screen(name=nome_tela)
self.manager.add_widget(screen)
simetria = int(self.constantes_lidas[-1])
if simetria:
if numero_condutores > 4:
raise NotImplementedError(
"Codigo no modulo Calculos nao implementado ... Parando ainda no modulo main"
)
nomes_campos = ["Distancia entre os contutores"]
keys = ["TEXT_INPUT"]
else:
nomes_campos = [
f"Distancia entre os cabos {i+1} e {j+1}"
for i in range(numero_condutores)
for j in range(i + 1, numero_condutores)
]
keys = [f"TEXT_INPUT{i}" for i, j in enumerate(nomes_campos)]
inserir = TelaInserirWidget(Window.size,
nome_tela,
nomes_campos,
"Entre com as distancias".title(),
keys=keys)
screen.add_widget(inserir)
n = 0
for chave, valor in inserir.ids.items():
if self.construir_medidas_com_historico and "TEXT_INPUT" in chave:
try:
valor.text = str(self._distancias[n])
except:
valor.text = ""
n += 1
self.manager.ids[chave] = valor
self.manager.ids[f"{nome_tela}_botao_voltar"].bind(
on_release=self.button_inserir_distancias_botao_voltar)
self.manager.ids[f"{nome_tela}_botao_ok"].bind(
on_release=self.button_inserir_distancias_botao_ok)
# self.manager.current = nome_tela
def constroi_tela_sobre(self):
nome_tela = "sobre"
screen = Screen(name=nome_tela)
dados = [[
"Programa desenvolvido pelos estudantes",
], ["Danilo C Nascimento", "*****@*****.**"],
["Kaio Nascimento", "*****@*****.**"],
["Shamella Castro", "*****@*****.**"]]
tela = TelaSobreWidget(titulo="Sobre os Desenvolvedores", dados=dados)
tela.ids["sobre_botao_voltar"].bind(
on_release=self.vai_para_tela("home"))
screen.add_widget(tela)
self.manager.add_widget(screen)
def constroi_tela_gera_relatorio(self):
# print("Aqui serão gerados os relatórios")
nomes = self.dados.get_valores_de_um_campo("NOME")
if self.NOME not in nomes:
self.dados.salva_no_banco_dados([
self.constantes_lidas_para_salvar,
self.distancias_lidas_para_salvar
])
nome_tela = "gera_relatorio"
if self.manager.has_screen(nome_tela):
screen = self.manager.get_screen(nome_tela)
screen.canvas.clear()
else:
screen = Screen(name=nome_tela)
self.manager.add_widget(screen)
#Execura os calculos
calculos = Calculos(self.constantes_lidas, self.distancias_lidas)
indutancia = calculos.calculo_indutancia()
capacitancia = calculos.calculo_capacitancia(True)
lista_tratada = []
unidade = "H/m H Ω/m Ω F/m F Ω/m Ω S".split()
num = unidades.para_notacao_cientifica(indutancia[1], unidade[1], 4)
for i, numero in enumerate(list(indutancia) + list(capacitancia)):
try:
num = unidades.para_notacao_cientifica(numero, unidade[i], 4)
num = str(num).replace(".", ",")
lista_tratada.append(num)
except Exception as e:
lista_tratada.append(numero)
print("Erro", e)
descricao = "Indutancia,Indutancia_Total,Reatancia_Indutiva,Reatancia Indutiva Total".split(
",")
descricao += "Capacitancia,Capacitancia Total,Reatancia Capacitiva,Reatancia Capacitiva Total, Susceptancia Capacitiva".split(
",")
dic = [(f"Descrição {i}", f"Valor {i}") for i in range(1, 20)]
valores = list(zip(descricao, lista_tratada))
#print(valores)
dic = dict(valores)
for i in range(1, 4):
txt = " " * i
dic[txt] = ""
relatorio = GeraRelatorioWidget(Window.size, nome_tela, "Relatórios",
dic)
relatorio.ids[f"{nome_tela}_botao_voltar"].bind(
on_release=self.button_relatorio_voltar)
tipo = self.constantes_lidas[0]
relatorio.ids[f"{nome_tela}_botao_home"].bind(
on_release=self.button_voltar_home_e_apaga_insercoes(tipo))
screen.add_widget(relatorio)
self.manager.current = nome_tela
def ler_entrada_dados(self, tipo: str):
"""
:param tipo: str ["simples", "duplo", "medidas"]
:param constantes: list
:return: list
"""
numero_condutores = 0
if tipo == "simples":
constantes = NOMES_CONSTANTES["simples"]
elif tipo == "duplo":
constantes = NOMES_CONSTANTES["duplo"]
else:
texto = f"tipo nao percence a " + ", \"{}\"" * 3
raise ValueError(texto.format("simples", "duplo"))
constantes_lidas = []
self.constantes_lidas_para_salvar = [tipo]
logs = []
texto_log = "O campo [b]{}[/b] {}"
simetria = False
nome_tela = "obtem_medidas"
if tipo != "medidas":
constantes_lidas = [tipo] # [f"\"{tipo}\""]
nome_tela = f"circuito_{tipo}"
for nome in constantes[1:]:
id = f"{nome_tela}_{nome}"
texto_label = " ".join(nome.split("_"))
if nome == "CONDUTORES_SIMETRICOS":
if self.manager.ids[id].active:
lido = "1"
simetria = True
else:
lido = "0"
simetria = False
constantes_lidas.append(lido)
self.constantes_lidas_para_salvar.append(lido)
continue
lido = str(self.manager.ids[id].text)
self.constantes_lidas_para_salvar.append(lido)
lido = lido.replace(",", ".")
try:
lido = unidades.de_notacao_cientifica(lido)
lido = str(lido)
except:
pass
if lido == "":
logs.append(texto_log.format(texto_label, "está vazio"))
elif nome == "NUMERO_CONDUTORES":
try:
lido = int(lido)
numero_condutores = lido
if lido <= 0:
logs.append(
texto_log.format(texto_label,
"deve ser maior que 0"))
if lido > 15:
logs.append(
texto_log.format(texto_label,
"deve ser menor ou igual a 15"))
except:
logs.append(texto_log.format(texto_label, "não é inteiro"))
elif nome != "NOME":
try:
lido = float(lido)
except:
logs.append(texto_log.format(texto_label, "não é real"))
constantes_lidas.append(lido)
self.NOME = constantes_lidas[1]
if simetria and numero_condutores > 4:
logs.append(
"Ainda não há implementação para calculos com mais de 4 consdutores simétricos"
)
if logs:
popup = LogPopup(Window.size, logs, opacity=.75)
popup.open()
elif numero_condutores > 1:
self.constantes_lidas = constantes_lidas
self.constroi_tela_inserir_medidas(numero_condutores)
self.numero_condutores = numero_condutores
self.manager.current = "inserir_distancias"
elif numero_condutores == 1:
self.distancias_lidas = []
self.constantes_lidas = constantes_lidas
self.constroi_tela_gera_relatorio()
def ler_entrada_distancias(self):
nome_tela = "inserir_distancias"
simetria = int(self.constantes_lidas[-1])
if simetria:
if self.numero_condutores > 4:
raise NotImplementedError(
"Codigo no modulo Calculos nao implementado ... Parando ainda no modulo main"
)
nomes_campos = ["Distancia entre os contutores"]
keys = ["TEXT_INPUT"]
else:
nomes_campos = [
f"Distancia entre os cabos {i + 1} e {j + 1}"
for i in range(self.numero_condutores)
for j in range(i + 1, self.numero_condutores)
]
keys = [f"TEXT_INPUT{i}" for i, j in enumerate(nomes_campos)]
distancias_lidas = []
self.distancias_lidas_para_salvar = []
logs = []
texto_log = "O campo [b]{}[/b] {}"
for nome, campo in zip(keys, nomes_campos):
lido = str(self.manager.ids[f"{nome_tela}_{nome}"].text)
self.distancias_lidas_para_salvar.append(lido)
lido = lido.replace(",", ".")
try:
lido = unidades.de_notacao_cientifica(lido)
lido = str(lido)
except:
...
if lido == "":
logs.append(texto_log.format(campo, "está vazio"))
else:
try:
lido = float(lido)
except:
logs.append(texto_log.format(campo, "nao é real"))
distancias_lidas.append(lido)
# print(distancias_lidas)
self.distancias_lidas = distancias_lidas
if logs:
popup = LogPopup(Window.size, logs, opacity=.75)
popup.open()
else:
self.distancias_lidas = distancias_lidas
self.constroi_tela_gera_relatorio()
