Ejemplo n.º 1
0
    def set_room_list(self, msg):

        if self.autojoin:
            self.autojoin = False

            if self.joinedrooms:
                room_list = list(self.joinedrooms.keys())
            else:
                room_list = config.sections["server"]["autojoin"]
                if room_list:
                    # Disable tab focusing while joining rooms
                    self.switch_tab = False

                    timer = threading.Timer(4.0, self.enable_tab_switch)
                    timer.name = "ChatroomTabSwitchTimer"
                    timer.daemon = True
                    timer.start()

            for room in room_list:
                if room == 'Public ':
                    self.roomlist.on_join_public_room(None)

                elif isinstance(room, str):
                    self.frame.np.queue.append(slskmessages.JoinRoom(room))

        self.roomlist.set_room_list(msg.rooms, msg.ownedprivaterooms,
                                    msg.otherprivaterooms)

        if config.sections["words"]["roomnames"]:
            self.frame.update_completions()
Ejemplo n.º 2
0
    def on_show_chat_feed(self, *args):

        if self.RoomFeed.get_active():
            self.frame.chatrooms.join_room(slskmessages.JoinRoom("Public "))
            self.frame.np.queue.append(slskmessages.JoinPublicRoom())
            return

        self.frame.np.queue.append(slskmessages.LeavePublicRoom())
        self.frame.chatrooms.leave_room(
            slskmessages.LeaveRoom("Public "))  # Faking protocol msg
Ejemplo n.º 3
0
    def server_login(self):

        join_list = self.joined_rooms

        if not join_list:
            join_list = self.config.sections["server"]["autojoin"]

        for room in join_list:
            if room == "Public ":
                self.request_join_public_room()

            elif isinstance(room, str):
                self.queue.append(slskmessages.JoinRoom(room))

        if self.ui_callback:
            self.ui_callback.server_login()
Ejemplo n.º 4
0
 def on_join_public_room(self, *args):
     self.frame.chatrooms.join_room(slskmessages.JoinRoom("Public "))
     self.frame.np.queue.append(slskmessages.JoinPublicRoom())
Ejemplo n.º 5
0
 def on_popup_join(self, *args):
     self.frame.np.queue.append(slskmessages.JoinRoom(self.popup_room))
