def __init__(self, animitem):
self.animitem = animitem
self.anchorgroup = None
self.anchorgroup = \
goocanvas.Group(
parent = animitem.anim.doc.rootitem,
)
self.anchorbound = \
goocanvas.Rect(
parent = self.anchorgroup,
stroke_color_rgba = 0x000000FFL,
line_width = 3)
self.down = \
goocanvas.Image(
parent = self.anchorgroup,
pixbuf = gcompris.utils.load_pixmap("anim/down.png"),
)
self.down.connect("button_press_event",
self.animitem.down_size, False)
self.up = \
goocanvas.Image(
parent = self.anchorgroup,
pixbuf = gcompris.utils.load_pixmap("anim/up.png"),
)
self.up.connect("button_press_event",
self.animitem.up_size, False)
def load_asteroid(self):
self.count = 1
self.asteroid_rootitem = goocanvas.Group(parent=self.rootitem)
space_shuttle_x = 200.0
right_asteroid_x = 550.0
space_shuttle_y = 530
right_asteroid_y = -20
# Load the space shuttle
self.space_shuttle = goocanvas.Image(
parent=self.asteroid_rootitem,
pixbuf=gcompris.utils.load_pixmap(
"intro_gravity/space_shuttle.svg"),
x=space_shuttle_x,
y=space_shuttle_y)
# Pick a random asteroid and load image
asteroid = random.choice([0, 1, 2, 3, 4])
image = "intro_gravity/asteroid" + str(asteroid) + ".jpg"
self.asteroid = goocanvas.Image(
parent=self.asteroid_rootitem,
pixbuf=gcompris.utils.load_pixmap(image),
x=right_asteroid_x,
y=right_asteroid_y)
self.asteroid_rootitem.lower(self.ship_instance.tux_spaceship)
gobject.timeout_add(30, self.check_asteroid)
def draw_tools(self):
self.root_toolitem = \
goocanvas.Group(
parent = self.rootitem,
)
goocanvas.Image(
parent = self.root_toolitem,
pixbuf = gcompris.utils.load_pixmap("anim/tool-selector.png"),
x = 5,
y = 5.0,
width = 107.0,
height = 517.0,
)
x1 = 11.0
x2 = 56.0
y = 11.0
stepy = 45
start_tool = 0
if gcompris.sugar_detected():
start_tool = 2
# Display the tools
for i in range(start_tool,len(self.tools)):
# Exclude the anim specific buttons
if self.gcomprisBoard.mode == 'draw':
if self.tools[i][0]=="MOVIE" or self.tools[i][0]=="PICTURE":
continue
if(i%2):
theX = x2
else:
theX = x1
item = \
goocanvas.Image(
parent = self.root_toolitem,
pixbuf = gcompris.utils.load_pixmap(self.tools[i][1]),
tooltip = self.tools[i][4],
x=theX,
y=y
)
gcompris.utils.item_focus_init(item, None)
item.connect("button_press_event", self.tool_item_event, i)
if i%2:
y += stepy
if(self.tools[i][0]=="SELECT"):
self.select_tool = item
self.select_tool_number = i
# Always select the SELECT item by default
self.current_tool = i
self.old_tool_item = item
self.old_tool_item.props.pixbuf = \
gcompris.utils.load_pixmap(self.tools[i][2])
gcompris.set_cursor(self.tools[i][3]);
def flame(self, x, y):
pixbuf = gcompris.utils.load_pixmap("land_safe/flame1.png")
self.flame_1 = goocanvas.Image(parent=self.flame_rootitem,
pixbuf=pixbuf,
x=x,
y=y + 68)
pixbuf = gcompris.utils.load_pixmap("land_safe/flame2.png")
self.flame_2 = goocanvas.Image(parent=self.flame_rootitem,
pixbuf=pixbuf,
x=x,
y=y + 65)
pixbuf = gcompris.utils.load_pixmap("land_safe/flame3.png")
self.flame_3 = goocanvas.Image(parent=self.flame_rootitem,
pixbuf=pixbuf,
x=x,
y=y + 65)
pixbuf = gcompris.utils.load_pixmap("land_safe/flame_left.png")
self.flame_left = goocanvas.Image(parent=self.flame_rootitem,
pixbuf=pixbuf,
x=x - 27,
y=y + 55)
pixbuf = gcompris.utils.load_pixmap("land_safe/flame_right.png")
self.flame_right = goocanvas.Image(parent=self.flame_rootitem,
pixbuf=pixbuf,
x=x + 25,
y=y + 55)
def draw_playing_area(self):
x1=self.playing_area[0]
y1=self.playing_area[1]
x2=self.playing_area[2]
y2=self.playing_area[3]
# The CanvasGroup for the playing area.
self.root_playingitem = \
goocanvas.Group(
parent = self.rootitem,
)
self.root_playingitem.props.visibility = goocanvas.ITEM_INVISIBLE
# intervall = 1000 / anim_speed
self.anim_speed=5
run = \
goocanvas.Image(
parent = self.root_playingitem,
pixbuf = gcompris.utils.load_pixmap("anim/down.png"),
x = 15,
y = 410,
width = 20,
height = 20,
)
run.connect("button_press_event", self.speed_event,False)
self.speed_item = \
goocanvas.Text(
parent = self.root_playingitem,
text=self.anim_speed,
font = gcompris.skin.get_font("gcompris/board/medium"),
x=52,
y=420,
anchor=gtk.ANCHOR_CENTER,
)
run = \
goocanvas.Image(
parent = self.root_playingitem,
pixbuf = gcompris.utils.load_pixmap("anim/up.png"),
x = 70,
y = 410,
width = 20,
height = 20,
)
run.connect("button_press_event", self.speed_event,True)
# And finaly a STOP icon
run = \
goocanvas.Image(
parent = self.root_playingitem,
pixbuf = gcompris.utils.load_pixmap("anim/draw.svg"),
x = 16,
y = 110,
)
run.connect("button_press_event", self.stop_event, True)
def __init__(self, board, root, x, y, index,
board_size,
scale):
self.board = board
self.itemgroup = goocanvas.Group(parent = root)
self.itemgroup.translate(x, y)
self.scale = scale
if (index == (board_size-1)):
pixbuf_case = self.board.pixmap_case_last
pixbuf_mask = self.board.pixmap_mask_last
else:
pixbuf_case = self.board.pixmap_case
pixbuf_mask = self.board.pixmap_mask
item = goocanvas.Image(
parent = self.itemgroup,
pixbuf = pixbuf_case,
x=0,
y=0)
bounds = item.get_bounds()
# Add a little zoom offset to make sure items stick well
item.scale(scale + 0.01, scale)
self.ombre = goocanvas.Image(
parent = self.itemgroup,
pixbuf = self.board.pixmap_ombre,
x=0,
y=0)
self.ombre.props.visibility = goocanvas.ITEM_INVISIBLE
bounds = self.ombre.get_bounds()
self.ombre.scale(scale, scale)
self.ball = goocanvas.Image(
parent = self.itemgroup,
x=0,
y=0)
self.ball.props.visibility = goocanvas.ITEM_INVISIBLE
item = goocanvas.Image(
parent = self.itemgroup,
pixbuf = pixbuf_mask,
x=0,
y=0)
bounds = item.get_bounds()
item.scale(scale, scale)
if ((index+1)%5 == 0):
goocanvas.Text(
parent = self.itemgroup,
x = (bounds.x2-bounds.x1)/2,
y = -10,
fill_color_rgba = 0x000000ffL,
font=gcompris.skin.get_font("gcompris/board/small bold"),
anchor = gtk.ANCHOR_CENTER,
text = index + 1)
def init_boats(self):
self.left_boat.x = self.border_x
self.left_boat.y = self.left_initial_boat_y
self.right_boat.x = self.left_boat.x
self.right_boat.y = self.right_initial_boat_y
self.left_boat.angle = 0
self.right_boat.angle = 0
# Display the player boats
if(self.left_boat.item):
self.left_boat.item.remove()
pixmap = gcompris.utils.load_pixmap("searace/top_boat_red.png")
self.left_boat.item = goocanvas.Image(parent = self.rootitem,
pixbuf = pixmap,
x=self.left_boat.x,
y=self.left_boat.y,
)
self.left_boat.item.raise_(None)
self.left_boat.item.connect("button_press_event", self.ruler_item_event)
self.left_boat.item.connect("button_release_event", self.ruler_item_event)
self.left_boat.item.connect("motion_notify_event", self.ruler_item_event)
if(self.right_boat.item):
self.right_boat.item.remove()
pixmap = gcompris.utils.load_pixmap("searace/top_boat_green.png")
self.right_boat.item = goocanvas.Image(
parent = self.rootitem,
pixbuf = pixmap,
x=self.right_boat.x,
y=self.right_boat.y,
)
self.right_boat.item.raise_(None)
self.right_boat.item.connect("button_press_event", self.ruler_item_event)
self.right_boat.item.connect("button_release_event", self.ruler_item_event)
self.right_boat.item.connect("motion_notify_event", self.ruler_item_event)
# Reset command line processing as well.
self.left_boat.line = 0
self.right_boat.line = 0
self.left_boat.arrived = False
self.right_boat.arrived = False
self.left_boat.won = False
self.right_boat.won = False
self.left_boat.speeditem.props.text = ""
self.right_boat.speeditem.props.text = ""
self.statusitem.props.text = ""
# Let the user enter comands
self.left_boat.tv.set_editable(True)
if self.gcomprisBoard.mode == '1player':
self.tux_move()
else:
self.right_boat.tv.set_editable(True)
def __init__(self, game_instance, rootitem, land_rootitem, level):
self.rootitem = rootitem
self.game = game_instance
self.level = level
self.flame_rootitem = goocanvas.Group(parent = rootitem)
self.land_rootitem = land_rootitem
self.land_rootitem.lower(self.flame_rootitem)
x = gcompris.BOARD_WIDTH/2
y = 10
# Load flames and hide them
self.flame(x + 15, y)
self.flame_1.props.visibility = goocanvas.ITEM_INVISIBLE
self.flame_2.props.visibility = goocanvas.ITEM_INVISIBLE
self.flame_3.props.visibility = goocanvas.ITEM_INVISIBLE
self.flame_left.props.visibility = goocanvas.ITEM_INVISIBLE
self.flame_right.props.visibility = goocanvas.ITEM_INVISIBLE
# Load landing area
self.land_x = random.randrange(100, 400)
self.landing_red = goocanvas.Image(
parent = self.land_rootitem,
pixbuf = gcompris.utils.load_pixmap("land_safe/landing_area_red.png"),
width = 145 - (self.level * 12),
x = self.land_x,
y = 365)
self.landing_red.props.visibility = goocanvas.ITEM_INVISIBLE
self.landing_green = goocanvas.Image(
parent = self.land_rootitem,
pixbuf = gcompris.utils.load_pixmap("land_safe/landing_area_green.png"),
width = 145 - (self.level * 12),
x = self.land_x,
y = 365)
# Load spaceship
pixbuf = gcompris.utils.load_pixmap("land_safe/rocket.png")
self.spaceship_image = goocanvas.Image(
parent = rootitem,
pixbuf = pixbuf,
x = x,
y = y
)
# Declaring variables
self.y = 0.005
self.x = 0
self.key_vertical = 4
self.zoom_out = False
self.scale = 1
# Load fuel, altitude and landing area
self.info = Display(self, rootitem)
# Set to true to stop the timeout
self.done = False
def __init__(self, root, scale, image, number_balls):
self.focus = False
self.number_balls = number_balls
self.itemgroup = goocanvas.Group(parent = root)
self.background = goocanvas.Image(
parent = self.itemgroup,
pixbuf = gcompris.utils.load_pixmap("bargame/enumerate_answer.png"),
)
answer_bounds = self.background.get_bounds()
gcompris.utils.item_focus_init(self.background, None)
self.itemgroup.translate(gcompris.BOARD_WIDTH - 180,
gcompris.BOARD_HEIGHT - answer_bounds.y2 \
- answer_bounds.y1 - 10)
self.background_focused = goocanvas.Image(
parent = self.itemgroup,
pixbuf = gcompris.utils.load_pixmap("bargame/enumerate_answer_focus.png"),
)
gcompris.utils.item_focus_init(self.background_focused, self.background)
self.background_focused.props.visibility = goocanvas.ITEM_INVISIBLE
self.icone = goocanvas.Image(
parent = self.itemgroup,
pixbuf = image)
bounds = self.icone.get_bounds()
self.icone.scale(scale, scale)
(x, y) = root.get_canvas().convert_from_item_space(self.itemgroup, 10, 20)
(x, y) = root.get_canvas().convert_to_item_space(self.icone, x, y)
self.icone.translate(x, y)
gcompris.utils.item_focus_init(self.icone, self.background)
self.value = number_balls[0]
self.text = goocanvas.Text(
parent = self.itemgroup,
x = answer_bounds.x2-answer_bounds.x1 - 50,
y = 40,
fill_color_rgba=0xff0000ffL,
font=gcompris.skin.get_font("gcompris/board/huge bold"),
anchor=gtk.ANCHOR_CENTER,
text = self.value
)
gcompris.utils.item_focus_init(self.text, self.background)
self.background.connect("button_press_event",self.answer_event)
self.background_focused.connect("button_press_event",self.answer_event)
self.icone.connect("button_press_event",self.answer_event)
self.text.connect("button_press_event",self.answer_event)
def display_current_level(self):
gcompris.set_background(self.gcomprisBoard.canvas.get_root_item(),
self.melodylist[self.theme][0]['background'])
gcompris.bar_set_level(self.gcomprisBoard)
gcompris.sound.policy_set(gcompris.sound.PLAY_AND_INTERRUPT)
# Create our rootitem. We put each canvas item in it so at the end we
# only have to kill it. The canvas deletes all the items it contains automaticaly.
self.rootitem = goocanvas.Group(
parent=self.gcomprisBoard.canvas.get_root_item())
# Put the theme switcher button
self.switch_item = goocanvas.Image(
parent=self.rootitem,
pixbuf=gcompris.utils.load_pixmap("melody/switch.png"),
x=10,
y=10)
self.switch_item.connect("button_press_event", self.switch_item_event)
# This item is clickeable and it must be seen
gcompris.utils.item_focus_init(self.switch_item, None)
# Put the sound buttons
self.sound_list = self.melodylist[self.theme][1]
for i in self.sound_list:
self.sound_item = goocanvas.Image(
parent=self.rootitem,
pixbuf=gcompris.utils.load_pixmap(i['image']),
x=i['x'],
y=i['y'])
self.sound_item.connect("button_press_event",
self.sound_item_event, i)
# This item is clickeable and it must be seen
gcompris.utils.item_focus_init(self.sound_item, None)
self.bang_item = goocanvas.Image(
parent=self.rootitem,
pixbuf=gcompris.utils.load_pixmap(
self.melodylist[self.theme][0]['hittool']),
)
self.bang_item.props.visibility = goocanvas.ITEM_INVISIBLE
self.hitofset_x = self.melodylist[self.theme][0]['hitofset_x']
self.hitofset_y = self.melodylist[self.theme][0]['hitofset_y']
self.waitOK(self.rootitem)
def Render(self):
# get the previous track from the parent sequence (if any)
pixels_per_second = self.parent.get_pixels_per_second()
y_top = 22
# get a reference to the 2 main canvas objects & theme
theme = self.parent.project.theme
canvas_left = self.parent.project.form.TimelineCanvas_Left
canvas_right = self.parent.project.form.TimelineCanvas_Right
# Add an item to the goocanvas
root_left = canvas_left.get_root_item()
root_right = canvas_right.get_root_item()
# load marker image
imgMarker = gtk.image_new_from_file(
"%s/libreshot/themes/%s/marker.png" %
(self.parent.project.form.libreshot_path, theme))
imgMarker_Width = imgMarker.get_pixbuf().get_width()
offset = float(imgMarker_Width) / float(2.0)
# determine position
x = pixels_per_second * self.position_on_track
# Add Left Image to Group
image1 = goocanvas.Image(parent=root_right,
pixbuf=imgMarker.get_pixbuf(),
x=x - offset,
y=y_top)
# attach button click event to marker image
image1.connect("button_press_event", self.on_marker_press)
def clue_left(self, event, target, item):
self.callout1 = goocanvas.Image(
parent=self.root,
pixbuf=gcompris.utils.load_pixmap("braille_lotto/callout1.svg"),
x=230,
y=250,
)
self.status_one = goocanvas.Text(
parent=self.root,
text="",
x=315,
y=310,
width=130,
font=gcompris.skin.get_font("gcompris/board/small"),
anchor=gtk.ANCHOR_CENTER,
)
if (self.check_random[self.counter] in self.ticket_array[0:6]):
#Translators : Do not translate the token {column}
self.status_one.props.text = \
_("Hey, you have it. It is there in your {column} column").format( column = self.findColumn() )
else:
self.status_one.props.text = _(
"Oops, this number is not in your ticket!")
self.timerAnim = gobject.timeout_add(1500, self.hideCalloutLeft)
def display_palette(self, orig_x, orig_y, palette):
gap_x = 10
gap_y = 10
number_item_x = 12
number_item_y = 2
for i in range(0, self.number_max_of_color_x *
self.number_max_of_color_y):
x = i % number_item_x
y = i / number_item_x
palette_x = i % self.palette_number_of_item_x
palette_y = i / self.palette_number_of_item_x
image = palette.subpixbuf(palette_x * self.palette_item_width,
palette_y * self.palette_item_height,
self.palette_item_width,
self.palette_item_height)
coord_x = orig_x + x * (self.palette_item_width + gap_x)
coord_y = orig_y + y * (self.palette_item_height + gap_y)
item = goocanvas.Image(parent=self.rootitem,
pixbuf=image,
x=coord_x,
y=coord_y)
gcompris.utils.item_focus_init(item, None)
item.connect("button_press_event", self.set_color_item_event,
(palette_x, palette_y, coord_x, coord_y))
def display_condition(self, condition):
#print condition
# Calc the center
cx = condition[0][0] + (condition[0][2] - condition[0][0]) / 2
cy = condition[0][1] + (condition[0][3] - condition[0][1]) / 2
pixmap = gcompris.utils.load_pixmap("searace/arrow.png")
item = goocanvas.Image(
parent=self.root_weather_item,
pixbuf=pixmap,
x=cx - pixmap.get_width() / 2,
y=cy - pixmap.get_height() / 2,
)
gcompris.utils.item_rotate_relative(item, condition[1][0])
item.connect("button_press_event", self.ruler_item_event)
item.connect("button_release_event", self.ruler_item_event)
item.connect("motion_notify_event", self.ruler_item_event)
# Text number
item = goocanvas.Text(parent=self.root_weather_item,
text=condition[1][1],
font=gcompris.skin.get_font("gcompris/content"),
x=cx,
y=cy,
fill_color_rgba=0xFFFFFFFFL,
anchor=gtk.ANCHOR_CENTER)
item.connect("button_press_event", self.ruler_item_event)
item.connect("button_release_event", self.ruler_item_event)
item.connect("motion_notify_event", self.ruler_item_event)
return
def display_game(self):
self.rootitem = \
goocanvas.Group(parent = self.gcomprisBoard.canvas.get_root_item())
self.create_components(self.gcomprisBoard.level)
# Display the tools
x = 12
y = 10
for i in range(0, len(self.tools)):
item = goocanvas.Image(parent=self.rootitem,
pixbuf=gcompris.utils.load_pixmap(
self.tools[i][1]),
x=x,
y=y)
x += 45
item.connect("button_press_event", self.tool_item_event, i)
if (self.tools[i][0] == "SELECT"):
self.select_tool = item
self.select_tool_number = i
# Always select the SELECT item by default
self.current_tool = i
self.old_tool_item = item
self.old_tool_item.props.pixbuf = gcompris.utils.load_pixmap(
self.tools[i][2])
gcompris.set_cursor(self.tools[i][3])
# Add the item in self.tools for later use
self.tools[i].append(item)
def __init__(self, computer, image, x, y):
self.computer = computer
self.canvas = computer.gcomprisBoard.canvas
self.rootitem = computer.rootitem
self.comp_rootitem = goocanvas.Group(parent=self.rootitem, )
pixmap = gcompris.utils.load_pixmap(self.image)
self.x = x
self.y = y
self.width = 70
self.height = 70
self.center_x = self.width / 2
self.center_y = self.height / 2
self.component_item_offset_x = 0
self.component_item_offset_y = 0
self.component_item = goocanvas.Image(
parent=self.comp_rootitem,
pixbuf=pixmap,
x=self.x - self.center_x,
y=self.y - self.center_y,
width=self.width,
height=self.height,
)
self.component_item.connect("button_press_event", self.component_move,
self)
self.component_item.connect("motion_notify_event", self.component_move,
self)
def __init__(self, board, root, prof_image):
self.board = board
self.prof_item = goocanvas.Image(
parent = root,
y = 210
)
def start(self):
self.board_paused = False
self.game_start = False
# Create our rootitem. We put each canvas item in it so at the end we
# only have to kill it. The canvas deletes all the items it contains
# automaticaly.
self.rootitem = goocanvas.Group(
parent=self.gcomprisBoard.canvas.get_root_item())
land_rootitem = goocanvas.Group(parent=self.rootitem)
# Set a background image
level = str(self.gcomprisBoard.level)
image = 'land_safe/background' + level + '.jpg'
gcompris.set_background(self.gcomprisBoard.canvas.get_root_item(),
image)
#Set the land
image = 'land_safe/land' + str(level) + '.png'
pixbuf = gcompris.utils.load_pixmap(image)
land = goocanvas.Image(parent=land_rootitem,
pixbuf=pixbuf,
x=-550,
y=gcompris.BOARD_HEIGHT - 125)
land.lower(None)
# Text for Gravity
gravity = str(0.58 * self.gcomprisBoard.level)
text = _('Gravity: %s') % (gravity)
gravity_text = goocanvas.Text(parent=self.rootitem,
x=760,
y=50,
fill_color="white",
anchor=gtk.ANCHOR_E,
alignment=pango.ALIGN_CENTER,
text=_(text))
bounds = gravity_text.get_bounds()
gap = 20
gravity_back = goocanvas.Rect(parent=self.rootitem,
radius_x=6,
radius_y=6,
x=bounds.x1 - gap,
y=bounds.y1 - gap,
width=bounds.x2 - bounds.x1 + gap * 2,
height=bounds.y2 - bounds.y1 + gap * 2,
stroke_color_rgba=0xFFFFFFFFL,
fill_color_rgba=0xCCCCCC44L)
# Load spaceship
self.space_ship = Spaceship(self, self.rootitem, land_rootitem,
self.gcomprisBoard.level)
gcompris.bar_set_level(self.gcomprisBoard)
# Set the buttons we want in the bar
gcompris.bar_set(gcompris.BAR_LEVEL)
gcompris.bar_location(2, -1, 0.5)
self.ready_button(self.rootitem)
def load_crash_image(self):
bounds = self.satellite.get_bounds()
self.satellite.remove()
crash_image = goocanvas.Image(
parent = self.rootitem,
pixbuf = gcompris.utils.load_pixmap("place_your_satellite/crash.png"),
x = bounds.x1,
y = bounds.y1)
def _BIcon(self):
pb = gtk.gdk.pixbuf_new_from_file(self.m_sDataDir +
self.m_oDictBlock["Icon"])
xpos = self.width / 2 - pb.get_width() / 2
ypos = self.height / 2 - pb.get_height() / 2
icon = goocanvas.Image(pixbuf=pb, x=xpos, y=ypos)
self.wGroup.add_child(icon)
self.widgets["pb"] = icon
def __init__(self, rootitem, move_back_callback):
rootitem = goocanvas.Group(parent = rootitem)
item = \
goocanvas.Rect(parent = rootitem,
x = 30,
y = 20,
width = 740,
height = 460,
stroke_color_rgba = 0x222222CCL,
fill_color_rgba = 0x999999EEL,
radius_x = 5.0,
radius_y = 5.0,
line_width = 2.0)
item.connect("button_press_event", move_back_callback)
# Place alphabets & numbers in array format
for index, letter in enumerate(string.ascii_uppercase[:10]):
BrailleChar(rootitem, index*(CELL_WIDTH+40)+60,
40, 38, letter ,COLOR_ON, COLOR_OFF, CIRCLE_FILL,
CIRCLE_STROKE,True ,False ,True , None)
for index, letter in enumerate(string.ascii_uppercase[10:20]):
BrailleChar(rootitem, index*(CELL_WIDTH+40)+60,
130, 38, letter ,COLOR_ON, COLOR_OFF, CIRCLE_FILL,
CIRCLE_STROKE,True ,False ,True , None)
# Put the W at the end to align the braille codes properly
for index, letter in enumerate(['U', 'V', 'X', 'Y', 'Z']):
BrailleChar(rootitem, index*(CELL_WIDTH+40)+60,
220, 38, letter ,COLOR_ON, COLOR_OFF, CIRCLE_FILL,
CIRCLE_STROKE,True ,False ,True , None)
BrailleChar(rootitem, (index + 2) *(CELL_WIDTH+40)+60,
220, 38, 'W' ,COLOR_ON, COLOR_OFF, CIRCLE_FILL,
CIRCLE_STROKE,True ,False ,True , None)
# The number line (Keep it aligned with the ASCII in the Braille sense)
for index in range(0, 9):
BrailleChar(rootitem, index *(CELL_WIDTH + 40)+60,
310, 38, index + 1,COLOR_ON, COLOR_OFF, CIRCLE_FILL,
CIRCLE_STROKE, True ,False ,True , None)
BrailleChar(rootitem, 9 *(CELL_WIDTH + 40)+60,
310, 38, 0 ,COLOR_ON, COLOR_OFF, CIRCLE_FILL,
CIRCLE_STROKE, True ,False ,True , None)
# The math operators +-*/
for index, value in enumerate( SYMBOL ):
BrailleChar(rootitem,index * (CELL_WIDTH + 40) + 60,
400 , 38, SYMBOL[index], COLOR_ON, COLOR_OFF, CIRCLE_FILL,
CIRCLE_STROKE,True ,False ,True , None)
# Move back item
item = goocanvas.Image(parent = rootitem,
pixbuf = gcompris.utils.load_pixmap("braille_alphabets/back.svg"),
x = 430,
y = 400,
tooltip = _("Back to the activity")
)
gcompris.utils.item_focus_init(item, None)
item.connect("button_press_event", move_back_callback)
def restore(self, anim_):
AnimItem.restore(self, anim_)
pixbuf = gcompris.utils.load_pixmap(self.image)
self.item = \
goocanvas.Image(
parent = self.rootitem,
pixbuf = pixbuf,
)
AnimItem.init_item(self)
def crash_image(self):
x = self.spaceship_image.get_bounds().x1
self.spaceship_image.remove()
pixbuf = gcompris.utils.load_pixmap("land_safe/crash.png")
explosion = goocanvas.Image(parent=self.rootitem,
pixbuf=pixbuf,
x=x - 20,
y=340)
self.game.crash()
def __init__(self, root, x, y, scale, image):
self.ball = goocanvas.Image(
parent = root,
pixbuf = image)
bounds = self.ball.get_bounds()
self.ball.scale(scale, scale)
(x, y) = root.get_canvas().convert_to_item_space(self.ball, x, y)
self.ball.translate(x, y)
def __init__(self, rootitem, x, y, planet_image):
self.rootitem = rootitem
self.scale = 0
self.x = x
self.y = y
self.planet = goocanvas.Image(
parent=rootitem,
pixbuf=gcompris.utils.load_pixmap("intro_gravity/" + planet_image),
x=0,
y=0)
def stone_init(self):
if self.player_stone:
self.player_stone.remove()
self.player_stone = \
goocanvas.Image(
parent = self.rootitem,
pixbuf = gcompris.utils.load_pixmap("connect4/stone_%d.png"
% self.cur_player),
x=0,
y=-20 )
self.update_stone2()
def __init__(self, frame):
self.dragging = False
self.lastPos = (0,0)
self.tool = FITSCanvas.CONTRAST
self.frame = frame
gtk.icon_theme_get_default().append_search_path(os.path.abspath(os.path.dirname(__file__)))
self.window = gtk.ScrolledWindow()
self.window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.canvas = goocanvas.Canvas()
self.canvas.set_property("automatic-bounds", True)
self.builder = gtk.Builder()
self.builder.add_from_file(os.path.join(os.path.dirname(__file__), "canvas.xml"))
self.builder.connect_signals({"contrast_activate_cb": self.contrast_activate_cb,
"zoom_activate_cb": self.zoom_activate_cb,
"pan_activate_cb": self.pan_activate_cb,
"_98_activate_cb": self._98_activate_cb,
"minmax_activate_cb": self.minmax_activate_cb,
"linear_activate_cb": self.linear_activate_cb,
"log_activate_cb": self.log_activate_cb,
"invert_activate_cb": self.invert_activate_cb,
"reset_contrast_activate_cb": self.reset_contrast_activate_cb})
w, h = self.frame.get_image().get_width(), self.frame.get_image().get_height()
self.canvas.set_bounds(0, 0, w, h)
canvasItem = goocanvas.Image(pixbuf=frame.get_pixbuf(), x=0, y=0)
self.canvas.get_root_item().add_child(canvasItem)
self.canvasImage = self.canvas.get_root_item().get_child(0)
# connect canvas events
self.canvas.connect("button-press-event", self.button_press_callback)
self.canvas.connect("button-release-event", self.button_release_callback)
self.canvas.connect("motion-notify-event", self.motion_notify_callback)
# create our accelerator maps
#gtk.accel_map_add_entry("<canvas>/Zoom", ord('z'), 0)
# connect accelerator
#accel_group = self.builder.get_object("canvasAcceleratorGroup")
#accel_group.connect_by_path("<canvas>/Zoom", self.zoom_activate_cb)
#self.window.get_parent().add_accel_group(accel_group)
# go!
self.window.add(self.canvas)
self.window.show_all()
def paint_cat(self):
position = 19 + self.sqrt3 * self.r * self.random_catx
if self.random_caty % 2:
position += self.sqrt3/2 * self.r
pixbuf2 = gcompris.utils.load_pixmap \
("hexagon/strawberry.svg")
h2 = 30
w2 = pixbuf2.get_width() * h2/pixbuf2.get_height()
img = goocanvas.Image (parent = self.rootitem,
pixbuf = pixbuf2.scale_simple(w2, h2,
gtk.gdk.INTERP_BILINEAR),
x = position - 5,
y = 14+1.5*self.random_caty*self.r)
def cross_number(self, item, event, target, index):
if (self.check_random[self.counter] == self.ticket_array[index]):
# This is a win
gcompris.sound.play_ogg("sounds/tuxok.wav")
if (index in (0, 1, 2, 3, 4, 5)):
self.score_player_a += 1
else:
self.score_player_b += 1
#Checked_button
goocanvas.Image(
parent=self.root,
pixbuf=gcompris.utils.load_pixmap(
"braille_lotto/button_checked.png"),
x=self.rect_x[index * 2] + 8,
y=self.rect_y[index * 2] + 5,
)
else:
# This is a loss, indicate it with a cross mark
gcompris.sound.play_ogg("sounds/crash.wav")
item = \
goocanvas.Image(parent = self.root,
pixbuf = gcompris.utils.load_pixmap("braille_lotto/cross_button.png"),
x = self.rect_x[index * 2] + 8,
y = self.rect_y[index * 2] + 5,
)
gobject.timeout_add(1000, lambda: item.remove())
winner = 0
if (self.score_player_a == 6):
winner = 1
elif (self.score_player_b == 6):
winner = 2
if winner:
self.displayGameStatus( \
_("Congratulation player {player_id}, you won").format(player_id = str(winner) ) )
self.timer_inc = gobject.timeout_add(5000, self.timer_loop)
def start(self):
# Create our rootitem. We put each canvas item in it so at the end we
# only have to kill it. The canvas deletes all the items it contains
# automaticaly.
self.game_complete = False
self.rootitem = goocanvas.Group(
parent=self.gcomprisBoard.canvas.get_root_item())
self.background = goocanvas.Image(
parent=self.rootitem,
pixbuf=gcompris.utils.load_pixmap(
"place_your_satellite/background.jpg"),
x=1,
y=1)
image = "place_your_satellite/planet" + str(self.gcomprisBoard.level) +\
".png"
self.planet = goocanvas.Image(
parent=self.rootitem,
pixbuf=gcompris.utils.load_pixmap(image),
x=gcompris.BOARD_WIDTH / 2 - 50 - (self.gcomprisBoard.level * 10),
y=gcompris.BOARD_HEIGHT / 2 - 50 - (self.gcomprisBoard.level * 10))
self.instructions(
_('Click anywhere on the screen to place the satellite '
'at a distance from the planet.') + "\n" +
_('Then click on the satellite and drag a line that sets '
'the speed of the satellite'))
self.message = Message(self.rootitem, 400, 50, 20)
self.distanceIndicator = Message(self.rootitem, 400, 480, 5)
self.satellite = Satellite(self, self.rootitem,
self.gcomprisBoard.level)
self.speed = Speed(self.satellite, self.rootitem)
# Set the buttons we want in the bar
gcompris.bar_set(gcompris.BAR_REPEAT | gcompris.BAR_LEVEL)
gcompris.bar_location(2, -1, 0.5)
gcompris.bar_set_level(self.gcomprisBoard)
