gajim-plural/gajim/conversation_textview.py

1391 lines
55 KiB
Python
Raw Normal View History

# -*- coding:utf-8 -*-
## src/conversation_textview.py
##
## Copyright (C) 2005 Norman Rasmussen <norman AT rasmussen.co.za>
## Copyright (C) 2005-2006 Alex Mauer <hawke AT hawkesnest.net>
## Travis Shirk <travis AT pobox.com>
## Copyright (C) 2005-2007 Nikos Kouremenos <kourem AT gmail.com>
2014-01-02 09:33:54 +01:00
## Copyright (C) 2005-2014 Yann Leboulanger <asterix AT lagaule.org>
## Copyright (C) 2006 Dimitur Kirov <dkirov AT gmail.com>
## Copyright (C) 2006-2008 Jean-Marie Traissard <jim AT lapin.org>
## Copyright (C) 2008 Jonathan Schleifer <js-gajim AT webkeks.org>
## Julien Pivotto <roidelapluie AT gmail.com>
## Stephan Erb <steve-e AT h3c.de>
##
## This file is part of Gajim.
##
## Gajim is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published
## by the Free Software Foundation; version 3 only.
##
## Gajim is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with Gajim. If not, see <http://www.gnu.org/licenses/>.
##
from gi.repository import Gtk
2013-01-02 14:30:54 +01:00
from gi.repository import Gdk
from gi.repository import Pango
from gi.repository import GObject
2013-07-28 20:50:30 +02:00
from gi.repository import GLib
import time
import os
2017-06-13 23:58:06 +02:00
from gajim import dialogs
2013-01-02 13:54:02 +01:00
import queue
2010-08-10 13:10:10 +02:00
import urllib
2017-06-13 23:58:06 +02:00
from gajim import gtkgui_helpers
from gajim.common import app
2017-06-13 23:58:06 +02:00
from gajim.common import helpers
from gajim.common import i18n
from calendar import timegm
2017-06-13 23:58:06 +02:00
from gajim.common.fuzzyclock import FuzzyClock
from gajim import emoticons
2017-06-13 23:58:06 +02:00
from gajim.htmltextview import HtmlTextView
NOT_SHOWN = 0
ALREADY_RECEIVED = 1
SHOWN = 2
import logging
log = logging.getLogger('gajim.conversation_textview')
def is_selection_modified(mark):
name = mark.get_name()
if name and name in ('selection_bound', 'insert'):
return True
else:
return False
def has_focus(widget):
2013-02-24 09:39:51 +01:00
return widget.get_state_flags() & Gtk.StateFlags.FOCUSED == \
Gtk.StateFlags.FOCUSED
class TextViewImage(Gtk.Image):
def __init__(self, anchor, text):
super(TextViewImage, self).__init__()
self.anchor = anchor
self._selected = False
self._disconnect_funcs = []
self.connect('parent-set', self.on_parent_set)
self.set_tooltip_markup(text)
2013-02-18 20:02:40 +01:00
self.anchor.plaintext = text
def _get_selected(self):
parent = self.get_parent()
if not parent or not self.anchor: return False
buffer_ = parent.get_buffer()
position = buffer_.get_iter_at_child_anchor(self.anchor)
bounds = buffer_.get_selection_bounds()
if bounds and position.in_range(*bounds):
return True
else:
return False
def get_state(self):
parent = self.get_parent()
if not parent:
return Gtk.StateType.NORMAL
if self._selected:
if has_focus(parent):
return Gtk.StateType.SELECTED
else:
return Gtk.StateType.ACTIVE
else:
return Gtk.StateType.NORMAL
def _update_selected(self):
selected = self._get_selected()
if self._selected != selected:
self._selected = selected
self.queue_draw()
def _do_connect(self, widget, signal, callback):
id_ = widget.connect(signal, callback)
def disconnect():
widget.disconnect(id_)
self._disconnect_funcs.append(disconnect)
def _disconnect_signals(self):
for func in self._disconnect_funcs:
func()
self._disconnect_funcs = []
def on_parent_set(self, widget, old_parent):
parent = self.get_parent()
if not parent:
self._disconnect_signals()
return
if isinstance(parent, Gtk.EventBox):
parent = parent.get_parent()
if not parent:
self._disconnect_signals()
return
self._do_connect(parent, 'style-set', self.do_queue_draw)
self._do_connect(parent, 'focus-in-event', self.do_queue_draw)
self._do_connect(parent, 'focus-out-event', self.do_queue_draw)
textbuf = parent.get_buffer()
self._do_connect(textbuf, 'mark-set', self.on_mark_set)
self._do_connect(textbuf, 'mark-deleted', self.on_mark_deleted)
def do_queue_draw(self, *args):
self.queue_draw()
return False
def on_mark_set(self, buf, iterat, mark):
self.on_mark_modified(mark)
return False
def on_mark_deleted(self, buf, mark):
self.on_mark_modified(mark)
return False
def on_mark_modified(self, mark):
if is_selection_modified(mark):
self._update_selected()
class ConversationTextview(GObject.GObject):
"""
Class for the conversation textview (where user reads already said messages)
for chat/groupchat windows
"""
__gsignals__ = dict(
quote = (GObject.SignalFlags.RUN_LAST | GObject.SignalFlags.ACTION,
None, # return value
(str, ) # arguments
)
)
2017-05-18 22:02:18 +02:00
MESSAGE_CORRECTED_PIXBUF = gtkgui_helpers.get_icon_pixmap(
'document-edit-symbolic')
2017-06-11 01:58:27 +02:00
MESSAGE_ENCRYPTED_PIXBUF = gtkgui_helpers.get_icon_pixmap(
'channel-secure-croped-symbolic')
def __init__(self, account, used_in_history_window = False):
"""
If used_in_history_window is True, then we do not show Clear menuitem in
context menu
"""
GObject.GObject.__init__(self)
self.used_in_history_window = used_in_history_window
self.line = 0
self.message_list = []
self.corrected_text_list = {}
self.fc = FuzzyClock()
# no need to inherit TextView, use it as atrribute is safer
self.tv = HtmlTextView()
# we have to override HtmlTextView Event handlers
# because we dont inherit
self.tv.hyperlink_handler = self.hyperlink_handler
self.tv.connect_tooltip(self.query_tooltip)
# set properties
self.tv.set_border_width(1)
self.tv.set_accepts_tab(True)
self.tv.set_editable(False)
self.tv.set_cursor_visible(False)
self.tv.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
self.tv.set_left_margin(2)
self.tv.set_right_margin(2)
self.handlers = {}
self.images = []
self.image_cache = {}
self.xep0184_marks = {}
# self.last_sent_message_id = msg_stanza_id
self.last_sent_message_id = None
# last_received_message_id[name] = (msg_stanza_id, line_start_mark)
self.last_received_message_id = {}
2018-03-20 22:19:30 +01:00
self.autoscroll = True
# connect signals
id_ = self.tv.connect('populate_popup', self.on_textview_populate_popup)
self.handlers[id_] = self.tv
id_ = self.tv.connect('button_press_event',
self.on_textview_button_press_event)
self.handlers[id_] = self.tv
self.account = account
self.cursor_changed = False
self.last_time_printout = 0
2017-03-02 23:01:12 +01:00
style = self.tv.get_style_context()
style.add_class('font_custom')
buffer_ = self.tv.get_buffer()
end_iter = buffer_.get_end_iter()
buffer_.create_mark('end', end_iter, False)
self.tagIn = buffer_.create_tag('incoming')
color = app.config.get('inmsgcolor')
font = Pango.FontDescription(app.config.get('inmsgfont'))
self.tagIn.set_property('foreground', color)
self.tagIn.set_property('font-desc', font)
self.tagOut = buffer_.create_tag('outgoing')
color = app.config.get('outmsgcolor')
font = Pango.FontDescription(app.config.get('outmsgfont'))
self.tagOut.set_property('foreground', color)
self.tagOut.set_property('font-desc', font)
self.tagStatus = buffer_.create_tag('status')
color = app.config.get('statusmsgcolor')
font = Pango.FontDescription(app.config.get('satusmsgfont'))
self.tagStatus.set_property('foreground', color)
self.tagStatus.set_property('font-desc', font)
self.tagInText = buffer_.create_tag('incomingtxt')
color = app.config.get('inmsgtxtcolor')
font = Pango.FontDescription(app.config.get('inmsgtxtfont'))
if color:
self.tagInText.set_property('foreground', color)
self.tagInText.set_property('font-desc', font)
self.tagOutText = buffer_.create_tag('outgoingtxt')
color = app.config.get('outmsgtxtcolor')
if color:
font = Pango.FontDescription(app.config.get('outmsgtxtfont'))
self.tagOutText.set_property('foreground', color)
self.tagOutText.set_property('font-desc', font)
colors = app.config.get('gc_nicknames_colors')
colors = colors.split(':')
for i, color in enumerate(colors):
tagname = 'gc_nickname_color_' + str(i)
tag = buffer_.create_tag(tagname)
tag.set_property('foreground', color)
self.tagMarked = buffer_.create_tag('marked')
color = app.config.get('markedmsgcolor')
self.tagMarked.set_property('foreground', color)
self.tagMarked.set_property('weight', Pango.Weight.BOLD)
tag = buffer_.create_tag('time_sometimes')
tag.set_property('foreground', 'darkgrey')
#Pango.SCALE_SMALL
tag.set_property('scale', 0.8333333333333)
tag.set_property('justification', Gtk.Justification.CENTER)
tag = buffer_.create_tag('small')
#Pango.SCALE_SMALL
tag.set_property('scale', 0.8333333333333)
tag = buffer_.create_tag('restored_message')
color = app.config.get('restored_messages_color')
tag.set_property('foreground', color)
self.tv.create_tags()
2014-11-11 23:11:15 +01:00
tag = buffer_.create_tag('bold')
tag.set_property('weight', Pango.Weight.BOLD)
tag = buffer_.create_tag('italic')
tag.set_property('style', Pango.Style.ITALIC)
tag = buffer_.create_tag('underline')
tag.set_property('underline', Pango.Underline.SINGLE)
buffer_.create_tag('focus-out-line', justification = Gtk.Justification.CENTER)
self.displaymarking_tags = {}
tag = buffer_.create_tag('xep0184-received')
2013-11-30 10:04:50 +01:00
tag.set_property('foreground', '#73d216')
# One mark at the begining then 2 marks between each lines
size = app.config.get('max_conversation_lines')
size = 2 * size - 1
2013-01-02 13:54:02 +01:00
self.marks_queue = queue.Queue(size)
self.allow_focus_out_line = True
# holds a mark at the end of --- line
self.focus_out_end_mark = None
2013-08-16 09:21:32 +02:00
self.just_cleared = False
def query_tooltip(self, widget, x_pos, y_pos, keyboard_mode, tooltip):
window = widget.get_window(Gtk.TextWindowType.TEXT)
x_pos, y_pos = self.tv.window_to_buffer_coords(
Gtk.TextWindowType.TEXT, x_pos, y_pos)
if Gtk.MINOR_VERSION > 18:
iter_ = self.tv.get_iter_at_position(x_pos, y_pos)[1]
else:
iter_ = self.tv.get_iter_at_position(x_pos, y_pos)[0]
for tag in iter_.get_tags():
tag_name = tag.get_property('name')
if tag_name == 'focus-out-line':
tooltip.set_text(_(
'Text below this line is what has '
'been said since the\nlast time you paid attention to this '
'group chat'))
return True
if getattr(tag, 'is_anchor', False):
text = getattr(tag, 'title', False)
if text:
if len(text) > 50:
text = text[:47] + ''
tooltip.set_text(text)
window.set_cursor(gtkgui_helpers.get_cursor('HAND2'))
self.cursor_changed = True
return True
if tag_name in ('url', 'mail', 'xmpp', 'sth_at_sth'):
window.set_cursor(gtkgui_helpers.get_cursor('HAND2'))
self.cursor_changed = True
return False
try:
text = self.corrected_text_list[tag_name]
tooltip.set_markup(text)
return True
except KeyError:
pass
if self.cursor_changed:
window.set_cursor(gtkgui_helpers.get_cursor('XTERM'))
self.cursor_changed = False
return False
def del_handlers(self):
for i in self.handlers.keys():
if self.handlers[i].handler_is_connected(i):
self.handlers[i].disconnect(i)
del self.handlers
self.tv.destroy()
def update_tags(self):
self.tagIn.set_property('foreground', app.config.get('inmsgcolor'))
self.tagOut.set_property('foreground', app.config.get('outmsgcolor'))
self.tagStatus.set_property('foreground',
app.config.get('statusmsgcolor'))
self.tagMarked.set_property('foreground',
app.config.get('markedmsgcolor'))
color = app.config.get('urlmsgcolor')
self.tv.tagURL.set_property('foreground', color)
self.tv.tagMail.set_property('foreground', color)
self.tv.tagXMPP.set_property('foreground', color)
self.tv.tagSthAtSth.set_property('foreground', color)
2018-03-20 22:19:30 +01:00
def scroll_to_end(self, force=False):
if self.autoscroll or force:
gtkgui_helpers.scroll_to_end(self.tv.get_parent())
def correct_message(self, correct_id, kind, name):
allowed = True
if kind == 'incoming':
try:
if correct_id in self.last_received_message_id[name]:
start_mark = self.last_received_message_id[name][1]
else:
allowed = False
except KeyError:
allowed = False
elif kind == 'outgoing':
if self.last_sent_message_id[0] == correct_id:
start_mark = self.last_sent_message_id[1]
else:
allowed = False
else:
allowed = False
if not allowed:
log.debug('Message correctiong not allowed')
return None
end_mark, index = self.get_end_mark(correct_id, start_mark)
if not index:
log.debug('Could not find line to correct')
return None
buffer_ = self.tv.get_buffer()
if not end_mark:
end_iter = self.tv.get_buffer().get_end_iter()
else:
end_iter = buffer_.get_iter_at_mark(end_mark)
start_iter = buffer_.get_iter_at_mark(start_mark)
old_txt = buffer_.get_text(start_iter, end_iter, True)
buffer_.delete(start_iter, end_iter)
buffer_.delete_mark(start_mark)
return index, end_mark, old_txt
def add_xep0184_mark(self, id_):
if id_ in self.xep0184_marks:
return
buffer_ = self.tv.get_buffer()
buffer_.begin_user_action()
self.xep0184_marks[id_] = buffer_.create_mark(
None, buffer_.get_end_iter(), left_gravity=True)
buffer_.end_user_action()
def show_xep0184_ack(self, id_):
if id_ not in self.xep0184_marks:
return
buffer_ = self.tv.get_buffer()
buffer_.begin_user_action()
if app.config.get('positive_184_ack'):
begin_iter = buffer_.get_iter_at_mark(self.xep0184_marks[id_])
buffer_.insert_with_tags_by_name(begin_iter, '',
'xep0184-received')
buffer_.end_user_action()
del self.xep0184_marks[id_]
2018-03-20 22:19:30 +01:00
def show_focus_out_line(self):
if not self.allow_focus_out_line:
# if room did not receive focus-in from the last time we added
# --- line then do not readd
return
print_focus_out_line = False
buffer_ = self.tv.get_buffer()
if self.focus_out_end_mark is None:
# this happens only first time we focus out on this room
print_focus_out_line = True
else:
focus_out_end_iter = buffer_.get_iter_at_mark(self.focus_out_end_mark)
focus_out_end_iter_offset = focus_out_end_iter.get_offset()
if focus_out_end_iter_offset != buffer_.get_end_iter().get_offset():
# this means after last-focus something was printed
# (else end_iter's offset is the same as before)
# only then print ---- line (eg. we avoid printing many following
# ---- lines)
print_focus_out_line = True
if print_focus_out_line and buffer_.get_char_count() > 0:
buffer_.begin_user_action()
# remove previous focus out line if such focus out line exists
if self.focus_out_end_mark is not None:
end_iter_for_previous_line = buffer_.get_iter_at_mark(
self.focus_out_end_mark)
begin_iter_for_previous_line = end_iter_for_previous_line.copy()
# img_char+1 (the '\n')
begin_iter_for_previous_line.backward_chars(21)
# remove focus out line
buffer_.delete(begin_iter_for_previous_line,
end_iter_for_previous_line)
buffer_.delete_mark(self.focus_out_end_mark)
# add the new focus out line
end_iter = buffer_.get_end_iter()
buffer_.insert(end_iter, '\n' + '' * 20)
end_iter = buffer_.get_end_iter()
before_img_iter = end_iter.copy()
# one char back (an image also takes one char)
before_img_iter.backward_chars(20)
buffer_.apply_tag_by_name('focus-out-line', before_img_iter, end_iter)
self.allow_focus_out_line = False
# update the iter we hold to make comparison the next time
self.focus_out_end_mark = buffer_.create_mark(None,
buffer_.get_end_iter(), left_gravity=True)
buffer_.end_user_action()
2018-03-20 22:19:30 +01:00
self.scroll_to_end()
def clear(self, tv = None):
"""
Clear text in the textview
"""
buffer_ = self.tv.get_buffer()
start, end = buffer_.get_bounds()
buffer_.delete(start, end)
size = app.config.get('max_conversation_lines')
size = 2 * size - 1
2013-01-02 13:54:02 +01:00
self.marks_queue = queue.Queue(size)
self.focus_out_end_mark = None
self.just_cleared = True
def visit_url_from_menuitem(self, widget, link):
"""
Basically it filters out the widget instance
"""
helpers.launch_browser_mailer('url', link)
def on_textview_populate_popup(self, textview, menu):
"""
Override the default context menu and we prepend Clear (only if
used_in_history_window is False) and if we have sth selected we show a
submenu with actions on the phrase (see
on_conversation_textview_button_press_event)
"""
separator_menuitem_was_added = False
if not self.used_in_history_window:
2013-01-01 16:46:04 +01:00
item = Gtk.SeparatorMenuItem.new()
menu.prepend(item)
separator_menuitem_was_added = True
2014-11-11 23:11:15 +01:00
item = Gtk.MenuItem.new_with_mnemonic(_('_Clear'))
menu.prepend(item)
id_ = item.connect('activate', self.clear)
self.handlers[id_] = item
if self.selected_phrase:
if not separator_menuitem_was_added:
2013-01-01 16:46:04 +01:00
item = Gtk.SeparatorMenuItem.new()
menu.prepend(item)
if not self.used_in_history_window:
2013-01-08 12:03:50 +01:00
item = Gtk.MenuItem.new_with_mnemonic(_('_Quote'))
id_ = item.connect('activate', self.on_quote)
self.handlers[id_] = item
menu.prepend(item)
_selected_phrase = helpers.reduce_chars_newlines(
self.selected_phrase, 25, 2)
2013-01-08 12:03:50 +01:00
item = Gtk.MenuItem.new_with_mnemonic(
_('_Actions for "%s"') % _selected_phrase)
menu.prepend(item)
submenu = Gtk.Menu()
item.set_submenu(submenu)
2013-01-08 12:03:50 +01:00
phrase_for_url = urllib.parse.quote(self.selected_phrase.encode(
'utf-8'))
always_use_en = app.config.get('always_english_wikipedia')
if always_use_en:
link = 'http://en.wikipedia.org/wiki/Special:Search?search=%s'\
2010-08-10 13:10:10 +02:00
% phrase_for_url
else:
link = 'http://%s.wikipedia.org/wiki/Special:Search?search=%s'\
% (app.LANG, phrase_for_url)
2013-01-08 12:03:50 +01:00
item = Gtk.MenuItem.new_with_mnemonic(_('Read _Wikipedia Article'))
id_ = item.connect('activate', self.visit_url_from_menuitem, link)
self.handlers[id_] = item
submenu.append(item)
2013-01-08 12:03:50 +01:00
item = Gtk.MenuItem.new_with_mnemonic(_('Look it up in _Dictionary'))
dict_link = app.config.get('dictionary_url')
if dict_link == 'WIKTIONARY':
# special link (yeah undocumented but default)
always_use_en = app.config.get('always_english_wiktionary')
if always_use_en:
link = 'http://en.wiktionary.org/wiki/Special:Search?search=%s'\
2010-08-10 13:10:10 +02:00
% phrase_for_url
else:
link = 'http://%s.wiktionary.org/wiki/Special:Search?search=%s'\
% (app.LANG, phrase_for_url)
id_ = item.connect('activate', self.visit_url_from_menuitem, link)
self.handlers[id_] = item
else:
if dict_link.find('%s') == -1:
# we must have %s in the url if not WIKTIONARY
item = Gtk.MenuItem.new_with_label(_(
'Dictionary URL is missing an "%s" and it is not WIKTIONARY'))
item.set_property('sensitive', False)
else:
2010-08-10 13:10:10 +02:00
link = dict_link % phrase_for_url
id_ = item.connect('activate', self.visit_url_from_menuitem,
link)
self.handlers[id_] = item
submenu.append(item)
search_link = app.config.get('search_engine')
if search_link.find('%s') == -1:
# we must have %s in the url
item = Gtk.MenuItem.new_with_label(
_('Web Search URL is missing an "%s"'))
item.set_property('sensitive', False)
else:
2013-01-08 12:03:50 +01:00
item = Gtk.MenuItem.new_with_mnemonic(_('Web _Search for it'))
2010-08-10 13:10:10 +02:00
link = search_link % phrase_for_url
id_ = item.connect('activate', self.visit_url_from_menuitem, link)
self.handlers[id_] = item
submenu.append(item)
2013-01-08 12:03:50 +01:00
item = Gtk.MenuItem.new_with_mnemonic(_('Open as _Link'))
id_ = item.connect('activate', self.visit_url_from_menuitem, link)
self.handlers[id_] = item
submenu.append(item)
menu.show_all()
def on_quote(self, widget):
self.emit('quote', self.selected_phrase)
def on_textview_button_press_event(self, widget, event):
# If we clicked on a taged text do NOT open the standard popup menu
# if normal text check if we have sth selected
self.selected_phrase = '' # do not move belove event button check!
if event.button != 3: # if not right click
return False
x, y = self.tv.window_to_buffer_coords(Gtk.TextWindowType.TEXT,
int(event.x), int(event.y))
iter_ = self.tv.get_iter_at_location(x, y)
if isinstance(iter_, tuple):
iter_ = iter_[1]
tags = iter_.get_tags()
if tags: # we clicked on sth special (it can be status message too)
for tag in tags:
tag_name = tag.get_property('name')
if tag_name in ('url', 'mail', 'xmpp', 'sth_at_sth'):
return True # we block normal context menu
# we check if sth was selected and if it was we assign
# selected_phrase variable
# so on_conversation_textview_populate_popup can use it
buffer_ = self.tv.get_buffer()
return_val = buffer_.get_selection_bounds()
if return_val: # if sth was selected when we right-clicked
# get the selected text
start_sel, finish_sel = return_val[0], return_val[1]
2013-01-03 18:04:54 +01:00
self.selected_phrase = buffer_.get_text(start_sel, finish_sel, True)
elif iter_.get_char() and ord(iter_.get_char()) > 31:
# we clicked on a word, do as if it's selected for context menu
start_sel = iter_.copy()
if not start_sel.starts_word():
start_sel.backward_word_start()
finish_sel = iter_.copy()
if not finish_sel.ends_word():
finish_sel.forward_word_end()
2013-01-03 18:21:38 +01:00
self.selected_phrase = buffer_.get_text(start_sel, finish_sel, True)
def on_open_link_activate(self, widget, kind, text):
helpers.launch_browser_mailer(kind, text)
def on_copy_link_activate(self, widget, text):
2013-01-12 10:34:04 +01:00
clip = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
clip.set_text(text, -1)
def on_start_chat_activate(self, widget, jid):
app.interface.new_chat_from_jid(self.account, jid)
def on_join_group_chat_menuitem_activate(self, widget, room_jid):
# Remove ?join
room_jid = room_jid.split('?')[0]
app.interface.join_gc_minimal(self.account, room_jid)
def on_add_to_roster_activate(self, widget, jid):
dialogs.AddNewContactWindow(self.account, jid)
def make_link_menu(self, event, kind, text):
xml = gtkgui_helpers.get_gtk_builder('chat_context_menu.ui')
menu = xml.get_object('chat_context_menu')
childs = menu.get_children()
if kind == 'url':
id_ = childs[0].connect('activate', self.on_copy_link_activate, text)
self.handlers[id_] = childs[0]
id_ = childs[1].connect('activate', self.on_open_link_activate, kind,
text)
self.handlers[id_] = childs[1]
childs[2].hide() # copy mail/jid address
childs[3].hide() # open mail composer
childs[4].hide() # jid section separator
childs[5].hide() # start chat
childs[6].hide() # join group chat
childs[7].hide() # add to roster
else: # It's a mail or a JID
# load muc icon
join_group_chat_menuitem = xml.get_object('join_group_chat_menuitem')
text = text.lower()
if text.startswith('xmpp:'):
text = text[5:]
id_ = childs[2].connect('activate', self.on_copy_link_activate, text)
self.handlers[id_] = childs[2]
id_ = childs[3].connect('activate', self.on_open_link_activate, kind,
text)
self.handlers[id_] = childs[3]
id_ = childs[5].connect('activate', self.on_start_chat_activate, text)
self.handlers[id_] = childs[5]
id_ = childs[6].connect('activate',
self.on_join_group_chat_menuitem_activate, text)
self.handlers[id_] = childs[6]
if self.account and app.connections[self.account].\
roster_supported:
id_ = childs[7].connect('activate',
self.on_add_to_roster_activate, text)
self.handlers[id_] = childs[7]
childs[7].show() # show add to roster menuitem
else:
childs[7].hide() # hide add to roster menuitem
if kind == 'xmpp':
id_ = childs[0].connect('activate', self.on_copy_link_activate,
'xmpp:' + text)
self.handlers[id_] = childs[0]
childs[0].set_label(_('Copy JID'))
childs[2].hide() # copy mail/jid address
childs[3].hide() # open mail composer
childs[4].hide() # jid section separator
elif kind == 'mail':
childs[2].set_label(_('Copy Email Address'))
childs[4].hide() # jid section separator
childs[5].hide() # start chat
childs[6].hide() # join group chat
childs[7].hide() # add to roster
if kind != 'xmpp':
childs[0].hide() # copy link location
childs[1].hide() # open link in browser
2013-01-12 10:34:04 +01:00
menu.attach_to_widget(self.tv, None)
menu.popup(None, None, None, None, event.button.button, event.time)
def hyperlink_handler(self, texttag, widget, event, iter_, kind):
if event.type == Gdk.EventType.BUTTON_PRESS:
begin_iter = iter_.copy()
# we get the begining of the tag
while not begin_iter.begins_tag(texttag):
begin_iter.backward_char()
end_iter = iter_.copy()
# we get the end of the tag
while not end_iter.ends_tag(texttag):
end_iter.forward_char()
# Detect XHTML-IM link
word = getattr(texttag, 'href', None)
if word:
if word.startswith('xmpp'):
kind = 'xmpp'
elif word.startswith('mailto:'):
kind = 'mail'
elif app.interface.sth_at_sth_dot_sth_re.match(word):
# it's a JID or mail
kind = 'sth_at_sth'
else:
2013-01-03 18:21:38 +01:00
word = self.tv.get_buffer().get_text(begin_iter, end_iter, True)
2013-01-12 10:34:04 +01:00
if event.button.button == 3: # right click
self.make_link_menu(event, kind, word)
return True
else:
self.plugin_modified = False
app.plugin_manager.extension_point(
'hyperlink_handler', word, kind, self,
self.tv.get_toplevel())
if self.plugin_modified:
return
# we launch the correct application
if kind == 'xmpp':
word = word[5:]
if '?' in word:
(jid, action) = word.split('?')
if action == 'join':
app.interface.join_gc_minimal(None, jid)
else:
self.on_start_chat_activate(None, jid)
else:
self.on_start_chat_activate(None, word)
2018-02-28 09:01:52 +01:00
# handle geo:-URIs
elif word[:4] == 'geo:':
location = word[4:]
lat, _, lon = location.partition(',')
if lon == '':
return
uri = 'https://www.openstreetmap.org/?' \
'mlat=%(lat)s&mlon=%(lon)s&zoom=16' % \
{'lat': lat, 'lon': lon}
helpers.launch_browser_mailer(kind, uri)
# other URIs
else:
helpers.launch_browser_mailer(kind, word)
def detect_and_print_special_text(self, otext, other_tags, graphics=True,
iter_=None, additional_data=None):
"""
Detect special text (emots & links & formatting), print normal text
before any special text it founds, then print special text (that happens
many times until last special text is printed) and then return the index
after *last* special text, so we can print it in
print_conversation_line()
"""
2013-01-10 22:54:53 +01:00
if not otext:
return
if additional_data is None:
additional_data = {}
buffer_ = self.tv.get_buffer()
if other_tags:
insert_tags_func = buffer_.insert_with_tags_by_name
else:
insert_tags_func = buffer_.insert
# detect_and_print_special_text() is also used by
# HtmlHandler.handle_specials() and there tags is Gtk.TextTag objects,
# not strings
if other_tags and isinstance(other_tags[0], Gtk.TextTag):
insert_tags_func = buffer_.insert_with_tags
index = 0
# Too many special elements (emoticons, LaTeX formulas, etc)
# may cause Gajim to freeze (see #5129).
# We impose an arbitrary limit of 100 specials per message.
specials_limit = 100
# add oob text to the end
try:
gajim_data = additional_data['gajim']
oob_url = gajim_data['oob_url']
except KeyError:
pass
else:
oob_desc = additional_data['gajim'].get('oob_desc', None)
if oob_desc is None:
oob_desc = _('URL:')
otext += '\n{} {}'.format(oob_desc, oob_url)
# basic: links + mail + formatting is always checked (we like that)
if app.config.get('emoticons_theme') and graphics:
# search for emoticons & urls
iterator = app.interface.emot_and_basic_re.finditer(otext)
else: # search for just urls + mail + formatting
iterator = app.interface.basic_pattern_re.finditer(otext)
if iter_:
end_iter = iter_
else:
end_iter = buffer_.get_end_iter()
for match in iterator:
start, end = match.span()
special_text = otext[start:end]
if start > index:
text_before_special_text = otext[index:start]
if not iter_:
end_iter = buffer_.get_end_iter()
# we insert normal text
if other_tags:
insert_tags_func(end_iter, text_before_special_text, *other_tags)
else:
buffer_.insert(end_iter, text_before_special_text)
index = end # update index
# now print it
self.print_special_text(special_text, other_tags, graphics=graphics,
iter_=end_iter, additional_data=additional_data)
specials_limit -= 1
if specials_limit <= 0:
break
# add the rest of text located in the index and after
insert_tags_func(end_iter, otext[index:], *other_tags)
return end_iter
def print_special_text(self, special_text, other_tags, graphics=True,
iter_=None, additional_data=None):
"""
Is called by detect_and_print_special_text and prints special text
(emots, links, formatting)
"""
if additional_data is None:
additional_data = {}
# PluginSystem: adding GUI extension point for ConversationTextview
self.plugin_modified = False
app.plugin_manager.extension_point('print_special_text', self,
special_text, other_tags, graphics, additional_data, iter_)
if self.plugin_modified:
return
tags = []
use_other_tags = True
text_is_valid_uri = False
2010-11-27 11:07:58 +01:00
is_xhtml_link = None
show_ascii_formatting_chars = \
app.config.get('show_ascii_formatting_chars')
buffer_ = self.tv.get_buffer()
# Detect XHTML-IM link
ttt = buffer_.get_tag_table()
tags_ = [(ttt.lookup(t) if isinstance(t, str) else t) for t in other_tags]
for t in tags_:
is_xhtml_link = getattr(t, 'href', None)
if is_xhtml_link:
break
# Check if we accept this as an uri
schemes = app.config.get('uri_schemes').split()
for scheme in schemes:
if special_text.startswith(scheme):
text_is_valid_uri = True
if iter_:
end_iter = iter_
else:
end_iter = buffer_.get_end_iter()
pixbuf = emoticons.get_pixbuf(special_text)
if app.config.get('emoticons_theme') and pixbuf and graphics:
# it's an emoticon
anchor = buffer_.create_child_anchor(end_iter)
img = TextViewImage(anchor,
GLib.markup_escape_text(special_text))
img.set_from_pixbuf(pixbuf)
img.show()
self.images.append(img)
self.tv.add_child_at_anchor(img, anchor)
2010-11-26 20:57:32 +01:00
elif special_text.startswith('www.') or \
special_text.startswith('ftp.') or \
2010-11-26 20:57:32 +01:00
text_is_valid_uri and not is_xhtml_link:
tags.append('url')
2010-11-26 20:57:32 +01:00
elif special_text.startswith('mailto:') and not is_xhtml_link:
tags.append('mail')
2010-11-26 20:57:32 +01:00
elif special_text.startswith('xmpp:') and not is_xhtml_link:
tags.append('xmpp')
elif app.interface.sth_at_sth_dot_sth_re.match(special_text) and\
2010-11-26 20:57:32 +01:00
not is_xhtml_link:
# it's a JID or mail
tags.append('sth_at_sth')
2010-11-26 20:57:32 +01:00
elif special_text.startswith('*'): # it's a bold text
tags.append('bold')
if special_text[1] == '/' and special_text[-2] == '/' and\
len(special_text) > 4: # it's also italic
tags.append('italic')
if not show_ascii_formatting_chars:
special_text = special_text[2:-2] # remove */ /*
elif special_text[1] == '_' and special_text[-2] == '_' and \
len(special_text) > 4: # it's also underlined
tags.append('underline')
if not show_ascii_formatting_chars:
special_text = special_text[2:-2] # remove *_ _*
else:
if not show_ascii_formatting_chars:
special_text = special_text[1:-1] # remove * *
elif special_text.startswith('/'): # it's an italic text
tags.append('italic')
if special_text[1] == '*' and special_text[-2] == '*' and \
len(special_text) > 4: # it's also bold
tags.append('bold')
if not show_ascii_formatting_chars:
special_text = special_text[2:-2] # remove /* */
elif special_text[1] == '_' and special_text[-2] == '_' and \
len(special_text) > 4: # it's also underlined
tags.append('underline')
if not show_ascii_formatting_chars:
special_text = special_text[2:-2] # remove /_ _/
else:
if not show_ascii_formatting_chars:
special_text = special_text[1:-1] # remove / /
elif special_text.startswith('_'): # it's an underlined text
tags.append('underline')
if special_text[1] == '*' and special_text[-2] == '*' and \
len(special_text) > 4: # it's also bold
tags.append('bold')
if not show_ascii_formatting_chars:
special_text = special_text[2:-2] # remove _* *_
elif special_text[1] == '/' and special_text[-2] == '/' and \
len(special_text) > 4: # it's also italic
tags.append('italic')
if not show_ascii_formatting_chars:
special_text = special_text[2:-2] # remove _/ /_
else:
if not show_ascii_formatting_chars:
special_text = special_text[1:-1] # remove _ _
else:
# It's nothing special
if use_other_tags:
insert_tags_func = buffer_.insert_with_tags_by_name
if other_tags and isinstance(other_tags[0], Gtk.TextTag):
insert_tags_func = buffer_.insert_with_tags
if other_tags:
insert_tags_func(end_iter, special_text, *other_tags)
else:
buffer_.insert(end_iter, special_text)
if tags:
all_tags = tags[:]
if use_other_tags:
all_tags += other_tags
# convert all names to TextTag
all_tags = [(ttt.lookup(t) if isinstance(t, str) else t) for t in all_tags]
buffer_.insert_with_tags(end_iter, special_text, *all_tags)
if 'url' in tags:
puny_text = helpers.puny_encode_url(special_text)
if puny_text != special_text:
puny_tags = []
if use_other_tags:
puny_tags += other_tags
if not puny_text:
puny_text = _('Invalid URL')
puny_tags = [(ttt.lookup(t) if isinstance(t, str) else t) for t in puny_tags]
buffer_.insert_with_tags(end_iter, " (%s)" % puny_text, *puny_tags)
def print_empty_line(self, iter_=None):
buffer_ = self.tv.get_buffer()
if not iter_:
iter_ = buffer_.get_end_iter()
buffer_.insert_with_tags_by_name(iter_, '\n', 'eol')
self.just_cleared = False
def get_end_mark(self, msg_stanza_id, start_mark):
for index, msg in enumerate(self.message_list):
if msg[2] == msg_stanza_id and msg[1] == start_mark:
try:
end_mark = self.message_list[index + 1][1]
end_mark_name = end_mark.get_name()
except IndexError:
# We are at the last message
end_mark = None
end_mark_name = None
log.debug('start mark: %s, end mark: %s, '
'replace message-list index: %s',
start_mark.get_name(), end_mark_name, index)
return end_mark, index
log.debug('stanza-id not in message list')
return None, None
def get_insert_mark(self, timestamp):
# message_list = [(timestamp, line_start_mark, msg_stanza_id)]
# We check if this is a new Message
try:
if self.message_list[-1][0] <= timestamp:
return None, None
except IndexError:
# We have no Messages in the TextView
return None, None
# Not a new Message
# Search for insertion point
for index, msg in enumerate(self.message_list):
if msg[0] > timestamp:
return msg[1], index
# Should not happen, but who knows
return None, None
def print_conversation_line(self, text, jid, kind, name, tim,
other_tags_for_name=None, other_tags_for_time=None, other_tags_for_text=None,
subject=None, old_kind=None, xhtml=None, simple=False, graphics=True,
2017-06-11 01:58:27 +02:00
displaymarking=None, msg_stanza_id=None, correct_id=None, additional_data=None,
encrypted=None):
"""
Print 'chat' type messages
"""
2017-11-03 16:16:54 +01:00
if additional_data is None:
additional_data = {}
buffer_ = self.tv.get_buffer()
buffer_.begin_user_action()
insert_mark = None
insert_mark_name = None
if kind == 'incoming_queue':
kind = 'incoming'
if old_kind == 'incoming_queue':
old_kind = 'incoming'
if not tim:
# For outgoing Messages and Status prints
tim = time.time()
corrected = False
if correct_id:
try:
index, insert_mark, old_txt = \
self.correct_message(correct_id, kind, name)
if correct_id in self.corrected_text_list:
self.corrected_text_list[msg_stanza_id] = \
self.corrected_text_list[correct_id] + '\n{}' \
.format(GLib.markup_escape_text(old_txt))
del self.corrected_text_list[correct_id]
else:
self.corrected_text_list[msg_stanza_id] = \
2018-01-22 11:55:32 +01:00
_('<b>Message corrected. Original message:</b>\n{}') \
.format(GLib.markup_escape_text(old_txt))
corrected = True
except TypeError:
log.debug('Message was not corrected !')
if not corrected:
# Get insertion point into TextView
insert_mark, index = self.get_insert_mark(tim)
if insert_mark:
insert_mark_name = insert_mark.get_name()
log.debug(
'Printed Line: %s, %s, %s, inserted after: %s'
', stanza-id: %s, correct-id: %s',
self.line, text, tim, insert_mark_name,
msg_stanza_id, correct_id)
if not insert_mark: # Texview is empty or Message is new
iter_ = buffer_.get_end_iter()
# Insert new Line if Textview is not empty
if buffer_.get_char_count() > 0 and not corrected:
buffer_.insert_with_tags_by_name(iter_, '\n', 'eol')
else:
iter_ = buffer_.get_iter_at_mark(insert_mark)
# Create a temporary mark at the start of the line
# with gravity=Left, so it will not move
# even if we insert directly at the mark iter
temp_mark = buffer_.create_mark('temp', iter_, left_gravity=True)
if text.startswith('/me '):
2014-02-15 21:09:13 +01:00
direction_mark = i18n.paragraph_direction_mark(str(text[3:]))
else:
direction_mark = i18n.paragraph_direction_mark(text)
2013-02-16 23:49:39 +01:00
# don't apply direction mark if it's status message
if kind == 'status':
direction_mark = i18n.direction_mark
# print the time stamp
self.print_time(text, kind, tim, simple, direction_mark,
other_tags_for_time, iter_)
2017-06-11 01:58:27 +02:00
if encrypted:
buffer_.insert_pixbuf(iter_, self.MESSAGE_ENCRYPTED_PIXBUF)
# If there's a displaymarking, print it here.
if displaymarking:
self.print_displaymarking(displaymarking, iter_=iter_)
# kind = info, we print things as if it was a status: same color, ...
if kind in ('error', 'info'):
kind = 'status'
other_text_tag = self.detect_other_text_tag(text, kind)
text_tags = []
if other_tags_for_text:
text_tags = other_tags_for_text[:] # create a new list
if other_text_tag:
text_tags.append(other_text_tag)
else: # not status nor /me
if app.config.get('chat_merge_consecutive_nickname'):
if kind != old_kind or self.just_cleared:
2013-02-16 23:49:39 +01:00
self.print_name(name, kind, other_tags_for_name,
direction_mark=direction_mark, iter_=iter_)
else:
self.print_real_text(app.config.get(
'chat_merge_consecutive_nickname_indent'),
mark=insert_mark, additional_data=additional_data)
else:
2013-02-16 23:49:39 +01:00
self.print_name(name, kind, other_tags_for_name,
direction_mark=direction_mark, iter_=iter_)
if kind == 'incoming':
text_tags.append('incomingtxt')
elif kind == 'outgoing':
text_tags.append('outgoingtxt')
self.print_subject(subject, iter_=iter_)
iter_ = self.print_real_text(text, text_tags, name, xhtml, graphics=graphics,
mark=insert_mark, additional_data=additional_data)
if corrected:
# Show Correction Icon
buffer_.create_tag(tag_name=msg_stanza_id)
buffer_.insert(iter_, ' ')
buffer_.insert_pixbuf(
iter_, ConversationTextview.MESSAGE_CORRECTED_PIXBUF)
tag_start_iter = iter_.copy()
tag_start_iter.backward_chars(2)
buffer_.apply_tag_by_name(msg_stanza_id, tag_start_iter, iter_)
# If we inserted a Line we add a new line at the end
if insert_mark:
buffer_.insert_with_tags_by_name(iter_, '\n', 'eol')
# We delete the temp mark and replace it with a mark
# that has gravity=right
temp_iter = buffer_.get_iter_at_mark(temp_mark)
buffer_.delete_mark(temp_mark)
new_mark = buffer_.create_mark(
str(self.line), temp_iter, left_gravity=False)
if not index:
# New Message
self.message_list.append((tim, new_mark, msg_stanza_id))
elif corrected:
# Replace the corrected message
self.message_list[index] = (tim, new_mark, msg_stanza_id)
else:
# We insert the message at index
self.message_list.insert(index, (tim, new_mark, msg_stanza_id))
if kind == 'incoming':
self.last_received_message_id[name] = (msg_stanza_id, new_mark)
elif kind == 'outgoing':
self.last_sent_message_id = (msg_stanza_id, new_mark)
if not insert_mark:
2018-03-20 22:19:30 +01:00
if self.autoscroll or kind == 'outgoing':
# we are at the end or we are sending something
2018-03-20 22:19:30 +01:00
self.scroll_to_end(force=True)
self.just_cleared = False
buffer_.end_user_action()
self.line += 1
return iter_
def get_time_to_show(self, tim, direction_mark=''):
"""
Get the time, with the day before if needed and return it. It DOESN'T
format a fuzzy time
"""
format_ = ''
# get difference in days since epoch (86400 = 24*3600)
# number of days since epoch for current time (in GMT) -
# number of days since epoch for message (in GMT)
2013-01-03 18:34:19 +01:00
diff_day = int(int(timegm(time.localtime())) / 86400 -\
int(timegm(tim)) / 86400)
if diff_day == 0.0:
day_str = ''
else:
#%i is day in year (1-365)
2011-03-06 22:18:28 +01:00
day_str = i18n.ngettext('Yesterday',
'%(nb_days)i days ago', diff_day, {'nb_days': diff_day},
{'nb_days': diff_day})
if day_str:
# strftime Windows bug has problems with Unicode
# see: http://bugs.python.org/issue8304
if os.name != 'nt':
format_ += i18n.direction_mark + day_str + direction_mark + ' '
else:
format_ += day_str + ' '
timestamp_str = app.config.get('time_stamp')
timestamp_str = helpers.from_one_line(timestamp_str)
format_ += timestamp_str
tim_format = time.strftime(format_, tim)
return tim_format
def detect_other_text_tag(self, text, kind):
if kind == 'status':
return kind
elif text.startswith('/me ') or text.startswith('/me\n'):
return kind
def print_time(self, text, kind, tim, simple, direction_mark, other_tags_for_time, iter_):
local_tim = time.localtime(tim)
buffer_ = self.tv.get_buffer()
current_print_time = app.config.get('print_time')
if current_print_time == 'always' and kind != 'info' and not simple:
timestamp_str = self.get_time_to_show(local_tim, direction_mark)
timestamp = time.strftime(timestamp_str, local_tim)
timestamp = direction_mark + timestamp + direction_mark
if other_tags_for_time:
buffer_.insert_with_tags_by_name(iter_, timestamp,
*other_tags_for_time)
else:
buffer_.insert(iter_, timestamp)
elif current_print_time == 'sometimes' and kind != 'info' and not simple:
every_foo_seconds = 60 * app.config.get(
'print_ichat_every_foo_minutes')
seconds_passed = tim - self.last_time_printout
if seconds_passed > every_foo_seconds:
self.last_time_printout = tim
if app.config.get('print_time_fuzzy') > 0:
tim_format = self.fc.fuzzy_time(
2017-12-06 21:32:13 +01:00
app.config.get('print_time_fuzzy'), local_tim)
else:
tim_format = self.get_time_to_show(local_tim, direction_mark)
buffer_.insert_with_tags_by_name(iter_, tim_format + '\n',
'time_sometimes')
def print_displaymarking(self, displaymarking, iter_=None):
bgcolor = displaymarking.getAttr('bgcolor') or '#FFF'
fgcolor = displaymarking.getAttr('fgcolor') or '#000'
text = displaymarking.getData()
if text:
buffer_ = self.tv.get_buffer()
if iter_:
end_iter = iter_
else:
end_iter = buffer_.get_end_iter()
tag = self.displaymarking_tags.setdefault(bgcolor + '/' + fgcolor,
buffer_.create_tag(None, background=bgcolor, foreground=fgcolor))
buffer_.insert_with_tags(end_iter, '[' + text + ']', tag)
end_iter = buffer_.get_end_iter()
buffer_.insert_with_tags(end_iter, ' ')
def print_name(self, name, kind, other_tags_for_name, direction_mark='',
iter_=None):
if name:
name_tags = []
buffer_ = self.tv.get_buffer()
if iter_:
end_iter = iter_
else:
end_iter = buffer_.get_end_iter()
if other_tags_for_name:
name_tags = other_tags_for_name[:] # create a new list
name_tags.append(kind)
before_str = app.config.get('before_nickname')
before_str = helpers.from_one_line(before_str)
after_str = app.config.get('after_nickname')
after_str = helpers.from_one_line(after_str)
format_ = before_str + name + direction_mark + after_str + ' '
2013-02-16 23:49:39 +01:00
buffer_.insert_with_tags_by_name(end_iter, format_, *name_tags)
def print_subject(self, subject, iter_=None):
if subject: # if we have subject, show it too!
subject = _('Subject: %s\n') % subject
buffer_ = self.tv.get_buffer()
if iter_:
end_iter = iter_
else:
end_iter = buffer_.get_end_iter()
buffer_.insert(end_iter, subject)
self.print_empty_line(end_iter)
def print_real_text(self, text, text_tags=None, name=None, xhtml=None,
graphics=True, mark=None, additional_data=None):
"""
Add normal and special text. call this to add text
"""
if text_tags is None:
text_tags = []
if additional_data is None:
additional_data = {}
buffer_ = self.tv.get_buffer()
if not mark:
iter_ = buffer_.get_end_iter()
else:
iter_ = buffer_.get_iter_at_mark(mark)
if xhtml:
try:
if name and (text.startswith('/me ') or text.startswith('/me\n')):
xhtml = xhtml.replace('/me', '<i>* %s</i>' % (name,), 1)
self.tv.display_html(xhtml, self.tv, self, iter_=iter_)
return
2013-01-01 23:18:36 +01:00
except Exception as e:
log.debug('Error processing xhtml: ' + str(e))
log.debug('with |' + xhtml + '|')
# /me is replaced by name if name is given
if name and (text.startswith('/me ') or text.startswith('/me\n')):
text = '* ' + name + text[3:]
text_tags.append('italic')
# PluginSystem: adding GUI extension point for ConversationTextview
self.plugin_modified = False
app.plugin_manager.extension_point('print_real_text', self,
text, text_tags, graphics, iter_, additional_data)
if self.plugin_modified:
if not mark:
return buffer_.get_end_iter()
else:
return buffer_.get_iter_at_mark(mark)
if not mark:
iter_ = buffer_.get_end_iter()
else:
iter_ = buffer_.get_iter_at_mark(mark)
# detect urls formatting and if the user has it on emoticons
return self.detect_and_print_special_text(text, text_tags, graphics=graphics,
iter_=iter_, additional_data=additional_data)