def __init__(self, handle):
activity.Activity.__init__(self, handle)
self._name = handle
self.num = mynum.Numbers()
if NEW_TOOLBARS:
toolbar_box = ToolbarBox()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
else:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
if self.num.widget.parent:
self.num.widget.parent.remove(self.num.widget)
self.num.widget.show()
self.set_canvas(self.num.widget)
self.show_all()
self.num.setActivity(self)
def _configure_toolbars(self):
if _USE_OLD_TOOLBARS:
toolbox = ActivityToolbox(self)
toolbar = gtk.Toolbar()
else:
toolbar_box = ToolbarBox()
toolbar = toolbar_box.toolbar
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self._add_expander(toolbar_box.toolbar)
toolbar.add(gtk.SeparatorToolItem())
if _USE_OLD_TOOLBARS:
self.set_toolbox(toolbox)
toolbox.show()
else:
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
def __init__(self, handle):
"""Set up the Acoustic Tape Measure activity."""
Activity.__init__(self, handle)
gobject.threads_init()
#self.set_title(gettext('Acoustic Tape Measure Activity'))
self._logger = logging.getLogger('acousticmeasure-activity')
try:
self._logger.debug("locale: " + locale.setlocale(locale.LC_ALL, ''))
except locale.Error:
self._logger.error("setlocale failed")
# top toolbar with share and close buttons:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
self._t_h_bar = atm_toolbars.TempToolbar()
toolbox.add_toolbar(gettext("Atmosphere"), self._t_h_bar)
if not self.powerd_running():
try:
bus = dbus.SystemBus()
proxy = bus.get_object('org.freedesktop.ohm',
'/org/freedesktop/ohm/Keystore')
self.ohm_keystore = dbus.Interface(proxy,
'org.freedesktop.ohm.Keystore')
except dbus.DBusException, e:
self._logger.warning("Error setting OHM inhibit: %s" % e)
self.ohm_keystore = None
def new_instance(self):
browser = gtk.VBox()
browser.show()
self.canvas.append_page(browser)
self.path = Path()
path_box = gtk.EventBox()
path_box.modify_bg(gtk.STATE_NORMAL,
style.COLOR_TOOLBAR_GREY.get_gdk_color())
path_box.add(self.path)
path_box.show_all()
browser.pack_end(path_box, False)
self.workspace = gtk.HPaned()
self.workspace.show()
self.workspace.connect('notify::position', self._workspace_position_cb)
browser.pack_start(self.workspace)
self.tags = TagSidebar()
self.tags.show()
self.workspace.add1(self.tags)
self.objects = gtk.Notebook()
self.objects.show()
self.objects.props.show_border = False
self.objects.props.show_tabs = False
self.workspace.add2(self.objects)
scrollbox = gtk.ScrolledWindow()
scrollbox.show()
scrollbox.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.objects_compat = ObjectCompact()
scrollbox.add(self.objects_compat)
self.objects.append_page(scrollbox)
model.object_model.view = self.objects_compat
self.object_thumbs = ObjectThumbs()
self.object_thumbs.show()
self.objects.append_page(self.object_thumbs)
self.editor = ObjectEditor()
self.editor.show()
self.canvas.append_page(self.editor)
toolbox = ActivityToolbox(self)
toolbox.show()
self.set_toolbox(toolbox)
self.toolbars = [[(_('Library'), BrowseToolbar())],
[(_('Edit'), EditToolbar())]]
self.browse()
model.source.query()
def __init__(self, handle, *args, **kwargs):
super(FraccionesActivity, self).__init__(handle, *args, **kwargs)
self.gamename = "Fracciones"
# barra de herramientas de Sugar
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
self.set_canvas(FractionPresentation())
self.show_all()
def __init__(self, handle):
Activity.__init__(self, handle)
self.gamename = 'BatallaNaval'
# Crea la barra de herramientas básica de Sugar
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
# Crea una instancia de Colaboración por si se quiere compartir la actividad
self.colaboracion = CollaborationWrapper(self)
# The activity is a subclass of Window, so it passses itself to the init function
BatallaNaval.init(False, self)
def buildToolbar(self):
""" Build GUI Toolbar
"""
self._toolbox = ActivityToolbox(self._activity)
self._toolbar = self._toolbox.get_activity_toolbar()
# Remove share button
self._toolbar.remove(self._toolbar.share)
self._toolbar.share = None
self._activity.set_toolbox(self._toolbox)
# we do not have collaboration features
# make the share option insensitive
self._activity.max_participants = 1
def loadUI(self):
"""Create and show UI
"""
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# Toolbar
toolbox = ActivityToolbox(self)
self._toolbar = toolbox.get_activity_toolbar()
self._toolbar.remove(self._toolbar.share)
self._toolbar.share = None
self._toolbar.remove(self._toolbar.keep)
self._toolbar.keep = None
self.set_toolbox(toolbox)
def build_toolbars(self):
self.settings_bar = gtk.Toolbar()
self.settings_buttons = {}
self.settings_buttons['reload_video'] = ToolButton('view-spiral')
self.settings_buttons['reload_video'].set_tooltip(_("Reload Screen"))
self.settings_buttons['reload_video'].connect("clicked",
self.force_redraw, None)
self.settings_bar.insert(self.settings_buttons['reload_video'], -1)
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Settings"), self.settings_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show_all()
def build_toolbars(self):
self.dungeon_buttons = {}
self.dungeon_bar = gtk.Toolbar()
self.view_bar = gtk.Toolbar()
# BUILD CUSTOM TOOLBAR
# Dungeon Bar
self.dungeon_buttons['new'] = ToolButton('add')
self.dungeon_buttons['new'].set_tooltip(_("New Dungeon"))
self.dungeon_buttons['new'].connect("clicked", self.view_change_cb, 'new')
self.dungeon_bar.insert(self.dungeon_buttons['new'], -1)
self.dungeon_buttons['load'] = ToolButton('fileopen')
self.dungeon_buttons['load'].set_tooltip(_("Open Dungeon"))
self.dungeon_buttons['load'].connect("clicked", self.view_change_cb, 'load')
self.dungeon_bar.insert(self.dungeon_buttons['load'], -1)
self.dungeon_buttons['save'] = ToolButton('filesave')
self.dungeon_buttons['save'].set_tooltip( _("Export dungeon file to journal") )
self.dungeon_buttons['save'].connect("clicked", self.view_change_cb, 'export')
self.dungeon_bar.insert(self.dungeon_buttons['save'], -1)
self.dungeon_buttons['save'].set_sensitive( False )
# VIEW BAR
self.dungeon_buttons['home'] = ToolButton('go-home')
self.dungeon_buttons['home'].set_tooltip(_("Welcome Screen"))
self.dungeon_buttons['home'].connect("clicked", self.view_change_cb, 'home')
self.view_bar.insert(self.dungeon_buttons['home'], -1)
self.dungeon_buttons['settings'] = ToolButton('view-spiral')
self.dungeon_buttons['settings'].set_tooltip(_("View Dungeon Settings"))
self.dungeon_buttons['settings'].connect("clicked", self.view_change_cb, 'settings')
self.view_bar.insert(self.dungeon_buttons['settings'], -1)
self.dungeon_buttons['settings'].set_sensitive( False )
self.dungeon_buttons['layout'] = ToolButton('view-freeform')
self.dungeon_buttons['layout'].set_tooltip(_("View Dungeon Layout"))
self.dungeon_buttons['layout'].connect("clicked", self.view_change_cb, 'layout')
self.view_bar.insert(self.dungeon_buttons['layout'], -1)
self.dungeon_buttons['layout'].set_sensitive( False )
self.toolbox = ActivityToolbox(self)
# Remove Share Bar
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.remove(activity_toolbar.share)
activity_toolbar.share = None
#Add our custom items to the toolbar
self.toolbox.add_toolbar(_("Dungeon"), self.dungeon_bar)
self.toolbox.add_toolbar(_("View"), self.view_bar)
self.set_toolbox(self.toolbox)
self.toolbox.show()
def __init__(self, handle):
Activity.__init__(self, handle)
logger.debug('Starting Jigsaw Puzzle activity... %s' % str(get_bundle_path()))
os.chdir(get_bundle_path())
self.connect('destroy', self._destroy_cb)
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
# Toolbar title size hack
title_widget = toolbox._activity_toolbar.title
title_widget.set_size_request(title_widget.get_layout().get_pixel_size()[0] + 30, -1)
self.ui = JigsawPuzzleUI(self)
self.set_canvas(self.ui)
self.show_all()
TubeHelper.__init__(self, tube_class=GameTube, service=SERVICE)
def __init__(self, handle):
Activity.__init__(self, handle)
logger.debug('Starting Slider Puzzle activity... %s' % str(get_bundle_path()))
os.chdir(get_bundle_path())
self.connect('destroy', self._destroy_cb)
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
title_widget = toolbox._activity_toolbar.title
title_widget.set_size_request(title_widget.get_layout().get_pixel_size()[0] + 20, -1)
self.ui = SliderPuzzleUI(self)
self.set_canvas(self.ui)
self.show_all()
self.frozen = FrozenState(self.ui)
self.ui.game.connect('shuffled', self.frozen.sync)
TubeHelper.__init__(self, tube_class=GameTube, service=SERVICE)
def __init__(self, handle):
Activity.__init__(self, handle)
logger.debug('Starting Jigsaw Puzzle activity... %s' %
str(get_bundle_path()))
os.chdir(get_bundle_path())
self.connect('destroy', self._destroy_cb)
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
# Toolbar title size hack
title_widget = toolbox._activity_toolbar.title
title_widget.set_size_request(
title_widget.get_layout().get_pixel_size()[0] + 30, -1)
self.ui = JigsawPuzzleUI(self)
self.set_canvas(self.ui)
self.show_all()
TubeHelper.__init__(self, tube_class=GameTube, service=SERVICE)
def __init__(self, handle):
Activity.__init__(self, handle)
logger.debug('Starting Slider Puzzle activity... %s' %
str(get_bundle_path()))
os.chdir(get_bundle_path())
self.connect('destroy', self._destroy_cb)
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
title_widget = toolbox._activity_toolbar.title
title_widget.set_size_request(
title_widget.get_layout().get_pixel_size()[0] + 20, -1)
self.ui = SliderPuzzleUI(self)
self.set_canvas(self.ui)
self.show_all()
self.frozen = FrozenState(self.ui)
self.ui.game.connect('shuffled', self.frozen.sync)
TubeHelper.__init__(self, tube_class=GameTube, service=SERVICE)
def __init__(self, handle):
Activity.__init__(self, handle)
root = self.make_root()
self.set_canvas(root)
root.show_all()
self.entry.grab_focus()
toolbox = ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.keep.props.visible = False
self.set_toolbox(toolbox)
toolbox.show()
self.pservice = PresenceService()
self.owner = self.pservice.get_owner()
# Auto vs manual scrolling:
self._scroll_auto = True
self._scroll_value = 0.0
# Track last message, to combine several messages:
self._last_msg = None
self._last_msg_sender = None
self.text_channel = None
if self._shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb()
else:
# we are creating the activity
if not self.metadata or self.metadata.get('share-scope',
SCOPE_PRIVATE) == SCOPE_PRIVATE:
# if we are in private session
self._alert(_('Off-line'), _('Share, or invite someone.'))
self.connect('shared', self._shared_cb)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self._name = handle
self.num = mynum.Numbers()
if NEW_TOOLBARS:
toolbar_box = ToolbarBox()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
else:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
if self.num.widget.parent:
self.num.widget.parent.remove(self.num.widget)
self.num.widget.show()
self.set_canvas(self.num.widget)
self.show_all()
self.num.setActivity(self)
def __init__(self, handle):
Activity.__init__(self, handle)
root = self.make_root()
self.set_canvas(root)
root.show_all()
self.entry.grab_focus()
toolbox = ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.keep.props.visible = False
self.set_toolbox(toolbox)
toolbox.show()
self.owner = self._pservice.get_owner()
# Auto vs manual scrolling:
self._scroll_auto = True
self._scroll_value = 0.0
# Track last message, to combine several messages:
self._last_msg = None
self._last_msg_sender = None
self.text_channel = None
if self._shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb()
else:
# we are creating the activity
if not self.metadata or self.metadata.get(
'share-scope', SCOPE_PRIVATE) == SCOPE_PRIVATE:
# if we are in private session
self._alert(_('Off-line'), _('Share, or invite someone.'))
self.connect('shared', self._shared_cb)
def build_toolbars(self):
self.settings_bar = gtk.Toolbar()
self.settings_buttons = {}
self.settings_buttons['reload_video'] = ToolButton('view-spiral')
self.settings_buttons['reload_video'].set_tooltip(_("Reload Screen"))
self.settings_buttons['reload_video'].connect("clicked",
self.force_redraw, None)
self.settings_bar.insert(self.settings_buttons['reload_video'], -1)
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Settings"), self.settings_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show_all()
def build_old_toolbar(self):
toolbox = ActivityToolbox(self)
activityToolbar = toolbox.get_activity_toolbar()
activityToolbar.keep.props.visible = False
self.J2JToolbar = Jam2JamToolBar(self)
toolbox.add_toolbar("Transform", self.J2JToolbar)
self.set_toolbox(toolbox)
self.J2JToolbar.show()
toolbox.show()
self.toolbox.set_current_toolbar(1)
self.connect("shared", self.shared_cb)
self.connect("joined", self.joined_cb)
if self.get_shared():
self.joined_cb()
log.info("FINISHED building toolbar")
return toolbox
def __init__(self, handle):
"""Set up the XoScope activity."""
activity.Activity.__init__(self, handle)
self._instance_directory = os.path.join(self.get_activity_root(),\
'instance')
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
self._capturing = False
self._mode = 'live'
# 0, 2 or 5 second delay before capturing the image
self._delay = 0
# Zoom 1x, 2x, 4x
self._zoom = 1
# Exposure bracketing
self._bracketing = '0'
# Preview mode stuff
self._num_pics = 0
# Index of pic to be displayed in preview mode
self._pic_index = 0
# This holds the image titles and name information. Saved
# across activity instances
self._images = []
# Flag to store whether image preview element needs to resize
# the pixbuf
self._needs_resize = False
if OLD_TOOLBAR:
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar = gtk.Toolbar()
self.toolbox.add_toolbar(_('Control'), activity_toolbar)
self.toolbox.set_current_toolbar(1)
self._controls_toolbar = activity_toolbar
advanced_toolbar = self.toolbox.get_activity_toolbar()
advanced_toolbar = gtk.Toolbar()
#self.toolbox.add_toolbar(_('Advanced controls'), advanced_toolbar)
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_toolbar = self.activity_button.page
self._controls_toolbar = self.get_toolbar_box().toolbar
self._controls_toolbar.show()
advanced_toolbar = gtk.Toolbar()
#advanced_toolbar.show_all()
advanced_button = ToolbarButton()
advanced_button.props.page = advanced_toolbar
advanced_button.props.label = _('Advanced controls')
advanced_button.props.icon_name = 'advanced'
#advanced_button.show()
#toolbar_box.toolbar.insert(advanced_button, -1)
self._live_toolitem = gtk.ToolItem()
self._live_toolbar_container = gtk.HBox()
self._preview_toolitem = gtk.ToolItem()
self._preview_toolbar_container = gtk.HBox()
separator = gtk.SeparatorToolItem()
if not OLD_TOOLBAR:
separator.props.draw = True
else:
separator.props.draw = False
separator.set_expand(False)
self._controls_toolbar.insert(separator, -1)
separator.show()
self._photo_button = ToolButton('photo')
self._photo_button.props.label = _('Capture photo')
self._photo_button.connect('clicked',
self.__capture_image_cb)
self._live_toolbar_container.add(self._photo_button)
self._photo_button.show()
self._delay_button = ToolButton('delay_%d' % self._delay)
self._delay_button.props.label = _('Capture delay')
self._delay_button.connect('clicked',
self.__change_capture_delay_cb)
self._live_toolbar_container.add(self._delay_button)
self._delay_button.show()
self._zoom_button = ToolButton('zoom_%d' % self._zoom)
self._zoom_button.props.label = _('Image Zoom')
self._zoom_button.connect('clicked',
self.__change_image_zoom_cb)
self._live_toolbar_container.add(self._zoom_button)
self._zoom_button.show()
#if self._check_available_control(v4l2.V4L2_CID_EXPOSURE):
# self._bracketing_button = ToolButton('bracketing_%s' % self._bracketing)
# self._bracketing_button.props.label = _('bracketing mode')
# self._bracketing_button.connect('clicked',
# self.__change_capture_bracketing_cb)
# self._live_toolbar_container.add(self._bracketing_button)
# self._bracketing_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
self._live_toolbar_container.add(separator)
separator.show()
# Camera control settings follow
if self._check_available_control(v4l2.V4L2_CID_EXPOSURE):
self._exposure_button = ToolButton('exposure')
self._exposure_button.set_palette(ScalePalette('Exposure',\
v4l2.V4L2_CID_EXPOSURE))
self._exposure_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._exposure_button)
self._exposure_button.show()
if self._check_available_control(v4l2.V4L2_CID_GAIN):
self._gain_button = ToolButton('gain')
self._gain_button.set_palette(ScalePalette('Gain',\
v4l2.V4L2_CID_GAIN,
self._check_available_control(v4l2.V4L2_CID_AUTOGAIN)))
self._gain_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._gain_button, -1)
self._gain_button.show()
if self._check_available_control(v4l2.V4L2_CID_BRIGHTNESS):
self._brightness_button = ToolButton('brightness')
self._brightness_button.set_palette(ScalePalette('Brightness',\
v4l2.V4L2_CID_BRIGHTNESS,
self._check_available_control(
v4l2.V4L2_CID_AUTOBRIGHTNESS)))
self._brightness_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._brightness_button)
self._brightness_button.show()
if self._check_available_control(v4l2.V4L2_CID_CONTRAST):
self._contrast_button = ToolButton('contrast')
self._contrast_button.set_palette(ScalePalette('Contrast',\
v4l2.V4L2_CID_CONTRAST))
self._contrast_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._contrast_button)
self._contrast_button.show()
if self._check_available_control(v4l2.V4L2_CID_SATURATION):
self._saturation_button = ToolButton('saturation')
self._saturation_button.set_palette(ScalePalette('Saturation',\
v4l2.V4L2_CID_SATURATION))
self._saturation_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._saturation_button, -1)
self._saturation_button.show()
if self._check_available_control(
v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE):
self._white_balance_button = ToolButton('white_balance')
self._white_balance_button.set_palette(ScalePalette('White'
' balance', v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE,
self._check_available_control(
v4l2.V4L2_CID_AUTO_WHITE_BALANCE)))
self._white_balance_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._white_balance_button, -1)
self._white_balance_button.show()
if self._check_available_control(v4l2.V4L2_CID_HUE):
self._color_tone_button = ToolButton('color_tone')
self._color_tone_button.set_palette(ScalePalette('Color'
' tone', v4l2.V4L2_CID_HUE,
self._check_available_control(
v4l2.V4L2_CID_HUE_AUTO)))
self._color_tone_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._color_tone_button, -1)
self._color_tone_button.show()
#if self._check_available_control(v4l2.V4L2_CID_NIGHT_MODE):
# self._night_mode_button = ToolButton('night_mode')
# self._night_mode_button.set_palette(ScalePalette('Night mode',\
# v4l2.V4L2_CID_NIGHT_MODE))
# self._night_mode_button.connect('clicked',
# self.__button_clicked_cb)
# self._live_toolbar_container.add(self._night_mode_button)
# self._night_mode_button.show()
self._previous_image = ToolButton('go-previous-paired')
self._previous_image.label = _('Previous image')
self._previous_image.connect('clicked',
self.__previous_image_clicked_cb)
self._preview_toolbar_container.add(self._previous_image)
self._previous_image.show()
self._next_image = ToolButton('go-next-paired')
self._next_image.label = _('Next image')
self._next_image.connect('clicked',
self.__next_image_clicked_cb)
self._preview_toolbar_container.add(self._next_image)
self._next_image.show()
self._image_name_entry = gtk.Entry()
self._image_name_entry.set_text('')
self._image_name_entry.set_size_request(400, -1)
self._image_name_entry.connect('activate',
self.__image_name_entry_activated_cb)
self._preview_toolbar_container.add(self._image_name_entry)
self._image_name_entry.show()
self._save_to_journal = ToolButton('save_to_journal')
self._save_to_journal.label = _('Save to journal')
self._save_to_journal.connect('clicked',
self.__save_to_journal_clicked_cb)
self._preview_toolbar_container.add(self._save_to_journal)
self._save_to_journal.show()
self._trash = ToolButton('trash')
self._trash.label = _('Delete')
self._trash.connect('clicked',
self.__trash_clicked_cb)
self._preview_toolbar_container.add(self._trash)
self._trash.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self._controls_toolbar.insert(separator, -1)
separator.show()
self._mode_button = ToolButton('%s_mode' % self._mode)
self._mode_button.props.label = _('Mode')
self._mode_button.connect('clicked',
self.__switch_modes_cb)
self._controls_toolbar.insert(self._mode_button, -1)
self._mode_button.show()
if not OLD_TOOLBAR:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
self._controls_toolbar.insert(separator, -1)
separator.show()
activity_stop = StopButton(self)
toolbar_box.toolbar.insert(activity_stop, -1)
activity_stop.show()
self._preview_toolitem.add(self._preview_toolbar_container)
self._live_toolitem.add(self._live_toolbar_container)
self._preview_toolbar_container.show()
self._live_toolbar_container.show()
if self._mode == 'preview':
self._controls_toolbar.insert(self._preview_toolitem, 1)
self._preview_toolitem.show()
else:
self._controls_toolbar.insert(self._live_toolitem, 1)
self._live_toolitem.show()
self._mode = 'live'
self._controls_toolbar.show()
activity_toolbar.show()
self._main_view = gtk.HBox()
self._movie_window = gtk.DrawingArea()
self._movie_window.connect('realize',
self.__movie_window_realize_cb)
self._movie_window.unset_flags(gtk.DOUBLE_BUFFERED)
self._movie_window.set_flags(gtk.APP_PAINTABLE)
self._main_view.add(self._movie_window)
self._preview_frame = gtk.AspectFrame(None, 0.5, 0.5, 1, True)
self._preview_window = gtk.Image()
self._preview_frame.add(self._preview_window)
self._preview_window.connect('size_allocate',
self.__preview_window_size_allocate_cb)
self.xoscope = gst.Pipeline('xoscope_pipe')
camsrc = gst.element_factory_make('v4l2src', 'camsrc')
caps = gst.Caps('video/x-raw-yuv')
filt = gst.element_factory_make('capsfilter', 'filter')
filt.set_property('caps', caps)
ffmpegcolorspace = gst.element_factory_make('ffmpegcolorspace',
'ffmpegcolorspace')
self._disp_sink = gst.element_factory_make('xvimagesink', 'disp_sink')
# http://thread.gmane.org/gmane.comp.video.gstreamer.devel/29644
self._disp_sink.set_property('sync', False)
self.image_sink = gst.element_factory_make('fakesink',
'image_sink')
self.image_sink.set_property('silent', True)
tee = gst.element_factory_make('tee', 'tee')
queue = gst.element_factory_make('queue', 'dispqueue')
queue.set_property('leaky', True)
queue.set_property('max-size-buffers', 20)
queue2 = gst.element_factory_make('queue', 'imagequeue')
queue2.set_property('leaky', True)
queue2.set_property('max-size-buffers', 20)
self._zoom_element = gst.element_factory_make('videobox', 'zoombox')
jpeg = gst.element_factory_make('jpegenc', 'pbjpeg')
jpeg.set_property('quality', 100)
self.xoscope.add(camsrc, filt, ffmpegcolorspace,\
self._zoom_element, self._disp_sink, tee, queue, queue2,\
self.image_sink, jpeg)
gst.element_link_many(camsrc, filt, self._zoom_element,\
ffmpegcolorspace, tee, queue, self._disp_sink)
gst.element_link_many(tee, queue2, jpeg, self.image_sink)
bus = self.xoscope.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect('message', self.__on_message_cb)
bus.connect('sync-message::element', self.__on_sync_message_cb)
self._main_view.show()
self._movie_window.show()
self.set_canvas(self._main_view)
# If we start playing without a delay, the live view window
# doesn't get attached to the main canvas properly (This is
# a problem on slow computers like xo1).
gobject.timeout_add(2000, self.__start_live_view)
class Gui (gtk.VBox):
def __init__(self, activity):
gtk.VBox.__init__(self)
self.activity = activity
mov_box = gtk.HBox()
#Add movie window
self.movie_window = gtk.DrawingArea()
self.movie_window_preview = gtk.DrawingArea()
mov_box.pack_start(self.movie_window)
mov_box.pack_start(self.movie_window_preview)
self.pack_start(mov_box)
# Add Chat section
##################
# Chat expander allows chat to be hidden/shown
chat_expander = gtk.Expander(_("Chat"))
chat_expander.set_expanded(True)
self.pack_start(chat_expander, False)
chat_holder = gtk.VBox()
chat_expander.add(chat_holder)
# Create entry and history view for chat
chat_history = gtk.ScrolledWindow()
chat_history.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.chat_text = gtk.TextBuffer()
self.text_view = gtk.TextView(self.chat_text)
self.text_view.set_editable(False)
self.text_view.set_size_request(-1, 200)
chat_history.add(self.text_view)
# Send button to complete feel of a chat program
self.chat_entry = gtk.Entry()
self.chat_entry.connect("activate", self.send_chat)
send_but = gtk.Button(_("Send"))
send_but.connect("clicked", self.send_chat)
# Wrap button and entry in hbox so they are on the same line
chat_entry_hbox = gtk.HBox()
chat_entry_hbox.pack_start(self.chat_entry)
chat_entry_hbox.pack_end(send_but, False)
# Add chat history and entry to expander
chat_holder.pack_start(chat_history)
chat_holder.pack_start(chat_entry_hbox, False)
# Show gui
self.build_toolbars()
self.show_all()
#scroll to bottom
self.text_view.scroll_to_iter(self.chat_text.get_end_iter(), 0.1)
def get_history(self):
return self.chat_text.get_text(self.chat_text.get_start_iter(),
self.chat_text.get_end_iter())
def add_chat_text(self, text):
self.chat_text.insert(self.chat_text.get_end_iter(), "%s\n" % text)
self.text_view.scroll_to_iter(self.chat_text.get_end_iter(), 0.1)
def send_chat(self, w):
if self.chat_entry.get_text != "":
self.activity.send_chat_text(self.chat_entry.get_text())
self.chat_entry.set_text("")
def build_toolbars(self):
self.settings_bar = gtk.Toolbar()
self.settings_buttons = {}
self.settings_buttons['reload_video'] = ToolButton('view-spiral')
self.settings_buttons['reload_video'].set_tooltip(_("Reload Screen"))
self.settings_buttons['reload_video'].connect("clicked",
self.force_redraw, None)
self.settings_bar.insert(self.settings_buttons['reload_video'], -1)
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Settings"), self.settings_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show_all()
def force_redraw(self, widget, value=None):
# Fixme: This should not be required, this is a hack for now until
# a better solution that works is found
self.movie_window.hide()
self.movie_window_preview.hide()
self.movie_window.show()
self.movie_window_preview.show()
def send_video_to_screen(self, source, screen):
if screen == 'MAIN':
source.set_xwindow_id(self.movie_window.window.xid)
elif screen == 'PREVIEW':
source.set_xwindow_id(self.movie_window_preview.window.xid)
def __init__(self, handle):
"""Set up the Words activity."""
super(WordsActivity, self).__init__(handle)
self._logger = logging.getLogger('words-activity')
from sugar.graphics.menuitem import MenuItem
from sugar.graphics.icon import Icon
# Instantiate a language model.
# FIXME: We should ask the language model what langs it supports.
self.langs = ["French", "German", "Italian", "Portuguese", "Spanish"]
# Initial values.
self.fromlang = "English"
self.tolang = "Spanish"
import LanguageModel
self.languagemodel = LanguageModel.LanguageModel()
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# Main layout.
hbox = gtk.HBox(homogeneous=True)
vbox = gtk.VBox()
# Toolbar.
try:
from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
from sugar.activity.widgets import ActivityButton, StopButton, \
ShareButton, KeepButton, TitleEntry
toolbar_box = ToolbarBox()
activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbar_box)
toolbar_box.show()
except ImportError:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
# transbox: <label> - <text entry> - <speak button>
transbox1 = gtk.HBox()
transbox2 = gtk.HBox()
# Labels.
label1 = gtk.Label(_("Word"))
label2 = gtk.Label(_("Translation"))
# Text entry box to enter word to be translated.
self.totranslate = gtk.Entry(max=50)
self.totranslate.connect("changed", self.totranslate_cb)
self.totranslate.modify_font(pango.FontDescription("Sans 14"))
# Text entry box to receive word translated.
self.translated = gtk.Entry(max=50)
self.translated.set_property('editable', False)
self.translated.modify_font(pango.FontDescription("Sans 14"))
# Speak buttons.
speak1 = gtk.Button("Speak")
speak1.connect("clicked", self.speak1_cb)
speak2 = gtk.Button("Speak")
speak2.connect("clicked", self.speak2_cb)
transbox1.pack_start(label1, expand=False)
transbox1.pack_start(self.totranslate)
transbox1.pack_start(speak1, expand=False)
transbox2.pack_start(label2, expand=False)
transbox2.pack_start(self.translated)
transbox2.pack_start(speak2, expand=False)
vbox.pack_start(transbox1, expand=False)
vbox.pack_start(transbox2, expand=False)
# The language choice combo boxes.
combohbox = gtk.HBox(homogeneous=True)
self.lang1combo = gtk.combo_box_new_text()
self.lang1combo.append_text("English")
self.lang1combo.connect("changed", self.lang1combo_cb)
self.lang1combo.set_active(0)
self.lang2combo = gtk.combo_box_new_text()
for x in self.langs:
self.lang2combo.append_text(x)
self.lang2combo.connect("changed", self.lang2combo_cb)
self.lang2combo.set_active(4)
self.lang1combo.set_size_request(600, 50)
self.lang2combo.set_size_request(600, 50)
combohbox.pack_start(self.lang1combo, expand=False)
combohbox.pack_start(self.lang2combo, expand=False)
vbox.pack_start(combohbox, expand=False)
# The "lang1" treeview box
self.lang1model = gtk.ListStore(str)
lang1view = gtk.TreeView(self.lang1model)
lang1cell = gtk.CellRendererText()
lang1treecol = gtk.TreeViewColumn("", lang1cell, text=0)
lang1view.get_selection().connect("changed", self.lang1sel_cb)
lang1view.append_column(lang1treecol)
# The "lang2" box
self.lang2model = gtk.ListStore(str)
lang2view = gtk.TreeView(self.lang2model)
lang2cell = gtk.CellRendererText()
lang2treecol = gtk.TreeViewColumn("", lang2cell, text=0)
lang2view.get_selection().connect("changed", self.lang2sel_cb)
lang2view.append_column(lang2treecol)
hbox.pack_start(lang1view)
hbox.pack_start(lang2view)
vbox.pack_start(hbox)
self.set_canvas(vbox)
self.totranslate.grab_focus()
self.show_all()
class ScreencastUserInterface(gobject.GObject):
__gsignals__ = {
'recordbutton-clicked':
(gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()),
'stopbutton-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())
}
def __init__(self, activity):
""" Constructor
"""
super(ScreencastUserInterface, self).__init__()
self._toolbox = None
self._toolbar = None
self._recordbutton = None
self._stopbutton = None
self._buttonsbox = None
self._box = None
self._boxalign = None
self._checkbox = None
self._label = None
self._activity = activity
# Widgets
self.buildToolbar()
self.buildButtons()
self.buildCheckbox()
self.buildLabel()
# Main box
self._box = gtk.VBox(spacing=20)
self._box.pack_start(self._buttonsbox)
self._box.pack_start(self._checkbox)
self._box.pack_start(self._label)
# Align box
self._boxalign = gtk.Alignment(0.5, 0.5, 0, 0)
self._boxalign.add(self._box)
# Set canvas with box alignment
self._activity.set_canvas(self._boxalign)
def buildToolbar(self):
""" Build GUI Toolbar
"""
self._toolbox = ActivityToolbox(self._activity)
self._toolbar = self._toolbox.get_activity_toolbar()
# Remove share button
self._toolbar.remove(self._toolbar.share)
self._toolbar.share = None
self._activity.set_toolbox(self._toolbox)
# we do not have collaboration features
# make the share option insensitive
self._activity.max_participants = 1
def buildButtons(self):
""" Build buttons
"""
# Record button
self._recordbutton = gtk.Button(i18n.I18N_RECORD_BUTTON)
self._recordbutton.connect("clicked", self.recordbuttonClicked)
self._recordbutton.set_size_request(150, 150)
recordbuttonIcon = gtk.Image()
recordbuttonIcon.set_from_icon_name("media-record", -1)
self._recordbutton.set_image(recordbuttonIcon)
# Stop button
self._stopbutton = gtk.Button(i18n.I18N_STOP_BUTTON)
self._stopbutton.connect("clicked", self.stopbuttonClicked)
self._stopbutton.set_size_request(150, 150)
self._stopbutton.set_sensitive(False)
stopbuttonIcon = gtk.Image()
stopbuttonIcon.set_from_icon_name("media-playback-stop", -1)
self._stopbutton.set_image(stopbuttonIcon)
# Buttons hbox
self._buttonsbox = gtk.HBox(spacing=20)
self._buttonsbox.pack_start(self._recordbutton)
self._buttonsbox.pack_start(self._stopbutton)
def buildCheckbox(self):
""" Build checkbox for display state
"""
self._checkbox = gtk.CheckButton(label=i18n.I18N_RECORD_SOUND_CHECKBOX)
self._checkbox.set_active(True)
def buildLabel(self):
""" Build label for display state
"""
self._label = gtk.Label(i18n.I18N_STATUS_STOPPED)
def recordbuttonClicked(self, widget):
""" Event click handler
"""
self.emit('recordbutton-clicked')
def stopbuttonClicked(self, widget):
""" Event click handler
"""
self.emit('stopbutton-clicked')
def changeLabelText(self, text):
""" Change text of status label
"""
self._label.set_text(text)
def refreshLabelRecordText(self, text1, text2):
""" Change text of label
"""
text = i18n.I18N_STATUS_RECORDING + ", " + text1 + ", " + text2
self.changeLabelText(text)
def changeButtonsState(self, newstate="recording"):
""" Change state of the buttons
"""
if newstate == "recording":
self._recordbutton.set_sensitive(False)
self._stopbutton.set_sensitive(True)
self.changeLabelText(i18n.I18N_STATUS_RECORDING)
self._checkbox.set_sensitive(False)
else:
self._recordbutton.set_sensitive(True)
self._stopbutton.set_sensitive(False)
self.changeLabelText(i18n.I18N_STATUS_STOPPED)
self._checkbox.set_sensitive(True)
def showInterface(self):
""" Show user interface
"""
self._activity.show_all()
def getRecordSoundOption(self):
""" Get record sound option
"""
return self._checkbox.get_active()
def alert(self, title, text=None):
""" Alert popup
"""
alert = NotifyAlert(timeout=10)
alert.props.title = title
alert.props.msg = text
self._activity.add_alert(alert)
alert.connect('response', self.alert_cancel_cb)
alert.show()
def alert_cancel_cb(self, alert, response_id):
""" Destroy alert popup
"""
self._activity.remove_alert(alert)
def __init__(self, handle):
""" Init canvas, toolbars, etc.
The toolbars are in toolbar_top.py and toolbar_side.py
The audio controls are in audiograb.py
The rendering happens in drawwaveform.py
Logging (Journal interactions) are in journal.py """
activity.Activity.__init__(self, handle)
try:
tmp_dir = path.join(activity.get_activity_root(), "data")
except AttributeError:
# Early versions of Sugar (e.g., 656) didn't support
# get_activity_root()
tmp_dir = path.join(
environ['HOME'],
".sugar/default/org.laptop.MeasureActivity/data")
self.using_gconf = _using_gconf
self.icon_colors = self.get_icon_colors_from_sugar()
self.stroke_color, self.fill_color = self.icon_colors.split(',')
self.nick = self.get_nick_from_sugar()
self.active_status = True
self.ACTIVE = True
self.LOGGING_IN_SESSION = False
self.CONTEXT = ''
self.adjustmentf = None # Freq. slider control
self.connect('notify::active', self._active_cb)
self.connect('destroy', self.on_quit)
self.hw = _get_hardware()
self.closedSound = None
self.openedSound = None
self.session_id = 0
self.ji = JournalInteraction(self)
colorBlack = Color()
colorBlack.init_rgba(0, 0, 0, 255)
self.playsoundWin = PlayVideoWindow(colorBlack.gColor)
self.playsound = Gplay()
self.playsound.window = self.playsoundWin
self.wave = DrawWaveform(self, self.playsound)
self.hw = _get_hardware()
log.debug('running on %s hardware' % (self.hw))
if self.hw == XO15:
self.audiograb = AudioGrab_XO15(self.wave.new_buffer, self)
elif self.hw == XO1:
self.audiograb = AudioGrab_XO1(self.wave.new_buffer, self)
else:
self.audiograb = AudioGrab_Unknown(self.wave.new_buffer, self)
# no sharing
self.max_participants = 1
self.has_toolbarbox = _has_toolbarbox
self.side_toolbar = SideToolbar(self)
self.text_box = TextBox()
self.box3 = gtk.HBox(False, 0)
self.box3.pack_start(self.wave, True, True, 0)
self.box3.pack_start(self.side_toolbar.box1, False, True, 0)
self.box1 = gtk.VBox(False, 0)
self.box1.pack_start(self.box3, True, True, 0)
self.box1.pack_start(self.text_box.box_main, False, True, 0)
self.set_canvas(self.box1)
self.toolbox = None
if self.has_toolbarbox:
toolbox = ToolbarBox()
self.toolbox = toolbox
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
else:
toolbox = ActivityToolbox(self)
self.toolbox = toolbox
# no sharing
if hasattr(toolbox, 'share'):
toolbox.share.hide()
elif hasattr(toolbox, 'props'):
toolbox.props.visible = False
self.set_toolbox(toolbox)
toolbox.connect('current-toolbar-changed',
self._toolbar_changed_cb)
self.sound_toolbar = SoundToolbar(self)
if self.has_toolbarbox:
self._sound_button = ToolbarButton(label=_('Sound'),
page=self.sound_toolbar,
icon_name='sound-tools')
toolbox.toolbar.insert(self._sound_button, -1)
self._sound_button.show()
else:
toolbox.add_toolbar(_('Sound'), self.sound_toolbar)
self.sound_toolbar.show()
if _is_xo(self.hw):
self.sensor_toolbar = SensorToolbar(self)
if self.has_toolbarbox:
self._sensor_button = ToolbarButton(label=_('Sensors'),
page=self.sensor_toolbar,
icon_name='sensor-tools')
toolbox.toolbar.insert(self._sensor_button, -1)
self._sensor_button.show()
else:
toolbox.add_toolbar(_('Sensors'), self.sensor_toolbar)
self.sensor_toolbar.show()
if self.has_toolbarbox:
_separator = gtk.SeparatorToolItem()
_separator.props.draw = False
toolbox.toolbar.insert(_separator, -1)
_separator.show()
# add a "dummy" button to indicate what capture mode we are in
self.label_button = ToolButton('domain-time2')
toolbox.toolbar.insert(self.label_button, -1)
self.label_button.show()
self.label_button.set_tooltip(_('Time Base'))
self.label_button.connect('clicked', self._label_cb)
self.sound_toolbar.add_frequency_slider(toolbox.toolbar)
_separator = gtk.SeparatorToolItem()
_separator.props.draw = False
_separator.set_expand(True)
toolbox.toolbar.insert(_separator, -1)
_separator.show()
_stop_button = StopButton(self)
_stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(_stop_button, -1)
_stop_button.show()
self.set_toolbox(toolbox)
self._sound_button.set_expanded(True)
else:
toolbox.set_current_toolbar(TOOLBARS.index('sensor'))
toolbox.show()
self.sound_toolbar.update_page_size()
self.show_all()
self.first = True
self.set_sound_context()
self.set_sensor_context()
self.set_show_hide_windows()
self.wave.set_active(True)
self.wave.set_context_on()
self.set_show_hide_windows()
def instance(self):
book.wiki = book.WikiBook()
if not book.custom:
book.custom = book.CustomBook()
self.edit_page = 1
self.edit = edit.View()
self.library = library.View(self)
if OLD_TOOLBAR:
self.edit_toolbar = gtk.Toolbar()
self.edit_bar = edit.ToolbarBuilder(self.edit, self.edit_toolbar)
self.edit_toolbar.show_all()
self.library_toolbar = gtk.Toolbar()
self.library_bar = library.ToolbarBuilder(self.library,
self.library_toolbar)
self.library_toolbar.show_all()
toolbox = ActivityToolbox(self)
toolbox.connect('current-toolbar-changed',
self._toolbar_changed_cb)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Library'), self.library_toolbar)
toolbox.add_toolbar(_('Edit'), self.edit_toolbar)
toolbox.set_current_toolbar(1)
else:
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
self.set_toolbar_box(toolbar_box)
self._toolbar = toolbar_box.toolbar
tool_group = None
search_button = RadioToolButton()
search_button.props.group = tool_group
tool_group = search_button
search_button.props.icon_name = 'white-search'
search_button.set_tooltip(_('Library'))
search_button.mode = 'search'
search_button.connect('clicked', self.__mode_button_clicked)
self._toolbar.insert(search_button, -1)
edit_button = RadioToolButton()
edit_button.props.group = tool_group
edit_button.props.icon_name = 'toolbar-edit'
edit_button.set_tooltip(_('Edit'))
edit_button.mode = 'edit'
edit_button.connect('clicked', self.__mode_button_clicked)
self._toolbar.insert(edit_button, -1)
self._toolbar.insert(gtk.SeparatorToolItem(), -1)
self.edit_bar = edit.ToolbarBuilder(self.edit, self._toolbar)
self.library_bar = library.ToolbarBuilder(self.library,
self._toolbar)
edit_fake = gtk.EventBox()
self.notebook.append_page(self.library)
self.notebook.append_page(self.edit)
self.notebook.append_page(edit_fake)
self.show_all()
if not OLD_TOOLBAR:
self.__mode_button_clicked(search_button)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
self._toolbar.insert(separator, -1)
stop_button = StopButton(self)
stop_button.show()
self._toolbar.insert(stop_button, -1)
def __init__(self, handle):
# self.initiating indicates whether this instance has initiated sharing
# it always starts false, but will be set to true if this activity
# initiates sharing. In particular, if Activity.__init__ calls
# self.share(), self.initiating will be set to True.
self.initiating = False
# self._processed_share indicates whether when_shared() has been called
self._processed_share = False
# self.initialized tracks whether the Activity's display is up and running
self.initialized = False
self.early_setup()
super(GroupActivity, self).__init__(handle)
self.dbus_name = self.get_bundle_id()
self.logger = logging.getLogger(self.dbus_name)
self._handle = handle
##gobject.threads_init()
self._sharing_completed = not self._shared_activity
self._readfile_completed = not handle.object_id
if self._shared_activity:
self.message = self.message_joining
elif handle.object_id:
self.message = self.message_loading
else:
self.message = self.message_preparing
if OLD_TOOLBAR:
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
self.set_toolbox(self.toolbox)
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.set_toolbar_box(toolbar_box)
v = gtk.VBox()
self.startup_label = gtk.Label(self.message)
v.pack_start(self.startup_label)
Window.set_canvas(self, v)
self.show_all()
# The show_all method queues up draw events, but they aren't executed
# until the mainloop has a chance to process them. We want to process
# them immediately, because we need to show the waiting screen
# before the waiting starts, not after.
exhaust_event_loop()
# exhaust_event_loop() provides the possibility that write_file could
# be called at this time, so write_file is designed to trigger read_file
# itself if that path occurs.
self.tubebox = groupthink.TubeBox()
self.timer = groupthink.TimeHandler("main", self.tubebox)
self.cloud = groupthink.Group(self.tubebox)
# self.cloud is extremely important. It is the unified reference point
# that contains all state in the system. Everything else is stateless.
# self.cloud has to be defined before the call to self.set_canvas, because
# set_canvas can trigger almost anything, including pending calls to read_file,
# which relies on self.cloud.
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
if self.get_shared():
if self.initiating:
self._shared_cb(self)
else:
self._joined_cb(self)
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
if not self._readfile_completed:
self.read_file(self._jobject.file_path)
elif not self._shared_activity:
gobject.idle_add(self._initialize_cleanstart)
def build_toolbars(self):
self.action_buttons = {}
# BUILD CUSTOM TOOLBAR
self.action_bar = gtk.Toolbar()
self.action_buttons['add'] = ToolButton('fs_gtk-add')
self.action_buttons['add'].set_tooltip(_("Add Object"))
self.action_buttons['rem'] = ToolButton('fs_gtk-remove')
self.action_buttons['rem'].set_tooltip(_("Remove Object(s)"))
self.action_buttons['save'] = ToolButton('filesave')
self.action_buttons['save'].set_tooltip(_("Copy Object(s) to Journal"))
self.action_buttons['down'] = ToolButton('epiphany-download')
self.action_buttons['down'].set_tooltip(_('Download Object(s)'))
self.action_buttons['admin'] = ToolButton('gtk-network')
self.action_buttons['admin'].set_tooltip(_('Server Permissions'))
self.action_buttons['server'] = ToolButton('gaim-link')
self.action_buttons['server'].set_tooltip(_('Connect to Server'))
self.action_buttons['server'].set_sensitive(False)
if self.activity.isServer:
self.action_buttons['add'].connect("clicked",
self.guiHandler.requestAddFile,
None)
self.action_buttons['save'].connect("clicked",
self.guiHandler.requestInsFile,
None)
self.action_buttons['rem'].connect("clicked",
self.guiHandler.requestRemFile,
None)
self.action_buttons['server'].connect(
"clicked", self.guiHandler.switch_to_server, None)
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['save'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
self.action_bar.insert(self.action_buttons['server'], -1)
# Check for server, if found activate connect link
def check_server_status():
try:
if self.activity.check_for_server():
self.action_buttons['server'].set_sensitive(True)
except ServerRequestFailure:
pass
threading.Thread(target=check_server_status).start()
else:
self.action_buttons['down'].connect(
"clicked", self.guiHandler.requestDownloadFile, None)
self.action_bar.insert(self.action_buttons['down'], -1)
if self.activity._mode == 'SERVER' and self.activity._user_permissions != 0:
self.action_buttons['add'].connect(
"clicked", self.guiHandler.requestAddFile,
{'upload': True})
self.action_buttons['rem'].connect(
"clicked", self.guiHandler.requestRemFile,
{'remove': True})
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
if self.activity._user_permissions == 2:
self.action_buttons['admin'].connect(
"clicked", self.guiHandler.showAdmin, None)
self.action_bar.insert(self.action_buttons['admin'], -1)
self.action_bar.show_all()
self.toolbar_set_selection(False)
# Create Toolbox
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Actions"), self.action_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show()
self.toolbox.set_current_toolbar(1)
class SaludameActivity(Activity):
''' Clase llamada por sugar cuando se ejecuta la actividad.
El nombre de esta clase está señalada en el archivo activity/activity.info '''
def __init__(self, handle):
self.game_init = False # Tells if game engine was initialized
self.loaded_game = None
Activity.__init__(self, handle)
# Creates the activiy box for toolbars
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
# Retrieves the Activity standard toolbar
self.activity_toolbar = self.toolbox.get_activity_toolbar()
# Creates other toolbars
# Game toolbar gets created on demand
# Library toolbar gets created on demand
self.guides_toolbar = gtk.Toolbar()
self.credits_toolbar = gtk.Toolbar()
self.indexes = ["activity"] # right now only activity toolbar
# Create startup windows
self.startup_window = startup_window.StartupWindow(self._start_cb, self._load_last_cb)
# Create the canvas to embbed pygame
self.pygame_canvas = PygameCanvas(self, False)
# Create Health Library Window
self.health_library = content_window.ContentWindow()
# Create Guides Window
self.guides = guides_window.GuidesWindow()
# Create Credits Window
self.credits = credits.Credits()
self.startup_window.show()
self.pygame_canvas.show()
self.health_library.show()
self.guides.show()
self.credits.show()
self.items = gtk.Notebook()
self.items.set_show_tabs(False)
self.items.set_show_border(False)
self.items.append_page(self.startup_window)
self.items.append_page(self.pygame_canvas)
self.items.append_page(self.health_library)
self.items.append_page(self.guides)
self.items.append_page(self.credits)
self.items.show()
self.set_canvas(self.items)
logging.debug("Create main")
self.game = game.Main()
self.game.set_game_over_callback(self.game_over_callback)
self.toolbox.connect('current-toolbar-changed', self.change_mode)
self.make_toolbox(False)
self.toolbox.set_current_toolbar(0) # Start in activity tab
# force the toolbar change
self.change_mode(None, self.toolbox.get_current_toolbar())
game.set_library_function = self.set_library # Sets the callback to put links in the library
self.show()
def make_toolbox(self, add_game):
toolbars = len(self.indexes)
for i in range(toolbars, 0, -1):
self.toolbox.remove_toolbar(i)
self.indexes = ["activity"] # activity toolbar never gets removed
if add_game:
self.toolbox.add_toolbar(_("Game"), self.get_game_toolbar())
self.indexes += ["game"]
self.indexes += ["library", "guides", "credits"]
self.toolbox.add_toolbar(_("Health Library"), self.health_library.get_toolbar())
self.toolbox.add_toolbar(_("Guides"), self.guides_toolbar)
self.toolbox.add_toolbar(_("Credits"), self.credits_toolbar)
def change_mode(self, notebook, index):
game.pause = True
self.pygame_canvas.translator.unhook_pygame()
self.health_library.ditch()
self.guides.ditch()
self.guides.ditch()
gc.collect() # Collects garbaje
if self.indexes[index] == "activity":
self.items.set_current_page(0)
if self.indexes[index] == "game":
game.pause = False
self.show_game()
self.items.set_current_page(1)
elif self.indexes[index] == "library":
self.items.set_current_page(2)
elif self.indexes[index] == "guides":
self.items.set_current_page(3)
elif self.indexes[index] == "credits":
self.credits.before_show()
self.items.set_current_page(4)
#Override activity.Activity's can_close method
def can_close(self):
game.running = False
return True
def _start_cb(self, gender, name):
#self.create_in_journal()
self.metadata['title'] = _("Saludame") + " " + name
self.game.gender = gender
self.game.name = name
self.startup_window.set_welcome()
if self.game.started:
self.game.main(True)
self.make_toolbox(True)
self.toolbox.set_current_toolbar(1) # Move to game tab
def show_game(self):
if self.game.started:
self.game.windows_controller.reload_main = True # Repaints the whole screen
if self.game_init:
self.pygame_canvas.translator.hook_pygame()
else:
self.game_init = True
# Start pygame
self.pygame_canvas.run_pygame(lambda:self.game.main(True)) # Indico que llame a la función local para iniciar el juego pygame
def set_library(self, link, anchor=None):
self.toolbox.set_current_toolbar(2)
self.health_library.set_url(link, anchor)
def _load_last_cb(self, event):
metadata = self.get_last_game()
if metadata:
self.metadata['title'] = metadata['title']
self.make_toolbox(True)
self.toolbox.set_current_toolbar(1)
def game_over_callback(self):
self.make_toolbox(False)
self.toolbox.set_current_toolbar(0) # Move to game tab
def write_file(self, file_path):
if self.game.started:
try:
self.game.save_game(file_path)
except Exception,e:
print "Error writting to file"
print e
raise e
else:
def __init__(self, handle):
print "running activity init", handle
Activity.__init__(self, handle)
print "activity running"
self._logger = logging.getLogger('scribble-activity')
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
pencilbtn = sugar.graphics.radiotoolbutton.RadioToolButton()
pencilbtn.set_named_icon('tool-pencil')
pencilbtn.set_tooltip(_("Pencil"))
pencilbtn.connect('toggled', self._pencil_cb)
circlebtn = sugar.graphics.radiotoolbutton.RadioToolButton()
circlebtn.set_named_icon('tool-shape-ellipse')
circlebtn.set_tooltip(_("Ellipse"))
circlebtn.connect('toggled', self._circle_cb)
circlebtn.set_group(pencilbtn)
rectbtn = sugar.graphics.radiotoolbutton.RadioToolButton()
rectbtn.set_named_icon('tool-shape-rectangle')
rectbtn.set_tooltip(_("Rectangle"))
rectbtn.connect('toggled', self._rect_cb)
rectbtn.set_group(circlebtn)
polybtn = sugar.graphics.radiotoolbutton.RadioToolButton()
polybtn.set_named_icon('tool-shape-freeform')
polybtn.set_tooltip(_("Shape"))
polybtn.connect('toggled', self._poly_cb)
polybtn.set_group(rectbtn)
sep = gtk.SeparatorToolItem()
sep.set_expand(False)
sep.set_draw(True)
erasebtn = sugar.graphics.radiotoolbutton.RadioToolButton()
erasebtn.set_named_icon('tool-eraser')
erasebtn.set_tooltip(_("Erase"))
erasebtn.connect('toggled', self._erase_cb)
erasebtn.set_group(polybtn)
toolbar = gtk.Toolbar()
toolbar.insert(pencilbtn, -1)
toolbar.insert(circlebtn, -1)
toolbar.insert(rectbtn, -1)
toolbar.insert(polybtn, -1)
toolbar.insert(sep, -1)
toolbar.insert(erasebtn, -1)
sep = gtk.SeparatorToolItem()
sep.set_expand(True)
sep.set_draw(False)
toolbar.insert(sep, -1)
exportbtn = ExportButton(self)
toolbar.insert(exportbtn, -1)
exportbtn.show()
toolbox.add_toolbar(_('Toolbox'), toolbar)
toolbar.show_all()
self._scribblewidget = scribblewidget.ScribbleWidget()
self._scribblewidget.connect('item-added', \
self.scribblewidget_item_added_cb)
colors = profile.get_color()
self._scribblewidget.set_fill_color(colors.get_fill_color())
self._scribblewidget.set_stroke_color(colors.get_stroke_color())
self._scribblewidget.set_tool('pencil')
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self._scribblewidget)
self.set_canvas(sw)
sw.show_all()
self.cmdtube = None # Shared session
self.initiating = False
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def __init__(self, handle):
"""Set up the StopWatch activity."""
Activity.__init__(self, handle)
self._logger = logging.getLogger('stopwatch-activity')
gobject.threads_init()
# top toolbar with share and close buttons:
OLD_TOOLBAR = False
try:
from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
from sugar.activity.widgets import ActivityToolbarButton, StopButton, \
ShareButton, TitleEntry, ActivityButton
except ImportError:
OLD_TOOLBAR = True
if OLD_TOOLBAR:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
try:
from sugar.activity.widgets import DescriptionItem
description_item = DescriptionItem(self)
toolbar_box.toolbar.insert(description_item, -1)
description_item.show()
except:
pass
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
self.tubebox = dobject.TubeBox()
self.timer = dobject.TimeHandler("main", self.tubebox)
self.gui = stopwatch.GUIView(self.tubebox, self.timer)
self.set_canvas(self.gui.display)
self.show_all()
self.initiating = False
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating PlayGo')
self.size = DEFAULT_SIZE
self.komi = DEFAULT_KOMI
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.gameToolbar = GameToolbar(self)
toolbox.add_toolbar(_('Game'), self.gameToolbar)
self.gameToolbar.connect('game-restart', self.restart_game)
self.gameToolbar.connect('game-board-size', self.board_size_change)
self.gameToolbar.connect('ai-activated', self.ai_activated_cb)
self.gameToolbar.connect('ai-deactivated', self.ai_deactivated_cb)
self.gameToolbar.show()
# Initialize the game
self.game = GoGame(self.size)
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.ai_activated = False
self.set_up_ui()
if not handle.object_id:
self.infopanel.show(_('Welcome to PlayGo!'))
else:
self.show_score()
self.lastX = -1
self.lastY = -1
# Set keypad actions
self._key_actions = {
'KP_Up': 'move_up',
'KP_Right': 'move_right',
'KP_Down': 'move_down',
'KP_Left': 'move_left',
'KP_Home': 'place_stone',
'KP_Next': 'undo',
'KP_End': 'pass'
}
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed', self._key_pressed_cb)
# New KeyGrabber API change (ticket #7999)
try:
self._key_grabber.grab_keys(self._key_actions.keys())
except:
for key in self._key_actions.keys():
self._key_grabber.grab(key)
#Set up collaboration
self.collaboration = CollaborationWrapper(self, self.buddy_joined,
self.buddy_left, self.Play,
self.game.undostack,
self.bootstrap)
self.connect('shared', self.collaboration._shared_cb)
if self._shared_activity:
# We are joining the activity
self.connect('joined', self.collaboration._joined_cb)
if self.get_shared():
# We've already joined
self.collaboration._joined_cb()
class GroupActivity(Activity):
message_preparing = "Preparing user interface"
message_loading = "Loading object from Journal"
message_joining = "Joining shared activity"
"""Abstract Class for Activities using Groupthink"""
def __init__(self, handle):
# self.initiating indicates whether this instance has initiated sharing
# it always starts false, but will be set to true if this activity
# initiates sharing. In particular, if Activity.__init__ calls
# self.share(), self.initiating will be set to True.
self.initiating = False
# self._processed_share indicates whether when_shared() has been called
self._processed_share = False
# self.initialized tracks whether the Activity's display is up and running
self.initialized = False
self.early_setup()
super(GroupActivity, self).__init__(handle)
self.dbus_name = self.get_bundle_id()
self.logger = logging.getLogger(self.dbus_name)
self._handle = handle
##gobject.threads_init()
self._sharing_completed = not self._shared_activity
self._readfile_completed = not handle.object_id
if self._shared_activity:
self.message = self.message_joining
elif handle.object_id:
self.message = self.message_loading
else:
self.message = self.message_preparing
if OLD_TOOLBAR:
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
self.set_toolbox(self.toolbox)
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.set_toolbar_box(toolbar_box)
v = gtk.VBox()
self.startup_label = gtk.Label(self.message)
v.pack_start(self.startup_label)
Window.set_canvas(self, v)
self.show_all()
# The show_all method queues up draw events, but they aren't executed
# until the mainloop has a chance to process them. We want to process
# them immediately, because we need to show the waiting screen
# before the waiting starts, not after.
exhaust_event_loop()
# exhaust_event_loop() provides the possibility that write_file could
# be called at this time, so write_file is designed to trigger read_file
# itself if that path occurs.
self.tubebox = groupthink.TubeBox()
self.timer = groupthink.TimeHandler("main", self.tubebox)
self.cloud = groupthink.Group(self.tubebox)
# self.cloud is extremely important. It is the unified reference point
# that contains all state in the system. Everything else is stateless.
# self.cloud has to be defined before the call to self.set_canvas, because
# set_canvas can trigger almost anything, including pending calls to read_file,
# which relies on self.cloud.
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
if self.get_shared():
if self.initiating:
self._shared_cb(self)
else:
self._joined_cb(self)
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
if not self._readfile_completed:
self.read_file(self._jobject.file_path)
elif not self._shared_activity:
gobject.idle_add(self._initialize_cleanstart)
def _initialize_cleanstart(self):
self.initialize_cleanstart()
self._initialize_display()
return False
def initialize_cleanstart(self):
"""Any subclass that needs to take any extra action in the case where
the activity is launched locally without a sharing context or input
file should override this method"""
pass
def early_setup(self):
"""Any subclass that needs to take an action before any external interaction
(e.g. read_file, write_file) occurs should place that code in early_setup"""
pass
def _initialize_display(self):
main_widget = self.initialize_display()
Window.set_canvas(self, main_widget)
self.initialized = True
if self._shared_activity and not self._processed_share:
# We are joining a shared activity, but when_shared has not yet
# been called
self.when_shared()
self._processed_share = True
self.show_all()
def initialize_display(self):
"""All subclasses must override this method, in order to display
their GUI using self.set_canvas()"""
raise NotImplementedError
def share(self, private=False):
"""The purpose of this function is solely to permit us to determine
whether share() has been called. This is necessary because share() may
be called during Activity.__init__, and thus emit the 'shared' signal
before we have a chance to connect any signal handlers."""
self.initiating = True
super(GroupActivity, self).share(private)
if self.initialized and not self._processed_share:
self.when_shared()
self._processed_share = True
def when_shared(self):
"""Inheritors should override this method to perform any special
operations when the user shares the session"""
pass
def _shared_cb(self, activity):
self.logger.debug('My activity was shared')
self.initiating = True
self._sharing_setup()
self.logger.debug('This is my activity: making a tube...')
id = self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].OfferDBusTube(
self.dbus_name, {})
def _sharing_setup(self):
if self._shared_activity is None:
self.logger.error('Failed to share or join activity')
return
self.conn = self._shared_activity.telepathy_conn
self.tubes_chan = self._shared_activity.telepathy_tubes_chan
self.text_chan = self._shared_activity.telepathy_text_chan
self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].connect_to_signal(
'NewTube', self._new_tube_cb)
def _list_tubes_reply_cb(self, tubes):
self.logger.debug('Got %d tubes from ListTubes' % len(tubes))
for tube_info in tubes:
self._new_tube_cb(*tube_info)
def _list_tubes_error_cb(self, e):
self.logger.error('ListTubes() failed: %s', e)
def _joined_cb(self, activity):
if not self._shared_activity:
return
self.logger.debug('Joined an existing shared activity')
self.initiating = False
self._sharing_setup()
self.logger.debug('This is not my activity: waiting for a tube...')
self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].ListTubes(
reply_handler=self._list_tubes_reply_cb,
error_handler=self._list_tubes_error_cb)
def _new_tube_cb(self, id, initiator, type, service, params, state):
self.logger.debug(
'New tube: ID=%d initator=%d type=%d service=%s '
'params=%r state=%d', id, initiator, type, service, params, state)
if (type == telepathy.TUBE_TYPE_DBUS and service == self.dbus_name):
if state == telepathy.TUBE_STATE_LOCAL_PENDING:
self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(
id)
tube_conn = TubeConnection(
self.conn,
self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES],
id,
group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
self.tubebox.insert_tube(tube_conn, self.initiating)
self._sharing_completed = True
if self._readfile_completed and not self.initialized:
self._initialize_display()
def read_file(self, file_path):
self.cloud.loads(self.load_from_journal(file_path))
self._readfile_completed = True
if self._sharing_completed and not self.initialized:
self._initialize_display()
pass
def load_from_journal(self, file_path):
"""This implementation of load_from_journal simply returns the contents
of the file. Any inheritor overriding this method must return the
string provided to save_to_journal as cloudstring."""
if file_path:
f = file(file_path, 'rb')
s = f.read()
f.close()
return s
def write_file(self, file_path):
# There is a possibility that the user could trigger a write_file
# action before read_file has occurred. This could be dangerous,
# potentially overwriting the journal entry with blank state. To avoid
# this, we ensure that read_file has been called (if there is a file to
# read) before writing.
if not self._readfile_completed:
self.read_file(self._jobject.file_path)
self.save_to_journal(file_path, self.cloud.dumps())
def save_to_journal(self, file_path, cloudstring):
"""This implementation of save_to_journal simply dumps the output of
self.cloud.dumps() to disk. Any inheritor who wishes to control file
output should override this method, and must
be sure to include cloudstring in its write_file."""
f = file(file_path, 'wb')
f.write(cloudstring)
f.close()
def _active_cb(self, widget, event):
self.logger.debug("_active_cb")
if self.props.active:
self.resume()
else:
self.pause()
def _visible_cb(self, widget, event):
self.logger.debug("_visible_cb")
if event.state == gtk.gdk.VISIBILITY_FULLY_OBSCURED:
self.pause()
else:
self.resume()
def pause(self):
"""Subclasses should override this function to stop updating the display
since it is not visible."""
pass
def resume(self):
"""Subclasses should override this function to resume updating the
display, since it is now visible"""
pass
def __init__(self, handle):
Activity.__init__(self, handle)
self.create_load = False
self.play_mode = None
toolbox = ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
self._memorizeToolbar = memorizetoolbar.MemorizeToolbar(self)
toolbox.add_toolbar(_('Play'), self._memorizeToolbar)
self._memorizeToolbar.show()
self._accessibility_toolbar = accessibilitytoolbar.AccessibilityToolbar(self)
toolbox.add_toolbar(_('Accessibility'), self._accessibility_toolbar)
self._accessibility_toolbar.show()
self._createToolbar = createtoolbar.CreateToolbar(self)
toolbox.add_toolbar(_('Create'), self._createToolbar)
self._createToolbar.show()
self.set_toolbox(toolbox)
toolbox.show()
# Play game mode
self.table = cardtable.CardTable()
self.scoreboard = scoreboard.Scoreboard()
self.game = game.MemorizeGame()
self.table.connect('key-press-event', self.table.key_press_event)
self.table.connect('card-flipped', self.game.card_flipped)
self.table.connect('card-overflipped', self.game.card_overflipped)
self.table.connect('card-highlighted', self.game.card_highlighted)
self.game.connect('set-border', self.table.set_border)
self.game.connect('flop-card', self.table.flop_card)
self.game.connect('flip-card', self.table.flip_card)
self.game.connect('cement-card', self.table.cement_card)
self.game.connect('highlight-card', self.table.highlight_card)
self.game.connect('load_mode', self.table.load_msg)
self.game.connect('msg_buddy', self.scoreboard.set_buddy_message)
self.game.connect('add_buddy', self.scoreboard.add_buddy)
self.game.connect('rem_buddy', self.scoreboard.rem_buddy)
self.game.connect('increase-score', self.scoreboard.increase_score)
self.game.connect('wait_mode_buddy', self.scoreboard.set_wait_mode)
self.game.connect('change-turn', self.scoreboard.set_selected)
self.game.connect('change_game', self.scoreboard.change_game)
self.game.connect('reset_scoreboard', self.scoreboard.reset)
self.game.connect('reset_table', self.table.reset)
self.game.connect('load_game', self.table.load_game)
self.game.connect('change_game', self.table.change_game)
self.game.connect('load_game', self._memorizeToolbar.update_toolbar)
self.game.connect('change_game', self._memorizeToolbar.update_toolbar)
self._memorizeToolbar.connect('game_changed', self.game.change_game)
self._accessibility_toolbar.connect('accessibility_changed', self.table.accessibility_changed)
self.hbox = gtk.HBox(False)
self.set_canvas(self.hbox)
# connect to the in/out events of the memorize activity
self.connect('focus_in_event', self._focus_in)
self.connect('focus_out_event', self._focus_out)
self.connect('destroy', self._cleanup_cb)
self.add_events(gtk.gdk.POINTER_MOTION_MASK)
self.connect('motion_notify_event',
lambda widget, event: face.look_at())
# start on the game toolbar, might change this
# to the create toolbar later
self.toolbox.connect('current-toolbar-changed', self.change_mode)
self.toolbox.set_current_toolbar(_TOOLBAR_PLAY)
# Get the Presence Service
self.pservice = presenceservice.get_instance()
self.initiating = None
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.current = 0
self.game.set_myself(self.owner)
self.connect('shared', self._shared_cb)
# Owner.props.key
if self._shared_activity:
# We are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# We've already joined
self._joined_cb()
else:
_logger.debug('buddy joined - __init__: %s', self.owner.props.nick)
game_file = join(dirname(__file__), 'demos', 'addition.zip')
self.game.load_game(game_file, 4, 'demo')
_logger.debug('loading conventional')
self.game.add_buddy(self.owner)
self.show_all()
def __init__(self, handle):
"""Set up the StopWatch activity."""
Activity.__init__(self, handle)
self._logger = logging.getLogger('stopwatch-activity')
gobject.threads_init()
# top toolbar with share and close buttons:
OLD_TOOLBAR = False
try:
from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton
from sugar.activity.widgets import ActivityToolbarButton, StopButton, \
ShareButton, TitleEntry, ActivityButton
except ImportError:
OLD_TOOLBAR = True
if OLD_TOOLBAR:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
try:
from sugar.activity.widgets import DescriptionItem
description_item = DescriptionItem(self)
toolbar_box.toolbar.insert(description_item, -1)
description_item.show()
except:
pass
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
self.tubebox = dobject.TubeBox()
self.timer = dobject.TimeHandler("main", self.tubebox)
self.gui = stopwatch.GUIView(self.tubebox, self.timer)
self.set_canvas(self.gui.display)
self.show_all()
self.initiating = False
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
class GuiView(gtk.ScrolledWindow):
"""
This class is used to just remove the table setup from the main file
"""
def __init__(self, activity):
gtk.ScrolledWindow.__init__(self)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.activity = activity
self.treeview = gtk.TreeView(gtk.TreeStore(str, object))
self.guiHandler = GuiHandler(activity, self.treeview, self)
#self.build_table(activity)
def build_toolbars(self):
self.action_buttons = {}
# BUILD CUSTOM TOOLBAR
self.action_bar = gtk.Toolbar()
self.action_buttons['add'] = ToolButton('fs_gtk-add')
self.action_buttons['add'].set_tooltip(_("Add Object"))
self.action_buttons['rem'] = ToolButton('fs_gtk-remove')
self.action_buttons['rem'].set_tooltip(_("Remove Object(s)"))
self.action_buttons['save'] = ToolButton('filesave')
self.action_buttons['save'].set_tooltip(_("Copy Object(s) to Journal"))
self.action_buttons['down'] = ToolButton('epiphany-download')
self.action_buttons['down'].set_tooltip(_('Download Object(s)'))
self.action_buttons['admin'] = ToolButton('gtk-network')
self.action_buttons['admin'].set_tooltip(_('Server Permissions'))
self.action_buttons['server'] = ToolButton('gaim-link')
self.action_buttons['server'].set_tooltip(_('Connect to Server'))
self.action_buttons['server'].set_sensitive(False)
if self.activity.isServer:
self.action_buttons['add'].connect("clicked",
self.guiHandler.requestAddFile,
None)
self.action_buttons['save'].connect("clicked",
self.guiHandler.requestInsFile,
None)
self.action_buttons['rem'].connect("clicked",
self.guiHandler.requestRemFile,
None)
self.action_buttons['server'].connect(
"clicked", self.guiHandler.switch_to_server, None)
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['save'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
self.action_bar.insert(self.action_buttons['server'], -1)
# Check for server, if found activate connect link
def check_server_status():
try:
if self.activity.check_for_server():
self.action_buttons['server'].set_sensitive(True)
except ServerRequestFailure:
pass
threading.Thread(target=check_server_status).start()
else:
self.action_buttons['down'].connect(
"clicked", self.guiHandler.requestDownloadFile, None)
self.action_bar.insert(self.action_buttons['down'], -1)
if self.activity._mode == 'SERVER' and self.activity._user_permissions != 0:
self.action_buttons['add'].connect(
"clicked", self.guiHandler.requestAddFile,
{'upload': True})
self.action_buttons['rem'].connect(
"clicked", self.guiHandler.requestRemFile,
{'remove': True})
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
if self.activity._user_permissions == 2:
self.action_buttons['admin'].connect(
"clicked", self.guiHandler.showAdmin, None)
self.action_bar.insert(self.action_buttons['admin'], -1)
self.action_bar.show_all()
self.toolbar_set_selection(False)
# Create Toolbox
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Actions"), self.action_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show()
self.toolbox.set_current_toolbar(1)
def on_selection_changed(self, selection):
if selection.count_selected_rows() == 0:
self.toolbar_set_selection(False)
else:
self.toolbar_set_selection(True)
def toolbar_set_selection(self, selected):
require_selection = ['save', 'rem', 'down']
for key in require_selection:
if selected:
self.action_buttons[key].set_sensitive(True)
else:
self.action_buttons[key].set_sensitive(False)
def build_table(self):
# Create File Tree
##################
# Name Cell_data_Func Expand Cell Renderer
text_cells = [
[_('Name'), FileInfo.file_name, False,
gtk.CellRendererText()],
[
_('Description'), FileInfo.file_desc, True,
gtk.CellRendererText()
], [_('Tags'), FileInfo.file_tags, False,
gtk.CellRendererText()],
[_('Size'), FileInfo.file_size, False,
gtk.CellRendererText()],
['', FileInfo.load_bar, False,
gtk.CellRendererProgress()]
]
for col_data in text_cells:
cell = col_data[3]
colName = gtk.TreeViewColumn(col_data[0], cell)
colName.set_cell_data_func(cell, col_data[1])
# Should the col expand
colName.set_expand(col_data[2])
# Add to tree
self.treeview.append_column(colName)
# make it searchable by name
self.treeview.set_search_column(1)
# Allow Multiple Selections
self.treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.treeview.get_selection().connect('changed',
self.on_selection_changed)
# Put table into scroll window to allow it to scroll
self.add_with_viewport(self.treeview)
def clear_files(self, deleteFile=True):
model = self.treeview.get_model()
iter = model.get_iter_root()
while iter:
key = model.get_value(iter, 0)
# Remove file from UI
self.guiHandler._remFileFromUIList(key)
# UnRegister File with activity share list
self.activity._unregisterShareFile(key)
# Attempt to remove file from system
if deleteFile:
self.activity.delete_file(key)
iter = model.iter_next(iter)
def update_progress(self, id, bytes):
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter:
if model.get_value(iter, 0) == id:
break
iter = model.iter_next(iter)
if iter:
obj = model.get_value(iter, 1)
obj.update_aquired(bytes)
# Store updated versoin of the object
self.activity.updateFileObj(id, obj)
model.set_value(iter, 1, obj)
model.row_changed(model.get_path(iter), iter)
def set_installed(self, id, sucessful=True):
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter:
if model.get_value(iter, 0) == id:
break
iter = model.iter_next(iter)
if iter:
obj = model.get_value(iter, 1)
if sucessful:
obj.set_installed()
else:
obj.set_failed()
# Store updated versoin of the object
self.activity.updateFileObj(id, obj)
model.set_value(iter, 1, obj)
model.row_changed(model.get_path(iter), iter)
def __init__(self, handle):
# self.initiating indicates whether this instance has initiated sharing
# it always starts false, but will be set to true if this activity
# initiates sharing. In particular, if Activity.__init__ calls
# self.share(), self.initiating will be set to True.
self.initiating = False
# self._processed_share indicates whether when_shared() has been called
self._processed_share = False
# self.initialized tracks whether the Activity's display is up and running
self.initialized = False
self.early_setup()
super(GroupActivity, self).__init__(handle)
self.dbus_name = self.get_bundle_id()
self.logger = logging.getLogger(self.dbus_name)
self._handle = handle
##gobject.threads_init()
self._sharing_completed = not self._shared_activity
self._readfile_completed = not handle.object_id
if self._shared_activity:
self.message = self.message_joining
elif handle.object_id:
self.message = self.message_loading
else:
self.message = self.message_preparing
# top toolbar with share and close buttons:
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
v = gtk.VBox()
self.startup_label = gtk.Label(self.message)
v.pack_start(self.startup_label)
Window.set_canvas(self,v)
self.show_all()
# The show_all method queues up draw events, but they aren't executed
# until the mainloop has a chance to process them. We want to process
# them immediately, because we need to show the waiting screen
# before the waiting starts, not after.
exhaust_event_loop()
# exhaust_event_loop() provides the possibility that write_file could
# be called at this time, so write_file is designed to trigger read_file
# itself if that path occurs.
self.tubebox = groupthink.TubeBox()
self.timer = groupthink.TimeHandler("main", self.tubebox)
self.cloud = groupthink.Group(self.tubebox)
# self.cloud is extremely important. It is the unified reference point
# that contains all state in the system. Everything else is stateless.
# self.cloud has to be defined before the call to self.set_canvas, because
# set_canvas can trigger almost anything, including pending calls to read_file,
# which relies on self.cloud.
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
if self.get_shared():
if self.initiating:
self._shared_cb(self)
else:
self._joined_cb(self)
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect("visibility-notify-event", self._visible_cb)
self.connect("notify::active", self._active_cb)
if not self._readfile_completed:
self.read_file(self._jobject.file_path)
elif not self._shared_activity:
gobject.idle_add(self._initialize_cleanstart)
class Gui(gtk.VBox):
def __init__(self, activity):
gtk.VBox.__init__(self)
self.activity = activity
mov_box = gtk.HBox()
# Add movie window
self.movie_window = gtk.DrawingArea()
self.movie_window_preview = gtk.DrawingArea()
mov_box.pack_start(self.movie_window)
mov_box.pack_start(self.movie_window_preview)
self.pack_start(mov_box)
# Add Chat section
##################
# Chat expander allows chat to be hidden/shown
chat_expander = gtk.Expander(_("Chat"))
chat_expander.set_expanded(True)
self.pack_start(chat_expander, False)
chat_holder = gtk.VBox()
chat_expander.add(chat_holder)
# Create entry and history view for chat
chat_history = gtk.ScrolledWindow()
chat_history.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.chat_text = gtk.TextBuffer()
self.text_view = gtk.TextView(self.chat_text)
self.text_view.set_editable(False)
self.text_view.set_size_request(-1, 200)
chat_history.add(self.text_view)
# Send button to complete feel of a chat program
self.chat_entry = gtk.Entry()
self.chat_entry.connect("activate", self.send_chat)
send_but = gtk.Button(_("Send"))
send_but.connect("clicked", self.send_chat)
# Wrap button and entry in hbox so they are on the same line
chat_entry_hbox = gtk.HBox()
chat_entry_hbox.pack_start(self.chat_entry)
chat_entry_hbox.pack_end(send_but, False)
# Add chat history and entry to expander
chat_holder.pack_start(chat_history)
chat_holder.pack_start(chat_entry_hbox, False)
# Show gui
self.build_toolbars()
self.show_all()
#scroll to bottom
self.text_view.scroll_to_iter(self.chat_text.get_end_iter(), 0.1)
def get_history(self):
return self.chat_text.get_text(self.chat_text.get_start_iter(),
self.chat_text.get_end_iter())
def add_chat_text(self, text):
self.chat_text.insert(self.chat_text.get_end_iter(), "%s\n" % text)
self.text_view.scroll_to_iter(self.chat_text.get_end_iter(), 0.1)
def send_chat(self, w):
if self.chat_entry.get_text != "":
self.activity.send_chat_text(self.chat_entry.get_text())
self.chat_entry.set_text("")
def build_toolbars(self):
self.settings_bar = gtk.Toolbar()
self.settings_buttons = {}
self.settings_buttons['reload_video'] = ToolButton('view-spiral')
self.settings_buttons['reload_video'].set_tooltip(_("Reload Screen"))
self.settings_buttons['reload_video'].connect("clicked",
self.force_redraw, None)
self.settings_bar.insert(self.settings_buttons['reload_video'], -1)
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Settings"), self.settings_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show_all()
def force_redraw(self, widget, value=None):
# Fixme: This should not be required, this is a hack for now until
# a better solution that works is found
self.movie_window.hide()
self.movie_window_preview.hide()
self.movie_window.show()
self.movie_window_preview.show()
def send_video_to_screen(self, source, screen):
if screen == 'MAIN':
source.set_xwindow_id(self.movie_window.window.xid)
elif screen == 'PREVIEW':
source.set_xwindow_id(self.movie_window_preview.window.xid)
def build_toolbars(self):
self.dungeon_buttons = {}
self.dungeon_bar = gtk.Toolbar()
self.view_bar = gtk.Toolbar()
# BUILD CUSTOM TOOLBAR
# Dungeon Bar
self.dungeon_buttons['new'] = ToolButton('add')
self.dungeon_buttons['new'].set_tooltip(_("New Dungeon"))
self.dungeon_buttons['new'].connect("clicked", self.view_change_cb,
'new')
self.dungeon_bar.insert(self.dungeon_buttons['new'], -1)
self.dungeon_buttons['load'] = ToolButton('fileopen')
self.dungeon_buttons['load'].set_tooltip(_("Open Dungeon"))
self.dungeon_buttons['load'].connect("clicked", self.view_change_cb,
'load')
self.dungeon_bar.insert(self.dungeon_buttons['load'], -1)
self.dungeon_buttons['save'] = ToolButton('filesave')
self.dungeon_buttons['save'].set_tooltip(
_("Export dungeon file to journal"))
self.dungeon_buttons['save'].connect("clicked", self.view_change_cb,
'export')
self.dungeon_bar.insert(self.dungeon_buttons['save'], -1)
self.dungeon_buttons['save'].set_sensitive(False)
# VIEW BAR
self.dungeon_buttons['home'] = ToolButton('go-home')
self.dungeon_buttons['home'].set_tooltip(_("Welcome Screen"))
self.dungeon_buttons['home'].connect("clicked", self.view_change_cb,
'home')
self.view_bar.insert(self.dungeon_buttons['home'], -1)
self.dungeon_buttons['settings'] = ToolButton('view-spiral')
self.dungeon_buttons['settings'].set_tooltip(
_("View Dungeon Settings"))
self.dungeon_buttons['settings'].connect("clicked",
self.view_change_cb,
'settings')
self.view_bar.insert(self.dungeon_buttons['settings'], -1)
self.dungeon_buttons['settings'].set_sensitive(False)
self.dungeon_buttons['layout'] = ToolButton('view-freeform')
self.dungeon_buttons['layout'].set_tooltip(_("View Dungeon Layout"))
self.dungeon_buttons['layout'].connect("clicked", self.view_change_cb,
'layout')
self.view_bar.insert(self.dungeon_buttons['layout'], -1)
self.dungeon_buttons['layout'].set_sensitive(False)
self.toolbox = ActivityToolbox(self)
# Remove Share Bar
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.remove(activity_toolbar.share)
activity_toolbar.share = None
#Add our custom items to the toolbar
self.toolbox.add_toolbar(_("Dungeon"), self.dungeon_bar)
self.toolbox.add_toolbar(_("View"), self.view_bar)
self.set_toolbox(self.toolbox)
self.toolbox.show()
class GuiView(gtk.ScrolledWindow):
"""
This class is used to just remove the table setup from the main file
"""
def __init__(self, activity):
gtk.ScrolledWindow.__init__(self)
self.set_policy( gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC )
self.activity = activity
self.treeview = gtk.TreeView(gtk.TreeStore(str,object))
self.guiHandler = GuiHandler( activity, self.treeview, self )
#self.build_table(activity)
def build_toolbars(self):
self.action_buttons = {}
# BUILD CUSTOM TOOLBAR
self.action_bar = gtk.Toolbar()
self.action_buttons['add'] = ToolButton('fs_gtk-add')
self.action_buttons['add'].set_tooltip(_("Add Object"))
self.action_buttons['rem'] = ToolButton('fs_gtk-remove')
self.action_buttons['rem'].set_tooltip(_("Remove Object(s)"))
self.action_buttons['save'] = ToolButton('filesave')
self.action_buttons['save'].set_tooltip( _("Copy Object(s) to Journal") )
self.action_buttons['down'] = ToolButton('epiphany-download')
self.action_buttons['down'].set_tooltip( _('Download Object(s)') )
self.action_buttons['admin'] = ToolButton('gtk-network')
self.action_buttons['admin'].set_tooltip( _('Server Permissions') )
self.action_buttons['server'] = ToolButton('gaim-link')
self.action_buttons['server'].set_tooltip( _('Connect to Server') )
self.action_buttons['server'].set_sensitive( False )
if self.activity.isServer:
self.action_buttons['add'].connect("clicked", self.guiHandler.requestAddFile, None)
self.action_buttons['save'].connect("clicked", self.guiHandler.requestInsFile, None)
self.action_buttons['rem'].connect("clicked", self.guiHandler.requestRemFile, None)
self.action_buttons['server'].connect("clicked", self.guiHandler.switch_to_server, None)
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['save'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
self.action_bar.insert(self.action_buttons['server'], -1)
# Check for server, if found activate connect link
def check_server_status():
try:
if self.activity.check_for_server():
self.action_buttons['server'].set_sensitive( True )
except ServerRequestFailure:
pass
threading.Thread(target=check_server_status).start()
else:
self.action_buttons['down'].connect("clicked", self.guiHandler.requestDownloadFile, None)
self.action_bar.insert(self.action_buttons['down'], -1)
if self.activity._mode == 'SERVER' and self.activity._user_permissions != 0:
self.action_buttons['add'].connect("clicked", self.guiHandler.requestAddFile, {'upload':True})
self.action_buttons['rem'].connect("clicked", self.guiHandler.requestRemFile, {'remove':True})
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
if self.activity._user_permissions == 2:
self.action_buttons['admin'].connect("clicked", self.guiHandler.showAdmin, None)
self.action_bar.insert(self.action_buttons['admin'], -1)
self.action_bar.show_all()
self.toolbar_set_selection( False )
# Create Toolbox
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Actions"), self.action_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show()
self.toolbox.set_current_toolbar(1)
def on_selection_changed(self, selection):
if selection.count_selected_rows() == 0:
self.toolbar_set_selection(False)
else:
self.toolbar_set_selection(True)
def toolbar_set_selection(self, selected):
require_selection = ['save', 'rem', 'down']
for key in require_selection:
if selected:
self.action_buttons[key].set_sensitive( True )
else:
self.action_buttons[key].set_sensitive( False )
def build_table(self):
# Create File Tree
##################
# Name Cell_data_Func Expand Cell Renderer
text_cells = [
[ _('Name'), FileInfo.file_name, False, gtk.CellRendererText()],
[ _('Description'), FileInfo.file_desc, True, gtk.CellRendererText()],
[ _('Tags'), FileInfo.file_tags, False, gtk.CellRendererText()],
[ _('Size'), FileInfo.file_size, False, gtk.CellRendererText()],
[ '', FileInfo.load_bar, False, gtk.CellRendererProgress()]
]
for col_data in text_cells:
cell = col_data[3]
colName = gtk.TreeViewColumn(col_data[0], cell)
colName.set_cell_data_func(cell, col_data[1])
# Should the col expand
colName.set_expand(col_data[2])
# Add to tree
self.treeview.append_column(colName)
# make it searchable by name
self.treeview.set_search_column(1)
# Allow Multiple Selections
self.treeview.get_selection().set_mode( gtk.SELECTION_MULTIPLE )
self.treeview.get_selection().connect('changed', self.on_selection_changed )
# Put table into scroll window to allow it to scroll
self.add_with_viewport(self.treeview)
def clear_files(self, deleteFile = True):
model = self.treeview.get_model()
iter = model.get_iter_root()
while iter:
key = model.get_value(iter, 0)
# Remove file from UI
self.guiHandler._remFileFromUIList(key)
# UnRegister File with activity share list
self.activity._unregisterShareFile( key )
# Attempt to remove file from system
if deleteFile:
self.activity.delete_file( key )
iter = model.iter_next(iter)
def update_progress(self, id, bytes ):
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter:
if model.get_value( iter, 0 ) == id:
break
iter = model.iter_next( iter )
if iter:
obj = model.get_value( iter, 1 )
obj.update_aquired( bytes )
# Store updated versoin of the object
self.activity.updateFileObj( id, obj )
model.set_value( iter, 1, obj)
model.row_changed(model.get_path(iter), iter)
def set_installed( self, id, sucessful=True ):
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter:
if model.get_value( iter, 0 ) == id:
break
iter = model.iter_next( iter )
if iter:
obj = model.get_value( iter, 1 )
if sucessful:
obj.set_installed()
else:
obj.set_failed()
# Store updated versoin of the object
self.activity.updateFileObj( id, obj )
model.set_value( iter, 1, obj)
model.row_changed(model.get_path(iter), iter)
class FortuneMaker(Activity):
def __init__(self, handle):
Activity.__init__(self, handle)
self.dungeon = None
self.active_room = None
self.action_but_group = None
# INITIALIZE GUI
################
self.set_title('FortuneMaker')
# Create Toolbox
self.build_toolbars()
self.enable_room_icons(False)
self.show_home()
def build_toolbars(self):
self.dungeon_buttons = {}
self.dungeon_bar = gtk.Toolbar()
self.view_bar = gtk.Toolbar()
# BUILD CUSTOM TOOLBAR
# Dungeon Bar
self.dungeon_buttons['new'] = ToolButton('add')
self.dungeon_buttons['new'].set_tooltip(_("New Dungeon"))
self.dungeon_buttons['new'].connect("clicked", self.view_change_cb,
'new')
self.dungeon_bar.insert(self.dungeon_buttons['new'], -1)
self.dungeon_buttons['load'] = ToolButton('fileopen')
self.dungeon_buttons['load'].set_tooltip(_("Open Dungeon"))
self.dungeon_buttons['load'].connect("clicked", self.view_change_cb,
'load')
self.dungeon_bar.insert(self.dungeon_buttons['load'], -1)
self.dungeon_buttons['save'] = ToolButton('filesave')
self.dungeon_buttons['save'].set_tooltip(
_("Export dungeon file to journal"))
self.dungeon_buttons['save'].connect("clicked", self.view_change_cb,
'export')
self.dungeon_bar.insert(self.dungeon_buttons['save'], -1)
self.dungeon_buttons['save'].set_sensitive(False)
# VIEW BAR
self.dungeon_buttons['home'] = ToolButton('go-home')
self.dungeon_buttons['home'].set_tooltip(_("Welcome Screen"))
self.dungeon_buttons['home'].connect("clicked", self.view_change_cb,
'home')
self.view_bar.insert(self.dungeon_buttons['home'], -1)
self.dungeon_buttons['settings'] = ToolButton('view-spiral')
self.dungeon_buttons['settings'].set_tooltip(
_("View Dungeon Settings"))
self.dungeon_buttons['settings'].connect("clicked",
self.view_change_cb,
'settings')
self.view_bar.insert(self.dungeon_buttons['settings'], -1)
self.dungeon_buttons['settings'].set_sensitive(False)
self.dungeon_buttons['layout'] = ToolButton('view-freeform')
self.dungeon_buttons['layout'].set_tooltip(_("View Dungeon Layout"))
self.dungeon_buttons['layout'].connect("clicked", self.view_change_cb,
'layout')
self.view_bar.insert(self.dungeon_buttons['layout'], -1)
self.dungeon_buttons['layout'].set_sensitive(False)
self.toolbox = ActivityToolbox(self)
# Remove Share Bar
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.remove(activity_toolbar.share)
activity_toolbar.share = None
#Add our custom items to the toolbar
self.toolbox.add_toolbar(_("Dungeon"), self.dungeon_bar)
self.toolbox.add_toolbar(_("View"), self.view_bar)
self.set_toolbox(self.toolbox)
self.toolbox.show()
def enable_room_icons(self, dn=True):
self.dungeon_buttons['settings'].set_sensitive(dn)
self.dungeon_buttons['save'].set_sensitive(dn)
self.dungeon_buttons['layout'].set_sensitive(dn)
def view_change_cb(self, widget, view=None):
if view == 'layout':
self.view_dungeon_grid()
elif view == 'export':
self.export_view()
elif view == 'new':
self.set_create_dungeon_settings()
elif view == 'load':
self.show_dungeon_selection()
elif view == 'settings':
self.show_dungeon_settings()
elif view == 'home':
self.show_home()
def show_home(self):
window_container = gtk.VBox()
label = gtk.Label(_("Welcome to Fortune Maker"))
window_container.pack_start(label, False)
# New Dungeon
button = gtk.Button()
button.set_image(Icon(icon_name="add"))
button.set_label(_("New Dungeon"))
button.set_alignment(0.0, 0.5)
button.connect('clicked', self.view_change_cb, 'new')
window_container.pack_start(button, False)
# load fileopen
button = gtk.Button()
button.set_image(Icon(icon_name="fileopen"))
button.set_label(_("Load Exported Dungeon"))
button.set_alignment(0.0, 0.5)
button.connect('clicked', self.view_change_cb, 'load')
window_container.pack_start(button, False)
#HELP EXAMPLES
label = gtk.Label(_("Dungeon Toolbar"))
label.set_alignment(0, 0.5)
window_container.pack_start(gtk.Label(" "), False)
window_container.pack_start(label, False)
row = gtk.HBox()
row.pack_start(Icon(icon_name="add"), False)
label = gtk.Label(_("Creates New Dungeon"))
label.set_alignment(0, 0.5)
row.pack_start(gtk.Label(" "), False)
row.pack_start(label)
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start(Icon(icon_name="fileopen"), False)
label = gtk.Label(_("Opens existing dungeon file"))
label.set_alignment(0, 0.5)
row.pack_start(gtk.Label(" "), False)
row.pack_start(label)
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start(Icon(icon_name="filesave"), False)
label = gtk.Label(_("Export dungeon file to journal"))
label.set_alignment(0, 0.5)
row.pack_start(gtk.Label(" "), False)
row.pack_start(label)
window_container.pack_start(row, False)
# View Bar Help
label = gtk.Label(_("View Toolbar"))
label.set_alignment(0, 0.5)
window_container.pack_start(gtk.Label(" "), False)
window_container.pack_start(label, False)
row = gtk.HBox()
row.pack_start(Icon(icon_name="go-home"), False)
label = gtk.Label(_("Display this home screen"))
label.set_alignment(0, 0.5)
row.pack_start(gtk.Label(" "), False)
row.pack_start(label)
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start(Icon(icon_name="view-spiral"), False)
label = gtk.Label(_("Shows the dungeon settings"))
label.set_alignment(0, 0.5)
row.pack_start(gtk.Label(" "), False)
row.pack_start(label)
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start(Icon(icon_name="view-freeform"), False)
label = gtk.Label(_("Shows the dungeon layout"))
label.set_alignment(0, 0.5)
row.pack_start(gtk.Label(" "), False)
row.pack_start(label)
window_container.pack_start(row, False)
window_container.pack_start(gtk.Label(" "), False)
label = gtk.Label(
_("Dungeons must be exported before they\n" +
"may be loaded into Fortune Hunter\n" +
"or linked as a next dungeon."))
window_container.pack_start(label, False)
room_center = gtk.HBox()
room_center.pack_start(gtk.Label())
room_center.pack_start(window_container)
room_center.pack_start(gtk.Label())
self.set_gui_view(room_center)
def export_view(self):
if self.dungeon.valid_dungeon():
data = self.dungeon.export()
filename = self.dungeon.name
JournalIntegration.export_textfile(self, filename, self.dungeon.id,
data)
self._alert(_("Dungeon Exported to Journal"), filename)
else:
self._alert(_("Export Failed"), _("Invalid dungeon configuration"))
def set_gui_view(self, view):
self.set_canvas(view)
self.show_all()
def show_dungeon_selection(self):
window_container = gtk.VBox()
frame = gtk.Frame(_("Load Dungeon"))
file_container = gtk.VBox()
##LOAD FILE LIST HERE
file_list = JournalIntegration.list_fh_files()
for dfile in file_list:
row = gtk.HBox()
label = gtk.Label(dfile.metadata['title'])
row.pack_start(label, False)
button = gtk.Button(_("Load"))
button.connect('clicked', self.load_dungeon, dfile)
row.pack_end(button, False)
file_container.pack_start(row, False)
frame.add(make_it_scroll(file_container))
window_container.pack_start(frame)
room_center = gtk.HBox()
room_center.pack_start(gtk.Label())
room_center.pack_start(window_container)
room_center.pack_start(gtk.Label())
self.set_gui_view(room_center)
def show_dungeon_settings(self):
window_container, name, theme, next_dungeon, file_list_map = self._get_dungeon_prop_box(
False)
save_dungeon = gtk.Button(_("Save Dungeon Settings"))
save_dungeon.connect(
"clicked", self.edit_dungeon_cb, {
'name': name,
'theme': theme,
'next_dungeon': next_dungeon,
'd_list': file_list_map
})
window_container.pack_start(save_dungeon, False)
room_center = gtk.HBox()
room_center.pack_start(gtk.Label())
room_center.pack_start(window_container)
room_center.pack_start(gtk.Label())
self.set_gui_view(room_center)
def _get_dungeon_prop_box(self, new_prop=True):
window_container = gtk.VBox()
## Dungeon Properties
###############
frame = gtk.Frame(_("Dungeon Properties"))
container = gtk.VBox()
# Name
row = gtk.HBox()
label = gtk.Label(_("Name:"))
label.set_alignment(0, 0.5)
row.pack_start(label)
name = gtk.Entry()
row.pack_end(name)
container.pack_start(row, False)
# Theme
row = gtk.HBox()
label = gtk.Label(_("Theme:"))
label.set_alignment(0, 0.5)
row.pack_start(label)
theme = gtk.combo_box_new_text()
for option in THEME_NAME:
theme.append_text(option)
theme.set_active(0)
row.pack_end(theme)
container.pack_start(row, False)
# Next Dungeon
row = gtk.HBox()
label = gtk.Label(_("Next Dungeon:"))
label.set_alignment(0, .5)
row.pack_start(label)
next_dungeon = gtk.combo_box_new_text()
file_list = JournalIntegration.list_fh_files()
file_list_map = {}
file_list_map["0"] = _("None")
next_dungeon.append_text(file_list_map["0"])
next_dungeon.set_active(0)
order_map = ["0"]
for dfile in file_list:
file_list_map[dfile.metadata['FM_UID']] = dfile.metadata['title']
next_dungeon.append_text(dfile.metadata['title'])
order_map.append(dfile.metadata['FM_UID'])
row.pack_start(next_dungeon)
container.pack_start(row, False)
frame.add(container)
window_container.pack_start(frame, False)
if not new_prop and self.dungeon:
name.set_text(self.dungeon.name)
theme.set_active(self.dungeon.theme)
next_dungeon.set_active(order_map.index(self.dungeon.next))
return (window_container, name, theme, next_dungeon, file_list_map)
def set_create_dungeon_settings(self, trash=None, trash2=None):
window_container, name, theme, next_dungeon, file_list_map = self._get_dungeon_prop_box(
True)
## Dungeon Size
###############
frame = gtk.Frame(_("Dungeon Size"))
# Width
widthADJ = gtk.Adjustment(MIN_GRID_WIDTH, MIN_GRID_WIDTH,
MAX_GRID_WIDTH, 1.0, 5.0, 0.0)
widthspin = gtk.SpinButton(widthADJ, 0, 0)
container = gtk.VBox()
row = gtk.HBox()
label = gtk.Label(_("Width:"))
label.set_alignment(0, 0.5)
row.pack_start(label)
row.pack_end(widthspin)
container.pack_start(row, False)
# Height
heightADJ = gtk.Adjustment(MIN_GRID_HEIGHT, MIN_GRID_HEIGHT,
MAX_GRID_HEIGHT, 1.0, 5.0, 0.0)
heightspin = gtk.SpinButton(heightADJ, 0, 0)
row = gtk.HBox()
label = gtk.Label(_("Height:"))
label.set_alignment(0, 0.5)
row.pack_start(label)
row.pack_end(heightspin)
container.pack_start(row, False)
frame.add(container)
window_container.pack_start(frame, False)
## Make Dungeon Button
make_dungeon = gtk.Button(_("Create Dungeon"))
make_dungeon.connect(
"clicked", self.create_dungeon_cb, {
'name': name,
'theme': theme,
'width': widthspin,
'height': heightspin,
'next_dungeon': next_dungeon,
'd_list': file_list_map
})
window_container.pack_start(make_dungeon, False)
room_center = gtk.HBox()
room_center.pack_start(gtk.Label())
room_center.pack_start(window_container)
room_center.pack_start(gtk.Label())
self.set_gui_view(room_center)
def load_dungeon(self, widget, file_data):
#try:
dungeon_dict = JournalIntegration.load_dungeon(file_data)
self.make_dungeon_from_dict(dungeon_dict)
#except:
# pass
def make_dungeon_from_dict(self, dungeon_dict):
self.dungeon = Dungeon(dungeon_dict['name'], dungeon_dict['theme'],
dungeon_dict['next'], dungeon_dict['x'],
dungeon_dict['y'], dungeon_dict['roomstr'],
dungeon_dict['d_id'])
self.enable_room_icons(True)
self.view_dungeon_grid()
def edit_dungeon_cb(self, widget, data):
self.dungeon.name = data['name'].get_text()
self.dungeon.theme = data['theme'].get_active()
self.dungeon.next = find_key(data['d_list'],
data['next_dungeon'].get_active_text())
self._alert(_("Dungeon Setting Saved"), self.dungeon.theme)
def create_dungeon_cb(self, widget, data):
name = data['name'].get_text()
theme = data['theme'].get_active() #.get_active_text()
next = find_key(data['d_list'], data['next_dungeon'].get_active_text())
width = data['width'].get_value_as_int()
height = data['height'].get_value_as_int()
self.dungeon = Dungeon(name, theme, next, width, height)
self.enable_room_icons(True)
self.view_dungeon_grid()
def _draw_room_button_grid(self):
# Setup Room Panel
room_array = self.dungeon.get_room_array()
box = gtk.VBox()
for row_array in room_array:
row = gtk.HBox()
box.pack_start(row, False)
for room in row_array:
room_gui = room.render_room()
room_gui.connect('button-press-event', self.add_prop_to_room,
room, room_gui)
row.pack_start(room_gui, False)
if self._pane2:
self.edit_pane.remove(self._pane2)
self._pane2 = make_it_scroll(box)
self._pane2.show_all()
self.edit_pane.add2(self._pane2)
def view_dungeon_grid(self):
self.edit_pane = gtk.HPaned()
self._pane2 = None
# Setup Button Panel
listbox = gtk.VBox()
lbl = gtk.RadioButton(None, _('Remove Enemy'))
lbl.track_mode = 'REM_ENEMY'
listbox.pack_start(lbl, False)
lbl = gtk.RadioButton(lbl, _('Remove Item'))
lbl.track_mode = 'REM_ITEM'
listbox.pack_start(lbl, False)
# Doors
exp = gtk.Expander(_("Doors"))
box = gtk.VBox()
doors = DOOR_FLAGS.values()
doors.sort()
for val in doors:
door_mode_key = find_key(DOOR_FLAGS, val)
lbl = gtk.RadioButton(lbl, val)
lbl.track_mode = 'DOOR'
lbl.track_flag = door_mode_key
box.pack_start(lbl, False)
exp.add(box)
listbox.pack_start(exp, False)
# Room Properties
exp = gtk.Expander(_("Room Flags"))
box = gtk.VBox()
flags = SPEC_FLAGS.values()
flags.sort()
for val in flags:
flag_key = find_key(SPEC_FLAGS, val)
lbl = gtk.RadioButton(lbl, val)
lbl.track_mode = 'SPEC_FLAG'
lbl.track_flag = flag_key
box.pack_start(lbl, False)
exp.add(box)
listbox.pack_start(exp, False)
# Enemies
exp = gtk.Expander(_("Enemies"))
box = gtk.VBox()
enemies = ENEM_INDEX.values()
enemies.sort()
for val in enemies:
enemy_key = find_key(ENEM_INDEX, val)
# Ignore None Key
if enemy_key != '0':
lbl = gtk.RadioButton(lbl, val)
lbl.track_mode = 'ENEMY'
lbl.track_flag = enemy_key
box.pack_start(lbl, False)
exp.add(box)
listbox.pack_start(exp, False)
# Items
exp = gtk.Expander(_("Items"))
box = gtk.VBox()
items = ITEM_INDEX.values()
items.sort()
for val in items:
item_key = find_key(ITEM_INDEX, val)
# Ignore None Key
if item_key != '0':
lbl = gtk.RadioButton(lbl, val)
lbl.track_mode = 'ITEM'
lbl.track_flag = item_key
box.pack_start(lbl, False)
exp.add(box)
listbox.pack_start(exp, False)
# Save the button group
self.action_but_group = lbl.get_group()
# Make Legend
legendBox = gtk.VBox()
legendBox.pack_start(gtk.Label(_("Door Legend")), False)
for door_key in DOOR_FLAGS:
if door_key != '0':
row = gtk.HBox()
colorbox = gtk.EventBox()
colorbox.add(gtk.Label(" "))
colorbox.modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse(DOOR_COLOR[door_key]))
row.pack_start(colorbox, False)
row.pack_start(gtk.Label(" "), False)
label = gtk.Label(DOOR_FLAGS[door_key])
label.set_alignment(0, 0.5)
row.pack_start(label)
legendBox.pack_start(row, False)
legendBox.pack_start(gtk.Label(_("Room Legend")), False)
for spec_key in SPEC_FLAGS:
if spec_key != '0':
row = gtk.HBox()
colorbox = gtk.EventBox()
colorbox.add(gtk.Label(" "))
colorbox.modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse(SPEC_COLOR[spec_key]))
row.pack_start(colorbox, False)
row.pack_start(gtk.Label(" "), False)
label = gtk.Label(SPEC_FLAGS[spec_key])
label.set_alignment(0, 0.5)
row.pack_start(label)
legendBox.pack_start(row, False)
split = gtk.VBox()
split.pack_start(make_it_scroll(listbox, False))
exp = gtk.Expander(_("Legend"))
exp.add(legendBox)
split.pack_end(exp, False)
self.edit_pane.add1(split)
self._draw_room_button_grid()
self.set_gui_view(self.edit_pane)
def set_active_room(self, widgit, room):
self.active_room = room
self.view_room()
def add_prop_to_room(self, widget, event, room, room_gui):
self.active_room = room
for but in self.action_but_group:
if but.get_active():
if but.track_mode == 'VIEW':
self.view_room()
return
elif but.track_mode == 'REM_ENEMY':
dialog = gtk.Dialog(_("Remove Enemy"),
buttons=(gtk.STOCK_CLOSE,
gtk.RESPONSE_CLOSE))
def rem_enm(widget, pos, row):
room.set_enemy(pos, '0')
row.hide()
display_box = False
for i in range(0, 4):
if room.enemy[i] != '0':
display_box = True
row = gtk.HBox()
label = gtk.Label(ENEM_INDEX[room.enemy[i]])
label.set_alignment(0.0, 0.5)
row.pack_start(label)
but = gtk.Button(_("Remove"))
but.connect('clicked', rem_enm, i, row)
row.pack_end(but, False)
dialog.vbox.pack_start(row, False)
if display_box:
dialog.show_all()
result = dialog.run()
else:
self._alert(_("No enemies found in this room"))
dialog.destroy()
elif but.track_mode == 'REM_ITEM':
dialog = gtk.Dialog(_("Remove Item"),
buttons=(gtk.STOCK_CLOSE,
gtk.RESPONSE_CLOSE))
def rem_enm(widget, pos, row):
room.set_item(pos, '0', '0')
row.hide()
display_box = False
for i in range(0, 4):
if room.item[i][0] != '0':
display_box = True
row = gtk.HBox()
label = gtk.Label(ITEM_INDEX[room.item[i][0]])
label.set_alignment(0.0, 0.5)
row.pack_start(label)
but = gtk.Button(_("Remove"))
but.connect('clicked', rem_enm, i, row)
row.pack_end(but, False)
dialog.vbox.pack_start(row, False)
if display_box:
dialog.show_all()
result = dialog.run()
else:
self._alert(_("No items found in this room"))
dialog.destroy()
elif but.track_mode == 'DOOR':
door_pos = room.get_door_from_click(event.x, event.y)
if not door_pos:
return
if but.track_flag == '0':
self.active_room.remove_door(door_pos)
try:
adj_room = self.dungeon.get_adj_room(
room, door_pos)
if door_pos == "N":
adj_room.remove_door("S")
elif door_pos == "E":
adj_room.remove_door("W")
elif door_pos == "S":
adj_room.remove_door("N")
elif door_pos == "W":
adj_room.remove_door("E")
adj_room._room_gui.queue_draw()
except:
pass
else:
# If not e or x, add door to adjoining room
if not (but.track_flag == 'e'
or but.track_flag == 'x'):
adj_room = self.dungeon.get_adj_room(
room, door_pos)
if adj_room:
self.active_room.add_door(
door_pos, but.track_flag)
if door_pos == "N":
adj_room.add_door("S", but.track_flag)
elif door_pos == "E":
adj_room.add_door("W", but.track_flag)
elif door_pos == "S":
adj_room.add_door("N", but.track_flag)
elif door_pos == "W":
adj_room.add_door("E", but.track_flag)
adj_room._room_gui.queue_draw()
else:
self._alert(
_("Door Not Added"),
_("This door can not be placed at edge of dungeon"
))
else:
if not self.dungeon.has_door_type(but.track_flag):
self.active_room.add_door(
door_pos, but.track_flag)
else:
self._alert(
_("Door Not Added"),
_("The dungeon can only have one %s") %
DOOR_FLAGS[but.track_flag])
elif but.track_mode == 'SPEC_FLAG':
self.active_room.set_room_flag(but.track_flag)
elif but.track_mode == 'ENEMY':
if not self.active_room.add_enemy(but.track_flag):
self._alert(_("Enemy not added to room"),
_("Room can not hold any more enemies"))
elif but.track_mode == 'ITEM':
def add_item(click, flag):
if not self.active_room.add_item(but.track_flag, flag):
self._alert(_("Item not added to room"),
_("Room can not hold any more items"))
self.dungeon.update_room(self.active_room)
room_gui.queue_draw()
menu = gtk.Menu()
for flag in ITEM_FLAGS:
if flag != '0':
opt = gtk.MenuItem(ITEM_FLAGS[flag])
opt.connect("activate", add_item, flag)
menu.append(opt)
menu.show_all()
menu.popup(None, None, None, event.button,
event.get_time())
return
self.dungeon.update_room(self.active_room)
room_gui.queue_draw()
#self._draw_room_button_grid()
break
def _alert(self, title, text=None, timeout=5):
alert = NotifyAlert(timeout=timeout)
alert.props.title = title
alert.props.msg = text
self.add_alert(alert)
alert.connect('response', self._alert_cancel_cb)
alert.show()
def _alert_cancel_cb(self, alert, response_id):
self.remove_alert(alert)
def can_close(self):
if self.metadata[
'mime_type'] == JournalIntegration.FILE_MIME and self.dungeon:
if not self.dungeon.valid_dungeon():
self._alert(
_("Dungeon Invalid"),
_("Dungeon must be valid to save to an exported dungeon"))
return False
return True
def read_file(self, file_path):
if hasattr(self, "SHUT_UP_XO_CALLING_ME"):
print "CALLED YET AGAIN! (%s)" % file_path
return
self.SHUT_UP_XO_CALLING_ME = True
dgnFile = open(file_path, 'r')
try:
dungeon_dict = JournalIntegration.do_load(dgnFile)
self.make_dungeon_from_dict(dungeon_dict)
except:
pass
dgnFile.close()
return
def write_file(self, file_path):
if self.dungeon:
f = open(file_path, 'w')
f.write(self.dungeon.export())
f.close()
else:
# Basically touch file to prevent it from keep error
open(file_path, 'w').close()
def build_toolbars(self):
self.action_buttons = {}
# BUILD CUSTOM TOOLBAR
self.action_bar = gtk.Toolbar()
self.action_buttons['add'] = ToolButton('fs_gtk-add')
self.action_buttons['add'].set_tooltip(_("Add Object"))
self.action_buttons['rem'] = ToolButton('fs_gtk-remove')
self.action_buttons['rem'].set_tooltip(_("Remove Object(s)"))
self.action_buttons['save'] = ToolButton('filesave')
self.action_buttons['save'].set_tooltip( _("Copy Object(s) to Journal") )
self.action_buttons['down'] = ToolButton('epiphany-download')
self.action_buttons['down'].set_tooltip( _('Download Object(s)') )
self.action_buttons['admin'] = ToolButton('gtk-network')
self.action_buttons['admin'].set_tooltip( _('Server Permissions') )
self.action_buttons['server'] = ToolButton('gaim-link')
self.action_buttons['server'].set_tooltip( _('Connect to Server') )
self.action_buttons['server'].set_sensitive( False )
if self.activity.isServer:
self.action_buttons['add'].connect("clicked", self.guiHandler.requestAddFile, None)
self.action_buttons['save'].connect("clicked", self.guiHandler.requestInsFile, None)
self.action_buttons['rem'].connect("clicked", self.guiHandler.requestRemFile, None)
self.action_buttons['server'].connect("clicked", self.guiHandler.switch_to_server, None)
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['save'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
self.action_bar.insert(self.action_buttons['server'], -1)
# Check for server, if found activate connect link
def check_server_status():
try:
if self.activity.check_for_server():
self.action_buttons['server'].set_sensitive( True )
except ServerRequestFailure:
pass
threading.Thread(target=check_server_status).start()
else:
self.action_buttons['down'].connect("clicked", self.guiHandler.requestDownloadFile, None)
self.action_bar.insert(self.action_buttons['down'], -1)
if self.activity._mode == 'SERVER' and self.activity._user_permissions != 0:
self.action_buttons['add'].connect("clicked", self.guiHandler.requestAddFile, {'upload':True})
self.action_buttons['rem'].connect("clicked", self.guiHandler.requestRemFile, {'remove':True})
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
if self.activity._user_permissions == 2:
self.action_buttons['admin'].connect("clicked", self.guiHandler.showAdmin, None)
self.action_bar.insert(self.action_buttons['admin'], -1)
self.action_bar.show_all()
self.toolbar_set_selection( False )
# Create Toolbox
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Actions"), self.action_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show()
self.toolbox.set_current_toolbar(1)
def __init__(self, handle):
''' Init canvas, toolbars, etc.
The toolbars are in sensor_toolbar.py and toolbar_side.py
The audio controls are in audiograb.py
The rendering happens in drawwaveform.py
Logging is in journal.py '''
activity.Activity.__init__(self, handle)
self.mode_images = {}
self.mode_images['sound'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'media-audio.svg'), 45, 45)
self.mode_images['resistance'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'resistance.svg'), 45, 45)
self.mode_images['voltage'] = gtk.gdk.pixbuf_new_from_file_at_size(
os.path.join(ICONS_DIR, 'voltage.svg'), 45, 45)
self._using_gconf = _using_gconf
self.icon_colors = self.get_icon_colors_from_sugar()
self.stroke_color, self.fill_color = self.icon_colors.split(',')
self.nick = self.get_nick_from_sugar()
self.CONTEXT = ''
self.adjustmentf = None # Freq. slider control
self.hw = _get_hardware()
self.new_recording = False
self.session_id = 0
self.read_metadata()
self._active = True
self._dsobject = None
self.connect('notify::active', self._notify_active_cb)
self.connect('destroy', self.on_quit)
self.data_logger = DataLogger(self)
self.hw = _get_hardware()
log.debug('running on %s hardware' % (self.hw))
self.wave = DrawWaveform(self)
if self.hw == XO15:
self.audiograb = AudioGrab_XO15(self.wave.new_buffer, self)
elif self.hw == XO175:
self.audiograb = AudioGrab_XO175(self.wave.new_buffer, self)
elif self.hw == XO1:
self.audiograb = AudioGrab_XO1(self.wave.new_buffer, self)
else:
self.audiograb = AudioGrab_Unknown(self.wave.new_buffer, self)
# no sharing
self.max_participants = 1
self.has_toolbarbox = _has_toolbarbox
box3 = gtk.HBox(False, 0)
box3.pack_start(self.wave, True, True, 0)
# We need event boxes in order to set the background color.
side_eventboxes = []
self.side_toolbars = []
for i in range(self.audiograb.channels):
side_eventboxes.append(gtk.EventBox())
side_eventboxes[i].modify_bg(
gtk.STATE_NORMAL, style.COLOR_TOOLBAR_GREY.get_gdk_color())
self.side_toolbars.append(SideToolbar(self, channel=i))
side_eventboxes[i].add(self.side_toolbars[i].box1)
box3.pack_start(side_eventboxes[i], False, True, 0)
event_box = gtk.EventBox()
self.text_box = gtk.Label()
self.text_box.set_justify(gtk.JUSTIFY_LEFT)
alist = pango.AttrList()
alist.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.text_box.set_attributes(alist)
event_box.add(self.text_box)
event_box.modify_bg(gtk.STATE_NORMAL,
style.COLOR_TOOLBAR_GREY.get_gdk_color())
box1 = gtk.VBox(False, 0)
box1.pack_start(box3, True, True, 0)
box1.pack_start(event_box, False, True, 0)
self.set_canvas(box1)
if self.has_toolbarbox:
toolbox = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button, 0)
activity_button.show()
else:
toolbox = ActivityToolbox(self)
# no sharing
if hasattr(toolbox, 'share'):
toolbox.share.hide()
elif hasattr(toolbox, 'props'):
toolbox.props.visible = False
self.set_toolbox(toolbox)
self.sensor_toolbar = SensorToolbar(self, self.audiograb.channels)
#Added by Butia
# Enciendo el bobot Server
log.debug('Starting Bobot-Server...')
os.system(bobot_cmd_on)
log.debug("Start : %s" % time.ctime())
time.sleep(bobot_delay_start)
log.debug("Started : %s" % time.ctime())
self.butia_toolbar = ButiaToolbar(self, self.audiograb.channels)
#Butia end
self.tuning_toolbar = TuningToolbar(self)
self.new_instrument_toolbar = InstrumentToolbar(self)
self.control_toolbar = gtk.Toolbar()
if self.has_toolbarbox:
sensor_button = ToolbarButton(label=_('Sensors'),
page=self.sensor_toolbar,
icon_name='sensor-tools')
toolbox.toolbar.insert(sensor_button, -1)
#Added by Butia
sensor_button.connect('clicked', self._sensor_toolbar_cb)
#Butia end
sensor_button.show()
#Added by Butia
butia_button = ToolbarButton(label=_('Butia'),
page=self.butia_toolbar,
icon_name='butia-tools')
toolbox.toolbar.insert(butia_button, -1)
butia_button.connect('clicked', self._butia_toolbar_cb)
butia_button.show()
#Butia end
tuning_button = ToolbarButton(
# TRANS: Tuning insruments
label=_('Tuning'),
page=self.tuning_toolbar,
icon_name='tuning-tools')
toolbox.toolbar.insert(tuning_button, -1)
tuning_button.show()
new_instrument_button = ToolbarButton(
label=_('Add instrument'),
page=self.new_instrument_toolbar,
icon_name='view-source')
toolbox.toolbar.insert(new_instrument_button, -1)
new_instrument_button.show()
else:
toolbox.add_toolbar(_('Sensors'), self.sensor_toolbar)
#Added by butia
toolbox.add_toolbar(_('Butia'), self.butia_toolbar)
#Butia end
# TRANS: Tuning insruments
toolbox.add_toolbar(_('Tuning'), self.tuning_toolbar)
toolbox.add_toolbar(_('Add instrument'),
self.new_instrument_toolbar)
toolbox.add_toolbar(_('Controls'), self.control_toolbar)
self.sensor_toolbar.show()
#Added by butia
self.butia_toolbar.show()
#Butia end
if self.has_toolbarbox:
# Set up Frequency-domain Button
self.freq = ToolButton('domain-time')
toolbox.toolbar.insert(self.freq, -1)
self.freq.show()
self.freq.set_tooltip(_('Time Base'))
self.freq.connect('clicked', self.timefreq_control)
self.sensor_toolbar.add_frequency_slider(toolbox.toolbar)
self._pause = ToolButton('media-playback-pause')
toolbox.toolbar.insert(self._pause, -1)
self._pause.set_tooltip(_('Freeze the display'))
self._pause.connect('clicked', self._pause_play_cb)
self._capture = ToolButton('image-saveoff')
toolbox.toolbar.insert(self._capture, -1)
self._capture.set_tooltip(_('Capture sample now'))
self._capture.connect('clicked', self._capture_cb)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbox.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = _('<Ctrl>Q')
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbox(toolbox)
sensor_button.set_expanded(True)
else:
# Set up Frequency-domain Button
self.freq = ToolButton('domain-time')
self.control_toolbar.insert(self.freq, -1)
self.freq.show()
self.freq.set_tooltip(_('Time Base'))
self.freq.connect('clicked', self.timefreq_control)
self.sensor_toolbar.add_frequency_slider(self.control_toolbar)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.control_toolbar.insert(separator, -1)
separator.show()
self._pause = ToolButton('media-playback-pause')
self.control_toolbar.insert(self._pause, -1)
self._pause.set_tooltip(_('Freeze the display'))
self._pause.connect('clicked', self._pause_play_cb)
self._capture = ToolButton('image-saveoff')
self.control_toolbar.insert(self._capture, -1)
self._capture.set_tooltip(_('Capture sample now'))
self._capture.connect('clicked', self._capture_cb)
toolbox.set_current_toolbar(1)
toolbox.show()
self.sensor_toolbar.update_page_size()
self.show_all()
self._first = True
# Always start in 'sound' mode.
self.sensor_toolbar.set_mode('sound')
self.sensor_toolbar.set_sound_context()
self.sensor_toolbar.set_show_hide_windows()
self.wave.set_active(True)
self.wave.set_context_on()
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating MathGraph32')
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.ceibaljam_icon_path = os.getenv("SUGAR_BUNDLE_PATH") + "/images/ceibaljam.png"
self.java_path = self.get_java_path()
#
# There's a good explanation of the use of boxes in PyGTK here:
# http://www.pygtk.org/pygtk2tutorial/sec-DetailsOfBoxes.html
#
box_canvas = gtk.VBox(False, 0)
self.set_canvas(box_canvas)
# Title
box_title = gtk.VBox(False, 0)
label_title = gtk.Label(_("MathGraph32"))
label_title.set_justify(gtk.JUSTIFY_CENTER)
label_title.modify_font(pango.FontDescription("Arial 22"))
box_title.add(gtk.Label("\n\n"))
box_title.add(label_title)
box_title.add(gtk.Label("\n"))
# Author
box_author = gtk.VBox(False, 0)
#box_author.add(gtk.Label(""))
box_author.add(gtk.Label(_("Created by Yves Biton")))
label_author_url = gtk.Label('<b>http://www.mathgraph32.org</b>')
label_author_url.set_use_markup(True)
box_author.add(label_author_url)
# Credits
box_credits = gtk.VBox(False, 0)
box_credits.add(gtk.Label(""))
box_credits.add(gtk.Label(_('Spanish translation and pedagogical evaluation by %(TEACHER)s') % { 'TEACHER': 'Luis Belcredi' }))
label_teacher_email= gtk.Label('<b>http://xsubcero.50webs.biz</b>')
label_teacher_email.set_use_markup(True)
box_credits.add(label_teacher_email)
box_credits.add(gtk.Label(""))
box_credits.add(gtk.Label(_('Sugarized by %(SUGARIZER)s') % { 'SUGARIZER': 'Marcos Orfila' }))
label_sugarizer_website = gtk.Label('<b>http://www.marcosorfila.com</b>')
label_sugarizer_website.set_use_markup(True)
box_credits.add(label_sugarizer_website)
box_credits.add(gtk.Label(""))
# Footer box (Activities on CeibalJAM! website)
box_footer = gtk.VBox(False, 0)
box_footer.add(gtk.Label(""))
box_footer.add(gtk.Label(_('Find more activities on %(CEIBALJAM)s website:') % { 'CEIBALJAM': 'CeibalJAM!'}))
label_ceibaljam_website = gtk.Label('<b>http://activities.ceibaljam.org</b>')
label_ceibaljam_website.set_use_markup(True)
box_footer.add(label_ceibaljam_website)
box_footer.add(gtk.Label(""))
# CeibalJAM! image
box_ceibaljam_image = gtk.VBox(False, 0)
image_ceibaljam = gtk.Image()
image_ceibaljam.set_from_file(self.ceibaljam_icon_path)
box_ceibaljam_image.pack_end(image_ceibaljam, False, False, 0)
# Get all the boxes together
box_canvas.pack_start(box_title, False, False, 0)
box_canvas.pack_start(box_author, False, False, 0)
box_canvas.pack_start(gtk.Label("\n"), False, False, 0)
if self.java_path == "":
box_java_not_found = gtk.VBox(False, 0)
label_java_not_found = gtk.Label('<span foreground="red"><b>' + _("Java was not found!") + '</b></span>')
label_java_not_found.set_justify(gtk.JUSTIFY_CENTER)
label_java_not_found.set_use_markup(True)
label_java_not_found.modify_font(pango.FontDescription("Arial 20"))
box_java_not_found.add(label_java_not_found)
box_java_not_found.add(gtk.Label(_('You can download the Java activity from %(CEIBALJAM)s website (see below)') % { 'CEIBALJAM': 'CeibalJAM!'}))
box_canvas.pack_start(box_java_not_found, False, False, 0)
box_canvas.pack_start(gtk.Label(""), False, False, 0)
else:
box_java_found = gtk.VBox(False, 0)
label_version_info_title = gtk.Label('<b>' + _("Java version found:") + '</b>')
label_version_info_title.set_use_markup(True)
version_information = commands.getoutput(self.java_path + " -version")
label_version_info = gtk.Label(version_information)
label_version_info.set_justify(gtk.JUSTIFY_CENTER)
box_java_found.add(label_version_info_title)
box_java_found.add(label_version_info)
box_canvas.pack_start(box_java_found, False, False, 0)
box_canvas.pack_end(gtk.Label("\n"), False, False, 0)
self.add_buttons(box_canvas)
box_canvas.pack_end(box_footer, False, False, 0)
box_canvas.pack_end(box_ceibaljam_image, False, False, 0)
box_canvas.pack_end(box_credits, False, False, 0)
if self.java_path != '':
self.button_play.grab_focus()
else:
self.button_exit.grab_focus()
self.show_all()
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating Tuxmath')
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.ceibaljam_icon_path = os.getenv(
"SUGAR_BUNDLE_PATH") + "/images/ceibaljam.png"
#
# There's a good explanation of the use of boxes in PyGTK here:
# http://www.pygtk.org/pygtk2tutorial/sec-DetailsOfBoxes.html
#
box_canvas = gtk.VBox(False, 0)
self.set_canvas(box_canvas)
# Title
box_title = gtk.VBox(False, 0)
label_title = gtk.Label(_("Tuxmath"))
label_title.set_justify(gtk.JUSTIFY_CENTER)
label_title.modify_font(pango.FontDescription("Arial 22"))
box_title.add(gtk.Label("\n\n\n"))
box_title.add(label_title)
box_title.add(gtk.Label("\n"))
# Author
box_author = gtk.VBox(False, 0)
box_author.add(gtk.Label(""))
box_author.add(gtk.Label(_("Created by Tux4kids")))
label_author_url = gtk.Label(
'<b>http://tux4kids.alioth.debian.org</b>')
label_author_url.set_use_markup(True)
box_author.add(label_author_url)
# Options box
box_options = gtk.VBox(False, 0)
label_options = gtk.Label(_("Options:"))
label_options.set_justify(gtk.JUSTIFY_LEFT)
self.checkbtn_sound = gtk.CheckButton(label=_("No sound"))
self.checkbtn_sound.set_active(True)
self.checkbtn_negatives = gtk.CheckButton(
label=_("Include negative numbers"))
self.checkbtn_negatives.set_active(False)
# Pack the checkboxes in HBoxes to center them
hbox1 = gtk.HBox(False, 0)
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(self.checkbtn_sound)
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
hbox1.add(gtk.Label(""))
box_options.add(hbox1)
#box_options.add(gtk.Label(""))
#box_options.add(label_options)
#box_options.add(self.checkbtn_sound)
#box_options.add(self.checkbtn_negatives)
# Credits
box_credits = gtk.VBox(False, 0)
box_credits.add(gtk.Label(""))
box_credits.add(
gtk.Label(
_('Spanish translation and pedagogical evaluation by %(TEACHER)s'
) % {'TEACHER': 'Ana Cichero'}))
label_teacher_email = gtk.Label('<b>[email protected]</b>')
label_teacher_email.set_use_markup(True)
box_credits.add(label_teacher_email)
box_credits.add(
gtk.Label(
_('Sugarized by %(SUGARIZER)s') %
{'SUGARIZER': 'Marcos Orfila'}))
label_sugarizer_website = gtk.Label(
'<b>http://www.marcosorfila.com</b>')
label_sugarizer_website.set_use_markup(True)
box_credits.add(label_sugarizer_website)
box_credits.add(gtk.Label(""))
# Footer box (Activities on CeibalJAM! website)
box_footer = gtk.VBox(False, 0)
box_footer.add(gtk.Label(""))
box_footer.add(
gtk.Label(
_('Find more activities on %(CEIBALJAM)s website:') %
{'CEIBALJAM': 'CeibalJAM!'}))
label_ceibaljam_website = gtk.Label(
'<b>http://activities.ceibaljam.org</b>')
label_ceibaljam_website.set_use_markup(True)
box_footer.add(label_ceibaljam_website)
box_footer.add(gtk.Label(""))
# CeibalJAM! image
box_ceibaljam_image = gtk.VBox(False, 0)
image_ceibaljam = gtk.Image()
image_ceibaljam.set_from_file(self.ceibaljam_icon_path)
box_ceibaljam_image.pack_end(image_ceibaljam, False, False, 0)
# Buttons box
box_buttons = gtk.HBox(False, 0)
self.button_play = gtk.Button(_("Play"))
self.button_play.connect("clicked", self._button_play_clicked_cb)
self.button_exit = gtk.Button(_("Exit"))
self.button_exit.connect("clicked", self._button_exit_clicked_cb)
box_buttons.add(gtk.VBox())
box_buttons.add(self.button_play)
box_buttons.add(gtk.VBox())
box_buttons.add(self.button_exit)
box_buttons.add(gtk.VBox())
# Get all the boxes together
box_canvas.pack_start(box_title, False, False, 0)
box_canvas.pack_start(box_options, False, False, 0)
box_canvas.pack_end(gtk.Label("\n\n"), False, False, 0)
box_canvas.pack_end(box_buttons, False, False, 0)
box_canvas.pack_end(gtk.Label("\n"), False, False, 0)
box_canvas.pack_end(box_footer, False, False, 0)
box_canvas.pack_end(box_ceibaljam_image, False, False, 0)
box_canvas.pack_end(box_credits, False, False, 0)
box_canvas.pack_end(box_author, False, False, 0)
self.button_play.grab_focus()
self.show_all()
class FortuneMaker(Activity):
def __init__(self, handle):
Activity.__init__(self, handle)
self.dungeon = None
self.active_room = None
self.action_but_group = None
# INITIALIZE GUI
################
self.set_title('FortuneMaker')
# Create Toolbox
self.build_toolbars()
self.enable_room_icons(False)
self.show_home()
def build_toolbars(self):
self.dungeon_buttons = {}
self.dungeon_bar = gtk.Toolbar()
self.view_bar = gtk.Toolbar()
# BUILD CUSTOM TOOLBAR
# Dungeon Bar
self.dungeon_buttons['new'] = ToolButton('add')
self.dungeon_buttons['new'].set_tooltip(_("New Dungeon"))
self.dungeon_buttons['new'].connect("clicked", self.view_change_cb, 'new')
self.dungeon_bar.insert(self.dungeon_buttons['new'], -1)
self.dungeon_buttons['load'] = ToolButton('fileopen')
self.dungeon_buttons['load'].set_tooltip(_("Open Dungeon"))
self.dungeon_buttons['load'].connect("clicked", self.view_change_cb, 'load')
self.dungeon_bar.insert(self.dungeon_buttons['load'], -1)
self.dungeon_buttons['save'] = ToolButton('filesave')
self.dungeon_buttons['save'].set_tooltip( _("Export dungeon file to journal") )
self.dungeon_buttons['save'].connect("clicked", self.view_change_cb, 'export')
self.dungeon_bar.insert(self.dungeon_buttons['save'], -1)
self.dungeon_buttons['save'].set_sensitive( False )
# VIEW BAR
self.dungeon_buttons['home'] = ToolButton('go-home')
self.dungeon_buttons['home'].set_tooltip(_("Welcome Screen"))
self.dungeon_buttons['home'].connect("clicked", self.view_change_cb, 'home')
self.view_bar.insert(self.dungeon_buttons['home'], -1)
self.dungeon_buttons['settings'] = ToolButton('view-spiral')
self.dungeon_buttons['settings'].set_tooltip(_("View Dungeon Settings"))
self.dungeon_buttons['settings'].connect("clicked", self.view_change_cb, 'settings')
self.view_bar.insert(self.dungeon_buttons['settings'], -1)
self.dungeon_buttons['settings'].set_sensitive( False )
self.dungeon_buttons['layout'] = ToolButton('view-freeform')
self.dungeon_buttons['layout'].set_tooltip(_("View Dungeon Layout"))
self.dungeon_buttons['layout'].connect("clicked", self.view_change_cb, 'layout')
self.view_bar.insert(self.dungeon_buttons['layout'], -1)
self.dungeon_buttons['layout'].set_sensitive( False )
self.toolbox = ActivityToolbox(self)
# Remove Share Bar
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.remove(activity_toolbar.share)
activity_toolbar.share = None
#Add our custom items to the toolbar
self.toolbox.add_toolbar(_("Dungeon"), self.dungeon_bar)
self.toolbox.add_toolbar(_("View"), self.view_bar)
self.set_toolbox(self.toolbox)
self.toolbox.show()
def enable_room_icons(self, dn=True):
self.dungeon_buttons['settings'].set_sensitive( dn )
self.dungeon_buttons['save'].set_sensitive( dn )
self.dungeon_buttons['layout'].set_sensitive( dn )
def view_change_cb(self, widget, view=None):
if view == 'layout':
self.view_dungeon_grid()
elif view == 'export':
self.export_view()
elif view == 'new':
self.set_create_dungeon_settings()
elif view == 'load':
self.show_dungeon_selection()
elif view == 'settings':
self.show_dungeon_settings()
elif view == 'home':
self.show_home()
def show_home(self):
window_container = gtk.VBox()
label = gtk.Label(_("Welcome to Fortune Maker"))
window_container.pack_start(label, False)
# New Dungeon
button = gtk.Button()
button.set_image( Icon( icon_name="add" ) )
button.set_label( _("New Dungeon") )
button.set_alignment(0.0,0.5)
button.connect( 'clicked', self.view_change_cb, 'new')
window_container.pack_start(button, False)
# load fileopen
button = gtk.Button()
button.set_image( Icon( icon_name="fileopen" ) )
button.set_label( _("Load Exported Dungeon") )
button.set_alignment(0.0,0.5)
button.connect( 'clicked', self.view_change_cb, 'load')
window_container.pack_start(button, False)
#HELP EXAMPLES
label = gtk.Label(_("Dungeon Toolbar") )
label.set_alignment( 0, 0.5 )
window_container.pack_start(gtk.Label(" "), False)
window_container.pack_start(label, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="add" ), False )
label = gtk.Label( _("Creates New Dungeon") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="fileopen" ), False )
label = gtk.Label( _("Opens existing dungeon file") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="filesave" ), False )
label = gtk.Label( _("Export dungeon file to journal") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
# View Bar Help
label = gtk.Label(_("View Toolbar") )
label.set_alignment( 0, 0.5 )
window_container.pack_start(gtk.Label(" "), False)
window_container.pack_start(label, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="go-home" ), False )
label = gtk.Label( _("Display this home screen") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="view-spiral" ), False )
label = gtk.Label( _("Shows the dungeon settings") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="view-freeform" ), False )
label = gtk.Label( _("Shows the dungeon layout") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
window_container.pack_start( gtk.Label(" "), False )
label = gtk.Label(_("Dungeons must be exported before they\n" +
"may be loaded into Fortune Hunter\n" +
"or linked as a next dungeon."))
window_container.pack_start( label, False)
room_center = gtk.HBox()
room_center.pack_start( gtk.Label() )
room_center.pack_start( window_container )
room_center.pack_start( gtk.Label() )
self.set_gui_view( room_center )
def export_view(self):
if self.dungeon.valid_dungeon():
data = self.dungeon.export()
filename = self.dungeon.name
JournalIntegration.export_textfile( self, filename, self.dungeon.id, data )
self._alert( _( "Dungeon Exported to Journal"), filename )
else:
self._alert( _( "Export Failed"), _("Invalid dungeon configuration") )
def set_gui_view(self, view):
self.set_canvas( view )
self.show_all()
def show_dungeon_selection(self):
window_container = gtk.VBox()
frame = gtk.Frame( _("Load Dungeon") )
file_container = gtk.VBox()
##LOAD FILE LIST HERE
file_list = JournalIntegration.list_fh_files()
for dfile in file_list:
row = gtk.HBox()
label = gtk.Label(dfile.metadata['title'])
row.pack_start( label, False )
button = gtk.Button(_("Load"))
button.connect( 'clicked', self.load_dungeon, dfile )
row.pack_end(button, False)
file_container.pack_start( row, False )
frame.add( make_it_scroll( file_container ) )
window_container.pack_start( frame )
room_center = gtk.HBox()
room_center.pack_start( gtk.Label() )
room_center.pack_start( window_container )
room_center.pack_start( gtk.Label() )
self.set_gui_view( room_center )
def show_dungeon_settings(self):
window_container, name, theme, next_dungeon, file_list_map = self._get_dungeon_prop_box(False)
save_dungeon = gtk.Button(_("Save Dungeon Settings"))
save_dungeon.connect("clicked", self.edit_dungeon_cb, {'name':name,
'theme':theme, 'next_dungeon':next_dungeon,
'd_list':file_list_map})
window_container.pack_start( save_dungeon, False )
room_center = gtk.HBox()
room_center.pack_start( gtk.Label() )
room_center.pack_start( window_container )
room_center.pack_start( gtk.Label() )
self.set_gui_view( room_center )
def _get_dungeon_prop_box(self, new_prop=True):
window_container = gtk.VBox()
## Dungeon Properties
###############
frame = gtk.Frame(_("Dungeon Properties"))
container = gtk.VBox()
# Name
row = gtk.HBox()
label = gtk.Label(_("Name:"))
label.set_alignment( 0, 0.5)
row.pack_start( label )
name = gtk.Entry()
row.pack_end( name )
container.pack_start( row, False )
# Theme
row = gtk.HBox()
label = gtk.Label(_("Theme:"))
label.set_alignment( 0, 0.5)
row.pack_start( label )
theme = gtk.combo_box_new_text()
for option in THEME_NAME:
theme.append_text( option )
theme.set_active( 0 )
row.pack_end( theme )
container.pack_start( row, False )
# Next Dungeon
row = gtk.HBox()
label = gtk.Label(_("Next Dungeon:"))
label.set_alignment( 0, .5)
row.pack_start( label )
next_dungeon = gtk.combo_box_new_text()
file_list = JournalIntegration.list_fh_files()
file_list_map = {}
file_list_map["0"] = _("None")
next_dungeon.append_text( file_list_map["0"] )
next_dungeon.set_active(0)
order_map = ["0"]
for dfile in file_list:
file_list_map[dfile.metadata['FM_UID']] = dfile.metadata['title']
next_dungeon.append_text( dfile.metadata['title'] )
order_map.append( dfile.metadata['FM_UID'] )
row.pack_start(next_dungeon)
container.pack_start( row, False )
frame.add( container )
window_container.pack_start( frame, False )
if not new_prop and self.dungeon:
name.set_text( self.dungeon.name )
theme.set_active( self.dungeon.theme )
next_dungeon.set_active( order_map.index( self.dungeon.next ) )
return (window_container, name, theme, next_dungeon, file_list_map)
def set_create_dungeon_settings(self, trash=None, trash2=None):
window_container, name, theme, next_dungeon, file_list_map = self._get_dungeon_prop_box(True)
## Dungeon Size
###############
frame = gtk.Frame(_("Dungeon Size"))
# Width
widthADJ = gtk.Adjustment(MIN_GRID_WIDTH, MIN_GRID_WIDTH, MAX_GRID_WIDTH, 1.0, 5.0, 0.0)
widthspin = gtk.SpinButton(widthADJ, 0, 0)
container = gtk.VBox()
row = gtk.HBox()
label = gtk.Label(_("Width:") )
label.set_alignment( 0, 0.5)
row.pack_start( label)
row.pack_end( widthspin )
container.pack_start( row, False )
# Height
heightADJ = gtk.Adjustment(MIN_GRID_HEIGHT, MIN_GRID_HEIGHT, MAX_GRID_HEIGHT, 1.0, 5.0, 0.0)
heightspin = gtk.SpinButton(heightADJ, 0, 0)
row = gtk.HBox()
label = gtk.Label(_("Height:") )
label.set_alignment( 0, 0.5)
row.pack_start( label )
row.pack_end( heightspin )
container.pack_start( row, False )
frame.add( container )
window_container.pack_start( frame, False )
## Make Dungeon Button
make_dungeon = gtk.Button(_("Create Dungeon"))
make_dungeon.connect("clicked", self.create_dungeon_cb, {'name':name,
'theme':theme,'width':widthspin, 'height':heightspin,
'next_dungeon':next_dungeon, 'd_list':file_list_map})
window_container.pack_start( make_dungeon, False )
room_center = gtk.HBox()
room_center.pack_start( gtk.Label() )
room_center.pack_start( window_container )
room_center.pack_start( gtk.Label() )
self.set_gui_view( room_center )
def load_dungeon(self, widget, file_data):
#try:
dungeon_dict = JournalIntegration.load_dungeon( file_data )
self.make_dungeon_from_dict( dungeon_dict )
#except:
# pass
def make_dungeon_from_dict(self, dungeon_dict):
self.dungeon = Dungeon( dungeon_dict['name'], dungeon_dict['theme'],
dungeon_dict['next'], dungeon_dict['x'],
dungeon_dict['y'], dungeon_dict['roomstr'],
dungeon_dict['d_id'])
self.enable_room_icons(True)
self.view_dungeon_grid()
def edit_dungeon_cb(self, widget, data):
self.dungeon.name = data['name'].get_text()
self.dungeon.theme = data['theme'].get_active()
self.dungeon.next = find_key( data['d_list'], data['next_dungeon'].get_active_text())
self._alert(_("Dungeon Setting Saved"), self.dungeon.theme)
def create_dungeon_cb(self, widget, data):
name = data['name'].get_text()
theme = data['theme'].get_active() #.get_active_text()
next = find_key( data['d_list'], data['next_dungeon'].get_active_text())
width = data['width'].get_value_as_int()
height = data['height'].get_value_as_int()
self.dungeon = Dungeon( name, theme, next, width, height )
self.enable_room_icons(True)
self.view_dungeon_grid()
def _draw_room_button_grid(self):
# Setup Room Panel
room_array = self.dungeon.get_room_array()
box = gtk.VBox()
for row_array in room_array:
row = gtk.HBox()
box.pack_start( row, False )
for room in row_array:
room_gui = room.render_room()
room_gui.connect('button-press-event', self.add_prop_to_room, room, room_gui)
row.pack_start( room_gui, False )
if self._pane2:
self.edit_pane.remove( self._pane2 )
self._pane2 = make_it_scroll( box )
self._pane2.show_all()
self.edit_pane.add2( self._pane2 )
def view_dungeon_grid(self):
self.edit_pane = gtk.HPaned()
self._pane2 = None
# Setup Button Panel
listbox = gtk.VBox()
lbl = gtk.RadioButton(None,_('Remove Enemy'))
lbl.track_mode = 'REM_ENEMY'
listbox.pack_start( lbl, False )
lbl = gtk.RadioButton(lbl,_('Remove Item'))
lbl.track_mode = 'REM_ITEM'
listbox.pack_start( lbl, False )
# Doors
exp = gtk.Expander(_("Doors"))
box = gtk.VBox()
doors = DOOR_FLAGS.values()
doors.sort()
for val in doors:
door_mode_key = find_key( DOOR_FLAGS, val )
lbl = gtk.RadioButton(lbl,val)
lbl.track_mode = 'DOOR'
lbl.track_flag = door_mode_key
box.pack_start(lbl, False)
exp.add( box )
listbox.pack_start( exp, False )
# Room Properties
exp = gtk.Expander(_("Room Flags"))
box = gtk.VBox()
flags = SPEC_FLAGS.values()
flags.sort()
for val in flags:
flag_key = find_key( SPEC_FLAGS, val )
lbl = gtk.RadioButton(lbl, val)
lbl.track_mode = 'SPEC_FLAG'
lbl.track_flag = flag_key
box.pack_start(lbl, False)
exp.add( box )
listbox.pack_start( exp, False )
# Enemies
exp = gtk.Expander(_("Enemies"))
box = gtk.VBox()
enemies = ENEM_INDEX.values()
enemies.sort()
for val in enemies:
enemy_key = find_key( ENEM_INDEX, val )
# Ignore None Key
if enemy_key != '0':
lbl = gtk.RadioButton(lbl, val)
lbl.track_mode = 'ENEMY'
lbl.track_flag = enemy_key
box.pack_start(lbl, False)
exp.add( box )
listbox.pack_start( exp, False )
# Items
exp = gtk.Expander(_("Items"))
box = gtk.VBox()
items = ITEM_INDEX.values()
items.sort()
for val in items:
item_key = find_key( ITEM_INDEX, val )
# Ignore None Key
if item_key != '0':
lbl = gtk.RadioButton(lbl,val)
lbl.track_mode = 'ITEM'
lbl.track_flag = item_key
box.pack_start(lbl, False)
exp.add(box)
listbox.pack_start( exp, False )
# Save the button group
self.action_but_group = lbl.get_group()
# Make Legend
legendBox = gtk.VBox()
legendBox.pack_start(gtk.Label(_("Door Legend")),False)
for door_key in DOOR_FLAGS:
if door_key != '0':
row = gtk.HBox()
colorbox = gtk.EventBox()
colorbox.add( gtk.Label(" ") )
colorbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(DOOR_COLOR[door_key]))
row.pack_start(colorbox, False)
row.pack_start( gtk.Label(" "), False )
label = gtk.Label(DOOR_FLAGS[door_key])
label.set_alignment( 0, 0.5 )
row.pack_start( label )
legendBox.pack_start(row, False)
legendBox.pack_start(gtk.Label(_("Room Legend")),False)
for spec_key in SPEC_FLAGS:
if spec_key != '0':
row = gtk.HBox()
colorbox = gtk.EventBox()
colorbox.add( gtk.Label(" ") )
colorbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(SPEC_COLOR[spec_key]))
row.pack_start(colorbox, False)
row.pack_start( gtk.Label(" "), False )
label = gtk.Label(SPEC_FLAGS[spec_key])
label.set_alignment( 0, 0.5 )
row.pack_start( label )
legendBox.pack_start(row, False)
split = gtk.VBox()
split.pack_start( make_it_scroll( listbox, False ) )
exp = gtk.Expander(_("Legend"))
exp.add(legendBox)
split.pack_end( exp, False )
self.edit_pane.add1( split )
self._draw_room_button_grid()
self.set_gui_view( self.edit_pane )
def set_active_room(self, widgit, room):
self.active_room = room
self.view_room()
def add_prop_to_room(self, widget, event, room, room_gui):
self.active_room = room
for but in self.action_but_group:
if but.get_active():
if but.track_mode == 'VIEW':
self.view_room()
return
elif but.track_mode == 'REM_ENEMY':
dialog = gtk.Dialog(_("Remove Enemy"), buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
def rem_enm(widget, pos, row):
room.set_enemy( pos, '0')
row.hide()
display_box = False
for i in range(0,4):
if room.enemy[i] != '0':
display_box = True
row = gtk.HBox()
label = gtk.Label( ENEM_INDEX[room.enemy[i]] )
label.set_alignment(0.0,0.5)
row.pack_start(label)
but = gtk.Button(_("Remove"))
but.connect('clicked', rem_enm, i, row)
row.pack_end(but, False)
dialog.vbox.pack_start(row, False)
if display_box:
dialog.show_all()
result = dialog.run()
else:
self._alert(_("No enemies found in this room"))
dialog.destroy()
elif but.track_mode == 'REM_ITEM':
dialog = gtk.Dialog(_("Remove Item"), buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
def rem_enm(widget, pos, row):
room.set_item( pos, '0', '0')
row.hide()
display_box = False
for i in range(0,4):
if room.item[i][0] != '0':
display_box = True
row = gtk.HBox()
label = gtk.Label( ITEM_INDEX[room.item[i][0]] )
label.set_alignment(0.0,0.5)
row.pack_start(label)
but = gtk.Button(_("Remove"))
but.connect('clicked', rem_enm, i, row)
row.pack_end(but, False)
dialog.vbox.pack_start(row, False)
if display_box:
dialog.show_all()
result = dialog.run()
else:
self._alert(_("No items found in this room"))
dialog.destroy()
elif but.track_mode == 'DOOR':
door_pos = room.get_door_from_click( event.x, event.y )
if not door_pos:
return
if but.track_flag == '0':
self.active_room.remove_door( door_pos )
try:
adj_room = self.dungeon.get_adj_room( room, door_pos )
if door_pos == "N":
adj_room.remove_door( "S" )
elif door_pos == "E":
adj_room.remove_door( "W" )
elif door_pos == "S":
adj_room.remove_door( "N" )
elif door_pos == "W":
adj_room.remove_door( "E" )
adj_room._room_gui.queue_draw()
except:
pass
else:
# If not e or x, add door to adjoining room
if not (but.track_flag == 'e' or but.track_flag == 'x'):
adj_room = self.dungeon.get_adj_room( room, door_pos )
if adj_room:
self.active_room.add_door( door_pos, but.track_flag )
if door_pos == "N":
adj_room.add_door( "S", but.track_flag)
elif door_pos == "E":
adj_room.add_door( "W", but.track_flag)
elif door_pos == "S":
adj_room.add_door( "N", but.track_flag)
elif door_pos == "W":
adj_room.add_door( "E", but.track_flag)
adj_room._room_gui.queue_draw()
else:
self._alert( _("Door Not Added"), _("This door can not be placed at edge of dungeon"))
else:
if not self.dungeon.has_door_type( but.track_flag ):
self.active_room.add_door( door_pos, but.track_flag )
else:
self._alert( _("Door Not Added"), _("The dungeon can only have one %s") % DOOR_FLAGS[but.track_flag] )
elif but.track_mode == 'SPEC_FLAG':
self.active_room.set_room_flag( but.track_flag )
elif but.track_mode == 'ENEMY':
if not self.active_room.add_enemy( but.track_flag ):
self._alert( _("Enemy not added to room"), _("Room can not hold any more enemies"))
elif but.track_mode == 'ITEM':
def add_item(click, flag):
if not self.active_room.add_item( but.track_flag, flag ):
self._alert( _("Item not added to room"), _("Room can not hold any more items"))
self.dungeon.update_room( self.active_room )
room_gui.queue_draw()
menu = gtk.Menu()
for flag in ITEM_FLAGS:
if flag != '0':
opt = gtk.MenuItem(ITEM_FLAGS[flag])
opt.connect("activate", add_item, flag)
menu.append(opt)
menu.show_all()
menu.popup(None, None, None, event.button, event.get_time())
return
self.dungeon.update_room( self.active_room )
room_gui.queue_draw()
#self._draw_room_button_grid()
break
def _alert(self, title, text=None, timeout=5):
alert = NotifyAlert(timeout=timeout)
alert.props.title = title
alert.props.msg = text
self.add_alert(alert)
alert.connect('response', self._alert_cancel_cb)
alert.show()
def _alert_cancel_cb(self, alert, response_id):
self.remove_alert(alert)
def can_close( self ):
if self.metadata['mime_type'] == JournalIntegration.FILE_MIME and self.dungeon:
if not self.dungeon.valid_dungeon():
self._alert(_("Dungeon Invalid"),_("Dungeon must be valid to save to an exported dungeon"))
return False
return True
def read_file(self, file_path):
if hasattr(self, "SHUT_UP_XO_CALLING_ME"):
print "CALLED YET AGAIN! (%s)"%file_path
return
self.SHUT_UP_XO_CALLING_ME = True
dgnFile=open(file_path,'r')
try:
dungeon_dict = JournalIntegration.do_load( dgnFile )
self.make_dungeon_from_dict( dungeon_dict )
except:
pass
dgnFile.close()
return
def write_file(self, file_path):
if self.dungeon:
f = open( file_path, 'w' )
f.write( self.dungeon.export() )
f.close()
else:
# Basically touch file to prevent it from keep error
open( file_path, 'w' ).close()
def __init__(self, handle):
self.game_init = False # Tells if game engine was initialized
self.loaded_game = None
Activity.__init__(self, handle)
# Creates the activiy box for toolbars
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
# Retrieves the Activity standard toolbar
self.activity_toolbar = self.toolbox.get_activity_toolbar()
# Creates other toolbars
# Game toolbar gets created on demand
# Library toolbar gets created on demand
self.guides_toolbar = gtk.Toolbar()
self.credits_toolbar = gtk.Toolbar()
self.indexes = ["activity"] # right now only activity toolbar
# Create startup windows
self.startup_window = startup_window.StartupWindow(self._start_cb, self._load_last_cb)
# Create the canvas to embbed pygame
self.pygame_canvas = PygameCanvas(self, False)
# Create Health Library Window
self.health_library = content_window.ContentWindow()
# Create Guides Window
self.guides = guides_window.GuidesWindow()
# Create Credits Window
self.credits = credits.Credits()
self.startup_window.show()
self.pygame_canvas.show()
self.health_library.show()
self.guides.show()
self.credits.show()
self.items = gtk.Notebook()
self.items.set_show_tabs(False)
self.items.set_show_border(False)
self.items.append_page(self.startup_window)
self.items.append_page(self.pygame_canvas)
self.items.append_page(self.health_library)
self.items.append_page(self.guides)
self.items.append_page(self.credits)
self.items.show()
self.set_canvas(self.items)
logging.debug("Create main")
self.game = game.Main()
self.game.set_game_over_callback(self.game_over_callback)
self.toolbox.connect('current-toolbar-changed', self.change_mode)
self.make_toolbox(False)
self.toolbox.set_current_toolbar(0) # Start in activity tab
# force the toolbar change
self.change_mode(None, self.toolbox.get_current_toolbar())
game.set_library_function = self.set_library # Sets the callback to put links in the library
self.show()
def __init__(self, handle):
# Initialize the parent
Activity.__init__(self, handle)
logger.debug('Initiating PlayGo')
self.size = DEFAULT_SIZE
self.komi = DEFAULT_KOMI
# Set the activity toolbox
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
self.gameToolbar = GameToolbar(self)
toolbox.add_toolbar(_('Game'), self.gameToolbar)
self.gameToolbar.connect('game-restart', self.restart_game)
self.gameToolbar.connect('game-board-size', self.board_size_change)
self.gameToolbar.connect('ai-activated', self.ai_activated_cb)
self.gameToolbar.connect('ai-deactivated', self.ai_deactivated_cb)
self.gameToolbar.show()
# Initialize the game
self.game = GoGame(self.size)
self.CurrentColor = 'B'
self.PlayerColor = 'B'
self.pass_count = 0
self.ai_activated = False
self.set_up_ui()
if not handle.object_id:
self.infopanel.show(_('Welcome to PlayGo!'))
else:
self.show_score()
self.lastX = -1
self.lastY = -1
# Set keypad actions
self._key_actions = {
'KP_Up' : 'move_up',
'KP_Right' : 'move_right',
'KP_Down' : 'move_down',
'KP_Left' : 'move_left',
'KP_Home' : 'place_stone',
'KP_Next' : 'undo',
'KP_End' : 'pass' }
self._key_grabber = KeyGrabber()
self._key_grabber.connect('key-pressed',
self._key_pressed_cb)
# New KeyGrabber API change (ticket #7999)
try:
self._key_grabber.grab_keys(self._key_actions.keys())
except:
for key in self._key_actions.keys():
self._key_grabber.grab(key)
#Set up collaboration
self.collaboration = CollaborationWrapper(self,
self.buddy_joined,
self.buddy_left,
self.Play,
self.game.undostack,
self.bootstrap)
self.connect('shared', self.collaboration._shared_cb)
if self._shared_activity:
# We are joining the activity
self.connect('joined', self.collaboration._joined_cb)
if self.get_shared():
# We've already joined
self.collaboration._joined_cb()
