## plugins/tabbed_chat_window.py ## ## Gajim Team: ## - Yann Le Boulanger ## - Vincent Hanquez ## - Nikos Kouremenos ## ## Copyright (C) 2003-2005 Gajim Team ## ## This program 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 2 only. ## ## This program 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. ## import gtk import gtk.glade import pango import gobject import time import dialogs import history_window try: import gtkspell except: pass from common import gajim from common import i18n _ = i18n._ APP = i18n.APP gtk.glade.bindtextdomain(APP, i18n.DIR) gtk.glade.textdomain(APP) GTKGUI_GLADE = 'gtkgui.glade' class Chat: """Class for chat/groupchat windows""" def __init__(self, plugin, account, widget_name): self.xml = gtk.glade.XML(GTKGUI_GLADE, widget_name, APP) self.window = self.xml.get_widget(widget_name) self.widget_name = widget_name self.notebook = self.xml.get_widget('chat_notebook') self.notebook.remove_page(0) self.plugin = plugin self.account = account self.change_cursor = None self.xmls = {} self.tagIn = {} # holds tag for nick that talks to us self.tagOut = {} # holds tag for our nick self.tagStatus = {} # holds status messages self.nb_unread = {} self.last_time_printout = {} self.print_time_timeout_id = {} self.names = {} # what is printed in the tab (eg. user.name) self.childs = {} # holds the contents for every tab (VBox) #The following vars are used to keep history of user's messages self.sent_history = {} self.sent_history_pos = {} self.typing_new = {} self.orig_msg = {} # we check that on opening new windows self.always_compact_view = gajim.config.get('always_compact_view') def update_tags(self): for jid in self.tagIn: self.tagIn[jid].set_property('foreground', gajim.config.get('inmsgcolor')) self.tagOut[jid].set_property('foreground', gajim.config.get('outmsgcolor')) self.tagStatus[jid].set_property('foreground', gajim.config.get('statusmsgcolor')) def update_print_time(self): if gajim.config.get('print_time') != 'sometimes': list_jid = self.print_time_timeout_id.keys() for jid in list_jid: gobject.source_remove(self.print_time_timeout_id[jid]) del self.print_time_timeout_id[jid] else: for jid in self.xmls: if self.print_time_timeout_id.has_key(jid): continue self.print_time_timeout(jid) self.print_time_timeout_id[jid] = \ gobject.timeout_add(300000, self.print_time_timeout, jid) def show_title(self): """redraw the window's title""" unread = 0 for jid in self.nb_unread: unread += self.nb_unread[jid] start = "" if unread > 1: start = '[' + str(unread) + '] ' elif unread == 1: start = '* ' chat = self.names[jid] if len(self.xmls) > 1: # if more than one tab in the same window if self.widget_name == 'tabbed_chat_window': chat = 'Chat' elif self.widget_name == 'groupchat_window': chat = 'Groupchat' title = start + chat if len(gajim.connections) >= 2: # if we have 2 or more accounts title = title + _(' (account: ') + self.account + ')' self.window.set_title(title) def redraw_tab(self, jid): """redraw the label of the tab""" start = '' if self.nb_unread[jid] > 1: start = '[' + str(self.nb_unread[jid]) + '] ' elif self.nb_unread[jid] == 1: start = '* ' child = self.childs[jid] if self.widget_name == 'tabbed_chat_window': nickname = self.notebook.get_tab_label(child).get_children()[1] elif self.widget_name == 'groupchat_window': nickname = self.notebook.get_tab_label(child).get_children()[0] #FIXME: when gtk2.4 is OOOOLD do it via glade2.10+ if gtk.pygtk_version >= (2, 6, 0) and gtk.gtk_version >= (2, 6, 0): nickname.set_max_width_chars(10) nickname.set_text(start + self.names[jid]) def on_window_destroy(self, widget, kind): #kind is 'chats' or 'gc' '''clean self.plugin.windows[self.account][kind]''' for jid in self.xmls: windows = self.plugin.windows[self.account][kind] if kind == 'chats': # send 'gone' chatstate to every tabbed chat tab windows[jid].send_chatstate('gone') gobject.source_remove(self.possible_paused_timeout_id[jid]) gobject.source_remove(self.possible_inactive_timeout_id[jid]) if self.plugin.systray_enabled and self.nb_unread[jid] > 0: self.plugin.systray.remove_jid(jid, self.account) del windows[jid] if self.print_time_timeout_id.has_key(jid): gobject.source_remove(self.print_time_timeout_id[jid]) if windows.has_key('tabbed'): del windows['tabbed'] def get_active_jid(self): notebook = self.notebook active_child = notebook.get_nth_page(notebook.get_current_page()) active_jid = '' for jid in self.xmls: if self.childs[jid] == active_child: active_jid = jid break return active_jid def on_close_button_clicked(self, button, jid): """When close button is pressed: close a tab""" self.remove_tab(jid) def on_history_button_clicked(self, widget): """When history button is pressed: call history window""" jid = self.get_active_jid() if self.plugin.windows['logs'].has_key(jid): self.plugin.windows['logs'][jid].window.present() else: self.plugin.windows['logs'][jid] = history_window.\ HistoryWindow(self.plugin, jid, self.account) def on_chat_window_focus_in_event(self, widget, event): """When window gets focus""" jid = self.get_active_jid() textview = self.xmls[jid].get_widget('conversation_textview') buffer = textview.get_buffer() end_iter = buffer.get_end_iter() end_rect = textview.get_iter_location(end_iter) visible_rect = textview.get_visible_rect() if end_rect.y <= (visible_rect.y + visible_rect.height): #we are at the end if self.nb_unread[jid] > 0: self.nb_unread[jid] = 0 self.redraw_tab(jid) self.show_title() if self.plugin.systray_enabled: self.plugin.systray.remove_jid(jid, self.account) def on_compact_view_menuitem_activate(self, widget): isactive = widget.get_active() self.set_compact_view(isactive) def remove_possible_switch_to_menuitems(self, menu): ''' remove duplicate 'Switch to' if they exist and return clean menu''' childs = menu.get_children() childs_no = len(childs) if self.widget_name == 'groupchat_window': no_more_than = 6 elif self.widget_name == 'tabbed_chat_window': no_more_than = 4 if childs_no > no_more_than: # we have switch to which we should remove how_many = childs_no - no_more_than # how many to remove for child_cnt in range(how_many): real_pos = child_cnt + no_more_than menu.remove(childs[real_pos]) return menu def on_chat_window_button_press_event(self, widget, event): '''If right-clicked, show popup''' if event.button == 3: # right click if self.widget_name == 'groupchat_window': menu = self.gc_popup_menu childs = menu.get_children() childs[0].show() # history_menuitem # compact_view_menuitem childs[5].set_active(self.compact_view_current_state) elif self.widget_name == 'tabbed_chat_window': menu = self.tabbed_chat_popup_menu childs = menu.get_children() # compact_view_menuitem childs[3].set_active(self.compact_view_current_state) menu = self.remove_possible_switch_to_menuitems(menu) # common menuitems (tab switches) if len(self.xmls) > 1: # if there is more than one tab menu.append(gtk.MenuItem()) # seperator for jid in self.xmls: if jid != self.get_active_jid(): item = gtk.ImageMenuItem(_('Switch to %s') % self.names[jid]) img = gtk.image_new_from_stock(gtk.STOCK_JUMP_TO, gtk.ICON_SIZE_MENU) item.set_image(img) item.connect('activate', lambda obj, jid:self.set_active_tab( jid), jid) menu.append(item) # show the menu menu.popup(None, None, None, event.button, event.time) menu.show_all() def on_chat_notebook_switch_page(self, notebook, page, page_num): # get the index of the page and then the page that we're leaving old_no = notebook.get_current_page() old_child = notebook.get_nth_page(old_no) new_child = notebook.get_nth_page(page_num) old_jid = '' new_jid = '' for jid in self.xmls: if self.childs[jid] == new_child: new_jid = jid elif self.childs[jid] == old_child: old_jid = jid if old_jid != '' and new_jid != '': # we found both jids break # so stop looping if self.widget_name == 'tabbed_chat_window': # send chatstate inactive to the one we're leaving # and active to the one we visit if old_jid != '': self.send_chatstate('inactive', old_jid) self.send_chatstate('active', new_jid) conversation_textview = self.xmls[new_jid].get_widget( 'conversation_textview') conversation_buffer = conversation_textview.get_buffer() end_iter = conversation_buffer.get_end_iter() end_rect = conversation_textview.get_iter_location(end_iter) visible_rect = conversation_textview.get_visible_rect() if end_rect.y <= (visible_rect.y + visible_rect.height): #we are at the end if self.nb_unread[new_jid] > 0: self.nb_unread[new_jid] = 0 self.redraw_tab(new_jid) self.show_title() if self.plugin.systray_enabled: self.plugin.systray.remove_jid(new_jid, self.account) conversation_textview.grab_focus() def set_active_tab(self, jid): self.notebook.set_current_page(self.notebook.page_num(self.childs[jid])) def remove_tab(self, jid, kind): #kind is 'chats' or 'gc' if len(self.xmls) == 1: # only one tab so destroy window # we check and possibly save positions here, because Ctrl+W, Escape # etc.. call remove_tab so similar code in delete_event callbacks # is not enough if gajim.config.get('saveposition'): if kind == 'chats': x, y = self.window.get_position() gajim.config.set('chat-x-position', x) gajim.config.set('chat-y-position', y) width, height = self.window.get_size() gajim.config.set('chat-width', width) gajim.config.set('chat-height', height) elif kind == 'gc': gajim.config.set('gc-hpaned-position', self.hpaned_position) x, y = self.window.get_position() gajim.config.set('gc-x-position', x) gajim.config.set('gc-y-position', y) width, height = self.window.get_size() gajim.config.set('gc-width', width) gajim.config.set('gc-height', height) self.window.destroy() return if self.nb_unread[jid] > 0: self.nb_unread[jid] = 0 self.show_title() if self.plugin.systray_enabled: self.plugin.systray.remove_jid(jid, self.account) if self.print_time_timeout_id.has_key(jid): gobject.source_remove(self.print_time_timeout_id[jid]) del self.print_time_timeout_id[jid] self.notebook.remove_page(self.notebook.page_num(self.childs[jid])) if len(self.xmls) == 2: # one that remains and one that we'll remove, 1 tab remains self.notebook.set_show_tabs(False) del self.plugin.windows[self.account][kind][jid] del self.nb_unread[jid] del gajim.last_message_time[self.account][jid] del self.last_time_printout[jid] del self.xmls[jid] del self.tagIn[jid] del self.tagOut[jid] del self.tagStatus[jid] self.show_title() def bring_scroll_to_end(self, textview, diff_y = 0): ''' scrolls to the end of textview if end is not visible ''' buffer = textview.get_buffer() buffer.begin_user_action() at_the_end = False end_iter = buffer.get_end_iter() end_rect = textview.get_iter_location(end_iter) visible_rect = textview.get_visible_rect() # scroll only if expected end is not visible if end_rect.y >= (visible_rect.y + visible_rect.height + diff_y): gobject.idle_add(self.scroll_to_end_iter, textview) def scroll_to_end_iter(self, textview): buffer = textview.get_buffer() end_iter = buffer.get_end_iter() textview.scroll_to_iter(end_iter, 0, False, 1, 1) return False def size_request(self, message_textview , requisition, xml_top): ''' When message_textview changes its size. If the new height will enlarge the window, enable the scrollbar automatic policy''' if message_textview.window is None: return message_scrolledwindow = xml_top.get_widget('message_scrolledwindow') conversation_scrolledwindow = \ xml_top.get_widget('conversation_scrolledwindow') conversation_textview = \ xml_top.get_widget('conversation_textview') min_height = conversation_scrolledwindow.get_property('height-request') conversation_height = conversation_textview.window.get_size()[1] message_height = message_textview.window.get_size()[1] # new tab is not exposed yet if conversation_height < 2: return if conversation_height < min_height: min_height = conversation_height diff_y = message_height - requisition.height if diff_y is not 0: if conversation_height + diff_y < min_height: message_scrolledwindow.set_property('vscrollbar-policy', gtk.POLICY_AUTOMATIC) message_scrolledwindow.set_property('hscrollbar-policy', gtk.POLICY_AUTOMATIC) message_scrolledwindow.set_property('height-request', message_height + \ conversation_height - min_height) self.bring_scroll_to_end(message_textview) else: message_scrolledwindow.set_property('vscrollbar-policy', gtk.POLICY_NEVER) message_scrolledwindow.set_property('hscrollbar-policy', gtk.POLICY_NEVER) message_scrolledwindow.set_property('height-request', -1) self.bring_scroll_to_end(conversation_textview, diff_y - 18) return True def new_tab(self, jid): #FIXME: text formating buttons will be hidden in 0.8 release for w in ['bold_togglebutton', 'italic_togglebutton', 'underline_togglebutton']: self.xmls[jid].get_widget(w).set_no_show_all(True) self.set_compact_view(self.always_compact_view) self.nb_unread[jid] = 0 gajim.last_message_time[self.account][jid] = 0 self.last_time_printout[jid] = float(0.0) if gajim.config.get('use_speller') and 'gtkspell' in globals(): message_textview = self.xmls[jid].get_widget('message_textview') try: gtkspell.Spell(message_textview) except gobject.GError, msg: dialogs.ErrorDialog(str(msg), _('If that is not your language for which you want to highlight misspelled words, then please set your $LANG as appropriate. Eg. for French do export LANG=fr_FR or export LANG=fr_FR.UTF-8 in ~/.bash_profile or to make it global in /etc/profile.\n\nHighlighting misspelled words feature will not be used')).get_response() gajim.config.set('use_speller', False) conversation_textview = self.xmls[jid].get_widget( 'conversation_textview') conversation_buffer = conversation_textview.get_buffer() end_iter = conversation_buffer.get_end_iter() conversation_buffer.create_mark('end', end_iter, False) self.tagIn[jid] = conversation_buffer.create_tag('incoming') color = gajim.config.get('inmsgcolor') self.tagIn[jid].set_property('foreground', color) self.tagOut[jid] = conversation_buffer.create_tag('outgoing') color = gajim.config.get('outmsgcolor') self.tagOut[jid].set_property('foreground', color) self.tagStatus[jid] = conversation_buffer.create_tag('status') color = gajim.config.get('statusmsgcolor') self.tagStatus[jid].set_property('foreground', color) tag = conversation_buffer.create_tag('marked') color = gajim.config.get('markedmsgcolor') tag.set_property('foreground', color) tag.set_property('weight', pango.WEIGHT_BOLD) tag = conversation_buffer.create_tag('time_sometimes') tag.set_property('foreground', '#9e9e9e') tag.set_property('scale', pango.SCALE_SMALL) tag.set_property('justification', gtk.JUSTIFY_CENTER) tag = conversation_buffer.create_tag('small') tag.set_property('scale', pango.SCALE_SMALL) tag = conversation_buffer.create_tag('grey') tag.set_property('foreground', '#9e9e9e') tag = conversation_buffer.create_tag('url') tag.set_property('foreground', '#0000ff') tag.set_property('underline', pango.UNDERLINE_SINGLE) tag.connect('event', self.hyperlink_handler, 'url') tag = conversation_buffer.create_tag('mail') tag.set_property('foreground', '#0000ff') tag.set_property('underline', pango.UNDERLINE_SINGLE) tag.connect('event', self.hyperlink_handler, 'mail') tag = conversation_buffer.create_tag('bold') tag.set_property('weight', pango.WEIGHT_BOLD) tag = conversation_buffer.create_tag('italic') tag.set_property('style', pango.STYLE_ITALIC) tag = conversation_buffer.create_tag('underline') tag.set_property('underline', pango.UNDERLINE_SINGLE) self.xmls[jid].signal_autoconnect(self) conversation_scrolledwindow = self.xmls[jid].get_widget( 'conversation_scrolledwindow') conversation_scrolledwindow.get_vadjustment().connect('value-changed', self.on_conversation_vadjustment_value_changed) if len(self.xmls) > 1: self.notebook.set_show_tabs(True) if self.widget_name == 'tabbed_chat_window': xm = gtk.glade.XML(GTKGUI_GLADE, 'chat_tab_hbox', APP) tab_hbox = xm.get_widget('chat_tab_hbox') elif self.widget_name == 'groupchat_window': xm = gtk.glade.XML(GTKGUI_GLADE, 'groupchat_tab_hbox', APP) tab_hbox = xm.get_widget('groupchat_tab_hbox') xm.signal_connect('on_close_button_clicked', self.on_close_button_clicked, jid) child = self.childs[jid] self.notebook.append_page(child, tab_hbox) message_textview = self.xmls[jid].get_widget('message_textview') message_textview.connect('size-request', self.size_request, self.xmls[jid]) #init new sent history for this conversation self.sent_history[jid] = [] self.sent_history_pos[jid] = 0 self.typing_new[jid] = True self.orig_msg[jid] = '' self.show_title() def on_conversation_textview_key_press_event(self, widget, event): """Do not block these events and send them to the notebook""" if event.state & gtk.gdk.CONTROL_MASK: if event.keyval == gtk.keysyms.Tab: # CTRL + TAB self.notebook.emit('key_press_event', event) elif event.keyval == gtk.keysyms.ISO_Left_Tab: # CTRL + SHIFT + TAB self.notebook.emit('key_press_event', event) elif event.keyval == gtk.keysyms.Page_Down: # CTRL + PAGE DOWN self.notebook.emit('key_press_event', event) elif event.keyval == gtk.keysyms.Page_Up: # CTRL + PAGE UP self.notebook.emit('key_press_event', event) elif event.keyval == gtk.keysyms.l or \ event.keyval == gtk.keysyms.L: # CTRL + L message_textview = self.xmls[jid].get_widget('message_textview') conversation_textview.get_buffer().set_text('') elif event.keyval == gtk.keysyms.v: # CTRL + V jid = self.get_active_jid() message_textview = self.xmls[jid].get_widget('message_textview') if not message_textview.is_focus(): message_textview.grab_focus() message_textview.emit('key_press_event', event) def on_chat_notebook_key_press_event(self, widget, event): st = '1234567890' # zero is here cause humans count from 1, pc from 0 :P jid = self.get_active_jid() if event.keyval == gtk.keysyms.Escape: # ESCAPE if self.widget_name == 'tabbed_chat_window': self.remove_tab(jid) elif event.keyval == gtk.keysyms.F4 and \ (event.state & gtk.gdk.CONTROL_MASK): # CTRL + F4 self.remove_tab(jid) elif event.keyval == gtk.keysyms.w and \ (event.state & gtk.gdk.CONTROL_MASK): # CTRL + W self.remove_tab(jid) elif event.string and event.string in st and \ (event.state & gtk.gdk.MOD1_MASK): # alt + 1,2,3.. self.notebook.set_current_page(st.index(event.string)) elif event.keyval == gtk.keysyms.c and \ (event.state & gtk.gdk.MOD1_MASK): # alt + C toggles compact view self.set_compact_view(not self.compact_view_current_state) elif event.keyval == gtk.keysyms.Page_Down: if event.state & gtk.gdk.SHIFT_MASK: # SHIFT + PAGE DOWN conversation_textview = self.xmls[jid].\ get_widget('conversation_textview') rect = conversation_textview.get_visible_rect() iter = conversation_textview.get_iter_at_location(rect.x,\ rect.y + rect.height) conversation_textview.scroll_to_iter(iter, 0.1, True, 0, 0) elif event.keyval == gtk.keysyms.Page_Up: if event.state & gtk.gdk.SHIFT_MASK: # SHIFT + PAGE UP conversation_textview = self.xmls[jid].\ get_widget('conversation_textview') rect = conversation_textview.get_visible_rect() iter = conversation_textview.get_iter_at_location(rect.x, rect.y) conversation_textview.scroll_to_iter(iter, 0.1, True, 0, 1) # or event.keyval == gtk.keysyms.KP_Up elif event.keyval == gtk.keysyms.Up: if event.state & gtk.gdk.SHIFT_MASK: # SHIFT + UP conversation_scrolledwindow = self.xml.get_widget('conversation_scrolledwindow') conversation_scrolledwindow.emit('scroll-child', gtk.SCROLL_PAGE_BACKWARD, False) elif event.keyval == gtk.keysyms.ISO_Left_Tab: # SHIFT + TAB if event.state & gtk.gdk.CONTROL_MASK: # CTRL + SHIFT + TAB current = self.notebook.get_current_page() if current > 0: self.notebook.prev_page() else: # traverse for ever (eg. don't stop at first tab) self.notebook.set_current_page(self.notebook.get_n_pages()-1) elif event.keyval == gtk.keysyms.Tab: # TAB if event.state & gtk.gdk.CONTROL_MASK: # CTRL + TAB current = self.notebook.get_current_page() if current < (self.notebook.get_n_pages()-1): self.notebook.next_page() else: # traverse for ever (eg. don't stop at last tab) self.notebook.set_current_page(0) elif (event.keyval == gtk.keysyms.l or event.keyval == gtk.keysyms.L) \ and event.state & gtk.gdk.CONTROL_MASK: # CTRL + L conversation_textview = self.xmls[jid].\ get_widget('conversation_textview') conversation_textview.get_buffer().set_text('') elif event.keyval == gtk.keysyms.v and event.state & gtk.gdk.CONTROL_MASK: # CTRL + V jid = self.get_active_jid() message_textview = self.xmls[jid].get_widget('message_textview') if not message_textview.is_focus(): message_textview.grab_focus() message_textview.emit('key_press_event', event) elif event.state & gtk.gdk.CONTROL_MASK or \ (event.keyval == gtk.keysyms.Control_L) or \ (event.keyval == gtk.keysyms.Control_R): # we pressed a control key or ctrl+sth: we don't block # the event in order to let ctrl+c (copy text) and # others do their default work pass else: # it's a normal key press make sure message_textview has focus message_textview = self.xmls[jid].get_widget('message_textview') if not message_textview.is_focus(): message_textview.grab_focus() message_textview.emit('key_press_event', event) def on_conversation_vadjustment_value_changed(self, widget): jid = self.get_active_jid() if not self.nb_unread[jid]: return textview = self.xmls[jid].get_widget('conversation_textview') buffer = textview.get_buffer() end_iter = buffer.get_end_iter() end_rect = textview.get_iter_location(end_iter) visible_rect = textview.get_visible_rect() if end_rect.y <= (visible_rect.y + visible_rect.height) and \ self.window.is_active(): #we are at the end self.nb_unread[jid] = 0 self.redraw_tab(jid) self.show_title() if self.plugin.systray_enabled: self.plugin.systray.remove_jid(jid, self.account) def on_conversation_textview_motion_notify_event(self, widget, event): '''change the cursor to a hand when we are over a mail or an url''' jid = self.get_active_jid() x, y, spam = widget.window.get_pointer() x, y = widget.window_to_buffer_coords(gtk.TEXT_WINDOW_TEXT, x, y) tags = widget.get_iter_at_location(x, y).get_tags() if self.change_cursor: widget.get_window(gtk.TEXT_WINDOW_TEXT).set_cursor( gtk.gdk.Cursor(gtk.gdk.XTERM)) self.change_cursor = None tag_table = widget.get_buffer().get_tag_table() for tag in tags: if tag == tag_table.lookup('url') or tag == tag_table.lookup('mail'): widget.get_window(gtk.TEXT_WINDOW_TEXT).set_cursor( gtk.gdk.Cursor(gtk.gdk.HAND2)) self.change_cursor = tag return False def on_clear(self, widget, textview): '''clear text in the given textview''' buffer = textview.get_buffer() start, end = buffer.get_bounds() buffer.delete(start, end) def visit_url_from_menuitem(self, widget, link): '''basically it filters out the widget instance''' self.plugin.launch_browser_mailer('url', link) def on_conversation_textview_populate_popup(self, textview, menu): '''we override the default context menu and we prepend Clear and if we have sth selected we show a submenu with actions on the phrase (see on_conversation_textview_button_press_event)''' item = gtk.MenuItem() # seperator menu.prepend(item) item = gtk.ImageMenuItem(gtk.STOCK_CLEAR) menu.prepend(item) item.connect('activate', self.on_clear, textview) if self.selected_phrase: s = self.selected_phrase if len(s) > 25: #FIXME: do me with pango ellipseEND when gtk24 is OLD s = s[:21] + '...' item = gtk.MenuItem(_('Actions for "%s"') % s) menu.prepend(item) submenu = gtk.Menu() item.set_submenu(submenu) always_use_en = gajim.config.get('always_english_wikipedia') if always_use_en: link = 'http://en.wikipedia.org/wiki/%s' % self.selected_phrase else: link = 'http://%s.wikipedia.org/wiki/%s'\ %(gajim.LANG, self.selected_phrase) item = gtk.MenuItem(_('Read _Wikipedia Article')) item.connect('activate', self.visit_url_from_menuitem, link) submenu.append(item) item = gtk.MenuItem(_('Look it up in _Dictionary')) link = gajim.config.get('dictionary_url') + self.selected_phrase item.connect('activate', self.visit_url_from_menuitem, link) submenu.append(item) item = gtk.MenuItem(_('Web _Search for it')) gajim.config.get('search_engine') link = gajim.config.get('search_engine') + self.selected_phrase +\ '&sourceid=gajim' item.connect('activate', self.visit_url_from_menuitem, link) submenu.append(item) menu.show_all() def on_conversation_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 = '' if event.button != 3: # if not right click return False win = widget.get_window(gtk.TEXT_WINDOW_TEXT) x, y = widget.window_to_buffer_coords(gtk.TEXT_WINDOW_TEXT, int(event.x), int(event.y)) iter = widget.get_iter_at_location(x, y) 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 'url' in tag_name or 'mail' in tag_name: 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 = widget.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] self.selected_phrase = buffer.get_text(start_sel, finish_sel) def print_time_timeout(self, jid): if not jid in self.xmls.keys(): return False if gajim.config.get('print_time') == 'sometimes': textview = self.xmls[jid].get_widget('conversation_textview') buffer = textview.get_buffer() end_iter = buffer.get_end_iter() tim = time.localtime() tim_format = time.strftime('%H:%M', tim) buffer.insert_with_tags_by_name(end_iter, '\n' + tim_format, 'time_sometimes') #scroll to the end of the textview end_rect = textview.get_iter_location(end_iter) visible_rect = textview.get_visible_rect() if end_rect.y <= (visible_rect.y + visible_rect.height): #we are at the end self.scroll_to_end(textview) return True # loop again if self.print_time_timeout_id.has_key(jid): del self.print_time_timeout_id[jid] return False def on_open_link_activate(self, widget, kind, text): self.plugin.launch_browser_mailer(kind, text) def on_copy_link_activate(self, widget, text): clip = gtk.clipboard_get() clip.set_text(text) def on_start_chat_activate(self, widget, jid): self.plugin.roster.new_chat_from_jid(self.account, jid) def on_join_group_chat_menuitem_activate(self, widget, jid): room, server = jid.split('@') if self.plugin.windows[self.account].has_key('join_gc'): instance = self.plugin.windows[self.account]['join_gc'] instance.xml.get_widget('server_entry').set_text(server) instance.xml.get_widget('room_entry').set_text(room) self.plugin.windows[self.account]['join_gc'].window.present() else: try: self.plugin.windows[self.account]['join_gc'] = \ dialogs.JoinGroupchatWindow(self.plugin, self.account, server, room) except RuntimeError: pass def on_add_to_roster_activate(self, widget, jid): dialogs.AddNewContactWindow(self.plugin, self.account, jid) def make_link_menu(self, event, kind, text): xml = gtk.glade.XML(GTKGUI_GLADE, 'chat_context_menu', APP) menu = xml.get_widget('chat_context_menu') childs = menu.get_children() if kind == 'url': childs[0].connect('activate', self.on_copy_link_activate, text) childs[1].connect('activate', self.on_open_link_activate, kind, text) childs[2].hide() # copy mail address childs[3].hide() # open mail composer childs[4].hide() # jid section seperator 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 childs[2].connect('activate', self.on_copy_link_activate, text) childs[3].connect('activate', self.on_open_link_activate, kind, text) childs[5].connect('activate', self.on_start_chat_activate, text) childs[6].connect('activate', self.on_join_group_chat_menuitem_activate, text) allow_add = False if gajim.contacts[self.account].has_key(text): c = gajim.contacts[self.account][text][0] if _('not in the roster') in c.groups: allow_add = True else: # he's not at all in the account contacts allow_add = True if allow_add: childs[7].connect('activate', self.on_add_to_roster_activate, text) childs[7].show() # show add to roster menuitem else: childs[7].hide() # hide add to roster menuitem childs[0].hide() # copy link location childs[1].hide() # open link in browser menu.popup(None, None, None, event.button, event.time) def hyperlink_handler(self, texttag, widget, event, iter, kind): if event.type == gtk.gdk.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() word = begin_iter.get_text(end_iter) if event.button == 3: # right click self.make_link_menu(event, kind, word) else: #we launch the correct application self.plugin.launch_browser_mailer(kind, word) def detect_and_print_special_text(self, otext, jid, other_tags): textview = self.xmls[jid].get_widget('conversation_textview') buffer = textview.get_buffer() start = 0 end = 0 index = 0 # basic: links + mail + formatting is always checked (we like that) if gajim.config.get('useemoticons'): # search for emoticons & urls iterator = self.plugin.emot_and_basic_re.finditer(otext) else: # search for just urls + mail + formatting iterator = self.plugin.basic_pattern_re.finditer(otext) for match in iterator: start, end = match.span() special_text = otext[start:end] if start != 0: text_before_special_text = otext[index:start] end_iter = buffer.get_end_iter() buffer.insert_with_tags_by_name(end_iter, text_before_special_text, *other_tags) index = end # update index #now print it self.print_special_text(special_text, other_tags, textview) return index def print_special_text(self, special_text, other_tags, textview): tags = [] use_other_tags = True buffer = textview.get_buffer() possible_emot_ascii_caps = special_text.upper() # emoticons keys are CAPS if possible_emot_ascii_caps in self.plugin.emoticons.keys(): #it's an emoticon emot_ascii = possible_emot_ascii_caps end_iter = buffer.get_end_iter() anchor = buffer.create_child_anchor(end_iter) img = gtk.Image() img.set_from_file(self.plugin.emoticons[emot_ascii]) img.show() #add with possible animation textview.add_child_at_anchor(img, anchor) elif special_text.startswith('mailto:'): #it's a mail tags.append('mail') use_other_tags = False elif self.plugin.sth_at_sth_dot_sth_re.match(special_text): #it's a mail tags.append('mail') use_other_tags = False elif special_text.startswith('*'): # it's a bold text tags.append('bold') if special_text[1] == '/': # it's also italic tags.append('italic') special_text = special_text[2:-2] # remove */ /* elif special_text[1] == '_': # it's also underlined tags.append('underline') special_text = special_text[2:-2] # remove *_ _* else: special_text = special_text[1:-1] # remove * * elif special_text.startswith('/'): # it's an italic text tags.append('italic') if special_text[1] == '*': # it's also bold tags.append('bold') special_text = special_text[2:-2] # remove /* */ elif special_text[1] == '_': # it's also underlined tags.append('underline') special_text = special_text[2:-2] # remove /_ _/ else: special_text = special_text[1:-1] # remove / / elif special_text.startswith('_'): # it's an underlined text tags.append('underline') if special_text[1] == '*': # it's also bold tags.append('bold') special_text = special_text[2:-2] # remove _* *_ elif special_text[1] == '/': # it's also italic tags.append('italic') special_text = special_text[2:-2] # remove _/ /_ else: special_text = special_text[1:-1] # remove _ _ else: #it's a url tags.append('url') use_other_tags = False if len(tags) > 0: end_iter = buffer.get_end_iter() all_tags = tags[:] if use_other_tags: all_tags += other_tags buffer.insert_with_tags_by_name(end_iter, special_text, *all_tags) def scroll_to_end(self, textview): parent = textview.get_parent() buffer = textview.get_buffer() textview.scroll_to_mark(buffer.get_mark('end'), 0, True, 0, 1) adjustment = parent.get_hadjustment() adjustment.set_value(0) return False def print_empty_line(self, jid): textview = self.xmls[jid].get_widget('conversation_textview') buffer = textview.get_buffer() end_iter = buffer.get_end_iter() buffer.insert(end_iter, '\n') def print_conversation_line(self, text, jid, kind, name, tim, other_tags_for_name = [], other_tags_for_time = [], other_tags_for_text = [], count_as_new = True, subject = None): '''' prints 'chat' type messages ''' textview = self.xmls[jid].get_widget('conversation_textview') buffer = textview.get_buffer() buffer.begin_user_action() at_the_end = False end_iter = buffer.get_end_iter() end_rect = textview.get_iter_location(end_iter) visible_rect = textview.get_visible_rect() if end_rect.y <= (visible_rect.y + visible_rect.height): at_the_end = True # FIXME: who gives us text that is not a string? if not text: text = '' if buffer.get_char_count() > 0: buffer.insert(end_iter, '\n') update_time = True if kind == 'incoming_queue': kind = 'incoming' update_time = False # print the time stamp if gajim.config.get('print_time') == 'always': if not tim: tim = time.localtime() before_str = gajim.config.get('before_time') after_str = gajim.config.get('after_time') format = before_str + '%H:%M:%S' + after_str tim_format = time.strftime(format, tim) buffer.insert_with_tags_by_name(end_iter, tim_format + ' ', *other_tags_for_time) elif gajim.config.get('print_time') == 'sometimes': every_foo_seconds = 60 * gajim.config.get( 'print_ichat_every_foo_minutes') seconds_passed = time.time() - self.last_time_printout[jid] if seconds_passed > every_foo_seconds: self.last_time_printout[jid] = time.time() end_iter = buffer.get_end_iter() tim = time.localtime() tim_format = time.strftime('%H:%M', tim) buffer.insert_with_tags_by_name(end_iter, tim_format + '\n', 'time_sometimes') #scroll to the end of the textview end_rect = textview.get_iter_location(end_iter) visible_rect = textview.get_visible_rect() text_tags = other_tags_for_text[:] if kind == 'status': text_tags.append(kind) elif text.startswith('/me ') or text.startswith('/me\n'): text = '* ' + name + text[3:] text_tags.append(kind) if name and len(text_tags) == len(other_tags_for_text): # not status nor /me name_tags = other_tags_for_name[:] #create a new list name_tags.append(kind) before_str = gajim.config.get('before_nickname') after_str = gajim.config.get('after_nickname') format = before_str + name + after_str + ' ' buffer.insert_with_tags_by_name(end_iter, format, *name_tags) # detect urls formatting and if the user has it on emoticons index = self.detect_and_print_special_text(text, jid, text_tags) if subject: # if we have subject, show it too! subject = _('Subject: %s\n') % subject end_iter = buffer.get_end_iter() buffer.insert(end_iter, subject) # add the rest of text located in the index and after end_iter = buffer.get_end_iter() buffer.insert_with_tags_by_name(end_iter, text[index:], *text_tags) #scroll to the end of the textview end = False if at_the_end or kind == 'outgoing': #we are at the end or we are sending something end = True # We scroll to the end after the scrollbar has appeared gobject.idle_add(self.scroll_to_end, textview) buffer.end_user_action() if not count_as_new: return if kind == 'incoming' and update_time: gajim.last_message_time[self.account][jid] = time.time() if (jid != self.get_active_jid() or \ not self.window.is_active() or \ not end) and kind == 'incoming': if self.widget_name == 'groupchat_window': # Do not notify us for gc messages that are not for us if text.find(self.nicks[jid]) == -1: return self.nb_unread[jid] += 1 if self.plugin.systray_enabled: self.plugin.systray.add_jid(jid, self.account) self.redraw_tab(jid) self.show_title() def save_sent_message(self, jid, message): #save the message, so user can scroll though the list with key up/down size = len(self.sent_history[jid]) #we don't want size of the buffer to grow indefinately max_size = gajim.config.get('key_up_lines') if size >= max_size: for i in range(0, size - 1): self.sent_history[jid][i] = self.sent_history[jid][i+1] self.sent_history[jid][max_size - 1] = message else: self.sent_history[jid].append(message) self.sent_history_pos[jid] = size + 1 self.typing_new[jid] = True self.orig_msg[jid] = '' def sent_messages_scroll(self, jid, direction, conv_buf): size = len(self.sent_history[jid]) if direction == 'up': if self.sent_history_pos[jid] == 0: return if self.typing_new[jid]: #user was typing something and then went into history, so save #whatever is already typed start_iter = conv_buf.get_start_iter() end_iter = conv_buf.get_end_iter() self.orig_msg[jid] = conv_buf.get_text(start_iter, end_iter, 0) self.typing_new[jid] = False self.sent_history_pos[jid] = self.sent_history_pos[jid] - 1 conv_buf.set_text(self.sent_history[jid][self.sent_history_pos[jid]]) elif direction == 'down': if self.sent_history_pos[jid] >= size - 1: conv_buf.set_text(self.orig_msg[jid]); self.typing_new[jid] = True self.sent_history_pos[jid] = size return self.sent_history_pos[jid] = self.sent_history_pos[jid] + 1 conv_buf.set_text(self.sent_history[jid][self.sent_history_pos[jid]]) def paint_banner(self, jid): theme = gajim.config.get('roster_theme') bgcolor = gajim.config.get_per('themes', theme, 'bannerbgcolor') textcolor = gajim.config.get_per('themes', theme, 'bannertextcolor') # the backgrounds are colored by using an eventbox by # setting the bg color of the eventbox and the fg of the name_label self.xmls[jid].get_widget('banner_eventbox').modify_bg( gtk.STATE_NORMAL, gtk.gdk.color_parse(bgcolor)) banner_name_label = self.xmls[jid].get_widget('banner_name_label') banner_name_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse(textcolor)) def repaint_colored_widgets(self): """Repaint widgets (banner) in the window/tab with theme color""" # iterate through tabs/windows and repaint for jid in self.xmls: self.paint_banner(jid) def set_compact_view(self, state): '''Toggle compact view''' self.compact_view_current_state = state for jid in self.xmls: if self.widget_name == 'tabbed_chat_window': widgets = [ self.xmls[jid].get_widget('banner_eventbox'), self.xmls[jid].get_widget('actions_hbox'), ] elif self.widget_name == 'groupchat_window': widgets = [self.xmls[jid].get_widget('banner_eventbox'), self.xmls[jid].get_widget('gc_actions_hbox'), self.xmls[jid].get_widget('list_scrolledwindow'), ] for widget in widgets: if state: widget.set_no_show_all(True) widget.hide() else: widget.set_no_show_all(False) widget.show_all()