def loadUI(self): """Create and show UI """ # we do not have collaboration features # make the share option insensitive self.max_participants = 1 # Toolbar toolbox = ActivityToolbox(self) self._toolbar = toolbox.get_activity_toolbar() self._toolbar.remove(self._toolbar.share) self._toolbar.share = None self._toolbar.remove(self._toolbar.keep) self._toolbar.keep = None self.set_toolbox(toolbox)
def build_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) 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)
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 ScreencastUserInterface(gobject.GObject): __gsignals__ = { 'recordbutton-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()), 'stopbutton-clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()) } def __init__(self, activity): """ Constructor """ super(ScreencastUserInterface, self).__init__() self._toolbox = None self._toolbar = None self._recordbutton = None self._stopbutton = None self._buttonsbox = None self._box = None self._boxalign = None self._checkbox = None self._label = None self._activity = activity # Widgets self.buildToolbar() self.buildButtons() self.buildCheckbox() self.buildLabel() # Main box self._box = gtk.VBox(spacing=20) self._box.pack_start(self._buttonsbox) self._box.pack_start(self._checkbox) self._box.pack_start(self._label) # Align box self._boxalign = gtk.Alignment(0.5, 0.5, 0, 0) self._boxalign.add(self._box) # Set canvas with box alignment self._activity.set_canvas(self._boxalign) def buildToolbar(self): """ Build GUI Toolbar """ self._toolbox = ActivityToolbox(self._activity) self._toolbar = self._toolbox.get_activity_toolbar() # Remove share button self._toolbar.remove(self._toolbar.share) self._toolbar.share = None self._activity.set_toolbox(self._toolbox) # we do not have collaboration features # make the share option insensitive self._activity.max_participants = 1 def buildButtons(self): """ Build buttons """ # Record button self._recordbutton = gtk.Button(i18n.I18N_RECORD_BUTTON) self._recordbutton.connect("clicked", self.recordbuttonClicked) self._recordbutton.set_size_request(150, 150) recordbuttonIcon = gtk.Image() recordbuttonIcon.set_from_icon_name("media-record", -1) self._recordbutton.set_image(recordbuttonIcon) # Stop button self._stopbutton = gtk.Button(i18n.I18N_STOP_BUTTON) self._stopbutton.connect("clicked", self.stopbuttonClicked) self._stopbutton.set_size_request(150, 150) self._stopbutton.set_sensitive(False) stopbuttonIcon = gtk.Image() stopbuttonIcon.set_from_icon_name("media-playback-stop", -1) self._stopbutton.set_image(stopbuttonIcon) # Buttons hbox self._buttonsbox = gtk.HBox(spacing=20) self._buttonsbox.pack_start(self._recordbutton) self._buttonsbox.pack_start(self._stopbutton) def buildCheckbox(self): """ Build checkbox for display state """ self._checkbox = gtk.CheckButton(label=i18n.I18N_RECORD_SOUND_CHECKBOX) self._checkbox.set_active(True) def buildLabel(self): """ Build label for display state """ self._label = gtk.Label(i18n.I18N_STATUS_STOPPED) def recordbuttonClicked(self, widget): """ Event click handler """ self.emit('recordbutton-clicked') def stopbuttonClicked(self, widget): """ Event click handler """ self.emit('stopbutton-clicked') def changeLabelText(self, text): """ Change text of status label """ self._label.set_text(text) def refreshLabelRecordText(self, text1, text2): """ Change text of label """ text = i18n.I18N_STATUS_RECORDING + ", " + text1 + ", " + text2 self.changeLabelText(text) def changeButtonsState(self, newstate="recording"): """ Change state of the buttons """ if newstate == "recording": self._recordbutton.set_sensitive(False) self._stopbutton.set_sensitive(True) self.changeLabelText(i18n.I18N_STATUS_RECORDING) self._checkbox.set_sensitive(False) else: self._recordbutton.set_sensitive(True) self._stopbutton.set_sensitive(False) self.changeLabelText(i18n.I18N_STATUS_STOPPED) self._checkbox.set_sensitive(True) def showInterface(self): """ Show user interface """ self._activity.show_all() def getRecordSoundOption(self): """ Get record sound option """ return self._checkbox.get_active() def alert(self, title, text=None): """ Alert popup """ alert = NotifyAlert(timeout=10) alert.props.title = title alert.props.msg = text self._activity.add_alert(alert) alert.connect('response', self.alert_cancel_cb) alert.show() def alert_cancel_cb(self, alert, response_id): """ Destroy alert popup """ self._activity.remove_alert(alert)
def __init__(self, handle): 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 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()
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)
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()