def __init__(self, handle): activity.Activity.__init__(self, handle) self._name = handle self.num = mynum.Numbers() if NEW_TOOLBARS: toolbar_box = ToolbarBox() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl><Shift>Q' toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() else: toolbox = ActivityToolbox(self) self.set_toolbox(toolbox) toolbox.show() if self.num.widget.parent: self.num.widget.parent.remove(self.num.widget) self.num.widget.show() self.set_canvas(self.num.widget) self.show_all() self.num.setActivity(self)
def __init__(self, handle): """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 _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 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 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): 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 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) 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 __init__(self, handle): """Set up the StopWatch activity.""" Activity.__init__(self, handle) self._logger = logging.getLogger('stopwatch-activity') gobject.threads_init() # top toolbar with share and close buttons: OLD_TOOLBAR = False try: from sugar.graphics.toolbarbox import ToolbarBox, ToolbarButton from sugar.activity.widgets import ActivityToolbarButton, StopButton, \ ShareButton, TitleEntry, ActivityButton except ImportError: OLD_TOOLBAR = True if OLD_TOOLBAR: toolbox = ActivityToolbox(self) self.set_toolbox(toolbox) toolbox.show() else: toolbar_box = ToolbarBox() self.activity_button = ActivityButton(self) toolbar_box.toolbar.insert(self.activity_button, 0) self.activity_button.show() title_entry = TitleEntry(self) toolbar_box.toolbar.insert(title_entry, -1) title_entry.show() try: from sugar.activity.widgets import DescriptionItem description_item = DescriptionItem(self) toolbar_box.toolbar.insert(description_item, -1) description_item.show() except: pass share_button = ShareButton(self) toolbar_box.toolbar.insert(share_button, -1) share_button.show() separator = gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) toolbar_box.toolbar.insert(separator, -1) separator.show() stop_button = StopButton(self) toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) self.tubebox = dobject.TubeBox() self.timer = dobject.TimeHandler("main", self.tubebox) self.gui = stopwatch.GUIView(self.tubebox, self.timer) self.set_canvas(self.gui.display) self.show_all() self.initiating = False # get the Presence Service self.pservice = presenceservice.get_instance() # Buddy object for you owner = self.pservice.get_owner() self.owner = owner self.connect('shared', self._shared_cb) self.connect('joined', self._joined_cb) self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK) self.connect("visibility-notify-event", self._visible_cb) self.connect("notify::active", self._active_cb)
class 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
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 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 __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): # 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 XoScopeActivity(activity.Activity): """XoScopeActivity class as specified in activity.info""" 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) def __preview_window_size_allocate_cb(self, gobject, allocation): # Make sure we don't get stuck in an infinite loop if self._needs_resize: pixbuf = self._preview_window.get_pixbuf() new_pixbuf = pixbuf.scale_simple(allocation.width,\ allocation.height, gtk.gdk.INTERP_BILINEAR) self._preview_window.set_from_pixbuf(new_pixbuf) self._preview_window.show() self._needs_resize = False else: return def read_file(self, path): logging.debug('read_file %s' % path) try: dom = minidom.parse(path) except Exception, e: logging.error('read_file: %s' % e) return logging.debug('read file, now filling hash') self._fill_info_hash(dom) self._update_zoom_element_and_button() self._delay_button.set_icon('delay_%d' % self._delay)
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()
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 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:
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()