Ejemplo n.º 6
0
    def on_enter(self, widget):

        text = widget.get_text()

        if not text:
            widget.set_text("")
            return

        if is_alias(text):
            alias_text = expand_alias(text)

            if not alias_text:
                log.add(_('Alias "%s" returned nothing'), text)
                return

            text = alias_text

        s = text.split(" ", 1)
        cmd = s[0]

        # Remove empty items created by split, if command ended with a space, e.g. '/ctcpversion '
        if len([i for i in s if i]) == 2:
            arg_self = args = s[1]
        else:
            if not self.is_chatroom:
                arg_self = self.entity
            else:
                arg_self = ""

            args = ""

        if cmd[:1] == "/" and cmd[:2] != "//" and cmd + " " not in self.command_list:
            log.add(_("Command %s is not recognized"), text)
            return

        if cmd in ("/alias", "/al"):
            append_line(self.textview, add_alias(args), None, "")

            if config.sections["words"]["aliases"]:
                self.frame.update_completions()

        elif cmd in ("/unalias", "/un"):
            append_line(self.textview, unalias(args), None, "")

            if config.sections["words"]["aliases"]:
                self.frame.update_completions()

        elif cmd in ("/w", "/whois", "/info"):
            if arg_self:
                self.frame.np.userinfo.request_user_info(arg_self)
                self.frame.change_main_page("userinfo")

        elif cmd in ("/b", "/browse"):
            if arg_self:
                self.frame.np.userbrowse.browse_user(arg_self)
                self.frame.change_main_page("userbrowse")

        elif cmd == "/ip":
            if arg_self:
                self.frame.np.request_ip_address(arg_self)

        elif cmd == "/pm":
            if args:
                self.frame.np.privatechats.show_user(args)
                self.frame.change_main_page("private")

        elif cmd in ("/m", "/msg"):
            if args:
                s = args.split(" ", 1)
                user = s[0]
                if len(s) == 2:
                    msg = s[1]
                else:
                    msg = None
                self.frame.np.privatechats.show_user(args)
                self.frame.np.privatechats.send_message(user, msg)
                self.frame.change_main_page("private")

        elif cmd in ("/s", "/search"):
            if args:
                self.frame.SearchMethod.set_active(0)
                self.frame.SearchEntry.set_text(args)
                self.frame.on_search(self.frame.SearchEntry)
                self.frame.change_main_page("search")

        elif cmd in ("/us", "/usearch"):
            s = args.split(" ", 1)
            if len(s) == 2:
                self.frame.SearchMethod.set_active(3)
                self.frame.SearchEntry.set_text(s[1])
                self.frame.UserSearchEntry.set_text(s[0])
                self.frame.on_search(self.frame.SearchEntry)
                self.frame.change_main_page("search")

        elif cmd in ("/rs", "/rsearch"):
            if args:
                self.frame.SearchMethod.set_active(2)
                self.frame.SearchEntry.set_text(args)
                self.frame.on_search(self.frame.SearchEntry)
                self.frame.change_main_page("search")

        elif cmd in ("/bs", "/bsearch"):
            if args:
                self.frame.SearchMethod.set_active(1)
                self.frame.SearchEntry.set_text(args)
                self.frame.on_search(self.frame.SearchEntry)
                self.frame.change_main_page("search")

        elif cmd in ("/j", "/join"):
            if args:
                self.frame.np.queue.append(slskmessages.JoinRoom(args))

        elif cmd in ("/l", "/leave", "/p", "/part"):
            if args:
                self.frame.np.queue.append(slskmessages.LeaveRoom(args))
            else:
                self.frame.np.queue.append(slskmessages.LeaveRoom(self.entity))

        elif cmd in ("/ad", "/add", "/buddy"):
            if args:
                self.frame.np.userlist.add_user(args)

        elif cmd in ("/rem", "/unbuddy"):
            if args:
                self.frame.np.userlist.remove_user(args)

        elif cmd == "/ban":
            if args:
                self.frame.np.network_filter.ban_user(args)

        elif cmd == "/ignore":
            if args:
                self.frame.np.network_filter.ignore_user(args)

        elif cmd == "/ignoreip":
            if args:
                self.frame.np.network_filter.ignore_ip(args)

        elif cmd == "/unban":
            if args:
                self.frame.np.network_filter.unban_user(args)

        elif cmd == "/unignore":
            if args:
                self.frame.np.network_filter.unignore_user(args)

        elif cmd == "/ctcpversion":
            if arg_self:
                self.frame.np.privatechats.show_user(arg_self)
                self.frame.np.privatechats.send_message(
                    arg_self, self.frame.privatechats.CTCP_VERSION, bytestring=True)

        elif cmd in ("/clear", "/cl"):
            self.textview.get_buffer().set_text("")

        elif cmd in ("/a", "/away"):
            self.frame.on_away()

        elif cmd in ("/q", "/quit", "/exit"):
            self.frame.on_quit()
            return  # Avoid gsignal warning

        elif cmd in ("/c", "/close"):
            self.frame.privatechats.users[self.entity].on_close()

        elif cmd == "/now":
            self.frame.np.now_playing.display_now_playing(
                callback=lambda np_message: self.send_message(self.entity, np_message))

        elif cmd == "/rescan":
            # Rescan public shares if needed
            if not config.sections["transfers"]["friendsonly"] and config.sections["transfers"]["shared"]:
                self.frame.on_rescan()

            # Rescan buddy shares if needed
            if config.sections["transfers"]["enablebuddyshares"]:
                self.frame.on_buddy_rescan()

        elif cmd in ("/tick", "/t"):
            self.frame.np.queue.append(slskmessages.RoomTickerSet(self.entity, args))

        elif cmd == "/tickers":
            self.frame.chatrooms.joinedrooms[self.entity].show_tickers()

        elif cmd == "/toggle":
            if args:
                self.frame.np.pluginhandler.toggle_plugin(args)

        elif cmd == "/me":
            self.send_message(self.entity, text)

        elif text[:2] == "//":
            text = text[1:]
            self.send_message(self.entity, text)

        elif cmd[:1] == "/" and self.is_chatroom:
            self.frame.np.pluginhandler.trigger_public_command_event(self.entity, cmd[1:], args)

        elif cmd[:1] == "/" and not self.is_chatroom:
            self.frame.np.pluginhandler.trigger_private_command_event(self.entity, cmd[1:], args)

        else:
            self.send_message(self.entity, text)

        self.entry.set_text("")
