def test_save(self):
"""
Check scene will save data on exit if needed.
"""
effect = MockEffect()
scene = Scene([effect], duration=10)
self.assertFalse(effect.save_called)
scene.exit()
self.assertTrue(effect.save_called)
def test_dynamic_effects(self):
"""
Check adding and removing effects works.
"""
# Start with no effects
effect = MockEffect()
scene = Scene([], duration=10)
self.assertEqual(scene.effects, [])
# Add one - check internals for presence
scene.add_effect(effect)
self.assertEqual(scene.effects, [effect])
# Remove it - check it's gone
scene.remove_effect(effect)
self.assertEqual(scene.effects, [])
def internal_checks(screen):
# First check that we can move between screens.
test_effect1 = MockEffect(stop=False)
test_effect2 = MockEffect(count=5)
screen.play([Scene([test_effect1], 5), Scene([test_effect2], 0)])
self.assertTrue(test_effect1.reset_called)
self.assertTrue(test_effect2.reset_called)
# Now check that we can start at the second scene.
test_effect1 = MockEffect(stop=False)
scene1 = Scene([test_effect1], 5, name="1")
test_effect2 = MockEffect(count=3)
scene2 = Scene([test_effect2], 0, name="2")
screen.play([scene1, scene2], start_scene=scene2)
self.assertFalse(test_effect1.reset_called)
self.assertTrue(test_effect2.reset_called)
# Now check that we can move to named scenes.
test_effect1 = MockEffect(stop=False, next_scene="B")
test_effect2 = MockEffect(count=5)
screen.play([
Scene([test_effect1], 15, name="A"),
Scene([test_effect2], 0, name="B")
])
self.assertTrue(test_effect1.reset_called)
self.assertTrue(test_effect2.reset_called)
# Now check that bad names cause an exception.
with self.assertRaises(RuntimeError):
test_effect1 = MockEffect(stop=False, next_scene="C")
test_effect2 = MockEffect(count=5)
screen.play([
Scene([test_effect1], 15, name="A"),
Scene([test_effect2], 0, name="B")
])
self.assertTrue(test_effect1.reset_called)
self.assertFalse(test_effect2.reset_called)
# Now check that play stops at the end when repeat=False
test_effect1 = MockEffect(stop=False)
scene1 = Scene([test_effect1], 5, name="1")
screen.play([scene1], repeat=False)
self.assertTrue(test_effect1.reset_called)
def demo(screen):
scenes = []
effects = [
Print(screen,
FigletText("H E L L O",
font='epic' if screen.width > 80 else 'banner'),
screen.height // 2 - 3,
colour=7,
bg=7 if screen.unicode_aware else 0),
]
scenes.append(Scene(effects))
screen.play(scenes, stop_on_resize=True)
def render(data: TopCache, show_details: bool) -> None:
while True:
try:
Screen.wrapper(
lambda screen, data_ref, show_details: screen.play(
[Scene([TopView(screen, data_ref, show_details)], -1)],
stop_on_resize=True,
),
catch_interrupt=True,
arguments=[data, show_details],
)
return
except ResizeScreenError:
pass
def from_scene(cls, scene, screen, application) -> "ScreenManager":
"""
Build a ScreenManager from a constructed scene,
replacing the screen, and keeping the model for
all frames.
:param scene: Scene to copy effects from.
:param screen: Screen object from asciimatics.
:param application: Application instance.
"""
new_frames = []
for frame in scene.effects:
new_frames.append(frame.copy_with_screen(screen))
new_scene = Scene(new_frames, -1, name="Iroha TUI")
return cls(new_scene, screen, application)
def demo(screen):
scenes = []
effects = [
Print(screen,
ImageFile("/home/pi/Desktop/WASP-Emojis-master/images/sound.jpg",
screen.height - 2,
colours=screen.colours),
0,
stop_frame=100),
]
scenes.append(Scene(effects))
screen.play(scenes, stop_on_resize=True)
def flood_demo(screen):
scenes = []
effects = [
Rain(screen, 200),
Print(screen,
FigletText("Flood!", "banner3"), (screen.height - 4) // 2,
colour=Screen.COLOUR_CYAN,
speed=1,
stop_frame=30),
]
scenes.append(Scene(effects, -1))
screen.play(scenes, stop_on_resize=True, repeat=False)
def internal_checks(screen):
# Since the Screen draws things, there's not too much we can do
# to genuinely verify this without verifying all Scene and Effect
# function too. Just play a dummy Effect for now.
test_effect = MockEffect()
screen.play([Scene([test_effect], 0)])
self.assertTrue(test_effect.stop_called)
self.assertTrue(test_effect.reset_called)
# Now check that the desired duration is used.
test_effect = MockEffect(count=6)
screen.play([Scene([test_effect], 15)])
self.assertFalse(test_effect.stop_called)
self.assertTrue(test_effect.reset_called)
# Now check that delete_count works.
test_effect = MockEffect(count=6)
test_effect2 = MockEffect(delete_count=3)
scene = Scene([test_effect, test_effect2], 15)
self.assertEqual(len(scene.effects), 2)
screen.play([scene])
self.assertEqual(len(scene.effects), 1)
self.assertEqual(scene.effects[0], test_effect)
def game_over(screen):
scenes = []
effects = [
Print(
screen,
Fire(
screen.height,
80,
"*" * 70,
0.8,
60,
screen.colours,
bg=screen.colours >= 256,
),
0,
speed=1,
transparent=False,
),
Print(
screen,
FigletText("\nGame", "banner3"),
(screen.height - 4) // 2,
colour=Screen.COLOUR_BLACK,
speed=1,
start_frame=30,
stop_frame=50,
),
Print(
screen,
FigletText("\nOver", "banner3"),
(screen.height - 4) // 2,
colour=Screen.COLOUR_BLACK,
speed=1,
start_frame=50,
stop_frame=70,
),
Print(
screen,
FigletText("BWA\n HA\n HA\nHA!!!", "banner3"),
(screen.height - 4) // 2,
colour=Screen.COLOUR_BLACK,
speed=1,
start_frame=70,
),
]
scenes.append(Scene(effects, 100))
screen.play(scenes, stop_on_resize=True, repeat=False)
def fireworks(screen):
scenes = []
effects = [
Stars(screen, screen.width),
Print(screen,
SpeechBubble("Press space to see it again"),
y=screen.height - 3,
start_frame=300)
]
for _ in range(20):
fireworks = [
(PalmFirework, 25, 30),
(PalmFirework, 25, 30),
(StarFirework, 25, 35),
(StarFirework, 25, 35),
(StarFirework, 25, 35),
(RingFirework, 20, 30),
(SerpentFirework, 30, 35),
]
firework, start, stop = choice(fireworks)
effects.insert(
1,
firework(screen,
randint(0, screen.width),
randint(screen.height // 8, screen.height * 3 // 4),
randint(start, stop),
start_frame=randint(0, 250)))
effects.append(
Print(screen,
Rainbow(screen, FigletText("CONGRATULATIONS")),
screen.height // 2 - 6,
speed=1,
start_frame=100))
effects.append(
Print(screen,
Rainbow(screen, FigletText("TO YOUR")),
screen.height // 2 + 1,
speed=1,
start_frame=100))
effects.append(
Print(screen,
Rainbow(screen, FigletText("OPTIMAL SCHEDULE")),
screen.height // 2 + 1,
speed=1,
start_frame=100))
scenes.append(Scene(effects, -1))
screen.play(scenes, stop_on_resize=True, repeat=False)
def yule_log(screen):
screen_height = screen.height
screen_width = screen.width
log_x = (screen_width // 2) - HALF_LOG_LENGTH
log_y = (screen_height // 2) + HALF_LOG_HEIGHT
if screen_height < 30:
log_y = screen_height // 3
elif screen_height < 48:
log_y = screen_height // 2
scenes = []
effects = [
Snow(screen),
Print(screen,
Fire(screen.height - 10,
80,
"*" * 70,
0.8,
60,
screen.colours,
bg=screen.colours >= 256),
0,
speed=1,
transparent=False),
Print(screen,
StaticRenderer(images=YULE_LOG),
x=log_x,
y=log_y,
colour=1,
speed=1,
transparent=True),
]
if screen_height > 40:
effects += [
Print(screen,
FigletText("MERRY", font='univers'),
1,
speed=1,
start_frame=5),
Print(screen,
FigletText("CHRISTMAS!", font='univers'),
10,
speed=1,
start_frame=15),
]
scenes.append(Scene(effects, -1))
screen.play(scenes, stop_on_resize=True)
def demo(screen):
#self._screen = screen
scenes = []
#Taille Rpi avec ecran 3,5" : 60x20
message = "Resize to 60x20\nActual %sx%s" % (screen.width,screen.height)
if screen.width != 60 or screen.height != 20:
effects = [
Print(screen, FigletText(message),
y=screen.height//2-3),
]
else:
# Rendu permettant l'affichage de l'horloge.
renderClock = fxobdfiglet.FigletClock(screen.width, screen.height)
renderExtTemp = fxobdfiglet.FigletExtTemp(screen.width, screen.height)
renderRPM = fxobdfiglet.FigletRPM(screen.width, screen.height)
#Creation de l'effet (inclusion de plusieurs rendus).
effects = [
#Ext Temperature
Print(screen,
BarChart(5, 40, [wv(3)], char="=",
gradient=[(12, Screen.COLOUR_GREEN),
(20, Screen.COLOUR_YELLOW),
(24, Screen.COLOUR_RED)],
scale=24,
intervals=5,
labels=True),
x=5, y=1, transparent=False, speed=2),
Print(screen, FigletText("%s"%screen.width, font=u'lcd'),
y=1, x= 40),
#Engine temperature
Print(screen,
BarChart(7, 40, [wv(2)],
char="=",
gradient=[(20, Screen.COLOUR_GREEN),
(40, Screen.COLOUR_YELLOW),
(60, Screen.COLOUR_RED)],
scale=80,
intervals=10,
labels=False),
x=5, y=5, transparent=False, speed=2),
Print(screen, renderRPM, y=10, x= 40),
#Affichage de la date et de l heure pb de rafraichissement il faut utiliser le fliglet dynamique.
Print(screen, renderClock,
x=(screen.width)//2-renderClock.max_width, y= screen.height-1),
#x=(screen.width-wv(4).__len__())//2, y= screen.height-1),
]
scenes.append(Scene(effects, -1))
screen.play(scenes, stop_on_resize=True)
def tdirstat(screen: Screen, old_scene):
nonlocal dirstat
on_stats_change = lambda *args, **kwargs: screen.force_update()
if dirstat is None:
dirstat = DirectoryStat(
path=str(args.root_dir.absolute()),
on_stats_change=on_stats_change,
mounts_to_ignore=get_mounts())
# Make sure this gets set each time the screen resizes
dirstat._on_stats_change = on_stats_change
screen.play(
[Scene([TDirStatView(screen, dirstat)], duration=-1)],
stop_on_resize=True,
start_scene=old_scene)
def demo(screen):
effects = [
Cycle(
screen,
FigletText("ASCIIMATICS", font='big'),
screen.height // 2 - 8),
BannerText(
screen,
FigletText("ROCKS!", font='big'),
screen.height // 2 + 3,
Screen.COLOUR_CYAN,
Screen.COLOUR_BLACK),
Stars(screen, (screen.width + screen.height) // 2)
]
screen.play([Scene(effects, 500)])
def credits(self):
scenes = []
effects = [
Print(self.screen,
SpeechBubble("Exiting GUI"),
self.screen.height // 2 - 1,
attr=Screen.A_BOLD)
]
scenes.append(Scene(
effects,
duration=10,
name="Exit",
))
return scenes
def demo(screen, scene):
scenes = []
centre = (screen.width // 2, screen.height // 2)
cx, cy = centre
effects = [
Rain(screen, 1000),
# ShootScreen(screen, cx, cy, 1000),
Clock(screen, cx, cy, cy),
# Splash(screen, cx, cy),
# Julia(screen),
DemoFrame(screen),
]
scenes.append(Scene(effects, -1))
screen.play(scenes, stop_on_resize=True, start_scene=scene)
def demo(screen, scene):
with AsciinemaPlayer("test.rec", max_delay=0.1) as player, \
AnsiArtPlayer("fruit.ans") as player2:
screen.play([
Scene([
Print(screen, player, 0, speed=1, transparent=False),
Print(screen,
SpeechBubble("Press space to see ansi art"),
y=screen.height - 3,
speed=0,
transparent=False)
], -1),
Scene([
Print(screen, player2, 0, speed=1, transparent=False),
Print(screen,
SpeechBubble("Press space to see asciinema"),
y=screen.height - 3,
speed=0,
transparent=False)
], -1)
],
stop_on_resize=True,
start_scene=scene,
allow_int=True)
def fireWorksAtTime(screen):
scenes = []
effects = []
for x in range(0, 50):
effects.append(PalmFirework(screen,
randint(0, screen.width),
randint(screen.height // 8, screen.height * 3 // 4),
randint(25, 40),
start_frame=randint(0, 250)))
scenes.append(Scene(effects, -1))
screen.play(scenes, stop_on_resize=True)
ev = screen.get_key()
if ev in (ord('Q'), ord('q')):
return
def test_clone(self):
"""
Check Frame cloning works.
"""
def test_on_click(selection):
raise NextScene(str(selection))
screen = MagicMock(spec=Screen, colours=8, unicode_aware=False)
scene = MagicMock(spec=Scene)
scene2 = Scene([], 10)
canvas = Canvas(screen, 10, 40, 0, 0)
# Check that pop-up dialogs get copied to the new Scene
form = PopUpDialog(canvas,
"Message", ["Yes", "No"],
test_on_click,
has_shadow=True)
form.register_scene(scene)
form.clone(canvas, scene2)
self.assertEqual(len(scene2.effects), 1)
self.assertEqual(scene2.effects[0]._text, "Message")
self.assertEqual(scene2.effects[0]._buttons, ["Yes", "No"])
# Check that normal Frame data gets copied to the new Scene.
frame = TestFrame(canvas)
frame2 = TestFrame(canvas)
scene2 = Scene([frame2], 10)
frame.register_scene(scene)
frame2.register_scene(scene)
frame.data = {"TA": "something"}
frame2.data = {}
self.assertEqual(frame2.data, {})
self.assertNotEqual(frame2.data, frame.data)
frame.clone(canvas, scene2)
self.assertEqual(frame2.data, frame.data)
def demo(wout, win):
while True:
screen = Screen.from_windows(wout, win)
effects = [
Print(screen, Rainbow(screen, FigletText("256 colours")),
y=screen.height//2 - 8),
Print(screen, Rainbow(screen, FigletText("for xterm users")),
y=screen.height//2 + 3),
Clock(screen, screen.width//2, screen.height//2, screen.height//2),
]
try:
screen.play([Scene(effects, -1)], stop_on_resize=True)
return
except ResizeScreenError:
pass
def splashScreen(screen):
effects = [
Cycle(
screen,
FigletText("PASSMAN,", font='big'),
int(screen.height / 2 - 8)),
Cycle(
screen,
FigletText("MAN!", font='big'),
int(screen.height / 2 + 3)),
Stars(screen, 200)
]
# play for 25 ms, don't repeat
screen.play([Scene(effects, 25)], repeat=False)
def lose(screen):
lose_effects = [
Cycle(
screen,
FigletText("YOU"),
screen.height // 2 - 6,
),
Cycle(
screen,
FigletText("LOST!"),
screen.height // 2 + 1,
),
]
lose_scene = Scene(lose_effects, -1)
screen.play([lose_scene])
def win(screen):
win_effects = [
Cycle(
screen,
FigletText("YOU"),
screen.height // 2 - 6,
),
Cycle(
screen,
FigletText("WON!"),
screen.height // 2 + 1,
),
]
win_scene = Scene(win_effects, -1)
screen.play([win_scene])
def demo(screen=None, name="", fav_colour=7):
x = Stars(screen, (screen.width + screen.height) // 2)
effects = [
Print(screen,
FigletText("{}".format(str("Hello"))),
screen.height // 2 - 7,
colour=fav_colour),
Print(screen,
FigletText("{} !".format(str(name))),
screen.height // 2,
colour=fav_colour), x
]
screen.play([Scene(effects, 500)])
def pages(self):
scenes = [Scene([TimeScreen(self.screen, self)], -1, name="Time")]
scenes += [Scene([LogsScreen(self.screen, self)], -1, name="Logs")]
scenes += [
Scene([NetworkScreen(self.screen, self)], -1, name="Network")
]
scenes += [Scene([BusScreen(self.screen, self)], -1, name="Bus")]
scenes += [Scene([ChatScreen(self.screen, self)], -1, name="Chat")]
scenes += [
Scene([VariablesScreen(self.screen, self)], -1, name="Variables")
]
scenes += [Scene([WIPScreen(self.screen, self)], -1, name="WIP")]
return scenes
def suspense(screen):
# Leer xlsx y seleccionar un estudiante
student = get_student_from_xlsx(generation)
student_split = student.split()
text = "{} {} \n{} {}".format(
student_split[0],
student_split[1],
student_split[2],
student_split[3]
)
effects = [
RandomNoise(screen,
signal=Rainbow(screen,
FigletText(text)))
]
screen.play([Scene(effects, -1)], stop_on_resize=True)
def normal(screen):
# Leer xlsx y seleccionar un estudiante
student = get_student_from_xlsx(generation)
student_split = student.split()
effects = [
Cycle(
screen,
FigletText("{} {}".format(student_split[0], student_split[1]), font='big'),
screen.height // 2 - 8),
Cycle(
screen,
FigletText("{} {}".format(student_split[2], student_split[3]), font='big'),
screen.height // 2 + 3),
Stars(screen, (screen.width + screen.height) // 2)
]
screen.play([Scene(effects, 500)])
def deft_splash(screen):
effects = [
Cycle(screen, FigletText("dEFT", font='big'),
int(screen.height / 2 - 8)),
Cycle(
screen,
FigletText("A differential Effective Field Theory tool",
font='small'), int(screen.height / 2 + 3)),
Cycle(screen, FigletText("press q to run job!", font='small'),
int(screen.height / 1.5)),
Stars(screen, 900)
]
screen.play([Scene(effects, 900)])
ev = screen.get_key()
if ev in (ord('Q'), ord('q')):
return
def internal_checks(screen):
# First check that Effects are always drawn at Scene start
test_effect = MockEffect(count=101, stop_frame=101, frame_rate=100)
screen.set_scenes([Scene([test_effect], 0)])
screen.draw_next_frame()
self.assertTrue(test_effect.update_called)
# Now check that the Screen honours the long frame rate...
test_effect.update_called = False
for _ in range(90):
screen.draw_next_frame()
self.assertFalse(test_effect.update_called)
# Now check that the forced update works as expected.
screen.force_update()
screen.draw_next_frame()
self.assertTrue(test_effect.update_called)
def welcome_screen(screen):
# create `effects` that asciimatics will display in the screen
effects = [
# main title
Cycle(screen, FigletText("HackHer413", font='univers'),
int(screen.height / 3 - 2)),
# subtitle
Cycle(screen, FigletText("I beelong", font='o8'),
int(screen.height / 2)),
# exit prompt
Cycle(screen, FigletText("PRESS ANY KEY TO EXIT", font='digital'),
int((screen.height / 2) * 1.5)),
Stars(screen, 200),
# allow exiting with a keypress
StopOnKeypress(screen),
]
screen.play([Scene(effects, 500)], )
def demo(screen):
effects = [
Cycle(screen, FigletText("LYRICAL", font='big'),
int(screen.height / 2 - 8)),
Cycle(screen, FigletText("GENIUSES!", font='big'),
int(screen.height / 2 + 3)),
Cycle(screen, FigletText("PRESS Q TO START", font='small'),
int(screen.height / 2 + 12)),
Stars(screen, 200)
]
screen.play([Scene(effects, 500)])
ev = screen.get_key()
if ev in (ord('Q'), ord('q')):
return
screen.refresh()
def test_events(self):
"""
Check event processing is queued correctly.
"""
# Check that the scene passes events through to the effects
effect1 = MockEffect()
effect2 = MockEffect()
scene = Scene([effect1, effect2], duration=10)
scene.process_event(MouseEvent(10, 5, 0))
self.assertTrue(effect1.event_called)
self.assertTrue(effect2.event_called)
# Check that the scene passes stops event processing when required
effect1 = MockEffect()
effect2 = MockEffect(swallow=True)
scene = Scene([effect1, effect2], duration=10)
scene.process_event(MouseEvent(10, 5, 0))
self.assertFalse(effect1.event_called)
self.assertTrue(effect2.event_called)
