gajim-plural/plugins/gtkgui/gtkgui.py

1333 lines
45 KiB
Python

#!/usr/bin/env python
## plugins/gtkgui.py
##
## Gajim Team:
## - Yann Le Boulanger <asterix@crans.org>
## - Vincent Hanquez <tab@tuxfamily.org>
##
## Copyright (C) 2003 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 pygtk
pygtk.require('2.0')
import gtk
from gtk import TRUE, FALSE
import gtk.glade,gobject
import os,string,time,Queue
import common.optparser,common.sleepy
from common import i18n
_ = i18n._
APP = i18n.APP
gtk.glade.bindtextdomain (APP, i18n.DIR)
gtk.glade.textdomain (APP)
from config import *
from dialogs import *
GTKGUI_GLADE='plugins/gtkgui/gtkgui.glade'
class user:
"""Informations concerning each users"""
def __init__(self, *args):
if len(args) == 0:
self.jid = ''
self.name = ''
self.groups = []
self.show = ''
self.status = ''
self.sub == ''
self.resource == ''
elif len(args) == 7:
self.jid = args[0]
self.name = args[1]
self.groups = args[2]
self.show = args[3]
self.status = args[4]
self.sub = args[5]
self.resource = args[6]
else: raise TypeError, _('bad arguments')
class message_Window:
"""Class for chat window"""
def delete_event(self, widget):
"""close window"""
del self.plugin.windows[self.account]['chats'][self.user.jid]
def print_conversation(self, txt, contact = None, tim = None):
"""Print a line in the conversation :
if contact is set to status : it's a status message
if contact is set to another value : it's an outgoing message
if contact is not set : it's an incomming message"""
conversation = self.xml.get_widget('conversation')
buffer = conversation.get_buffer()
if not txt:
txt = ""
end_iter = buffer.get_end_iter()
if not tim:
tim = time.strftime("[%H:%M:%S]")
buffer.insert(end_iter, tim)
if contact:
if contact == 'status':
buffer.insert_with_tags_by_name(end_iter, txt+'\n', \
'status')
else:
buffer.insert_with_tags_by_name(end_iter, '<'+self.plugin.nicks[self.account]+'> ', 'outgoing')
buffer.insert(end_iter, txt+'\n')
else:
buffer.insert_with_tags_by_name(end_iter, '<' + \
self.user.name + '> ', 'incoming')
buffer.insert(end_iter, txt+'\n')
#scroll to the end of the textview
conversation.scroll_to_mark(buffer.get_mark('end'), 0.1, 0, 0, 0)
def read_queue(self, q):
"""read queue and print messages containted in it"""
while not q.empty():
evt = q.get()
self.print_conversation(evt[0], tim = evt[1])
del self.plugin.queues[self.account][self.user.jid]
for i in self.plugin.roster.get_user_iter(self.user.jid, self.account):
if self.plugin.roster.pixbufs.has_key(self.user.show):
self.plugin.roster.tree.get_model().set_value(i, 0, \
self.plugin.roster.pixbufs[self.user.show])
def on_msg_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
and printed in the conversation"""
if event.keyval == gtk.keysyms.Return:
if (event.state & gtk.gdk.SHIFT_MASK):
return 0
txt_buffer = widget.get_buffer()
start_iter = txt_buffer.get_start_iter()
end_iter = txt_buffer.get_end_iter()
txt = txt_buffer.get_text(start_iter, end_iter, 0)
if txt != '':
self.plugin.send('MSG', self.account, (self.user.jid, txt))
txt_buffer.set_text('', -1)
self.print_conversation(txt, self.user.jid)
widget.grab_focus()
return 1
return 0
def on_clear(self, widget):
"""When clear button is pressed :
clear the conversation"""
buffer = self.xml.get_widget('conversation').get_buffer()
deb, end = buffer.get_bounds()
buffer.delete(deb, end)
def on_history(self, widget):
"""When history button is pressed : call log window"""
if not self.plugin.windows['logs'].has_key(self.user.jid):
self.plugin.windows['logs'][self.user.jid] = log_Window(self.plugin, self.user.jid)
def __init__(self, user, plugin, account):
self.user = user
self.plugin = plugin
self.account = account
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'Chat', APP)
self.window = self.xml.get_widget('Chat')
# hbox = xml.get_widget('hbox1')
# hbox.set_property('resize-mode', 2)
self.window.set_title('Chat with ' + user.name)
self.img = self.xml.get_widget('image')
self.img.set_from_pixbuf(self.plugin.roster.pixbufs[user.show])
self.xml.get_widget('button_contact').set_label(user.name + ' <'\
+ user.jid + '>')
self.xml.get_widget('button_contact').set_resize_mode(gtk.RESIZE_QUEUE)
message = self.xml.get_widget('message')
message.grab_focus()
conversation = self.xml.get_widget('conversation')
buffer = conversation.get_buffer()
end_iter = buffer.get_end_iter()
buffer.create_mark('end', end_iter, 0)
self.xml.signal_connect('gtk_widget_destroy', self.delete_event)
self.xml.signal_connect('on_clear_clicked', self.on_clear)
self.xml.signal_connect('on_history_clicked', self.on_history)
self.xml.signal_connect('on_msg_key_press_event', \
self.on_msg_key_press_event)
self.tagIn = buffer.create_tag("incoming")
color = self.plugin.config['inmsgcolor']
if not color:
color = 'red'
self.tagIn.set_property("foreground", color)
self.tagOut = buffer.create_tag("outgoing")
color = self.plugin.config['outmsgcolor']
if not color:
color = 'blue'
self.tagOut.set_property("foreground", color)
self.tagStatus = buffer.create_tag("status")
color = self.plugin.config['statusmsgcolor']
if not color:
color = 'green'
self.tagStatus.set_property("foreground", color)
#print queued messages
if plugin.queues[account].has_key(user.jid):
self.read_queue(plugin.queues[account][user.jid])
class log_Window:
"""Class for bowser agent window :
to know the agents on the selected server"""
def delete_event(self, widget):
"""close window"""
del self.plugin.windows['logs'][self.jid]
def on_close(self, widget):
"""When Close button is clicked"""
widget.get_toplevel().destroy()
def on_earliest(self, widget):
buffer = self.xml.get_widget('textview').get_buffer()
start, end = buffer.get_bounds()
buffer.delete(start, end)
self.xml.get_widget('earliest_button').set_sensitive(False)
self.xml.get_widget('previous_button').set_sensitive(False)
self.xml.get_widget('forward_button').set_sensitive(True)
self.xml.get_widget('latest_button').set_sensitive(True)
end = 50
if end > self.nb_line:
end = self.nb_line
self.plugin.send('LOG_GET_RANGE', None, (self.jid, 0, end))
self.num_begin = self.nb_line
def on_previous(self, widget):
buffer = self.xml.get_widget('textview').get_buffer()
start, end = buffer.get_bounds()
buffer.delete(start, end)
self.xml.get_widget('earliest_button').set_sensitive(True)
self.xml.get_widget('previous_button').set_sensitive(True)
self.xml.get_widget('forward_button').set_sensitive(True)
self.xml.get_widget('latest_button').set_sensitive(True)
begin = self.num_begin - 50
if begin < 0:
begin = 0
end = begin + 50
if end > self.nb_line:
end = self.nb_line
self.plugin.send('LOG_GET_RANGE', None, (self.jid, begin, end))
self.num_begin = self.nb_line
def on_forward(self, widget):
buffer = self.xml.get_widget('textview').get_buffer()
start, end = buffer.get_bounds()
buffer.delete(start, end)
self.xml.get_widget('earliest_button').set_sensitive(True)
self.xml.get_widget('previous_button').set_sensitive(True)
self.xml.get_widget('forward_button').set_sensitive(True)
self.xml.get_widget('latest_button').set_sensitive(True)
begin = self.num_begin + 50
if begin > self.nb_line:
begin = self.nb_line
end = begin + 50
if end > self.nb_line:
end = self.nb_line
self.plugin.send('LOG_GET_RANGE', None, (self.jid, begin, end))
self.num_begin = self.nb_line
def on_latest(self, widget):
buffer = self.xml.get_widget('textview').get_buffer()
start, end = buffer.get_bounds()
buffer.delete(start, end)
self.xml.get_widget('earliest_button').set_sensitive(True)
self.xml.get_widget('previous_button').set_sensitive(True)
self.xml.get_widget('forward_button').set_sensitive(False)
self.xml.get_widget('latest_button').set_sensitive(False)
begin = self.nb_line - 50
if begin < 0:
begin = 0
self.plugin.send('LOG_GET_RANGE', None, (self.jid, begin, self.nb_line))
self.num_begin = self.nb_line
def new_line(self, infos):
"""write a new line"""
#infos = [num_line, date, type, data]
if infos[0] < self.num_begin:
self.num_begin = infos[0]
if infos[0] == 0:
self.xml.get_widget('earliest_button').set_sensitive(False)
self.xml.get_widget('previous_button').set_sensitive(False)
if infos[0] == self.nb_line:
self.xml.get_widget('forward_button').set_sensitive(False)
self.xml.get_widget('latest_button').set_sensitive(False)
buffer = self.xml.get_widget('textview').get_buffer()
start_iter = buffer.get_start_iter()
end_iter = buffer.get_end_iter()
tim = time.strftime("[%x %X] ", time.localtime(float(infos[1])))
buffer.insert(start_iter, tim)
if infos[2] == 'recv':
msg = string.join(infos[3][0:], ':')
msg = string.replace(msg, '\\n', '\n')
buffer.insert_with_tags_by_name(start_iter, msg, 'incoming')
elif infos[2] == 'sent':
msg = string.join(infos[3][0:], ':')
msg = string.replace(msg, '\\n', '\n')
buffer.insert_with_tags_by_name(start_iter, msg, 'outgoing')
else:
msg = string.join(infos[3][1:], ':')
msg = string.replace(msg, '\\n', '\n')
buffer.insert_with_tags_by_name(start_iter, _('Status is now : ') + \
infos[3][0]+' : ' + msg, 'status')
def set_nb_line(self, nb_line):
self.nb_line = nb_line
self.num_begin = nb_line
def __init__(self, plugin, jid):
self.plugin = plugin
self.jid = jid
self.nb_line = 0
self.num_begin = 0
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'Log', APP)
self.xml.signal_connect('gtk_widget_destroy', self.delete_event)
self.xml.signal_connect('on_close_clicked', self.on_close)
self.xml.signal_connect('on_earliest_clicked', self.on_earliest)
self.xml.signal_connect('on_previous_clicked', self.on_previous)
self.xml.signal_connect('on_forward_clicked', self.on_forward)
self.xml.signal_connect('on_latest_clicked', self.on_latest)
buffer = self.xml.get_widget('textview').get_buffer()
tagIn = buffer.create_tag("incoming")
color = self.plugin.config['inmsgcolor']
if not color:
color = 'red'
tagIn.set_property("foreground", color)
tagOut = buffer.create_tag("outgoing")
color = self.plugin.config['outmsgcolor']
if not color:
color = 'blue'
tagOut.set_property("foreground", color)
tagStatus = buffer.create_tag("status")
color = self.plugin.config['statusmsgcolor']
if not color:
color = 'green'
tagStatus.set_property("foreground", color)
self.plugin.send('LOG_NB_LINE', None, jid)
class roster_Window:
"""Class for main gtk window"""
def get_account_iter(self, name):
model = self.tree.get_model()
fin = False
account = model.get_iter_root()
if not account:
return None
while not fin:
account_name = model.get_value(account, 3)
if name == account_name:
return account
account = model.iter_next(account)
if not account:
fin = True
return None
def get_group_iter(self, name, account):
model = self.tree.get_model()
root = self.get_account_iter(account)
fin = False
group = model.iter_children(root)
if not group:
fin = True
while not fin:
group_name = model.get_value(group, 3)
if name == group_name:
return group
group = model.iter_next(group)
if not group:
fin = True
return None
def get_user_iter(self, jid, account):
model = self.tree.get_model()
acct = self.get_account_iter(account)
found = []
fin = False
group = model.iter_children(acct)
if not group:
return found
while not fin:
fin2 = False
user = model.iter_children(group)
if not user:
fin2=True
while not fin2:
if jid == model.get_value(user, 3):
found.append(user)
user = model.iter_next(user)
if not user:
fin2 = True
group = model.iter_next(group)
if not group:
fin = True
return found
def add_account_to_roster(self, account):
model = self.tree.get_model()
if self.get_account_iter(account):
return
statuss = ['offline', 'online', 'away', 'xa', 'dnd', 'invisible']
status = statuss[self.plugin.connected[account]]
model.append(None, (self.pixbufs[status], account, 'account', account,\
FALSE))
def add_user_to_roster(self, user, account):
"""Add a user to the roster and add groups if they aren't in roster"""
showOffline = self.plugin.config['showoffline']
if not self.contacts[account].has_key(user.jid):
self.contacts[account][user.jid] = user
if user.groups == []:
if string.find(user.jid, "@") <= 0:
user.groups.append('Agents')
else:
user.groups.append('general')
if (user.show == 'offline' or user.show == 'error') and not showOffline\
and not 'Agents' in user.groups:
return
model = self.tree.get_model()
for g in user.groups:
iterG = self.get_group_iter(g, account)
if not iterG:
acct = self.get_account_iter(account)
iterG = model.append(acct, \
(self.pixbufs['closed'], g, 'group', \
g, FALSE))
if not self.groups[account].has_key(g):
self.groups[account][g] = {'expand': True}
self.tree.expand_row((model.get_path(iterG)[0]), False)
typestr = 'user'
if g == 'Agents':
typestr = 'agent'
model.append(iterG, (self.pixbufs[user.show], \
user.name, typestr, user.jid, TRUE))
if self.groups[account][g]['expand']:
self.tree.expand_row(model.get_path(iterG), FALSE)
def remove_user(self, user, account):
"""Remove a user from the roster"""
model = self.tree.get_model()
for i in self.get_user_iter(user.jid, account):
parent_i = model.iter_parent(i)
model.remove(i)
if model.iter_n_children(parent_i) == 0:
model.remove(parent_i)
def mkmenu(self):
"""create the browse agents and add sub menus"""
if len(self.plugin.accounts.keys()) > 0:
self.xml.get_widget('add').set_sensitive(True)
self.xml.get_widget('browse_agents').set_sensitive(True)
else:
self.xml.get_widget('add').set_sensitive(False)
self.xml.get_widget('browse_agents').set_sensitive(False)
if len(self.plugin.accounts.keys()) > 1:
#add
menu_sub = gtk.Menu()
self.xml.get_widget('add').set_submenu(menu_sub)
for a in self.plugin.accounts.keys():
item = gtk.MenuItem(a)
menu_sub.append(item)
item.connect("activate", self.on_add, a)
menu_sub.show_all()
#agents
menu_sub = gtk.Menu()
self.xml.get_widget('browse_agents').set_submenu(menu_sub)
for a in self.plugin.accounts.keys():
item = gtk.MenuItem(a)
menu_sub.append(item)
item.connect("activate", self.on_browse, a)
menu_sub.show_all()
elif len(self.plugin.accounts.keys()) == 1:
#add
self.xml.get_widget('add').connect("activate", self.on_add, \
self.plugin.accounts.keys()[0])
#agents
self.xml.get_widget('browse_agents').connect("activate", \
self.on_browse, self.plugin.accounts.keys()[0])
def draw_roster(self):
"""Clear and draw roster"""
self.mkmenu()
self.tree.get_model().clear()
for acct in self.contacts.keys():
self.add_account_to_roster(acct)
for user in self.contacts[acct].values():
self.add_user_to_roster(user, acct)
def mklists(self, array, account):
"""fill self.contacts and self.groups"""
if not self.contacts.has_key(account):
self.contacts[account] = {}
if not self.groups.has_key(account):
self.groups[account] = {}
for jid in array.keys():
jids = string.split(jid, '/')
#get jid
ji = jids[0]
#get resource
resource = ''
if len(jids) > 1:
resource = jids[1:]
#get name
name = array[jid]['name']
if not name:
if string.find(ji, "@") <= 0:
name = ji
else:
name = string.split(jid, '@')[0]
#get show
show = array[jid]['show']
if not show:
show = 'offline'
user1 = user(ji, name, array[jid]['groups'], show, \
array[jid]['status'], array[jid]['sub'], resource)
self.contacts[account][ji] = user1
for g in array[jid]['groups'] :
if not g in self.groups[account].keys():
self.groups[account][g] = {'expand':True}
def chg_user_status(self, user, show, status, account):
"""When a user change his status"""
showOffline = self.plugin.config['showoffline']
iters = self.get_user_iter(user.jid, account)
if not iters:
self.add_user_to_roster(user, account)
else:
model = self.tree.get_model()
if (show == 'offline' or show == 'error') and not showOffline:
self.remove_user(user, account)
else:
for i in iters:
if self.pixbufs.has_key(show):
model.set_value(i, 0, self.pixbufs[show])
user.show = show
user.status = status
#Print status in chat window
if self.plugin.windows[account]['chats'].has_key(user.jid):
self.plugin.windows[account]['chats'][user.jid].\
img.set_from_pixbuf(self.pixbufs[show])
self.plugin.windows[account]['chats'][user.jid].print_conversation(\
_("%s is now %s (%s)") % (user.name, show, status), 'status')
def on_info(self, widget, user, account):
"""Call infoUser_Window class to display user's information"""
if not self.plugin.windows[account]['infos'].has_key(user.jid):
self.plugin.windows[account]['infos'][user.jid] = \
infoUser_Window(user, self.plugin, account)
def on_agent_logging(self, widget, jid, state, account):
"""When an agent is requested to log in or off"""
self.plugin.send('AGENT_LOGGING', account, (jid, state))
def on_history(self, widget, user):
"""When history button is pressed : call log window"""
if not self.plugin.windows['logs'].has_key(user.jid):
self.plugin.windows['logs'][user.jid] = log_Window(self.plugin, \
user.jid)
def mk_menu_user(self, event, iter):
"""Make user's popup menu"""
model = self.tree.get_model()
jid = model.get_value(iter, 3)
path = model.get_path(iter)
acct_iter = model.get_iter((path[0]))
account = model.get_value(acct_iter, 3)
user = self.contacts[account][jid]
menu = gtk.Menu()
item = gtk.MenuItem(_("Start chat"))
menu.append(item)
item.connect("activate", self.on_row_activated, path)
item = gtk.MenuItem(_("Rename"))
menu.append(item)
#item.connect("activate", self.on_rename, iter)
item = gtk.MenuItem()
menu.append(item)
item = gtk.MenuItem(_("Subscription"))
menu.append(item)
menu_sub = gtk.Menu()
item.set_submenu(menu_sub)
item = gtk.MenuItem(_("Resend authorization to"))
menu_sub.append(item)
item.connect("activate", self.authorize, jid, account)
item = gtk.MenuItem(_("Rerequest authorization from"))
menu_sub.append(item)
item.connect("activate", self.req_sub, jid, \
_('I would like to add you to my contact list, please.'), account)
item = gtk.MenuItem()
menu.append(item)
item = gtk.MenuItem(_("Remove"))
menu.append(item)
item.connect("activate", self.on_req_usub, user, account)
item = gtk.MenuItem()
menu.append(item)
item = gtk.MenuItem(_("Informations"))
menu.append(item)
item.connect("activate", self.on_info, user, account)
item = gtk.MenuItem(_("History"))
menu.append(item)
item.connect("activate", self.on_history, user)
menu.popup(None, None, None, event.button, event.time)
menu.show_all()
def mk_menu_g(self, event):
"""Make group's popup menu"""
menu = gtk.Menu()
item = gtk.MenuItem(_("grp1"))
# menu.append(item)
item = gtk.MenuItem(_("grp2"))
# menu.append(item)
item = gtk.MenuItem(_("grp3"))
# menu.append(item)
menu.popup(None, None, None, event.button, event.time)
menu.show_all()
def mk_menu_agent(self, event, iter):
"""Make agent's popup menu"""
model = self.tree.get_model()
jid = model.get_value(iter, 3)
path = model.get_path(iter)
acct_iter = model.get_iter((path[0]))
account = model.get_value(acct_iter, 3)
menu = gtk.Menu()
item = gtk.MenuItem(_("Log on"))
if self.contacts[account][jid].show != 'offline':
item.set_sensitive(FALSE)
menu.append(item)
item.connect("activate", self.on_agent_logging, jid, 'available', account)
item = gtk.MenuItem(_("Log off"))
if self.contacts[account][jid].show == 'offline':
item.set_sensitive(FALSE)
menu.append(item)
item.connect("activate", self.on_agent_logging, jid, 'unavailable', account)
menu.popup(None, None, None, event.button, event.time)
menu.show_all()
def on_edit_account(self, widget, account):
if not self.plugin.windows.has_key('accountPreference'):
infos = {}
infos['name'] = account
if self.plugin.accounts[account].has_key("name"):
infos['jid'] = self.plugin.accounts[account]["name"] + \
'@' + self.plugin.accounts[account]["hostname"]
if self.plugin.accounts[account].has_key("password"):
infos['password'] = self.plugin.accounts[account]["password"]
if self.plugin.accounts[account].has_key("ressource"):
infos['ressource'] = self.plugin.accounts[account]["ressource"]
if self.plugin.accounts[account].has_key("use_proxy"):
infos['use_proxy'] = self.plugin.accounts[account]["use_proxy"]
if self.plugin.accounts[account].has_key("proxyhost"):
infos['proxyhost'] = self.plugin.accounts[account]["proxyhost"]
if self.plugin.accounts[account].has_key("proxyport"):
infos['proxyport'] = self.plugin.accounts[account]["proxyport"]
self.plugin.windows['accountPreference'] = \
accountPreference_Window(self.plugin, infos)
def mk_menu_account(self, event, iter):
"""Make account's popup menu"""
model = self.tree.get_model()
account = model.get_value(iter, 3)
menu = gtk.Menu()
item = gtk.MenuItem(_("Status"))
menu.append(item)
menu_sub = gtk.Menu()
item.set_submenu(menu_sub)
item = gtk.MenuItem(_("Online"))
menu_sub.append(item)
item.connect("activate", self.change_status, account, 'online')
item = gtk.MenuItem(_("Away"))
menu_sub.append(item)
item.connect("activate", self.change_status, account, 'away')
item = gtk.MenuItem(_("NA"))
menu_sub.append(item)
item.connect("activate", self.change_status, account, 'na')
item = gtk.MenuItem(_("DND"))
menu_sub.append(item)
item.connect("activate", self.change_status, account, 'dnd')
item = gtk.MenuItem()
menu_sub.append(item)
item = gtk.MenuItem(_("Offline"))
menu_sub.append(item)
item.connect("activate", self.change_status, account, 'offline')
item = gtk.MenuItem()
menu.append(item)
item = gtk.MenuItem(_("Edit account"))
menu.append(item)
item.connect("activate", self.on_edit_account, account)
menu.popup(None, None, None, event.button, event.time)
menu.show_all()
def authorize(self, widget, jid, account):
"""Authorize a user"""
self.plugin.send('AUTH', account, jid)
def req_sub(self, widget, jid, txt, account):
"""Request subscription to a user"""
self.plugin.send('SUB', account, (jid, txt))
if not self.contacts[account].has_key(jid):
user1 = user(jid, jid, ['general'], 'requested', \
'requested', 'sub', '')
self.add_user_to_roster(user1, account)
def on_treeview_event(self, widget, event):
"""popup user's group's or agent menu"""
if (event.button == 3) & (event.type == gtk.gdk.BUTTON_PRESS):
try:
path, column, x, y = self.tree.get_path_at_pos(int(event.x), \
int(event.y))
except TypeError:
return
model = self.tree.get_model()
iter = model.get_iter(path)
type = model.get_value(iter, 2)
if type == 'group':
self.mk_menu_g(event)
elif type == 'agent':
self.mk_menu_agent(event, iter)
elif type == 'user':
self.mk_menu_user(event, iter)
elif type == 'account':
self.mk_menu_account(event, iter)
return gtk.TRUE
return gtk.FALSE
def on_req_usub(self, widget, user, account):
"""Remove a user"""
window = confirm_Window(_("Are you sure you want to remove %s (%s) from your roster ?") % (user.name, user.jid))
if window.wait() == gtk.RESPONSE_OK:
self.plugin.send('UNSUB', account, user.jid)
self.remove_user(user, account)
del self.contacts[account][user.jid]
def change_status(self, widget, account, status):
if status != 'online' and status != 'offline':
w = awayMsg_Window()
txt = w.run()
if txt != -1:
self.plugin.send('STATUS', account, (status, txt))
else:
txt = status
self.plugin.send('STATUS', account, (status, txt))
def on_optionmenu_changed(self, widget):
"""When we change our status"""
optionmenu = self.xml.get_widget('optionmenu')
history = optionmenu.get_history()
status = optionmenu.get_menu().get_children()[history].name
if status != 'online' and status != 'offline':
w = awayMsg_Window()
txt = w.run()
if txt == -1:
self.set_optionmenu()
return
else:
txt = status
accounts = self.plugin.accounts.keys()
if len(accounts) == 0:
warning_Window(_("You must setup an account before connecting to jabber network."))
return
for acct in accounts:
self.plugin.send('STATUS', acct, (status, txt))
def set_optionmenu(self):
#table to change index in plugin.connected to index in optionmenu
table = {0:6, 1:0, 2:1, 3:2, 4:3, 5:4}
mini = min(self.plugin.connected.values())
optionmenu = self.xml.get_widget('optionmenu')
#temporarily block signal in order not to send status that we show
#in the optionmenu
optionmenu.handler_block(self.id_signal_optionmenu)
optionmenu.set_history(table[mini])
optionmenu.handler_unblock(self.id_signal_optionmenu)
def on_status_changed(self, account, status):
"""the core tells us that our status has changed"""
if not self.contacts.has_key(account):
return
model = self.tree.get_model()
accountIter = self.get_account_iter(account)
if accountIter:
model.set_value(accountIter, 0, self.pixbufs[status])
statuss = ['offline', 'online', 'away', 'xa', 'dnd', 'invisible']
if status == 'offline':
self.plugin.sleeper = None
for jid in self.contacts[account]:
user = self.contacts[account][jid]
self.chg_user_status(user, 'offline', 'Disconnected', account)
elif self.plugin.connected[account] == 0:
self.plugin.sleeper = None#common.sleepy.Sleepy(\
#self.plugin.config['autoawaytime']*60, \
#self.plugin.config['autoxatime']*60)
self.plugin.connected[account] = statuss.index(status)
self.set_optionmenu()
def on_message(self, jid, msg, account):
"""when we receive a message"""
if not self.contacts[account].has_key(jid):
user1 = user(jid, jid, ['not in list'], \
'not in list', 'not in list', 'none', '')
self.add_user_to_roster(user1, account)
autopopup = self.plugin.config['autopopup']
if autopopup == 0 and not \
self.plugin.windows[account]['chats'].has_key(jid):
#We save it in a queue
if not self.plugin.queues[account].has_key(jid):
model = self.tree.get_model()
self.plugin.queues[account][jid] = Queue.Queue(50)
for i in self.get_user_iter(jid, account):
model.set_value(i, 0, self.pixbufs['message'])
tim = time.strftime("[%H:%M:%S]")
self.plugin.queues[account][jid].put((msg, tim))
else:
if not self.plugin.windows[account]['chats'].has_key(jid):
self.plugin.windows[account]['chats'][jid] = \
message_Window(self.contacts[account][jid], self.plugin, account)
self.plugin.windows[account]['chats'][jid].print_conversation(msg)
def on_prefs(self, widget):
"""When preferences is selected :
call the preference_Window class"""
if not self.plugin.windows.has_key('preferences'):
self.plugin.windows['preferences'] = preference_Window(self.plugin)
def on_add(self, widget, account):
"""When add user is selected :
call the add class"""
addContact_Window(self.plugin, account)
def on_about(self, widget):
"""When about is selected :
call the about class"""
if not self.plugin.windows.has_key('about'):
self.plugin.windows['about'] = about_Window(self.plugin)
def on_accounts(self, widget):
"""When accounts is seleted :
call the accounts class to modify accounts"""
if not self.plugin.windows.has_key('accounts'):
self.plugin.windows['accounts'] = accounts_Window(self.plugin)
def on_quit(self, widget):
"""When we quit the gtk plugin :
tell that to the core and exit gtk"""
self.plugin.send('QUIT', None, '')
print _("plugin gtkgui stopped")
gtk.mainquit()
def on_row_activated(self, widget, path, col=0):
"""When an iter is dubble clicked :
open the chat window"""
model = self.tree.get_model()
acct_iter = model.get_iter((path[0]))
account = model.get_value(acct_iter, 3)
iter = model.get_iter(path)
type = model.get_value(iter, 2)
jid = model.get_value(iter, 3)
if (type == 'group') or (type == 'account'):
if (self.tree.row_expanded(path)):
self.tree.collapse_row(path)
else:
self.tree.expand_row(path, False)
else:
if self.plugin.windows[account]['chats'].has_key(jid):
self.plugin.windows[account]['chats'][jid].window.present()
elif self.contacts[account].has_key(jid):
self.plugin.windows[account]['chats'][jid] = \
message_Window(self.contacts[account][jid], self.plugin, account)
def on_row_expanded(self, widget, iter, path):
"""When a row is expanded :
change the icon of the arrow"""
model = self.tree.get_model()
acct_iter = model.get_iter((path[0]))
account = model.get_value(acct_iter, 3)
type = model.get_value(iter, 2)
if type == 'group':
model.set_value(iter, 0, self.pixbufs['opened'])
jid = model.get_value(iter, 3)
self.groups[account][jid]['expand'] = True
elif type == 'account':
for g in self.groups[account]:
groupIter = self.get_group_iter(g, account)
if groupIter and self.groups[account][g]['expand']:
pathG = model.get_path(groupIter)
self.tree.expand_row(pathG, False)
def on_row_collapsed(self, widget, iter, path):
"""When a row is collapsed :
change the icon of the arrow"""
model = self.tree.get_model()
acct_iter = model.get_iter((path[0]))
account = model.get_value(acct_iter, 3)
type = model.get_value(iter, 2)
if type == 'group':
model.set_value(iter, 0, self.pixbufs['closed'])
jid = model.get_value(iter, 3)
self.groups[account][jid]['expand'] = False
def on_cell_edited (self, cell, row, new_text):
"""When an iter is editer :
if text has changed, rename the user
else open chat window"""
model = self.tree.get_model()
iter = model.get_iter_from_string(row)
path = model.get_path(iter)
acct_iter = model.get_iter((path[0]))
account = model.get_value(acct_iter, 3)
jid = model.get_value(iter, 3)
old_text = self.contacts[account][jid].name
#FIXME:If it is a double click, old_text == new_text
if old_text == new_text:
if self.plugin.windows[account]['chats'].has_key(jid):
chat = self.plugin.windows[account]['chats'][jid]
chat.xml.get_widget('Chat').present()
elif self.contacts[account].has_key(jid):
self.plugin.windows[account]['chats'][jid] = \
message_Window(self.contacts[account][jid], self.plugin, account)
else:
model.set_value(iter, 1, new_text)
self.contacts[account][jid].name = new_text
self.plugin.send('UPDUSER', account, (jid, new_text, \
self.contacts[account][jid].groups))
def on_browse(self, widget, account):
"""When browse agent is selected :
Call browse class"""
if not self.plugin.windows[account].has_key('browser'):
self.plugin.windows[account]['browser'] = browseAgent_Window(self.plugin, account)
def mkpixbufs(self):
"""initialise pixbufs array"""
iconstyle = self.plugin.config['iconstyle']
if not iconstyle:
iconstyle = 'sun'
self.path = 'plugins/gtkgui/icons/' + iconstyle + '/'
self.pixbufs = {}
for state in ('online', 'chat', 'away', 'xa', 'dnd', 'offline', 'error', \
'requested', 'message', 'opened', 'closed', 'not in list'):
# try to open a pixfile with the correct method
files = []
files.append(self.path + state + '.gif')
files.append(self.path + state + '.png')
files.append(self.path + state + '.xpm')
self.pixbufs[state] = None
for file in files:
if not os.path.exists(file):
continue
fct = gtk.gdk.pixbuf_new_from_file
if file.find('.gif') != -1:
fct = gtk.gdk.PixbufAnimation
pix = fct(file)
self.pixbufs[state] = pix
break
for state in ('online', 'away', 'xa', 'dnd', 'offline'):
image = gtk.Image()
image.set_from_pixbuf(self.pixbufs[state])
image.show()
self.xml.get_widget(state).set_image(image)
self.xml.get_widget('invisible').set_sensitive(False)
def on_show_off(self, widget):
"""when show offline option is changed :
redraw the treeview"""
self.plugin.config['showoffline'] = 1 - self.plugin.config['showoffline']
self.plugin.send('CONFIG', None, ('GtkGui', self.plugin.config))
self.draw_roster()
def iconCellDataFunc(self, column, renderer, model, iter, data=None):
"""When a row is added, set properties for icon renderer"""
if model.get_value(iter, 2) == 'account':
renderer.set_property('cell-background', '#9fdfff')
renderer.set_property('xalign', 0)
elif model.get_value(iter, 2) == 'group':
renderer.set_property('cell-background-set', False)
renderer.set_property('xalign', 0.3)
else:
renderer.set_property('cell-background-set', False)
renderer.set_property('xalign', 1)
renderer.set_property('width', 30)
def nameCellDataFunc(self, column, renderer, model, iter, data=None):
"""When a row is added, set properties for name renderer"""
if model.get_value(iter, 2) == 'account':
renderer.set_property('foreground', 'red')
renderer.set_property('cell-background', '#9fdfff')
renderer.set_property('font', 'Normal')
renderer.set_property('weight', 700)
renderer.set_property('xpad', 0)
elif model.get_value(iter, 2) == 'group':
renderer.set_property('foreground', 'blue')
renderer.set_property('cell-background-set', False)
renderer.set_property('font', 'Italic')
renderer.set_property('weight-set', False)
renderer.set_property('xpad', 8)
else:
renderer.set_property('foreground-set', False)
renderer.set_property('cell-background-set', False)
renderer.set_property('font', 'Normal')
renderer.set_property('weight-set', False)
renderer.set_property('xpad', 16)
def compareIters(self, model, iter1, iter2, data = None):
"""Compare two iters to sort them"""
name1 = model.get_value(iter1, 1)
name2 = model.get_value(iter2, 1)
if not name1 or not name2:
return 0
type = model.get_value(iter1, 2)
if type == 'group':
if name1 == 'Agents':
return 1
if name2 == 'Agents':
return -1
if name1.lower() < name2.lower():
return -1
if name2.lower < name1.lower():
return 1
return 0
def __init__(self, plugin):
# FIXME : handle no file ...
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'Gajim', APP)
self.tree = self.xml.get_widget('treeview')
self.plugin = plugin
self.groups = {}
self.contacts = {}
for a in self.plugin.accounts.keys():
self.contacts[a] = {}
self.groups[a] = {}
#(icon, name, type, jid, editable)
model = gtk.TreeStore(gobject.GObject, str, str, str, \
# model = gtk.TreeStore(gtk.gdk.Pixbuf, str, str, str, \
gobject.TYPE_BOOLEAN)
model.set_sort_func(1, self.compareIters)
model.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.tree.set_model(model)
self.mkpixbufs()
# map = self.tree.get_colormap()
# colour = map.alloc_color("red") # light red
# colour2 = map.alloc_color("blue") # light red
# colour = map.alloc_color("#FF9999") # light red
# st = self.tree.get_style().copy()
# st.bg[gtk.STATE_NORMAL] = colour
# st.fg[gtk.STATE_NORMAL] = colour
# st.bg[gtk.STATE_ACTIVE] = colour2
# st.fg[gtk.STATE_ACTIVE] = colour2
# st.bg[gtk.STATE_INSENSITIVE] = colour
# st.bg[gtk.STATE_PRELIGHT] = colour
# st.bg[gtk.STATE_SELECTED] = colour
# st.fg[gtk.STATE_SELECTED] = colour2
# st.white = colour
# print st.bg
# print self.tree.get_property('expander-column')
# self.tree.set_style(st)
self.xml.get_widget('optionmenu').set_history(6)
showOffline = self.plugin.config['showoffline']
self.xml.get_widget('show_offline').set_active(showOffline)
#columns
col = gtk.TreeViewColumn()
self.tree.append_column(col)
render_pixbuf = gtk.CellRendererPixbuf()
col.pack_start(render_pixbuf, expand = False)
col.add_attribute(render_pixbuf, 'pixbuf', 0)
col.set_cell_data_func(render_pixbuf, self.iconCellDataFunc, None)
render_text = gtk.CellRendererText()
render_text.connect('edited', self.on_cell_edited)
col.pack_start(render_text, expand = True)
col.add_attribute(render_text, 'text', 1)
col.add_attribute(render_text, 'editable', 4)
col.set_cell_data_func(render_text, self.nameCellDataFunc, None)
col = gtk.TreeViewColumn()
render_pixbuf = gtk.CellRendererPixbuf()
col.pack_start(render_pixbuf, expand = False)
self.tree.append_column(col)
col.set_visible(FALSE)
self.tree.set_expander_column(col)
#signals
self.xml.signal_connect('gtk_main_quit', self.on_quit)
self.xml.signal_connect('on_preferences_activate', self.on_prefs)
self.xml.signal_connect('on_accounts_activate', self.on_accounts)
self.xml.signal_connect('on_show_offline_activate', self.on_show_off)
self.xml.signal_connect('on_about_activate', self.on_about)
self.xml.signal_connect('on_quit_activate', self.on_quit)
self.xml.signal_connect('on_treeview_event', self.on_treeview_event)
self.xml.signal_connect('on_status_changed', self.on_status_changed)
optionmenu = self.xml.get_widget('optionmenu')
self.id_signal_optionmenu = optionmenu.connect('changed', \
self.on_optionmenu_changed)
self.xml.signal_connect('on_row_activated', self.on_row_activated)
self.xml.signal_connect('on_row_expanded', self.on_row_expanded)
self.xml.signal_connect('on_row_collapsed', self.on_row_collapsed)
self.draw_roster()
class plugin:
"""Class called by the core in a new thread"""
class accounts:
"""Class where are stored the accounts and users in them"""
def __init__(self):
self.__accounts = {}
def add_account(self, account, users=()):
#users must be like (user1, user2)
self.__accounts[account] = users
def add_user_to_account(self, account, user):
if self.__accounts.has_key(account):
self.__accounts[account].append(user)
else :
return 1
def get_accounts(self):
return self.__accounts.keys();
def get_users(self, account):
if self.__accounts.has_key(account):
return self.__accounts[account]
else :
return None
def which_account(self, user):
for a in self.__accounts.keys():
if user in self.__accounts[a]:
return a
return None
def send(self, event, account, data):
self.queueOUT.put((event, account, data))
def wait(self, what):
"""Wait for a message from Core"""
#TODO: timeout
temp_q = Queue.Queue(50)
while 1:
if not self.queueIN.empty():
ev = self.queueIN.get()
if ev[0] == what and ev[2][0] == 'GtkGui':
#Restore messages
while not temp_q.empty():
ev2 = temp_q.get()
self.queueIN.put(ev2)
return ev[2][1]
else:
#Save messages
temp_q.put(ev)
def read_queue(self):
"""Read queue from the core and execute commands from it"""
model = self.roster.tree.get_model()
while self.queueIN.empty() == 0:
ev = self.queueIN.get()
if ev[0] == 'ROSTER':
self.roster.mklists(ev[2], ev[1])
self.roster.draw_roster()
elif ev[0] == 'WARNING':
warning_Window(ev[2])
#('STATUS', account, status)
elif ev[0] == 'STATUS':
self.roster.on_status_changed(ev[1], ev[2])
#('NOTIFY', account, (jid, status, message, resource))
elif ev[0] == 'NOTIFY':
jid = string.split(ev[2][0], '/')[0]
resource = ev[2][3]
if not resource:
resource = ''
if string.find(jid, "@") <= 0:
#It must be an agent
ji = string.replace(jid, '@', '')
else:
ji = jid
#Update user
if self.roster.contacts[ev[1]].has_key(ji):
user = self.roster.contacts[ev[1]][ji]
user.show = ev[2][1]
user.status = ev[2][2]
user.resource = resource
if string.find(jid, "@") <= 0:
#It must be an agent
if not self.roster.contacts[ev[1]].has_key(ji):
user1 = user(ji, ji, ['Agents'], ev[2][1], \
ev[2][2], 'from', resource)
self.roster.add_user_to_roster(user1, ev[1])
else:
#Update existing iter
for i in self.roster.get_user_iter(ji, ev[1]):
if self.roster.pixbufs.has_key(ev[2][1]):
model.set_value(i, 0, self.roster.pixbufs[ev[2][1]])
elif self.roster.contacts[ev[1]].has_key(ji):
#It isn't an agent
self.roster.chg_user_status(user, ev[2][1], ev[2][2], ev[1])
#('MSG', account, (user, msg))
elif ev[0] == 'MSG':
if string.find(ev[2][0], "@") <= 0:
jid = string.replace(ev[2][0], '@', '')
else:
jid = ev[2][0]
self.roster.on_message(jid, ev[2][1], ev[1])
#('SUBSCRIBE', account, (jid, text))
elif ev[0] == 'SUBSCRIBE':
authorize_Window(self, ev[2][0], ev[2][1], ev[1])
#('SUBSCRIBED', account, (jid, nom, resource))
elif ev[0] == 'SUBSCRIBED':
if self.roster.contacts[ev[1]].has_key(ev[2][0]):
u = self.roster.contacts[ev[1]][ev[2][0]]['user']
u.name = ev[2][1]
u.resource = ev[2][2]
for i in self.roster.contacts[ev[1]][u.jid]['iter']:
model.set_value(i, 1, u.name)
else:
user1 = user(ev[2][0], ev[2][0], ['general'], 'online', \
'online', 'to', ev[2][2])
self.roster.add_user(user1)
warning_Window(_("You are now authorized by %s") % ev[2][0])
elif ev[0] == 'UNSUBSCRIBED':
warning_Window(_("You are now unsubscribed by %s") % ev[2])
#TODO: change icon
#('AGENTS', account, agents)
elif ev[0] == 'AGENTS':
if self.windows[ev[1]].has_key('browser'):
self.windows[ev[1]]['browser'].agents(ev[2])
#('AGENTS_INFO', account, (agent, infos))
elif ev[0] == 'AGENT_INFO':
if not ev[2][1].has_key('instructions'):
warning_Window(_("error contacting %s") % ev[2][0])
else:
agentRegistration_Window(ev[2][0], ev[2][1], self, ev[1])
#('ACC_OK', account, (hostname, login, pasword, name, ressource))
elif ev[0] == 'ACC_OK':
self.accounts[ev[2][3]] = {'ressource': ev[2][4], \
'password': ev[2][2], 'hostname': ev[2][0], 'name': ev[2][1]}
self.send('CONFIG', None, ('accounts', self.accounts))
self.windows[name] = {'infos': {}, 'chats': {}}
self.queues[name] = {}
self.connected[name] = 0
self.roster.groups[name] = {}
self.roster.contacts[name] = {}
if self.windows.has_key('accounts'):
self.windows['accounts'].init_accounts()
elif ev[0] == 'QUIT':
self.roster.on_quit(self)
elif ev[0] == 'MYVCARD':
nick = ''
if ev[2].has_key('NICKNAME'):
nick = ev[2]['NICKNAME']
if nick == '':
nick = self.accounts[ev[1]]['name']
self.nicks[ev[1]] = nick
elif ev[0] == 'VCARD':
if self.windows[ev[1]]['infos'].has_key(ev[2]['jid']):
self.windows[ev[1]]['infos'][ev[2]['jid']].set_values(ev[2])
#('LOG_NB_LINE', account, (jid, nb_line))
elif ev[0] == 'LOG_NB_LINE':
if self.windows['logs'].has_key(ev[2][0]):
self.windows['logs'][ev[2][0]].set_nb_line(ev[2][1])
begin = 0
if ev[2][1] > 50:
begin = ev[2][1] - 50
self.send('LOG_GET_RANGE', None, (ev[2][0], begin, ev[2][1]))
#('LOG_LINE', account, (jid, num_line, date, type, data))
# if type = 'recv' or 'sent' data = [msg]
# else type = jid and data = [status, away_msg]
elif ev[0] == 'LOG_LINE':
if self.windows['logs'].has_key(ev[2][0]):
self.windows['logs'][ev[2][0]].new_line(ev[2][1:])
return 1
def read_sleepy(self):
"""Check if we are idle"""
if self.sleeper and (self.config['autoaway'] or self.config['autoxa'])\
and (self.roster.optionmenu.get_history()==0 or \
self.sleeper_state!=common.sleepy.STATE_AWAKE):
self.sleeper.poll()
state = self.sleeper.getState()
if state != self.sleeper_state:
if state == common.sleepy.STATE_AWAKE:
#we go online
self.roster.optionmenu.set_history(0)
self.send('STATUS', None, ('online', ''))
elif state == common.sleepy.STATE_AWAY and self.config['autoaway']:
#we go away
self.roster.optionmenu.set_history(1)
self.send('STATUS', None, ('away', 'auto away (idle)'))
elif state == common.sleepy.STATE_XAWAY and self.config['autoxa']:
#we go extended away
self.roster.optionmenu.set_history(2)
self.send('STATUS',('xa', 'auto away (idel)'))
self.sleeper_state = state
return 1
def __init__(self, quIN, quOUT):
gtk.threads_init()
gtk.threads_enter()
self.queueIN = quIN
self.queueOUT = quOUT
self.send('ASK_CONFIG', None, ('GtkGui', 'GtkGui', {'autopopup':1,\
'showoffline':0,\
'autoaway':0,\
'autoawaytime':10,\
'autoxa':0,\
'autoxatime':20,\
'iconstyle':'sun',\
'inmsgcolor':'#ff0000',\
'outmsgcolor': '#0000ff',\
'statusmsgcolor':'#1eaa1e'}))
self.config = self.wait('CONFIG')
self.send('ASK_CONFIG', None, ('GtkGui', 'accounts'))
self.accounts = self.wait('CONFIG')
self.windows = {'logs':{}}
self.queues = {}
self.connected = {}
self.nicks = {}
for a in self.accounts.keys():
self.windows[a] = {}
self.windows[a]['infos'] = {}
self.windows[a]['chats'] = {}
self.queues[a] = {}
self.connected[a] = 0
self.nicks[a] = self.accounts[a]['name']
self.roster = roster_Window(self)
gtk.timeout_add(100, self.read_queue)
gtk.timeout_add(1000, self.read_sleepy)
self.sleeper = None
self.sleeper_state = None
gtk.main()
gtk.threads_leave()
if __name__ == "__main__":
plugin(None, None)
print _("plugin gtkgui loaded")