a better code for roster_Window class
This commit is contained in:
Yann Leboulanger
parent
8e0bd6c409
commit
9954becd9c
|
|
@ -54,7 +54,7 @@ class GajimHub:
|
|||
self.events[event] = [qu]
|
||||
# END register
|
||||
|
||||
def sendPlugin(self, event, data):
|
||||
def sendPlugin(self, event, con, data):
|
||||
""" Sends an event to registered plugins
|
||||
NOTIFY : ('NOTIFY', (user, status, message))
|
||||
MSG : ('MSG', (user, msg))
|
||||
|
|
@ -63,6 +63,6 @@ class GajimHub:
|
|||
|
||||
if self.events.has_key(event):
|
||||
for i in self.events[event]:
|
||||
i.put((event, data))
|
||||
i.put((event, con, data))
|
||||
# END sendPlugin
|
||||
# END GajimHub
|
||||
|
|
|
|||
267
core/core.py
267
core/core.py
|
|
@ -36,11 +36,15 @@ CONFPATH = "~/.gajim/config"
|
|||
class GajimCore:
|
||||
"""Core"""
|
||||
def __init__(self):
|
||||
self.connected = 0
|
||||
self.init_cfg_file()
|
||||
self.cfgParser = common.optparser.OptionsParser(CONFPATH)
|
||||
self.hub = common.hub.GajimHub()
|
||||
self.parse()
|
||||
self.connected = {}
|
||||
#connexions {con: name, ...}
|
||||
self.connexions = {}
|
||||
for a in self.accounts:
|
||||
self.connected[a] = 0
|
||||
# END __init__
|
||||
|
||||
def init_cfg_file(self):
|
||||
|
|
@ -89,12 +93,12 @@ class GajimCore:
|
|||
vcard[info.getName()] = {}
|
||||
for c in info.getChildren():
|
||||
vcard[info.getName()][c.getName()] = c.getData()
|
||||
self.hub.sendPlugin('VCARD', vcard)
|
||||
self.hub.sendPlugin('VCARD', self.connexions[con], vcard)
|
||||
|
||||
def messageCB(self, con, msg):
|
||||
"""Called when we recieve a message"""
|
||||
self.hub.sendPlugin('MSG', (msg.getFrom().getBasic(), \
|
||||
msg.getBody()))
|
||||
self.hub.sendPlugin('MSG', self.connexions[con], \
|
||||
(msg.getFrom().getBasic(), msg.getBody()))
|
||||
# END messageCB
|
||||
|
||||
def presenceCB(self, con, prs):
|
||||
|
|
@ -108,38 +112,40 @@ class GajimCore:
|
|||
show = prs.getShow()
|
||||
else:
|
||||
show = 'online'
|
||||
self.hub.sendPlugin('NOTIFY', (prs.getFrom().getBasic(), \
|
||||
show, prs.getStatus(), prs.getFrom().getResource()))
|
||||
self.hub.sendPlugin('NOTIFY', self.connexions[con], \
|
||||
(prs.getFrom().getBasic(), show, prs.getStatus(), \
|
||||
prs.getFrom().getResource()))
|
||||
elif type == 'unavailable':
|
||||
self.hub.sendPlugin('NOTIFY', \
|
||||
self.hub.sendPlugin('NOTIFY', self.connexions[con], \
|
||||
(prs.getFrom().getBasic(), 'offline', prs.getStatus(), \
|
||||
prs.getFrom().getResource()))
|
||||
elif type == 'subscribe':
|
||||
log.debug("subscribe request from %s" % who)
|
||||
if self.cfgParser.Core['alwaysauth'] == 1 or \
|
||||
string.find(who, "@") <= 0:
|
||||
self.con.send(common.jabber.Presence(who, 'subscribed'))
|
||||
con.send(common.jabber.Presence(who, 'subscribed'))
|
||||
if string.find(who, "@") <= 0:
|
||||
self.hub.sendPlugin('NOTIFY', (who, 'offline', 'offline', \
|
||||
prs.getFrom().getResource()))
|
||||
self.hub.sendPlugin('NOTIFY', self.connexions[con], \
|
||||
(who, 'offline', 'offline', prs.getFrom().getResource()))
|
||||
else:
|
||||
txt = prs.getStatus()
|
||||
if not txt:
|
||||
txt = "I would like to add you to my roster."
|
||||
self.hub.sendPlugin('SUBSCRIBE', (who, 'txt'))
|
||||
self.hub.sendPlugin('SUBSCRIBE', self.connexions[con], (who, 'txt'))
|
||||
elif type == 'subscribed':
|
||||
jid = prs.getFrom()
|
||||
self.hub.sendPlugin('SUBSCRIBED', {'jid':jid.getBasic(), \
|
||||
'nom':jid.getNode(), 'ressource':jid.getResource()})
|
||||
self.hub.queueIn.put(('UPDUSER', (jid.getBasic(), \
|
||||
jid.getNode(), ['general'])))
|
||||
#BE CAREFUL : no self.con.updateRosterItem() in a callback
|
||||
self.hub.sendPlugin('SUBSCRIBED', self.connexions[con],\
|
||||
(jid.getBasic(), jid.getNode(), jid.getResource()))
|
||||
self.hub.queueIn.put(('UPDUSER', self.connexions[con], \
|
||||
(jid.getBasic(), jid.getNode(), ['general'])))
|
||||
#BE CAREFUL : no con.updateRosterItem() in a callback
|
||||
log.debug("we are now subscribed to %s" % who)
|
||||
elif type == 'unsubscribe':
|
||||
log.debug("unsubscribe request from %s" % who)
|
||||
elif type == 'unsubscribed':
|
||||
log.debug("we are now unsubscribed to %s" % who)
|
||||
self.hub.sendPlugin('UNSUBSCRIBED', prs.getFrom().getBasic())
|
||||
self.hub.sendPlugin('UNSUBSCRIBED', self.connexions[con], \
|
||||
prs.getFrom().getBasic())
|
||||
elif type == 'error':
|
||||
print "\n\n******** ERROR *******"
|
||||
#print "From : %s" % prs.getFrom()
|
||||
|
|
@ -158,10 +164,10 @@ class GajimCore:
|
|||
def disconnectedCB(self, con):
|
||||
"""Called when we are disconnected"""
|
||||
log.debug("disconnectedCB")
|
||||
if self.connected == 1:
|
||||
self.connected = 0
|
||||
self.con.disconnect()
|
||||
self.hub.sendPlugin('STATUS', 'offline')
|
||||
if self.connected[self.connexions[con]] == 1:
|
||||
self.connected[self.connexions[con]] = 0
|
||||
con.disconnect()
|
||||
self.hub.sendPlugin('STATUS', self.connexions[con], 'offline')
|
||||
# END disconenctedCB
|
||||
|
||||
def connect(self, account):
|
||||
|
|
@ -170,45 +176,49 @@ class GajimCore:
|
|||
name = self.cfgParser.tab[account]["name"]
|
||||
password = self.cfgParser.tab[account]["password"]
|
||||
ressource = self.cfgParser.tab[account]["ressource"]
|
||||
self.con = common.jabber.Client(host = hostname, \
|
||||
con = common.jabber.Client(host = hostname, \
|
||||
debug = [common.jabber.DBG_ALWAYS], log = sys.stderr, \
|
||||
connection=common.xmlstream.TCP, port=5222)
|
||||
#debug = [common.jabber.DBG_ALWAYS], log = sys.stderr, \
|
||||
#connection=common.xmlstream.TCP_SSL, port=5223)
|
||||
self.connexions[con] = account
|
||||
try:
|
||||
self.con.connect()
|
||||
con.connect()
|
||||
except IOError, e:
|
||||
log.debug("Couldn't connect to %s %s" % (hostname, e))
|
||||
self.hub.sendPlugin('STATUS', 'offline')
|
||||
self.hub.sendPlugin('WARNING', "Couldn't connect to %s" % hostname)
|
||||
self.hub.sendPlugin('STATUS', account, 'offline')
|
||||
self.hub.sendPlugin('WARNING', None, "Couldn't connect to %s" \
|
||||
% hostname)
|
||||
return 0
|
||||
except common.xmlstream.socket.error, e:
|
||||
log.debug("Couldn't connect to %s %s" % (hostname, e))
|
||||
self.hub.sendPlugin('STATUS', 'offline')
|
||||
self.hub.sendPlugin('WARNING', "Couldn't connect to %s : %s" % (hostname, e))
|
||||
self.hub.sendPlugin('STATUS', account, 'offline')
|
||||
self.hub.sendPlugin('WARNING', None, "Couldn't connect to %s : %s" \
|
||||
% (hostname, e))
|
||||
return 0
|
||||
else:
|
||||
log.debug("Connected to server")
|
||||
|
||||
self.con.registerHandler('message', self.messageCB)
|
||||
self.con.registerHandler('presence', self.presenceCB)
|
||||
self.con.registerHandler('iq',self.vCardCB,'result')#common.jabber.NS_VCARD)
|
||||
self.con.setDisconnectHandler(self.disconnectedCB)
|
||||
con.registerHandler('message', self.messageCB)
|
||||
con.registerHandler('presence', self.presenceCB)
|
||||
con.registerHandler('iq',self.vCardCB,'result')#common.jabber.NS_VCARD)
|
||||
con.setDisconnectHandler(self.disconnectedCB)
|
||||
#BUG in jabberpy library : if hostname is wrong : "boucle"
|
||||
if self.con.auth(name, password, ressource):
|
||||
self.con.requestRoster()
|
||||
roster = self.con.getRoster().getRaw()
|
||||
if con.auth(name, password, ressource):
|
||||
con.requestRoster()
|
||||
roster = con.getRoster().getRaw()
|
||||
if not roster :
|
||||
roster = {}
|
||||
self.hub.sendPlugin('ROSTER', roster)
|
||||
self.con.sendInitPresence()
|
||||
self.hub.sendPlugin('STATUS', 'online')
|
||||
self.connected = 1
|
||||
self.hub.sendPlugin('ROSTER', account, roster)
|
||||
con.sendInitPresence()
|
||||
self.hub.sendPlugin('STATUS', account, 'online')
|
||||
self.connected[account] = 1
|
||||
else:
|
||||
log.debug("Couldn't authentificate to %s" % hostname)
|
||||
self.hub.sendPlugin('STATUS', 'offline')
|
||||
self.hub.sendPlugin('WARNING', \
|
||||
'Authentification failed, check your login and password')
|
||||
self.hub.sendPlugin('STATUS', account, 'offline')
|
||||
self.hub.sendPlugin('WARNING', None, \
|
||||
'Authentification failed with %s, check your login and password'\
|
||||
% hostname)
|
||||
return 0
|
||||
# END connect
|
||||
|
||||
|
|
@ -218,27 +228,32 @@ class GajimCore:
|
|||
while 1:
|
||||
if not self.hub.queueIn.empty():
|
||||
ev = self.hub.queueIn.get()
|
||||
for con in self.connexions.keys():
|
||||
if ev[1] == self.connexions[con]:
|
||||
break
|
||||
#('QUIT', account, ())
|
||||
if ev[0] == 'QUIT':
|
||||
if self.connected == 1:
|
||||
self.connected = 0
|
||||
self.con.disconnect()
|
||||
self.hub.sendPlugin('QUIT', ())
|
||||
for con in self.connexions.keys():
|
||||
# if self.connected[a] == 1:
|
||||
# self.connected[a] = 0
|
||||
con.disconnect()
|
||||
self.hub.sendPlugin('QUIT', None, ())
|
||||
return
|
||||
#('ASK_CONFIG', (who_ask, section, default_config))
|
||||
#('ASK_CONFIG', account, (who_ask, section, default_config))
|
||||
elif ev[0] == 'ASK_CONFIG':
|
||||
if ev[1][1] == 'accounts':
|
||||
self.hub.sendPlugin('CONFIG', (ev[1][0], self.accounts))
|
||||
if ev[2][1] == 'accounts':
|
||||
self.hub.sendPlugin('CONFIG', None, (ev[2][0], self.accounts))
|
||||
else:
|
||||
if self.cfgParser.tab.has_key(ev[1][1]):
|
||||
self.hub.sendPlugin('CONFIG', (ev[1][0], \
|
||||
self.cfgParser.__getattr__(ev[1][1])))
|
||||
if self.cfgParser.tab.has_key(ev[2][1]):
|
||||
self.hub.sendPlugin('CONFIG', None, (ev[2][0], \
|
||||
self.cfgParser.__getattr__(ev[2][1])))
|
||||
else:
|
||||
self.cfgParser.tab[ev[1][1]] = ev[1][2]
|
||||
self.cfgParser.tab[ev[2][1]] = ev[2][2]
|
||||
self.cfgParser.writeCfgFile()
|
||||
self.hub.sendPlugin('CONFIG', (ev[1][0], ev[1][2]))
|
||||
#('CONFIG', (section, config))
|
||||
self.hub.sendPlugin('CONFIG', None, (ev[2][0], ev[2][2]))
|
||||
#('CONFIG', account, (section, config))
|
||||
elif ev[0] == 'CONFIG':
|
||||
if ev[1][0] == 'accounts':
|
||||
if ev[2][0] == 'accounts':
|
||||
#Remove all old accounts
|
||||
accts = string.split(self.cfgParser.tab\
|
||||
['Profile']['accounts'], ' ')
|
||||
|
|
@ -247,51 +262,51 @@ class GajimCore:
|
|||
for a in accts:
|
||||
del self.cfgParser.tab[a]
|
||||
#Write all new accounts
|
||||
accts = ev[1][1].keys()
|
||||
accts = ev[2][1].keys()
|
||||
self.cfgParser.tab['Profile']['accounts'] = \
|
||||
string.join(accts)
|
||||
for a in accts:
|
||||
self.cfgParser.tab[a] = ev[1][1][a]
|
||||
self.cfgParser.tab[a] = ev[2][1][a]
|
||||
else:
|
||||
self.cfgParser.tab[ev[1][0]] = ev[1][1]
|
||||
self.cfgParser.tab[ev[2][0]] = ev[2][1]
|
||||
self.cfgParser.writeCfgFile()
|
||||
#TODO: tell the changes to other plugins
|
||||
#('STATUS', (status, msg, account))
|
||||
#('STATUS', account, (status, msg))
|
||||
elif ev[0] == 'STATUS':
|
||||
if (ev[1][0] != 'offline') and (self.connected == 0):
|
||||
self.connect(ev[1][2])
|
||||
elif (ev[1][0] == 'offline') and (self.connected == 1):
|
||||
self.connected = 0
|
||||
self.con.disconnect()
|
||||
self.hub.sendPlugin('STATUS', 'offline')
|
||||
if ev[1][0] != 'offline' and self.connected == 1:
|
||||
if (ev[2][0] != 'offline') and (self.connected[ev[1]] == 0):
|
||||
self.connect(ev[1])
|
||||
elif (ev[2][0] == 'offline') and (self.connected[ev[1]] == 1):
|
||||
self.connected[ev[1]] = 0
|
||||
con.disconnect()
|
||||
self.hub.sendPlugin('STATUS', ev[1], 'offline')
|
||||
if ev[2][0] != 'offline' and self.connected[ev[1]] == 1:
|
||||
p = common.jabber.Presence()
|
||||
p.setShow(ev[1][0])
|
||||
p.setStatus(ev[1][1])
|
||||
self.con.send(p)
|
||||
self.hub.sendPlugin('STATUS', ev[1][0])
|
||||
#('MSG', (jid, msg))
|
||||
p.setShow(ev[2][0])
|
||||
p.setStatus(ev[2][1])
|
||||
con.send(p)
|
||||
self.hub.sendPlugin('STATUS', ev[1], ev[2][0])
|
||||
#('MSG', account, (jid, msg))
|
||||
elif ev[0] == 'MSG':
|
||||
msg = common.jabber.Message(ev[1][0], ev[1][1])
|
||||
msg = common.jabber.Message(ev[2][0], ev[2][1])
|
||||
msg.setType('chat')
|
||||
self.con.send(msg)
|
||||
self.hub.sendPlugin('MSGSENT', ev[1])
|
||||
#('SUB', (jid, txt))
|
||||
con.send(msg)
|
||||
self.hub.sendPlugin('MSGSENT', ev[1], ev[2])
|
||||
#('SUB', account, (jid, txt))
|
||||
elif ev[0] == 'SUB':
|
||||
log.debug('subscription request for %s' % ev[1][0])
|
||||
pres = common.jabber.Presence(ev[1][0], 'subscribe')
|
||||
if ev[1][1]:
|
||||
pres.setStatus(ev[1][1])
|
||||
log.debug('subscription request for %s' % ev[2][0])
|
||||
pres = common.jabber.Presence(ev[2][0], 'subscribe')
|
||||
if ev[2][1]:
|
||||
pres.setStatus(ev[2][1])
|
||||
else:
|
||||
pres.setStatus("I would like to add you to my roster.")
|
||||
self.con.send(pres)
|
||||
#('REQ', jid)
|
||||
con.send(pres)
|
||||
#('REQ', account, jid)
|
||||
elif ev[0] == 'AUTH':
|
||||
self.con.send(common.jabber.Presence(ev[1], 'subscribed'))
|
||||
#('DENY', jid)
|
||||
con.send(common.jabber.Presence(ev[2], 'subscribed'))
|
||||
#('DENY', account, jid)
|
||||
elif ev[0] == 'DENY':
|
||||
self.con.send(common.jabber.Presence(ev[1], 'unsubscribed'))
|
||||
#('UNSUB', jid)
|
||||
con.send(common.jabber.Presence(ev[2], 'unsubscribed'))
|
||||
#('UNSUB', accountjid)
|
||||
elif ev[0] == 'UNSUB':
|
||||
if self.cfgParser.Core.has_key('delauth'):
|
||||
delauth = self.cfgParser.Core['delauth']
|
||||
|
|
@ -302,26 +317,29 @@ class GajimCore:
|
|||
else:
|
||||
delroster = 1
|
||||
if delauth:
|
||||
self.con.send(common.jabber.Presence(ev[1], 'unsubscribe'))
|
||||
con.send(common.jabber.Presence(ev[2], 'unsubscribe'))
|
||||
if delroster:
|
||||
self.con.removeRosterItem(ev[1])
|
||||
#('UPDUSER', (jid, name, groups))
|
||||
con.removeRosterItem(ev[2])
|
||||
#('UPDUSER', account, (jid, name, groups))
|
||||
elif ev[0] == 'UPDUSER':
|
||||
self.con.updateRosterItem(jid=ev[1][0], name=ev[1][1], \
|
||||
groups=ev[1][2])
|
||||
con.updateRosterItem(jid=ev[2][0], name=ev[2][1], \
|
||||
groups=ev[2][2])
|
||||
#('REQ_AGENTS', account, ())
|
||||
elif ev[0] == 'REQ_AGENTS':
|
||||
agents = self.con.requestAgents()
|
||||
self.hub.sendPlugin('AGENTS', agents)
|
||||
agents = con.requestAgents()
|
||||
self.hub.sendPlugin('AGENTS', ev[1], agents)
|
||||
#('REQ_AGENT_INFO', account, agent)
|
||||
elif ev[0] == 'REQ_AGENT_INFO':
|
||||
self.con.requestRegInfo(ev[1])
|
||||
agent_info = self.con.getRegInfo()
|
||||
self.hub.sendPlugin('AGENT_INFO', (ev[1], agent_info))
|
||||
con.requestRegInfo(ev[2])
|
||||
agent_info = con.getRegInfo()
|
||||
self.hub.sendPlugin('AGENT_INFO', ev[1], (ev[2], agent_info))
|
||||
#('REG_AGENT', account, infos)
|
||||
elif ev[0] == 'REG_AGENT':
|
||||
self.con.sendRegInfo(ev[1])
|
||||
con.sendRegInfo(ev[2])
|
||||
#('NEW_ACC', (hostname, login, password, name, ressource))
|
||||
elif ev[0] == 'NEW_ACC':
|
||||
c = common.jabber.Client(host = \
|
||||
ev[1][0], debug = False, log = sys.stderr)
|
||||
ev[2][0], debug = False, log = sys.stderr)
|
||||
try:
|
||||
c.connect()
|
||||
except IOError, e:
|
||||
|
|
@ -331,44 +349,46 @@ class GajimCore:
|
|||
log.debug("Connected to server")
|
||||
c.requestRegInfo()
|
||||
req = c.getRegInfo()
|
||||
c.setRegInfo( 'username', ev[1][1])
|
||||
c.setRegInfo( 'password', ev[1][2])
|
||||
c.setRegInfo( 'username', ev[2][1])
|
||||
c.setRegInfo( 'password', ev[2][2])
|
||||
#FIXME: if users already exist, no error message :(
|
||||
if not c.sendRegInfo():
|
||||
print "error " + c.lastErr
|
||||
else:
|
||||
self.hub.sendPlugin('ACC_OK', ev[1])
|
||||
#('ASK_VCARD', jid)
|
||||
self.hub.sendPlugin('ACC_OK', ev[1], ev[2])
|
||||
#('ASK_VCARD', account, jid)
|
||||
elif ev[0] == 'ASK_VCARD':
|
||||
iq = common.jabber.Iq(to=ev[1], type="get")
|
||||
iq = common.jabber.Iq(to=ev[2], type="get")
|
||||
iq._setTag('vCard', common.jabber.NS_VCARD)
|
||||
iq.setID(self.con.getAnID())
|
||||
self.con.send(iq)
|
||||
iq.setID(con.getAnID())
|
||||
con.send(iq)
|
||||
#('VCARD', {entry1: data, entry2: {entry21: data, ...}, ...})
|
||||
elif ev[0] == 'VCARD':
|
||||
iq = common.jabber.Iq(type="set")
|
||||
iq.setID(self.con.getAnID())
|
||||
iq.setID(con.getAnID())
|
||||
iq2 = iq._setTag('vCard', common.jabber.NS_VCARD)
|
||||
for i in ev[1].keys():
|
||||
for i in ev[2].keys():
|
||||
if i != 'jid':
|
||||
if type(ev[1][i]) == type({}):
|
||||
if type(ev[2][i]) == type({}):
|
||||
iq3 = iq2.insertTag(i)
|
||||
for j in ev[1][i].keys():
|
||||
iq3.insertTag(j).putData(ev[1][i][j])
|
||||
for j in ev[2][i].keys():
|
||||
iq3.insertTag(j).putData(ev[2][i][j])
|
||||
else:
|
||||
iq2.insertTag(i).putData(ev[1][i])
|
||||
self.con.send(iq)
|
||||
#('AGENT_LOGGING', (agent, type))
|
||||
iq2.insertTag(i).putData(ev[2][i])
|
||||
con.send(iq)
|
||||
#('AGENT_LOGGING', account, (agent, type))
|
||||
elif ev[0] == 'AGENT_LOGGING':
|
||||
t = ev[1][1];
|
||||
t = ev[2][1];
|
||||
if not t:
|
||||
t='available';
|
||||
p = common.jabber.Presence(to=ev[1][0], type=t)
|
||||
self.con.send(p)
|
||||
p = common.jabber.Presence(to=ev[2][0], type=t)
|
||||
con.send(p)
|
||||
else:
|
||||
log.debug("Unknown Command %s" % ev[0])
|
||||
elif self.connected == 1:
|
||||
self.con.process(1)
|
||||
else:
|
||||
for con in self.connexions:
|
||||
if self.connected[self.connexions[con]] == 1:
|
||||
con.process(1)
|
||||
time.sleep(0.1)
|
||||
# END main
|
||||
# END GajimCore
|
||||
|
|
@ -403,21 +423,16 @@ def start():
|
|||
"""Start the Core"""
|
||||
gc = GajimCore()
|
||||
loadPlugins(gc)
|
||||
################ pr des tests ###########
|
||||
# gc.hub.sendPlugin('NOTIFY', ('aste@lagaule.org', 'online', 'online', 'oleron'))
|
||||
# gc.hub.sendPlugin('MSG', ('ate@lagaule.org', 'msg'))
|
||||
#########################################
|
||||
try:
|
||||
gc.mainLoop()
|
||||
except KeyboardInterrupt:
|
||||
print "Keyboard Interrupt : Bye!"
|
||||
if gc.connected:
|
||||
gc.con.disconnect()
|
||||
gc.hub.sendPlugin('QUIT', ())
|
||||
for con in gc.connexions:
|
||||
if gc.connected[gc.connexions[con]]:
|
||||
con.disconnect()
|
||||
gc.hub.sendPlugin('QUIT', None, ())
|
||||
return 0
|
||||
# except:
|
||||
# print "Erreur survenue"
|
||||
# if gc.connected:
|
||||
# gc.con.disconnect()
|
||||
# gc.hub.sendPlugin('QUIT', ())
|
||||
# END start
|
||||
|
|
|
|||
|
|
@ -1058,13 +1058,14 @@ class roster_Window:
|
|||
def add_user_to_roster(self, user, account):
|
||||
"""Add a user to the roster and add groups if they aren't in roster"""
|
||||
newgrp = 0
|
||||
showOffline = self.plugin.config['showoffline']
|
||||
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 self.showOffline or 'Agents' in user.groups:
|
||||
if user.show != 'offline' or showOffline or 'Agents' in user.groups:
|
||||
model = self.tree.get_model()
|
||||
for g in user.groups:
|
||||
if not self.groups[account].has_key(g):
|
||||
|
|
@ -1096,7 +1097,7 @@ class roster_Window:
|
|||
def draw_roster(self):
|
||||
"""Clear and draw roster"""
|
||||
self.tree.get_model().clear()
|
||||
for acct in self.contacts.keys()
|
||||
for acct in self.contacts.keys():
|
||||
self.add_account_to_roster(acct)
|
||||
for user in self.contacts[acct]:
|
||||
self.add_user_to_roster(user, acct)
|
||||
|
|
@ -1138,40 +1139,39 @@ class roster_Window:
|
|||
|
||||
def chg_user_status(self, user, show, status, account):
|
||||
"""When a user change his status"""
|
||||
if self.l_contact[user.jid]['iter'] == []:
|
||||
iters = self.get_user_iter(user.jid, account)
|
||||
showOffline = self.plugin.config['showoffline']
|
||||
if not iters:
|
||||
self.add_user(user)
|
||||
else:
|
||||
model = self.tree.get_model()
|
||||
if show == 'offline' and not self.showOffline:
|
||||
if show == 'offline' and not showOffline:
|
||||
self.remove_user(user)
|
||||
else:
|
||||
for i in self.l_contact[user.jid]['iter']:
|
||||
for i in iters:
|
||||
if self.pixbufs.has_key(show):
|
||||
model.set_value(i, 0, self.pixbufs[show])
|
||||
#update icon in chat window
|
||||
if self.tab_messages.has_key(user.jid):
|
||||
self.tab_messages[user.jid].img.set_from_pixbuf(self.pixbufs[show])
|
||||
u.show = show
|
||||
u.status = status
|
||||
user.show = show
|
||||
user.status = status
|
||||
#Print status in chat window
|
||||
if self.plugin.windows.has_key("%s_%s" % (user.jid, account)):
|
||||
self.windows["%s_%s" % (user.jid, account)].print_conversation(\
|
||||
if self.plugin.windows[account].has_key(user.jid):
|
||||
self.plugin.windows[account][user.jid].img.set_from_pixbuf(self.pixbufs[show])
|
||||
self.plugin.windows[account][user.jid].print_conversation(\
|
||||
"%s is now %s (%s)" % (user.name, show, status), 'status')
|
||||
|
||||
def on_info(self, widget, jid):
|
||||
def on_info(self, widget, user, account):
|
||||
"""Call infoUser_Window class to display user's information"""
|
||||
jid = self.l_contact[jid]['user'].jid
|
||||
if not self.tab_vcard.has_key(jid):
|
||||
self.tab_vcard[jid] = infoUser_Window(self.l_contact[jid]['user'], self)
|
||||
if not self.plugin.windows[account].has_key('infos'+user.jid):
|
||||
self.plugin.windows[account]['infos'+user.jid] = infoUser_Window(user, self.plugin)
|
||||
|
||||
def on_agent_logging(self, widget, jid, type):
|
||||
def on_agent_logging(self, widget, jid, state, account):
|
||||
"""When an agent is requested to log in or off"""
|
||||
self.queueOUT.put(('AGENT_LOGGING', (jid, type)))
|
||||
self.plugin.send('AGENT_LOGGING', account, (jid, state))
|
||||
|
||||
def mk_menu_c(self, event, iter):
|
||||
def mk_menu_user(self, event, iter):
|
||||
"""Make user's popup menu"""
|
||||
model = self.tree.get_model()
|
||||
jid = model.get_value(iter, 2)
|
||||
jid = model.get_value(iter, 3)
|
||||
path = model.get_path(iter)
|
||||
menu = gtk.Menu()
|
||||
item = gtk.MenuItem("Start chat")
|
||||
|
|
@ -1225,16 +1225,16 @@ class roster_Window:
|
|||
def mk_menu_agent(self, event, iter):
|
||||
"""Make agent's popup menu"""
|
||||
model = self.tree.get_model()
|
||||
jid = model.get_value(iter, 1)
|
||||
jid = model.get_value(iter, 3)
|
||||
menu = gtk.Menu()
|
||||
item = gtk.MenuItem("Log on")
|
||||
if self.l_contact[jid]['user'].show != 'offline':
|
||||
if self.contacts[jid].show != 'offline':
|
||||
item.set_sensitive(FALSE)
|
||||
menu.append(item)
|
||||
item.connect("activate", self.on_agent_logging, jid, 'available')
|
||||
|
||||
item = gtk.MenuItem("Log off")
|
||||
if self.l_contact[jid]['user'].show == 'offline':
|
||||
if self.contacts[jid].show == 'offline':
|
||||
item.set_sensitive(FALSE)
|
||||
menu.append(item)
|
||||
item.connect("activate", self.on_agent_logging, jid, 'unavailable')
|
||||
|
|
@ -1242,26 +1242,18 @@ class roster_Window:
|
|||
menu.popup(None, None, None, event.button, event.time)
|
||||
menu.show_all()
|
||||
|
||||
def authorize(self, widget, jid):
|
||||
def authorize(self, widget, jid, account):
|
||||
"""Authorize a user"""
|
||||
self.queueOUT.put(('AUTH', jid))
|
||||
self.plugin.send('AUTH', account, jid)
|
||||
|
||||
def req_sub(self, widget, jid, txt):
|
||||
def req_sub(self, widget, jid, txt, account):
|
||||
"""Request subscription to a user"""
|
||||
self.queueOUT.put(('SUB', (jid, txt)))
|
||||
if not self.l_contact.has_key(jid):
|
||||
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(user1)
|
||||
|
||||
def init_tree(self):
|
||||
"""initialize treeview, l_contact and l_group"""
|
||||
self.tree.get_model().clear()
|
||||
#l_contact = {jid:{'user':_, 'iter':[iter1, ...]]
|
||||
self.l_contact = {}
|
||||
#l_group = {name:{'iter':_, 'hide':Bool}
|
||||
self.l_group = {}
|
||||
|
||||
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):
|
||||
|
|
@ -1272,16 +1264,16 @@ class roster_Window:
|
|||
return
|
||||
model = self.tree.get_model()
|
||||
iter = model.get_iter(path)
|
||||
data = model.get_value(iter, 2)
|
||||
type = model.get_value(iter, 2)
|
||||
if data == 'group':
|
||||
self.mk_menu_g(event)
|
||||
elif data == 'agent':
|
||||
self.mk_menu_agent(event, iter)
|
||||
else:
|
||||
self.mk_menu_c(event, iter)
|
||||
elif data == 'user':
|
||||
self.mk_menu_user(event, iter)
|
||||
return gtk.TRUE
|
||||
return gtk.FALSE
|
||||
|
||||
|
||||
def on_req_usub(self, widget, iter):
|
||||
"""Remove a user"""
|
||||
window_confirm = confirm_Window(self, iter)
|
||||
|
|
@ -1296,12 +1288,15 @@ class roster_Window:
|
|||
txt = w.run()
|
||||
else:
|
||||
txt = status
|
||||
if len(self.plugin.accounts) > 0:
|
||||
self.queueOUT.put(('STATUS', None, (status, txt)))
|
||||
else:
|
||||
accounts = self.plugin.accts.get_accounts()
|
||||
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 on_status_changed(self, account, status):
|
||||
"""the core tells us that our status has changed"""
|
||||
optionmenu = self.xml.get_widget('optionmenu')
|
||||
for i in range(7):
|
||||
if optionmenu.get_menu().get_children()[i].name == status:
|
||||
|
|
@ -1310,64 +1305,63 @@ class roster_Window:
|
|||
if status == 'offline':
|
||||
self.plugin.connected[account] = 0
|
||||
self.plugin.sleeper = None
|
||||
for jid in self.l_contact.keys():
|
||||
user = self.l_contact[jid]['user']
|
||||
#TODO: give account to chg_status
|
||||
self.chg_status(user, 'offline', 'Disconnected', 'account')
|
||||
elif self.plugin.connected[ev[1]] == 0:
|
||||
self.plugin.connected[ev[1]] = 1
|
||||
for jid in self.contacts.keys():
|
||||
user = self.contacts[jid]
|
||||
self.chg_user_status(user, 'offline', 'Disconnected', account)
|
||||
elif self.plugin.connected[account] == 0:
|
||||
self.plugin.connected[account] = 1
|
||||
self.plugin.sleeper = None#common.sleepy.Sleepy(\
|
||||
#self.autoawaytime*60, self.autoxatime*60)
|
||||
|
||||
def on_message(self, jid, msg, account):
|
||||
"""when we receive a message"""
|
||||
if not self.l_contact.has_key(jid):
|
||||
if not self.contacts.has_key(jid):
|
||||
user1 = user(jid, jid, ['not in list'], \
|
||||
'not in list', 'not in list', 'none', '')
|
||||
self.add_user(user1)
|
||||
autopopup = self.plugin.config['autopopup']
|
||||
if autopopup == 0 and not self.tab_messages.has_key(jid):
|
||||
if autopopup == 0 and not self.plugin.windows[account].has_key(jid):
|
||||
#We save it in a queue
|
||||
if not self.tab_queues.has_key(jid):
|
||||
if not self.plugin.queues[account].has_key(jid):
|
||||
model = self.tree.get_model()
|
||||
self.tab_queues[jid] = Queue.Queue(50)
|
||||
for i in self.l_contact[jid]['iter']:
|
||||
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.tab_queues[jid].put((msg, tim))
|
||||
self.plugin.queues[account][jid].put((msg, tim))
|
||||
else:
|
||||
if not self.tab_messages.has_key(jid):
|
||||
if self.l_contact.has_key(jid):
|
||||
self.tab_messages[jid] = \
|
||||
message_Window(self.l_contact[jid]['user'], self)
|
||||
self.tab_messages[jid].print_conversation(msg)
|
||||
if not self.plugin.windows[account].has_key(jid):
|
||||
self.plugin.windows[account][jid] = \
|
||||
message_Window(self.contacts[account][jid], self)
|
||||
self.plugin.windows[account][jid].print_conversation(msg)
|
||||
|
||||
def on_prefs(self, widget):
|
||||
"""When preferences is selected :
|
||||
call the preference_Window class"""
|
||||
window = preference_Window(self)
|
||||
if not self.plugin.windows.has_key('preferences'):
|
||||
self.plugin.windows['preferences'] = preference_Window(self)
|
||||
|
||||
def on_add(self, widget):
|
||||
"""When add user is selected :
|
||||
call the add class"""
|
||||
window_add = addContact_Window(self)
|
||||
addContact_Window(self)
|
||||
|
||||
def on_about(self, widget):
|
||||
"""When about is selected :
|
||||
call the about class"""
|
||||
window_about = about_Window()
|
||||
if not self.plugin.windows.has_key('about'):
|
||||
self.plugin.windows['about'] = about_Window()
|
||||
|
||||
def on_accounts(self, widget):
|
||||
"""When accounts is seleted :
|
||||
call the accounts class to modify accounts"""
|
||||
global accountsWindow
|
||||
if not accountsWindow:
|
||||
accountsWindow = accounts_Window(self)
|
||||
if not self.plugin.windows.has_key('accounts'):
|
||||
self.plugin.windows['accounts'] = accounts_Window(self)
|
||||
|
||||
def on_quit(self, widget):
|
||||
"""When we quit the gtk plugin :
|
||||
tell that to the core and exit gtk"""
|
||||
self.queueOUT.put(('QUIT',''))
|
||||
self.plugin.send('QUIT', None, '')
|
||||
print "plugin gtkgui stopped"
|
||||
gtk.mainquit()
|
||||
|
||||
|
|
@ -1375,20 +1369,25 @@ class roster_Window:
|
|||
"""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)
|
||||
jid = model.get_value(iter, 2)
|
||||
if (jid == 'group'):
|
||||
type = model.get_value(iter, 2)
|
||||
jid = model.get_value(iter, 3)
|
||||
if (type == 'group'):
|
||||
if (self.tree.row_expanded(path)):
|
||||
self.tree.collapse_row(path)
|
||||
else:
|
||||
self.tree.expand_row(path, FALSE)
|
||||
else:
|
||||
if self.tab_messages.has_key(jid):
|
||||
self.tab_messages[jid].window.present()
|
||||
elif self.l_contact.has_key(jid):
|
||||
self.tab_messages[jid] = message_Window(self.l_contact[jid]['user'], self)
|
||||
if self.tab_queues.has_key(jid):
|
||||
self.tab_messages[jid].read_queue(self.tab_queues[jid])
|
||||
if self.plugin.windows[account].has_key(jid):
|
||||
self.plugin.windows[account][jid].window.present()
|
||||
elif self.contacts[account].has_key(jid):
|
||||
self.plugin.windows[account][jid] = \
|
||||
message_Window(self.contacts[account][jid], self)
|
||||
if self.plugin.queues[account].has_key(jid):
|
||||
self.plugin.windows[account][jid].read_queue(\
|
||||
self.plugin.queues[account][jid])
|
||||
|
||||
def on_row_expanded(self, widget, iter, path):
|
||||
"""When a row is expanded :
|
||||
|
|
@ -1425,13 +1424,15 @@ class roster_Window:
|
|||
def on_browse(self, widget):
|
||||
"""When browse agent is selected :
|
||||
Call browse class"""
|
||||
global browserWindow
|
||||
if not browserWindow:
|
||||
browserWindow = browseAgent_Window(self)
|
||||
if not self.plugin.windows.has_key('browser'):
|
||||
self.plugin.windows['browser'] = browseAgent_Window(self)
|
||||
|
||||
def mkpixbufs(self):
|
||||
"""initialise pixbufs array"""
|
||||
self.path = 'plugins/gtkgui/icons/' + self.iconstyle + '/'
|
||||
iconstyle = self.plugin.config['iconstyle']
|
||||
if not iconstyle:
|
||||
iconstyle = 'sun'
|
||||
self.path = 'plugins/gtkgui/icons/' + iconstyle + '/'
|
||||
self.pixbufs = {}
|
||||
for state in ('online', 'away', 'xa', 'dnd', 'offline', \
|
||||
'requested', 'message', 'opened', 'closed', 'not in list'):
|
||||
|
|
@ -1454,24 +1455,23 @@ class roster_Window:
|
|||
def on_show_off(self, widget):
|
||||
"""when show offline option is changed :
|
||||
redraw the treeview"""
|
||||
self.showOffline = 1 - self.showOffline
|
||||
self.plugin.config['showoffline'] = 1 - self.plugin.config['showoffline']
|
||||
self.redraw_roster()
|
||||
|
||||
def __init__(self, plugin):
|
||||
# FIXME : handle no file ...
|
||||
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'Gajim')
|
||||
self.window = self.xml.get_widget('Gajim')
|
||||
self.tree = self.xml.get_widget('treeview')
|
||||
self.plugin = plugin
|
||||
self.connected = 0
|
||||
self.connected = {}
|
||||
self.contacts = {}
|
||||
for a in self.plugin.accounts.keys():
|
||||
self.contacts[a] = {}
|
||||
self.connected[a] = 0
|
||||
#(icon, name, type, jid, editable)
|
||||
model = gtk.TreeStore(gtk.gdk.Pixbuf, str, str, str, \
|
||||
gobject.TYPE_BOOLEAN)
|
||||
self.tree.set_model(model)
|
||||
self.init_tree()
|
||||
self.iconstyle = self.plugin.config['iconstyle']
|
||||
if not self.iconstyle:
|
||||
self.iconstyle = 'sun'
|
||||
self.mkpixbufs()
|
||||
# map = self.tree.get_colormap()
|
||||
# colour = map.alloc_color("red") # light red
|
||||
|
|
@ -1491,19 +1491,9 @@ class roster_Window:
|
|||
# print self.tree.get_property('expander-column')
|
||||
# self.tree.set_style(st)
|
||||
self.xml.get_widget('optionmenu').set_history(6)
|
||||
self.tab_messages = {}
|
||||
self.tab_queues = {}
|
||||
self.tab_vcard = {}
|
||||
|
||||
if self.plugin.config.has_key('showoffline'):
|
||||
self.showOffline = self.plugin.config['showoffline']
|
||||
else:
|
||||
self.showOffline = 0
|
||||
|
||||
xml.get_widget('show_offline').set_active(self.showOffline)
|
||||
|
||||
self.grpbgcolor = 'gray50'
|
||||
self.userbgcolor = 'white'
|
||||
showOffline = self.plugin.config['showoffline']
|
||||
self.xml.get_widget('show_offline').set_active(showOffline)
|
||||
|
||||
#columns
|
||||
col = gtk.TreeViewColumn()
|
||||
|
|
@ -1524,20 +1514,20 @@ class roster_Window:
|
|||
self.tree.set_expander_column(col)
|
||||
|
||||
#signals
|
||||
xml.signal_connect('gtk_main_quit', self.on_quit)
|
||||
xml.signal_connect('on_preferences_activate', self.on_prefs)
|
||||
xml.signal_connect('on_accounts_activate', self.on_accounts)
|
||||
xml.signal_connect('on_browse_agents_activate', self.on_browse)
|
||||
xml.signal_connect('on_add_activate', self.on_add)
|
||||
xml.signal_connect('on_show_offline_activate', self.on_show_off)
|
||||
xml.signal_connect('on_about_activate', self.on_about)
|
||||
xml.signal_connect('on_quit_activate', self.on_quit)
|
||||
xml.signal_connect('on_treeview_event', self.on_treeview_event)
|
||||
xml.signal_connect('on_status_changed', self.on_status_changed)
|
||||
xml.signal_connect('on_optionmenu_changed', self.on_optionmenu_changed)
|
||||
xml.signal_connect('on_row_activated', self.on_row_activated)
|
||||
xml.signal_connect('on_row_expanded', self.on_row_expanded)
|
||||
xml.signal_connect('on_row_collapsed', self.on_row_collapsed)
|
||||
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_browse_agents_activate', self.on_browse)
|
||||
self.xml.signal_connect('on_add_activate', self.on_add)
|
||||
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)
|
||||
self.xml.signal_connect('on_optionmenu_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)
|
||||
|
||||
class plugin:
|
||||
"""Class called by the core in a new thread"""
|
||||
|
|
@ -1667,8 +1657,8 @@ class plugin:
|
|||
#TODO: change icon
|
||||
#('AGENTS', account, agents)
|
||||
elif ev[0] == 'AGENTS':
|
||||
if self.windows.has_key('browser'):
|
||||
self.windows['browser'].agents(ev[2])
|
||||
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'):
|
||||
|
|
@ -1679,8 +1669,8 @@ class plugin:
|
|||
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)))
|
||||
if self.windiws.has_key('accounts'):
|
||||
self.send('CONFIG', None, ('accounts', self.accounts))
|
||||
if self.windows.has_key('accounts'):
|
||||
self.windows['accounts'].init_accounts()
|
||||
elif ev[0] == 'QUIT':
|
||||
self.roster.on_quit(self)
|
||||
|
|
@ -1717,7 +1707,6 @@ class plugin:
|
|||
gtk.threads_enter()
|
||||
self.queueIN = quIN
|
||||
self.queueOUT = quOUT
|
||||
self.windows = {}
|
||||
self.send('ASK_CONFIG', None, ('GtkGui', 'GtkGui', {'autopopup':1,\
|
||||
'showoffline':0,\
|
||||
'autoaway':0,\
|
||||
|
|
@ -1731,6 +1720,11 @@ class plugin:
|
|||
self.config = self.wait('CONFIG')
|
||||
self.send('ASK_CONFIG', None, ('GtkGui', 'accounts'))
|
||||
self.accounts = self.wait('CONFIG')
|
||||
self.windows = {}
|
||||
self.queues = {}
|
||||
for a in self.accounts.keys():
|
||||
self.windows[a] = {}
|
||||
self.queues[a] = {}
|
||||
self.roster = roster_Window(self)
|
||||
# if self.config.has_key('autoaway'):
|
||||
# self.autoaway = self.config['autoaway']
|
||||
|
|
|
|||
Loading…
Reference in New Issue