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.__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_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()
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()