Ejemplo n.º 7
0
    def OnEnter(self, widget):

        text = widget.get_text()

        if not text:
            widget.set_text("")
            return

        if is_alias(self.frame.np.config.aliases, text):
            import _thread
            _thread.start_new_thread(self.threadAlias, (text, ))
            widget.set_text("")
            return

        s = text.split(" ", 1)
        cmd = s[0]
        if len(s) == 2 and s[1]:
            realargs = args = s[1]
        else:
            args = self.user
            realargs = ""

        if cmd in ("/alias", "/al"):

            AppendLine(self.ChatScroll,
                       self.frame.np.config.AddAlias(realargs), None, "")
            if self.frame.np.config.sections["words"]["aliases"]:
                self.frame.chatrooms.roomsctrl.UpdateCompletions()
                self.frame.privatechats.UpdateCompletions()

        elif cmd in ("/unalias", "/un"):

            AppendLine(self.ChatScroll, self.frame.np.config.Unalias(realargs),
                       None, "")
            if self.frame.np.config.sections["words"]["aliases"]:
                self.frame.chatrooms.roomsctrl.UpdateCompletions()
                self.frame.privatechats.UpdateCompletions()

        elif cmd in ["/join", "/j"]:
            self.frame.np.queue.put(slskmessages.JoinRoom(args))

        elif cmd in ["/w", "/whois", "/info"]:
            if args:
                self.frame.LocalUserInfoRequest(args)
                self.frame.OnUserInfo(None)

        elif cmd in ["/b", "/browse"]:
            if args:
                self.frame.BrowseUser(args)
                self.frame.OnUserBrowse(None)

        elif cmd == "/ip":
            if args:
                user = args
                if user not in self.frame.np.ip_requested:
                    self.frame.np.ip_requested.append(user)
                self.frame.np.queue.put(slskmessages.GetPeerAddress(user))

        elif cmd == "/pm":
            if realargs:
                self.frame.privatechats.SendMessage(realargs, None, 1)

        elif cmd in ["/m", "/msg"]:
            if realargs:
                s = realargs.split(" ", 1)
                user = s[0]
                if len(s) == 2:
                    msg = s[1]
                else:
                    msg = None

                self.frame.privatechats.SendMessage(user, msg)

        elif cmd in ["/s", "/search"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 0)
                self.frame.OnSearch(None)

        elif cmd in ["/us", "/usearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 3, [self.user])
                self.frame.OnSearch(None)

        elif cmd in ["/rs", "/rsearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 1)
                self.frame.OnSearch(None)

        elif cmd in ["/bs", "/bsearch"]:
            if realargs:
                self.frame.Searches.DoSearch(realargs, 2)
                self.frame.OnSearch(None)

        elif cmd in ["/ad", "/add", "/buddy"]:
            if args:
                self.frame.userlist.AddToList(args)

        elif cmd in ["/rem", "/unbuddy"]:
            if args:
                self.frame.userlist.RemoveFromList(args)

        elif cmd == "/ban":
            if args:
                self.frame.BanUser(args)

        elif cmd == "/ignore":
            if args:
                self.frame.IgnoreUser(args)

        elif cmd == "/ignoreip":
            if args:
                self.frame.IgnoreIP(args)

        elif cmd == "/unban":
            if args:
                self.frame.UnbanUser(args)

        elif cmd == "/unignore":
            if args:
                self.frame.UnignoreUser(args)

        elif cmd == "/ctcpversion":
            if args:
                self.frame.privatechats.SendMessage(args,
                                                    CTCP_VERSION,
                                                    1,
                                                    bytestring=True)

        elif cmd in ["/clear", "/cl"]:
            self.ChatScroll.get_buffer().set_text("")

        elif cmd in ["/a", "/away"]:
            self.frame.OnAway(None)

        elif cmd in ["/q", "/quit", "/exit"]:
            self.frame.OnExit(None)
            return

        elif cmd in ["/c", "/close"]:
            self.OnClose(None)

        elif cmd == "/now":
            self.NowPlayingThread()

        elif cmd == "/rescan":
            self.frame.OnRescan()

        elif cmd[:
                 1] == "/" and self.frame.pluginhandler.TriggerPrivateCommandEvent(
                     self.user, cmd[1:], args):
            pass

        elif cmd and cmd[:1] == "/" and cmd != "/me" and cmd[:2] != "//":
            self.frame.logMessage(_("Command %s is not recognized") % text)
            return

        else:

            if text[:2] == "//":
                text = text[1:]

            if self.chats.connected:
                self.SendMessage(text)
                widget.set_text("")

            return

        widget.set_text("")
Ejemplo n.º 8
0
    def on_enter(self, widget):

        text = widget.get_text()

        if not text:
            widget.set_text("")
            return

        if is_alias(text):
            import _thread
            _thread.start_new_thread(self.thread_alias, (text, ))
            widget.set_text("")
            return

        s = text.split(" ", 1)
        cmd = s[0]
        if len(s) == 2 and s[1]:
            realargs = args = s[1]
        else:
            args = self.user
            realargs = ""

        if cmd in ("/alias", "/al"):

            append_line(self.ChatScroll, add_alias(realargs), None, "")
            if self.frame.np.config.sections["words"]["aliases"]:
                self.frame.chatrooms.update_completions()
                self.frame.privatechats.update_completions()

        elif cmd in ("/unalias", "/un"):

            append_line(self.ChatScroll, unalias(realargs), None, "")
            if self.frame.np.config.sections["words"]["aliases"]:
                self.frame.chatrooms.update_completions()
                self.frame.privatechats.update_completions()

        elif cmd in ["/join", "/j"]:
            self.frame.np.queue.put(slskmessages.JoinRoom(args))

        elif cmd in ["/w", "/whois", "/info"]:
            if args:
                self.frame.local_user_info_request(args)
                self.frame.on_user_info(None)

        elif cmd in ["/b", "/browse"]:
            if args:
                self.frame.browse_user(args)
                self.frame.on_user_browse(None)

        elif cmd == "/ip":
            if args:
                user = args
                self.frame.np.ip_requested.add(user)
                self.frame.np.queue.put(slskmessages.GetPeerAddress(user))

        elif cmd == "/pm":
            if realargs:
                self.frame.privatechats.send_message(realargs, show_user=True)

        elif cmd in ["/m", "/msg"]:
            if realargs:
                s = realargs.split(" ", 1)
                user = s[0]
                if len(s) == 2:
                    msg = s[1]
                else:
                    msg = None

                self.frame.privatechats.send_message(user, msg)

        elif cmd in ["/s", "/search"]:
            if realargs:
                self.frame.searches.do_search(realargs, 0)
                self.frame.on_search(None)

        elif cmd in ["/us", "/usearch"]:
            if realargs:
                self.frame.searches.do_search(realargs, 3, [self.user])
                self.frame.on_search(None)

        elif cmd in ["/rs", "/rsearch"]:
            if realargs:
                self.frame.searches.do_search(realargs, 1)
                self.frame.on_search(None)

        elif cmd in ["/bs", "/bsearch"]:
            if realargs:
                self.frame.searches.do_search(realargs, 2)
                self.frame.on_search(None)

        elif cmd in ["/ad", "/add", "/buddy"]:
            if args:
                self.frame.userlist.add_to_list(args)

        elif cmd in ["/rem", "/unbuddy"]:
            if args:
                self.frame.userlist.remove_from_list(args)

        elif cmd == "/ban":
            if args:
                self.frame.ban_user(args)

        elif cmd == "/ignore":
            if args:
                self.frame.ignore_user(args)

        elif cmd == "/ignoreip":
            if args:
                self.frame.ignore_ip(args)

        elif cmd == "/unban":
            if args:
                self.frame.unban_user(args)

        elif cmd == "/unignore":
            if args:
                self.frame.unignore_user(args)

        elif cmd == "/ctcpversion":
            if args:
                self.frame.privatechats.send_message(args,
                                                     CTCP_VERSION,
                                                     show_user=True,
                                                     bytestring=True)

        elif cmd in ["/clear", "/cl"]:
            self.ChatScroll.get_buffer().set_text("")

        elif cmd in ["/a", "/away"]:
            self.frame.on_away(None)

        elif cmd in ["/q", "/quit", "/exit"]:
            self.frame.on_quit(None)
            return

        elif cmd in ["/c", "/close"]:
            self.on_close(None)

        elif cmd == "/now":
            self.display_now_playing()

        elif cmd == "/rescan":
            self.frame.on_rescan()

        elif cmd[:
                 1] == "/" and self.frame.np.pluginhandler.trigger_private_command_event(
                     self.user, cmd[1:], args):
            pass

        elif cmd and cmd[:1] == "/" and cmd != "/me" and cmd[:2] != "//":
            log.add(_("Command %s is not recognized"), text)
            return

        else:

            if text[:2] == "//":
                text = text[1:]

            if self.chats.connected:
                self.send_message(text)
                widget.set_text("")

            return

        widget.set_text("")
Ejemplo n.º 9
0
    def on_enter(self, *_args):

        if not self.frame.np.logged_in:
            return

        text = self.entry.get_text()

        if not text:
            return

        if is_alias(text):
            alias_text = get_alias(text)

            if not alias_text:
                log.add(_('Alias "%s" returned nothing'), text)
                return

            text = alias_text

        is_double_slash_cmd = text.startswith("//")
        is_single_slash_cmd = (text.startswith("/")
                               and not is_double_slash_cmd)

        if not is_single_slash_cmd or text.startswith("/me"):
            # Regular chat message (/me is sent as plain text)

            self.entry.set_text("")

            if is_double_slash_cmd:
                # Remove first slash and send the rest of the command as plain text
                text = text[1:]

            self.send_message(self.entity, text)
            return

        cmd_split = text.split(maxsplit=1)
        cmd = cmd_split[0]

        if cmd + " " not in self.command_list:
            log.add(_("Command %s is not recognized"), cmd)
            return

        # Clear chat entry
        self.entry.set_text("")

        if len(cmd_split) == 2:
            args = arg_self = cmd_split[1]
        else:
            args = ""
            arg_self = "" if self.is_chatroom else self.entity

        if cmd in ("/alias", "/al"):
            parent = self.frame.np.chatrooms if self.is_chatroom else self.frame.np.privatechats
            parent.echo_message(self.entity, add_alias(args))

            if config.sections["words"]["aliases"]:
                self.frame.update_completions()

        elif cmd in ("/unalias", "/un"):
            parent = self.frame.np.chatrooms if self.is_chatroom else self.frame.np.privatechats
            parent.echo_message(self.entity, unalias(args))

            if config.sections["words"]["aliases"]:
                self.frame.update_completions()

        elif cmd in ("/w", "/whois", "/info"):
            if arg_self:
                self.frame.np.userinfo.request_user_info(arg_self)
                self.frame.change_main_page("userinfo")

        elif cmd in ("/b", "/browse"):
            if arg_self:
                self.frame.np.userbrowse.browse_user(arg_self)
                self.frame.change_main_page("userbrowse")

        elif cmd == "/ip":
            if arg_self:
                self.frame.np.request_ip_address(arg_self)

        elif cmd == "/pm":
            if args:
                self.frame.np.privatechats.show_user(args)
                self.frame.change_main_page("private")

        elif cmd in ("/m", "/msg"):
            if args:
                args_split = args.split(" ", maxsplit=1)
                user = args_split[0]
                msg = None

                if len(args_split) == 2:
                    msg = args_split[1]

                if msg:
                    self.frame.np.privatechats.show_user(user)
                    self.frame.np.privatechats.send_message(user, msg)
                    self.frame.change_main_page("private")

        elif cmd in ("/s", "/search"):
            if args:
                self.frame.np.search.do_search(args, "global")
                self.frame.change_main_page("search")

        elif cmd in ("/us", "/usearch"):
            args_split = args.split(" ", maxsplit=1)

            if len(args_split) == 2:
                self.frame.np.search.do_search(args_split[1],
                                               "user",
                                               user=args_split[0])
                self.frame.change_main_page("search")

        elif cmd in ("/rs", "/rsearch"):
            if args:
                self.frame.np.search.do_search(args, "rooms")
                self.frame.change_main_page("search")

        elif cmd in ("/bs", "/bsearch"):
            if args:
                self.frame.np.search.do_search(args, "buddies")
                self.frame.change_main_page("search")

        elif cmd in ("/j", "/join"):
            if args:
                self.frame.np.queue.append(slskmessages.JoinRoom(args))

        elif cmd in ("/l", "/leave", "/p", "/part"):
            if args:
                self.frame.np.queue.append(slskmessages.LeaveRoom(args))
            else:
                self.frame.np.queue.append(slskmessages.LeaveRoom(self.entity))

        elif cmd in ("/ad", "/add", "/buddy"):
            if args:
                self.frame.np.userlist.add_user(args)

        elif cmd in ("/rem", "/unbuddy"):
            if args:
                self.frame.np.userlist.remove_user(args)

        elif cmd == "/ban":
            if args:
                self.frame.np.network_filter.ban_user(args)

        elif cmd == "/ignore":
            if args:
                self.frame.np.network_filter.ignore_user(args)

        elif cmd == "/ignoreip":
            if args:
                self.frame.np.network_filter.ignore_ip(args)

        elif cmd == "/unban":
            if args:
                self.frame.np.network_filter.unban_user(args)

        elif cmd == "/unignore":
            if args:
                self.frame.np.network_filter.unignore_user(args)

        elif cmd == "/ctcpversion":
            if arg_self:
                self.frame.np.privatechats.show_user(arg_self)
                self.frame.np.privatechats.send_message(
                    arg_self, self.frame.np.privatechats.CTCP_VERSION)

        elif cmd in ("/clear", "/cl"):
            if self.is_chatroom:
                parent = self.frame.chatrooms.pages[self.entity]
            else:
                parent = self.frame.privatechat.pages[self.entity]

            parent.chat_textview.clear()

        elif cmd in ("/a", "/away"):
            self.frame.on_away()

        elif cmd in ("/q", "/quit", "/exit"):
            self.frame.on_quit()

        elif cmd in ("/c", "/close"):
            self.frame.privatechat.pages[self.entity].on_close()

        elif cmd == "/now":
            self.frame.np.now_playing.display_now_playing(
                callback=lambda np_message: self.send_message(
                    self.entity, np_message))

        elif cmd == "/rescan":
            self.frame.np.shares.rescan_shares()

        elif cmd == "/toggle":
            if args:
                self.frame.np.pluginhandler.toggle_plugin(args)

        elif self.is_chatroom:
            self.frame.np.pluginhandler.trigger_public_command_event(
                self.entity, cmd[1:], args)

        elif not self.is_chatroom:
            self.frame.np.pluginhandler.trigger_private_command_event(
                self.entity, cmd[1:], args)
Ejemplo n.º 10
0
 def on_join_public_room(self, widget):
     self.frame.chatrooms.join_room(slskmessages.JoinRoom("Public "))
     self.frame.np.queue.put(slskmessages.JoinPublicRoom())
Ejemplo n.º 11
0
 def on_popup_join(self, widget):
     self.frame.np.queue.put(slskmessages.JoinRoom(self.popup_room))
Ejemplo n.º 12
0
 def request_join_public_room(self):
     self.join_room(slskmessages.JoinRoom("Public "))
     self.queue.append(slskmessages.JoinPublicRoom())
Ejemplo n.º 13
0
 def request_join_room(self, room, private=None):
     self.queue.append(slskmessages.JoinRoom(room, private))