def entry_text(self):
self.entry = gtk.Entry()
self.entry.modify_font(pango.FontDescription(gcompris.skin.get_font("gcompris/board/huge bold")))
text_color = gtk.gdk.color_parse("black")
text_color_selected = gtk.gdk.color_parse("black")
bg_color = gtk.gdk.color_parse("white")
self.entry.modify_text(gtk.STATE_NORMAL, text_color)
self.entry.modify_text(gtk.STATE_SELECTED, text_color_selected)
self.entry.modify_base(gtk.STATE_NORMAL, bg_color)
self.entry.set_max_length(50)
self.entry.connect("activate", self.enter_callback)
self.entry.connect("changed", self.enter_char_callback)
self.widget = goocanvas.Widget(
parent = self.rootitem,
widget=self.entry,
x=400,
y=400,
width=400,
height=72,
anchor=gtk.ANCHOR_CENTER,
)
self.widget.raise_(None)
self.entry.grab_focus()
def start(self, area):
# Connect to our database
self.con = sqlite.connect(gcompris.get_database())
self.cur = self.con.cursor()
# 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.canvas, )
# Call our parent start
module.Module.start(self)
frame = gtk.Frame(_("Groups"))
frame.show()
goocanvas.Widget(parent=self.rootitem,
widget=frame,
x=area[0] + self.module_panel_ofset,
y=area[1] + self.module_panel_ofset,
width=area[2] - area[0] - 2 * self.module_panel_ofset,
height=area[3] - area[1] -
2 * self.module_panel_ofset,
anchor=gtk.ANCHOR_NW)
group_list.Group_list(frame, self.con, self.cur)
def start(self, area):
# Connect to our database
self.con = sqlite.connect(gcompris.get_database())
self.cur = self.con.cursor()
if Boards.already_loaded:
self.rootitem.props.visibility = goocanvas.ITEM_VISIBLE
self.boardList.show(self.con, self.cur)
return
Boards.already_loaded = True
# 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.canvas, )
module.Module.start(self)
self.frame = gtk.Frame(_("Boards"))
self.frame.show()
goocanvas.Widget(parent=self.rootitem,
widget=self.frame,
x=area[0] + self.module_panel_ofset,
y=area[1] + self.module_panel_ofset,
width=area[2] - area[0] - 2 * self.module_panel_ofset,
height=area[3] - area[1] -
2 * self.module_panel_ofset,
anchor=gtk.ANCHOR_NW)
self.boardList = board_list.Board_list(self.con, self.cur, self.frame)
self.boardList.init()
def entry_text(self):
self.entry = gtk.Entry()
self.entry.modify_font(
pango.FontDescription(
gcompris.skin.get_font("gcompris/board/big bold")))
text_color = gtk.gdk.color_parse("blue")
text_color_selected = gtk.gdk.color_parse("green")
self.entry.modify_text(gtk.STATE_NORMAL, text_color)
self.entry.modify_text(gtk.STATE_SELECTED, text_color_selected)
self.entry.set_max_length(4)
self.entry.connect("activate", self.enter_callback)
self.entry.connect("changed", self.enter_char_callback)
self.entry.props.visibility = goocanvas.ITEM_VISIBLE
self.widget = goocanvas.Widget(
parent=self.rootitem,
widget=self.entry,
x=730,
y=30,
width=100,
height=46,
anchor=gtk.ANCHOR_CENTER,
)
self.widget.raise_(None)
#self.widget.grab_focus()
self.entry.grab_focus()
return self.entry
def start(self, area):
# Connect to our database
self.con = sqlite.connect(gcompris.get_database())
self.cur = self.con.cursor()
# 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.canvas, )
module.Module.start(self)
frame = gtk.Frame(_("Logins"))
goocanvas.Widget(parent=self.rootitem,
widget=frame,
x=area[0] + self.module_panel_ofset,
y=area[1] + self.module_panel_ofset,
width=area[2] - area[0] - 2 * self.module_panel_ofset,
height=area[3] - area[1] -
2 * self.module_panel_ofset,
anchor=gtk.ANCHOR_NW)
self.profile_widget = profile_widget.ProfileWidget(
self.con, self.cur, gcompris.sugar_get_profile_id(), False)
frame.add(self.profile_widget)
frame.show_all()
def create_demo_item(table, demo_item_type, row, column, rows, columns, text):
if demo_item_type == DEMO_RECT_ITEM:
item = goocanvas.Rect(parent=table,
x=0,
y=0,
width=38,
height=19,
fill_color="red")
if demo_item_type == DEMO_TEXT_ITEM:
item = goocanvas.Text(parent=table,
text=text,
x=0,
y=0,
width=-1,
anchor=gtk.ANCHOR_NW)
if demo_item_type == DEMO_WIDGET_ITEM:
widget = gtk.Button(label=text)
item = goocanvas.Widget(parent=table,
widget=widget,
x=0,
y=0,
width=-1,
height=-1)
table.set_child_properties(item,
row=row,
column=column,
rows=rows,
columns=columns,
x_expand=True,
x_fill=True,
y_expand=True,
y_fill=True)
item.set_data("id", text)
item.connect("button_press_event", on_button_press)
def main(argv):
window = gtk.Window()
window.set_default_size(640, 600)
window.show()
window.connect("delete_event", on_delete_event)
scrolled_win = gtk.ScrolledWindow()
scrolled_win.set_shadow_type(gtk.SHADOW_IN)
scrolled_win.show()
window.add(scrolled_win)
canvas = goocanvas.Canvas()
canvas.set_size_request(600, 450)
canvas.set_bounds(0, 0, 1000, 1000)
canvas.show()
scrolled_win.add(canvas)
root = canvas.get_root_item()
url = swfdec.URL(sys.argv[1])
p = swfdec.ui.Player(None)
p.set_url(url)
wdg = swfdec.ui.Widget(player=p)
p.set_playing(True)
## Add a few simple items.
item = goocanvas.Widget(x=100, y=100, height=-1, width=-1, widget=wdg)
root.add_child(item, 0)
wdg.connect("motion-notify-event", on_motion_notify, item)
wdg.connect("button-press-event", on_button_press)
wdg.connect("button-release-event", on_button_release)
gtk.main()
def display_sea_area(self):
# Some constant to define the sea area
# The sea area is defined in the global self.sea_area
step_x = (self.sea_area[2] - self.sea_area[0]) / 20
step_y = (self.sea_area[3] - self.sea_area[1]) / 10
self.sea_ratio = step_x
text_x = self.sea_area[0] - 15
text_y = self.sea_area[1] - 15
# We manage a 2 colors grid
ci = 0
ca = 0xc6afffFFL
cb = 0x1D0DFFFFL
# The background
item = goocanvas.Rect(parent=self.rootitem,
x=self.sea_area[0],
y=self.sea_area[1],
width=self.sea_area[2] - self.sea_area[0],
height=self.sea_area[3] - self.sea_area[1],
fill_color_rgba=0xafe0ffFFL,
line_width=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)
for y in range(self.sea_area[1], self.sea_area[3] + 1, int(step_y)):
if (ci % 2):
color = ca
else:
color = cb
ci += 1
# Text number
item = goocanvas.Text(
parent=self.rootitem,
text=int(ci),
font=gcompris.skin.get_font("gcompris/content"),
x=text_x,
y=y,
fill_color_rgba=cb,
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)
item = goocanvas.Polyline(parent=self.rootitem,
points=goocanvas.Points([
(self.sea_area[0], y),
(self.sea_area[2], y)
]),
stroke_color_rgba=color,
line_width=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)
ci = 0
for x in range(self.sea_area[0], self.sea_area[2] + 1, int(step_x)):
if (ci % 2):
color = ca
else:
color = cb
ci += 1
# Text number
item = goocanvas.Text(
parent=self.rootitem,
text=int(ci),
font=gcompris.skin.get_font("gcompris/content"),
x=x,
y=text_y,
fill_color_rgba=cb,
anchor=gtk.ANCHOR_CENTER)
item.connect("button_press_event", self.ruler_item_event)
item = goocanvas.Polyline(parent=self.rootitem,
points=goocanvas.Points([
(x, self.sea_area[1]),
(x, self.sea_area[3])
]),
stroke_color_rgba=color,
line_width=1.0)
item.connect("button_press_event", self.ruler_item_event)
# The ARRIVAL LINE
item = goocanvas.Polyline(parent=self.rootitem,
points=goocanvas.Points([
(self.sea_area[2], self.sea_area[1] - 5),
(self.sea_area[2], self.sea_area[3] + 5)
]),
stroke_color_rgba=0xFF0000FFL,
line_width=5.0)
item.connect("button_press_event", self.ruler_item_event)
# The grid is done
# ----------------
# The Programming input area LEFT
self.left_boat.sw = gtk.ScrolledWindow()
self.left_boat.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.left_boat.sw.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
w = 200.0
h = 160.0
y = 355.0 # The upper limit of the text boxes
x_left = gcompris.BOARD_WIDTH / 4 - 30
x_right = (gcompris.BOARD_WIDTH / 4) * 3 + 30
self.left_boat.tb = gtk.TextBuffer()
self.left_boat.tv = gtk.TextView(self.left_boat.tb)
self.left_boat.sw.add(self.left_boat.tv)
command_example = _("right") + " 45\n" + _("forward") + " 5\n" + _(
"left") + " 45"
self.left_boat.tb.set_text(command_example)
self.left_boat.tv.set_wrap_mode(gtk.WRAP_CHAR)
goocanvas.Widget(parent=self.rootitem,
widget=self.left_boat.sw,
x=x_left,
y=y,
width=w,
height=h,
anchor=gtk.ANCHOR_N)
self.left_boat.tv.show()
self.left_boat.sw.show()
# The Programming input area RIGHT
self.right_boat.sw = gtk.ScrolledWindow()
self.right_boat.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.right_boat.sw.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.right_boat.tb = gtk.TextBuffer()
self.right_boat.tv = gtk.TextView(self.right_boat.tb)
self.right_boat.sw.add(self.right_boat.tv)
command_example = _("left") + " 45\n" + _("forward") + " 5\n" + _(
"right") + " 45"
self.right_boat.tb.set_text(command_example)
self.right_boat.tv.set_wrap_mode(gtk.WRAP_CHAR)
goocanvas.Widget(parent=self.rootitem,
widget=self.right_boat.sw,
x=x_right,
y=y,
width=w,
height=h,
anchor=gtk.ANCHOR_N)
self.right_boat.tv.show()
self.right_boat.sw.show()
# Text Labels
self.left_boat.speeditem = goocanvas.Text(
parent=self.rootitem,
text="",
font=gcompris.skin.get_font("gcompris/content"),
x=x_left,
y=y - 20,
fill_color_rgba=0xFF0000FFL,
anchor=gtk.ANCHOR_CENTER)
self.right_boat.speeditem = goocanvas.Text(
parent=self.rootitem,
text="",
font=gcompris.skin.get_font("gcompris/content"),
x=x_right,
y=y - 20,
fill_color_rgba=0X027308FFL,
anchor=gtk.ANCHOR_CENTER)
# The status area
self.statusitem = goocanvas.Text(
parent=self.rootitem,
text="",
font=gcompris.skin.get_font("gcompris/content"),
x=gcompris.BOARD_WIDTH / 2,
y=y - 12,
fill_color_rgba=0X000a89FFL,
anchor=gtk.ANCHOR_CENTER)
# The decoration boats
pixmap = gcompris.utils.load_pixmap("searace/top_boat_red.png")
item = goocanvas.Image(
parent=self.rootitem,
pixbuf=pixmap,
)
gcompris.utils.item_rotate(item, -90)
item.translate(-y - 40, -10)
pixmap = gcompris.utils.load_pixmap("searace/top_boat_green.png")
item = goocanvas.Image(
parent=self.rootitem,
pixbuf=pixmap,
)
gcompris.utils.item_rotate(item, -90)
item.translate(-y - 40, gcompris.BOARD_WIDTH - 60)
# The commands
hl = 18
y += 7
text_color = 0x0000FFFFL
goocanvas.Text(parent=self.rootitem,
text=_("COMMANDS ARE"),
font=gcompris.skin.get_font("gcompris/small"),
x=gcompris.BOARD_WIDTH / 2,
y=y,
fill_color_rgba=text_color,
anchor=gtk.ANCHOR_CENTER)
goocanvas.Text(parent=self.rootitem,
text=_("forward"),
font=gcompris.skin.get_font("gcompris/tiny"),
x=gcompris.BOARD_WIDTH / 2,
y=y + hl,
fill_color_rgba=text_color,
anchor=gtk.ANCHOR_CENTER)
goocanvas.Text(parent=self.rootitem,
text=_("left"),
font=gcompris.skin.get_font("gcompris/tiny"),
x=gcompris.BOARD_WIDTH / 2,
y=y + hl * 2,
fill_color_rgba=text_color,
anchor=gtk.ANCHOR_CENTER)
goocanvas.Text(parent=self.rootitem,
text=_("right"),
font=gcompris.skin.get_font("gcompris/tiny"),
x=gcompris.BOARD_WIDTH / 2,
y=y + hl * 3,
fill_color_rgba=text_color,
anchor=gtk.ANCHOR_CENTER)
def __init__(self, goocalendar):
super(Toolbar, self).__init__()
self.goocalendar = goocalendar
self.accel_group = Main.get_main().accel_group
today_label = gtk.Label(_('Today'))
today_button = gtk.ToolButton(today_label)
today_button.set_homogeneous(False)
today_button.connect("clicked", self.on_today_button_clicked)
today_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.t, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(today_button, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
go_back = gtk.ToolButton(arrow_left, "go left")
go_back.set_expand(False)
go_back.set_homogeneous(False)
go_back.connect("clicked", self.on_go_back_clicked)
self.insert(go_back, -1)
self.current_page_label = gtk.Label("")
self.current_page = gtk.ToggleToolButton()
self.current_page.set_icon_widget(self.current_page_label)
self.current_page.connect("clicked", self.on_current_page_clicked)
self.insert(self.current_page, -1)
gtkcal = gtk.Calendar()
gtkcal.connect('day-selected', self.on_gtkcal_day_selected)
gtkcal.set_display_options(
gtk.CALENDAR_SHOW_HEADING |
gtk.CALENDAR_SHOW_WEEK_NUMBERS |
gtk.CALENDAR_SHOW_DAY_NAMES)
gtkcal.set_no_show_all(True)
gtkcal_item = goocanvas.Widget(widget=gtkcal)
gtkcal_item.set_property('visibility', goocanvas.ITEM_INVISIBLE)
goocalendar.get_root_item().add_child(gtkcal_item)
self.gtkcal = gtkcal
self.gtkcal_item = gtkcal_item
self.goocalendar.connect('day-selected',
self.on_goocalendar_day_selected)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
go_forward = gtk.ToolButton(arrow_right, "go right")
go_forward.set_expand(False)
go_forward.set_homogeneous(False)
go_forward.connect("clicked", self.on_go_forward_clicked)
self.insert(go_forward, -1)
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
previous_year = gtk.ToolButton(arrow_left, "next year")
previous_year.set_expand(False)
previous_year.set_homogeneous(False)
previous_year.connect("clicked", self.on_previous_year_clicked)
self.insert(previous_year, -1)
self.current_year_label = gtk.Label("")
current_year = gtk.ToolItem()
current_year.add(self.current_year_label)
self.insert(current_year, -1)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
next_year = gtk.ToolButton(arrow_right, "next year")
next_year.set_expand(False)
next_year.set_homogeneous(False)
next_year.connect("clicked", self.on_next_year_clicked)
self.insert(next_year, -1)
blank_widget = gtk.ToolItem()
blank_widget.set_expand(True)
self.insert(blank_widget, -1)
week_button = gtk.RadioToolButton()
week_button.set_label(_('Week View'))
week_button.connect("clicked", self.on_week_button_clicked)
week_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.w,
gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
self.insert(week_button, -1)
month_button = gtk.RadioToolButton(week_button)
month_button.set_label(_('Month View'))
month_button.connect("clicked", self.on_month_button_clicked)
month_button.add_accelerator("clicked", self.accel_group,
gtk.keysyms.m, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE)
month_button.set_active(True)
self.insert(month_button, -1)
self.update_displayed_date()
self.set_style(gtk.TOOLBAR_ICONS)
def RenderTrack(self):
"""This adds a track to the canvas with 3 images: a left, middle, and right"""
# get a reference to the language translate method
_ = self.parent.project.translate
# get the pixels per second from the parent sequence
pixels_per_second = self.parent.get_pixels_per_second()
# get a reference to the 2 main canvas objects & theme
theme = self.parent.project.theme
canvas_left = self.parent.project.form.MyCanvas_Left
canvas_right = self.parent.project.form.MyCanvas
# Get theme settings
theme_settings = self.parent.project.theme_settings.settings
# get the previous track from the parent sequence (if any)
previous_track_index = self.parent.tracks.index(self) - 1
previous_track = None
previous_y_top = 0
previous_y_bottom = 0
if (previous_track_index >= 0):
previous_track = self.parent.tracks[previous_track_index]
previous_y_top = previous_track.y_top
previous_y_bottom = previous_track.y_bottom
# set the top coordinate of this track to the bottom coordinate of the last track
self.y_top = previous_y_bottom + theme_settings["track"]["padding"]
# Add an item to the goocanvas
root_left = canvas_left.get_root_item()
root_right = canvas_right.get_root_item()
# Load all 3 images
imgTrack_Left = gtk.image_new_from_file(
"%s/libreshot/themes/%s/Track_Left.png" %
(self.parent.project.form.libreshot_path, theme))
imgTrack_Middle = gtk.image_new_from_file(
"%s/libreshot/themes/%s/Track_Middle.png" %
(self.parent.project.form.libreshot_path, theme))
imgTrack_Right = gtk.image_new_from_file(
"%s/libreshot/themes/%s/Track_Right.png" %
(self.parent.project.form.libreshot_path, theme))
# Get Height and Width of Images
imgTrack_Left_Height = imgTrack_Left.get_pixbuf().get_height()
imgTrack_Left_Width = imgTrack_Left.get_pixbuf().get_width()
imgTrack_Right_Width = imgTrack_Right.get_pixbuf().get_width()
# Get Size of Window (to determine how wide the middle image should be streched)
Size_Of_Middle = int(pixels_per_second * self.parent.length)
# Resize Middle pixbuf
middlePixBuf = imgTrack_Middle.get_pixbuf()
pixbuf_list = self.parent.split_images(middlePixBuf,
imgTrack_Left_Height,
Size_Of_Middle)
# Create Group (for the track)
GroupTrack = goocanvas.Group(parent=root_right)
GroupTrack_Left = goocanvas.Group(parent=root_left)
# set the unique ID of the group
GroupTrack.set_data("id", self.unique_id)
# Add Left Image to Group
image1 = goocanvas.Image(parent=GroupTrack_Left,
pixbuf=imgTrack_Left.get_pixbuf(),
x=self.x,
y=self.y_top)
# Track the state of the hover over image
image1.set_data("id", "normal")
image1.connect("button_press_event", self.on_focus_in)
# Add Middle Image to Group (this can be multiple image tiled together
pixbuf_x = 0
for pixbuf in pixbuf_list:
# get width of this pixbuf
pixbuf_width = pixbuf.get_width()
image2 = goocanvas.Image(parent=GroupTrack,
pixbuf=pixbuf,
x=pixbuf_x,
y=self.y_top)
# increment the x
pixbuf_x = pixbuf_x + pixbuf_width
# Add Middle Image to Group
image3 = goocanvas.Image(parent=GroupTrack,
pixbuf=imgTrack_Right.get_pixbuf(),
x=Size_Of_Middle - 1,
y=self.y_top)
# Add Text to the Track
text1 = goocanvas.Text(
parent=GroupTrack_Left,
text=theme_settings["track"]["track_name_text"]["font"] %
self.name,
antialias=False,
use_markup=True,
x=self.x + theme_settings["track"]["track_name_text"]["x"],
y=self.y_top + theme_settings["track"]["track_name_text"]["y"])
# Load buttons
if self.play_video:
imgTrack_Visible = gtk.image_new_from_file(
"%s/libreshot/themes/%s/visible.png" %
(self.parent.project.form.libreshot_path, theme))
imgTrack_Visible.set_tooltip_text(_("Video Visible"))
else:
imgTrack_Visible = gtk.image_new_from_file(
"%s/libreshot/themes/%s/not_visible.png" %
(self.parent.project.form.libreshot_path, theme))
imgTrack_Visible.set_tooltip_text(_("Video not Visible"))
if self.play_audio:
imgTrack_Audio = gtk.image_new_from_file(
"%s/libreshot/themes/%s/speaker.png" %
(self.parent.project.form.libreshot_path, theme))
imgTrack_Audio.set_tooltip_text(_("Sound Activated"))
else:
imgTrack_Audio = gtk.image_new_from_file(
"%s/libreshot/themes/%s/speaker_mute.png" %
(self.parent.project.form.libreshot_path, theme))
imgTrack_Audio.set_tooltip_text(_("Sound Deactivated"))
# Add Visible Image to Group
image4 = goocanvas.Widget(
parent=GroupTrack_Left,
widget=imgTrack_Visible,
x=self.x + theme_settings["track"]["visible"]["x"],
y=self.y_top + theme_settings["track"]["visible"]["y"])
# Track the state of the hover over image
image4.connect("button_press_event", self.on_visible_click)
# Add Audio Image to Group
image5 = goocanvas.Widget(
parent=GroupTrack_Left,
widget=imgTrack_Audio,
x=self.x + theme_settings["track"]["speaker"]["x"],
y=self.y_top + theme_settings["track"]["speaker"]["y"])
# Track the state of the hover over image
image5.connect("button_press_event", self.on_audio_click)
# Increment the Y cooridinate (by the height of the left image)
self.y_bottom = self.y_top + imgTrack_Left_Height
def start(self):
gcompris.bar_set (0)
gcompris.bar_location(gcompris.BOARD_WIDTH - 160, -1, 0.6)
gcompris.set_default_background(self.gcomprisBoard.canvas.get_root_item())
self.rootitem = goocanvas.Group(parent = self.gcomprisBoard.canvas.get_root_item())
# The global area
# ---------------
self.global_area_sw = gtk.ScrolledWindow()
self.global_area_sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.global_area_sw.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
w = gcompris.BOARD_WIDTH - 240.0
h = gcompris.BOARD_HEIGHT - 300.0
y = 20.0 # The upper limit of the text boxes
x = 20.0
self.global_area_tb = gtk.TextBuffer()
self.global_area_tv = gtk.TextView(self.global_area_tb)
self.global_area_tv.set_editable(False)
self.global_area_sw.add(self.global_area_tv)
self.global_area_tb.set_text(_("All messages will be displayed here.\n"))
self.global_area_tv.set_wrap_mode(gtk.WRAP_CHAR)
goocanvas.Widget(
parent = self.rootitem,
widget=self.global_area_sw,
x=x,
y=y,
width=w,
height= h,
anchor=gtk.ANCHOR_NW)
self.global_area_tv.show()
self.global_area_sw.show()
# The friend area
# ---------------
self.friend_area_sw = gtk.ScrolledWindow()
self.friend_area_sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.friend_area_sw.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
w = 160.0
h = gcompris.BOARD_HEIGHT - 240.0
y = 20.0 # The upper limit of the text boxes
x = gcompris.BOARD_WIDTH - w - 20.0
self.friend_area_tb = gtk.TextBuffer()
self.friend_area_tv = gtk.TextView(self.friend_area_tb)
self.friend_area_tv.set_editable(False)
self.friend_area_sw.add(self.friend_area_tv)
# save name and selected color in a map
self.friend_map = {}
self.friend_area_tb.set_text("")
self.friend_area_tv.set_wrap_mode(gtk.WRAP_CHAR)
goocanvas.Widget(
parent = self.rootitem,
widget=self.friend_area_sw,
x=x,
y=y,
width=w,
height= h,
anchor=gtk.ANCHOR_NW)
self.friend_area_tv.show()
self.friend_area_sw.show()
# A label for the friend area
goocanvas.Text(
parent = self.rootitem,
text=_("Your Friends"),
font = gcompris.skin.get_font("gcompris/board/medium"),
x=x+(w/2),
y=y+h+15,
anchor=gtk.ANCHOR_CENTER,
)
# The channel area
# ---------------
self.channel = gtk.Entry()
w = 160.0
h = 30.0
y = gcompris.BOARD_HEIGHT - 160.0
x = x
goocanvas.Widget(
parent = self.rootitem,
widget=self.channel,
x=x,
y=y,
width=w,
height= h,
anchor=gtk.ANCHOR_NW)
self.channel.show()
self.channel.set_text("")
# A label for the channel area
goocanvas.Text(
parent = self.rootitem,
text=_("Your Channel"),
font = gcompris.skin.get_font("gcompris/board/medium"),
x=x+(w/2),
y=y+h+15,
anchor=gtk.ANCHOR_CENTER,
)
# the entry area
self.entry = gtk.Entry()
self.entry.connect("activate", self.enter_callback, self.entry)
x = 20.0
w = gcompris.BOARD_WIDTH - x * 2
h = 30.0
y = gcompris.BOARD_HEIGHT - 70.0
goocanvas.Widget(
parent = self.rootitem,
widget=self.entry,
x=x,
y=y,
width=w,
height= h,
anchor=gtk.ANCHOR_NW)
self.entry.show()
self.entry.set_text(_("Type your message here, to send to other GCompris users on your local network."))
# drawing area
x = 20.0
w = gcompris.BOARD_WIDTH - 300
h = 200.0
y = gcompris.BOARD_HEIGHT - 270.0
self.colors = {}
self.colors['bg'] = 0xFFFFFFFFL
self.colors['border'] = 0x000000FFL
self.drawboard = goocanvas.Rect(
parent = self.rootitem,
fill_color_rgba = self.colors['bg'],
stroke_color_rgba = self.colors['border'],
line_width = 1.0,
x = x,
y = y,
width = w,
height = h)
self.drawboard.connect("button_press_event", self.draw_item_event)
self.drawboard.connect("button_release_event", self.draw_item_event)
self.drawboard.connect("motion_notify_event", self.draw_item_event)
r = random.randint(0,200) # Prevent the possibility of white
g = random.randint(0,255)
b = random.randint(0,255)
# colorpicker
self.colorpicker = gtk.ColorButton(gtk.gdk.color_parse(self.tohex(r, g, b)))
x = gcompris.BOARD_WIDTH - 270
y = gcompris.BOARD_HEIGHT - 270.0
w = 50
h = 50
goocanvas.Widget(
parent = self.rootitem,
widget = self.colorpicker,
x = x,
y = y,
width = w,
height = h,
anchor = gtk.ANCHOR_NW)
self.colorpicker.show()
self.colorpicker.set_tooltip_text(_("color"))
# line and draw radiobuttons
self.buttonline = gtk.RadioButton()
self.buttondraw = gtk.RadioButton(group=self.buttonline)
x = gcompris.BOARD_WIDTH - 270
y = gcompris.BOARD_HEIGHT - 220.0
w = 70
h = 50
goocanvas.Widget(
parent = self.rootitem,
widget = self.buttonline,
x = x,
y = y,
width = w,
height = h,
anchor = gtk.ANCHOR_NW)
goocanvas.Widget(
parent = self.rootitem,
widget = self.buttondraw,
x = x,
y = y + 50,
width = w,
height = h,
anchor = gtk.ANCHOR_NW)
image_line = gtk.Image()
image_draw = gtk.Image()
pixbuf = gcompris.utils.load_pixmap("chat/tool-line.png")
image_line.set_from_pixbuf(pixbuf)
pixbuf = gcompris.utils.load_pixmap("chat/tool-draw.png")
image_draw.set_from_pixbuf(pixbuf)
self.buttonline.set_image(image_line)
self.buttondraw.set_image(image_draw)
# erase all button
self.delAll = gtk.Button()
x = gcompris.BOARD_WIDTH - 270
y = gcompris.BOARD_HEIGHT - 100.0
w = 50
h = 30
goocanvas.Widget(
parent = self.rootitem,
widget = self.delAll,
x = x,
y = y,
width = w,
height = h,
anchor = gtk.ANCHOR_NW)
self.delAll.show()
# don't delete this, it's used to change font...
self.delAll.set_label("")
if self.delAll.get_use_stock():
label = self.delAll.child.get_children()[1]
elif isinstance(self.delAll.child, gtk.Label):
label = self.delAll.child
label.set_markup("<span foreground='red' weight='ultrabold' size='x-large'>X</span>")
self.delAll.connect("button_press_event", self.delAllEvent)
try:
# Start the server
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind(('', self.port))
mreq = struct.pack('4sl', socket.inet_aton(self.mcast_adress), socket.INADDR_ANY)
self.sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
self.sock.setblocking(0)
self.timer_interval = 10
self.mcast_timer = gobject.timeout_add(self.timer_interval, self.mcast_read)
except:
self.display_message("GCompris",
_("ERROR: Failed to initialize the network interface. You cannot communicate."))
def sample_gradiant(self, canvas):
root = canvas.get_root_item()
self.list_item = []
color_set = [
'red', 'blue', 'green', '#A0FF05', "#567893", '#567400', '#AF3456',
'#F345B2'
]
group1 = goocanvas.Group(parent=root,
x=125,
y=0,
width=46,
height=360,
line_width=0)
#TODO : create arrow setecd gradiant template
gadiant_list = []
self.radial = cairo.RadialGradient(20, 7, 15, 20, 7, 40)
self.radial.add_color_stop_rgba(0, 0.63, 0.76, 0.82, 0.8)
self.radial.add_color_stop_rgba(0.9, 0.1, 0.1, 1, 0.8)
gadiant_list.append(self.radial)
for j in range(7):
linear = cairo.LinearGradient(0, 0, 20, 7)
linear.add_color_stop_rgba(0.0, 1, 1, 1, 0)
linear.add_color_stop_rgba(0.25, 0, 1, 0, 0.5)
gadiant_list.append(linear)
for i in range(8):
item = goocanvas.Rect(parent=group1,
x=0,
y=(i * 30 + 5),
width=45,
height=28,
line_width=2,
fill_color=color_set[i],
stroke_color='white',
fill_pattern=gadiant_list[i],
radius_x=4,
radius_y=4)
#focus_in_event
#item.connect("enter_notify_event", self.on_enter_notify)#enter-notify
#item.connect("leave_notify_event", self.on_leave_notify)
item.connect("focus_in_event", self.on_enter_notify) #enter-notify
item.connect("focus_out_event", self.on_leave_notify)
item.connect("button_press_event", self.on_button_press)
self.list_item.append(item)
#Cursor
'''item = goocanvas.Rect(parent = root,x=173, y=0, width=11, height=120,
line_width=0,
fill_color_rgba = 0xEDD4CC7F, #EDD4CC
radius_x=3.0,
radius_y=3.0,
stroke_color = 'white')
item = goocanvas.Rect(parent = root,x=175, y=0, width=7, height=20,
line_width=1,
fill_color = "#C8BDBA", #EDD4CC
radius_x=3.0,
radius_y=3.0,
stroke_color = '#9D847C')
item.connect("button_press_event", self.on_button_press_cursor)
item.connect("button_release_event", self.on_button_release_cursor)'''
adj_hscale = gtk.Adjustment(0, 0, 100, 1.0, 5.0, 0.0)
#vscale= gtk.VScale(adj_hscale)
#vscale.set_size_request(5, 110)
#vscale.set_value_pos(gtk.POS_RIGHT)
#vscale.set_draw_value(False)
#scrbar = gtk.Scrollbar(0,10)
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
scrolled.set_vadjustment(adj_hscale)
adj_hscale.connect("value_changed", self.gradiant_template_sel, group1)
ent = goocanvas.Widget(parent=root,
widget=scrolled,
x=176,
y=60,
width=-1,
height=120,
anchor=gtk.ANCHOR_CENTER)
#Create Arrow button for selected gradaint from template
'''
def make_widget_item(self, **kwargs):
item = goocanvas.Widget(**kwargs)
return item
