def main(self, filepath):
"""The Main method that kicks off the app loop."""
try:
self.store = StorageManager(filepath)
self.cm = ContentManager(self.store)
self.sm = ScreenManager()
content = self.cm.render()
self.sm.update_content(content)
while True:
self.sm.status_wnd.update_status(
self.mode_strs[self.mode],
self.cm.dirty)
if self.mode == Modes.NORMAL:
self.normal_loop()
elif self.mode == Modes.EDIT:
self.edit_loop()
elif self.mode == Modes.MOVE:
self.move_loop()
finally:
curses.endwin()
#TODO: Only use logging.exception if there is an actual exception.
logging.exception(date.today())
print('Exception in application')
print('-'*50)
print('-'*50)
def __init__(self):
self.curses = CursesHelper()
self.screenManager = ScreenManager()
self.colorTracker = ColorTracker()
self.curses.start()
self.currentInput = ""
self.layoutWidth = 0
self.layoutHeight = 0
self.outputWindow = 'main'
def _setUpScreen(self):
self._screenmanager = ScreenManager(self._settings, self._logger)
try:
self._screenmanager.screenCreate()
except Exception as e:
print("RaspLed system error:")
print(" Could not create user interface " + str(e))
print(" Contact system support.")
self._logger.error("### Error: cant create screen.")
sys.exit()
def execution(type, count, item_type):
sm = ScreenManager()
rp = RechercheProcess()
r = Item()
sm.set_focus_by_window_name("Greenlamp")
rp.search_multiple_item(type, count)
items = r.generate_item_list(type)
Excel(items, item_type)
def initGame(self):
self.window = Window(self)
self.SCREEN_RESOLUTION = (self.window.width, self.window.height)
initBatches()
self.screenManager = ScreenManager()
self.spriteManager = SpriteManager()
self.musicManager = MusicManager()
self.uiManager = UIManager.UIManager()
pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
changeGameState(GAMESTATE_MENU)
def build(self):
Window.minimum_width = 650
Window.minimum_height = 670
Window.size = 700, 1000
self.icon = 'Resources/icon.png'
self.audio.play()
return ScreenManager()
def __init__(self):
self.soundManager = SoundManager()
self.screenManager = ScreenManager(self)
conf.pg.init()
pg.display.set_caption(conf.TITLE)
# Full-screen test stuff
#user32 = conf.ctypes.windll.user32
#screenSize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
#print(screenSize)
#size = (screenSize)
#pg.display.set_mode((size) , pg.FULLSCREEN)
#conf.WIDTH = screenSize[0]
#conf.HEIGHT = screenSize[1]
self.screen = conf.pg.display.set_mode((conf.WIDTH, conf.HEIGHT))
#self.screen = conf.pg.display.set_mode((conf.WIDTH, conf.HEIGHT), pg.FULLSCREEN)
self.clock = pg.time.Clock()
pg.key.set_repeat(500, 100)
self.load_data()
pg.mouse.set_cursor(*pg.cursors.broken_x)
self.map_progress = 0
self.points = 0
self.player_health = 0
self.seed = conf.random.randint(42, 69)
class RaspLedApplication():
def run(self):
self._setUpSettings()
self._setUpLogger()
self._ledsManager = LedsManager(self._settings, self._logger)
self._ledsManager.resetLeds()
self._ledsManager.startLeds()
self._setUpScreen()
self._configureRunLoop()
self._startScreen()
def _startScreen(self):
try:
self._screenmanager.startScreen()
except Exception as e:
self._runLoop = False
print("RaspLed system error:")
print(" Could not start user interface " + str(e))
print(" Contact system support.")
self._logger.error("### Error: cant start screen.")
sys.exit()
def _configureRunLoop(self):
self._runLoop = True
try:
loopThreath = threading.Thread(target=self._mainLoop)
loopThreath.setDaemon(True)
loopThreath.start()
except Exception as e:
self._runLoop = False
print("RaspLed system error:")
print(" Could not create refresh loop " + str(e))
print(" Contact system support.")
self._logger.error("### Error: cant create refresh lood.")
sys.exit()
def _setUpScreen(self):
self._screenmanager = ScreenManager(self._settings, self._logger)
try:
self._screenmanager.screenCreate()
except Exception as e:
print("RaspLed system error:")
print(" Could not create user interface " + str(e))
print(" Contact system support.")
self._logger.error("### Error: cant create screen.")
sys.exit()
def _setUpSettings(self):
try:
self._settings = ConfigurationManager()
except Exception as e:
print("RaspLed system error:")
print(" Could not load configuration file RaspLed.ini " +
str(e))
print(" Contact system support.")
sys.exit()
def _setUpLogger(self):
# logging
self._logger = logging.getLogger()
handler = logging.handlers.RotatingFileHandler(
self._settings.logFilename,
mode='a',
maxBytes=7340032,
backupCount=3,
encoding=None,
delay=False)
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
self._logger.addHandler(handler)
self._logger.setLevel(self._settings.logLevel)
self._logger.info(
'************************************************************************'
)
self._logger.info(
'***************** RaspLed, starting script *********************'
)
self._logger.info(
'************************************************************************'
)
def _setupWebClient(self):
self._webClient = WebClient(self._settings.comunication, self._logger)
def _mainLoop(self):
self._logger.info('### Main loop')
self._setupWebClient()
while self._runLoop:
# self._logger.info('### Main loop again')
try:
siteState = self._webClient.updateSiteState()
if isinstance(siteState, SiteState):
self._screenmanager.updateScreen(siteState)
self._ledsManager.updateLeds(siteState)
sleep(self._settings.comunication.refreshInterval)
else:
self._logger.error(
'### Error: _mainLoop invalid site state')
sleep(self._settings.comunication.refreshInterval)
except Exception as e:
self._logger.error("### Error: exception in mail loop." +
str(e),
exc_info=True)
self._logger.error(
"### Retrying in " +
str(self._settings.comunication.refreshInterval) +
" seconds.")
sleep(self._settings.comunication.refreshInterval)
from wnck import Window
import wnck
from screenManager import ScreenManager
from piWindow import PIWindow
if __name__ == '__main__':
manager = ScreenManager()
window = PIWindow(manager.get_active_window())
print window.set_position(0,0)
#print manager.get_screen_size()
#window.set_geometry(5, 15, 1900, 24, 500, 500)
#window.maximize()
#print type(window.get_window().get_workspace())
#print dir(wnck.Screen)
print manager.get_screen_size()
(usable_width,usable_height,xorigin, yorigin)=manager.get_usable_size()
print (usable_width,usable_height,xorigin, yorigin)
import pygtk
pygtk.require('2.0')
import gtk
import appindicator
import pynotify
from piWindow import PIWindow
from screenManager import ScreenManager
manager = ScreenManager()
window_handle = PIWindow(manager.get_active_window())
(usable_width,usable_height,xorigin, yorigin)=manager.get_usable_size()
class PlaceItIndicator:
def __init__(self):
self.ind = appindicator.Indicator ("example-simple-client", "indicator-messages", appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status (appindicator.STATUS_ACTIVE)
self.ind.set_attention_icon ("indicator-messages-red")
self.ind.set_icon("distributor-logo")
self.menu = gtk.Menu()
agr = gtk.AccelGroup()
#Add menu items
#First Batch Maximize,Minimize,Restore
menuMaximize = gtk.MenuItem("Maximize")
menuMaximize.connect("activate", self.win_maximize,"Maximize")
import pygtk
pygtk.require('2.0')
import gtk
import appindicator
import pynotify
from piWindow import PIWindow
from screenManager import ScreenManager
manager = ScreenManager()
window_handle = PIWindow(manager.get_active_window())
(usable_width, usable_height, xorigin, yorigin) = manager.get_usable_size()
class PlaceItIndicator:
def __init__(self):
self.ind = appindicator.Indicator(
"example-simple-client", "indicator-messages",
appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status(appindicator.STATUS_ACTIVE)
self.ind.set_attention_icon("indicator-messages-red")
self.ind.set_icon("distributor-logo")
self.menu = gtk.Menu()
agr = gtk.AccelGroup()
#Add menu items
#First Batch Maximize,Minimize,Restore
menuMaximize = gtk.MenuItem("Maximize")
class Game:
def __init__(self):
self.soundManager = SoundManager()
self.screenManager = ScreenManager(self)
conf.pg.init()
pg.display.set_caption(conf.TITLE)
# Full-screen test stuff
#user32 = conf.ctypes.windll.user32
#screenSize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
#print(screenSize)
#size = (screenSize)
#pg.display.set_mode((size) , pg.FULLSCREEN)
#conf.WIDTH = screenSize[0]
#conf.HEIGHT = screenSize[1]
self.screen = conf.pg.display.set_mode((conf.WIDTH, conf.HEIGHT))
#self.screen = conf.pg.display.set_mode((conf.WIDTH, conf.HEIGHT), pg.FULLSCREEN)
self.clock = pg.time.Clock()
pg.key.set_repeat(500, 100)
self.load_data()
pg.mouse.set_cursor(*pg.cursors.broken_x)
self.map_progress = 0
self.points = 0
self.player_health = 0
self.seed = conf.random.randint(42, 69)
def load_data(self):
game_folder = path.dirname('__file__')
img_folder = path.join(game_folder, 'img')
snd_folder = path.join(game_folder, 'snd')
music_folder = path.join(game_folder, 'music')
map_folder = path.join(game_folder, 'maps')
self.asset_folder = path.join(game_folder, 'assets')
self.title_font = path.join(game_folder, conf.FONT)
self.background_image = utils.load_images_in_folder(conf.BACKGROUND_IMAGE, img_folder)
self.dim_screen_img = pg.Surface(self.screen.get_size()).convert_alpha()
self.dim_screen_img.fill((0, 0, 0, 120))
self.maps = utils.load_maps(map_folder)
self.player_imgs = utils.load_images_in_folder(conf.PLAYER_IMGS, img_folder)
for i in range(0, len(self.player_imgs)):
self.player_imgs[i] = pg.transform.scale(self.player_imgs[i], (conf.TILESIZE, conf.TILESIZE))
self.wall_img = utils.load_images_in_folder(conf.WALL_IMG, img_folder)
self.bullet_imgs = utils.load_images_in_folder(conf.BULLET_IMGS, img_folder)
self.noise_imgs = utils.load_images_in_folder(conf.NOISE_IMGS, img_folder)
self.flash_imgs = utils.load_images_in_folder(conf.BULLET_FLASH_IMGS, img_folder)
self.item_imgs = utils.load_images_in_folder(conf.ITEM_IMGS, img_folder)
self.splat_imgs = utils.load_images_in_folder(conf.SPLAT_IMGS, img_folder)
# Sound
pg.mixer.music.load(path.join(music_folder, conf.BG_MUSIC))
self.effect_sounds = utils.load_sounds_in_folder(conf.EFFECTS_SOUNDS, snd_folder)
self.weapon_sounds = utils.load_sounds_in_folder(conf.WEAPON_SOUNDS, snd_folder)
self.enemy_sounds = utils.load_sounds_in_folder(conf.ENEMY_SOUNDS, snd_folder)
for s in self.enemy_sounds:
s.set_volume(.2)
self.player_hit_sounds = utils.load_sounds_in_folder(conf.PLAYER_HIT_SOUNDS, snd_folder)
# TODO - Find other sound for this
self.enemy_hit_sounds = utils.load_sounds_in_folder(conf.ENEMY_SOUNDS, snd_folder)
for s in self.enemy_hit_sounds:
s.set_volume(.2)
def new(self):
# initialize all variables and do all the setup for a new game
conf.random.seed(self.seed)
self.all_sprites = pg.sprite.LayeredUpdates()
self.walls = pg.sprite.Group()
self.mobs = pg.sprite.Group()
self.bullets = pg.sprite.Group()
self.items = pg.sprite.Group()
for row, tiles in enumerate(self.maps[self.map_progress].data):
for col, tile in enumerate(tiles):
if tile == conf.WALL_TILE:
Wall(self, conf.vec(col, row))
elif tile == conf.PLAYER_TILE:
self.player = Player(self, conf.vec(col, row))
if (self.player_health != 0):
self.player.health = self.player_health
elif tile == conf.HEALTH_TILE:
Item(self, conf.vec(col, row), 'health')
elif tile == conf.MG_TILE:
Item(self, conf.vec(col, row), 'machinegun')
elif tile == conf.SW_TILE:
Item(self, conf.vec(col, row), 'shockwave')
elif tile == conf.SG_TILE:
Item(self, conf.vec(col, row), 'shotgun')
for row, tiles in enumerate(self.maps[self.map_progress].data):
for col, tile in enumerate(tiles):
if tile == conf.MOB_TILE:
Mob(self, conf.vec(col, row))
self.paused = False
self.camera = Camera(self, self.maps[self.map_progress].width, self.maps[self.map_progress].height)
self.background = Background(self, conf.vec(
self.maps[self.map_progress].width / 4, self.maps[self.map_progress].height / 4))
self.soundManager.play_sound_effect(self.effect_sounds['level_start'])
def run(self):
# game loop - set self.playing = False to end the game
self.playing = True
self.soundManager.play_music()
while self.playing:
self.dt = self.clock.tick(conf.FPS) / 1000.0
self.events()
if not self.paused:
self.update()
self.screenManager.draw_info(
conf.BGCOLOR,
self.title_font,
self.player.health,
self.clock.get_fps(),
self.points + self.player.points_current_level,
self.player.secondary_weapon_bullets,
self.player.secondary_weapon
)
def quit(self):
pg.quit()
#TODO sys.exit()??
def update(self):
# update portion of the game loop
self.all_sprites.update()
self.camera.update(self.player)
def events(self):
# catch all events here
for event in pg.event.get():
if event.type == pg.QUIT:
self.quit()
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
self.quit()
elif event.type == pg.KEYUP:
if event.key == pg.K_m:
self.soundManager.toggle_mute()
if event.key == pg.K_r:
self.new()
self.run()
if event.key == pg.K_p:
self.paused = not self.paused
if event.key == pg.K_SPACE and len(self.mobs) == 0:
self.add_points(self.player.points_current_level)
self.player_health = self.player.health
if self.map_progress < len(self.maps) - 1:
self.map_progress += 1
else:
self.map_progress = 0
self.new()
self.run()
def show_start_screen(self):
pass
def show_go_screen(self):
pass
def add_points(self, pointsToAdd):
self.points += pointsToAdd
from wnck import Window
import wnck
from screenManager import ScreenManager
from piWindow import PIWindow
if __name__ == '__main__':
manager = ScreenManager()
window = PIWindow(manager.get_active_window())
#print window.set_position(0,0)
#print manager.get_screen_size()
#window.set_geometry(5, 15, 1900, 24, 500, 500)
#window.maximize()
#print type(window.get_window().get_workspace())
manager.get_usable_size()
#print dir(wnck.Screen)
def main():
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%d/%m/%Y %H:%M:%S',
filename='logs/error.log',
level=logging.ERROR)
ui = UI()
ui.print_message("-- Passphrase for encryption database")
cm = ConstantsManager(ui.get_user_entry("Enter passphrase: "))
constants.VIEW_ID = cm.getConstantValue(constants.STR_VIEW_ID)
constants.TELEGRAM_BOT_TOKEN = cm.getConstantValue(
constants.STR_TELEGRAM_BOT_TOKEN)
constants.TELEGRAM_GROUP_ID = cm.getConstantValue(
constants.STR_TELEGRAM_GROUP_ID)
from infoFactory import InfoFactory
from screenManager import ScreenManager
from telegramBotManager import TelegramBotManager
from info import Info
screen_manager = ScreenManager()
info_factory = InfoFactory()
id_info_max = info_factory.get_number_of_info()
id_info = 2
#Id de l'info qui provoque l'erreur courante
#Si elle est à 0, il n'y a pas d'erreur
id_info_error = 0
screen_manager.lcd_init()
screen_manager.light_off_alert_led()
while True:
#On repart à la première info si on a affiché la dernière info
#sinon on passe à la suivante
if id_info == id_info_max:
id_info = 1
else:
id_info = id_info + 1
info = Info()
#On récupère l'info à afficher
info = info_factory.generate_info(id_info)
#On affiche l'info
screen_manager.print_first_line(info.get_first_line())
screen_manager.print_second_line(info.get_second_line())
if (info.get_level() == "ERROR"):
screen_manager.light_on_alert_led()
id_info_error = info.get_id()
try:
tbm = TelegramBotManager()
tbm.send_message_to_group(constants.TELEGRAM_GROUP_ID,
info.get_telegram_message())
except:
logging.error(
"Erreur lors de l'envoi de message par le Bot Telegram")
else:
if (id_info_error == info.get_id()):
screen_manager.light_off_alert_led()
#On signale qu'il n'y a plus d'erreur
id_info_error = 0
try:
tbm = TelegramBotManager()
tbm.send_message_to_group(constants.TELEGRAM_GROUP_ID,
info.get_telegram_message())
except:
logging.error(
"Erreur lors de l'envoi de message par le Bot Telegram"
)
time.sleep(10)
#On efface le contenu de l'écran
screen_manager.lcd_init()
class Interface(object):
def __init__(self):
self.curses = CursesHelper()
self.screenManager = ScreenManager()
self.colorTracker = ColorTracker()
self.curses.start()
self.currentInput = ""
self.layoutWidth = 0
self.layoutHeight = 0
self.outputWindow = 'main'
def getColorTracker(self):
return self.colorTracker
def getWindow(self, name):
return self.screenManager.getWindow(name)
def createWindow(self, name, position, size=False):
self.screenManager.registerWindow(name, position, size)
def setLayoutSize(self, width, height):
self.layoutWidth = width
self.layoutHeight = height
def build(self):
mainScreen = self.curses.getMainScreen()
size = self.curses.getSize()
self.screenManager.buildScreens(mainScreen, size,
(self.layoutWidth, self.layoutHeight))
def stop(self):
self.curses.stop()
def getch(self):
return self.curses.getch()
def setInput(self, string):
if string != self.currentInput:
self.screenManager.getWindow('input').clear()
self.screenManager.getWindow('input').printString(string)
self.currentInput = string
def checkResize(self):
if self.curses.isResized():
self.build()
def setOutputWindow(self, name):
self.outputWindow = name
def getOutputWindow(self):
return self.outputWindow
def step(self, action):
if action[0] == "print":
self.screenManager.getWindow(self.outputWindow).printString(
action[1], self.colorTracker.getColor())
elif action[0] == "color":
self.colorTracker.updateColor(action[1])
def refresh(self):
if self.screenManager.refresh():
self.curses.refresh()
class ListMaker:
def __init__(self):
self.store = None
self.cm = None
self.sm = None
self.mode = Modes.NORMAL
self.state = dict()
self.mode_strs = {
Modes.EDIT:'Edit Mode',
Modes.NORMAL:'Normal Mode',
Modes.MOVE:'Move Mode'}
os.environ.setdefault('ESCDELAY', '25')
logging.basicConfig(filename='app.log', level=logging.DEBUG)
def main(self, filepath):
"""The Main method that kicks off the app loop."""
try:
self.store = StorageManager(filepath)
self.cm = ContentManager(self.store)
self.sm = ScreenManager()
content = self.cm.render()
self.sm.update_content(content)
while True:
self.sm.status_wnd.update_status(
self.mode_strs[self.mode],
self.cm.dirty)
if self.mode == Modes.NORMAL:
self.normal_loop()
elif self.mode == Modes.EDIT:
self.edit_loop()
elif self.mode == Modes.MOVE:
self.move_loop()
finally:
curses.endwin()
#TODO: Only use logging.exception if there is an actual exception.
logging.exception(date.today())
print('Exception in application')
print('-'*50)
print('-'*50)
def normal_loop(self):
"""This method handles the main-loop while app is in Normal mode."""
sm = self.sm
cm = self.cm
key = self.process_input()
if key in('KEY_DOWN', 'j'):
sm.anno_wnd.update_selected(cm.traverse_down(), 'normal')
elif key in('KEY_UP', 'k'):
sm.anno_wnd.update_selected(cm.traverse_up(), 'normal')
elif key == 'c':
content = self.cm.add_child()
self.sm.update_content(content)
self.start_edit()
elif key == 'w':
self.store.write(self.cm.root)
self.cm.dirty = False
elif key == 'q':
sys.exit()
elif key == 'e':
self.start_edit()
elif key == 'm':
self.start_move()
elif key in ('Enter', 'b'):
content = self.cm.add_sibling()
self.sm.update_content(content)
self.start_edit()
elif key == 'd':
content = self.cm.delete_node()
self.sm.update_content(content)
elif key in ('[', '<'):
content = self.cm.promote_node()
self.sm.update_content(content)
elif key in (']', '>'):
content = self.cm.demote_node()
self.sm.update_content(content)
def edit_loop(self):
"""This method handles the main-loop while app is in Edit mode."""
key = self.process_input()
if key == 'KEY_LEFT':
target = self.cm.traverse_left()
self.sm.show_cursor(target)
elif key == 'KEY_RIGHT':
target = self.cm.traverse_right()
self.sm.show_cursor(target)
elif key == 'Escape':
self.end_edit()
elif key == 'KEY_BACKSPACE':
target = self.cm.backspace()
self.sm.update_line(target)
self.sm.show_cursor(target)
elif key == 'KEY_DC':
target = self.cm.del_char()
self.sm.update_line(target)
self.sm.show_cursor(target)
elif key == 'Enter':
self.end_edit()
self.sm.update_content(self.cm.add_sibling())
self.start_edit()
elif key in string.printable:
target = self.cm.insert(key)
self.sm.update_line(target)
self.sm.show_cursor(target)
def start_edit(self):
self.mode = Modes.EDIT
edit_target = self.cm.get_selected_row()
self.sm.status_wnd.update_status('Edit Mode', self.cm.dirty)
self.sm.anno_wnd.update_selected(self.cm.selected_row, 'edit')
self.sm.show_cursor(edit_target)
def end_edit(self):
self.mode = Modes.NORMAL
self.sm.status_wnd.update_status('Normal Mode', self.cm.dirty)
self.sm.anno_wnd.update_selected(self.cm.selected_row, 'normal')
self.sm.hide_cursor()
def move_loop(self):
"""This method handles the main-loop while app is in move mode."""
sm = self.sm
cm = self.cm
key = self.process_input()
if key in('KEY_DOWN', 'j'):
sm.anno_wnd.update_selected(cm.traverse_down(), 'normal')
elif key in('KEY_UP', 'k'):
sm.anno_wnd.update_selected(cm.traverse_up(), 'normal')
elif key == 'Escape':
self.end_move(execute=False)
elif key == 'Enter':
self.end_move(execute=True)
def start_move(self):
"""This method puts the application in Move Mode.
This involved painting the starting item's annotation,
updating object mode state, updating status line.
"""
self.mode = Modes.MOVE
self.sm.status_wnd.update_status('Move Mode', self.cm.dirty)
self.sm.anno_wnd.update_move_item(self.cm.selected_row)
self.state['move_row'] = self.cm.selected_row
def end_move(self, execute: bool = False):
"""This method ends the move and goes back to normal mode.
Arguments:
execute -- If True, the move command will be executed. If
False, the move will be canceled and the content
tree will not be changed.
"""
if execute:
content = self.cm.move_node(self.state.pop('move_row'))
self.sm.update_content(content)
self.mode = Modes.NORMAL
self.sm.status_wnd.update_status('Normal Mode', self.cm.dirty)
self.sm.anno_wnd.clear_move()
def process_input(self):
ch = self.sm.getch()
result = self.process_ch(ch)
if result == None:
result = self.sm.getkey()
return result
def process_ch(self, ch) -> str:
if ch == 27:
# Escape key
return 'Escape'
elif ch == 8:
# Backspace key
return 'Backspace'
elif ch == 10:
# Enter key
return 'Enter'
else:
curses.ungetch(ch)
return None