2005-05-20 19:25:21 +02:00
|
|
|
## plugins/groupchat_window.py
|
2005-03-11 18:57:35 +01:00
|
|
|
##
|
|
|
|
## Gajim Team:
|
2005-05-20 19:25:21 +02:00
|
|
|
## - Yann Le Boulanger <asterix@lagaule.org>
|
|
|
|
## - Vincent Hanquez <tab@snarc.org>
|
|
|
|
## - Nikos Kouremenos <kourem@gmail.com>
|
2005-03-11 18:57:35 +01:00
|
|
|
##
|
2005-05-20 19:25:21 +02:00
|
|
|
## Copyright (C) 2003-2005 Gajim Team
|
2005-03-11 18:57:35 +01:00
|
|
|
##
|
|
|
|
## 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
|
2005-04-14 19:07:55 +02:00
|
|
|
import dialogs
|
|
|
|
import chat
|
2005-04-18 18:40:10 +02:00
|
|
|
import cell_renderer_image
|
2005-06-07 18:52:24 +02:00
|
|
|
from gajim import User
|
2005-04-18 16:05:30 +02:00
|
|
|
from common import gajim
|
2005-03-11 18:57:35 +01:00
|
|
|
from common import i18n
|
|
|
|
|
|
|
|
_ = i18n._
|
|
|
|
APP = i18n.APP
|
|
|
|
gtk.glade.bindtextdomain(APP, i18n.DIR)
|
|
|
|
gtk.glade.textdomain(APP)
|
|
|
|
|
2005-04-22 01:20:18 +02:00
|
|
|
GTKGUI_GLADE = 'gtkgui.glade'
|
2005-03-11 18:57:35 +01:00
|
|
|
|
2005-04-14 19:07:55 +02:00
|
|
|
class Groupchat_window(chat.Chat):
|
2005-03-13 18:04:57 +01:00
|
|
|
"""Class for Groupchat window"""
|
2005-03-12 22:30:50 +01:00
|
|
|
def __init__(self, room_jid, nick, plugin, account):
|
2005-04-14 19:07:55 +02:00
|
|
|
chat.Chat.__init__(self, plugin, account, 'groupchat_window')
|
2005-03-12 22:30:50 +01:00
|
|
|
self.nicks = {}
|
|
|
|
self.list_treeview = {}
|
|
|
|
self.subjects = {}
|
2005-05-14 03:29:53 +02:00
|
|
|
self.subject_entry = {}
|
|
|
|
self.subject_entry_tooltip = {}
|
2005-06-04 15:25:26 +02:00
|
|
|
self.room_creation = {}
|
2005-04-23 16:26:04 +02:00
|
|
|
self.new_room(room_jid, nick)
|
2005-03-12 22:30:50 +01:00
|
|
|
self.show_title()
|
2005-05-14 03:29:53 +02:00
|
|
|
self.xml.signal_connect('on_groupchat_window_destroy',
|
2005-03-12 22:30:50 +01:00
|
|
|
self.on_groupchat_window_destroy)
|
2005-05-14 03:29:53 +02:00
|
|
|
self.xml.signal_connect('on_groupchat_window_delete_event',
|
2005-03-12 22:30:50 +01:00
|
|
|
self.on_groupchat_window_delete_event)
|
2005-05-14 03:29:53 +02:00
|
|
|
self.xml.signal_connect('on_groupchat_window_focus_in_event',
|
2005-03-12 22:30:50 +01:00
|
|
|
self.on_groupchat_window_focus_in_event)
|
2005-05-14 03:29:53 +02:00
|
|
|
self.xml.signal_connect('on_chat_notebook_key_press_event',
|
2005-03-12 22:30:50 +01:00
|
|
|
self.on_chat_notebook_key_press_event)
|
2005-05-14 03:29:53 +02:00
|
|
|
self.xml.signal_connect('on_chat_notebook_switch_page',
|
2005-03-12 22:30:50 +01:00
|
|
|
self.on_chat_notebook_switch_page)
|
2005-05-14 03:29:53 +02:00
|
|
|
self.xml.signal_connect('on_change_subject_menuitem_activate',
|
|
|
|
self.on_change_subject_menuitem_activate)
|
|
|
|
self.xml.signal_connect('on_configure_room_menuitem_activate',
|
|
|
|
self.on_configure_room_menuitem_activate)
|
2005-06-07 20:21:36 +02:00
|
|
|
self.xml.signal_connect('on_add_bookmark_menuitem_activate',
|
|
|
|
self.on_add_bookmark_menuitem_activate)
|
2005-05-14 03:29:53 +02:00
|
|
|
self.xml.signal_connect('on_close_window_activate',
|
|
|
|
self.on_close_window_activate)
|
2005-04-28 17:48:20 +02:00
|
|
|
self.window.show_all()
|
|
|
|
|
|
|
|
def save_var(self, jid):
|
|
|
|
if not jid in self.nicks:
|
|
|
|
return {}
|
|
|
|
return {
|
|
|
|
'nick': self.nicks[jid],
|
|
|
|
'model': self.list_treeview[jid].get_model(),
|
|
|
|
'subject': self.subjects[jid],
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
def load_var(self, jid, var):
|
|
|
|
if not self.xmls.has_key(jid):
|
|
|
|
return
|
|
|
|
self.list_treeview[jid].set_model(var['model'])
|
|
|
|
self.list_treeview[jid].expand_all()
|
|
|
|
self.set_subject(jid, var['subject'])
|
2005-03-12 22:30:50 +01:00
|
|
|
|
2005-05-14 03:29:53 +02:00
|
|
|
def on_close_window_activate(self, widget):
|
2005-05-14 18:34:07 +02:00
|
|
|
if not self.on_groupchat_window_delete_event(widget, None):
|
2005-05-14 13:46:15 +02:00
|
|
|
self.window.destroy()
|
2005-05-14 03:29:53 +02:00
|
|
|
|
2005-03-11 18:57:35 +01:00
|
|
|
def on_groupchat_window_delete_event(self, widget, event):
|
|
|
|
"""close window"""
|
|
|
|
for room_jid in self.xmls:
|
|
|
|
if time.time() - self.last_message_time[room_jid] < 2:
|
2005-06-07 22:24:22 +02:00
|
|
|
dialog = dialogs.Confirmation_dialog(_('You just received a new message in room "%s".'), \
|
|
|
|
_('If you close this window, this message will be lost.') % \
|
2005-03-11 18:57:35 +01:00
|
|
|
room_jid.split('@')[0])
|
2005-06-07 03:10:24 +02:00
|
|
|
if dialog.get_response() != gtk.RESPONSE_OK:
|
2005-03-11 18:57:35 +01:00
|
|
|
return True #stop the propagation of the event
|
|
|
|
for room_jid in self.xmls:
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].send_gc_status(self.nicks[room_jid], \
|
|
|
|
room_jid, 'offline', 'offline')
|
2005-04-28 17:48:20 +02:00
|
|
|
|
|
|
|
def on_groupchat_window_destroy(self, widget):
|
2005-04-14 19:07:55 +02:00
|
|
|
chat.Chat.on_window_destroy(self, widget, 'gc')
|
2005-03-12 22:30:50 +01:00
|
|
|
|
|
|
|
def on_groupchat_window_focus_in_event(self, widget, event):
|
|
|
|
"""When window get focus"""
|
2005-04-14 19:07:55 +02:00
|
|
|
chat.Chat.on_chat_window_focus_in_event(self, widget, event)
|
2005-03-12 22:30:50 +01:00
|
|
|
|
|
|
|
def on_chat_notebook_key_press_event(self, widget, event):
|
2005-04-14 19:07:55 +02:00
|
|
|
chat.Chat.on_chat_notebook_key_press_event(self, widget, event)
|
2005-03-16 21:48:56 +01:00
|
|
|
|
|
|
|
def on_chat_notebook_switch_page(self, notebook, page, page_num):
|
|
|
|
new_child = notebook.get_nth_page(page_num)
|
|
|
|
new_jid = ''
|
|
|
|
for jid in self.xmls:
|
|
|
|
if self.childs[jid] == new_child:
|
|
|
|
new_jid = jid
|
|
|
|
break
|
2005-04-23 16:26:04 +02:00
|
|
|
subject = self.subjects[new_jid]
|
2005-05-14 03:29:53 +02:00
|
|
|
subject_entry = self.subject_entry[new_jid]
|
|
|
|
subject_entry.set_text(subject)
|
|
|
|
self.subject_entry_tooltip[new_jid].set_tip(subject_entry, subject)
|
2005-04-14 19:07:55 +02:00
|
|
|
chat.Chat.on_chat_notebook_switch_page(self, notebook, page, page_num)
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def get_role_iter(self, room_jid, role):
|
|
|
|
model = self.list_treeview[room_jid].get_model()
|
|
|
|
fin = False
|
|
|
|
iter = model.get_iter_root()
|
|
|
|
if not iter:
|
|
|
|
return None
|
|
|
|
while not fin:
|
|
|
|
role_name = model.get_value(iter, 2)
|
|
|
|
if role == role_name:
|
|
|
|
return iter
|
|
|
|
iter = model.iter_next(iter)
|
|
|
|
if not iter:
|
|
|
|
fin = True
|
|
|
|
return None
|
|
|
|
|
|
|
|
def get_user_iter(self, room_jid, nick):
|
|
|
|
model = self.list_treeview[room_jid].get_model()
|
|
|
|
fin = False
|
|
|
|
role_iter = model.get_iter_root()
|
|
|
|
if not role_iter:
|
|
|
|
return None
|
|
|
|
while not fin:
|
|
|
|
fin2 = False
|
|
|
|
user_iter = model.iter_children(role_iter)
|
|
|
|
if not user_iter:
|
2005-04-22 01:20:18 +02:00
|
|
|
fin2 = True
|
2005-03-11 18:57:35 +01:00
|
|
|
while not fin2:
|
2005-03-13 09:51:34 +01:00
|
|
|
if nick == model.get_value(user_iter, 1):
|
2005-03-11 18:57:35 +01:00
|
|
|
return user_iter
|
|
|
|
user_iter = model.iter_next(user_iter)
|
|
|
|
if not user_iter:
|
|
|
|
fin2 = True
|
|
|
|
role_iter = model.iter_next(role_iter)
|
|
|
|
if not role_iter:
|
|
|
|
fin = True
|
|
|
|
return None
|
|
|
|
|
|
|
|
def get_nick_list(self, room_jid):
|
|
|
|
model = self.list_treeview[room_jid].get_model()
|
|
|
|
list = []
|
|
|
|
fin = False
|
|
|
|
role = model.get_iter_root()
|
|
|
|
if not role:
|
|
|
|
return list
|
|
|
|
while not fin:
|
|
|
|
fin2 = False
|
|
|
|
user = model.iter_children(role)
|
|
|
|
if not user:
|
2005-04-22 01:20:18 +02:00
|
|
|
fin2 = True
|
2005-03-11 18:57:35 +01:00
|
|
|
while not fin2:
|
|
|
|
nick = model.get_value(user, 1)
|
|
|
|
list.append(nick)
|
|
|
|
user = model.iter_next(user)
|
|
|
|
if not user:
|
|
|
|
fin2 = True
|
|
|
|
role = model.iter_next(role)
|
|
|
|
if not role:
|
|
|
|
fin = True
|
|
|
|
return list
|
|
|
|
|
|
|
|
def remove_user(self, room_jid, nick):
|
2005-05-14 03:29:53 +02:00
|
|
|
"""Remove a user from the list_users"""
|
2005-03-11 18:57:35 +01:00
|
|
|
model = self.list_treeview[room_jid].get_model()
|
|
|
|
iter = self.get_user_iter(room_jid, nick)
|
|
|
|
if not iter:
|
|
|
|
return
|
|
|
|
parent_iter = model.iter_parent(iter)
|
|
|
|
model.remove(iter)
|
|
|
|
if model.iter_n_children(parent_iter) == 0:
|
|
|
|
model.remove(parent_iter)
|
|
|
|
|
|
|
|
def add_user_to_roster(self, room_jid, nick, show, role, jid):
|
|
|
|
model = self.list_treeview[room_jid].get_model()
|
2005-04-23 03:37:05 +02:00
|
|
|
image = self.plugin.roster.jabber_state_images[show]
|
2005-03-11 18:57:35 +01:00
|
|
|
role_iter = self.get_role_iter(room_jid, role)
|
|
|
|
if not role_iter:
|
2005-04-23 03:37:05 +02:00
|
|
|
role_iter = model.append(None,
|
|
|
|
(self.plugin.roster.jabber_state_images['closed'], role + 's',\
|
|
|
|
role, ''))
|
|
|
|
iter = model.append(role_iter, (image, nick, jid, show))
|
2005-03-11 18:57:35 +01:00
|
|
|
self.list_treeview[room_jid].expand_row((model.get_path(role_iter)), \
|
|
|
|
False)
|
|
|
|
return iter
|
|
|
|
|
|
|
|
def get_role(self, room_jid, jid_iter):
|
|
|
|
model = self.list_treeview[room_jid].get_model()
|
|
|
|
path = model.get_path(jid_iter)[0]
|
|
|
|
iter = model.get_iter(path)
|
|
|
|
return model.get_value(iter, 2)
|
|
|
|
|
2005-04-23 03:37:05 +02:00
|
|
|
def update_state_images(self):
|
|
|
|
roster = self.plugin.roster
|
2005-03-31 21:21:48 +02:00
|
|
|
for room_jid in self.list_treeview:
|
|
|
|
model = self.list_treeview[room_jid].get_model()
|
|
|
|
role_iter = model.get_iter_root()
|
|
|
|
if not role_iter:
|
|
|
|
continue
|
|
|
|
while role_iter:
|
|
|
|
user_iter = model.iter_children(role_iter)
|
|
|
|
if not user_iter:
|
|
|
|
continue
|
|
|
|
while user_iter:
|
|
|
|
show = model.get_value(user_iter, 3)
|
2005-04-23 03:37:05 +02:00
|
|
|
state_images = roster.get_appropriate_state_images(room_jid)
|
|
|
|
image = state_images[show] #FIXME: always Jabber why?
|
|
|
|
model.set_value(user_iter, 0, image)
|
2005-03-31 21:21:48 +02:00
|
|
|
user_iter = model.iter_next(user_iter)
|
|
|
|
role_iter = model.iter_next(role_iter)
|
|
|
|
|
2005-03-11 18:57:35 +01:00
|
|
|
def chg_user_status(self, room_jid, nick, show, status, role, affiliation, \
|
|
|
|
jid, reason, actor, statusCode, account):
|
2005-05-14 03:29:53 +02:00
|
|
|
"""When a user changes his status"""
|
2005-05-07 11:08:54 +02:00
|
|
|
if not role:
|
2005-05-15 11:29:45 +02:00
|
|
|
role = 'visitor'
|
2005-03-11 18:57:35 +01:00
|
|
|
model = self.list_treeview[room_jid].get_model()
|
|
|
|
if show == 'offline' or show == 'error':
|
|
|
|
if statusCode == '307':
|
2005-05-21 16:48:29 +02:00
|
|
|
self.print_conversation(_('%s has been kicked by %s: %s') % (nick,
|
2005-05-26 19:47:10 +02:00
|
|
|
actor, reason), room_jid)
|
2005-03-11 18:57:35 +01:00
|
|
|
self.remove_user(room_jid, nick)
|
2005-05-27 18:46:51 +02:00
|
|
|
if nick == self.nicks[room_jid]: # We became offline
|
|
|
|
model.clear()
|
2005-03-11 18:57:35 +01:00
|
|
|
else:
|
|
|
|
iter = self.get_user_iter(room_jid, nick)
|
|
|
|
ji = jid
|
|
|
|
if jid:
|
|
|
|
ji = jid.split('/')[0]
|
|
|
|
if not iter:
|
|
|
|
iter = self.add_user_to_roster(room_jid, nick, show, role, ji)
|
|
|
|
else:
|
|
|
|
actual_role = self.get_role(room_jid, iter)
|
|
|
|
if role != actual_role:
|
|
|
|
self.remove_user(room_jid, nick)
|
|
|
|
self.add_user_to_roster(room_jid, nick, show, role, ji)
|
|
|
|
else:
|
2005-04-23 03:37:05 +02:00
|
|
|
roster = self.plugin.roster
|
2005-04-23 16:26:04 +02:00
|
|
|
state_images = roster.get_appropriate_state_images(ji)
|
2005-04-23 15:39:15 +02:00
|
|
|
image = state_images[show]
|
2005-04-23 03:37:05 +02:00
|
|
|
model.set_value(iter, 0, image)
|
2005-03-31 21:21:48 +02:00
|
|
|
model.set_value(iter, 3, show)
|
2005-06-04 15:25:26 +02:00
|
|
|
if (time.time() - self.room_creation[room_jid]) > 30 and \
|
|
|
|
nick != self.nicks[room_jid]:
|
2005-06-08 00:49:17 +02:00
|
|
|
if show == 'offline':
|
|
|
|
st = _('%s has left') % nick
|
|
|
|
else:
|
|
|
|
st = _('%s is now %s') % (nick, show)
|
|
|
|
if status:
|
|
|
|
st += ' (' + status + ')'
|
|
|
|
self.print_conversation(st, room_jid)
|
2005-06-04 15:25:26 +02:00
|
|
|
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def set_subject(self, room_jid, subject):
|
|
|
|
self.subjects[room_jid] = subject
|
2005-05-14 03:29:53 +02:00
|
|
|
subject_entry = self.subject_entry[room_jid]
|
|
|
|
subject_entry.set_text(subject)
|
|
|
|
self.subject_entry_tooltip[room_jid].set_tip(subject_entry, subject)
|
2005-03-11 18:57:35 +01:00
|
|
|
|
2005-05-14 03:29:53 +02:00
|
|
|
def on_change_subject_menuitem_activate(self, widget):
|
2005-03-11 18:57:35 +01:00
|
|
|
room_jid = self.get_active_jid()
|
2005-05-14 18:34:07 +02:00
|
|
|
subject = self.subject_entry[room_jid].get_text()
|
2005-05-14 03:29:53 +02:00
|
|
|
instance = dialogs.Input_dialog('Changing the Subject',
|
2005-05-14 18:34:07 +02:00
|
|
|
'Please specify the new subject:', subject)
|
2005-05-14 03:29:53 +02:00
|
|
|
response = instance.dialog.run()
|
|
|
|
instance.dialog.destroy()
|
|
|
|
if response == gtk.RESPONSE_OK:
|
|
|
|
subject = instance.input_entry.get_text()
|
|
|
|
gajim.connections[self.account].send_gc_subject(room_jid, subject)
|
|
|
|
|
|
|
|
def on_configure_room_menuitem_activate(self, widget):
|
2005-04-20 12:21:33 +02:00
|
|
|
room_jid = self.get_active_jid()
|
|
|
|
gajim.connections[self.account].request_gc_config(room_jid)
|
|
|
|
|
2005-06-07 20:21:36 +02:00
|
|
|
def on_add_bookmark_menuitem_activate(self, widget):
|
|
|
|
room_jid = self.get_active_jid()
|
|
|
|
bm = { 'name':"",
|
|
|
|
'jid':self.get_active_jid(),
|
|
|
|
'autojoin':"1",
|
|
|
|
'password':"",
|
|
|
|
'nick':self.nicks[self.get_active_jid()]
|
|
|
|
}
|
|
|
|
|
2005-06-08 00:02:51 +02:00
|
|
|
for bookmark in gajim.connections[self.account].bookmarks:
|
|
|
|
if bookmark['jid'] == bm['jid']:
|
|
|
|
dialogs.Error_dialog(
|
2005-06-08 00:04:23 +02:00
|
|
|
_('Bookmark already set'),
|
2005-06-08 00:02:51 +02:00
|
|
|
_('The bookmark is already in your roster.')).get_response()
|
|
|
|
return
|
|
|
|
|
2005-06-07 20:21:36 +02:00
|
|
|
gajim.connections[self.account].bookmarks.append(bm)
|
|
|
|
gajim.connections[self.account].store_bookmarks()
|
|
|
|
|
|
|
|
#FIXME: add code to add to Bookmarks group (should be account-specific)
|
|
|
|
|
|
|
|
#FIXME: use join_gc_window [where user can put password] and change the
|
|
|
|
#name of the boookmark [default: fill with room's 'name']
|
|
|
|
dialogs.Information_dialog(
|
|
|
|
_('Bookmark has been added successfully'),
|
|
|
|
_('You can find the bookmark for room "%s" in your roster.') % \
|
|
|
|
room_jid.split('@')[0]).get_response()
|
|
|
|
|
|
|
|
|
2005-03-11 18:57:35 +01:00
|
|
|
def on_message_textview_key_press_event(self, widget, event):
|
|
|
|
"""When a key is pressed:
|
|
|
|
if enter is pressed without the shit key, message (if not empty) is sent
|
2005-05-20 19:25:21 +02:00
|
|
|
and printed in the conversation. Tab does autocomplete in nickames"""
|
2005-04-23 20:03:17 +02:00
|
|
|
room_jid = self.get_active_jid()
|
|
|
|
conversation_textview = self.xmls[room_jid].get_widget(
|
|
|
|
'conversation_textview')
|
2005-06-07 18:25:55 +02:00
|
|
|
message_buffer = widget.get_buffer()
|
|
|
|
start_iter, end_iter = message_buffer.get_bounds()
|
|
|
|
message = message_buffer.get_text(start_iter, end_iter, False)
|
|
|
|
|
2005-05-15 22:58:04 +02:00
|
|
|
if event.keyval == gtk.keysyms.ISO_Left_Tab: # SHIFT + TAB
|
|
|
|
if (event.state & gtk.gdk.CONTROL_MASK): # CTRL + SHIFT + TAB
|
2005-04-12 17:30:09 +02:00
|
|
|
self.notebook.emit('key_press_event', event)
|
2005-05-15 22:58:04 +02:00
|
|
|
elif event.keyval == gtk.keysyms.Tab: # TAB
|
|
|
|
if event.state & gtk.gdk.CONTROL_MASK: # CTRL + TAB
|
2005-04-12 17:30:09 +02:00
|
|
|
self.notebook.emit('key_press_event', event)
|
2005-04-18 23:41:23 +02:00
|
|
|
else:
|
|
|
|
list_nick = self.get_nick_list(room_jid)
|
|
|
|
cursor_position = message_buffer.get_insert()
|
|
|
|
end_iter = message_buffer.get_iter_at_mark(cursor_position)
|
2005-06-07 18:25:55 +02:00
|
|
|
text = message_buffer.get_text(start_iter, end_iter, False)
|
2005-05-20 19:25:21 +02:00
|
|
|
if not text or text.endswith(' '):
|
2005-04-18 23:41:23 +02:00
|
|
|
return False
|
|
|
|
splitted_text = text.split()
|
2005-05-20 19:25:21 +02:00
|
|
|
begin = splitted_text[-1] # last word we typed
|
2005-04-18 23:41:23 +02:00
|
|
|
for nick in list_nick:
|
|
|
|
if nick.find(begin) == 0: # the word is the begining of a nick
|
|
|
|
if len(splitted_text) == 1: # This is the 1st word of the line
|
|
|
|
add = ': '
|
|
|
|
else:
|
|
|
|
add = ' '
|
|
|
|
message_buffer.insert_at_cursor(nick[len(begin):] + add)
|
|
|
|
return True
|
2005-05-15 19:49:40 +02:00
|
|
|
return False
|
2005-04-03 11:13:14 +02:00
|
|
|
elif event.keyval == gtk.keysyms.Page_Down: # PAGE DOWN
|
|
|
|
if event.state & gtk.gdk.CONTROL_MASK: # CTRL + PAGE DOWN
|
|
|
|
self.notebook.emit('key_press_event', event)
|
|
|
|
elif event.state & gtk.gdk.SHIFT_MASK: # SHIFT + PAGE DOWN
|
|
|
|
conversation_textview.emit('key_press_event', event)
|
|
|
|
elif event.keyval == gtk.keysyms.Page_Up: # PAGE UP
|
|
|
|
if event.state & gtk.gdk.CONTROL_MASK: # CTRL + PAGE UP
|
|
|
|
self.notebook.emit('key_press_event', event)
|
|
|
|
elif event.state & gtk.gdk.SHIFT_MASK: # SHIFT + PAGE UP
|
|
|
|
conversation_textview.emit('key_press_event', event)
|
|
|
|
elif event.keyval == gtk.keysyms.Return or \
|
|
|
|
event.keyval == gtk.keysyms.KP_Enter: # ENTER
|
2005-03-11 18:57:35 +01:00
|
|
|
if (event.state & gtk.gdk.SHIFT_MASK):
|
2005-04-12 17:30:09 +02:00
|
|
|
return False
|
2005-06-06 15:04:11 +02:00
|
|
|
if message != '' or message != '\n':
|
2005-06-07 18:25:55 +02:00
|
|
|
self.save_sent_message(room_jid, message)
|
2005-06-06 15:04:11 +02:00
|
|
|
if message == '/clear':
|
2005-05-18 03:01:49 +02:00
|
|
|
self.on_clear(None, conversation_textview) # clear conversation
|
|
|
|
self.on_clear(None, widget) # clear message textview too
|
|
|
|
return True
|
2005-06-06 15:04:11 +02:00
|
|
|
gajim.connections[self.account].send_gc_message(room_jid, message)
|
2005-03-11 18:57:35 +01:00
|
|
|
message_buffer.set_text('', -1)
|
|
|
|
widget.grab_focus()
|
2005-04-12 17:30:09 +02:00
|
|
|
return True
|
2005-06-07 18:25:55 +02:00
|
|
|
elif event.keyval == gtk.keysyms.Up:
|
|
|
|
if event.state & gtk.gdk.CONTROL_MASK: #Ctrl+UP
|
|
|
|
self.sent_messages_scroll(room_jid, 'up', widget.get_buffer())
|
|
|
|
elif event.keyval == gtk.keysyms.Down:
|
|
|
|
if event.state & gtk.gdk.CONTROL_MASK: #Ctrl+Down
|
|
|
|
self.sent_messages_scroll(room_jid, 'down', widget.get_buffer())
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def print_conversation(self, text, room_jid, contact = '', tim = None):
|
2005-05-13 18:53:30 +02:00
|
|
|
"""Print a line in the conversation:
|
|
|
|
if contact is set: it's a message from someone
|
|
|
|
if contact is not set: it's a message from the server"""
|
2005-03-16 18:22:20 +01:00
|
|
|
other_tags_for_name = []
|
2005-03-11 18:57:35 +01:00
|
|
|
if contact:
|
|
|
|
if contact == self.nicks[room_jid]:
|
2005-03-16 18:22:20 +01:00
|
|
|
kind = 'outgoing'
|
2005-03-11 18:57:35 +01:00
|
|
|
else:
|
2005-03-16 18:22:20 +01:00
|
|
|
kind = 'incoming'
|
2005-03-11 18:57:35 +01:00
|
|
|
else:
|
2005-03-16 18:22:20 +01:00
|
|
|
kind = 'status'
|
2005-03-11 18:57:35 +01:00
|
|
|
|
2005-04-19 12:34:29 +02:00
|
|
|
if kind == 'incoming' and (self.nicks[room_jid].lower() in \
|
|
|
|
text.lower().split() or self.nicks[room_jid].lower() + ':' in \
|
|
|
|
text.lower().split()):
|
2005-03-16 18:22:20 +01:00
|
|
|
other_tags_for_name.append('bold')
|
|
|
|
|
2005-06-02 21:38:22 +02:00
|
|
|
chat.Chat.print_conversation_line(self, text, room_jid, kind, contact,
|
|
|
|
tim, other_tags_for_name)
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def kick(self, widget, room_jid, nick):
|
|
|
|
"""kick a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_role(room_jid, nick, 'none')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def grant_voice(self, widget, room_jid, nick):
|
|
|
|
"""grant voice privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_role(room_jid, nick, 'participant')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def revoke_voice(self, widget, room_jid, nick):
|
|
|
|
"""revoke voice privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_role(room_jid, nick, 'visitor')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def grant_moderator(self, widget, room_jid, nick):
|
|
|
|
"""grant moderator privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_role(room_jid, nick, 'moderator')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def revoke_moderator(self, widget, room_jid, nick):
|
|
|
|
"""revoke moderator privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_role(room_jid, nick, 'participant')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def ban(self, widget, room_jid, jid):
|
|
|
|
"""ban a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_affiliation(room_jid, jid, \
|
|
|
|
'outcast')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def grant_membership(self, widget, room_jid, jid):
|
|
|
|
"""grant membership privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_affiliation(room_jid, jid, \
|
|
|
|
'member')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def revoke_membership(self, widget, room_jid, jid):
|
|
|
|
"""revoke membership privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_affiliation(room_jid, jid, \
|
|
|
|
'none')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def grant_admin(self, widget, room_jid, jid):
|
|
|
|
"""grant administrative privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_affiliation(room_jid, jid, 'admin')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def revoke_admin(self, widget, room_jid, jid):
|
|
|
|
"""revoke administrative privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_affiliation(room_jid, jid, \
|
|
|
|
'member')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def grant_owner(self, widget, room_jid, jid):
|
|
|
|
"""grant owner privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_affiliation(room_jid, jid, 'owner')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def revoke_owner(self, widget, room_jid, jid):
|
|
|
|
"""revoke owner privilege to a user"""
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].gc_set_affiliation(room_jid, jid, 'admin')
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def on_info(self, widget, jid):
|
|
|
|
"""Call vcard_information_window class to display user's information"""
|
2005-05-12 18:59:51 +02:00
|
|
|
if self.plugin.windows[self.account]['infos'].has_key(jid):
|
2005-05-13 18:53:30 +02:00
|
|
|
self.plugin.windows[self.account]['infos'][jid].window.present()
|
2005-05-12 18:59:51 +02:00
|
|
|
else:
|
2005-03-11 18:57:35 +01:00
|
|
|
self.plugin.windows[self.account]['infos'][jid] = \
|
2005-05-13 18:53:30 +02:00
|
|
|
dialogs.Vcard_window(jid, self.plugin, self.account, True)
|
2005-05-11 20:47:09 +02:00
|
|
|
# FIXME: when we'll have a user for each contact, this won't be needed
|
|
|
|
# cause we'll user real information window
|
|
|
|
vcard_xml = self.plugin.windows[self.account]['infos'][jid].xml
|
|
|
|
hbuttonbox = vcard_xml.get_widget('information_hbuttonbox')
|
|
|
|
children = hbuttonbox.get_children()
|
|
|
|
hbuttonbox.remove(children[0])
|
|
|
|
hbuttonbox.remove(children[1])
|
|
|
|
vcard_xml.get_widget('nickname_label').set_text(jid)
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].request_vcard(jid)
|
2005-04-12 17:30:09 +02:00
|
|
|
|
2005-04-06 22:18:55 +02:00
|
|
|
#FIXME: we need the resource but it's not saved
|
|
|
|
#self.plugin.send('ASK_OS_INFO', self.account, jid, resource)
|
2005-03-11 18:57:35 +01:00
|
|
|
|
2005-06-08 00:31:01 +02:00
|
|
|
def on_send_pm(self, widget, model, iter):
|
|
|
|
room_jid = self.get_active_jid()
|
|
|
|
nick = model.get_value(iter, 1)
|
|
|
|
fjid = room_jid + '/' + nick
|
|
|
|
if not self.plugin.windows[self.account]['chats'].has_key(fjid):
|
|
|
|
show = model.get_value(iter, 3)
|
|
|
|
u = User(fjid, nick, ['none'], show, '', 'none', None, '', 0, '')
|
|
|
|
self.plugin.roster.new_chat(u, self.account)
|
|
|
|
self.plugin.windows[self.account]['chats'][fjid].set_active_tab(fjid)
|
|
|
|
self.plugin.windows[self.account]['chats'][fjid].window.present()
|
|
|
|
|
2005-03-11 18:57:35 +01:00
|
|
|
def mk_menu(self, room_jid, event, iter):
|
|
|
|
"""Make user's popup menu"""
|
|
|
|
model = self.list_treeview[room_jid].get_model()
|
|
|
|
nick = model.get_value(iter, 1)
|
|
|
|
jid = model.get_value(iter, 2)
|
|
|
|
|
|
|
|
menu = gtk.Menu()
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Privileges'))
|
2005-03-11 18:57:35 +01:00
|
|
|
menu.append(item)
|
|
|
|
|
|
|
|
sub_menu = gtk.Menu()
|
|
|
|
item.set_submenu(sub_menu)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Kick'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.kick, room_jid, nick)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Grant Voice'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.grant_voice, room_jid, nick)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Revoke Voice'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.revoke_voice, room_jid, nick)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Grant Moderator'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.grant_moderator, room_jid, nick)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Revoke Moderator'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.revoke_moderator, room_jid, nick)
|
|
|
|
if jid:
|
|
|
|
item = gtk.MenuItem()
|
|
|
|
sub_menu.append(item)
|
|
|
|
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Ban'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.ban, room_jid, jid)
|
2005-05-17 13:55:30 +02:00
|
|
|
item = gtk.MenuItem(_('_Grant Membership'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.grant_membership, room_jid, jid)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Revoke Membership'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.revoke_membership, room_jid, jid)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Grant Admin'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.grant_admin, room_jid, jid)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Revoke Admin'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.revoke_admin, room_jid, jid)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Grant Owner'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.grant_owner, room_jid, jid)
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Revoke Owner'))
|
2005-03-11 18:57:35 +01:00
|
|
|
sub_menu.append(item)
|
|
|
|
item.connect('activate', self.revoke_owner, room_jid, jid)
|
|
|
|
|
|
|
|
item = gtk.MenuItem()
|
|
|
|
menu.append(item)
|
|
|
|
|
2005-05-13 19:58:54 +02:00
|
|
|
item = gtk.MenuItem(_('_Information'))
|
2005-03-11 18:57:35 +01:00
|
|
|
menu.append(item)
|
|
|
|
item.connect('activate', self.on_info, jid)
|
|
|
|
|
2005-06-08 11:12:01 +02:00
|
|
|
item = gtk.MenuItem(_('Send _Private Message'))
|
2005-06-08 10:08:32 +02:00
|
|
|
menu.append(item)
|
|
|
|
item.connect('activate', self.on_send_pm, model, iter)
|
2005-06-08 00:31:01 +02:00
|
|
|
|
2005-03-11 18:57:35 +01:00
|
|
|
menu.popup(None, None, None, event.button, event.time)
|
|
|
|
menu.show_all()
|
|
|
|
menu.reposition()
|
|
|
|
|
|
|
|
def remove_tab(self, room_jid):
|
|
|
|
if time.time() - self.last_message_time[room_jid] < 2:
|
2005-06-07 03:10:24 +02:00
|
|
|
dialog = dialogs.Confirmation_dialog(
|
2005-06-07 22:24:22 +02:00
|
|
|
_('You just received a new message in room "%s"'),
|
|
|
|
_('If you close this tab, the message will be lost.') % \
|
2005-03-11 18:57:35 +01:00
|
|
|
room_jid.split('@')[0])
|
2005-06-07 03:10:24 +02:00
|
|
|
if dialog.get_response() != gtk.RESPONSE_OK:
|
2005-03-11 18:57:35 +01:00
|
|
|
return
|
2005-03-12 22:30:50 +01:00
|
|
|
|
2005-04-14 19:07:55 +02:00
|
|
|
chat.Chat.remove_tab(self, room_jid, 'gc')
|
2005-03-12 22:30:50 +01:00
|
|
|
if len(self.xmls) > 0:
|
2005-04-14 11:38:08 +02:00
|
|
|
gajim.connections[self.account].send_gc_status(self.nicks[room_jid], \
|
|
|
|
room_jid, 'offline', 'offline')
|
2005-03-11 18:57:35 +01:00
|
|
|
del self.nicks[room_jid]
|
|
|
|
del self.list_treeview[room_jid]
|
|
|
|
del self.subjects[room_jid]
|
|
|
|
|
2005-04-23 16:26:04 +02:00
|
|
|
def new_room(self, room_jid, nick):
|
2005-03-12 22:30:50 +01:00
|
|
|
self.names[room_jid] = room_jid.split('@')[0]
|
|
|
|
self.xmls[room_jid] = gtk.glade.XML(GTKGUI_GLADE, 'gc_vbox', APP)
|
|
|
|
self.childs[room_jid] = self.xmls[room_jid].get_widget('gc_vbox')
|
2005-04-14 19:07:55 +02:00
|
|
|
chat.Chat.new_tab(self, room_jid)
|
2005-03-11 18:57:35 +01:00
|
|
|
self.nicks[room_jid] = nick
|
|
|
|
self.subjects[room_jid] = ''
|
2005-06-04 15:25:26 +02:00
|
|
|
self.room_creation[room_jid] = time.time()
|
2005-04-23 16:26:04 +02:00
|
|
|
self.list_treeview[room_jid] = self.xmls[room_jid].get_widget(
|
2005-05-13 19:58:54 +02:00
|
|
|
'list_treeview')
|
2005-04-23 16:26:04 +02:00
|
|
|
conversation_textview = self.xmls[room_jid].get_widget(
|
2005-05-13 19:58:54 +02:00
|
|
|
'conversation_textview')
|
2005-05-14 03:29:53 +02:00
|
|
|
self.subject_entry[room_jid] = self.xmls[room_jid].get_widget(
|
|
|
|
'subject_entry')
|
|
|
|
self.subject_entry_tooltip[room_jid] = gtk.Tooltips()
|
2005-03-11 18:57:35 +01:00
|
|
|
|
2005-06-07 18:52:24 +02:00
|
|
|
#status_image, nickname, real_jid, show
|
2005-03-31 21:21:48 +02:00
|
|
|
store = gtk.TreeStore(gtk.Image, str, str, str)
|
2005-05-15 19:36:43 +02:00
|
|
|
store.set_sort_column_id(1, gtk.SORT_ASCENDING)
|
2005-03-11 18:57:35 +01:00
|
|
|
column = gtk.TreeViewColumn('contacts')
|
2005-04-18 16:05:30 +02:00
|
|
|
renderer_image = cell_renderer_image.CellRendererImage()
|
2005-04-05 17:06:11 +02:00
|
|
|
renderer_image.set_property('width', 20)
|
|
|
|
column.pack_start(renderer_image, expand = False)
|
|
|
|
column.add_attribute(renderer_image, 'image', 0)
|
|
|
|
renderer_text = gtk.CellRendererText()
|
|
|
|
column.pack_start(renderer_text, expand = True)
|
|
|
|
column.add_attribute(renderer_text, 'text', 1)
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
self.list_treeview[room_jid].append_column(column)
|
|
|
|
self.list_treeview[room_jid].set_model(store)
|
2005-04-05 17:06:11 +02:00
|
|
|
|
|
|
|
# workaround to avoid gtk arrows to be shown
|
|
|
|
column = gtk.TreeViewColumn() # 2nd COLUMN
|
|
|
|
renderer = gtk.CellRendererPixbuf()
|
|
|
|
column.pack_start(renderer, expand = False)
|
2005-03-11 18:57:35 +01:00
|
|
|
self.list_treeview[room_jid].append_column(column)
|
|
|
|
column.set_visible(False)
|
|
|
|
self.list_treeview[room_jid].set_expander_column(column)
|
|
|
|
|
|
|
|
self.redraw_tab(room_jid)
|
|
|
|
self.show_title()
|
2005-05-14 18:34:07 +02:00
|
|
|
conversation_textview.grab_focus()
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def on_list_treeview_button_press_event(self, widget, event):
|
|
|
|
"""popup user's group's or agent menu"""
|
|
|
|
if event.type == gtk.gdk.BUTTON_PRESS:
|
2005-04-05 17:06:11 +02:00
|
|
|
if event.button == 3: # right click
|
2005-03-11 18:57:35 +01:00
|
|
|
try:
|
|
|
|
path, column, x, y = widget.get_path_at_pos(int(event.x), \
|
|
|
|
int(event.y))
|
|
|
|
except TypeError:
|
|
|
|
widget.get_selection().unselect_all()
|
|
|
|
return False
|
2005-05-31 19:49:35 +02:00
|
|
|
widget.get_selection().select_path(path)
|
2005-03-11 18:57:35 +01:00
|
|
|
model = widget.get_model()
|
|
|
|
iter = model.get_iter(path)
|
|
|
|
if len(path) == 2:
|
|
|
|
room_jid = self.get_active_jid()
|
|
|
|
self.mk_menu(room_jid, event, iter)
|
|
|
|
return True
|
2005-04-05 17:06:11 +02:00
|
|
|
if event.button == 1: # left click
|
2005-03-11 18:57:35 +01:00
|
|
|
try:
|
|
|
|
path, column, x, y = widget.get_path_at_pos(int(event.x), \
|
|
|
|
int(event.y))
|
|
|
|
except TypeError:
|
|
|
|
widget.get_selection().unselect_all()
|
2005-04-05 17:06:11 +02:00
|
|
|
return False
|
|
|
|
|
2005-04-05 23:37:50 +02:00
|
|
|
model = widget.get_model()
|
2005-04-05 17:06:11 +02:00
|
|
|
iter = model.get_iter(path)
|
2005-04-06 00:01:51 +02:00
|
|
|
status = model.get_value(iter, 3) # if no status: it's a group
|
|
|
|
if not status:
|
2005-04-05 17:06:11 +02:00
|
|
|
if x < 20: # first cell in 1st column (the arrow SINGLE clicked)
|
2005-04-06 00:01:51 +02:00
|
|
|
if (widget.row_expanded(path)):
|
|
|
|
widget.collapse_row(path)
|
2005-04-05 17:06:11 +02:00
|
|
|
else:
|
2005-04-06 00:01:51 +02:00
|
|
|
widget.expand_row(path, False)
|
2005-04-05 17:06:11 +02:00
|
|
|
|
|
|
|
#FIXME: should popup chat window for GC contact DOUBLE clicked
|
2005-05-10 14:19:24 +02:00
|
|
|
# also chat [in context menu]
|
2005-03-11 18:57:35 +01:00
|
|
|
return False
|
|
|
|
|
2005-03-26 21:46:23 +01:00
|
|
|
def on_list_treeview_key_press_event(self, widget, event):
|
2005-05-10 14:19:24 +02:00
|
|
|
if event.keyval == gtk.keysyms.Escape:
|
|
|
|
widget.get_selection().unselect_all()
|
2005-03-11 18:57:35 +01:00
|
|
|
return False
|
|
|
|
|
2005-04-22 01:20:18 +02:00
|
|
|
def on_list_treeview_row_activated(self, widget, path, col = 0):
|
2005-04-05 17:06:11 +02:00
|
|
|
"""When an iter is double clicked: open the chat window"""
|
2005-03-11 18:57:35 +01:00
|
|
|
model = widget.get_model()
|
|
|
|
iter = model.get_iter(path)
|
2005-06-07 18:52:24 +02:00
|
|
|
if len(path) == 1: # It's a group
|
2005-03-11 18:57:35 +01:00
|
|
|
if (widget.row_expanded(path)):
|
|
|
|
widget.collapse_row(path)
|
|
|
|
else:
|
|
|
|
widget.expand_row(path, False)
|
2005-06-07 18:52:24 +02:00
|
|
|
else: # We want to send a private message
|
|
|
|
room_jid = self.get_active_jid()
|
|
|
|
nick = model.get_value(iter, 1)
|
|
|
|
fjid = room_jid + '/' + nick
|
|
|
|
if not self.plugin.windows[self.account]['chats'].has_key(fjid):
|
|
|
|
show = model.get_value(iter, 3)
|
|
|
|
u = User(fjid, nick, ['none'], show, '', 'none', None, '', 0,
|
|
|
|
'')
|
|
|
|
self.plugin.roster.new_chat(u, self.account)
|
|
|
|
self.plugin.windows[self.account]['chats'][fjid].set_active_tab(fjid)
|
|
|
|
self.plugin.windows[self.account]['chats'][fjid].window.present()
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def on_list_treeview_row_expanded(self, widget, iter, path):
|
2005-04-05 17:06:11 +02:00
|
|
|
"""When a row is expanded: change the icon of the arrow"""
|
2005-03-11 18:57:35 +01:00
|
|
|
model = widget.get_model()
|
2005-04-23 15:18:47 +02:00
|
|
|
image = self.plugin.roster.jabber_state_images['opened']
|
2005-04-23 03:37:05 +02:00
|
|
|
model.set_value(iter, 0, image)
|
2005-03-11 18:57:35 +01:00
|
|
|
|
|
|
|
def on_list_treeview_row_collapsed(self, widget, iter, path):
|
2005-04-05 17:06:11 +02:00
|
|
|
"""When a row is collapsed: change the icon of the arrow"""
|
2005-03-11 18:57:35 +01:00
|
|
|
model = widget.get_model()
|
2005-04-23 15:18:47 +02:00
|
|
|
image = self.plugin.roster.jabber_state_images['closed']
|
2005-04-23 03:37:05 +02:00
|
|
|
model.set_value(iter, 0, image)
|