def main():
"""
This is the main method which call the main screen consisting of the GUI
:return:nothing
"""
app = MainScreen()
app.display()
def __init__(self):
self.__Window = tkinter.Tk()
self.__Window.attributes('-fullscreen', self.__FullScreenState)
self.__Window.title('Identity Check')
self.__Window.bind("<F11>", self.__ToggleFullScreen)
self.__Window.bind("<Escape>", self.__QuitFullScreen)
self.__Window.bind('<q>', self.__QuitApplication)
self.__LockScreen = LockScreen(self.__Window)
self.__LockScreen.RaiseEvent = self.RaiseEvent
self.__MainScreen = MainScreen(self.__Window)
self.__MainScreen.RaiseEvent = self.RaiseEvent
def __init__(self, config, core):
super(FrontendAdafruitCharLCDPlate, self).__init__()
self.input_manager = InputManager()
self.display_object = DisplayObject()
if True:
import Adafruit_CharLCD as LCD
self.display = LCD.Adafruit_CharLCDPlate()
else:
from web_socket_lcd_simulator import WebSockectLCDSimulator
self.display = WebSockectLCDSimulator()
self.main_screen = MainScreen(core)
self.running = True
def main(self):
# load big resources first
cardPath = os.path.join(os.getcwd(), "res", "cardData.json")
allCardData = None
with open(cardPath, 'r', encoding="utf-8") as f:
allCardData = json.load(f)
# SET UP THE GRAPHICS WINDOW
window = sf.RenderWindow(sf.VideoMode(1100, 800), 'Mana Burn')
window.framerate_limit = 60
window.clear()
view = sf.View()
view.reset(sf.Rectangle((0, 0), (1100, 850)))
window.view = view
window.display()
# figure out the save game situation
currentSavedGame = SavedGame()
currentScreen = MainScreen(window, view, currentSavedGame, allCardData)
# A clock runs and cleans up dead objects periodically
cleanupClock = sf.Clock()
# THE UPDATE AND GAME LOOP
while window.is_open:
for event in window.events:
if type(event) is sf.CloseEvent:
window.close()
if type(event
) is sf.KeyEvent and event.code is sf.Keyboard.ESCAPE:
window.close()
if type(currentScreen) is MainScreen:
if type(event) is sf.MouseButtonEvent:
currentScreen.checkClicks(window, event)
if type(event) is sf.MouseWheelEvent:
currentScreen.checkScroll(window, event)
window.clear()
currentScreen.update()
window.display()
if cleanupClock.elapsed_time.seconds >= .5:
currentScreen.cleanUp()
cleanupClock.restart()
class Application:
__FullScreenState = True
def __init__(self):
self.__Window = tkinter.Tk()
self.__Window.attributes('-fullscreen', self.__FullScreenState)
self.__Window.title('Identity Check')
self.__Window.bind("<F11>", self.__ToggleFullScreen)
self.__Window.bind("<Escape>", self.__QuitFullScreen)
self.__Window.bind('<q>', self.__QuitApplication)
self.__LockScreen = LockScreen(self.__Window)
self.__LockScreen.RaiseEvent = self.RaiseEvent
self.__MainScreen = MainScreen(self.__Window)
self.__MainScreen.RaiseEvent = self.RaiseEvent
def RaiseEvent(self, _Event):
if _Event == 'LockScreen':
self.__MainScreen.Remove()
self.__LockScreen.Add()
else:
self.__LockScreen.Remove()
self.__MainScreen.Add()
def __ToggleFullScreen(self, _Event):
self.__FullScreenState = not self.__FullScreenState
self.__Window.attributes('-fullscreen', self.__FullScreenState)
def __QuitFullScreen(self, _Event):
self.__Window.attributes('-fullscreen', False)
def __QuitApplication(self, _Event):
exit()
def Start(self):
self.__LockScreen.Start()
self.__MainScreen.Start()
self.__Window.mainloop()
def __initializationFinished(self):
from MainScreen import MainScreen
if len(sys.argv) >= 2:
fn = sys.argv[1]
else:
fn = None
stdscr = self.mainScreen.stdscr
self.mainScreen = MainScreen(fn, None, (0,0))
self.mainScreen.stdscr = stdscr
self.__handleTerminalResize()
self.mainScreen.makeFirstResponder()
def build(self):
self.title = 'Text Translation'
self.sm = ScreenManager()
self.main_screen = MainScreen(name="main screen")
def move_to_main(session_id = 0):
self.sm.switch_to(self.main_screen)
self.main_screen.session_id = session_id
self.login_screen = LoginScreen(switch_main_callback=move_to_main, name="Login screen")
self.sm.switch_to(self.login_screen)
return self.sm
def __cursesWrapper(self, stdscr):
curses.curs_set(0) # No cursor
stdscr.nodelay(1) # getch returns immediately
stdscr.notimeout(1) # escape sequences come immediately
# Begin with the initialization screen
prefs = self.preferences
doneHandler = self.__initializationFinished
self.mainScreen = InitializationScreen(prefs, doneHandler, None, (0, 0))
self.mainScreen.stdscr = stdscr
# Make sure the terminal has enough space
self.__handleTerminalResize(False)
self.mainScreen.makeFirstResponder()
# Main runloop
while True:
# Notifications
Notification.handleNotifications()
# List of responders
c = stdscr.getch()
if c == -1:
continue
if c == curses.KEY_RESIZE:
self.__handleTerminalResize()
continue
r = self.mainScreen
responders = [r]
while True:
r = r.parentResponder
if r != None:
responders.append(r)
else:
break
# Top down
for i in range(len(responders)-1, -1, -1):
r = responders[i]
if r.activeModalSession() != None:
break
if r.respondsTo(c):
r.handleEvent(c)
break
# -*- coding: utf-8 -*- """ Created on Wed Jul 4 17:05:03 2018 @author: Sander Oosterveld """ import pygame from MainScreen import MainScreen from queue import Queue q = Queue() screen = MainScreen(q) musicFile = 'disturbed.ogg' pygame.mixer.init() pygame.mixer.music.load(musicFile) pygame.mixer.music.play() screen.start() pygame.mixer.quit()
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 31 18:42:53 2018
@author: Sander Oosterveld
"""
from MainScreen import MainScreen
from Alarm import Alarm, AlarmWidget
from queue import Queue
from Widget import TimeWidget, TextWidget, Position
from TimerObject import TimerObject
q = Queue()
screen = MainScreen(q)
screen.changeBackground('white')
alarm = Alarm("0700", "disturbed.ogg", True)
alarmWidget = AlarmWidget(screen, alarm)
timeWidget = TimeWidget(screen)
alarmWidget.make()
timeWidget.make()
timerObject = TimerObject(screen)
timerObject.addObject(screen.changeBackground, ("2300", -1), "black")
timerObject.addObject(screen.changeBackground, ("0630", -1), "white")
timerObject.addAlarm(alarm)
print(timerObject.getObjects())
alarm.setRepeat((1,2,3,4))
timerObject.updateAlarm(alarm)
print(timerObject.getObjects())
#timerObject.addObject(alarm.activate, ("0600", -1))
class FrontendAdafruitCharLCDPlate(pykka.ThreadingActor, core.CoreListener):
def __init__(self, config, core):
super(FrontendAdafruitCharLCDPlate, self).__init__()
self.input_manager = InputManager()
self.display_object = DisplayObject()
if True:
import Adafruit_CharLCD as LCD
self.display = LCD.Adafruit_CharLCDPlate()
else:
from web_socket_lcd_simulator import WebSockectLCDSimulator
self.display = WebSockectLCDSimulator()
self.main_screen = MainScreen(core)
self.running = True
def on_start(self):
# Add newline
self.display.set_color(1.0, 0.0, 0.0)
self.display.create_char(0, [16, 16, 16, 16, 16, 16, 0, 0])
self.display.create_char(1, [24, 24, 24, 24, 24, 24, 0, 0])
self.display.create_char(2, [28, 28, 28, 28, 28, 28, 0, 0])
self.display.create_char(3, [30, 30, 30, 30, 30, 30, 0, 0])
self.display.create_char(4, [31, 31, 31, 31, 31, 31, 0, 0])
try:
self.display.on_start()
except AttributeError:
pass
t = threading.Thread(target=self.start_working)
t.start()
def on_stop(self):
self.running = False
try:
self.display.on_stop()
except AttributeError:
pass
def send_screen_update(self):
self.display.clear()
self.display.message(self.display_object.getString())
def start_working(self):
while self.running:
self.update()
sleep(0.03)
def update(self):
# Check inputs
for event in self.input_manager.update(self.display):
print event
self.main_screen.input_event(event)
if self.main_screen.check_and_update(self.display_object, True) or self.display_object.update():
self.send_screen_update()
# Events
def playback_state_changed(self, old_state, new_state):
self.main_screen.playback_state_changed(old_state, new_state)
def track_playback_started(self, tl_track):
self.main_screen.track_playback_started(tl_track)
def track_playback_ended(self, tl_track, time_position):
self.main_screen.track_playback_ended(tl_track, time_position)
def track_playback_paused(self, tl_track, time_position):
self.main_screen.track_playback_paused(tl_track, time_position)
def track_playback_resumed(self, tl_track, time_position):
self.main_screen.track_playback_resumed(tl_track, time_position)
def seeked(self, time_position):
self.main_screen.seeked(time_position)
def volume_changed(self, volume):
self.main_screen.volume_changed(volume)
def stream_title_changed(self, title):
self.main_screen.stream_title_changed(title)
def playlists_loaded(self):
self.main_screen.playlists_loaded()
from kivy.core.window import Window
# This sets the window to size (800,800)
Window.size = (800, 700)
# Sets the colour of the window background
Window.clearcolor = (0.2, 0.2, 0.2, 0.5)
from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.lang import Builder
from MainScreen import MainScreen
from EditScreen import EditScreen
# Creates new instances of the MainScreen and EditScreen
MainScreen = MainScreen()
EditScreen = EditScreen()
# MapScreen class -- responsible for th
class MapScreen(Screen):
# Returns coordinates of mouse on the screen
def __init__(self, **kwargs):
super(MapScreen, self).__init__(**kwargs)
# Binds the mouse_pos() function to the window -- the coordinates of the mouse is continuously retrieved.
Window.bind(mouse_pos=self.mouse_pos)
# Done by Gan Shyan
# This function retrieves the coordinates of the mouse cursor on the map
def mouse_pos(self, window, pos):
self.ids.cursor_coordinate_id.text = "Cursor: " + str(pos)
class CursesApplication(object):
MIN_SIZE = (80,24)
def __init__(self):
pass
def run(self):
self.preferences = Preferences.Preferences()
try:
self.preferences.readPreferences()
except Preferences.PreferencesException as e:
print("An error occurred while parsing the preferences:",
e, file=sys.stderr)
return
curses.wrapper(self.__cursesWrapper)
def __cursesWrapper(self, stdscr):
curses.curs_set(0) # No cursor
stdscr.nodelay(1) # getch returns immediately
stdscr.notimeout(1) # escape sequences come immediately
# Begin with the initialization screen
prefs = self.preferences
doneHandler = self.__initializationFinished
self.mainScreen = InitializationScreen(prefs, doneHandler, None, (0, 0))
self.mainScreen.stdscr = stdscr
# Make sure the terminal has enough space
self.__handleTerminalResize(False)
self.mainScreen.makeFirstResponder()
# Main runloop
while True:
# Notifications
Notification.handleNotifications()
# List of responders
c = stdscr.getch()
if c == -1:
continue
if c == curses.KEY_RESIZE:
self.__handleTerminalResize()
continue
r = self.mainScreen
responders = [r]
while True:
r = r.parentResponder
if r != None:
responders.append(r)
else:
break
# Top down
for i in range(len(responders)-1, -1, -1):
r = responders[i]
if r.activeModalSession() != None:
break
if r.respondsTo(c):
r.handleEvent(c)
break
def __handleTerminalResize(self, shouldRedraw=True):
newSize = self.mainScreen.stdscr.getmaxyx()
while newSize[0] < self.MIN_SIZE[1] or newSize[1] < self.MIN_SIZE[0]:
self.mainScreen.stdscr.clear()
error = "The minimal terminal size is " + str(self.MIN_SIZE)
error = error[:newSize[1]]
if newSize[1] > 1:
self.mainScreen.stdscr.addstr(0, 0, error)
self.mainScreen.stdscr.getch()
newSize = self.mainScreen.stdscr.getmaxyx()
self.mainScreen.size = newSize
if shouldRedraw:
self.mainScreen.clear()
self.mainScreen.update()
def __initializationFinished(self):
from MainScreen import MainScreen
if len(sys.argv) >= 2:
fn = sys.argv[1]
else:
fn = None
stdscr = self.mainScreen.stdscr
self.mainScreen = MainScreen(fn, None, (0,0))
self.mainScreen.stdscr = stdscr
self.__handleTerminalResize()
self.mainScreen.makeFirstResponder()
