privatetab.py 14.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
"""
Module for the PrivateTab

A PrivateTab is a private conversation opened with someone from a MUC
(see muctab.py). The conversation happens with both JID being relative
to the MUC (room@server/nick1 and room@server/nick2).

This tab references his parent room, and is modified to keep track of
both participant’s nicks. It also has slightly different features than
the ConversationTab (such as tab-completion on nicks from the room).

"""
13
import curses
14
15
import logging
from typing import Dict, Callable
16

17
18
from slixmpp import JID

mathieui's avatar
mathieui committed
19
from poezio.tabs import OneToOneTab, MucTab, Tab
20

21
22
from poezio import windows
from poezio import xhtml
23
from poezio.common import safeJID
24
from poezio.config import config
25
from poezio.core.structs import Command
26
27
28
29
from poezio.decorators import refresh_wrapper
from poezio.logger import logger
from poezio.theming import get_theme, dump_tuple
from poezio.decorators import command_args_parser
30

31
32
log = logging.getLogger(__name__)

mathieui's avatar
mathieui committed
33

34
class PrivateTab(OneToOneTab):
35
    """
36
    The tab containing a private conversation (someone from a MUC)
37
    """
38
39
    plugin_commands = {}  # type: Dict[str, Command]
    plugin_keys = {}  # type: Dict[str, Callable]
40
    message_type = 'chat'
41
    additional_information = {}  # type: Dict[str, Callable[[str], str]]
mathieui's avatar
mathieui committed
42

43
44
    def __init__(self, core, jid, nick):
        OneToOneTab.__init__(self, core, jid)
45
46
47
48
49
50
51
52
        self.own_nick = nick
        self.text_win = windows.TextWin()
        self._text_buffer.add_window(self.text_win)
        self.info_header = windows.PrivateInfoWin()
        self.input = windows.MessageInput()
        # keys
        self.key_func['^I'] = self.completion
        # commands
mathieui's avatar
mathieui committed
53
54
55
56
        self.register_command(
            'info',
            self.command_info,
            desc=
Kim Alvefur's avatar
Kim Alvefur committed
57
            'Display some information about the user in the MUC: their role, affiliation, status and status message.',
mathieui's avatar
mathieui committed
58
59
60
61
62
63
64
            shortdesc='Info about the user.')
        self.register_command(
            'version',
            self.command_version,
            desc=
            'Get the software version of the current interlocutor (usually its XMPP client and Operating System).',
            shortdesc='Get the software version of a jid.')
65
        self.resize()
66
        self.parent_muc = self.core.tabs.by_name_and_class(self.jid.bare, MucTab)
67
68
69
70
        self.on = True
        self.update_commands()
        self.update_keys()

71
    def remote_user_color(self):
72
        user = self.parent_muc.get_user_by_name(self.jid.resource)
73
        if user:
mathieui's avatar
mathieui committed
74
            return dump_tuple(user.color)
75
76
        return super().remote_user_color()

77
78
    @property
    def general_jid(self):
79
        return self.jid
80

81
    def get_dest_jid(self):
82
        return self.jid
83

84
85
86
87
    @property
    def nick(self):
        return self.get_nick()

88
89
90
    def ack_message(self, msg_id: str, msg_jid: JID):
        # special case when talking to oneself
        if msg_jid == self.core.xmpp.boundjid:
91
            msg_jid = self.jid.full
92
93
        super().ack_message(msg_id, msg_jid)

94
    @staticmethod
95
    @refresh_wrapper.always
96
97
98
99
    def add_information_element(plugin_name, callback):
        """
        Lets a plugin add its own information to the PrivateInfoWin
        """
100
        PrivateTab.additional_information[plugin_name] = callback
101
102

    @staticmethod
103
    @refresh_wrapper.always
104
    def remove_information_element(plugin_name):
105
        del PrivateTab.additional_information[plugin_name]
106
107

    def load_logs(self, log_nb):
108
        logs = logger.get_logs(self.jid.full.replace('/', '\\'), log_nb)
109
        return logs
110
111
112
113
114

    def log_message(self, txt, nickname, time=None, typ=1):
        """
        Log the messages in the archives.
        """
