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()
