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 _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 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