mathieui's avatar
mathieui committed
115
        if not logger.log_message(
116
                self.jid.full, nickname, txt, date=time, typ=typ):
117
            self.core.information('Unable to write in the log file', 'Error')
118
119

    def on_close(self):
120
        super().on_close()
121
122
123
124
125
126
127
128
129
130
131
132
133
        self.parent_muc.privates.remove(self)

    def completion(self):
        """
        Called when Tab is pressed, complete the nickname in the input
        """
        if self.complete_commands(self.input):
            return

        # If we are not completing a command or a command's argument, complete a nick
        compare_users = lambda x: x.last_talked
        word_list = [user.nick for user in sorted(self.parent_muc.users, key=compare_users, reverse=True)\
                         if user.nick != self.own_nick]
134
        after = config.get('after_completion') + ' '
135
136
137
138
139
140
141
        input_pos = self.input.pos
        if ' ' not in self.input.get_text()[:input_pos] or (self.input.last_completion and\
                     self.input.get_text()[:input_pos] == self.input.last_completion + after):
            add_after = after
        else:
            add_after = ''
        self.input.auto_completion(word_list, add_after, quotify=False)
mathieui's avatar
mathieui committed
142
143
144
        empty_after = self.input.get_text() == '' or (
            self.input.get_text().startswith('/')
            and not self.input.get_text().startswith('//'))
145
146
        self.send_composing_chat_state(empty_after)

147
    @refresh_wrapper.always
148
    @command_args_parser.raw
149
150
151
    def command_say(self, line, attention=False, correct=False):
        if not self.on:
            return
152
        echo_message = self.jid.resource != self.own_nick
153
154
155
156
        msg = self.core.xmpp.make_message(
            mto=self.jid.full,
            mfrom=self.core.xmpp.boundjid
        )
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
        msg['type'] = 'chat'
        msg['body'] = line
        # trigger the event BEFORE looking for colors.
        # This lets a plugin insert \x19xxx} colors, that will
        # be converted in xhtml.
        self.core.events.trigger('private_say', msg, self)
        if not msg['body']:
            return
        user = self.parent_muc.get_user_by_name(self.own_nick)
        replaced = False
        if correct or msg['replace']['id']:
            msg['replace']['id'] = self.last_sent_message['id']
        else:
            del msg['replace']

        if msg['body'].find('\x19') != -1:
            msg.enable('html')
            msg['html']['body'] = xhtml.poezio_colors_to_html(msg['body'])
            msg['body'] = xhtml.clean_text(msg['body'])
176
        if config.get_by_tabname('send_chat_states', self.general_jid):
177
178
            needed = 'inactive' if self.inactive else 'active'
            msg['chat_state'] = needed
179
        if attention:
180
181
182
183
184
            msg['attention'] = True
        self.core.events.trigger('private_say_after', msg, self)
        if not msg['body']:
            return
        self.last_sent_message = msg
185
        self.core.handler.on_normal_message(msg)
186
        msg._add_receipt = True
187
188
189
        msg.send()
        self.cancel_paused_delay()

190
191
    @command_args_parser.quoted(0, 1)
    def command_version(self, args):
192
193
194
        """
        /version
        """
195
        if args:
196
            return self.core.command.version(args[0])
197
        jid = self.jid.full
198
199
        self.core.xmpp.plugin['xep_0092'].get_version(
            jid, callback=self.core.handler.on_version_result)
200

201
    @command_args_parser.quoted(0, 1)
202
203
204
205
    def command_info(self, arg):
        """
        /info
        """
mathieui's avatar
mathieui committed
206
207
        if arg and arg[0]:
            self.parent_muc.command_info(arg[0])
208
        else:
209
            user = self.jid.resource
210
211
212
            self.parent_muc.command_info(user)

    def resize(self):
213
214
        self.need_resize = False

215
216
217
218
219
220
221
        if self.size.tab_degrade_y:
            info_win_height = 0
            tab_win_height = 0
        else:
            info_win_height = self.core.information_win_size
            tab_win_height = Tab.tab_win_height()

mathieui's avatar
mathieui committed
222
223
224
        self.text_win.resize(
            self.height - 2 - info_win_height - tab_win_height, self.width, 0,
            0)
