def _alpha_cards(self):
x = self._grid_x_offset + GUTTER
y = self._grid_y_offset + GUTTER
if len(self._cards) > 0:
for card in self._cards:
card.set_layer(100)
return
for card in self._card_data:
self.current_card = self._card_data.index(card)
# Two-tone cards add some complexity.
if type(self._color_data[self.current_card][0]) == type([]):
stroke = self._test_for_stroke()
top = svg_str_to_pixbuf(
generate_card(
string=card[0],
colors=[
self._color_data[self.current_card][0][0],
'#FFFFFF'
],
scale=self._scale,
center=True))
bot = svg_str_to_pixbuf(
generate_card(
string=card[0],
colors=[
self._color_data[self.current_card][0][1],
'#FFFFFF'
],
scale=self._scale,
center=True))
# Where to draw the line
h1 = 9 / 16.
h2 = 1.0 - h1
bot.composite(top, 0, int(h1 * top.get_height()),
top.get_width(), int(h2 * top.get_height()), 0,
0, 1, 1, GdkPixbuf.InterpType.NEAREST, 255)
self._cards.append(Sprite(self._sprites, x, y, top))
else:
stroke = self._test_for_stroke()
self._cards.append(
Sprite(
self._sprites, x, y,
svg_str_to_pixbuf(
generate_card(
string='%s%s' %
(card[0].upper(), card[0].lower()),
colors=[
self._color_data[self.current_card][0],
'#FFFFFF'
],
stroke=stroke,
scale=self._scale,
center=True))))
x += self._card_width + GUTTER * 2
if x > self._width - (self._card_width / 2):
x = self._grid_x_offset + GUTTER * 2
y += self._card_height + GUTTER * 2
def load_level(self, path):
''' Load a level (CSV) from path: letter, word, color, image,
image sound, letter sound '''
self._card_data = [] # (letter, word, letter_sound_path)
self._color_data = []
self._image_data = {} # {letter: [(Sprite, image_sound_path)...]}
self._pictures = []
f = open(path)
for line in f:
if len(line) > 0 and line[0] not in '#\n':
words = line.split(', ')
self._card_data.append((words[0], words[1].replace('-', ', '),
os.path.join(self._sounds_path,
words[5])))
if words[2].count('#') > 1:
self._color_data.append([words[2].split('/')])
else:
self._color_data.append([words[2]])
imagefilename = words[3]
imagepath = os.path.join(self._images_path, imagefilename)
pixbuf = image_file_to_pixbuf(imagepath, self._card_width,
self._card_height)
s = Sprite(self._sprites, 0, 0, pixbuf)
self._image_data[words[0]] = \
[(s, os.path.join(self._sounds_path, words[4]))]
self._pictures.append(s)
f.close()
self._clear_all()
self._cards = []
self._colored_letters_lower = []
self._colored_letters_upper = []
def _init_preview(self):
''' Set up customization toolbar, preview image '''
w = int(self._page._card_width)
h = int(self._page._card_height)
x = int(self._page._grid_x_offset + w + 12)
y = int(self._page._grid_y_offset + 40)
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(self._images_path, '../drawing.png'), w, h)
self.status.set_text(
_('Please choose image and audio objects from the Journal.'))
self._page._hide_cards()
if not hasattr(self, 'preview_image'):
self.preview_image = Sprite(self._page._sprites, 0, 0, pixbuf)
else:
self.preview_image.set_image(pixbuf)
self.preview_image.move((x, y))
self.preview_image.set_layer(100)
self._page._canvas.disconnect(self._page.button_press_event_id)
self._page._canvas.disconnect(self._page.button_release_event_id)
self._page.button_press_event_id = \
self._page._canvas.connect('button-press-event',
self._preview_press_cb)
self._page.button_release_event_id = \
self._page._canvas.connect('button-release-event',
self._dummy_cb)
def _alpha_cards(self):
for card in self._card_data:
self.current_card = self._card_data.index(card)
# Two-tone cards add some complexity.
if type(self._color_data[self.current_card][0]) == type([]):
stroke = self._test_for_stroke()
top = svg_str_to_pixbuf(
generate_card(
string=card[0],
colors=[
self._color_data[self.current_card][0][0],
'#FFFFFF'
],
scale=self._scale,
center=True))
bot = svg_str_to_pixbuf(
generate_card(
string=card[0],
colors=[
self._color_data[self.current_card][0][1],
'#FFFFFF'
],
scale=self._scale,
center=True))
# Where to draw the line
h1 = 9 / 16.
h2 = 1.0 - h1
bot.composite(top, 0, int(h1 * top.get_height()),
top.get_width(), int(h2 * top.get_height()), 0,
0, 1, 1, GdkPixbuf.InterpType.NEAREST, 255)
self._cards.append(Sprite(self._sprites, 0, 0, top))
else:
stroke = self._test_for_stroke()
self._cards.append(
Sprite(
self._sprites, 0, 0,
svg_str_to_pixbuf(
generate_card(
string='%s%s' %
(card[0].upper(), card[0].lower()),
colors=[
self._color_data[self.current_card][0],
'#FFFFFF'
],
stroke=stroke,
scale=self._scale,
center=True))))
def _load_card(self):
''' a card is a sprite and a message. '''
vadj = self._activity.scrolled_window.get_vadjustment()
vadj.set_value(0)
self._activity.scrolled_window.set_vadjustment(vadj)
self._cards[self.page].set_layer(2)
self._x_pos = self._margin
self._y_pos = self._cards[self.page].rect.y + \
self._cards[self.page].images[0].get_height() + self._lead
rect = gtk.gdk.Rectangle(0, 0, self._width, int(self._height * 2.5))
self._my_canvas.images[0].draw_rectangle(self._my_gc, True, *rect)
self.invalt(0, 0, self._width, int(self._height * 2.5))
text = self._card_data[self.page][1]
'''
for phrase in text.split('\n'):
self._x_pos = self._margin * 2
self._render_phrase(phrase, self._my_canvas, self._my_gc)
# self._x_pos = self._margin
self._y_pos += self._lead
'''
self._x_pos = self._margin * 2
self._render_phrase(text, self._my_canvas, self._my_gc)
self._x_pos = self._margin * 2
self._y_pos += self._lead
self._render_phrase(text.upper(), self._my_canvas, self._my_gc)
# Is there a picture for this page?
imagefilename = self._image_data[self.page]
if len(imagefilename) > 4 and \
os.path.exists(os.path.join(self._images_path, imagefilename)):
pixbuf = image_file_to_pixbuf(
os.path.join(self._images_path, imagefilename),
self._scale / 4)
if self._picture is None:
self._picture = Sprite(
self._sprites,
# int(self._width - 320 * self._scale / 2.5),
self._left,
GRID_CELL_SIZE,
pixbuf)
else:
self._picture.images[0] = pixbuf
self._picture.set_layer(2)
elif self._picture is not None:
self._picture.set_layer(0)
# Hide all the letter sprites.
for l in self._letters:
l.set_layer(0)
for l in self._colored_letters_lower:
l.set_layer(0)
for l in self._colored_letters_upper:
l.set_layer(0)
self._my_canvas.set_layer(0)
def __init__(self, canvas, lessons_path, images_path, sounds_path,
parent=None):
''' The general stuff we need to track '''
self._activity = parent
self._lessons_path = lessons_path
self._images_path = images_path
self._sounds_path = sounds_path
self._colors = profile.get_color().to_string().split(',')
self._card_data = []
self._color_data = []
self._image_data = []
self._media_data = [] # (image sound, letter sound)
self._word_data = []
self._deja_vu = []
# Starting from command line
if self._activity is None:
self._sugar = False
self._canvas = canvas
else:
self._sugar = True
self._canvas = canvas
self._activity.show_all()
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK)
self._canvas.connect("draw", self.__draw_cb)
self._canvas.connect("button-press-event", self._button_press_cb)
self._canvas.connect("button-release-event", self._button_release_cb)
self._canvas.connect("key_press_event", self._keypress_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height()
self._card_width = int((self._width / XDIM)) - GUTTER * 2
self._card_height = int((self._height - GRID_CELL_SIZE) / YDIM) \
- GUTTER * 2
self._grid_x_offset = int(
(self._width - XDIM * (self._card_width + GUTTER * 2)) / 2)
self._grid_y_offset = 0
self._scale = self._card_width / 80.
self._sprites = Sprites(self._canvas)
self.current_card = 0
self._cards = []
self._pictures = []
self._press = None
self._release = None
self.timeout = None
self._my_canvas = Sprite(
self._sprites, 0, 0, svg_str_to_pixbuf(genblank(
self._width, self._height, (self._colors[0],
self._colors[0]))))
self._my_canvas.type = 'background'
self.load_level(os.path.join(self._lessons_path, 'alphabet' + '.csv'))
self.new_page()
def load_from_journal(self, journal_data):
for card in self._card_data:
alphabet = card[0]
if alphabet in journal_data:
for images in journal_data[alphabet]:
imagedataobject = datastore.get(images[0])
audiodataobject = datastore.get(images[1])
if imagedataobject and audiodataobject:
imagepath = imagedataobject.get_file_path()
pixbuf = image_file_to_pixbuf(imagepath, self._card_width,
self._card_height)
audiopath = audiodataobject.get_file_path()
s = Sprite(self._sprites, 0, 0, pixbuf)
self._image_data[alphabet].append((s, audiopath))
self._pictures.append(s)
def _image_cards(self):
x = self._grid_x_offset + GUTTER
y = self._grid_y_offset + GUTTER
if len(self._pictures) > 0:
for card in self._pictures:
card.set_layer(100)
return
for card in self._card_data:
self.current_card = self._card_data.index(card)
imagefilename = self._image_data[self.current_card]
imagepath = os.path.join(self._images_path, imagefilename)
pixbuf = image_file_to_pixbuf(imagepath, self._card_width,
self._card_height)
self._pictures.append(Sprite(self._sprites, x, y, pixbuf))
x += self._card_width + GUTTER * 2
if x > self._width - (self._card_width / 2):
x = self._grid_x_offset + GUTTER
y += self._card_height + GUTTER * 2
def __init__(self,
canvas,
lessons_path,
images_path,
sounds_path,
parent=None):
''' The general stuff we need to track '''
self._activity = parent
self._lessons_path = lessons_path
self._images_path = images_path
self._sounds_path = sounds_path
self._colors = profile.get_color().to_string().split(',')
self._card_data = []
self._color_data = []
self._image_data = []
self._word_data = []
self.chosen_image = None
# Starting from command line
if self._activity is None:
self._sugar = False
self._canvas = canvas
else:
self._sugar = True
self._canvas = canvas
self._activity.show_all()
self._canvas.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self._canvas.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK)
self._canvas.connect("draw", self.__draw_cb)
self.button_release_event_id = \
self._canvas.connect("button-release-event", self._button_release_cb)
self.button_press_event_id = \
self._canvas.connect("button-press-event", self._button_press_cb)
self._canvas.connect("key_press_event", self._keypress_cb)
self._width = Gdk.Screen.width()
self._height = Gdk.Screen.height()
self._card_height = int((self._height - GRID_CELL_SIZE) / YDIM) \
- GUTTER * 2
self._card_width = int(self._card_height * 4 / 3.)
self._grid_x_offset = int(
(self._width - XDIM * (self._card_width + GUTTER * 2)) / 2)
self._grid_y_offset = 0
self._scale = self._card_width / 80.
self._sprites = Sprites(self._canvas)
self.current_card = 0
self._cards = []
self._pictures = []
self._press = None
self._release = None
self.timeout = None
self.target = 0
self.answers = []
self._my_canvas = Sprite(
self._sprites, 0, 0,
svg_str_to_pixbuf(
genblank(self._width, self._height,
(self._colors[0], self._colors[0]))))
self._my_canvas.type = 'background'
self._smile = Sprite(
self._sprites, int(self._width / 4), int(self._height / 4),
GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(self._activity.activity_path, 'images',
'correct.png'), int(self._width / 2),
int(self._height / 2)))
self._frown = Sprite(
self._sprites, int(self._width / 4), int(self._height / 4),
GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(self._activity.activity_path, 'images',
'wrong.png'), int(self._width / 2),
int(self._height / 2)))
self.load_level(os.path.join(self._lessons_path, 'alphabet' + '.csv'))
# Create the cards we'll need
self._alpha_cards()
self.load_from_journal(self._activity.data_from_journal)
self.new_page()
def __init__(self,
canvas,
lessons_path,
images_path,
sounds_path,
level,
parent=None):
''' The general stuff we need to track '''
self._activity = parent
self._lessons_path = lessons_path
self._images_path = images_path
self._sounds_path = sounds_path
self._card_data = []
self._color_data = []
self._image_data = []
self._media_data = [] # (image sound, letter sound)
self._word_data = []
_logger.debug(ALPHABET)
# Starting from command line
if self._activity is None:
self._sugar = False
self._canvas = canvas
else:
self._sugar = True
self._canvas = canvas
self._activity.show_all()
self._canvas.set_flags(gtk.CAN_FOCUS)
self._canvas.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self._canvas.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self._canvas.connect("expose-event", self._expose_cb)
self._canvas.connect("button-press-event", self._button_press_cb)
self._canvas.connect("button-release-event", self._button_release_cb)
self._canvas.connect("key_press_event", self._keypress_cb)
self._width = gtk.gdk.screen_width()
self._height = gtk.gdk.screen_height()
self._scale = self._width / 240.
self._sprites = Sprites(self._canvas)
self.page = 0
self._cards = []
self._letters = []
self._colored_letters_lower = []
self._colored_letters_upper = []
self._picture = None
self._press = None
self._release = None
# self.gplay = None
self.aplay = None
self.vplay = None
self._final_x = 0
self._lead = int(self._scale * 15)
self._margin = int(self._scale * 3)
self._left = self._margin # int((self._width - self._scale * 60) / 2.)
self._x_pos = self._margin
self._y_pos = self._lead
self._offset = int(self._scale * 9) # self._width / 30.)
self._looking_at_word_list = False
self._my_canvas = Sprite(
self._sprites, 0, 0,
gtk.gdk.Pixmap(self._canvas.window, self._width,
int(self._height * 2.75), -1))
self._my_canvas.set_layer(0)
self._my_gc = self._my_canvas.images[0].new_gc()
self._my_gc.set_foreground(
self._my_gc.get_colormap().alloc_color('#FFFFFF'))
for c in ALPHABET:
self._letters.append(
Sprite(
self._sprites, 0, 0,
svg_str_to_pixbuf(
generate_card(string=c,
colors=['#000000', '#000000'],
font_size=12 * self._scale,
background=False))))
self.load_level(os.path.join(self._lessons_path, level + '.csv'))
self.new_page()
def new_page(self):
''' Load a new page: a card and a message '''
if self.page == len(self._word_data):
self.page = 0
if self._sugar:
if self.page < len(self._card_data):
if hasattr(self._activity, 'sounds_combo'):
self._activity.sounds_combo.set_active(self.page)
if self.page == len(self._cards) and \
self.page < len(self._card_data):
# Two-tone cards add some complexity.
if type(self._color_data[self.page][0]) == type([]):
stroke = self._test_for_stroke()
top = svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0].lower(),
colors=[self._color_data[self.page][0][0], '#FFFFFF'],
scale=self._scale,
center=True))
bot = svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0].lower(),
colors=[self._color_data[self.page][0][1], '#FFFFFF'],
scale=self._scale,
center=True))
# Where to draw the line
h1 = 9 / 16.
h2 = 1.0 - h1
bot.composite(top, 0, int(h1 * top.get_height()),
top.get_width(), int(h2 * top.get_height()), 0,
0, 1, 1, gtk.gdk.INTERP_NEAREST, 255)
self._cards.append(
Sprite(
self._sprites, # self._left,
int(self._width - 320 * self._scale / 2.5),
GRID_CELL_SIZE,
top))
top = svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0][0].lower(),
colors=[self._color_data[self.page][0][0], '#FFFFFF'],
font_size=12 * self._scale,
background=False,
stroke=stroke))
bot = svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0][0].lower(),
colors=[self._color_data[self.page][0][1], '#FFFFFF'],
font_size=12 * self._scale,
background=False,
stroke=stroke))
bot.composite(top, 0, int(h1 * top.get_height()),
top.get_width(), int(h2 * top.get_height()), 0,
0, 1, 1, gtk.gdk.INTERP_NEAREST, 255)
self._colored_letters_lower.append(
Sprite(self._sprites, 0, 0, top))
top = svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0][0].upper(),
colors=[self._color_data[self.page][0][0], '#FFFFFF'],
font_size=12 * self._scale,
background=False,
stroke=stroke))
bot = svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0][0].upper(),
colors=[self._color_data[self.page][0][1], '#FFFFFF'],
font_size=12 * self._scale,
background=False,
stroke=stroke))
bot.composite(top, 0, int(h1 * top.get_height()),
top.get_width(), int(h2 * top.get_height()), 0,
0, 1, 1, gtk.gdk.INTERP_NEAREST, 255)
self._colored_letters_upper.append(
Sprite(self._sprites, 0, 0, top))
else:
stroke = self._test_for_stroke()
self._cards.append(
Sprite(
self._sprites,
int(self._width - 320 * self._scale / 2.5),
GRID_CELL_SIZE,
svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0].lower(),
colors=[
self._color_data[self.page][0], '#FFFFFF'
],
stroke=stroke,
scale=self._scale,
center=True))))
self._colored_letters_lower.append(
Sprite(
self._sprites, 0, 0,
svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0].lower(),
colors=[
self._color_data[self.page][0], '#FFFFFF'
],
font_size=12 * self._scale,
background=False,
stroke=stroke))))
self._colored_letters_upper.append(
Sprite(
self._sprites, 0, 0,
svg_str_to_pixbuf(
generate_card(
string=self._card_data[self.page][0].upper(),
colors=[
self._color_data[self.page][0], '#FFFFFF'
],
font_size=12 * self._scale,
background=False,
stroke=stroke))))
self._hide_cards()
if self.page >= len(self._card_data):
self.read()
else:
self._load_card()
self._looking_at_word_list = False
