class SaludameActivity(Activity):
''' Clase llamada por sugar cuando se ejecuta la actividad.
El nombre de esta clase está señalada en el archivo activity/activity.info '''
def __init__(self, handle):
self.game_init = False # Tells if game engine was initialized
self.loaded_game = None
Activity.__init__(self, handle)
# Creates the activiy box for toolbars
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
# Retrieves the Activity standard toolbar
self.activity_toolbar = self.toolbox.get_activity_toolbar()
# Creates other toolbars
# Game toolbar gets created on demand
# Library toolbar gets created on demand
self.guides_toolbar = gtk.Toolbar()
self.credits_toolbar = gtk.Toolbar()
self.indexes = ["activity"] # right now only activity toolbar
# Create startup windows
self.startup_window = startup_window.StartupWindow(self._start_cb, self._load_last_cb)
# Create the canvas to embbed pygame
self.pygame_canvas = PygameCanvas(self, False)
# Create Health Library Window
self.health_library = content_window.ContentWindow()
# Create Guides Window
self.guides = guides_window.GuidesWindow()
# Create Credits Window
self.credits = credits.Credits()
self.startup_window.show()
self.pygame_canvas.show()
self.health_library.show()
self.guides.show()
self.credits.show()
self.items = gtk.Notebook()
self.items.set_show_tabs(False)
self.items.set_show_border(False)
self.items.append_page(self.startup_window)
self.items.append_page(self.pygame_canvas)
self.items.append_page(self.health_library)
self.items.append_page(self.guides)
self.items.append_page(self.credits)
self.items.show()
self.set_canvas(self.items)
logging.debug("Create main")
self.game = game.Main()
self.game.set_game_over_callback(self.game_over_callback)
self.toolbox.connect('current-toolbar-changed', self.change_mode)
self.make_toolbox(False)
self.toolbox.set_current_toolbar(0) # Start in activity tab
# force the toolbar change
self.change_mode(None, self.toolbox.get_current_toolbar())
game.set_library_function = self.set_library # Sets the callback to put links in the library
self.show()
def make_toolbox(self, add_game):
toolbars = len(self.indexes)
for i in range(toolbars, 0, -1):
self.toolbox.remove_toolbar(i)
self.indexes = ["activity"] # activity toolbar never gets removed
if add_game:
self.toolbox.add_toolbar(_("Game"), self.get_game_toolbar())
self.indexes += ["game"]
self.indexes += ["library", "guides", "credits"]
self.toolbox.add_toolbar(_("Health Library"), self.health_library.get_toolbar())
self.toolbox.add_toolbar(_("Guides"), self.guides_toolbar)
self.toolbox.add_toolbar(_("Credits"), self.credits_toolbar)
def change_mode(self, notebook, index):
game.pause = True
self.pygame_canvas.translator.unhook_pygame()
self.health_library.ditch()
self.guides.ditch()
self.guides.ditch()
gc.collect() # Collects garbaje
if self.indexes[index] == "activity":
self.items.set_current_page(0)
if self.indexes[index] == "game":
game.pause = False
self.show_game()
self.items.set_current_page(1)
elif self.indexes[index] == "library":
self.items.set_current_page(2)
elif self.indexes[index] == "guides":
self.items.set_current_page(3)
elif self.indexes[index] == "credits":
self.credits.before_show()
self.items.set_current_page(4)
#Override activity.Activity's can_close method
def can_close(self):
game.running = False
return True
def _start_cb(self, gender, name):
#self.create_in_journal()
self.metadata['title'] = _("Saludame") + " " + name
self.game.gender = gender
self.game.name = name
self.startup_window.set_welcome()
if self.game.started:
self.game.main(True)
self.make_toolbox(True)
self.toolbox.set_current_toolbar(1) # Move to game tab
def show_game(self):
if self.game.started:
self.game.windows_controller.reload_main = True # Repaints the whole screen
if self.game_init:
self.pygame_canvas.translator.hook_pygame()
else:
self.game_init = True
# Start pygame
self.pygame_canvas.run_pygame(lambda:self.game.main(True)) # Indico que llame a la función local para iniciar el juego pygame
def set_library(self, link, anchor=None):
self.toolbox.set_current_toolbar(2)
self.health_library.set_url(link, anchor)
def _load_last_cb(self, event):
metadata = self.get_last_game()
if metadata:
self.metadata['title'] = metadata['title']
self.make_toolbox(True)
self.toolbox.set_current_toolbar(1)
def game_over_callback(self):
self.make_toolbox(False)
self.toolbox.set_current_toolbar(0) # Move to game tab
def write_file(self, file_path):
if self.game.started:
try:
self.game.save_game(file_path)
except Exception,e:
print "Error writting to file"
print e
raise e
else:
def instance(self):
book.wiki = book.WikiBook()
if not book.custom:
book.custom = book.CustomBook()
self.edit_page = 1
self.edit = edit.View()
self.library = library.View(self)
if OLD_TOOLBAR:
self.edit_toolbar = gtk.Toolbar()
self.edit_bar = edit.ToolbarBuilder(self.edit, self.edit_toolbar)
self.edit_toolbar.show_all()
self.library_toolbar = gtk.Toolbar()
self.library_bar = library.ToolbarBuilder(self.library,
self.library_toolbar)
self.library_toolbar.show_all()
toolbox = ActivityToolbox(self)
toolbox.connect('current-toolbar-changed',
self._toolbar_changed_cb)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Library'), self.library_toolbar)
toolbox.add_toolbar(_('Edit'), self.edit_toolbar)
toolbox.set_current_toolbar(1)
else:
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
self.set_toolbar_box(toolbar_box)
self._toolbar = toolbar_box.toolbar
tool_group = None
search_button = RadioToolButton()
search_button.props.group = tool_group
tool_group = search_button
search_button.props.icon_name = 'white-search'
search_button.set_tooltip(_('Library'))
search_button.mode = 'search'
search_button.connect('clicked', self.__mode_button_clicked)
self._toolbar.insert(search_button, -1)
edit_button = RadioToolButton()
edit_button.props.group = tool_group
edit_button.props.icon_name = 'toolbar-edit'
edit_button.set_tooltip(_('Edit'))
edit_button.mode = 'edit'
edit_button.connect('clicked', self.__mode_button_clicked)
self._toolbar.insert(edit_button, -1)
self._toolbar.insert(gtk.SeparatorToolItem(), -1)
self.edit_bar = edit.ToolbarBuilder(self.edit, self._toolbar)
self.library_bar = library.ToolbarBuilder(self.library,
self._toolbar)
edit_fake = gtk.EventBox()
self.notebook.append_page(self.library)
self.notebook.append_page(self.edit)
self.notebook.append_page(edit_fake)
self.show_all()
if not OLD_TOOLBAR:
self.__mode_button_clicked(search_button)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
separator.show()
self._toolbar.insert(separator, -1)
stop_button = StopButton(self)
stop_button.show()
self._toolbar.insert(stop_button, -1)
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 GuiView(gtk.ScrolledWindow):
"""
This class is used to just remove the table setup from the main file
"""
def __init__(self, activity):
gtk.ScrolledWindow.__init__(self)
self.set_policy( gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC )
self.activity = activity
self.treeview = gtk.TreeView(gtk.TreeStore(str,object))
self.guiHandler = GuiHandler( activity, self.treeview, self )
#self.build_table(activity)
def build_toolbars(self):
self.action_buttons = {}
# BUILD CUSTOM TOOLBAR
self.action_bar = gtk.Toolbar()
self.action_buttons['add'] = ToolButton('fs_gtk-add')
self.action_buttons['add'].set_tooltip(_("Add Object"))
self.action_buttons['rem'] = ToolButton('fs_gtk-remove')
self.action_buttons['rem'].set_tooltip(_("Remove Object(s)"))
self.action_buttons['save'] = ToolButton('filesave')
self.action_buttons['save'].set_tooltip( _("Copy Object(s) to Journal") )
self.action_buttons['down'] = ToolButton('epiphany-download')
self.action_buttons['down'].set_tooltip( _('Download Object(s)') )
self.action_buttons['admin'] = ToolButton('gtk-network')
self.action_buttons['admin'].set_tooltip( _('Server Permissions') )
self.action_buttons['server'] = ToolButton('gaim-link')
self.action_buttons['server'].set_tooltip( _('Connect to Server') )
self.action_buttons['server'].set_sensitive( False )
if self.activity.isServer:
self.action_buttons['add'].connect("clicked", self.guiHandler.requestAddFile, None)
self.action_buttons['save'].connect("clicked", self.guiHandler.requestInsFile, None)
self.action_buttons['rem'].connect("clicked", self.guiHandler.requestRemFile, None)
self.action_buttons['server'].connect("clicked", self.guiHandler.switch_to_server, None)
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['save'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
self.action_bar.insert(self.action_buttons['server'], -1)
# Check for server, if found activate connect link
def check_server_status():
try:
if self.activity.check_for_server():
self.action_buttons['server'].set_sensitive( True )
except ServerRequestFailure:
pass
threading.Thread(target=check_server_status).start()
else:
self.action_buttons['down'].connect("clicked", self.guiHandler.requestDownloadFile, None)
self.action_bar.insert(self.action_buttons['down'], -1)
if self.activity._mode == 'SERVER' and self.activity._user_permissions != 0:
self.action_buttons['add'].connect("clicked", self.guiHandler.requestAddFile, {'upload':True})
self.action_buttons['rem'].connect("clicked", self.guiHandler.requestRemFile, {'remove':True})
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
if self.activity._user_permissions == 2:
self.action_buttons['admin'].connect("clicked", self.guiHandler.showAdmin, None)
self.action_bar.insert(self.action_buttons['admin'], -1)
self.action_bar.show_all()
self.toolbar_set_selection( False )
# Create Toolbox
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Actions"), self.action_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show()
self.toolbox.set_current_toolbar(1)
def on_selection_changed(self, selection):
if selection.count_selected_rows() == 0:
self.toolbar_set_selection(False)
else:
self.toolbar_set_selection(True)
def toolbar_set_selection(self, selected):
require_selection = ['save', 'rem', 'down']
for key in require_selection:
if selected:
self.action_buttons[key].set_sensitive( True )
else:
self.action_buttons[key].set_sensitive( False )
def build_table(self):
# Create File Tree
##################
# Name Cell_data_Func Expand Cell Renderer
text_cells = [
[ _('Name'), FileInfo.file_name, False, gtk.CellRendererText()],
[ _('Description'), FileInfo.file_desc, True, gtk.CellRendererText()],
[ _('Tags'), FileInfo.file_tags, False, gtk.CellRendererText()],
[ _('Size'), FileInfo.file_size, False, gtk.CellRendererText()],
[ '', FileInfo.load_bar, False, gtk.CellRendererProgress()]
]
for col_data in text_cells:
cell = col_data[3]
colName = gtk.TreeViewColumn(col_data[0], cell)
colName.set_cell_data_func(cell, col_data[1])
# Should the col expand
colName.set_expand(col_data[2])
# Add to tree
self.treeview.append_column(colName)
# make it searchable by name
self.treeview.set_search_column(1)
# Allow Multiple Selections
self.treeview.get_selection().set_mode( gtk.SELECTION_MULTIPLE )
self.treeview.get_selection().connect('changed', self.on_selection_changed )
# Put table into scroll window to allow it to scroll
self.add_with_viewport(self.treeview)
def clear_files(self, deleteFile = True):
model = self.treeview.get_model()
iter = model.get_iter_root()
while iter:
key = model.get_value(iter, 0)
# Remove file from UI
self.guiHandler._remFileFromUIList(key)
# UnRegister File with activity share list
self.activity._unregisterShareFile( key )
# Attempt to remove file from system
if deleteFile:
self.activity.delete_file( key )
iter = model.iter_next(iter)
def update_progress(self, id, bytes ):
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter:
if model.get_value( iter, 0 ) == id:
break
iter = model.iter_next( iter )
if iter:
obj = model.get_value( iter, 1 )
obj.update_aquired( bytes )
# Store updated versoin of the object
self.activity.updateFileObj( id, obj )
model.set_value( iter, 1, obj)
model.row_changed(model.get_path(iter), iter)
def set_installed( self, id, sucessful=True ):
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter:
if model.get_value( iter, 0 ) == id:
break
iter = model.iter_next( iter )
if iter:
obj = model.get_value( iter, 1 )
if sucessful:
obj.set_installed()
else:
obj.set_failed()
# Store updated versoin of the object
self.activity.updateFileObj( id, obj )
model.set_value( iter, 1, obj)
model.row_changed(model.get_path(iter), iter)
class GuiView(gtk.ScrolledWindow):
"""
This class is used to just remove the table setup from the main file
"""
def __init__(self, activity):
gtk.ScrolledWindow.__init__(self)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.activity = activity
self.treeview = gtk.TreeView(gtk.TreeStore(str, object))
self.guiHandler = GuiHandler(activity, self.treeview, self)
#self.build_table(activity)
def build_toolbars(self):
self.action_buttons = {}
# BUILD CUSTOM TOOLBAR
self.action_bar = gtk.Toolbar()
self.action_buttons['add'] = ToolButton('fs_gtk-add')
self.action_buttons['add'].set_tooltip(_("Add Object"))
self.action_buttons['rem'] = ToolButton('fs_gtk-remove')
self.action_buttons['rem'].set_tooltip(_("Remove Object(s)"))
self.action_buttons['save'] = ToolButton('filesave')
self.action_buttons['save'].set_tooltip(_("Copy Object(s) to Journal"))
self.action_buttons['down'] = ToolButton('epiphany-download')
self.action_buttons['down'].set_tooltip(_('Download Object(s)'))
self.action_buttons['admin'] = ToolButton('gtk-network')
self.action_buttons['admin'].set_tooltip(_('Server Permissions'))
self.action_buttons['server'] = ToolButton('gaim-link')
self.action_buttons['server'].set_tooltip(_('Connect to Server'))
self.action_buttons['server'].set_sensitive(False)
if self.activity.isServer:
self.action_buttons['add'].connect("clicked",
self.guiHandler.requestAddFile,
None)
self.action_buttons['save'].connect("clicked",
self.guiHandler.requestInsFile,
None)
self.action_buttons['rem'].connect("clicked",
self.guiHandler.requestRemFile,
None)
self.action_buttons['server'].connect(
"clicked", self.guiHandler.switch_to_server, None)
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['save'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
self.action_bar.insert(self.action_buttons['server'], -1)
# Check for server, if found activate connect link
def check_server_status():
try:
if self.activity.check_for_server():
self.action_buttons['server'].set_sensitive(True)
except ServerRequestFailure:
pass
threading.Thread(target=check_server_status).start()
else:
self.action_buttons['down'].connect(
"clicked", self.guiHandler.requestDownloadFile, None)
self.action_bar.insert(self.action_buttons['down'], -1)
if self.activity._mode == 'SERVER' and self.activity._user_permissions != 0:
self.action_buttons['add'].connect(
"clicked", self.guiHandler.requestAddFile,
{'upload': True})
self.action_buttons['rem'].connect(
"clicked", self.guiHandler.requestRemFile,
{'remove': True})
self.action_bar.insert(self.action_buttons['add'], -1)
self.action_bar.insert(self.action_buttons['rem'], -1)
if self.activity._user_permissions == 2:
self.action_buttons['admin'].connect(
"clicked", self.guiHandler.showAdmin, None)
self.action_bar.insert(self.action_buttons['admin'], -1)
self.action_bar.show_all()
self.toolbar_set_selection(False)
# Create Toolbox
self.toolbox = ActivityToolbox(self.activity)
self.toolbox.add_toolbar(_("Actions"), self.action_bar)
self.activity.set_toolbox(self.toolbox)
self.toolbox.show()
self.toolbox.set_current_toolbar(1)
def on_selection_changed(self, selection):
if selection.count_selected_rows() == 0:
self.toolbar_set_selection(False)
else:
self.toolbar_set_selection(True)
def toolbar_set_selection(self, selected):
require_selection = ['save', 'rem', 'down']
for key in require_selection:
if selected:
self.action_buttons[key].set_sensitive(True)
else:
self.action_buttons[key].set_sensitive(False)
def build_table(self):
# Create File Tree
##################
# Name Cell_data_Func Expand Cell Renderer
text_cells = [
[_('Name'), FileInfo.file_name, False,
gtk.CellRendererText()],
[
_('Description'), FileInfo.file_desc, True,
gtk.CellRendererText()
], [_('Tags'), FileInfo.file_tags, False,
gtk.CellRendererText()],
[_('Size'), FileInfo.file_size, False,
gtk.CellRendererText()],
['', FileInfo.load_bar, False,
gtk.CellRendererProgress()]
]
for col_data in text_cells:
cell = col_data[3]
colName = gtk.TreeViewColumn(col_data[0], cell)
colName.set_cell_data_func(cell, col_data[1])
# Should the col expand
colName.set_expand(col_data[2])
# Add to tree
self.treeview.append_column(colName)
# make it searchable by name
self.treeview.set_search_column(1)
# Allow Multiple Selections
self.treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.treeview.get_selection().connect('changed',
self.on_selection_changed)
# Put table into scroll window to allow it to scroll
self.add_with_viewport(self.treeview)
def clear_files(self, deleteFile=True):
model = self.treeview.get_model()
iter = model.get_iter_root()
while iter:
key = model.get_value(iter, 0)
# Remove file from UI
self.guiHandler._remFileFromUIList(key)
# UnRegister File with activity share list
self.activity._unregisterShareFile(key)
# Attempt to remove file from system
if deleteFile:
self.activity.delete_file(key)
iter = model.iter_next(iter)
def update_progress(self, id, bytes):
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter:
if model.get_value(iter, 0) == id:
break
iter = model.iter_next(iter)
if iter:
obj = model.get_value(iter, 1)
obj.update_aquired(bytes)
# Store updated versoin of the object
self.activity.updateFileObj(id, obj)
model.set_value(iter, 1, obj)
model.row_changed(model.get_path(iter), iter)
def set_installed(self, id, sucessful=True):
model = self.treeview.get_model()
iter = model.get_iter_first()
while iter:
if model.get_value(iter, 0) == id:
break
iter = model.iter_next(iter)
if iter:
obj = model.get_value(iter, 1)
if sucessful:
obj.set_installed()
else:
obj.set_failed()
# Store updated versoin of the object
self.activity.updateFileObj(id, obj)
model.set_value(iter, 1, obj)
model.row_changed(model.get_path(iter), iter)