225
        self.text_win.rebuild_everything(self._text_buffer)
mathieui's avatar
mathieui committed
226
227
228
229
        self.info_header.resize(
            1, self.width, self.height - 2 - info_win_height - tab_win_height,
            0)
        self.input.resize(1, self.width, self.height - 1, 0)
230
231
232
233

    def refresh(self):
        if self.need_resize:
            self.resize()
234
        log.debug('  TAB   Refresh: %s', self.__class__.__name__)
235
236
        display_info_win = not self.size.tab_degrade_y

237
        self.text_win.refresh()
238
        self.info_header.refresh(self.jid.full, self.text_win, self.chatstate,
239
                                 PrivateTab.additional_information)
240
241
242
        if display_info_win:
            self.info_win.refresh()

243
244
245
246
        self.refresh_tab_win()
        self.input.refresh()

    def refresh_info_header(self):
247
        self.info_header.refresh(self.jid.full, self.text_win, self.chatstate,
mathieui's avatar
mathieui committed
248
                                 PrivateTab.additional_information)
249
250
251
        self.input.refresh()

    def get_nick(self):
252
        return self.jid.resource
253
254
255
256
257
258
259
260

    def on_input(self, key, raw):
        if not raw and key in self.key_func:
            self.key_func[key]()
            return False
        self.input.do_command(key, raw=raw)
        if not self.on:
            return False
mathieui's avatar
mathieui committed
261
262
263
        empty_after = self.input.get_text() == '' or (
            self.input.get_text().startswith('/')
            and not self.input.get_text().startswith('//'))
264
        tab = self.core.tabs.by_name_and_class(self.jid.bare, MucTab)
265
266
267
268
269
        if tab and tab.joined:
            self.send_composing_chat_state(empty_after)
        return False

    def on_lose_focus(self):
270
271
272
273
274
        if self.input.text:
            self.state = 'nonempty'
        else:
            self.state = 'normal'

275
276
        self.text_win.remove_line_separator()
        self.text_win.add_line_separator(self._text_buffer)
277
        tab = self.core.tabs.by_name_and_class(self.jid.bare, MucTab)
mathieui's avatar
mathieui committed
278
279
        if tab and tab.joined and config.get_by_tabname(
                'send_chat_states', self.general_jid) and self.on:
280
281
282
283
284
285
            self.send_chat_state('inactive')
        self.check_scrolled()

    def on_gain_focus(self):
        self.state = 'current'
        curses.curs_set(1)
286
        tab = self.core.tabs.by_name_and_class(self.jid.bare, MucTab)
mathieui's avatar
mathieui committed
287
288
289
290
        if tab and tab.joined and config.get_by_tabname(
                'send_chat_states',
                self.general_jid,
        ) and not self.input.get_text() and self.on:
291
292
293
            self.send_chat_state('active')

    def on_info_win_size_changed(self):
mathieui's avatar
mathieui committed
294
        if self.core.information_win_size >= self.height - 3:
295
            return
mathieui's avatar
mathieui committed
296
297
298
        self.text_win.resize(
            self.height - 2 - self.core.information_win_size -
            Tab.tab_win_height(), self.width, 0, 0)
mathieui's avatar
mathieui committed
299
300
301
        self.info_header.resize(
            1, self.width, self.height - 2 - self.core.information_win_size -
            Tab.tab_win_height(), 0)
302
303
304
305

    def get_text_window(self):
        return self.text_win

306
    @refresh_wrapper.conditional
307
    def rename_user(self, old_nick, user):
308
309
310
311
        """
        The user changed her nick in the corresponding muc: update the tab’s name and
        display a message.
        """
mathieui's avatar
mathieui committed
312
313
314
315
316
317
318
319
320
        self.add_message(
            '\x19%(nick_col)s}%(old)s\x19%(info_col)s} is now '
            'known as \x19%(nick_col)s}%(new)s' % {
                'old': old_nick,
                'new': user.nick,
                'nick_col': dump_tuple(user.color),
                'info_col': dump_tuple(get_theme().COLOR_INFORMATION_TEXT)
            },
            typ=2)
