736 lines
26 KiB
Python
736 lines
26 KiB
Python
#!/usr/bin/env python
|
|
## plugins/config.py
|
|
##
|
|
## Gajim Team:
|
|
## - Yann Le Boulanger <asterix@crans.org>
|
|
## - Vincent Hanquez <tab@snarc.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
|
|
import common.sleepy
|
|
from common import i18n
|
|
_ = i18n._
|
|
APP = i18n.APP
|
|
gtk.glade.bindtextdomain (APP, i18n.DIR)
|
|
gtk.glade.textdomain (APP)
|
|
|
|
from dialogs import *
|
|
import gtkgui
|
|
|
|
GTKGUI_GLADE='plugins/gtkgui/gtkgui.glade'
|
|
|
|
|
|
class vCard_Window:
|
|
"""Class for window that show vCard information"""
|
|
def delete_event(self, widget=None):
|
|
"""close window"""
|
|
del self.plugin.windows[self.account]['infos'][self.jid]
|
|
|
|
def on_close(self, widget):
|
|
"""When Close button is clicked"""
|
|
widget.get_toplevel().destroy()
|
|
|
|
def set_value(self, entry_name, value):
|
|
try:
|
|
self.xml.get_widget(entry_name).set_text(value)
|
|
except AttributeError, e:
|
|
pass
|
|
|
|
def set_values(self, vcard):
|
|
for i in vcard.keys():
|
|
if type(vcard[i]) == type({}):
|
|
for j in vcard[i].keys():
|
|
self.set_value('entry_'+i+'_'+j, vcard[i][j])
|
|
else:
|
|
if i == 'DESC':
|
|
self.xml.get_widget('textview_DESC').get_buffer().\
|
|
set_text(vcard[i], 0)
|
|
else:
|
|
self.set_value('entry_'+i, vcard[i])
|
|
|
|
def add_to_vcard(self, vcard, entry, txt):
|
|
"""Add an information to the vCard dictionary"""
|
|
entries = string.split(entry, '_')
|
|
loc = vcard
|
|
while len(entries) > 1:
|
|
if not loc.has_key(entries[0]):
|
|
loc[entries[0]] = {}
|
|
loc = loc[entries[0]]
|
|
del entries[0]
|
|
loc[entries[0]] = txt
|
|
return vcard
|
|
|
|
def make_vcard(self):
|
|
"""make the vCard dictionary"""
|
|
entries = ['FN', 'NICKNAME', 'BDAY', 'EMAIL_USERID', 'URL', 'TEL_NUMBER',\
|
|
'ADR_STREET', 'ADR_EXTADR', 'ADR_LOCALITY', 'ADR_REGION', 'ADR_PCODE',\
|
|
'ADR_CTRY', 'ORG_ORGNAME', 'ORG_ORGUNIT', 'TITLE', 'ROLE']
|
|
vcard = {}
|
|
for e in entries:
|
|
txt = self.xml.get_widget('entry_'+e).get_text()
|
|
if txt != '':
|
|
vcard = self.add_to_vcard(vcard, e, txt)
|
|
buf = self.xml.get_widget('textview_DESC').get_buffer()
|
|
start_iter = buf.get_start_iter()
|
|
end_iter = buf.get_end_iter()
|
|
txt = buf.get_text(start_iter, end_iter, 0)
|
|
if txt != '':
|
|
vcard['DESC']= txt
|
|
return vcard
|
|
|
|
|
|
def on_retrieve(self, widget):
|
|
if self.plugin.connected[self.account]:
|
|
self.plugin.send('ASK_VCARD', self.account, self.jid)
|
|
else:
|
|
warning_Window(_("You must be connected to get your informations"))
|
|
|
|
def on_publish(self, widget):
|
|
if not self.plugin.connected[self.account]:
|
|
warning_Window(_("You must be connected to publish your informations"))
|
|
return
|
|
vcard = self.make_vcard()
|
|
nick = ''
|
|
if vcard.has_key('NICKNAME'):
|
|
nick = vcard['NICKNAME']
|
|
if nick == '':
|
|
nick = self.plugin.accounts[self.account]['name']
|
|
self.plugin.nicks[self.account] = nick
|
|
self.plugin.send('VCARD', self.account, vcard)
|
|
|
|
def __init__(self, jid, plugin, account):
|
|
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'vcard', APP)
|
|
self.jid = jid
|
|
self.plugin = plugin
|
|
self.account = account
|
|
|
|
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_retrieve_clicked', self.on_retrieve)
|
|
self.xml.signal_connect('on_publish_clicked', self.on_publish)
|
|
|
|
|
|
class preference_Window:
|
|
"""Class for Preferences window"""
|
|
def delete_event(self, widget):
|
|
"""close window"""
|
|
del self.plugin.windows['preferences']
|
|
|
|
def on_cancel(self, widget):
|
|
"""When Cancel button is clicked"""
|
|
widget.get_toplevel().destroy()
|
|
|
|
def on_color_button_clicked(self, widget):
|
|
"""Open a ColorSelectionDialog and change button's color"""
|
|
if widget.name == 'colorIn':
|
|
color = self.colorIn
|
|
da = self.da_in
|
|
elif widget.name == 'colorOut':
|
|
color = self.colorOut
|
|
da = self.da_out
|
|
elif widget.name == 'colorStatus':
|
|
color = self.colorStatus
|
|
da = self.da_status
|
|
colorseldlg = gtk.ColorSelectionDialog('Select Color')
|
|
colorsel = colorseldlg.colorsel
|
|
colorsel.set_previous_color(color)
|
|
colorsel.set_current_color(color)
|
|
colorsel.set_has_palette(gtk.TRUE)
|
|
response = colorseldlg.run()
|
|
if response == gtk.RESPONSE_OK:
|
|
color = colorsel.get_current_color()
|
|
da.modify_bg(gtk.STATE_NORMAL, color)
|
|
if widget.name == 'colorIn':
|
|
self.colorIn = color
|
|
elif widget.name == 'colorOut':
|
|
self.colorOut = color
|
|
elif widget.name == 'colorStatus':
|
|
self.colorStatus = color
|
|
colorseldlg.destroy()
|
|
|
|
def write_cfg(self):
|
|
"""Save preferences in config File and apply them"""
|
|
#Color for incomming messages
|
|
colSt_in = '#'+(hex(self.colorIn.red)+'0')[2:4]\
|
|
+(hex(self.colorIn.green)+'0')[2:4]\
|
|
+(hex(self.colorIn.blue)+'0')[2:4]
|
|
self.plugin.config['inmsgcolor'] = colSt_in
|
|
#Color for outgoing messages
|
|
colSt_out = '#'+(hex(self.colorOut.red)+'0')[2:4]\
|
|
+(hex(self.colorOut.green)+'0')[2:4]\
|
|
+(hex(self.colorOut.blue)+'0')[2:4]
|
|
self.plugin.config['outmsgcolor'] = colSt_out
|
|
#Color for status messages
|
|
colSt_status = '#'+(hex(self.colorStatus.red)+'0')[2:4]\
|
|
+(hex(self.colorStatus.green)+'0')[2:4]\
|
|
+(hex(self.colorStatus.blue)+'0')[2:4]
|
|
self.plugin.config['statusmsgcolor'] = colSt_status
|
|
#update opened chat windows
|
|
for a in self.plugin.accounts.keys():
|
|
for w in self.plugin.windows[a]['chats'].keys():
|
|
self.plugin.windows[a]['chats'][w].tagIn.\
|
|
set_property("foreground", colSt_in)
|
|
self.plugin.windows[a]['chats'][w].tagOut.\
|
|
set_property("foreground", colSt_out)
|
|
self.plugin.windows[a]['chats'][w].tagStatus.\
|
|
set_property("foreground", colSt_status)
|
|
#IconStyle
|
|
ist = self.combo_iconstyle.entry.get_text()
|
|
self.plugin.config['iconstyle'] = ist
|
|
self.plugin.roster.mkpixbufs()
|
|
#autopopup
|
|
pp = self.chk_autopp.get_active()
|
|
if pp == True:
|
|
self.plugin.config['autopopup'] = 1
|
|
else:
|
|
self.plugin.config['autopopup'] = 0
|
|
#autopopupaway
|
|
ppaway = self.chk_autoppaway.get_active()
|
|
if ppaway == True:
|
|
self.plugin.config['autopopupaway'] = 1
|
|
else:
|
|
self.plugin.config['autopopupaway'] = 0
|
|
#autoaway
|
|
aw = self.chk_autoaway.get_active()
|
|
if aw == True:
|
|
self.plugin.config['autoaway'] = 1
|
|
else:
|
|
self.plugin.config['autoaway'] = 0
|
|
aat = self.spin_autoawaytime.get_value_as_int()
|
|
self.plugin.config['autoawaytime'] = aat
|
|
#autoxa
|
|
xa = self.chk_autoxa.get_active()
|
|
if xa == True:
|
|
self.plugin.config['autoxa'] = 1
|
|
else:
|
|
self.plugin.config['autoxa'] = 0
|
|
axt = self.spin_autoxatime.get_value_as_int()
|
|
self.plugin.config['autoxatime'] = axt
|
|
if aw or xa:
|
|
self.plugin.sleeper = common.sleepy.Sleepy(\
|
|
self.plugin.config['autoawaytime']*60, \
|
|
self.plugin.config['autoxatime']*60)
|
|
#trayicon
|
|
trayicon = self.chk_trayicon.get_active()
|
|
if trayicon:
|
|
self.plugin.config['trayicon'] = 1
|
|
else:
|
|
self.plugin.config['trayicon'] = 0
|
|
self.plugin.send('CONFIG', None, ('GtkGui', self.plugin.config))
|
|
self.plugin.roster.draw_roster()
|
|
|
|
def on_ok(self, widget):
|
|
"""When Ok button is clicked"""
|
|
self.write_cfg()
|
|
self.xml.get_widget('Preferences').destroy()
|
|
|
|
def change_notebook_page(self, number):
|
|
self.notebook.set_current_page(number)
|
|
|
|
def on_lookfeel_button_clicked(self, widget, data=None):
|
|
self.change_notebook_page(0)
|
|
|
|
def on_events_button_clicked(self, widget, data=None):
|
|
self.change_notebook_page(1)
|
|
|
|
def on_presence_button_clicked(self, widget, data=None):
|
|
self.change_notebook_page(2)
|
|
|
|
def __init__(self, plugin):
|
|
"""Initialize Preference window"""
|
|
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'Preferences', APP)
|
|
self.plugin = plugin
|
|
self.da_in = self.xml.get_widget('drawing_in')
|
|
self.da_out = self.xml.get_widget('drawing_out')
|
|
self.da_status = self.xml.get_widget('drawing_status')
|
|
self.combo_iconstyle = self.xml.get_widget('combo_iconstyle')
|
|
self.chk_autopp = self.xml.get_widget('chk_autopopup')
|
|
self.chk_autoppaway = self.xml.get_widget('chk_autopopupaway')
|
|
self.chk_autoaway = self.xml.get_widget('chk_autoaway')
|
|
self.spin_autoawaytime = self.xml.get_widget('spin_autoawaytime')
|
|
self.chk_autoxa = self.xml.get_widget('chk_autoxa')
|
|
self.spin_autoxatime = self.xml.get_widget('spin_autoxatime')
|
|
self.chk_trayicon = self.xml.get_widget('chk_trayicon')
|
|
self.notebook = self.xml.get_widget('preferences_notebook')
|
|
|
|
button = self.xml.get_widget('lookfeel_button')
|
|
button.connect('clicked', self.on_lookfeel_button_clicked)
|
|
button = self.xml.get_widget('events_button')
|
|
button.connect('clicked', self.on_events_button_clicked)
|
|
button = self.xml.get_widget('presence_button')
|
|
button.connect('clicked', self.on_presence_button_clicked)
|
|
|
|
#Color for incomming messages
|
|
colSt = self.plugin.config['inmsgcolor']
|
|
cmapIn = self.da_in.get_colormap()
|
|
self.colorIn = cmapIn.alloc_color(colSt)
|
|
self.da_in.window.set_background(self.colorIn)
|
|
|
|
#Color for outgoing messages
|
|
colSt = self.plugin.config['outmsgcolor']
|
|
cmapOut = self.da_out.get_colormap()
|
|
self.colorOut = cmapOut.alloc_color(colSt)
|
|
self.da_out.window.set_background(self.colorOut)
|
|
|
|
#Color for status messages
|
|
colSt = self.plugin.config['statusmsgcolor']
|
|
cmapStatus = self.da_status.get_colormap()
|
|
self.colorStatus = cmapStatus.alloc_color(colSt)
|
|
self.da_status.window.set_background(self.colorStatus)
|
|
|
|
#iconStyle
|
|
list_style = os.listdir('plugins/gtkgui/icons/')
|
|
l = []
|
|
for i in list_style:
|
|
if i != 'CVS' and i[0] != '.':
|
|
l.append(i)
|
|
if l.count == 0:
|
|
l.append(" ")
|
|
self.combo_iconstyle.set_popdown_strings(l)
|
|
if self.plugin.config['iconstyle'] in l:
|
|
self.combo_iconstyle.entry.set_text(self.plugin.config['iconstyle'])
|
|
|
|
#Autopopup
|
|
st = self.plugin.config['autopopup']
|
|
self.chk_autopp.set_active(st)
|
|
|
|
#Autopopupaway
|
|
st = self.plugin.config['autopopupaway']
|
|
self.chk_autoppaway.set_active(st)
|
|
|
|
#Autoaway
|
|
st = self.plugin.config['autoaway']
|
|
self.chk_autoaway.set_active(st)
|
|
|
|
#Autoawaytime
|
|
st = self.plugin.config['autoawaytime']
|
|
self.spin_autoawaytime.set_value(st)
|
|
|
|
#Autoxa
|
|
st = self.plugin.config['autoxa']
|
|
self.chk_autoxa.set_active(st)
|
|
|
|
#Autoxatime
|
|
st = self.plugin.config['autoxatime']
|
|
self.spin_autoxatime.set_value(st)
|
|
|
|
#trayicon
|
|
st = self.plugin.config['trayicon']
|
|
self.chk_trayicon.set_active(st)
|
|
|
|
self.xml.signal_connect('gtk_widget_destroy', self.delete_event)
|
|
self.xml.signal_connect('on_but_col_clicked', \
|
|
self.on_color_button_clicked)
|
|
self.xml.signal_connect('on_ok_clicked', self.on_ok)
|
|
self.xml.signal_connect('on_cancel_clicked', self.on_cancel)
|
|
|
|
|
|
class accountPreference_Window:
|
|
"""Class for account informations"""
|
|
def delete_event(self, widget):
|
|
"""close window"""
|
|
del self.plugin.windows['accountPreference']
|
|
|
|
def on_close(self, widget):
|
|
"""When Close button is clicked"""
|
|
widget.get_toplevel().destroy()
|
|
|
|
def destroy(self):
|
|
self.xml.get_widget("Account").destroy()
|
|
|
|
def init_account(self, infos):
|
|
"""Initialize window with defaults values"""
|
|
if infos.has_key('name'):
|
|
self.xml.get_widget("entry_name").set_text(infos['name'])
|
|
if infos.has_key('jid'):
|
|
self.xml.get_widget("entry_jid").set_text(infos['jid'])
|
|
if infos.has_key('password'):
|
|
self.xml.get_widget("entry_password").set_text(infos['password'])
|
|
if infos.has_key('ressource'):
|
|
self.xml.get_widget("entry_ressource").set_text(infos['ressource'])
|
|
if infos.has_key('priority'):
|
|
self.xml.get_widget("entry_priority").set_text(str(infos['priority']))
|
|
if infos.has_key('use_proxy'):
|
|
self.xml.get_widget("checkbutton_proxy").set_active(infos['use_proxy'])
|
|
if infos.has_key('proxyhost'):
|
|
self.xml.get_widget("entry_proxyhost").set_text(infos['proxyhost'])
|
|
if infos.has_key('proxyport'):
|
|
self.xml.get_widget("entry_proxyport").set_text(str(\
|
|
infos['proxyport']))
|
|
|
|
def on_save_clicked(self, widget):
|
|
"""When save button is clicked : Save informations in config file"""
|
|
entryPass = self.xml.get_widget("entry_password")
|
|
entryRessource = self.xml.get_widget("entry_ressource")
|
|
entryPriority = self.xml.get_widget("entry_priority")
|
|
prio = entryPriority.get_text()
|
|
check = self.xml.get_widget("checkbutton")
|
|
entryName = self.xml.get_widget("entry_name")
|
|
entryJid = self.xml.get_widget("entry_jid")
|
|
checkProxy = self.xml.get_widget("checkbutton_proxy")
|
|
if checkProxy.get_active():
|
|
useProxy = 1
|
|
else:
|
|
useProxy = 0
|
|
entryProxyhost = self.xml.get_widget("entry_proxyhost")
|
|
entryProxyport = self.xml.get_widget("entry_proxyport")
|
|
proxyPort = entryProxyport.get_text()
|
|
proxyHost = entryProxyhost.get_text()
|
|
name = entryName.get_text()
|
|
jid = entryJid.get_text()
|
|
if (name == ''):
|
|
warning_Window(_("You must enter a name for this account"))
|
|
return 0
|
|
if name.find(' ') != -1:
|
|
warning_Window(_("Spaces are not permited in account name"))
|
|
return 0
|
|
if (jid == '') or (string.count(jid, '@') != 1):
|
|
warning_Window(_("You must enter a Jabber ID for this account\nFor example : login@hostname"))
|
|
return 0
|
|
if useProxy:
|
|
if proxyPort != '':
|
|
try:
|
|
proxyPort = string.atoi(proxyPort)
|
|
except ValueError:
|
|
warning_Window(_("Proxy Port must be a port number"))
|
|
return 0
|
|
if proxyHost == '':
|
|
warning_Window(_("You must enter a proxy host to use proxy"))
|
|
if prio != '':
|
|
try:
|
|
prio = string.atoi(prio)
|
|
except ValueError:
|
|
warning_Window(_("Priority must be a number"))
|
|
return 0
|
|
(login, hostname) = string.split(jid, '@')
|
|
#if we are modifying an account
|
|
if self.modify:
|
|
#if we modify the name of the account
|
|
if name != self.account:
|
|
#update variables
|
|
self.plugin.windows[name] = self.plugin.windows[self.account]
|
|
self.plugin.queues[name] = self.plugin.queues[self.account]
|
|
self.plugin.connected[name] = self.plugin.connected[self.account]
|
|
self.plugin.nicks[name] = self.plugin.nicks[self.account]
|
|
self.plugin.roster.groups[name] = \
|
|
self.plugin.roster.groups[self.account]
|
|
self.plugin.roster.contacts[name] = \
|
|
self.plugin.roster.contacts[self.account]
|
|
del self.plugin.windows[self.account]
|
|
del self.plugin.queues[self.account]
|
|
del self.plugin.connected[self.account]
|
|
del self.plugin.nicks[self.account]
|
|
del self.plugin.roster.groups[self.account]
|
|
del self.plugin.roster.contacts[self.account]
|
|
del self.plugin.accounts[self.account]
|
|
self.plugin.send('ACC_CHG', self.account, name)
|
|
self.plugin.accounts[name] = {'name': login, 'hostname': hostname,\
|
|
'password': entryPass.get_text(), 'ressource': \
|
|
entryRessource.get_text(), 'priority' : prio, 'use_proxy': \
|
|
useProxy, 'proxyhost': entryProxyhost.get_text(), 'proxyport': \
|
|
proxyPort}
|
|
self.plugin.send('CONFIG', None, ('accounts', self.plugin.accounts))
|
|
#refresh accounts window
|
|
if self.plugin.windows.has_key('accounts'):
|
|
self.plugin.windows['accounts'].init_accounts()
|
|
#refresh roster
|
|
self.plugin.roster.draw_roster()
|
|
widget.get_toplevel().destroy()
|
|
return
|
|
#if it's a new account
|
|
else:
|
|
if name in self.plugin.accounts.keys():
|
|
warning_Window(_("An account already has this name"))
|
|
return
|
|
#if we neeed to register a new account
|
|
if check.get_active():
|
|
self.plugin.send('NEW_ACC', None, (hostname, login, \
|
|
entryPass.get_text(), name, entryRessource.get_text(), prio, \
|
|
useProxy, proxyHost, proxyPort))
|
|
check.set_active(FALSE)
|
|
return
|
|
self.plugin.accounts[name] = {'name': login, 'hostname': hostname,\
|
|
'password': entryPass.get_text(), 'ressource': \
|
|
entryRessource.get_text(), 'priority' : prio, 'use_proxy': useProxy, \
|
|
'proxyhost': entryProxyhost.get_text(), 'proxyport': proxyPort}
|
|
self.plugin.send('CONFIG', None, ('accounts', self.plugin.accounts))
|
|
#update variables
|
|
self.plugin.windows[name] = {'infos': {}, 'chats': {}}
|
|
self.plugin.queues[name] = {}
|
|
self.plugin.connected[name] = 0
|
|
self.plugin.roster.groups[name] = {}
|
|
self.plugin.roster.contacts[name] = {}
|
|
self.plugin.nicks[name] = login
|
|
self.plugin.sleeper_state[name] = 0
|
|
#refresh accounts window
|
|
if self.plugin.windows.has_key('accounts'):
|
|
self.plugin.windows['accounts'].init_accounts()
|
|
#refresh roster
|
|
self.plugin.roster.draw_roster()
|
|
widget.get_toplevel().destroy()
|
|
|
|
def on_edit_details_clicked(self, widget):
|
|
entryJid = self.xml.get_widget("entry_jid")
|
|
if not self.plugin.windows.has_key('vcard'):
|
|
self.plugin.windows[self.account]['infos'][entryJid.get_text()] = \
|
|
vCard_Window(entryJid.get_text(), self.plugin, self.account)
|
|
if self.plugin.connected[self.account]:
|
|
self.plugin.send('ASK_VCARD', self.account, entryJid.get_text())
|
|
else:
|
|
warning_Window(_("You must be connected to get your informations"))
|
|
|
|
#info must be a dictionnary
|
|
def __init__(self, plugin, infos = {}):
|
|
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'Account', APP)
|
|
self.plugin = plugin
|
|
self.account = ''
|
|
self.modify = False
|
|
if infos:
|
|
self.modify = True
|
|
self.account = infos['name']
|
|
self.init_account(infos)
|
|
self.xml.get_widget("checkbutton").set_sensitive(FALSE)
|
|
self.xml.signal_connect('gtk_widget_destroy', self.delete_event)
|
|
self.xml.signal_connect('on_save_clicked', self.on_save_clicked)
|
|
self.xml.signal_connect('on_edit_details_clicked', \
|
|
self.on_edit_details_clicked)
|
|
self.xml.signal_connect('on_close_clicked', self.on_close)
|
|
|
|
|
|
class accounts_Window:
|
|
"""Class for accounts window : lists of accounts"""
|
|
def delete_event(self, widget):
|
|
"""close window"""
|
|
del self.plugin.windows['accounts']
|
|
|
|
#Not for the moment ... but maybe one day there will be a button
|
|
# def on_close(self, widget):
|
|
# """When Close button is clicked"""
|
|
# widget.get_toplevel().destroy()
|
|
|
|
def init_accounts(self):
|
|
"""initialize listStore with existing accounts"""
|
|
self.xml.get_widget("modify_button").set_sensitive(False)
|
|
self.xml.get_widget("delete_button").set_sensitive(False)
|
|
model = self.treeview.get_model()
|
|
model.clear()
|
|
for account in self.plugin.accounts:
|
|
iter = model.append()
|
|
model.set(iter, 0, account, 1, \
|
|
self.plugin.accounts[account]["hostname"])
|
|
|
|
def on_row_activated(self, widget):
|
|
"""Activate delete and modify buttons when a row is selected"""
|
|
self.xml.get_widget("modify_button").set_sensitive(True)
|
|
self.xml.get_widget("delete_button").set_sensitive(True)
|
|
|
|
def on_new_clicked(self, widget):
|
|
"""When new button is clicked : open an account information window"""
|
|
if not self.plugin.windows.has_key('accountPreference'):
|
|
self.plugin.windows['accountPreference'] = \
|
|
accountPreference_Window(self.plugin)
|
|
|
|
def on_delete_clicked(self, widget):
|
|
"""When delete button is clicked :
|
|
Remove an account from the listStore and from the config file"""
|
|
sel = self.treeview.get_selection()
|
|
(model, iter) = sel.get_selected()
|
|
account = model.get_value(iter, 0)
|
|
window = confirm_Window(_("Are you sure you want to remove this account (%s) ?") % account)
|
|
if window.wait() == gtk.RESPONSE_OK:
|
|
if self.plugin.connected[account]:
|
|
self.plugin.send('STATUS', account, ('offline', 'offline'))
|
|
del self.plugin.accounts[account]
|
|
self.plugin.send('CONFIG', None, ('accounts', self.plugin.accounts))
|
|
del self.plugin.windows[account]
|
|
del self.plugin.queues[account]
|
|
del self.plugin.connected[account]
|
|
del self.plugin.roster.groups[account]
|
|
del self.plugin.roster.contacts[account]
|
|
self.plugin.roster.draw_roster()
|
|
self.init_accounts()
|
|
|
|
def on_modify_clicked(self, widget):
|
|
"""When modify button is clicked :
|
|
open the account information window for this account"""
|
|
if not self.plugin.windows.has_key('accountPreference'):
|
|
infos = {}
|
|
sel = self.treeview.get_selection()
|
|
(model, iter) = sel.get_selected()
|
|
account = model.get_value(iter, 0)
|
|
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("priority"):
|
|
infos['priority'] = self.plugin.accounts[account]["priority"]
|
|
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 __init__(self, plugin):
|
|
self.plugin = plugin
|
|
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'Accounts', APP)
|
|
self.treeview = self.xml.get_widget("treeview")
|
|
model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
|
|
self.treeview.set_model(model)
|
|
#columns
|
|
renderer = gtk.CellRendererText()
|
|
renderer.set_data('column', 0)
|
|
self.treeview.insert_column_with_attributes(-1, _('Name'), renderer, text=0)
|
|
renderer = gtk.CellRendererText()
|
|
renderer.set_data('column', 1)
|
|
self.treeview.insert_column_with_attributes(-1, _('Server'), \
|
|
renderer, text=1)
|
|
self.xml.signal_connect('gtk_widget_destroy', self.delete_event)
|
|
self.xml.signal_connect('on_row_activated', self.on_row_activated)
|
|
self.xml.signal_connect('on_new_clicked', self.on_new_clicked)
|
|
self.xml.signal_connect('on_delete_clicked', self.on_delete_clicked)
|
|
self.xml.signal_connect('on_modify_clicked', self.on_modify_clicked)
|
|
self.init_accounts()
|
|
|
|
|
|
class agentRegistration_Window:
|
|
"""Class for agent registration window :
|
|
window that appears when we want to subscribe to an agent"""
|
|
def on_cancel(self, widget):
|
|
"""When Cancel button is clicked"""
|
|
widget.get_toplevel().destroy()
|
|
|
|
def draw_table(self):
|
|
"""Draw the table in the window"""
|
|
nbrow = 0
|
|
table = self.xml.get_widget('table')
|
|
for name in self.infos.keys():
|
|
if name != 'key' and name != 'instructions' and name != 'x':
|
|
nbrow = nbrow + 1
|
|
table.resize(rows=nbrow, columns=2)
|
|
label = gtk.Label(name)
|
|
table.attach(label, 0, 1, nbrow-1, nbrow, 0, 0, 0, 0)
|
|
entry = gtk.Entry()
|
|
entry.set_text(self.infos[name])
|
|
table.attach(entry, 1, 2, nbrow-1, nbrow, 0, 0, 0, 0)
|
|
self.entries[name] = entry
|
|
if nbrow == 1:
|
|
entry.grab_focus()
|
|
table.show_all()
|
|
|
|
def on_ok(self, widget):
|
|
"""When Ok button is clicked :
|
|
send registration info to the core"""
|
|
for name in self.entries.keys():
|
|
self.infos[name] = self.entries[name].get_text()
|
|
user1 = gtkgui.user(self.agent, self.agent, ['Agents'], 'offline', 'offline', \
|
|
'from', '', 0)
|
|
self.plugin.roster.contacts[self.account][self.agent] = [user1]
|
|
self.plugin.roster.add_user_to_roster(self.agent, self.account)
|
|
self.plugin.send('REG_AGENT', self.account, self.agent)
|
|
widget.get_toplevel().destroy()
|
|
|
|
def __init__(self, agent, infos, plugin, account):
|
|
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'agent_reg', APP)
|
|
self.agent = agent
|
|
self.infos = infos
|
|
self.plugin = plugin
|
|
self.account = account
|
|
self.xml.get_widget('agent_reg').set_title(_("Register to %s") % agent)
|
|
self.xml.get_widget('label').set_text(infos['instructions'])
|
|
self.entries = {}
|
|
self.draw_table()
|
|
self.xml.signal_connect('on_cancel_clicked', self.on_cancel)
|
|
self.xml.signal_connect('on_button_ok_clicked', self.on_ok)
|
|
|
|
|
|
class browseAgent_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[self.account]['browser']
|
|
|
|
def on_cancel(self, widget):
|
|
"""When Cancel button is clicked"""
|
|
widget.get_toplevel().destroy()
|
|
|
|
def on_close(self, widget):
|
|
"""When Close button is clicked"""
|
|
widget.get_toplevel().destroy()
|
|
|
|
def browse(self):
|
|
"""Send a request to the core to know the available agents"""
|
|
self.plugin.send('REQ_AGENTS', self.account, None)
|
|
|
|
def agents(self, agents):
|
|
"""When list of available agent arrive :
|
|
Fill the treeview with it"""
|
|
model = self.treeview.get_model()
|
|
for jid in agents.keys():
|
|
iter = model.append()
|
|
# model.set(iter, 0, agents[jid]['name'], 1, agents[jid]['service'])
|
|
model.set(iter, 0, agents[jid]['name'], 1, jid)
|
|
|
|
def on_refresh(self, widget):
|
|
"""When refresh button is clicked :
|
|
refresh list : clear and rerequest it"""
|
|
self.treeview.get_model().clear()
|
|
self.browse()
|
|
|
|
def on_row_activated(self, widget, path, col=0):
|
|
"""When a row is activated :
|
|
Ask specific informations about the selected agent and close the window"""
|
|
model = self.treeview.get_model()
|
|
iter = model.get_iter(path)
|
|
service = model.get_value(iter, 1)
|
|
self.plugin.send('REQ_AGENT_INFO', self.account, service)
|
|
widget.get_toplevel().destroy()
|
|
|
|
def __init__(self, plugin, account):
|
|
xml = gtk.glade.XML(GTKGUI_GLADE, 'browser', APP)
|
|
self.treeview = xml.get_widget('treeview')
|
|
self.plugin = plugin
|
|
self.account = account
|
|
model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
|
|
self.treeview.set_model(model)
|
|
#columns
|
|
renderer = gtk.CellRendererText()
|
|
renderer.set_data('column', 0)
|
|
self.treeview.insert_column_with_attributes(-1, 'Name', renderer, text=0)
|
|
renderer = gtk.CellRendererText()
|
|
renderer.set_data('column', 1)
|
|
self.treeview.insert_column_with_attributes(-1, 'Service', \
|
|
renderer, text=1)
|
|
|
|
xml.signal_connect('gtk_widget_destroy', self.delete_event)
|
|
xml.signal_connect('on_refresh_clicked', self.on_refresh)
|
|
xml.signal_connect('on_row_activated', self.on_row_activated)
|
|
xml.signal_connect('on_close_clicked', self.on_close)
|
|
if self.plugin.connected[account]:
|
|
self.browse()
|
|
else:
|
|
warning_Window(_("You must be connected to view Agents"))
|