class CelticKnotwork(App):
'''Main tabbed interface, each tab contains its own instance of CelticKnotwork2'''
def build(self):
##Instance Variables
self.showDots = True
self.showGrid = True
self.showBreaklines = True
self.showSkeleton = True
self.showKnot = True
self.knotX = 4
self.knotY = 4
self.knotWidth = 8
self.knotWidthView = 8
self.gridUnits = 50
self.gridUnitsView = 50
self.offsetX = 150
self.offsetY = 50
self.totTabs = 1
self.tabNo = 1
##Main Layout
self.layout_main = AnchorLayout(anchor_x = "left", anchor_y="top")
self.layout_tabs= FloatLayout(size=(Window.width, Window.height), size_hint=(0.1, 0.08))
##Top Tab Bar - allowing multiple knots
self.tp = TabbedPanel()
self.tp.default_tab_text = "Knot 1"
self.layout_main.add_widget(self.tp)
self.addTab = TabbedPanelHeader(text='+')
self.addTab.bind(on_release = self.onPressAddTab)
self.addTab = Button(text='+', pos =(Window.width*.9,Window.height*.92))
self.addTab.bind(on_press = self.onPressAddTab)
self.tp.default_tab_content = CelticKnotwork2().build() #get tab content from CelticKnotwork2
self.layout_tabs.add_widget(self.addTab)
self.layout_main.add_widget(self.layout_tabs)
Window.bind(on_resize=self.on_resize)
return self.layout_main
def onPressAddTab(self, instance):
'''Add a tab when "+" button pressed'''
self.totTabs += 1
self.tabNo = self.totTabs
self.th = TabbedPanelHeader(text='Knot '+str(self.totTabs))
self.th.content = CelticKnotwork2().build()
self.tp.add_widget(self.th)
self.tp.switch_to(self.th)
def on_resize(self, window, height, somethingesle):
'''Handles window resize'''
self.layout_main.remove_widget(self.layout_tabs)
self.layout_tabs= FloatLayout(size=(Window.width, Window.height), size_hint=(0.1, 0.05))
self.addTab = Button(text='+', pos =(Window.width*.9,Window.height*.95))
self.addTab.bind(on_press = self.onPressAddTab)
self.layout_tabs.add_widget(self.addTab)
self.layout_main.add_widget(self.layout_tabs)
class Info(Label):
'''put some info on screen'''
def __init__(self, root):
self.layout = AnchorLayout(anchor_x='center', anchor_y='center')
self.infotext = Label(text='Your turn, pick a card from Deck or Pit.')
self.layout.add_widget(self.infotext)
root.add_widget(self.layout)
def showinfo(self, txt):
self.layout.remove_widget(self.infotext)
self.infotext = Label(text=txt)
self.layout.add_widget(self.infotext)
class ToolSelectFunction(Spinner):
def __init__(self, **kwargs):
self.map_pars = {}
self.bubble = None
self.bubb_layout = None
self.button = None
self.func_des = None
self.background_color = (0.46, 0.46, 0.46, 0.6)
super(ToolSelectFunction, self).__init__(**kwargs)
def _on_dropdown_select(self, instance, data, *largs):
self.text = data
self.is_open = False
#print('select function',self.text)
self.func_des = '[color=#ffff00][i][b]' + self.parent.tool_library.read_obj.get_func_des(
self.text) + '[/i][/b][/color]'
self.set_select_parameter(self.text)
if self.bubble is None:
self.bubble = Bubble(size_hint=(.3, .2))
self.bubb_layout = AnchorLayout(anchor_x='right', anchor_y='top')
def remove_bubble(instance):
self.bubb_layout.remove_widget(self.bubble)
self.parent.parent.remove_widget(self.bubb_layout)
self.bubble = None
self.bubb_layout = None
self.button = BubbleButton(text=self.func_des,
halign='left',
valign='middle',
text_size=(300, 300),
background_color=(0, 0, 1, 1),
markup=True)
self.button.bind(on_press=remove_bubble)
self.bubble.add_widget(self.button)
self.bubble.arrow_pos = 'top_mid'
self.bubb_layout.add_widget(self.bubble)
self.parent.parent.parent.add_widget(self.bubb_layout)
else:
self.button.text = self.func_des
def set_select_parameter(self, function):
self.parent.tool_parameter.text = 'Select Parameter'
self.map_pars = self.parent.tool_library.read_obj.get_pars_type(
function)
#print('map_pars',map_pars)
self.parent.tool_parameter.values = self.map_pars.keys()
class DatabaseChat(App):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.entry_log = TextInput()
self.entry_pass = TextInput(password=True)
self.al = AnchorLayout()
self.bl = BoxLayout(orientation='vertical', size_hint=[.7, .2])
self.bl2 = BoxLayout(orientation='vertical')
self.bl_buttons = BoxLayout(orientation='horizontal')
self.entry_msg = TextInput(size_hint=[.1, .05])
self.entry_id = TextInput(size_hint=[.015, .05])
self.msg_box = TextInput()
def login(self, instance):
# regenerate_keys()
if login(self.entry_log.text, self.entry_pass.text):
self.al.remove_widget(self.bl)
self.al.add_widget(self.msg_box)
self.al.add_widget(self.bl2)
get_message(self.msg_box)
return self.al
def register(self, instance):
# create_tables()
register(self.entry_log.text, self.entry_pass.text)
def send_message(self, instance):
send_message(self.entry_id.text, self.entry_msg.text)
self.entry_msg.text = ''
# self.msg_box.text += '\n' + self.entry_msg.text
def build(self):
self.bl.add_widget(self.entry_log, self.entry_pass)
self.bl.add_widget(self.entry_pass)
self.bl.add_widget(Button(text='LOGIN', on_press=self.login))
self.bl.add_widget(Button(text='REGISTER', on_press=self.register))
self.al.add_widget(self.bl)
self.bl_buttons.add_widget(self.entry_id)
self.bl_buttons.add_widget(self.entry_msg)
self.bl2.add_widget(self.bl_buttons)
self.bl2.add_widget(
Button(text='SEND',
on_press=self.send_message,
size_hint=[.999, .05]))
return self.al
class VictoryScreen(Screen):
minutes = int()
seconds = int()
order = ''
leaderboard_button_visible = True
def __init__(self, theme, **kwargs):
super(VictoryScreen, self).__init__(**kwargs)
self.theme = theme
self.name_adder = NameAdder(theme=theme)
self.root = AnchorLayout(anchor_x='center', anchor_y='center')
# make a green line on the ground (to have some style on the winners page ;))
with self.root.canvas:
self.color = Color(0, 255, 0, 1)
self.line = Line(points=[50, 50, Window.width - 50, 50])
self.root.bind(pos=self.redraw, size=self.redraw)
self.anchor = AnchorLayout(anchor_x='center', anchor_y='center')
self.box = BoxLayout(orientation='vertical',
size_hint=[1, None],
size=[10, 210])
self.box.bind(minimum_size=self.box.setter('size'))
self.paused_label = Label(text='Victory',
font_size='50sp',
font_name='gothic',
color=theme.get_secondary(),
halign='center',
valign='bottom',
padding_y=10,
size_hint=[1, None],
size=[150, 60])
self.paused_label.bind(size=self.paused_label.setter('text_size'))
self.box.add_widget(self.paused_label)
self.info = Label(text='dummy',
font_size='25sp',
font_name='gothic',
color=theme.get_secondary(),
halign='center',
valign='bottom',
padding_y=15,
size_hint=[1, None],
size=[150, 40])
self.info.bind(size=self.info.setter('text_size'))
self.box.add_widget(self.info)
# the button to go to the menu screen
quit_layout = AnchorLayout(anchor_x='center',
anchor_y='top',
size_hint=[1, None],
size=[15, 65])
self.quit_button = Button(
text='Back to menu',
size_hint=[None, None],
size=[150, 50],
font_name='gothic',
font_size='16sp',
color=[0.9, 0.9, 0.9, 1],
padding_y=50,
background_normal=
f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_normal_{theme.current}.png',
background_down=
f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_pressed_{theme.current}.png',
on_release=lambda n: self.change_to_menu())
quit_layout.add_widget(self.quit_button)
self.box.add_widget(quit_layout)
# the add button for the leaderboard
self.to_leaderboard_layout = AnchorLayout(anchor_x='center',
anchor_y='bottom',
size_hint=[1, None],
size=[15, 70])
self.to_leaderboard_button = NameAdderButton(theme, self.box)
# add the bindings of the submit button (translate the data to the leaderboard)
self.to_leaderboard_button.name_adder.submit.on_release = lambda: self.add_to_leaderboard(
name=self.to_leaderboard_button.name_adder.input.text,
minutes=self.minutes,
seconds=self.seconds,
order=self.order)
self.to_leaderboard_layout.add_widget(self.to_leaderboard_button)
self.box.add_widget(self.to_leaderboard_layout)
self.anchor.add_widget(self.box)
self.root.add_widget(self.anchor)
self.add_widget(self.root)
def add_leaderboard_button(self):
if not self.leaderboard_button_visible:
self.to_leaderboard_layout.add_widget(self.to_leaderboard_button)
self.leaderboard_button_visible = True
def remove_leaderboard_button(self):
if self.leaderboard_button_visible:
self.to_leaderboard_layout.remove_widget(
self.to_leaderboard_button)
# remove also the the name adder field
self.to_leaderboard_button.reset_button()
self.leaderboard_button_visible = False
def add_to_leaderboard(self, name, minutes, seconds, order):
if not name == '':
print('Leaderboard entry: ', name, minutes, seconds, order)
self.manager.get_screen('leaderboard_screen').entries.append(
[name, minutes, seconds, order])
self.manager.get_screen('leaderboard_screen').update_list()
self.change_to_leaderboard()
def change_to_menu(self):
# reset the leaderboard button
self.to_leaderboard_button.reset_button()
self.manager.get_screen('game_screen').reset_game()
self.manager.current = 'menu_screen'
def change_to_leaderboard(self):
# reset the leaderboard button
self.to_leaderboard_button.reset_button()
self.manager.get_screen('game_screen').reset_game()
self.manager.current = 'leaderboard_screen'
def redraw(self, *args):
self.line.points = [50, 50, Window.width - 50, 50]
def apply_theme(self, theme):
self.paused_label.color = theme.get_secondary()
self.info.color = theme.get_secondary_accent()
self.to_leaderboard_button.name_adder.apply_theme(theme)
# recolor the button
self.quit_button.background_normal = f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_normal_{theme.current}.png'
self.quit_button.background_down = f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_pressed_{theme.current}.png'
self.to_leaderboard_button.background_down = f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_pressed_{theme.current}.png'
self.to_leaderboard_button.background_normal = f'C:/Users/Nutzer/PycharmProjects/Minesweeper/assets/img/buttons/button_normal_{theme.current}.png'
class BoardDisplay(FloatLayout):
"""Show the 4x2 Gameboard.
Methods:
update -- refresh the full display
highlight -- highlight every card on the board
place_card -- place and display the card on the board
remove_card -- remove card from the display and return it
validate -- remove and return a list of invalid cards
pop -- remove card at the given index and return it
play_dealer -- play all dealer cards with timing
apply_specials -- apply all specials with timing and highlights
score_round -- score each match with timing and highlights
"""
board = ObjectProperty()
def __init__(self, **kwargs):
"""Set up the CardDisplays."""
FloatLayout.__init__(self, **kwargs)
self.main = BoxLayout(orientation="vertical", pos_hint={'x':0, 'y':0})
self.slots = []
for i in range(len(self.board)): # for card in board iterates all sides
layout = BoxLayout()
side_slots = []
for card in self.board[i]:
display = CardDisplay(card=card)
side_slots.append(display)
layout.add_widget(display)
self.slots.append(side_slots)
self.main.add_widget(layout)
self.add_widget(self.main)
# Prep the next round prompt widget for later
self._next_round_prompt = BoxLayout(size_hint=(1, .125))
self._next_round_prompt.add_widget(Button(text="Replay",
on_release=self.rescore_prompted))
self._next_round_prompt.add_widget(Widget()) # spacer
self._next_round_prompt.add_widget(Button(text="Continue",
on_release=self.next_round_prompted))
# Prep for powerup overlays
self.powerup_anchor = AnchorLayout(anchor_x='right', anchor_y='top',
size_hint=(1, 1),
pos_hint={'x':0, 'y':0})
self.add_widget(self.powerup_anchor)
def show_next_click_powerup(self, powerup):
"""Display a large overlay of the powerup to select."""
try: self.remove_widget(self.powerup_overlay_single)
except: pass
if powerup is None:
self.highlight(BLANK)
else:
self.highlight(DARKEN)
self.powerup_overlay_single = PowerupIcon(powerup=powerup,
color=(1, 1, 1, .3),
size_hint=(.6, .6),
pos_hint={'x':.2, 'y':.2})
self.add_widget(self.powerup_overlay_single)
def show_active_powerups(self, powerups):
"""Display a series of active powerup icons."""
try: self.powerup_anchor.remove_widget(self.powerup_overlay_tray)
except: pass
if not powerups:
return
self.powerup_overlay_tray = tray = StackLayout(size_hint_y=0.1)
for powerup in powerups:
tray.add_widget(PowerupIcon(powerup=powerup,
color=(1, 1, 1, .5),
size_hint=(None, 1)))
tray.width = tray.height * len(powerups)
from kivy.graphics import Color, Rectangle
with tray.canvas.before:
Color((1, 0, 0, 1))
Rectangle(size=tray.size, pos=tray.pos)
self.powerup_anchor.add_widget(self.powerup_overlay_tray)
def prompt_for_next_round(self):
"""Prompt the user to continue, or replay the scoring sequence."""
try: self.main.add_widget(self._next_round_prompt)
except: pass
def next_round_prompted(self, *args):
"""Continue to the next round on the user's command."""
self.main.remove_widget(self._next_round_prompt)
return App.get_running_app().root.next_round()
def rescore_prompted(self, *args):
"""Replay the scoring animation on the user's command."""
self.main.remove_widget(self._next_round_prompt)
App.get_running_app().root.replay_scoring()
def update(self):
"""Update the visual display."""
for i in range(len(self.board)):
for j, card in enumerate(self.board[i]):
self.slots[i][j].card = None # force update
self.slots[i][j].card = card
self.slots[i][j].waited = self.board._wait[i][j]
try:
self.dealer_hand.update()
except AttributeError:
pass
def show_dealer_hand(self, hand):
"""Show the dealer's hand at the top of the screen."""
self.dealer_hand = HandDisplay(hand=hand)
self.main.add_widget(self.dealer_hand, len(self.children))
def hide_dealer_hand(self):
"""Remove the dealer's hand display."""
self.main.remove_widget(self.dealer_hand)
del self.dealer_hand
def highlight(self, color):
"""Update all highlight colors at once."""
for side in self.slots:
for display in side:
display.highlight(color)
def place_card(self, card, index=None, player=PLAYER):
"""Place the card on the board, including visually."""
if index is None:
index = self.board.play_cards(player, [card])[0]
else:
self.board[player][index] = card
self.slots[player][index].card = card
def remove_card(self, card_display):
"""Remove the card from the display and return it."""
try:
index = self.slots[PLAYER].index(card_display)
except ValueError:
return
card = self.board[PLAYER][index]
self.board[PLAYER][index] = None
card_display.card = None
return card
def validate(self):
"""Remove and return a list of any invalid cards."""
return [self.pop(i) for i in self.board.validate(self.board[PLAYER])]
def pop(self, i):
"""Remove and return the specified card."""
card = self.board[PLAYER][i]
self.board[PLAYER][i] = None
self.slots[PLAYER][i].card = None
return card
def find(self, display):
"""Return the (player, index) of this display."""
for i, side in enumerate(self.slots):
try:
return i, self.slots[i].index(display)
except ValueError: pass
raise ValueError("CardDisplay not found on board.")
def _find_display(self, card):
"""Return the slot holding this card."""
if isinstance(card, CardDisplay):
return card
for slot in self.slots[PLAYER]:
if slot.card is card:
return slot
raise ValueError
def swap(self, card1, card2):
"""Swap the two cards on the player's board."""
def index(c):
try:
t = self._find_display(c)
except ValueError:
return c
return self.slots[PLAYER].index(t)
c, d = index(card1), index(card2)
if not (isinstance(c, int) and isinstance(d, int)): return
self.board[PLAYER][c], self.board[PLAYER][d] = self.board[PLAYER][d], self.board[PLAYER][c]
self.slots[PLAYER][c].card, self.slots[PLAYER][d].card = self.slots[PLAYER][d].card, self.slots[PLAYER][c].card
## Auto-scoring (with breaks)
def play_dealer(self, cards, callback=None, timer=GameSettings.SPEED):
"""Automatically lay out the dealer's cards one by one."""
self.board.play_cards(DEALER, cards)
Clock.schedule_once(lambda t: self._play_next_dealer(callback=callback,
timer=timer))
def _play_next_dealer(self, index=None,
callback=None, timer=GameSettings.SPEED):
"""Place the next dealer card on the board."""
if index is None:
index = 0
else:
index += 1
if index >= len(self.board[0]):
if callback is not None:
Clock.schedule_once(lambda dt:callback())
return
self.slots[DEALER][index].card = self.board[DEALER][index]
if self.board._wait[DEALER][index]:
Clock.schedule_once(lambda t: self._play_next_dealer(index=index,
callback=callback,
timer=timer))
else:
Clock.schedule_once(lambda t: self._play_next_dealer(index=index,
callback=callback,
timer=timer),
timer)
def apply_specials(self, game, hand_display,
callback=None, timer=GameSettings.SPEED):
"""Apply all special cards in play, one-by-one with highlighting."""
self.highlight(DARKEN)
Clock.schedule_once(lambda t: self._apply_special(game, hand_display,
callback=callback,
timer=timer), timer)
def _apply_special(self, game, hand_display, player=None, index=None,
callback=None, timer=GameSettings.SPEED):
"""Apply the next special card, column by column."""
if index is None:
player, index = 0, 0
else:
self.slots[player][index].highlight(DARKEN)
player += 1
if player >= len(self.board):
player = 0
index += 1
if index >= len(self.board[0]):
Clock.schedule_once(lambda t: callback())
return
next_slot = lambda t: self._apply_special(game, hand_display,
player=player, index=index,
callback=callback,
timer=timer)
if (self.board[player][index] is None or
self.board[player][index].suit != SpecialSuit.SPECIAL):
Clock.schedule_once(next_slot)
return
self.slots[player][index].highlight(BLUE)
game._apply(player, index)
self.update()
if (player == PLAYER and
self.slots[player][index].card.effect.effect == EffectType.FLUSH):
hand_display.update()
Clock.schedule_once(next_slot, timer)
def score_round(self, score_display, index=None,
callback=None, timer=GameSettings.SPEED):
"""Score the given match, or all of them, with highlighting."""
if index is not None:
self._score_match(score_display, score_display.scoreboard, index)
Clock.schedule_once(lambda t: callback(), timer)
Clock.schedule_once(lambda t: self._score_next_match(score_display,
callback=callback,
timer=timer))
def _score_next_match(self, score_display, index=None,
callback=None, timer=GameSettings.SPEED):
"""Highlight and score the next match of the round."""
if index is None:
index = 0
else:
index += 1
if index >= len(self.board[0]):
Clock.schedule_once(lambda t: callback())
return
self._score_match(score_display, score_display.scoreboard, index)
Clock.schedule_once(lambda t: self._score_next_match(score_display,
index=index,
callback=callback,
timer=timer),
timer)
def _score_match(self, score_display, score, index):
"""Highlight and score the given match."""
for player in range(len(self.board)):
result = score._score_match(player, self.board[player][index],
player-1, self.board[player-1][index])
self.slots[player][index].highlight([WHITE, GREEN, RED][result])
score_display.update()
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 MyApp(App):
def build(self):
Config.set('graphics', 'width', '360')
Config.set('graphics', 'height', '640')
self.text = TextInput(multiline=False)
self.text.bind(on_text_validate=self.on_enter)
self.text.text_language = "kor"
self.text.font_size = '20sp'
self.text.hint_text = "Input what you want to paraphrase."
self.text.size_hint_y = None
self.text.height = 40
self.text.width = 120
self.anchor1 = AnchorLayout(anchor_x='center', anchor_y='center')
self.anchor1.orientation = 'vertical'
self.anchor1.add_widget(self.text)
self.anchor1.spacing = 30
self.boxLayout = BoxLayout()
canvas = self.boxLayout.canvas
with canvas:
Color(255., 250., 250)
Rectangle(size=(360, 640))
self.boxLayout.add_widget(self.anchor1)
self.anchor2 = AnchorLayout()
return self.boxLayout
def on_enter(self, instance):
print('User pressed enter in', self.text.text)
self.boxLayout.remove_widget(self.anchor2)
return self.trans(self.text.text)
def on_enter2(self, instance):
print('User pressed enter in', self.text.text)
self.result.remove_widget(self.text)
self.boxLayout.remove_widget(self.result)
self.boxLayout.remove_widget(self.anchor2)
return self.trans(self.text.text)
def trans(self, message):
tr = paraphrase.paraphrase()
trans = tr.manyResult(message) # paraphrase
if len(trans) > 18:
transL = 18
else:
transL = len(trans)
self.result = BoxLayout()
self.result.orientation = 'vertical'
self.result.height = 400
if transL > 10:
transL = 10
self.anchor1.remove_widget(self.text)
self.text.text = ''
self.text.bind(on_text_validate=self.on_enter2)
self.result.add_widget(self.text)
for i in range(0, transL):
button = Button(text=trans[i], background_color=(.255, .115, .115))
button.height = 30
self.result.add_widget(button)
self.anchor2.anchor_x = 'left'
self.anchor2.anchor_y = 'bottom'
self.anchor2.add_widget(self.result)
self.boxLayout.remove_widget(self.anchor1)
self.boxLayout.add_widget(self.anchor2)
return self.boxLayout
class EditBlockPage(BoxLayout):
def __init__(self, **kwargs):
super(EditBlockPage, self).__init__(**kwargs)
self.orientation = "vertical"
self.previous_screen = ""
# Title "Add/Edit Block" at top of page
self.title = Label(text="Add/Edit Block", font_size=25)
self.title.size_hint_y = None
self.title.height = 58
self.add_widget(self.title)
# Float layout for form
self.form = GridLayout(cols=2)
self.form.size_hint_y = None
self.form.height = 550
self.add_widget(self.form)
# Dropdown Selection
label = Label(text="Work/Break:", font_size=20)
self.form.add_widget(label)
self.dropdown = DropDown()
for item in ["Work", "Break"]:
btn = Button(text=item, size_hint_y=None, height=38)
btn.bind(on_release=lambda btn: self.dropdown.select(btn.text))
self.dropdown.add_widget(btn)
anchor = AnchorLayout(anchor_x='center', anchor_y='top')
self.dropbutton = Button(text='SELECT', size_hint_y=None, height=44)
self.dropbutton.bind(on_release=self.dropdown.open)
self.dropdown.bind(
on_select=lambda instance, x: setattr(self.dropbutton, 'text', x))
anchor.add_widget(self.dropbutton)
self.form.add_widget(anchor)
# Start Date
self.form.add_widget(Label(text="Start Date:", font_size=20))
self.start_date = DatePicker(size_hint_y=None, height=60)
self.start_date_anchor = AnchorLayout(anchor_x='center',
anchor_y='center')
self.start_date_anchor.add_widget(self.start_date)
self.form.add_widget(self.start_date_anchor)
# Start Time
self.form.add_widget(Label(text="Start Time:", font_size=20))
self.start_time = TimePicker(size_hint_y=None, height=60)
self.start_time_anchor = AnchorLayout(anchor_x='center',
anchor_y='center')
self.start_time_anchor.add_widget(self.start_time)
self.form.add_widget(self.start_time_anchor)
# End Date
self.form.add_widget(Label(text="End Date:", font_size=20))
self.end_date = DatePicker(size_hint_y=None, height=60)
self.end_date_anchor = AnchorLayout(anchor_x='center',
anchor_y='center')
self.end_date_anchor.add_widget(self.end_date)
self.form.add_widget(self.end_date_anchor)
# End Time
self.form.add_widget(Label(text="End Time:", font_size=20))
self.end_time = TimePicker(size_hint_y=None, height=60)
self.end_time_anchor = AnchorLayout(anchor_x='center',
anchor_y='center')
self.end_time_anchor.add_widget(self.end_time)
self.form.add_widget(self.end_time_anchor)
# Buttons
# self.button1 = Button(text="Add Tasks", font_size=20)
# self.button1.bind(on_press=self.button1_act)
# self.add_widget(self.button1)
self.button2 = Button(text="Specialized Denylist", font_size=20)
self.button2.bind(on_press=self.button2_act)
self.add_widget(self.button2)
self.button3 = Button(text="Submit", font_size=20)
self.button3.bind(on_press=self.button3_act)
self.add_widget(self.button3)
self.special_denylist = None
self.block = None
# Button 1 - Add Tasks
def button1_act(self, instance):
pass
# Button 2 - Specialized Denylist - go to Denylist screen
def button2_act(self, instance):
if self.block == None or self.block.denylist == None:
self.special_denylist = deepcopy(db.get_denylist())
nag_bot_app.denylist_page.gen_list(
specialized=self.special_denylist)
else:
nag_bot_app.denylist_page.gen_list(specialized=self.block.denylist)
nag_bot_app.screen_manager.transition.direction = 'left'
nag_bot_app.screen_manager.current = "Denylist"
nag_bot_app.denylist_page.previous_screen = "Edit Block"
pass
# Button 3 - Submit - add Block, return to previous screen
def button3_act(self, instance):
# add Block
if self.dropbutton.text != "SELECT":
start_date = self.start_date.text.split('.')
start_time = self.start_time.text.split(':')
end_date = self.end_date.text.split('.')
end_time = self.end_time.text.split(':')
for x in range(3):
start_date[x] = int(start_date[x])
start_time[x] = int(start_time[x])
end_date[x] = int(end_date[x])
end_time[x] = int(end_time[x])
type = self.dropbutton.text
start = datetime.datetime(start_date[2], start_date[0],
start_date[1], start_time[0],
start_time[1], start_time[1])
end = datetime.datetime(end_date[2], end_date[0], end_date[1],
end_time[0], end_time[1], end_time[1])
try:
if self.block != None:
print("Editing block")
db.edit_block(self.block.id, type, start, end)
db.save()
if self.block.denylist == None:
self.block.denylist = self.special_denylist
else:
block = db.add_block(type, start, end)
block.denylist = self.special_denylist
db.save()
print("Block Added")
except EndBeforeStart:
win32api.MessageBox(
0, '''NagBot: Cannot have block end before it starts.
The block will not be added.''', 'End Before Start',
0x00001000)
except OverlapsExisting:
win32api.MessageBox(
0, '''NagBot: The block you are attempting to add overlaps
with an existing block. The block will not be
added.''', 'Overlaps Existing', 0x00001000)
# return to previous screen
nag_bot_app.schedule_page.gen_schedule()
if self.block != None:
nag_bot_app.to_do_page.update_block(self.block)
nag_bot_app.screen_manager.transition.direction = 'right'
nag_bot_app.screen_manager.current = self.previous_screen
nag_bot_app.screen_manager.get_screen(
self.previous_screen).previous_screen = "Edit Block"
# reset form
def reset(self, date):
self.block = None
self.dropbutton.text = "SELECT"
self.start_date_anchor.remove_widget(self.start_date)
self.start_date = DatePicker(size_hint_y=None, height=60, date=date)
self.start_date_anchor.add_widget(self.start_date)
self.end_date_anchor.remove_widget(self.end_date)
self.end_date = DatePicker(size_hint_y=None, height=60, date=date)
self.end_date_anchor.add_widget(self.end_date)
def edit_block(self, block):
self.block = block
self.dropbutton.text = block.type
self.start_time.text = block.start.strftime("%H:%M:%S")
self.end_time.text = block.end.strftime("%H:%M:%S")
start_date = datetime.date(block.start.year, block.start.month,
block.start.day)
self.start_date_anchor.remove_widget(self.start_date)
self.start_date = DatePicker(size_hint_y=None,
height=60,
date=start_date)
self.start_date_anchor.add_widget(self.start_date)
end_date = datetime.date(block.end.year, block.end.month,
block.end.day)
self.end_date_anchor.remove_widget(self.end_date)
self.end_date = DatePicker(size_hint_y=None, height=60, date=end_date)
self.end_date_anchor.add_widget(self.end_date)
