def __init__(self, handle):
activity.Activity.__init__(self, handle)
""" Create the official Sugar toolbox at the top of the screen"""
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
file_location = activity.get_activity_root() + \
"/data/reckonprimer_report.txt"
file_handle = open(file_location, 'w')
file_handle.write("Report: " + profile.get_nick_name() + \
strftime(" %Y-%m-%d %H:%M:%S") + "\n")
file_handle.close()
title = "Report: " + profile.get_nick_name() + \
strftime(" %Y-%m-%d %H:%M:%S")
mime = "text/plain"
file_path = activity.get_activity_root() + \
"/data/reckonprimer_report.txt"
favorite = "1"
tags = "ReckonPrimer"
journal_object = datastore.create()
journal_object.metadata['title'] = title
journal_object.metadata['mime_type'] = mime
journal_object.file_path = file_path
journal_object.metadata['keep'] = favorite
journal_object.metadata['tags'] = tags
journal_object.metadata['icon-color'] = '#AFD600,#5B615C'
datastore.write( journal_object )
journal_object.destroy()
self.run_session()
def _share_audio(self):
if profile.get_nick_name() in self._audio_recordings:
base64 = file_to_base64(
activity, self._audio_recordings[profile.get_nick_name()])
gobject.idle_add(self._send_event, 'a:' + str(
self._data_dumper([profile.get_nick_name(),
self.colors,
base64])))
def event_received_cb(self, text):
''' Data is passed as tuples: cmd:text '''
_logger.debug('<<< %s' % (text[0]))
if text[0] == 's': # shared journal objects
e, data = text.split(':')
self._load(data)
elif text[0] == 'j': # Someone new has joined
e, buddy = text.split(':')
_logger.debug('%s has joined' % (buddy))
if buddy not in self._buddies:
self._buddies.append(buddy)
if self.initiating:
self._send_event('J:%s' % (profile.get_nick_name()))
self._share_slides()
self._share_audio()
elif text[0] == 'J': # Everyone must share
e, buddy = text.split(':')
self.waiting = False
if buddy not in self._buddies:
self._buddies.append(buddy)
_logger.debug('%s has joined' % (buddy))
self._share_slides()
self._share_audio()
elif text[0] == 'a': # audio recording
e, data = text.split(':')
nick, colors, base64 = self._data_loader(data)
path = os.path.join(activity.get_activity_root(),
'instance', 'nick.ogg')
base64_to_file(activity, base64, path)
self._add_playback_button(nick, colors, path)
def __init__(self, handle):
''' Initialize the toolbars and the work surface '''
super(BBoardActivity, self).__init__(handle)
self.datapath = get_path(activity, 'instance')
self._hw = get_hardware()
self._playback_buttons = {}
self._audio_recordings = {}
self.colors = profile.get_color().to_string().split(',')
self._setup_toolbars()
self._setup_canvas()
self.slides = []
self._setup_workspace()
self._buddies = [profile.get_nick_name()]
self._setup_presence_service()
self._thumbs = []
self._thumbnail_mode = False
self._recording = False
self._grecord = None
self._alert = None
self._dirty = False
def __init__(self, cfg_file):
self._cfg_file = cfg_file
if not os.path.exists(self._cfg_file): # create it
open(self._cfg_file, 'w')
self._cp = ConfigParser()
if not self._cp.read([self._cfg_file]):
logging.error('ConfigParser: error parsing %s', self._cfg_file)
### public options ###
# defaults
self.name = get_nick_name()
#self.name = "dingbat"
self.del_on_retr = False
self.store_account = accounts.DummyStoreAccount()
#self.store_account = accounts.POPStoreAccount("mew.don.gs", 110, "insecure", "*****@*****.**", "sugar", False)
self.transport_account = accounts.DummyTransportAccount()
# now parse (from the config file at "activityroot"/data/config.txt")
self._parse_profile()
self._parse_store()
def get_nick_from_sugar(self):
''' Returns nick from Sugar '''
if self._using_gconf:
client = gconf.client_get_default()
return client.get_string('/desktop/sugar/user/nick')
else:
return profile.get_nick_name()
def __init__(self, handle):
''' Initiate activity. '''
super(FractionBounceActivity, self).__init__(handle)
self.nick = profile.get_nick_name()
if profile.get_color() is not None:
self.colors = profile.get_color().to_string().split(',')
else:
self.colors = ['#A0FFA0', '#FF8080']
self.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK)
self.connect('visibility-notify-event', self.__visibility_notify_cb)
self.max_participants = 4 # sharing
self._setup_toolbars()
self._setup_dispatch_table()
canvas = self._setup_canvas()
# Read any custom fractions from the project metadata
if 'custom' in self.metadata:
custom = self.metadata['custom']
else:
custom = None
# Initialize the canvas
self.bounce_window = Bounce(canvas, activity.get_bundle_path(), self)
# Restore any custom fractions
if custom is not None:
fractions = custom.split(',')
for f in fractions:
self.bounce_window.add_fraction(f)
self._setup_presence_service()
def __init__(self, handle):
""" Initialize the toolbars and the game board """
super(PathsActivity, self).__init__(handle)
self.nick = profile.get_nick_name()
if profile.get_color() is not None:
self.colors = profile.get_color().to_string().split(',')
else:
self.colors = ['#A0FFA0', '#FF8080']
self._setup_toolbars(_have_toolbox)
self._setup_dispatch_table()
# Create a canvas
canvas = gtk.DrawingArea()
canvas.set_size_request(gtk.gdk.screen_width(), \
gtk.gdk.screen_height())
self.set_canvas(canvas)
canvas.show()
self.show_all()
self._game = Game(canvas, parent=self, colors=self.colors)
self._setup_presence_service()
# Restore game state from Journal or start new game
if 'deck' in self.metadata:
self._restore()
else:
self._game.new_game()
def __init__(self, handle):
""" Initialize the toolbars and the game board """
super(PathsActivity, self).__init__(handle)
self.nick = profile.get_nick_name()
if profile.get_color() is not None:
self.colors = profile.get_color().to_string().split(',')
else:
self.colors = ['#A0FFA0', '#FF8080']
self._setup_toolbars(_have_toolbox)
self._setup_dispatch_table()
# Create a canvas
canvas = gtk.DrawingArea()
canvas.set_size_request(gtk.gdk.screen_width(), \
gtk.gdk.screen_height())
self.set_canvas(canvas)
canvas.show()
self.show_all()
self._game = Game(canvas, parent=self, colors=self.colors)
self._setup_presence_service()
# Restore game state from Journal or start new game
if 'deck' in self.metadata:
self._restore()
else:
self._game.new_game()
def _save_recording(self):
if os.path.exists(os.path.join(self.datapath, 'output.ogg')):
_logger.debug('Saving recording to Journal...')
obj_id = self._get_audio_obj_id()
copyfile(os.path.join(self.datapath, 'output.ogg'),
os.path.join(self.datapath, '%s.ogg' % (obj_id)))
dsobject = self._search_for_audio_note(obj_id)
if dsobject is None:
dsobject = datastore.create()
if dsobject is not None:
_logger.debug(self.dsobjects[self.i].metadata['title'])
dsobject.metadata['title'] = _('Audio recording by %s') % \
(self.metadata['title'])
dsobject.metadata['icon-color'] = \
profile.get_color().to_string()
dsobject.metadata['tags'] = obj_id
dsobject.metadata['mime_type'] = 'audio/ogg'
dsobject.set_file_path(
os.path.join(self.datapath, '%s.ogg' % (obj_id)))
datastore.write(dsobject)
dsobject.destroy()
self._add_playback_button(
profile.get_nick_name(), self.colors,
os.path.join(self.datapath, '%s.ogg' % (obj_id)))
if hasattr(self, 'chattube') and self.chattube is not None:
self._share_audio()
else:
_logger.debug('Nothing to save...')
return
def _add_link(self):
''' take screenshot and add link info to the model '''
for link in self.model.data['shared_links']:
if link['hash'] == sha.new(self.current).hexdigest():
_logger.debug('_add_link: link exist already a=%s b=%s' %(
link['hash'], sha.new(self.current).hexdigest()))
return
buf = self._get_screenshot()
timestamp = time.time()
self.model.add_link(self.current, self.webtitle, buf,
profile.get_nick_name(),
profile.get_color().to_string(), timestamp)
if self.messenger is not None:
self.messenger._add_link(self.current, self.webtitle,
profile.get_color().to_string(),
profile.get_nick_name(),
base64.b64encode(buf), timestamp)
def __init__(self, series_name=None, series_color=None):
gobject.GObject.__init__(self)
self.series_name = series_name \
if series_name is not None else profile.get_nick_name()
self.data_length = 40
self.shrink_by = 1
self.data_moments = (0, 1, 2, 3)
self.data = []
self.moments = [[] for m in self.data_moments]
self.set_color(series_color if series_color is not None else XoColor())
def add_annotation(self, page):
annotation_title = (_("%s's annotation") % profile.get_nick_name())
annotation_content = (_("Annotation for page %d") % (page + 1))
dialog = AnnotationAddDialog(parent_xid = self.get_toplevel().window.xid, \
dialog_title = _("Add notes for annotation: "), \
annotation_id = 0, \
annotation_title = annotation_title, \
annotation_content = annotation_content, page = page, \
sidebarinstance = self)
dialog.show_all()
def _build_series(self):
self.series = []
interfaces = get_wireless_interfaces()
if len(interfaces) > 0:
series = WirelessDataSeries(series_name=profile.get_nick_name(),
series_color=profile.get_color(),
interface=interfaces[0])
self.series.append(series)
self.graph.add_series(series)
for interface in interfaces[1:]:
series_name = "%s-%s" % (profile.get_nick_name(), interface)
series_colors = xocolor.colors[hash(series_name) %
len(xocolor.colors)]
series_xocolor = xocolor.XoColor(",".join(series_colors))
series = WirelessDataSeries(series_name=series_name,
series_color=series_xocolor,
interface=interface)
self.series.append(series)
self.graph.add_series(series)
def _save_as_html_cb(self, button=None):
''' Export an HTML version of the slideshow to the Journal. '''
self._save_button.set_icon('save-in-progress')
results = save_html(self._dsobjects, profile.get_nick_name(),
self._colors, self._tmp_path)
html_file = os.path.join(self._tmp_path, 'tmp.html')
tmp_file = open(html_file, 'w')
tmp_file.write(results)
tmp_file.close()
dsobject = datastore.create()
dsobject.metadata['title'] = profile.get_nick_name() + ' ' + \
_('Portfolio')
dsobject.metadata['icon-color'] = profile.get_color().to_string()
dsobject.metadata['mime_type'] = 'text/html'
dsobject.set_file_path(html_file)
dsobject.metadata['activity'] = 'org.laptop.WebActivity'
datastore.write(dsobject)
dsobject.destroy()
gobject.timeout_add(250, self._save_button.set_icon, 'save-as-html')
return
def __init__(self, owner, tablet_mode):
gtk.ScrolledWindow.__init__(self)
if owner is None:
self._owner = {'nick': profile.get_nick_name(),
'color': profile.get_color().to_string()}
else:
self._owner = owner
self._tablet_mode = tablet_mode
# Auto vs manual scrolling:
self._scroll_auto = True
self._scroll_value = 0.0
self._last_msg_sender = None
# Track last message, to combine several messages:
self._last_msg = None
self._chat_log = ''
self._row_counter = 0
# We need access to individual messages for resizing
# TODO: use a signal for this
self._rb_list = []
self._grid_list = []
self._message_list = []
self._conversation = gtk.VBox()
# self._conversation.set_row_spacing(style.DEFAULT_PADDING)
# self._conversation.set_border_width(0)
self._conversation.set_size_request(
gtk.gdk.screen_width() - style.GRID_CELL_SIZE, -1)
# OSK padding for conversation
self._dy = 0
evbox = gtk.EventBox()
evbox.modify_bg(
gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color())
evbox.add(self._conversation)
self._conversation.show()
self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
self.add_with_viewport(evbox)
evbox.show()
vadj = self.get_vadjustment()
vadj.connect('changed', self._scroll_changed_cb)
vadj.connect('value-changed', self._scroll_value_changed_cb)
def generate_unique_id():
"""Generate an id based on the user's nick name and their public key
(Based on schema used by IRC activity).
"""
nick = profile.get_nick_name()
pubkey = profile.get_pubkey()
m = hashlib.sha1()
m.update(pubkey)
hexhash = m.hexdigest()
nick_letters = "".join([x for x in nick if x.isalpha()])
if not nick_letters:
nick_letters = 'XO'
return nick_letters + '_' + hexhash[:4]
def start_game(self,numPlayers): self._create_domino() self.placed_pieces = [] self.players = [] auto_player = SimpleAutoPlayer(self,0) auto_player.set_pieces(self.take_pieces(7)) self.players.append(auto_player) for n in range(1,numPlayers): #print "bucle creacion jugadores",n player = DominoPlayer(self,n) player.set_pieces(self.take_pieces(7)) self.players.append(player) # comienza a jugar el primer jugador self.players[0].play() self.ui_player = self.players[1] self.ui_player.color = profile.get_color() self.ui_player.name = profile.get_nick_name()
def _save_as_pdf_cb(self, button=None):
''' Export an PDF version of the slideshow to the Journal. '''
_logger.debug('saving to PDF...')
if 'description' in self.metadata:
tmp_file = save_pdf(self, self._buddies,
description=self.metadata['description'])
else:
tmp_file = save_pdf(self, self._buddies)
_logger.debug('copying PDF file to Journal...')
dsobject = datastore.create()
dsobject.metadata['title'] = profile.get_nick_name() + ' ' + \
_('Bboard')
dsobject.metadata['icon-color'] = profile.get_color().to_string()
dsobject.metadata['mime_type'] = 'application/pdf'
dsobject.set_file_path(tmp_file)
dsobject.metadata['activity'] = 'org.laptop.sugar.ReadActivity'
datastore.write(dsobject)
dsobject.destroy()
return
def __init__(self, mount_point):
gobject.GObject.__init__(self)
self._mount_point = mount_point
self._path = None
self._bundle = None
self._child_pid = None
self._pipe_from_child = None
self._pipe_to_child = None
self._pipe_from_child_watch_id = None
self._num_entries = None
self._entries = None
self._data_store = None
self._data_store_version = None
self._data_store_mount_id = None
self._user_name = profile.get_nick_name().replace('/', ' ')
self._id = self._get_id()
if '\0' in self._user_name:
raise ValueError('Invalid user name')
def _new_tube_cb(self, id, initiator, type, service, params, state):
''' Create a new tube. '''
_logger.debug('New tube: ID=%d initator=%d type=%d service=%s '
'params=%r state=%d', id, initiator, type, service,
params, state)
if (type == telepathy.TUBE_TYPE_DBUS and service == SERVICE):
if state == telepathy.TUBE_STATE_LOCAL_PENDING:
self.tubes_chan[ \
telepathy.CHANNEL_TYPE_TUBES].AcceptDBusTube(id)
tube_conn = TubeConnection(self.conn,
self.tubes_chan[telepathy.CHANNEL_TYPE_TUBES], id, \
group_iface=self.text_chan[telepathy.CHANNEL_INTERFACE_GROUP])
self.chattube = ChatTube(tube_conn, self.initiating, \
self.event_received_cb)
if self.waiting:
self._send_event('j:%s' % (profile.get_nick_name()))
def __init__(self, activity):
self._logger = logging.getLogger('GeoModel')
self._logger.setLevel(constants.LOG_LEVEL)
self.activity = activity
self.activity.set_model(self)
# Init the player list
self.mynickname = profile.get_nick_name()
self.pservice = presenceservice.get_instance()
self.owner = self.pservice.get_owner()
# create shared datastructure for players
self.players = CausalDict(value_translator=player_translator)
activity.cloud.players = self.players
this_player = Player(self.mynickname)
self.players[self.mynickname] = this_player
#gobject.timeout_add(3000, self.print_dict) # only for debugging
activity.connect('position_changed', this_player.set_position)
self._logger.debug("INIT GEOSPACEMODEL DONE.")
def send_chat_text(self, text):
handle = self.netstack.get_tube_handle()
prof = profile.get_nick_name()
if handle:
handle.send_chat_text( "<%s> %s" % (prof, text) )
def _setup_toolbars(self):
''' Setup the toolbars. '''
self.max_participants = 6
if HAVE_TOOLBOX:
toolbox = ToolbarBox()
# Activity toolbar
activity_button_toolbar = ActivityToolbarButton(self)
toolbox.toolbar.insert(activity_button_toolbar, 0)
activity_button_toolbar.show()
self.set_toolbar_box(toolbox)
toolbox.show()
self.toolbar = toolbox.toolbar
self.record_toolbar = gtk.Toolbar()
record_toolbar_button = ToolbarButton(
label=_('Record a sound'),
page=self.record_toolbar,
icon_name='media-audio')
self.record_toolbar.show_all()
record_toolbar_button.show()
toolbox.toolbar.insert(record_toolbar_button, -1)
else:
# Use pre-0.86 toolbar design
primary_toolbar = gtk.Toolbar()
toolbox = activity.ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.add_toolbar(_('Page'), primary_toolbar)
self.record_toolbar = gtk.Toolbar()
toolbox.add_toolbar(_('Record'), self.record_toolbar)
toolbox.show()
toolbox.set_current_toolbar(1)
self.toolbar = primary_toolbar
self._prev_button = button_factory(
'go-previous-inactive', self.toolbar, self._prev_cb,
tooltip=_('Prev slide'), accelerator='<Ctrl>P')
self._next_button = button_factory(
'go-next', self.toolbar, self._next_cb,
tooltip=_('Next slide'), accelerator='<Ctrl>N')
separator_factory(self.toolbar)
slide_button = radio_factory('slide-view', self.toolbar,
self._slides_cb, group=None,
tooltip=_('Slide view'))
radio_factory('thumbs-view', self.toolbar, self._thumbs_cb,
tooltip=_('Thumbnail view'),
group=slide_button)
button_factory('view-fullscreen', self.toolbar,
self.do_fullscreen_cb, tooltip=_('Fullscreen'),
accelerator='<Alt>Return')
separator_factory(self.toolbar)
journal_button = button_factory(
'write-journal', self.toolbar, self._do_journal_cb,
tooltip=_('Update description'))
self._palette = journal_button.get_palette()
msg_box = gtk.HBox()
sw = gtk.ScrolledWindow()
sw.set_size_request(int(gtk.gdk.screen_width() / 2),
2 * style.GRID_CELL_SIZE)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._text_view = gtk.TextView()
self._text_view.set_left_margin(style.DEFAULT_PADDING)
self._text_view.set_right_margin(style.DEFAULT_PADDING)
self._text_view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
self._text_view.connect('focus-out-event',
self._text_view_focus_out_event_cb)
sw.add(self._text_view)
sw.show()
msg_box.pack_start(sw, expand=False)
msg_box.show_all()
self._palette.set_content(msg_box)
label_factory(self.record_toolbar, _('Record a sound') + ':')
self._record_button = button_factory(
'media-record', self.record_toolbar,
self._record_cb, tooltip=_('Start recording'))
separator_factory(self.record_toolbar)
# Look to see if we have audio previously recorded
obj_id = self._get_audio_obj_id()
dsobject = self._search_for_audio_note(obj_id)
if dsobject is not None:
_logger.debug('Found previously recorded audio')
self._add_playback_button(profile.get_nick_name(),
self.colors,
dsobject.file_path)
if HAVE_TOOLBOX:
button_factory('system-restart', activity_button_toolbar,
self._resend_cb, tooltip=_('Refresh'))
separator_factory(activity_button_toolbar)
self._save_pdf = button_factory(
'save-as-pdf', activity_button_toolbar,
self._save_as_pdf_cb, tooltip=_('Save as PDF'))
else:
separator_factory(self.toolbar)
self._save_pdf = button_factory(
'save-as-pdf', self.toolbar,
self._save_as_pdf_cb, tooltip=_('Save as PDF'))
if HAVE_TOOLBOX:
separator_factory(toolbox.toolbar, True, False)
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl>q'
toolbox.toolbar.insert(stop_button, -1)
stop_button.show()
def send_chat_text(self, text):
handle = self.netstack.get_tube_handle()
prof = profile.get_nick_name()
if handle:
handle.send_chat_text("<%s> %s" % (prof, text))
def get_test_bt(self, widget=None, data=None, check_pass=True):
self.clear_alerts()
try:
if self.chosen_test_id:
self.test_id = self.chosen_test_id
self.chosen_test_id = None
self.test_pass = self.browse_toolbar.pass_entry.get_text()
else:
self.test_pass = self.test_toolbar.pass_entry.get_text()
self.test_id = self.test_toolbar.test_entry.get_text()
#sprawdzenie czy istnieje
if check_pass and not self.test_pass:
self.show_alert(title="Pobieranie testu %s" % self.test_id, msg="Hasło jest wymagane")
elif not self.test_id:
self.show_alert(title="Pobieranie testu %s" % self.test_id, msg="Pole z Id testu jest wymagane")
else:
self.user_name = profile.get_nick_name()
self.test_pass = self.test_pass
values = {'test-id': self.test_id,
'test-password': self.test_pass,
'user-name': self.user_name}
data = urllib.urlencode(values)
url = self.server + '/questions_download/'
req = urllib2.Request(url, data)
response = urllib2.urlopen(req)
questions_file = open(self.questions_path, "w")
questions_file.write(response.fp.read())
questions_file.close()
questions_file = tarfile.open(self.questions_path,"r")
questions_file.extractall(path=self.data_path)
os.remove(self.questions_path)
# user_name = profile.get_nick_name()
# test_pass = self.test_toolbar.pass_entry.get_text()
# body_list = ["--%s--"%boundary,"Content-Disposition: form-data; name=test-id", "", self.test_id, "--%s--"%boundary,
# "Content-Disposition: form-data; name=test-password", "", test_pass, "--%s--"%boundary,
# "Content-Disposition: form-data; name=user_name", "", user_name, "--%s--"%boundary]
# body = "\r\n".join(body_list)
# headers = {"Content-Type": "multipart/form-data; boundary=%s"%boundary, "Content-Length": str(len(body))}
# connection = httplib.HTTPConnection(self.server)
# connection.request("POST","/questions_download/", body, headers)
# response = connection.getresponse()
# if response.reason != "OK":
# print response.reason
# print response.read()
#
# questions_file = open(self.questions_path, "w")
# questions_file.write(response.fp.read())
# questions_file.close()
#
# connection = httplib.HTTPConnection(self.server)
# connection.request("POST","/answers_download/", body, headers)
# response = connection.getresponse()
# if response.reason != "OK":
# print response.reason
# print response.read()
#
# answers_response = response.fp.read()
# answers_file = open(self.answers_path, "w")
# answers_file.write(answers_response)
# answers_file.close()
#
# #wypakowanie testu
# questions_file = tarfile.open(self.questions_path,"r")
# questions_file.extractall(path=self.data_path)
# os.remove(self.questions_path)
self.show_alert(title="Pobieranie testu %s" % self.test_id, msg="Pobieranie testu zakończone sukcesem, kliknij ok aby kontynuować", start_test=True)
#urlretrieve(url+"test.zip", zip_path)
#xmlschema_doc = etree.parse("kvml.xsd")
#
##os.chdir(self.handle.instance_path)
##os.popen("unzip -o test.zip", "r")
#
#f_test = file(self.handle.test_path)
#if (f_test.readline() == "Nie odnaleziono pliku"):
# msg = "Nie udało się pobrać testu"
# f_test.close()
#else:
# f_test.close()
##walidacja przy użyciu XMLSchema
#xmlschema = etree.XMLSchema(xmlschema_doc)
#test_doc = etree.parse(file(self.handle.test_path))
#if xmlschema.validate(test_doc):
# msg = "Test pobrany poprawnie"
# self.handle.test_cover = True
#else:
# msg = "Pobrany test nie jest zgodny ze standardem"
except:
self._logger = logging.getLogger('activity-knut')
self._logger.setLevel(logging.DEBUG)
#First log handler: outputs to a file
file_handler = logging.FileHandler('/home/wiktor/code/knut.log')
file_formatter = logging.Formatter('%(message)s')
file_handler.setFormatter(file_formatter)
self._logger.addHandler(file_handler)
self._logger.exception('Pobieranie testu')
self.show_alert(title="Pobieranie testu %s" % self.test_id, msg="Nie udało się pobrać testu, skontaktuj się z nauczycielem")
def _finish_test(self):
self.item_panel.hide_all()
user_name = profile.get_nick_name()
# downloading answers
values = {'test-id': self.handle.test_id,
'test-password': self.handle.test_pass,
'user-name': user_name}
data = urllib.urlencode(values)
url = self.handle.server + '/answers_download/'
req = urllib2.Request(url, data)
response = urllib2.urlopen(req)
answers_file = open(self.handle.answers_path, "w")
answers_file.write(response.fp.read())
answers_file.close()
answers_xml = objectify.parse(self.handle.answers_path).getroot()
# print self.answers_dict
emr = objectify.ElementMaker()
# emr._nsmap = {None : "http://kolos.math.uni.lodz.pl/~idzik84/kvml_results"}
results_xml = emr.results()
points = 0.0
points_max = len(self.answers_dict)
for item in answers_xml.item:
item_id = item.get('id')
user_ans = self.answers_dict[item_id]
options_num = len(item.option)
cumul = 0.0
results_item = emr.item()
results_item.set('id', item_id)
for index in xrange(options_num):
results_option = emr.option({True: 'true', False: 'false'}[user_ans[index]])
results_item.append(results_option)
if item.option[index].get('correct') == 'true':
if user_ans[index]:
cumul += 1.0
elif item.option[index].get('correct') == 'false':
if not user_ans[index]:
cumul += 1.0
answer_correct = False
item_type = self.question_type[item_id]
if item_type in ('one', 't/f'):
if options_num == cumul:
points += 1.0
answer_correct = True
# print 'after one', points
elif item_type == 'mul':
points += (cumul/options_num)
if cumul == options_num:
answer_correct = True
# print 'after mul', points
results_item.set('all_correct', {True: 'true', False: 'false'}[answer_correct])
results_xml.append(results_item)
points_percentage = (points/points_max*100)
self.handle.show_alert(title="Wyniki testu", msg="Twój wyniki to %s punktów na %s możliwych. Wynik wyrażony w procentach %2.1f%%" % (points, points_max, points_percentage))
# print(etree.tostring(results_xml, pretty_print=True))
# results_path = os.path.join(self.handle.data_path, "results.xml")
# f = open(results_path, 'w')
# f.write(etree.tostring(results_xml, pretty_print=True))
# f.close()
boundary = mimetools.choose_boundary()
body_list = []
body_list = ["--%s--"%boundary, "Content-Disposition: form-data; name=results_xml; filename=results.xml",
"Content-Type: application/xml", "", etree.tostring(results_xml, pretty_print=True), "--%s--"%boundary,
'Content-Disposition: form-data; name="login"', "", user_name, "--%s--"%boundary,
'Content-Disposition: form-data; name="test-id"', "", self.handle.test_id, "--%s--"%boundary,
'Content-Disposition: form-data; name="points"', "", str(points), "--%s--"%boundary,
'Content-Disposition: form-data; name="points-percentage"', "", '%2.1f' % points_percentage, "--%s--"%boundary]
body = "\r\n".join(body_list)
headers = {"content-type":"multipart/form-data; boundary=%s"%boundary, "content-length":str(len(body))}
connection = httplib.HTTPConnection(self.handle.server.replace('http://',''))
self._logger.debug(self.handle.server)
connection.request("POST","/results_upload/", body, headers)
response = connection.getresponse()
re = response.read()
if re == "OK":
text = " Test wysłany "
else:
file = open(self.handle.data_path + '/error.html', 'w')
file.write(re)
file.close()
text = " Nie wysłano testu "
#usuwanie pozostałych plików
for root, dirs, files in os.walk(self.handle.data_path, topdown=False):
for name in files:
os.remove(os.path.join(root, name) )
for name in dirs:
os.rmdir(os.path.join(root, name) )
self._logger.debug('koniec')
def add_text(self, buddy, text, status_message=False):
'''Display text on screen, with name and colors.
buddy -- buddy object or dict {nick: string, color: string}
(The dict is for loading the chat log from the journal,
when we don't have the buddy object any more.)
text -- string, what the buddy said
status_message -- boolean
False: show what buddy said
True: show what buddy did
.----- rb ------------.
| +----align-------+ |
| | +--message---+ | |
| | | nick: | | |
| | | text 1 | | |
| | | text 2 | | |
| | +------------+ | |
| +----------------+ |
`----------------- +--'
\|
The color scheme for owner messages is:
nick in darker of stroke and fill colors
background in lighter of stroke and fill colors
text in black
The color scheme for buddy messages is:
nick in darker of stroke and fill colors
background in light gray
text in black
rb has a tail on the right for owner messages and the left for
buddy messages.
'''
if not buddy:
buddy = self._owner
if type(buddy) is dict:
# dict required for loading chat log from journal
nick = buddy['nick']
color = buddy['color']
elif buddy is None:
nick = 'unknown'
color = '#000000,#808080'
else:
nick = buddy.props.nick
color = buddy.props.color
try:
color_stroke_html, color_fill_html = color.split(',')
except ValueError:
color_stroke_html, color_fill_html = ('#000000', '#888888')
lighter = lighter_color(color.split(','))
darker = 1 - lighter
if len(text) > 3 and text[0:4] == '/me ':
me_message = True
else:
me_message = False
if status_message or me_message:
text_color = style.COLOR_WHITE
nick_color = style.COLOR_WHITE
color_fill = style.Color('#808080')
highlight_fill = style.COLOR_WHITE
tail = None
else:
highlight_fill = style.COLOR_BUTTON_GREY
text_color = style.COLOR_BLACK
if darker == 1:
color_fill = style.Color(color_stroke_html)
if is_low_contrast(color.split(',')):
nick_color = text_color
else:
nick_color = style.Color(color_fill_html)
else:
color_fill = style.Color(color_fill_html)
if is_low_contrast(color.split(',')):
nick_color = text_color
else:
nick_color = style.Color(color_stroke_html)
if nick == profile.get_nick_name():
tail = 'right'
else:
tail = 'left'
color_stroke = None
self._add_log(nick, color, text, status_message)
# Check for Right-To-Left languages:
if pango.find_base_dir(nick, -1) == pango.DIRECTION_RTL:
lang_rtl = True
else:
lang_rtl = False
# Check if new message box or add text to previous:
new_msg = True
if self._last_msg_sender and buddy == self._last_msg_sender:
# Add text to previous message
if not (me_message or status_message):
new_msg = False
if not new_msg:
message = self._last_msg
message.add_text(text)
else:
rb = RoundBox()
rb.background_color = color_fill
rb.border_color = color_stroke
rb.tail = tail
self._rb_list.append(rb)
grid_internal = gtk.VBox()
grid_internal.set_size_request(
gtk.gdk.screen_width() - style.GRID_CELL_SIZE,
style.GRID_CELL_SIZE) # -1)
self._grid_list.append(grid_internal)
row = 0
if status_message:
nick = None
elif me_message:
text = text[4:]
message = TextBox(self, nick_color, text_color, color_fill,
highlight_fill, lang_rtl, nick, text)
self._message_list.append(message)
self._last_msg_sender = buddy
self._last_msg = message
grid_internal.pack_start(message, expand=False, padding=0)
row += 1
align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
if rb.tail is None:
bottom_padding = style.zoom(7)
else:
bottom_padding = style.zoom(40)
align.set_padding(style.zoom(7), bottom_padding, style.zoom(30),
style.zoom(30))
align.add(grid_internal)
grid_internal.show()
rb.pack_start(align, True, True, 0)
align.show()
self._conversation.pack_start(rb, expand=False,
padding=style.DEFAULT_PADDING)
rb.show()
self._row_counter += 1
message.show()
if status_message:
self._last_msg_sender = None
def __init__(self):
BaseBuddy.__init__(self)
client = gconf.client_get_default()
self.props.nick = get_nick_name()
self.props.color = get_color().to_string()
def draw_result_screen(self):
"""RENAME to draw_feedback_screen"""
# Section for stopwatch
self.stopwatch = Timer()
self.stopwatch_label = gtk.Label("00:00")
self.stopwatch_label.modify_font(pango.FontDescription("sans 16"))
self.table_with_start.attach(self.stopwatch_label, 3, 5, 12, 13)
# Section for nickname
self.name = profile.get_nick_name()
self.name_label = gtk.Label(self.name)
self.name_label.modify_font(pango.FontDescription("sans 16"))
self.table_with_start.attach(self.name_label, 0, 6, 13, 14)
# Section for progress bar
self.progressbar = gtk.ProgressBar(adjustment=None)
# Color for progress bar
style = self.progressbar.get_style()
style.bg[gtk.STATE_PRELIGHT] = gtk.gdk.color_parse("green")
self.progressbar.set_style (style)
self.progressbar.set_fraction(0)
self.table_with_start.attach(self.progressbar, 0, 6, 8, 9)
# Labels for progress bar
self.progress0 = gtk.Label("0")
self.progress0.modify_font(pango.FontDescription("sans 16"))
self.table_with_start.attach(self.progress0, 0, 1, 9, 10 )
# Labels for status update
self.correct_count = 0
self.correct_counter = gtk.Label(str(self.correct_count))
self.correct_counter.modify_font(pango.FontDescription("sans 16"))
# Ugly code for label color
attr = pango.AttrList()
fg_color = pango.AttrForeground(0, 65535, 0, 0, 6)
attr.insert(fg_color)
self.correct_counter.set_attributes(attr)
self.table_with_start.attach(self.correct_counter, 2, 4, 9, 10 )
self.false_count = 0
self.false_counter = gtk.Label(str(self.false_count))
self.false_counter.modify_font(pango.FontDescription("sans 16"))
# Ugly code for label color
attr = pango.AttrList()
fg_color = pango.AttrForeground(0, 0, 65535, 0, 6)
attr.insert(fg_color)
self.false_counter.set_attributes(attr)
self.table_with_start.attach(self.false_counter, 2, 4, 10, 11 )
self.stopwatch_label.show()
gobject.timeout_add(1000, self.update_time)
self.name_label.show()
self.progressbar.show()
self.progress0.show()
self.correct_counter.show()
self.false_counter.show()
self.total_calcs = self._ex.count()
self.progress_total = gtk.Label(str(self.total_calcs))
self.progress_total.modify_font(pango.FontDescription("sans 16"))
self.table_with_start.attach(self.progress_total, 5, 6, 9, 10 )
self.progress_total.show()
def __init__(self):
BaseBuddy.__init__(self)
client = gconf.client_get_default()
self.props.nick = get_nick_name()
self.props.color = get_color().to_string()
def initialize_display(self):
"""Set up the Arithmetic activity."""
self._logger = logging.getLogger('arithmetic-activity')
self.starttime = 0
self.endtime = 0
self.secondsleft = ""
self.question = ""
self.answer = ""
self.cloud.scoreboard = groupthink.CausalDict(
value_translator=score_codec)
self.scoreboard = self.cloud.scoreboard
self.mynickname = profile.get_nick_name()
self.scoreboard[self.mynickname] = ImmutableScore()
self._question_index = 0
self._puzzle_hashes = set()
self._puzzle_code = {}
self._active_mode_hashes = set()
# Main layout
vbox = gtk.VBox()
# Set a startpoint for a shared seed
self.cloud.startpoint = groupthink.HighScore(self.timer.time(), 0)
# Scoreboard
scorebox = gtk.VBox()
self.model = gtk.TreeStore(
gobject.TYPE_STRING, # name
gobject.TYPE_INT, # last round score
gobject.TYPE_INT, # total score
gobject.TYPE_FLOAT) # time for last question
self.treeview = treeview = gtk.TreeView(self.model)
cellrenderer = gtk.CellRendererText()
col1 = gtk.TreeViewColumn(_("Name"), cellrenderer, text=0)
col2 = gtk.TreeViewColumn(_("Round score"), cellrenderer, text=1)
col3 = gtk.TreeViewColumn(_("Total score"), cellrenderer, text=2)
col4 = gtk.TreeViewColumn(_("Time for answering last question"),
cellrenderer,
text=3)
treeview.append_column(col1)
treeview.append_column(col2)
treeview.append_column(col3)
treeview.append_column(col4)
my_score = self.scoreboard[self.mynickname]
self.olditer = self.model.insert_before(None, None)
self.model.set_value(self.olditer, 0, self.mynickname)
self.model.set_value(self.olditer, 1, my_score.last_score)
self.model.set_value(self.olditer, 2, my_score.cumulative_score)
self.model.set_value(self.olditer, 3, my_score.last_time)
treeview.expand_all()
scorebox.pack_start(treeview)
# Horizontal fields
difficultybox = gtk.HBox()
periodbox = gtk.HBox()
toprowbox = gtk.HBox()
modebox = gtk.HBox()
self.inner_modebox = gtk.HBox()
questionbox = gtk.HBox()
answerbox = gtk.HBox()
decisionbox = gtk.HBox()
lastroundbox = gtk.HBox()
bottomrowbox = gtk.HBox()
countdownbox = gtk.HBox()
# Labels
difficultylabel = gtk.Label(_("Difficulty: "))
periodlabel = gtk.Label(_("Period: "))
periodunitslabel = gtk.Label(" sec ")
modelabel = gtk.Label(_("Puzzles: "))
questionlabel = gtk.Label(_("Question: "))
answerlabel = gtk.Label(_("Answer: "))
decisionlabel = gtk.Label(_("You were: "))
lastroundlabel = gtk.Label(_("Last round: "))
self.lastanswerlabel = gtk.Label("")
staticcountdownlabel = gtk.Label(_("Time until next question: "))
self.countdownlabel = gtk.Label("")
# ToggleButtons for difficulty
self.cloud.easytoggle = groupthink.gtk_tools.SharedToggleButton("< 10")
self.cloud.mediumtoggle = groupthink.gtk_tools.SharedToggleButton(
"< 20")
self.cloud.hardtoggle = groupthink.gtk_tools.SharedToggleButton("< 50")
self.cloud.easytoggle.set_active(False)
self.cloud.mediumtoggle.set_active(False)
self.cloud.hardtoggle.set_active(False)
self.cloud.easytoggle.connect("toggled", self.easy_cb)
self.cloud.mediumtoggle.connect("toggled", self.medium_cb)
self.cloud.hardtoggle.connect("toggled", self.hard_cb)
# Entry for puzzle period
self.cloud.periodentry = groupthink.gtk_tools.RecentEntry(max=2)
self.cloud.periodentry.modify_font(pango.FontDescription("Mono 14"))
self.cloud.periodentry.set_text(str(self.period))
self.cloud.periodentry.set_width_chars(2)
self.cloud.periodentry.connect("changed", self._period_cb)
# Puzzle generators
self.cloud.puzzles = groupthink.AddOnlySet()
self.cloud.puzzles.register_listener(self.new_puzzles_cb)
# Text entry box for question
self.questionentry = gtk.TextView()
self.questionentry.modify_font(pango.FontDescription("Mono 14"))
self.questionentry.set_property("editable", False)
# Text entry box for answer
self.answerentry = gtk.Entry(max=50)
self.answerentry.modify_font(pango.FontDescription("Sans 14"))
self.answerentry.connect("activate", self.answer_cb)
# Whether the user was correct
self.decisionentry = gtk.Entry(max=50)
self.decisionentry.modify_font(pango.FontDescription("Sans 14"))
self.decisionentry.set_property("editable", False)
# Packing
difficultybox.pack_start(difficultylabel, expand=False)
difficultybox.pack_start(self.cloud.easytoggle, expand=False)
difficultybox.pack_start(self.cloud.mediumtoggle, expand=False)
difficultybox.pack_start(self.cloud.hardtoggle, expand=False)
periodbox.pack_start(periodlabel, expand=False)
periodbox.pack_start(self.cloud.periodentry, expand=False)
periodbox.pack_start(periodunitslabel, expand=False)
toprowbox.pack_start(difficultybox, expand=False)
toprowbox.pack_end(periodbox, expand=False)
questionbox.pack_start(questionlabel, expand=False)
questionbox.pack_start(self.questionentry)
modebox.pack_start(modelabel, expand=False)
modebox.pack_start(self.inner_modebox)
answerbox.pack_start(answerlabel, expand=False)
answerbox.pack_start(self.answerentry)
decisionbox.pack_start(decisionlabel, expand=False)
decisionbox.pack_start(self.decisionentry)
lastroundbox.pack_start(lastroundlabel, expand=False)
lastroundbox.pack_start(self.lastanswerlabel, expand=False)
countdownbox.pack_start(staticcountdownlabel, expand=False)
countdownbox.pack_start(self.countdownlabel, expand=False)
bottomrowbox.pack_start(countdownbox)
bottomrowbox.pack_end(lastroundbox)
vbox.pack_start(toprowbox, expand=False)
vbox.pack_start(modebox, expand=False)
vbox.pack_start(questionbox, expand=False)
vbox.pack_start(answerbox, expand=False)
vbox.pack_start(decisionbox, expand=False)
vbox.pack_start(countdownbox, expand=False)
vbox.pack_start(bottomrowbox, expand=False)
vbox.pack_start(scorebox)
# Set defaults for questions.
self.setup_puzzles()
self.cloud.easytoggle.set_active(True)
# Make a new question.
self.generate_new_question()
self.start_question()
self.start_countdown()
self.answerentry.grab_focus()
self.lastanswerlabel.set_markup("")
return vbox
def get_nick_from_sugar(self):
''' Returns nick from Sugar '''
return profile.get_nick_name()
class SimCityActivity(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.set_title(_('SimCity Activity'))
self.connect('destroy', self._destroy_cb)
self.connect('focus-in-event', self._focus_in_cb)
self.connect('focus-out-event', self._focus_out_cb)
signal.signal(signal.SIGCHLD, self._sigchild_handler)
self._bundle_path = get_bundle_path()
if False:
# FIXME: Plug SimCity's window into a gtk socket.
# Doesn't work yet, but it would be cool if it did.
socket = gtk.Socket()
try:
self.set_canvas(socket)
except AttributeError:
self.add(socket)
socket.show()
socket.connect('plug-added', self._plug_added_cb)
socket.connect('plug-removed', self._plug_removed_cb)
win = socket.get_id()
command = os.path.join(self._bundle_path, 'SimCity')
args = [
command,
#'-R', str(win), # Set root window to socket window id
'-t', # Interactive tty mode, so we can send it commands.
]
logging.debug("CWD: " + self._bundle_path)
logging.debug("SIMCITY ARGS: " + repr(args))
self._process = subprocess.Popen(
args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
close_fds=True,
cwd=self._bundle_path,
preexec_fn=lambda: os.chdir(self._bundle_path))
logging.debug("STARTING THREAD... " +
str(self._stdout_thread_function))
t = None
try:
t = thread.start_new(self._stdout_thread_function, ())
except Exception, e:
logging.debug("EXCEPTION " + str(e))
self._stdout_thread = t
logging.debug("STARTED THREAD. " + str(t))
uri = handle.uri or ''
logging.debug("SIMCITYACTIVITY SUGARSTARTUP URI " + repr(uri))
self.send_process('SugarStartUp "' + QuoteTCL(uri) + '"\n')
nick = profile.get_nick_name() or ''
logging.debug("SIMCITYACTIVITY SUGARNICKNAME NICK " + repr(nick))
self.send_process('SugarNickName "' + QuoteTCL(nick) + '"\n')
#logging.debug("started SimCity, pid " + repr(self._pid))
ps = presenceservice.get_instance()
for buddy in ps.get_buddies():
self._buddy_appeared_cb(ps, buddy)
ps.connect("buddy-appeared", self._buddy_appeared_cb)
ps.connect("buddy-disappeared", self._buddy_disappeared_cb)
def __init__(self):
BaseBuddy.__init__(self)
self.props.nick = get_nick_name()
self.props.color = get_color().to_string()
def _playback_recording_cb(self, button=None, nick=profile.get_nick_name()):
''' Play back current recording '''
_logger.debug('Playback current recording from %s...' % (nick))
if nick in self._audio_recordings:
play_audio_from_file(self._audio_recordings[nick])
return