321
        new_jid = self.jid.bare + '/' + user.nick
322
        self.name = new_jid
323
        return self.core.tabs.current_tab is self
324
325

    @refresh_wrapper.conditional
326
    def user_left(self, status_message, user):
327
328
329
330
        """
        The user left the associated MUC
        """
        self.deactivate()
331
        theme = get_theme()
mathieui's avatar
mathieui committed
332
333
        if config.get_by_tabname('display_user_color_in_join_part',
                                 self.general_jid):
334
335
            color = dump_tuple(user.color)
        else:
336
            color = dump_tuple(theme.COLOR_REMOTE_USER)
337

338
        if not status_message:
mathieui's avatar
mathieui committed
339
340
341
342
            self.add_message(
                '\x19%(quit_col)s}%(spec)s \x19%(nick_col)s}'
                '%(nick)s\x19%(info_col)s} has left the room' % {
                    'nick': user.nick,
343
                    'spec': theme.CHAR_QUIT,
mathieui's avatar
mathieui committed
344
                    'nick_col': color,
345
346
                    'quit_col': dump_tuple(theme.COLOR_QUIT_CHAR),
                    'info_col': dump_tuple(theme.COLOR_INFORMATION_TEXT)
mathieui's avatar
mathieui committed
347
348
                },
                typ=2)
349
        else:
mathieui's avatar
mathieui committed
350
351
352
353
354
355
            self.add_message(
                '\x19%(quit_col)s}%(spec)s \x19%(nick_col)s}'
                '%(nick)s\x19%(info_col)s} has left the room'
                ' (%(status)s)' % {
                    'status': status_message,
                    'nick': user.nick,
356
                    'spec': theme.CHAR_QUIT,
mathieui's avatar
mathieui committed
357
                    'nick_col': color,
358
359
                    'quit_col': dump_tuple(theme.COLOR_QUIT_CHAR),
                    'info_col': dump_tuple(theme.COLOR_INFORMATION_TEXT)
mathieui's avatar
mathieui committed
360
361
                },
                typ=2)
362
        return self.core.tabs.current_tab is self
363
364
365
366
367
368
369

    @refresh_wrapper.conditional
    def user_rejoined(self, nick):
        """
        The user (or at least someone with the same nick) came back in the MUC
        """
        self.activate()
370
        self.check_features()
371
        tab = self.parent_muc
372
373
        theme = get_theme()
        color = dump_tuple(theme.COLOR_REMOTE_USER)
374
375
        if tab and config.get_by_tabname('display_user_color_in_join_part',
                                         self.general_jid):
376
377
378
            user = tab.get_user_by_name(nick)
            if user:
                color = dump_tuple(user.color)
mathieui's avatar
mathieui committed
379
380
381
382
383
        self.add_message(
            '\x19%(join_col)s}%(spec)s \x19%(color)s}%(nick)s\x19'
            '%(info_col)s} joined the room' % {
                'nick': nick,
                'color': color,
384
385
386
                'spec': theme.CHAR_JOIN,
                'join_col': dump_tuple(theme.COLOR_JOIN_CHAR),
                'info_col': dump_tuple(theme.COLOR_INFORMATION_TEXT)
mathieui's avatar
mathieui committed
387
388
            },
            typ=2)
389
        return self.core.tabs.current_tab is self
390
391
392
393
394
395
396
397
398
399
400
401

    def activate(self, reason=None):
        self.on = True
        if reason:
            self.add_message(txt=reason, typ=2)

    def deactivate(self, reason=None):
        self.on = False
        if reason:
            self.add_message(txt=reason, typ=2)

    def matching_names(self):
402
        return [(3, self.jid.resource), (4, self.name)]
403

404
    def add_error(self, error_message):
405
406
        theme = get_theme()
        error = '\x19%s}%s\x19o' % (dump_tuple(theme.COLOR_CHAR_NACK),
407
                                    error_message)
mathieui's avatar
mathieui committed
408
409
410
411
        self.add_message(
            error,
            highlight=True,
            nickname='Error',
412
            nick_color=theme.COLOR_ERROR_MSG,
mathieui's avatar
mathieui committed
413
            typ=2)
414
        self.core.refresh_window()