def _comment_activate_cb(self, entry): text = entry.props.text if 'comments' not in self._reflection.data: self._reflection.data['comments'] = [] data = { 'nick': profile.get_nick_name(), 'color': self._reflection.activity.fg_color.get_html(), 'comment': text } self._reflection.data['comments'].append(data) self.add_new_comment(data) # Send the comment if self._reflection.activity.sharing: send_data = data.copy() send_data["obj_id"] = self._reflection.data["obj_id"] self._reflection.activity.send_event(COMMENT_CMD, send_data) entry.set_text('') # Update journal entry dsobj = datastore.get(self._reflection.data['obj_id']) if 'comments' in dsobj.metadata: data = json.loads(dsobj.metadata['comments']) else: data = [] data.append({ 'from': profile.get_nick_name(), 'message': text, 'icon-color': profile.get_color().to_string() }) dsobj.metadata['comments'] = json.dumps(data) datastore.write(dsobj, update_mtime=False, reply_handler=self.datastore_write_cb, error_handler=self.datastore_write_error_cb)
def _comment_activate_cb(self, entry): text = entry.props.text if not "comments" in self._reflection.data: self._reflection.data["comments"] = [] data = { "nick": profile.get_nick_name(), "color": self._reflection.activity.fg_color.get_html(), "comment": text, } self._reflection.data["comments"].append(data) self.add_new_comment(data) # Send the comment if self._reflection.activity.sharing: self._reflection.activity.send_event( "%s|%s|%s|%s|%s" % (COMMENT_CMD, self._reflection.data["obj_id"], data["nick"], data["color"], data["comment"]) ) entry.set_text("") # Update journal entry dsobj = datastore.get(self._reflection.data["obj_id"]) if "comments" in dsobj.metadata: data = json.loads(dsobj.metadata["comments"]) else: data = [] data.append({"from": profile.get_nick_name(), "message": text, "icon-color": profile.get_color().to_string()}) dsobj.metadata["comments"] = json.dumps(data) datastore.write( dsobj, update_mtime=False, reply_handler=self.datastore_write_cb, error_handler=self.datastore_write_error_cb, )
def _comment_activate_cb(self, entry): text = entry.props.text if not 'comments' in self._reflection.data: self._reflection.data['comments'] = [] data = {'nick': profile.get_nick_name(), 'color': self._reflection.activity.fg_color.get_html(), 'comment': text} self._reflection.data['comments'].append(data) self.add_new_comment(data) # Send the comment if self._reflection.activity.sharing: send_data = data.copy() send_data["obj_id"] = self._reflection.data["obj_id"] self._reflection.activity.send_event(COMMENT_CMD, send_data) entry.set_text('') # Update journal entry dsobj = datastore.get(self._reflection.data['obj_id']) if 'comments' in dsobj.metadata: data = json.loads(dsobj.metadata['comments']) else: data = [] data.append({'from': profile.get_nick_name(), 'message': text, 'icon-color': profile.get_color().to_string()}) dsobj.metadata['comments'] = json.dumps(data) datastore.write(dsobj, update_mtime=False, reply_handler=self.datastore_write_cb, error_handler=self.datastore_write_error_cb)
def __start_teacher_cb(self, button=None): if self._service is None: # get a free port sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) sock.bind(('', 0)) sock.listen(socket.SOMAXCONN) _ipaddr, self.port = sock.getsockname() sock.shutdown(socket.SHUT_RDWR) logging.error('Using port %d', self.port) # puvblish the server direction self._service = ZeroconfService(name="Teacher", port=self.port, text=profile.get_nick_name()) logging.error('Publish teacher zeroconf service') self._service.publish() # start the http server httpd = MyHTTPServer(('', self.port), lambda *args: TeacherRequestHandler( self._show_received_student_info, *args)) from threading import Thread self._server = Thread(target=httpd.serve_forever) self._server.setDaemon(True) self._server.start() logging.debug("After start server") else: logging.error('Unpublish teacher zeroconf service') self._service.unpublish() self._service = None self._server.stop()
def __init__(self, handle): """ Initialize the toolbars and the game board """ super(FlipActivity, 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() self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, colors=self.colors) self.connect('shared', self._shared_cb) self.connect('joined', self._joined_cb) self._collab = CollabWrapper(self) self._collab.connect('message', self._message_cb) self._collab.connect('joined', self._joined_cb) self._collab.setup() if 'dotlist' in self.metadata: self._restore() else: self._game.new_game()
def __init__(self, handle): """ Initialize the toolbars and the game board """ super(RecallActivity, self).__init__(handle) self.path = activity.get_bundle_path() 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._restoring = False self._setup_toolbars(True) # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), \ Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, path=self.path, colors=self.colors) self._setup_collab() if 'dotlist' in self.metadata: self._restore() else: self._game.new_game()
def default_nicks(): try: nicks = [conf.get('nick')] + conf.get('altnicks', []) if not nicks[0]: # We're going to generate a nick based on the user's nick name # and their public key. from sugar3 import profile import hashlib user_name = profile.get_nick_name() pubkey = profile.get_pubkey() m = hashlib.sha1() m.update(pubkey) hexhash = m.hexdigest() # Okay. Get all of the alphabetic bits of the username: user_name_letters = "".join([x for x in user_name if x.isalpha()]) # If that came up with nothing, make it 'XO'. Also, shorten it # if it's more than 11 characters (as we need 5 for - and the # hash). if len(user_name_letters) == 0: user_name_letters = "XO" if len(user_name_letters) > 11: user_name_letters = user_name_letters[0:11] # Finally, generate a nick by using those letters plus the first # four hash bits of the user's public key. user_nick = user_name_letters + "-" + hexhash[0:4] nicks = [user_nick] except: nicks = ["purk"] return nicks
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) if self.ENABLE_AUTO_MODE: auto_player2 = SimpleAutoPlayer(self, 1) auto_player2.set_pieces(self.take_pieces(7)) auto_player2.pieces_position = self.table.second_player_position self.players.append(auto_player2) else: for n in range(1, numPlayers): 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() self._actual_player = 0
def _on_close(self, ws): self._file.close() self.send_event(CLOSE_CMD, { "nick": profile.get_nick_name(), "chunk": self._chunk }) GObject.idle_add(self.emit, 'uploaded', True)
def __init__(self): BaseBuddyModel.__init__(self) self.props.nick = profile.get_nick_name() self.props.color = profile.get_color() self.props.key = profile.get_profile().pubkey self.connect('notify::nick', self.__property_changed_cb) self.connect('notify::color', self.__property_changed_cb) bus = dbus.SessionBus() bus.add_signal_receiver(self.__name_owner_changed_cb, signal_name='NameOwnerChanged', dbus_interface='org.freedesktop.DBus') bus_object = bus.get_object(dbus.BUS_DAEMON_NAME, dbus.BUS_DAEMON_PATH) for service in bus_object.ListNames( dbus_interface=dbus.BUS_DAEMON_IFACE): if service.startswith(CONNECTION + '.'): path = '/%s' % service.replace('.', '/') Connection(service, path, bus, ready_handler=self.__connection_ready_cb)
def __init__(self, handle): """ Initialize the toolbars and the game board """ super(RecallActivity, self).__init__(handle) self.path = activity.get_bundle_path() 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._restoring = False self._setup_toolbars(True) self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, path=self.path, colors=self.colors) self._setup_presence_service() if "dotlist" 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() self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), 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 yupana """ activity.Activity.__init__(self, handle) self.nick = profile.get_nick_name() self._reload_custom = False if profile.get_color() is not None: self.colors = profile.get_color().to_string().split(',') else: self.colors = ['#A0FFA0', '#FF8080'] self._setup_toolbars() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), \ Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._yupana = Yupana(canvas, parent=self, colors=self.colors) self._setup_collab() if 'dotlist' in self.metadata: self._restore() else: self._yupana.new_yupana(mode='ten') self._make_custom_toolbar() if self._reload_custom: self._custom_cb()
def __init__(self, handle): """ Initialize the toolbars and the game board """ try: super(XOEditorActivity, self).__init__(handle) except dbus.exceptions.DBusException as e: _logger.error(str(e)) 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.level = 0 self._setup_toolbars(_have_toolbox) # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, mycolors=self.colors) # Read the dot positions from the Journal for i in range(len(colors)): if 'x%d' % (i) in self.metadata and 'y%d' % (i) in self.metadata: self._game.move_dot(i, int(self.metadata['x%d' % (i)]), int(self.metadata['y%d' % (i)])) if 'xox' in self.metadata and 'xoy' in self.metadata: self._game.move_xo_man(int(self.metadata['xox']), int(self.metadata['xoy']))
def _start_all_cb(self, widget): win = str(self.socket.get_id()) if (win.endswith("L")): # L of "Long" win = win[:-1] # Run game command = os.path.join(self._bundle_path, "res/sim") #'SugarCity') args = [ command, #'-R', win, # Set root window to socket window id '-t', # Interactive tty mode, so we can send it commands. ] 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)) self._stdout_thread = thread.start_new(self._stdout_thread_function, ()) uri = self._handle.uri or '' self.send_process('SugarStartUp "' + QuoteTCL(uri) + '"\n') nick = profile.get_nick_name() or '' self.send_process('SugarNickName "' + QuoteTCL(nick) + '"\n')
def _share_stats(self): stats = self._generate_stats() nick = profile.get_nick_name() colors = profile.get_color().to_string() self._send_event('S:%s' % (json.dumps([nick, colors, stats]))) self._restore_cursor() self._create_chart(stats)
def __init__(self, handle): sugar3.activity.activity.Activity.__init__(self, handle) self.set_title(_("Typing Turtle")) self.max_participants = 1 self.build_toolbox() self.screens = [] self.screenbox = Gtk.VBox() self.nick = profile.get_nick_name() self.wordlist = [] # All data which is saved in the Journal entry is placed in this dictionary. self.data = {'motd': 'welcome', 'history': [], 'medals': {}} # This calls the read_file method when restoring from the Journal. self.set_canvas(self.screenbox) # Start with the main screen. self.mainscreen = mainscreen.MainScreen(self) self.push_screen(self.mainscreen) self.show_all() self.editorbtn = sugar3.graphics.toolbutton.ToolButton('view-source') self.editorbtn.set_tooltip(_("Edit Lessons")) self.editorbtn.connect('clicked', self.editor_clicked_cb) activity_toolbar = self.toolbar_box.toolbar activity_toolbar.insert(self.editorbtn, 1) self.editorbtn.show_all()
def _create_new_poll(self): # Reset vote data to 0 self._poll = Poll(activity=self, author=profile.get_nick_name(), active=False) self.current_vote = None self.set_canvas(NewPollCanvas(self._poll))
class Instance: key = profile.get_pubkey() # joyride ... # keyHash = util.sha_data(key) # 8.2... # keyHash = util._sha_data(key) # keyHashPrintable = util.printable_hash(keyHash) nick_name = profile.get_nick_name() color_fill = Color() color_fill.init_hex(profile.get_color().get_fill_color()) color_stroke = Color() color_stroke.init_hex(profile.get_color().get_stroke_color()) instance_id = None instance_path = None data_path = None def __init__(self, ca): self.__class__.instance_id = ca._activity_id self.__class__.instance_path = os.path.join(ca.get_activity_root(), "instance") recreate_tmp() self.__class__.data_path = os.path.join(ca.get_activity_root(), "data") recreate_data()
def __init__(self, handle): """ Initialize the toolbars and the game board """ try: super(FlipActivity, self).__init__(handle) except dbus.exceptions.DBusException as e: _logger.error(str(e)) 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() self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), 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() if 'dotlist' in self.metadata: self._restore() else: self._game.new_game()
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.max_participants = 4 # sharing self._playing = True 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 self._current_ball = 'soccerball' self._toolbar_was_expanded = False # Initialize the canvas self._bounce_window = Bounce(canvas, activity.get_bundle_path(), self) Gdk.Screen.get_default().connect('size-changed', self._configure_cb) # Restore any custom fractions if custom is not None: fractions = custom.split(',') for f in fractions: self._bounce_window.add_fraction(f) if self.shared_activity: # We're joining if not self.get_shared(): xocolors = XoColor(profile.get_color().to_string()) share_icon = Icon(icon_name='zoom-neighborhood', xo_color=xocolors) self._joined_alert = NotifyAlert() self._joined_alert.props.icon = share_icon self._joined_alert.props.title = _('Please wait') self._joined_alert.props.msg = _('Starting connection...') self._joined_alert.connect('response', self._alert_cancel_cb) self.add_alert(self._joined_alert) self._label.set_label(_('Wait for the sharer to start.')) # Wait for joined signal self.connect("joined", self._joined_cb) self._setup_sharing()
def _added_bookmark_cb(self, bookmarkmanager, page, title): logging.debug('Bookmark added page %d', page) title = _('%(title)s (Page %(number)d)') % \ ({'title': title, 'number': page}) color = profile.get_color().to_string() owner = profile.get_nick_name() thumb = self._get_screenshot() self._add_link_totray(page, thumb, color, title, owner, 1) bookmarkmanager.add_bookmark_preview(page - 1, thumb)
def _get_identifier(): path = None if os.path.exists(SN_PATH_X86): path = SN_PATH_X86 elif os.path.exists(SN_PATH_ARM): path = SN_PATH_ARM if path is not None: with open(path, 'r') as file: return file.read().rstrip('\0\n') return profile.get_nick_name()
def add_bookmark(self, page): bookmark_title = (_("%s's bookmark") % profile.get_nick_name()) bookmark_content = (_("Bookmark for page %d") % (int(page) + 1)) dialog = BookmarkAddDialog( parent_xid=self.get_toplevel().get_window(), dialog_title=_("Add notes for bookmark: "), bookmark_title=bookmark_title, bookmark_content=bookmark_content, page=page, sidebarinstance=self) dialog.show_all()
def add_bookmark(self, page): bookmark_title = (_("%s's bookmark") % profile.get_nick_name()) bookmark_content = (_("Bookmark for page %d") % (int(page) + 1)) dialog = BookmarkAddDialog(parent_xid=self.get_toplevel().get_window(), dialog_title=_("Add notes for bookmark: "), bookmark_title=bookmark_title, bookmark_content=bookmark_content, page=page, sidebarinstance=self) dialog.show_all()
def register_laptop(url=_REGISTER_URL): profile = get_profile() if _have_ofw_tree(): sn = _read_mfg_data(os.path.join(_OFW_TREE, _MFG_SN)) uuid_ = _read_mfg_data(os.path.join(_OFW_TREE, _MFG_UUID)) elif _have_proc_device_tree(): sn = _read_mfg_data(os.path.join(_PROC_TREE, _MFG_SN)) uuid_ = _read_mfg_data(os.path.join(_PROC_TREE, _MFG_UUID)) else: sn = _generate_serial_number() uuid_ = str(uuid.uuid1()) sn = sn or 'SHF00000000' uuid_ = uuid_ or '00000000-0000-0000-0000-000000000000' nick = get_nick_name() settings = Gio.Settings('org.sugarlabs.collaboration') jabber_server = settings.get_string('jabber-server') _store_identifiers(sn, uuid_, jabber_server) if jabber_server: url = 'http://' + jabber_server + ':8080/' if sys.hexversion < 0x2070000: server = xmlrpclib.ServerProxy(url, _TimeoutTransport()) else: socket.setdefaulttimeout(_REGISTER_TIMEOUT) server = xmlrpclib.ServerProxy(url) try: data = server.register(sn, nick, uuid_, profile.pubkey) except (xmlrpclib.Error, TypeError, socket.error): logging.exception('Registration: cannot connect to server') raise RegisterError(_('Cannot connect to the server.')) finally: socket.setdefaulttimeout(None) if data['success'] != 'OK': logging.error('Registration: server could not complete request: %s', data['error']) raise RegisterError(_('The server could not complete the request.')) settings.set_string('jabber-server', data['jabberserver']) settings = Gio.Settings('org.sugarlabs') settings.set_string('backup-url', data['backupurl']) # DEPRECATED from gi.repository import GConf client = GConf.Client.get_default() client.set_string( '/desktop/sugar/collaboration/jabber_server', data['jabberserver']) client.set_string('/desktop/sugar/backup_url', data['backupurl']) return True
def _do_finish(self): self._tarfile.close() # Add metadata to the file created metadata = model.get(self._checkpoint) metadata['description'] = _('Backup from user %s') % \ profile.get_nick_name() metadata['icon_color'] = profile.get_color().to_string() metadata['uncompressed_size'] = self._uncompressed_size metadata['mime_type'] = 'application/vnd.olpc-journal-backup' model.write(metadata, self._checkpoint) self.emit('finished')
def do_GET(self): logging.error('do_GET path: %s', self.path) student_data = parse_qs(urlparse(self.path).query) GObject.idle_add(self._received_data_cb, student_data) self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() # Send the html message teacher_data = {'nick_name': profile.get_nick_name()} self.wfile.write(json.dumps(teacher_data)) return
def _service_resolved(self, *args): logging.error('service resolved name: %s address %s port %s more %s', args[2], args[7], args[8], args) nick_name = profile.get_nick_name() teacher_ip = args[7] teacher_port = args[8] teacher_xo_id = args[5] for widget in self._vbox.get_children(): self._vbox.remove(widget) label = Gtk.Label() self._vbox.add(label) text = ("My name is %s \n" % nick_name) label.set_text(text) label = Gtk.Label() self._vbox.add(label) text = ("Teacher ip: %s \n" % teacher_ip) label.set_text(text) label = Gtk.Label() self._vbox.add(label) text = ("Teacher port: %s \n" % teacher_port) label.set_text(text) label = Gtk.Label() self._vbox.add(label) text = ("Teacher xo id: %s \n" % teacher_xo_id) label.set_text(text) self._vbox.show_all() # sent my information to the teacher student_data = {} student_data['nick_name'] = nick_name student_data['age'] = self._age student_data['gender'] = self._gender url_values = urllib.urlencode(student_data) response = urllib2.urlopen( 'http://%s:%d/student_info?%s' % (teacher_ip, teacher_port, url_values)) json_data = response.read() teacher_data = json.loads(json_data) label = Gtk.Label() self._vbox.add(label) text = ("Teacher name: %s \n" % teacher_data['nick_name']) label.set_text(text) label.show()
def get_user_data(): """ Create this structure: {"from": "Walter Bender", "icon": ["#FFC169", "#FF2B34"]} used to identify the owner of a shared object is compatible with how the comments are saved in http://wiki.sugarlabs.org/go/Features/Comment_box_in_journal_detail_view """ xo_color = profile.get_color() data = {} data['from'] = profile.get_nick_name() data['icon'] = [xo_color.get_stroke_color(), xo_color.get_fill_color()] return data
def _add_link(self): ''' take screenshot and add link info to the model ''' browser = self._tabbed_view.props.current_browser ui_uri = browser.get_uri() for link in self.model.data['shared_links']: if link['hash'] == sha1(ui_uri).hexdigest(): _logger.debug('_add_link: link exist already a=%s b=%s', link['hash'], sha1(ui_uri).hexdigest()) return buf = self._get_screenshot() timestamp = time.time() self.model.add_link(ui_uri, browser.props.title, buf, profile.get_nick_name(), profile.get_color().to_string(), timestamp) if self.messenger is not None: self.messenger._add_link(ui_uri, browser.props.title, profile.get_color().to_string(), profile.get_nick_name(), base64.b64encode(buf), timestamp)
def _service_resolved(self, *args): logging.error('service resolved name: %s address %s port %s more %s', args[2], args[7], args[8], args) nick_name = profile.get_nick_name() teacher_ip = args[7] teacher_port = args[8] teacher_xo_id = args[5] for widget in self._vbox.get_children(): self._vbox.remove(widget) label = Gtk.Label() self._vbox.add(label) text = ("My name is %s \n" % nick_name) label.set_text(text) label = Gtk.Label() self._vbox.add(label) text = ("Teacher ip: %s \n" % teacher_ip) label.set_text(text) label = Gtk.Label() self._vbox.add(label) text = ("Teacher port: %s \n" % teacher_port) label.set_text(text) label = Gtk.Label() self._vbox.add(label) text = ("Teacher xo id: %s \n" % teacher_xo_id) label.set_text(text) self._vbox.show_all() # sent my information to the teacher student_data = {} student_data['nick_name'] = nick_name student_data['age'] = self._age student_data['gender'] = self._gender url_values = urllib.urlencode(student_data) response = urllib2.urlopen('http://%s:%d/student_info?%s' % (teacher_ip, teacher_port, url_values)) json_data = response.read() teacher_data = json.loads(json_data) label = Gtk.Label() self._vbox.add(label) text = ("Teacher name: %s \n" % teacher_data['nick_name']) label.set_text(text) label.show()
def load_brain(): global _kernel global _kernel_voice is_first_session = _kernel is None try: if voice.friendlyname in BOTS: brain = BOTS[voice.friendlyname] brain_name = BOTS[voice.friendlyname]['name'] else: brain = BOTS[_('English')] brain_name = BOTS[_('English')]['name'] logger.debug('Load bot: %s' % brain) kernel = aiml.Kernel() if brain['brain'] is None: warning = _("Sorry, there is no free memory to load my " \ "brain. Close other activities and try once more.") activity.face.say_notification(warning) return kernel.loadBrain(brain['brain']) for name, value in brain['predicates'].items(): kernel.setBotPredicate(name, value) if _kernel is not None: del _kernel _kernel = None import gc gc.collect() _kernel = kernel _kernel_voice = voice finally: activity.get_window().set_cursor(old_cursor) if is_first_session: _kernel.respond(_('my name is %s') % (profile.get_nick_name())) _kernel.respond(_('I am %d years old') % (_get_age())) hello = \ _("Hello, I'm a robot \"%s\". Please ask me any question.") \ % brain_name if sorry: hello += ' ' + sorry activity.face.say_notification(hello) elif sorry: activity.face.say_notification(sorry)
def load_brain(): global _kernel global _kernel_voice is_first_session = _kernel is None try: if voice.friendlyname in BOTS: brain = BOTS[voice.friendlyname] brain_name = BOTS[voice.friendlyname]['name'] else: brain = BOTS[_('English')] brain_name = BOTS[_('English')]['name'] logger.debug('Load bot: %s' % brain) kernel = Kernel() if brain['brain'] is None: warning = _("Sorry, there is no free memory to load my " "brain. Close other activities and try once more.") activity.face.say_notification(warning) return kernel.loadBrain(brain['brain']) for name, value in list(brain['predicates'].items()): kernel.setBotPredicate(name, value) if _kernel is not None: del _kernel _kernel = None import gc gc.collect() _kernel = kernel _kernel_voice = voice finally: activity.get_window().set_cursor(old_cursor) if is_first_session: _kernel.respond(_('my name is %s') % (profile.get_nick_name())) _kernel.respond(_('I am %d years old') % (_get_age())) hello = \ _("Hello, I'm a robot \"%s\". Please ask me any question.") \ % brain_name if sorry: hello += ' ' + sorry activity.face.say_notification(hello) elif sorry: activity.face.say_notification(sorry)
def _add_link(self): ''' take screenshot and add link info to the model ''' browser = self._tabbed_view.props.current_browser ui_uri = browser.get_uri() if self.model.has_link(ui_uri): return buf = b64encode(self._get_screenshot()) timestamp = time.time() args = (ui_uri, browser.props.title, buf, profile.get_nick_name(), profile.get_color().to_string(), timestamp) self.model.add_link(*args, by_me=True) self._collab.post({'type': 'add_link', 'args': args})
def _share_favorites(self, data=None): logging.debug('SHARE FAVORITES %s' % (str(self.initiating))) if self.initiating: favorites = self._read_favorites() self._send_event('F:%s' % (json.dumps(favorites))) data_array = json.loads(data) nick = data_array[0] colors = data_array[1].encode('ascii', 'replace') icon = self._create_icon(colors) self._add_buddy(icon, nick) else: favorites_data = self._read_favorites() self._unset_favorites(favorites_data) nick = profile.get_nick_name() colors = profile.get_color().to_string() self._send_event('f:%s' % (json.dumps([nick, colors])))
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 __init__(self, handle): """ Initialize the toolbars and the game board """ activity.Activity.__init__(self, 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.level = 0 self._correct = 0 self._playing = True self._game_over = False self._python_code = None self._setup_toolbars() self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, colors=self.colors) self._sharing = False self._initiating = False self.connect('shared', self._shared_cb) self._collab = CollabWrapper(self) self._collab.connect('message', self._message_cb) self._collab.connect('joined', self._joined_cb) self._collab.setup() if 'level' in self.metadata: self.level = int(self.metadata['level']) self.status.set_label(_('Resuming level %d') % (self.level + 1)) self._game.show_random() else: self._game.new_game()
def __init__(self, handle): """ Initialize the toolbars and the game board """ try: super(DeductoActivity, self).__init__(handle) except dbus.exceptions.DBusException as e: _logger.error(str(e)) 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.level = 0 self._correct = 0 self._playing = True self._game_over = False self._python_code = None self._setup_toolbars() self._setup_dispatch_table() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, colors=self.colors) self._sharing = False self._initiating = False self._setup_presence_service() if 'level' in self.metadata: self.level = int(self.metadata['level']) self.status.set_label(_('Resuming level %d') % (self.level + 1)) self._game.show_random() else: self._game.new_game()
def __init__(self, filehash): self._filehash = filehash dbpath = _init_db() assert dbpath != None self._conn = sqlite3.connect(dbpath) _init_db_highlights(self._conn) self._conn.text_factory = lambda x: unicode(x, "utf-8", "ignore") self._bookmarks = [] self._populate_bookmarks() self._highlights = {0: []} self._populate_highlights() self._user = profile.get_nick_name() self._color = profile.get_color().to_string()
def __init__(self, filehash): GObject.GObject.__init__(self) self._filehash = filehash dbpath = _init_db() assert dbpath is not None self._conn = sqlite3.connect(dbpath) _init_db_highlights(self._conn) _init_db_previews(self._conn) self._conn.text_factory = lambda x: unicode(x, "utf-8", "ignore") self._bookmarks = [] self._populate_bookmarks() self._highlights = {0: []} self._populate_highlights() self._user = profile.get_nick_name() self._color = profile.get_color().to_string()
def __init__(self, handle): """ Initialize the toolbars and the game board """ super(TurtlePondActivity, 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() # Create a canvas canvas = Gtk.DrawingArea() canvas.set_size_request(Gdk.Screen.width(), \ Gdk.Screen.height()) self.set_canvas(canvas) canvas.show() self.show_all() self._game = Game(canvas, parent=self, colors=self.colors) # TODO: Restore game state from Journal or start new game self._game.new_game()
def __init__(self): BaseBuddyModel.__init__(self) self.props.nick = profile.get_nick_name() self.props.color = profile.get_color() self.props.key = profile.get_profile().pubkey self.connect('notify::nick', self.__property_changed_cb) self.connect('notify::color', self.__property_changed_cb) bus = dbus.SessionBus() bus.add_signal_receiver( self.__name_owner_changed_cb, signal_name='NameOwnerChanged', dbus_interface='org.freedesktop.DBus') bus_object = bus.get_object(dbus.BUS_DAEMON_NAME, dbus.BUS_DAEMON_PATH) for service in bus_object.ListNames( dbus_interface=dbus.BUS_DAEMON_IFACE): if service.startswith(CONNECTION + '.'): path = '/%s' % service.replace('.', '/') Connection(service, path, bus, ready_handler=self.__connection_ready_cb)
def start(self): self.collab.send(JOIN_CMD, {"nick": profile.get_nick_name(), "chunk": self._chunk})
def get_nick(): return profile.get_nick_name()
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.RoundBox() rb.background_color = color_fill rb.border_color = color_stroke rb.tail = tail self._rb_list.append(rb) grid_internal = Gtk.Grid() grid_internal.set_row_spacing(0) grid_internal.set_border_width(style.DEFAULT_PADDING) grid_internal.set_size_request( Gdk.Screen.width() - 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) message.connect('open-on-journal', self.__open_on_journal) self._last_msg_sender = buddy self._last_msg = message grid_internal.attach(message, 0, row, 1, 1) row += 1 align = Gtk.Alignment.new(xalign=0.0, yalign=0.0, xscale=1.0, yscale=1.0) if rb.tail is None: bottom_padding = style.zoom(7) else: bottom_padding = style.zoom(35) 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.attach(rb, 0, self._row_counter, 1, 1) rb.show() self._row_counter += 1 message.show() if status_message: self._last_msg_sender = None
def _on_close(self, ws): self._file.close() self.send_event(CLOSE_CMD, {"nick": profile.get_nick_name(), "chunk": self._chunk}) GObject.idle_add(self.emit, 'uploaded', True)