gajim-plural/src/config.py

3462 lines
124 KiB
Python

## config.py
##
## Copyright (C) 2003-2006 Yann Le Boulanger <asterix@lagaule.org>
## Copyright (C) 2005-2006 Nikos Kouremenos <kourem@gmail.com>
## Copyright (C) 2005 Dimitur Kirov <dkirov@gmail.com>
## Copyright (C) 2003-2005 Vincent Hanquez <tab@snarc.org>
## Copyright (C) 2006 Stefan Bethge <stefan@lanpartei.de>
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published
## by the Free Software Foundation; version 2 only.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
import gtk
import gobject
import os
import common.config
import common.sleepy
from common.i18n import Q_
import gtkgui_helpers
import dialogs
import cell_renderer_image
import message_control
import chat_control
import dataforms_widget
try:
import gtkspell
HAS_GTK_SPELL = True
except:
HAS_GTK_SPELL = False
from common import helpers
from common import gajim
from common import connection
from common import passwords
from common import zeroconf
from common import dbus_support
from common import dataforms
from common.exceptions import GajimGeneralException
#---------- PreferencesWindow class -------------#
class PreferencesWindow:
'''Class for Preferences window'''
def on_preferences_window_destroy(self, widget):
'''close window'''
del gajim.interface.instances['preferences']
def on_close_button_clicked(self, widget):
self.window.destroy()
def __init__(self):
'''Initialize Preferences window'''
self.xml = gtkgui_helpers.get_glade('preferences_window.glade')
self.window = self.xml.get_widget('preferences_window')
self.window.set_transient_for(gajim.interface.roster.window)
self.iconset_combobox = self.xml.get_widget('iconset_combobox')
self.notify_on_new_message_radiobutton = self.xml.get_widget(
'notify_on_new_message_radiobutton')
self.popup_new_message_radiobutton = self.xml.get_widget(
'popup_new_message_radiobutton')
self.notify_on_signin_checkbutton = self.xml.get_widget(
'notify_on_signin_checkbutton')
self.notify_on_signout_checkbutton = self.xml.get_widget(
'notify_on_signout_checkbutton')
self.auto_popup_away_checkbutton = self.xml.get_widget(
'auto_popup_away_checkbutton')
self.auto_away_checkbutton = self.xml.get_widget('auto_away_checkbutton')
self.auto_away_time_spinbutton = self.xml.get_widget(
'auto_away_time_spinbutton')
self.auto_away_message_entry = self.xml.get_widget(
'auto_away_message_entry')
self.auto_xa_checkbutton = self.xml.get_widget('auto_xa_checkbutton')
self.auto_xa_time_spinbutton = self.xml.get_widget(
'auto_xa_time_spinbutton')
self.auto_xa_message_entry = self.xml.get_widget('auto_xa_message_entry')
self.trayicon_checkbutton = self.xml.get_widget('trayicon_checkbutton')
self.notebook = self.xml.get_widget('preferences_notebook')
self.one_window_type_combobox =\
self.xml.get_widget('one_window_type_combobox')
self.treat_incoming_messages_combobox =\
self.xml.get_widget('treat_incoming_messages_combobox')
#FIXME: remove when ANC will be implemented
w = self.xml.get_widget('hbox3020')
w.set_no_show_all(True)
w.hide()
# trayicon
if gajim.interface.systray_capabilities:
st = gajim.config.get('trayicon')
self.trayicon_checkbutton.set_active(st)
else:
self.trayicon_checkbutton.set_sensitive(False)
# Save position
st = gajim.config.get('saveposition')
self.xml.get_widget('save_position_checkbutton').set_active(st)
# Sort contacts by show
st = gajim.config.get('sort_by_show')
self.xml.get_widget('sort_by_show_checkbutton').set_active(st)
# Display avatars in roster
st = gajim.config.get('show_avatars_in_roster')
self.xml.get_widget('show_avatars_in_roster_checkbutton').set_active(st)
# Display status msg under contact name in roster
st = gajim.config.get('show_status_msgs_in_roster')
self.xml.get_widget('show_status_msgs_in_roster_checkbutton').set_active(
st)
# emoticons
emoticons_combobox = self.xml.get_widget('emoticons_combobox')
emoticons_list = os.listdir(os.path.join(gajim.DATA_DIR, 'emoticons'))
# user themes
if os.path.isdir(gajim.MY_EMOTS_PATH):
emoticons_list += os.listdir(gajim.MY_EMOTS_PATH)
renderer_text = gtk.CellRendererText()
emoticons_combobox.pack_start(renderer_text, True)
emoticons_combobox.add_attribute(renderer_text, 'text', 0)
model = gtk.ListStore(str)
emoticons_combobox.set_model(model)
l = []
for dir in emoticons_list:
if not os.path.isdir(os.path.join(gajim.DATA_DIR, 'emoticons', dir)) \
and not os.path.isdir(os.path.join(gajim.MY_EMOTS_PATH, dir)) :
continue
if dir != '.svn':
l.append(dir)
l.append(_('Disabled'))
for i in xrange(len(l)):
model.append([l[i]])
if gajim.config.get('emoticons_theme') == l[i]:
emoticons_combobox.set_active(i)
if not gajim.config.get('emoticons_theme'):
emoticons_combobox.set_active(len(l)-1)
# iconset
iconsets_list = os.listdir(os.path.join(gajim.DATA_DIR, 'iconsets'))
# new model, image in 0, string in 1
model = gtk.ListStore(gtk.Image, str)
renderer_image = cell_renderer_image.CellRendererImage(0, 0)
renderer_text = gtk.CellRendererText()
renderer_text.set_property('xpad', 5)
self.iconset_combobox.pack_start(renderer_image, expand = False)
self.iconset_combobox.pack_start(renderer_text, expand = True)
self.iconset_combobox.set_attributes(renderer_text, text = 1)
self.iconset_combobox.add_attribute(renderer_image, 'image', 0)
self.iconset_combobox.set_model(model)
l = []
for dir in iconsets_list:
if not os.path.isdir(os.path.join(gajim.DATA_DIR, 'iconsets', dir)):
continue
if dir != '.svn' and dir != 'transports':
l.append(dir)
if l.count == 0:
l.append(' ')
for i in xrange(len(l)):
preview = gtk.Image()
files = []
files.append(os.path.join(gajim.DATA_DIR, 'iconsets', l[i], '16x16',
'online.png'))
files.append(os.path.join(gajim.DATA_DIR, 'iconsets', l[i], '16x16',
'online.gif'))
for file in files:
if os.path.exists(file):
preview.set_from_file(file)
model.append([preview, l[i]])
if gajim.config.get('iconset') == l[i]:
self.iconset_combobox.set_active(i)
# Set default for single window type
choices = common.config.opt_one_window_types
type = gajim.config.get('one_message_window')
if type in choices:
self.one_window_type_combobox.set_active(choices.index(type))
else:
self.one_window_type_combobox.set_active(0)
# Set default for treat incoming messages
choices = common.config.opt_treat_incoming_messages
type = gajim.config.get('treat_incoming_messages')
if type in choices:
self.treat_incoming_messages_combobox.set_active(choices.index(type))
else:
self.treat_incoming_messages_combobox.set_active(0)
# Use transports iconsets
st = gajim.config.get('use_transports_iconsets')
self.xml.get_widget('transports_iconsets_checkbutton').set_active(st)
# Themes
theme_combobox = self.xml.get_widget('theme_combobox')
cell = gtk.CellRendererText()
theme_combobox.pack_start(cell, True)
theme_combobox.add_attribute(cell, 'text', 0)
model = gtk.ListStore(str)
theme_combobox.set_model(model)
i = 0
for config_theme in gajim.config.get_per('themes'):
theme = config_theme.replace('_', ' ')
model.append([theme])
if gajim.config.get('roster_theme') == config_theme:
theme_combobox.set_active(i)
i += 1
# use speller
if os.name == 'nt':
self.xml.get_widget('speller_checkbutton').set_no_show_all(True)
else:
if HAS_GTK_SPELL:
st = gajim.config.get('use_speller')
self.xml.get_widget('speller_checkbutton').set_active(st)
else:
self.xml.get_widget('speller_checkbutton').set_sensitive(False)
# Ignore XHTML
st = gajim.config.get('ignore_incoming_xhtml')
self.xml.get_widget('xhtml_checkbutton').set_active(st)
# Print time
st = gajim.config.get('print_ichat_every_foo_minutes')
text = _('Every %s _minutes') % st
self.xml.get_widget('time_sometimes_radiobutton').set_label(text)
if gajim.config.get('print_time') == 'never':
self.xml.get_widget('time_never_radiobutton').set_active(True)
elif gajim.config.get('print_time') == 'sometimes':
self.xml.get_widget('time_sometimes_radiobutton').set_active(True)
else:
self.xml.get_widget('time_always_radiobutton').set_active(True)
# Color for incoming messages
colSt = gajim.config.get('inmsgcolor')
self.xml.get_widget('incoming_msg_colorbutton').set_color(
gtk.gdk.color_parse(colSt))
# Color for outgoing messages
colSt = gajim.config.get('outmsgcolor')
self.xml.get_widget('outgoing_msg_colorbutton').set_color(
gtk.gdk.color_parse(colSt))
# Color for status messages
colSt = gajim.config.get('statusmsgcolor')
self.xml.get_widget('status_msg_colorbutton').set_color(
gtk.gdk.color_parse(colSt))
# Color for hyperlinks
colSt = gajim.config.get('urlmsgcolor')
self.xml.get_widget('url_msg_colorbutton').set_color(
gtk.gdk.color_parse(colSt))
# Font for messages
font = gajim.config.get('conversation_font')
# try to set default font for the current desktop env
fontbutton = self.xml.get_widget('conversation_fontbutton')
if font == '':
fontbutton.set_sensitive(False)
self.xml.get_widget('default_chat_font').set_active(True)
else:
fontbutton.set_font_name(font)
# on new message
only_in_roster = True
if gajim.config.get('notify_on_new_message'):
self.xml.get_widget('notify_on_new_message_radiobutton').set_active(
True)
only_in_roster = False
if gajim.config.get('autopopup'):
self.xml.get_widget('popup_new_message_radiobutton').set_active(True)
only_in_roster = False
if only_in_roster:
self.xml.get_widget('only_in_roster_radiobutton').set_active(True)
# notify on online statuses
st = gajim.config.get('notify_on_signin')
self.notify_on_signin_checkbutton.set_active(st)
# notify on offline statuses
st = gajim.config.get('notify_on_signout')
self.notify_on_signout_checkbutton.set_active(st)
# autopopupaway
st = gajim.config.get('autopopupaway')
self.auto_popup_away_checkbutton.set_active(st)
# Ignore messages from unknown contacts
self.xml.get_widget('ignore_events_from_unknown_contacts_checkbutton').\
set_active(gajim.config.get('ignore_unknown_contacts'))
# outgoing send chat state notifications
st = gajim.config.get('outgoing_chat_state_notifications')
combo = self.xml.get_widget('outgoing_chat_states_combobox')
if st == 'all':
combo.set_active(0)
elif st == 'composing_only':
combo.set_active(1)
else: # disabled
combo.set_active(2)
# displayed send chat state notifications
st = gajim.config.get('displayed_chat_state_notifications')
combo = self.xml.get_widget('displayed_chat_states_combobox')
if st == 'all':
combo.set_active(0)
elif st == 'composing_only':
combo.set_active(1)
else: # disabled
combo.set_active(2)
# sounds
if os.name == 'nt':
# if windows, player must not become visible on show_all
soundplayer_hbox = self.xml.get_widget('soundplayer_hbox')
soundplayer_hbox.set_no_show_all(True)
if gajim.config.get('sounds_on'):
self.xml.get_widget('play_sounds_checkbutton').set_active(True)
else:
self.xml.get_widget('soundplayer_hbox').set_sensitive(False)
self.xml.get_widget('sounds_scrolledwindow').set_sensitive(False)
self.xml.get_widget('browse_sounds_hbox').set_sensitive(False)
# sound player
player = gajim.config.get('soundplayer')
self.xml.get_widget('soundplayer_entry').set_text(player)
if player == '': # only on first time Gajim starts
commands = ('aplay', 'play', 'esdplay', 'artsplay')
for command in commands:
if helpers.is_in_path(command):
if command == 'aplay':
command += ' -q'
self.xml.get_widget('soundplayer_entry').set_text(command)
gajim.config.set('soundplayer', command)
break
# sounds treeview
self.sound_tree = self.xml.get_widget('sounds_treeview')
# active, event ui name, path to sound file, event_config_name
model = gtk.ListStore(bool, str, str, str)
self.sound_tree.set_model(model)
col = gtk.TreeViewColumn(_('Active'))
self.sound_tree.append_column(col)
renderer = gtk.CellRendererToggle()
renderer.set_property('activatable', True)
renderer.connect('toggled', self.sound_toggled_cb)
col.pack_start(renderer)
col.set_attributes(renderer, active = 0)
col = gtk.TreeViewColumn(_('Event'))
self.sound_tree.append_column(col)
renderer = gtk.CellRendererText()
col.pack_start(renderer)
col.set_attributes(renderer, text = 1)
self.fill_sound_treeview()
#Autoaway
st = gajim.config.get('autoaway')
self.auto_away_checkbutton.set_active(st)
# Autoawaytime
st = gajim.config.get('autoawaytime')
self.auto_away_time_spinbutton.set_value(st)
self.auto_away_time_spinbutton.set_sensitive(gajim.config.get('autoaway'))
# autoaway message
st = gajim.config.get('autoaway_message')
self.auto_away_message_entry.set_text(st)
self.auto_away_message_entry.set_sensitive(gajim.config.get('autoaway'))
# Autoxa
st = gajim.config.get('autoxa')
self.auto_xa_checkbutton.set_active(st)
# Autoxatime
st = gajim.config.get('autoxatime')
self.auto_xa_time_spinbutton.set_value(st)
self.auto_xa_time_spinbutton.set_sensitive(gajim.config.get('autoxa'))
# autoxa message
st = gajim.config.get('autoxa_message')
self.auto_xa_message_entry.set_text(st)
self.auto_xa_message_entry.set_sensitive(gajim.config.get('autoxa'))
# ask_status when online / offline
st = gajim.config.get('ask_online_status')
self.xml.get_widget('prompt_online_status_message_checkbutton').\
set_active(st)
st = gajim.config.get('ask_offline_status')
self.xml.get_widget('prompt_offline_status_message_checkbutton').\
set_active(st)
# Default Status messages
self.default_msg_tree = self.xml.get_widget('default_msg_treeview')
# (status, translated_status, message, enabled)
model = gtk.ListStore(str, str, str, bool)
self.default_msg_tree.set_model(model)
col = gtk.TreeViewColumn('Status')
self.default_msg_tree.append_column(col)
renderer = gtk.CellRendererText()
col.pack_start(renderer, False)
col.set_attributes(renderer, text = 1)
col = gtk.TreeViewColumn('Message')
self.default_msg_tree.append_column(col)
renderer = gtk.CellRendererText()
col.pack_start(renderer, True)
col.set_attributes(renderer, text = 2)
renderer.connect('edited', self.on_default_msg_cell_edited)
renderer.set_property('editable', True)
col = gtk.TreeViewColumn('Enabled')
self.default_msg_tree.append_column(col)
renderer = gtk.CellRendererToggle()
col.pack_start(renderer, False)
col.set_attributes(renderer, active = 3)
renderer.set_property('activatable', True)
renderer.connect('toggled', self.default_msg_toggled_cb)
self.fill_default_msg_treeview()
# Status messages
self.msg_tree = self.xml.get_widget('msg_treeview')
model = gtk.ListStore(str, str)
self.msg_tree.set_model(model)
col = gtk.TreeViewColumn('name')
self.msg_tree.append_column(col)
renderer = gtk.CellRendererText()
col.pack_start(renderer, True)
col.set_attributes(renderer, text = 0)
renderer.connect('edited', self.on_msg_cell_edited)
renderer.set_property('editable', True)
self.fill_msg_treeview()
buf = self.xml.get_widget('msg_textview').get_buffer()
buf.connect('changed', self.on_msg_textview_changed)
# open links with
if os.name == 'nt':
applications_frame = self.xml.get_widget('applications_frame')
applications_frame.set_no_show_all(True)
applications_frame.hide()
else:
self.applications_combobox = self.xml.get_widget(
'applications_combobox')
self.xml.get_widget('custom_apps_frame').hide()
self.xml.get_widget('custom_apps_frame').set_no_show_all(True)
if gajim.config.get('autodetect_browser_mailer'):
self.applications_combobox.set_active(0)
# else autodetect_browser_mailer is False.
# so user has 'Always Use GNOME/KDE/XFCE4' or Custom
elif gajim.config.get('openwith') == 'gnome-open':
self.applications_combobox.set_active(1)
elif gajim.config.get('openwith') == 'kfmclient exec':
self.applications_combobox.set_active(2)
elif gajim.config.get('openwith') == 'exo-open':
self.applications_combobox.set_active(3)
elif gajim.config.get('openwith') == 'custom':
self.applications_combobox.set_active(4)
self.xml.get_widget('custom_apps_frame').show()
self.xml.get_widget('custom_browser_entry').set_text(
gajim.config.get('custombrowser'))
self.xml.get_widget('custom_mail_client_entry').set_text(
gajim.config.get('custommailapp'))
self.xml.get_widget('custom_file_manager_entry').set_text(
gajim.config.get('custom_file_manager'))
# log status changes of contacts
st = gajim.config.get('log_contact_status_changes')
self.xml.get_widget('log_show_changes_checkbutton').set_active(st)
# send os info
st = gajim.config.get('send_os_info')
self.xml.get_widget('send_os_info_checkbutton').set_active(st)
# send os info
st = gajim.config.get('check_if_gajim_is_default')
self.xml.get_widget('check_default_client_checkbutton').set_active(st)
# set status msg from currently playing music track
widget = self.xml.get_widget(
'set_status_msg_from_current_music_track_checkbutton')
if os.name == 'nt':
widget.set_no_show_all(True)
widget.hide()
elif dbus_support.supported:
st = gajim.config.get('set_status_msg_from_current_music_track')
widget.set_active(st)
else:
widget.set_sensitive(False)
# Notify user of new gmail e-mail messages,
# only show checkbox if user has a gtalk account
frame_gmail = self.xml.get_widget('frame_gmail')
notify_gmail_checkbutton = self.xml.get_widget('notify_gmail_checkbutton')
notify_gmail_extra_checkbutton = self.xml.get_widget(
'notify_gmail_extra_checkbutton')
frame_gmail.set_no_show_all(True)
for account in gajim.config.get_per('accounts'):
jid = gajim.get_jid_from_account(account)
if gajim.get_server_from_jid(jid) in gajim.gmail_domains:
frame_gmail.show_all()
st = gajim.config.get('notify_on_new_gmail_email')
notify_gmail_checkbutton.set_active(st)
st = gajim.config.get('notify_on_new_gmail_email_extra')
notify_gmail_extra_checkbutton.set_active(st)
break
else:
frame_gmail.hide()
self.xml.signal_autoconnect(self)
self.sound_tree.get_model().connect('row-changed',
self.on_sounds_treemodel_row_changed)
self.msg_tree.get_model().connect('row-changed',
self.on_msg_treemodel_row_changed)
self.msg_tree.get_model().connect('row-deleted',
self.on_msg_treemodel_row_deleted)
self.default_msg_tree.get_model().connect('row-changed',
self.on_default_msg_treemodel_row_changed)
self.theme_preferences = None
self.notebook.set_current_page(0)
self.window.show_all()
gtkgui_helpers.possibly_move_window_in_current_desktop(self.window)
def on_preferences_window_key_press_event(self, widget, event):
if event.keyval == gtk.keysyms.Escape:
self.window.hide()
def on_checkbutton_toggled(self, widget, config_name,
change_sensitivity_widgets = None):
gajim.config.set(config_name, widget.get_active())
if change_sensitivity_widgets:
for w in change_sensitivity_widgets:
w.set_sensitive(widget.get_active())
gajim.interface.save_config()
def on_trayicon_checkbutton_toggled(self, widget):
if widget.get_active():
gajim.config.set('trayicon', True)
gajim.interface.show_systray()
show = helpers.get_global_show()
gajim.interface.systray.change_status(show)
else:
gajim.config.set('trayicon', False)
if not gajim.interface.roster.window.get_property('visible'):
gajim.interface.roster.window.present()
gajim.interface.hide_systray()
# no tray, show roster!
gajim.config.set('show_roster_on_startup', True)
gajim.interface.roster.draw_roster()
gajim.interface.save_config()
def on_save_position_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'saveposition')
def on_sort_by_show_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'sort_by_show')
gajim.interface.roster.draw_roster()
def on_show_status_msgs_in_roster_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'show_status_msgs_in_roster')
gajim.interface.roster.draw_roster()
for ctl in gajim.interface.msg_win_mgr.controls():
if ctl.type_id == message_control.TYPE_GC:
ctl.update_ui()
def on_show_avatars_in_roster_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'show_avatars_in_roster')
gajim.interface.roster.draw_roster()
# Redraw connected groupchats (in an ugly way)
for account in gajim.connections:
if gajim.connections[account].connected:
for gc_control in gajim.interface.msg_win_mgr.get_controls(
message_control.TYPE_GC) + \
gajim.interface.minimized_controls[account].values():
gc_control.draw_roster()
def on_emoticons_combobox_changed(self, widget):
active = widget.get_active()
model = widget.get_model()
emot_theme = model[active][0].decode('utf-8')
if emot_theme == _('Disabled'):
gajim.config.set('emoticons_theme', '')
else:
gajim.config.set('emoticons_theme', emot_theme)
gajim.interface.init_emoticons(need_reload = True)
gajim.interface.make_regexps()
self.toggle_emoticons()
def toggle_emoticons(self):
'''Update emoticons state in Opened Chat Windows'''
for win in gajim.interface.msg_win_mgr.windows():
win.toggle_emoticons()
def on_iconset_combobox_changed(self, widget):
model = widget.get_model()
active = widget.get_active()
icon_string = model[active][1].decode('utf-8')
gajim.config.set('iconset', icon_string)
gajim.interface.roster.reload_jabber_state_images()
gajim.interface.save_config()
def on_transports_iconsets_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'use_transports_iconsets')
gajim.interface.roster.reload_jabber_state_images()
def on_manage_theme_button_clicked(self, widget):
if self.theme_preferences is None:
self.theme_preferences = dialogs.GajimThemesWindow()
else:
self.theme_preferences.window.present()
self.theme_preferences.select_active_theme()
def on_theme_combobox_changed(self, widget):
model = widget.get_model()
active = widget.get_active()
config_theme = model[active][0].decode('utf-8').replace(' ', '_')
gajim.config.set('roster_theme', config_theme)
# begin repainting themed widgets throughout
gajim.interface.roster.repaint_themed_widgets()
gajim.interface.roster.change_roster_style(None)
gajim.interface.save_config()
def on_open_advanced_notifications_button_clicked(self, widget):
dialogs.AdvancedNotificationsWindow()
def on_one_window_type_combo_changed(self, widget):
active = widget.get_active()
config_type = common.config.opt_one_window_types[active]
gajim.config.set('one_message_window', config_type)
gajim.interface.save_config()
gajim.interface.msg_win_mgr.reconfig()
def on_treat_incoming_messages_combobox_changed(self, widget):
active = widget.get_active()
config_type = common.config.opt_treat_incoming_messages[active]
gajim.config.set('treat_incoming_messages', config_type)
def apply_speller(self):
for acct in gajim.connections:
for ctrl in gajim.interface.msg_win_mgr.controls():
if isinstance(ctrl, chat_control.ChatControlBase):
try:
spell_obj = gtkspell.get_from_text_view(ctrl.msg_textview)
except:
spell_obj = None
if not spell_obj:
gtkspell.Spell(ctrl.msg_textview)
def remove_speller(self):
for acct in gajim.connections:
for ctrl in gajim.interface.msg_win_mgr.controls():
if isinstance(ctrl, chat_control.ChatControlBase):
try:
spell_obj = gtkspell.get_from_text_view(ctrl.msg_textview)
except:
spell_obj = None
if spell_obj:
spell_obj.detach()
def on_speller_checkbutton_toggled(self, widget):
active = widget.get_active()
gajim.config.set('use_speller', active)
gajim.interface.save_config()
if active:
lang = gajim.config.get('speller_language')
if not lang:
lang = gajim.LANG
tv = gtk.TextView()
try:
spell = gtkspell.Spell(tv, lang)
except:
dialogs.ErrorDialog(
_('Dictionary for lang %s not available') % lang,
_('You have to install %s dictionary to use spellchecking, or '
'choose another language by setting the speller_language option.'
) % lang)
gajim.config.set('use_speller', False)
widget.set_active(False)
else:
gajim.config.set('speller_language', lang)
self.apply_speller()
else:
self.remove_speller()
def on_xhtml_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'ignore_incoming_xhtml')
def on_time_never_radiobutton_toggled(self, widget):
if widget.get_active():
gajim.config.set('print_time', 'never')
gajim.interface.save_config()
def on_time_sometimes_radiobutton_toggled(self, widget):
if widget.get_active():
gajim.config.set('print_time', 'sometimes')
gajim.interface.save_config()
def on_time_always_radiobutton_toggled(self, widget):
if widget.get_active():
gajim.config.set('print_time', 'always')
gajim.interface.save_config()
def update_text_tags(self):
'''Update color tags in Opened Chat Windows'''
for win in gajim.interface.msg_win_mgr.windows():
win.update_tags()
def on_preference_widget_color_set(self, widget, text):
color = widget.get_color()
color_string = gtkgui_helpers.make_color_string(color)
gajim.config.set(text, color_string)
self.update_text_tags()
gajim.interface.save_config()
def on_preference_widget_font_set(self, widget, text):
if widget:
font = widget.get_font_name()
else:
font = ''
gajim.config.set(text, font)
self.update_text_font()
gajim.interface.save_config()
def update_text_font(self):
'''Update text font in Opened Chat Windows'''
for win in gajim.interface.msg_win_mgr.windows():
win.update_font()
def on_incoming_msg_colorbutton_color_set(self, widget):
self.on_preference_widget_color_set(widget, 'inmsgcolor')
def on_outgoing_msg_colorbutton_color_set(self, widget):
self.on_preference_widget_color_set(widget, 'outmsgcolor')
def on_url_msg_colorbutton_color_set(self, widget):
self.on_preference_widget_color_set(widget, 'urlmsgcolor')
def on_status_msg_colorbutton_color_set(self, widget):
self.on_preference_widget_color_set(widget, 'statusmsgcolor')
def on_conversation_fontbutton_font_set(self, widget):
self.on_preference_widget_font_set(widget, 'conversation_font')
def on_default_chat_font_toggled(self, widget):
font_widget = self.xml.get_widget('conversation_fontbutton')
if widget.get_active():
font_widget.set_sensitive(False)
font_widget = None
else:
font_widget.set_sensitive(True)
self.on_preference_widget_font_set(font_widget, 'conversation_font')
def on_reset_colors_button_clicked(self, widget):
for i in ('inmsgcolor', 'outmsgcolor', 'statusmsgcolor', 'urlmsgcolor'):
gajim.config.set(i, gajim.interface.default_colors[i])
self.xml.get_widget('incoming_msg_colorbutton').set_color(\
gtk.gdk.color_parse(gajim.config.get('inmsgcolor')))
self.xml.get_widget('outgoing_msg_colorbutton').set_color(\
gtk.gdk.color_parse(gajim.config.get('outmsgcolor')))
self.xml.get_widget('status_msg_colorbutton').set_color(\
gtk.gdk.color_parse(gajim.config.get('statusmsgcolor')))
self.xml.get_widget('url_msg_colorbutton').set_color(\
gtk.gdk.color_parse(gajim.config.get('urlmsgcolor')))
self.update_text_tags()
gajim.interface.save_config()
def on_notify_on_new_message_radiobutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'notify_on_new_message',
[self.auto_popup_away_checkbutton])
def on_popup_new_message_radiobutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'autopopup',
[self.auto_popup_away_checkbutton])
def on_only_in_roster_radiobutton_toggled(self, widget):
if widget.get_active():
self.auto_popup_away_checkbutton.set_sensitive(False)
def on_notify_on_signin_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'notify_on_signin')
def on_notify_on_signout_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'notify_on_signout')
def on_auto_popup_away_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'autopopupaway')
def on_ignore_events_from_unknown_contacts_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'ignore_unknown_contacts')
def on_outgoing_chat_states_combobox_changed(self, widget):
active = widget.get_active()
if active == 0: # all
gajim.config.set('outgoing_chat_state_notifications', 'all')
elif active == 1: # only composing
gajim.config.set('outgoing_chat_state_notifications', 'composing_only')
else: # disabled
gajim.config.set('outgoing_chat_state_notifications', 'disabled')
def on_displayed_chat_states_combobox_changed(self, widget):
active = widget.get_active()
if active == 0: # all
gajim.config.set('displayed_chat_state_notifications', 'all')
elif active == 1: # only composing
gajim.config.set('displayed_chat_state_notifications',
'composing_only')
else: # disabled
gajim.config.set('displayed_chat_state_notifications', 'disabled')
def on_play_sounds_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'sounds_on',
[self.xml.get_widget('soundplayer_hbox'),
self.xml.get_widget('sounds_scrolledwindow'),
self.xml.get_widget('browse_sounds_hbox')])
def on_soundplayer_entry_changed(self, widget):
gajim.config.set('soundplayer', widget.get_text().decode('utf-8'))
gajim.interface.save_config()
def on_prompt_online_status_message_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'ask_online_status')
def on_prompt_offline_status_message_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'ask_offline_status')
def on_sounds_treemodel_row_changed(self, model, path, iter):
sound_event = model[iter][3].decode('utf-8')
gajim.config.set_per('soundevents', sound_event, 'enabled',
bool(model[path][0]))
gajim.config.set_per('soundevents', sound_event, 'path',
model[iter][2].decode('utf-8'))
gajim.interface.save_config()
def on_auto_away_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'autoaway',
[self.auto_away_time_spinbutton, self.auto_away_message_entry])
def on_auto_away_time_spinbutton_value_changed(self, widget):
aat = widget.get_value_as_int()
gajim.config.set('autoawaytime', aat)
gajim.interface.sleeper = common.sleepy.Sleepy(
gajim.config.get('autoawaytime') * 60,
gajim.config.get('autoxatime') * 60)
gajim.interface.save_config()
def on_auto_away_message_entry_changed(self, widget):
gajim.config.set('autoaway_message', widget.get_text().decode('utf-8'))
def on_auto_xa_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'autoxa',
[self.auto_xa_time_spinbutton, self.auto_xa_message_entry])
def on_auto_xa_time_spinbutton_value_changed(self, widget):
axt = widget.get_value_as_int()
gajim.config.set('autoxatime', axt)
gajim.interface.sleeper = common.sleepy.Sleepy(
gajim.config.get('autoawaytime') * 60,
gajim.config.get('autoxatime') * 60)
gajim.interface.save_config()
def on_auto_xa_message_entry_changed(self, widget):
gajim.config.set('autoxa_message', widget.get_text().decode('utf-8'))
def fill_default_msg_treeview(self):
model = self.default_msg_tree.get_model()
model.clear()
status = []
for status_ in gajim.config.get_per('defaultstatusmsg'):
status.append(status_)
status.sort()
for status_ in status:
msg = gajim.config.get_per('defaultstatusmsg', status_, 'message')
enabled = gajim.config.get_per('defaultstatusmsg', status_, 'enabled')
iter = model.append()
uf_show = helpers.get_uf_show(status_)
model.set(iter, 0, status_, 1, uf_show, 2, msg, 3, enabled)
def on_default_msg_cell_edited(self, cell, row, new_text):
model = self.default_msg_tree.get_model()
iter = model.get_iter_from_string(row)
model.set_value(iter, 2, new_text)
def default_msg_toggled_cb(self, cell, path):
model = self.default_msg_tree.get_model()
model[path][3] = not model[path][3]
def on_default_msg_treemodel_row_changed(self, model, path, iter):
status = model[iter][0]
message = model[iter][2].decode('utf-8')
gajim.config.set_per('defaultstatusmsg', status, 'enabled',
model[iter][3])
gajim.config.set_per('defaultstatusmsg', status, 'message', message)
def on_default_status_expander_activate(self, expander):
eventbox = self.xml.get_widget('default_status_eventbox')
vbox = self.xml.get_widget('status_vbox')
vbox.set_child_packing(eventbox, not expander.get_expanded(), True, 0,
gtk.PACK_START)
def save_status_messages(self, model):
for msg in gajim.config.get_per('statusmsg'):
gajim.config.del_per('statusmsg', msg)
iter = model.get_iter_first()
while iter:
val = model[iter][0].decode('utf-8')
if model[iter][1]: # we have a preset message
if not val: # no title, use message text for title
val = model[iter][1]
gajim.config.add_per('statusmsg', val)
msg = helpers.to_one_line(model[iter][1].decode('utf-8'))
gajim.config.set_per('statusmsg', val, 'message', msg)
iter = model.iter_next(iter)
gajim.interface.save_config()
def on_msg_treemodel_row_changed(self, model, path, iter):
self.save_status_messages(model)
def on_msg_treemodel_row_deleted(self, model, path):
self.save_status_messages(model)
def on_applications_combobox_changed(self, widget):
gajim.config.set('autodetect_browser_mailer', False)
if widget.get_active() == 4:
self.xml.get_widget('custom_apps_frame').show()
gajim.config.set('openwith', 'custom')
else:
if widget.get_active() == 0:
gajim.config.set('autodetect_browser_mailer', True)
elif widget.get_active() == 1:
gajim.config.set('openwith', 'gnome-open')
elif widget.get_active() == 2:
gajim.config.set('openwith', 'kfmclient exec')
elif widget.get_active() == 3:
gajim.config.set('openwith', 'exo-open')
self.xml.get_widget('custom_apps_frame').hide()
gajim.interface.save_config()
def on_custom_browser_entry_changed(self, widget):
gajim.config.set('custombrowser', widget.get_text().decode('utf-8'))
gajim.interface.save_config()
def on_custom_mail_client_entry_changed(self, widget):
gajim.config.set('custommailapp', widget.get_text().decode('utf-8'))
gajim.interface.save_config()
def on_custom_file_manager_entry_changed(self, widget):
gajim.config.set('custom_file_manager', widget.get_text().decode('utf-8'))
gajim.interface.save_config()
def on_log_show_changes_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'log_contact_status_changes')
def on_send_os_info_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'send_os_info')
def on_check_default_client_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'check_if_gajim_is_default')
def on_notify_gmail_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'notify_on_new_gmail_email')
def on_notify_gmail_extra_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'notify_on_new_gmail_email_extra')
def fill_msg_treeview(self):
self.xml.get_widget('delete_msg_button').set_sensitive(False)
model = self.msg_tree.get_model()
model.clear()
preset_status = []
for msg_name in gajim.config.get_per('statusmsg'):
preset_status.append(msg_name)
preset_status.sort()
for msg_name in preset_status:
msg_text = gajim.config.get_per('statusmsg', msg_name, 'message')
msg_text = helpers.from_one_line(msg_text)
iter = model.append()
model.set(iter, 0, msg_name, 1, msg_text)
def on_msg_cell_edited(self, cell, row, new_text):
model = self.msg_tree.get_model()
iter = model.get_iter_from_string(row)
model.set_value(iter, 0, new_text)
def on_msg_treeview_cursor_changed(self, widget, data = None):
(model, iter) = self.msg_tree.get_selection().get_selected()
if not iter:
return
self.xml.get_widget('delete_msg_button').set_sensitive(True)
buf = self.xml.get_widget('msg_textview').get_buffer()
msg = model[iter][1]
buf.set_text(msg)
def on_new_msg_button_clicked(self, widget, data = None):
model = self.msg_tree.get_model()
iter = model.append()
model.set(iter, 0, _('status message title'), 1, _('status message text'))
self.msg_tree.set_cursor(model.get_path(iter))
def on_delete_msg_button_clicked(self, widget, data = None):
(model, iter) = self.msg_tree.get_selection().get_selected()
if not iter:
return
buf = self.xml.get_widget('msg_textview').get_buffer()
model.remove(iter)
buf.set_text('')
self.xml.get_widget('delete_msg_button').set_sensitive(False)
def on_msg_textview_changed(self, widget, data = None):
(model, iter) = self.msg_tree.get_selection().get_selected()
if not iter:
return
buf = self.xml.get_widget('msg_textview').get_buffer()
first_iter, end_iter = buf.get_bounds()
name = model.get_value(iter, 0)
model.set_value(iter, 1, buf.get_text(first_iter, end_iter))
def on_msg_treeview_key_press_event(self, widget, event):
if event.keyval == gtk.keysyms.Delete:
self.on_delete_msg_button_clicked(widget)
def sound_toggled_cb(self, cell, path):
model = self.sound_tree.get_model()
model[path][0] = not model[path][0]
def fill_sound_treeview(self):
model = self.sound_tree.get_model()
model.clear()
# NOTE: sounds_ui_names MUST have all items of
# sounds = gajim.config.get_per('soundevents') as keys
sounds_dict = {
'first_message_received': _('First Message Received'),
'next_message_received': _('Next Message Received'),
'contact_connected': _('Contact Connected'),
'contact_disconnected': _('Contact Disconnected'),
'message_sent': _('Message Sent'),
'muc_message_highlight': _('Group Chat Message Highlight'),
'muc_message_received': _('Group Chat Message Received')
}
# In case of a GMail account we provide a sound notification option
for account in gajim.config.get_per('accounts'):
jid = gajim.get_jid_from_account(account)
if gajim.get_server_from_jid(jid) in gajim.gmail_domains:
sounds_dict['gmail_received'] = _('GMail Email Received')
break
for sound_event_config_name, sound_ui_name in sounds_dict.items():
enabled = gajim.config.get_per('soundevents',
sound_event_config_name, 'enabled')
path = gajim.config.get_per('soundevents',
sound_event_config_name, 'path')
model.append((enabled, sound_ui_name, path, sound_event_config_name))
def on_treeview_sounds_cursor_changed(self, widget, data = None):
(model, iter) = self.sound_tree.get_selection().get_selected()
sounds_entry = self.xml.get_widget('sounds_entry')
if not iter:
sounds_entry.set_text('')
return
path_to_snd_file = model[iter][2]
sounds_entry.set_text(path_to_snd_file)
def on_browse_for_sounds_button_clicked(self, widget, data = None):
(model, iter) = self.sound_tree.get_selection().get_selected()
if not iter:
return
def on_ok(widget, path_to_snd_file):
self.dialog.destroy()
model, iter = self.sound_tree.get_selection().get_selected()
if not path_to_snd_file:
model[iter][2] = ''
self.xml.get_widget('sounds_entry').set_text('')
model[iter][0] = False
return
directory = os.path.dirname(path_to_snd_file)
gajim.config.set('last_sounds_dir', directory)
self.xml.get_widget('sounds_entry').set_text(path_to_snd_file)
model[iter][2] = path_to_snd_file # set new path to sounds_model
model[iter][0] = True # set the sound to enabled
def on_cancel(widget):
self.dialog.destroy()
model, iter = self.sound_tree.get_selection().get_selected()
model[iter][2] = ''
model[iter][0] = False
path_to_snd_file = model[iter][2].decode('utf-8')
path_to_snd_file = os.path.join(os.getcwd(), path_to_snd_file)
self.dialog = dialogs.SoundChooserDialog(path_to_snd_file, on_ok,
on_cancel)
def on_sounds_entry_changed(self, widget):
path_to_snd_file = widget.get_text()
model, iter = self.sound_tree.get_selection().get_selected()
model[iter][2] = path_to_snd_file # set new path to sounds_model
def on_play_button_clicked(self, widget):
model, iter = self.sound_tree.get_selection().get_selected()
if not iter:
return
snd_event_config_name = model[iter][3]
helpers.play_sound(snd_event_config_name)
def on_open_advanced_editor_button_clicked(self, widget, data = None):
if gajim.interface.instances.has_key('advanced_config'):
gajim.interface.instances['advanced_config'].window.present()
else:
gajim.interface.instances['advanced_config'] = \
dialogs.AdvancedConfigurationWindow()
def set_status_msg_from_current_music_track_checkbutton_toggled(self,
widget):
self.on_checkbutton_toggled(widget,
'set_status_msg_from_current_music_track')
gajim.interface.roster.enable_syncing_status_msg_from_current_music_track(
widget.get_active())
#---------- AccountModificationWindow class -------------#
class AccountModificationWindow:
'''Class for account informations'''
def on_account_modification_window_destroy(self, widget):
'''close window'''
if gajim.interface.instances.has_key(self.account):
if gajim.interface.instances[self.account].has_key(
'account_modification'):
del gajim.interface.instances[self.account]['account_modification']
return
if gajim.interface.instances.has_key('account_modification'):
del gajim.interface.instances['account_modification']
def on_cancel_button_clicked(self, widget):
self.window.destroy()
def __init__(self, account):
self.xml = gtkgui_helpers.get_glade('account_modification_window.glade')
self.window = self.xml.get_widget('account_modification_window')
self.window.set_transient_for(gajim.interface.roster.window)
self.account = account
# init proxy list
self.update_proxy_list()
self.xml.signal_autoconnect(self)
self.init_account()
self.xml.get_widget('save_button').grab_focus()
self.window.show_all()
def on_checkbutton_toggled(self, widget, widgets):
'''set or unset sensitivity of widgets when widget is toggled'''
for w in widgets:
w.set_sensitive(widget.get_active())
def init_account_gpg(self):
keyid = gajim.config.get_per('accounts', self.account, 'keyid')
keyname = gajim.config.get_per('accounts', self.account, 'keyname')
savegpgpass = gajim.config.get_per('accounts', self.account,
'savegpgpass')
if not keyid or not gajim.config.get('usegpg'):
return
self.xml.get_widget('gpg_key_label').set_text(keyid)
self.xml.get_widget('gpg_name_label').set_text(keyname)
gpg_save_password_checkbutton = \
self.xml.get_widget('gpg_save_password_checkbutton')
gpg_save_password_checkbutton.set_sensitive(True)
gpg_save_password_checkbutton.set_active(savegpgpass)
if savegpgpass:
entry = self.xml.get_widget('gpg_password_entry')
entry.set_sensitive(True)
gpgpassword = gajim.config.get_per('accounts',
self.account, 'gpgpassword')
entry.set_text(gpgpassword)
def update_proxy_list(self):
if self.account:
our_proxy = gajim.config.get_per('accounts', self.account, 'proxy')
else:
our_proxy = ''
if not our_proxy:
our_proxy = _('None')
self.proxy_combobox = self.xml.get_widget('proxies_combobox')
model = gtk.ListStore(str)
self.proxy_combobox.set_model(model)
l = gajim.config.get_per('proxies')
l.insert(0, _('None'))
for i in xrange(len(l)):
model.append([l[i]])
if our_proxy == l[i]:
self.proxy_combobox.set_active(i)
def init_account(self):
'''Initialize window with defaults values'''
self.xml.get_widget('name_entry').set_text(self.account)
jid = gajim.config.get_per('accounts', self.account, 'name') \
+ '@' + gajim.config.get_per('accounts',
self.account, 'hostname')
self.xml.get_widget('jid_entry').set_text(jid)
self.xml.get_widget('save_password_checkbutton').set_active(
gajim.config.get_per('accounts', self.account, 'savepass'))
if gajim.config.get_per('accounts', self.account, 'savepass'):
passstr = passwords.get_password(self.account) or ''
password_entry = self.xml.get_widget('password_entry')
password_entry.set_sensitive(True)
password_entry.set_text(passstr)
self.xml.get_widget('resource_entry').set_text(gajim.config.get_per(
'accounts', self.account, 'resource'))
self.xml.get_widget('adjust_priority_with_status_checkbutton').set_active(
gajim.config.get_per('accounts', self.account,
'adjust_priority_with_status'))
spinbutton = self.xml.get_widget('priority_spinbutton')
if gajim.config.get('enable_negative_priority'):
spinbutton.set_range(-128, 127)
spinbutton.set_value(gajim.config.get_per('accounts', self.account,
'priority'))
usessl = gajim.config.get_per('accounts', self.account, 'usessl')
self.xml.get_widget('use_ssl_checkbutton').set_active(usessl)
self.xml.get_widget('send_keepalive_checkbutton').set_active(
gajim.config.get_per('accounts', self.account,
'keep_alives_enabled'))
use_custom_host = gajim.config.get_per('accounts', self.account,
'use_custom_host')
self.xml.get_widget('custom_host_port_checkbutton').set_active(
use_custom_host)
custom_host = gajim.config.get_per('accounts', self.account,
'custom_host')
if not custom_host:
custom_host = gajim.config.get_per('accounts',
self.account, 'hostname')
self.xml.get_widget('custom_host_entry').set_text(custom_host)
custom_port = gajim.config.get_per('accounts', self.account,
'custom_port')
if not custom_port:
custom_port = 5222
self.xml.get_widget('custom_port_entry').set_text(unicode(custom_port))
gpg_key_label = self.xml.get_widget('gpg_key_label')
if gajim.config.get('usegpg'):
self.init_account_gpg()
else:
gpg_key_label.set_text(_('OpenPGP is not usable in this computer'))
self.xml.get_widget('gpg_choose_button').set_sensitive(False)
self.xml.get_widget('autoconnect_checkbutton').set_active(gajim.config.\
get_per('accounts', self.account, 'autoconnect'))
self.xml.get_widget('autoreconnect_checkbutton').set_active(gajim.config.\
get_per('accounts', self.account, 'autoreconnect'))
self.xml.get_widget('sync_with_global_status_checkbutton').set_active(
gajim.config.get_per('accounts', self.account,
'sync_with_global_status'))
self.xml.get_widget('autoconnect_checkbutton').set_active(
gajim.config.get_per('accounts', self.account, 'autoconnect'))
self.xml.get_widget('use_ft_proxies_checkbutton').set_active(
gajim.config.get_per('accounts', self.account, 'use_ft_proxies'))
list_no_log_for = gajim.config.get_per('accounts', self.account,
'no_log_for').split()
if self.account in list_no_log_for:
self.xml.get_widget('log_history_checkbutton').set_active(0)
def option_changed(self, config, opt):
if gajim.config.get_per('accounts', self.account, opt) != config[opt]:
return True
return False
def options_changed_need_relogin(self, config, options):
'''accepts configuration and options
(tupple of strings of the name of options changed)
and returns True or False depending on if at least one of the options
need relogin to server to apply'''
for option in options:
if self.option_changed(config, option):
return True
return False
def on_adjust_priority_with_status_checkbutton_toggled(self, widget):
self.xml.get_widget('priority_spinbutton').set_sensitive(
not widget.get_active())
def on_save_button_clicked(self, widget):
'''When save button is clicked: Save information in config file'''
config = {}
name = self.xml.get_widget('name_entry').get_text().decode('utf-8')
if gajim.connections.has_key(self.account):
if name != self.account:
if gajim.connections[self.account].connected != 0:
dialogs.ErrorDialog(
_('You are currently connected to the server'),
_('To change the account name, you must be disconnected.'))
return
if len(gajim.events.get_events(self.account)):
dialogs.ErrorDialog(_('Unread events'),
_('To change the account name, you must read all pending '
'events.'))
return
if name in gajim.connections:
dialogs.ErrorDialog(_('Account Name Already Used'),
_('This name is already used by another of your accounts. '
'Please choose another name.'))
return
if (name == ''):
dialogs.ErrorDialog(_('Invalid account name'),
_('Account name cannot be empty.'))
return
if name.find(' ') != -1:
dialogs.ErrorDialog(_('Invalid account name'),
_('Account name cannot contain spaces.'))
return
jid = self.xml.get_widget('jid_entry').get_text().decode('utf-8')
# check if jid is conform to RFC and stringprep it
try:
jid = helpers.parse_jid(jid)
except helpers.InvalidFormat, s:
pritext = _('Invalid Jabber ID')
dialogs.ErrorDialog(pritext, str(s))
return
n, hn = jid.split('@', 1)
if not n:
pritext = _('Invalid Jabber ID')
sectext = _('A Jabber ID must be in the form "user@servername".')
dialogs.ErrorDialog(pritext, sectext)
return
resource = self.xml.get_widget('resource_entry').get_text().decode(
'utf-8')
try:
resource = helpers.parse_resource(resource)
except helpers.InvalidFormat, s:
pritext = _('Invalid Jabber ID')
dialogs.ErrorDialog(pritext, (s))
return
config['savepass'] = self.xml.get_widget(
'save_password_checkbutton').get_active()
config['password'] = self.xml.get_widget('password_entry').get_text().\
decode('utf-8')
config['resource'] = resource
config['adjust_priority_with_status'] = self.xml.get_widget(
'adjust_priority_with_status_checkbutton').get_active()
config['priority'] = self.xml.get_widget('priority_spinbutton').\
get_value_as_int()
config['autoconnect'] = self.xml.get_widget('autoconnect_checkbutton').\
get_active()
config['autoreconnect'] = self.xml.get_widget(
'autoreconnect_checkbutton').get_active()
if self.account:
list_no_log_for = gajim.config.get_per('accounts', self.account,
'no_log_for').split()
else:
list_no_log_for = []
if self.account in list_no_log_for:
list_no_log_for.remove(self.account)
if not self.xml.get_widget('log_history_checkbutton').get_active():
list_no_log_for.append(name)
config['no_log_for'] = ' '.join(list_no_log_for)
config['sync_with_global_status'] = self.xml.get_widget(
'sync_with_global_status_checkbutton').get_active()
config['use_ft_proxies'] = self.xml.get_widget(
'use_ft_proxies_checkbutton').get_active()
active = self.proxy_combobox.get_active()
proxy = self.proxy_combobox.get_model()[active][0].decode('utf-8')
if proxy == _('None'):
proxy = ''
config['proxy'] = proxy
config['usessl'] = self.xml.get_widget('use_ssl_checkbutton').get_active()
config['name'] = n
config['hostname'] = hn
config['use_custom_host'] = self.xml.get_widget(
'custom_host_port_checkbutton').get_active()
custom_port = self.xml.get_widget('custom_port_entry').get_text()
try:
custom_port = int(custom_port)
except:
dialogs.ErrorDialog(_('Invalid entry'),
_('Custom port must be a port number.'))
return
config['custom_port'] = custom_port
config['custom_host'] = self.xml.get_widget(
'custom_host_entry').get_text().decode('utf-8')
# update in case the name was changed to local account's name
config['is_zeroconf'] = False
config['keyname'] = self.xml.get_widget('gpg_name_label').get_text().\
decode('utf-8')
if config['keyname'] == '': # no key selected
config['keyid'] = ''
config['savegpgpass'] = False
config['gpgpassword'] = ''
else:
config['keyid'] = self.xml.get_widget('gpg_key_label').get_text().\
decode('utf-8')
config['savegpgpass'] = self.xml.get_widget(
'gpg_save_password_checkbutton').get_active()
config['gpgpassword'] = self.xml.get_widget('gpg_password_entry'
).get_text().decode('utf-8')
# if we modify the name of the account
if name != self.account:
# update variables
gajim.interface.instances[name] = gajim.interface.instances[
self.account]
gajim.nicks[name] = gajim.nicks[self.account]
gajim.block_signed_in_notifications[name] = \
gajim.block_signed_in_notifications[self.account]
gajim.groups[name] = gajim.groups[self.account]
gajim.gc_connected[name] = gajim.gc_connected[self.account]
gajim.automatic_rooms[name] = gajim.automatic_rooms[self.account]
gajim.newly_added[name] = gajim.newly_added[self.account]
gajim.to_be_removed[name] = gajim.to_be_removed[self.account]
gajim.sleeper_state[name] = gajim.sleeper_state[self.account]
gajim.encrypted_chats[name] = gajim.encrypted_chats[self.account]
gajim.last_message_time[name] = \
gajim.last_message_time[self.account]
gajim.status_before_autoaway[name] = \
gajim.status_before_autoaway[self.account]
gajim.transport_avatar[name] = gajim.transport_avatar[self.account]
gajim.contacts.change_account_name(self.account, name)
gajim.events.change_account_name(self.account, name)
# change account variable for chat / gc controls
gajim.interface.msg_win_mgr.change_account_name(self.account, name)
# upgrade account variable in opened windows
for kind in ('infos', 'disco', 'gc_config', 'search'):
for j in gajim.interface.instances[name][kind]:
gajim.interface.instances[name][kind][j].account = name
# ServiceCache object keep old property account
if hasattr(gajim.connections[self.account], 'services_cache'):
gajim.connections[self.account].services_cache.account = name
del gajim.interface.instances[self.account]
del gajim.nicks[self.account]
del gajim.block_signed_in_notifications[self.account]
del gajim.groups[self.account]
del gajim.gc_connected[self.account]
del gajim.automatic_rooms[self.account]
del gajim.newly_added[self.account]
del gajim.to_be_removed[self.account]
del gajim.sleeper_state[self.account]
del gajim.encrypted_chats[self.account]
del gajim.last_message_time[self.account]
del gajim.status_before_autoaway[self.account]
del gajim.transport_avatar[self.account]
gajim.connections[self.account].name = name
gajim.connections[name] = gajim.connections[self.account]
del gajim.connections[self.account]
gajim.config.del_per('accounts', self.account)
gajim.config.add_per('accounts', name)
self.account = name
resend_presence = False
if gajim.connections[self.account].connected == 0: # we're disconnected
relogin_needed = False
else: # we're connected to the account we want to apply changes
# check if relogin is needed
relogin_needed = False
if self.options_changed_need_relogin(config,
('resource', 'proxy', 'usessl', 'keyname',
'use_custom_host', 'custom_host')):
relogin_needed = True
elif config['use_custom_host'] and (self.option_changed(config,
'custom_host') or self.option_changed(config, 'custom_port')):
relogin_needed = True
if self.option_changed(config, 'use_ft_proxies') and \
config['use_ft_proxies']:
gajim.connections[self.account].discover_ft_proxies()
if self.option_changed(config, 'priority') or self.option_changed(
config, 'adjust_priority_with_status'):
resend_presence = True
for opt in config:
gajim.config.set_per('accounts', name, opt, config[opt])
if config['savepass']:
passwords.save_password(name, config['password'])
else:
passwords.save_password(name, '')
# refresh accounts window
if gajim.interface.instances.has_key('accounts'):
gajim.interface.instances['accounts'].init_accounts()
# refresh roster
gajim.interface.roster.draw_roster()
gajim.interface.save_config()
self.window.destroy()
if relogin_needed:
def login(account, show_before, status_before):
''' login with previous status'''
# first make sure connection is really closed,
# 0.5 may not be enough
gajim.connections[account].disconnect(True)
gajim.interface.roster.send_status(account, show_before,
status_before)
def relog(widget):
self.dialog.destroy()
show_before = gajim.SHOW_LIST[gajim.connections[self.account].\
connected]
status_before = gajim.connections[self.account].status
gajim.interface.roster.send_status(self.account, 'offline',
_('Be right back.'))
gobject.timeout_add(500, login, self.account, show_before,
status_before)
def resend(widget):
self.resend_presence()
on_no = None
if resend_presence:
on_no = resend
self.dialog = dialogs.YesNoDialog(_('Relogin now?'),
_('If you want all the changes to apply instantly, '
'you must relogin.'), on_response_yes = relog,
on_response_no = on_no)
elif resend_presence:
self.resend_presence()
def resend_presence(self):
show = gajim.SHOW_LIST[gajim.connections[self.account].connected]
status = gajim.connections[self.account].status
gajim.connections[self.account].change_status(show, status)
def on_change_password_button_clicked(self, widget):
try:
dialog = dialogs.ChangePasswordDialog(self.account)
except GajimGeneralException:
#if we showed ErrorDialog, there will not be dialog instance
return
new_password = dialog.run()
if new_password != -1:
gajim.connections[self.account].change_password(new_password)
if self.xml.get_widget('save_password_checkbutton').get_active():
self.xml.get_widget('password_entry').set_text(new_password)
def on_edit_details_button_clicked(self, widget):
if not gajim.interface.instances.has_key(self.account):
dialogs.ErrorDialog(_('No such account available'),
_('You must create your account before editing your personal '
'information.'))
return
# show error dialog if account is newly created (not in gajim.connections)
if not gajim.connections.has_key(self.account) or \
gajim.connections[self.account].connected < 2:
dialogs.ErrorDialog(_('You are not connected to the server'),
_('Without a connection, you can not edit your personal information.'))
return
if not gajim.connections[self.account].vcard_supported:
dialogs.ErrorDialog(_("Your server doesn't support Vcard"),
_("Your server can't save your personal information."))
return
gajim.interface.edit_own_details(self.account)
def on_manage_proxies_button_clicked(self, widget):
if gajim.interface.instances.has_key('manage_proxies'):
gajim.interface.instances['manage_proxies'].window.present()
else:
gajim.interface.instances['manage_proxies'] = \
ManageProxiesWindow()
def on_synchronise_contacts_button_clicked(self, widget):
try:
dialog = dialogs.SynchroniseSelectAccountDialog(self.account)
except GajimGeneralException:
# If we showed ErrorDialog, there will not be dialog instance
return
def on_gpg_choose_button_clicked(self, widget, data = None):
if gajim.connections.has_key(self.account):
secret_keys = gajim.connections[self.account].ask_gpg_secrete_keys()
# self.account is None and/or gajim.connections is {}
else:
from common import GnuPG
if GnuPG.USE_GPG:
secret_keys = GnuPG.GnuPG().get_secret_keys()
else:
secret_keys = []
if not secret_keys:
dialogs.ErrorDialog(_('Failed to get secret keys'),
_('There was a problem retrieving your OpenPGP secret keys.'))
return
secret_keys[_('None')] = _('None')
instance = dialogs.ChooseGPGKeyDialog(_('OpenPGP Key Selection'),
_('Choose your OpenPGP key'), secret_keys)
keyID = instance.run()
if keyID is None:
return
checkbutton = self.xml.get_widget('gpg_save_password_checkbutton')
gpg_key_label = self.xml.get_widget('gpg_key_label')
gpg_name_label = self.xml.get_widget('gpg_name_label')
if keyID[0] == _('None'):
gpg_key_label.set_text(_('No key selected'))
gpg_name_label.set_text('')
checkbutton.set_sensitive(False)
self.xml.get_widget('gpg_password_entry').set_sensitive(False)
else:
gpg_key_label.set_text(keyID[0])
gpg_name_label.set_text(keyID[1])
checkbutton.set_sensitive(True)
checkbutton.set_active(False)
self.xml.get_widget('gpg_password_entry').set_text('')
def on_checkbutton_toggled_and_clear(self, widget, widgets):
self.on_checkbutton_toggled(widget, widgets)
for w in widgets:
if not widget.get_active():
w.set_text('')
def on_use_ssl_checkbutton_toggled(self, widget):
isactive = widget.get_active()
if isactive:
self.xml.get_widget('custom_port_entry').set_text('5223')
else:
self.xml.get_widget('custom_port_entry').set_text('5222')
def on_send_keepalive_checkbutton_toggled(self, widget):
isactive = widget.get_active()
gajim.config.set_per('accounts', self.account,
'keep_alives_enabled', isactive)
def on_custom_host_port_checkbutton_toggled(self, widget):
isactive = widget.get_active()
self.xml.get_widget('custom_host_port_hbox').set_sensitive(isactive)
def on_gpg_save_password_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled_and_clear(widget, [
self.xml.get_widget('gpg_password_entry')])
def on_save_password_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled_and_clear(widget,
[self.xml.get_widget('password_entry')])
self.xml.get_widget('password_entry').grab_focus()
#---------- ManageProxiesWindow class -------------#
class ManageProxiesWindow:
def __init__(self):
self.xml = gtkgui_helpers.get_glade('manage_proxies_window.glade')
self.window = self.xml.get_widget('manage_proxies_window')
self.window.set_transient_for(gajim.interface.roster.window)
self.proxies_treeview = self.xml.get_widget('proxies_treeview')
self.proxyname_entry = self.xml.get_widget('proxyname_entry')
self.proxytype_combobox = self.xml.get_widget('proxytype_combobox')
self.init_list()
self.xml.signal_autoconnect(self)
self.window.show_all()
def fill_proxies_treeview(self):
model = self.proxies_treeview.get_model()
model.clear()
iter = model.append()
model.set(iter, 0, _('None'))
for p in gajim.config.get_per('proxies'):
iter = model.append()
model.set(iter, 0, p)
def init_list(self):
self.xml.get_widget('remove_proxy_button').set_sensitive(False)
self.proxytype_combobox.set_sensitive(False)
self.xml.get_widget('proxy_table').set_sensitive(False)
model = gtk.ListStore(str)
self.proxies_treeview.set_model(model)
col = gtk.TreeViewColumn('Proxies')
self.proxies_treeview.append_column(col)
renderer = gtk.CellRendererText()
col.pack_start(renderer, True)
col.set_attributes(renderer, text = 0)
self.fill_proxies_treeview()
self.xml.get_widget('proxytype_combobox').set_active(0)
def on_manage_proxies_window_destroy(self, widget):
for account in gajim.connections:
if gajim.interface.instances[account].has_key('account_modification'):
gajim.interface.instances[account]['account_modification'].\
update_proxy_list()
if gajim.interface.instances.has_key('account_modification'):
gajim.interface.instances['account_modification'].update_proxy_list()
del gajim.interface.instances['manage_proxies']
def on_add_proxy_button_clicked(self, widget):
model = self.proxies_treeview.get_model()
proxies = gajim.config.get_per('proxies')
i = 1
while ('proxy' + unicode(i)) in proxies:
i += 1
iter = model.append()
model.set(iter, 0, 'proxy' + unicode(i))
gajim.config.add_per('proxies', 'proxy' + unicode(i))
def on_remove_proxy_button_clicked(self, widget):
(model, iter) = self.proxies_treeview.get_selection().get_selected()
if not iter:
return
proxy = model[iter][0].decode('utf-8')
model.remove(iter)
gajim.config.del_per('proxies', proxy)
self.xml.get_widget('remove_proxy_button').set_sensitive(False)
def on_close_button_clicked(self, widget):
self.window.destroy()
def on_useauth_checkbutton_toggled(self, widget):
act = widget.get_active()
self.xml.get_widget('proxyuser_entry').set_sensitive(act)
self.xml.get_widget('proxypass_entry').set_sensitive(act)
def on_proxies_treeview_cursor_changed(self, widget):
#FIXME: check if off proxy settings are correct (see
# http://trac.gajim.org/changeset/1921#file2 line 1221
(model, iter) = widget.get_selection().get_selected()
if not iter:
return
proxy = model[iter][0]
self.xml.get_widget('proxyname_entry').set_text(proxy)
proxyhost_entry = self.xml.get_widget('proxyhost_entry')
proxyport_entry = self.xml.get_widget('proxyport_entry')
proxyuser_entry = self.xml.get_widget('proxyuser_entry')
proxypass_entry = self.xml.get_widget('proxypass_entry')
useauth_checkbutton = self.xml.get_widget('useauth_checkbutton')
proxyhost_entry.set_text('')
proxyport_entry.set_text('')
proxyuser_entry.set_text('')
proxypass_entry.set_text('')
useauth_checkbutton.set_active(False)
self.on_useauth_checkbutton_toggled(useauth_checkbutton)
if proxy == _('None'): # special proxy None
self.proxyname_entry.set_editable(False)
self.xml.get_widget('remove_proxy_button').set_sensitive(False)
self.xml.get_widget('proxytype_combobox').set_sensitive(False)
self.xml.get_widget('proxy_table').set_sensitive(False)
else:
self.proxyname_entry.set_editable(True)
self.xml.get_widget('remove_proxy_button').set_sensitive(True)
self.xml.get_widget('proxytype_combobox').set_sensitive(True)
self.xml.get_widget('proxy_table').set_sensitive(True)
proxyhost_entry.set_text(gajim.config.get_per('proxies', proxy,
'host'))
proxyport_entry.set_text(unicode(gajim.config.get_per('proxies',
proxy, 'port')))
proxyuser_entry.set_text(gajim.config.get_per('proxies', proxy,
'user'))
proxypass_entry.set_text(gajim.config.get_per('proxies', proxy,
'pass'))
proxytype = gajim.config.get_per('proxies', proxy, 'type')
types = ['http', 'socks5']
self.proxytype_combobox.set_active(types.index(proxytype))
if gajim.config.get_per('proxies', proxy, 'user'):
useauth_checkbutton.set_active(True)
def on_proxies_treeview_key_press_event(self, widget, event):
if event.keyval == gtk.keysyms.Delete:
self.on_remove_proxy_button_clicked(widget)
def on_proxyname_entry_changed(self, widget):
(model, iter) = self.proxies_treeview.get_selection().get_selected()
if not iter:
return
old_name = model.get_value(iter, 0).decode('utf-8')
new_name = widget.get_text().decode('utf-8')
if new_name == '':
return
if new_name == old_name:
return
config = gajim.config.get_per('proxies', old_name)
gajim.config.del_per('proxies', old_name)
gajim.config.add_per('proxies', new_name)
for option in config:
gajim.config.set_per('proxies', new_name, option,
config[option][common.config.OPT_VAL])
model.set_value(iter, 0, new_name)
def on_proxytype_combobox_changed(self, widget):
types = ['http', 'socks5']
type_ = self.proxytype_combobox.get_active()
proxy = self.proxyname_entry.get_text().decode('utf-8')
gajim.config.set_per('proxies', proxy, 'type', types[type_])
def on_proxyhost_entry_changed(self, widget):
value = widget.get_text().decode('utf-8')
proxy = self.proxyname_entry.get_text().decode('utf-8')
gajim.config.set_per('proxies', proxy, 'host', value)
def on_proxyport_entry_changed(self, widget):
value = widget.get_text().decode('utf-8')
proxy = self.proxyname_entry.get_text().decode('utf-8')
gajim.config.set_per('proxies', proxy, 'port', value)
def on_proxyuser_entry_changed(self, widget):
value = widget.get_text().decode('utf-8')
proxy = self.proxyname_entry.get_text().decode('utf-8')
gajim.config.set_per('proxies', proxy, 'user', value)
def on_proxypass_entry_changed(self, widget):
value = widget.get_text().decode('utf-8')
proxy = self.proxyname_entry.get_text().decode('utf-8')
gajim.config.set_per('proxies', proxy, 'pass', value)
#---------- AccountsWindow class -------------#
class AccountsWindow:
'''Class for accounts window: list of accounts'''
def on_accounts_window_destroy(self, widget):
del gajim.interface.instances['accounts']
def on_close_button_clicked(self, widget):
self.window.destroy()
def __init__(self):
self.xml = gtkgui_helpers.get_glade('accounts_window.glade')
self.window = self.xml.get_widget('accounts_window')
self.window.set_transient_for(gajim.interface.roster.window)
self.accounts_treeview = self.xml.get_widget('accounts_treeview')
self.modify_button = self.xml.get_widget('modify_button')
self.remove_button = self.xml.get_widget('remove_button')
model = gtk.ListStore(str, str, bool)
self.accounts_treeview.set_model(model)
#columns
renderer = gtk.CellRendererText()
self.accounts_treeview.insert_column_with_attributes(-1,
_('Name'), renderer, text = 0)
renderer = gtk.CellRendererText()
self.accounts_treeview.insert_column_with_attributes(-1,
_('Server'), renderer, text = 1)
self.xml.signal_autoconnect(self)
self.init_accounts()
self.window.show_all()
#Merge accounts
st = gajim.config.get('mergeaccounts')
self.xml.get_widget('merge_checkbutton').set_active(st)
import os
avahi_error = False
try:
import avahi
except ImportError:
avahi_error = True
# enable zeroconf
st = gajim.config.get('enable_zeroconf')
w = self.xml.get_widget('enable_zeroconf_checkbutton')
w.set_active(st)
if os.name == 'nt' or (avahi_error and not w.get_active()):
w.set_sensitive(False)
self.zeroconf_toggled_id = w.connect('toggled',
self.on_enable_zeroconf_checkbutton_toggled)
def on_accounts_window_key_press_event(self, widget, event):
if event.keyval == gtk.keysyms.Escape:
self.window.destroy()
def init_accounts(self):
'''initialize listStore with existing accounts'''
self.modify_button.set_sensitive(False)
self.remove_button.set_sensitive(False)
model = self.accounts_treeview.get_model()
model.clear()
for account in gajim.connections:
iter = model.append()
model.set(iter, 0, account, 1, gajim.get_hostname_from_account(
account))
def on_accounts_treeview_cursor_changed(self, widget):
'''Activate delete and modify buttons when a row is selected'''
self.modify_button.set_sensitive(True)
self.remove_button.set_sensitive(True)
def on_new_button_clicked(self, widget):
'''When new button is clicked: open an account information window'''
if gajim.interface.instances.has_key('account_creation_wizard'):
gajim.interface.instances['account_creation_wizard'].window.present()
else:
gajim.interface.instances['account_creation_wizard'] = \
AccountCreationWizardWindow()
def on_remove_button_clicked(self, widget):
'''When delete button is clicked:
Remove an account from the listStore and from the config file'''
sel = self.accounts_treeview.get_selection()
(model, iter) = sel.get_selected()
if not iter:
return
account = model.get_value(iter, 0).decode('utf-8')
if len(gajim.events.get_events(account)):
dialogs.ErrorDialog(_('Unread events'),
_('Read all pending events before removing this account.'))
return
if gajim.config.get_per('accounts', account, 'is_zeroconf'):
w = self.xml.get_widget('enable_zeroconf_checkbutton')
w.set_active(False)
return
else:
if gajim.interface.instances[account].has_key('remove_account'):
gajim.interface.instances[account]['remove_account'].window.present(
)
else:
gajim.interface.instances[account]['remove_account'] = \
RemoveAccountWindow(account)
win_opened = False
if gajim.interface.msg_win_mgr.get_controls(acct = account):
win_opened = True
else:
for key in gajim.interface.instances[account]:
if gajim.interface.instances[account][key] and key != \
'remove_account':
win_opened = True
break
# Detect if we have opened windows for this account
self.dialog = None
def remove(widget, account):
if self.dialog:
self.dialog.destroy()
if gajim.interface.instances[account].has_key('remove_account'):
gajim.interface.instances[account]['remove_account'].window.\
present()
else:
gajim.interface.instances[account]['remove_account'] = \
RemoveAccountWindow(account)
if win_opened:
self.dialog = dialogs.ConfirmationDialog(
_('You have opened chat in account %s') % account,
_('All chat and groupchat windows will be closed. Do you want to '
'continue?'),
on_response_ok = (remove, account))
else:
remove(widget, account)
def on_modify_button_clicked(self, widget):
'''When modify button is clicked:
open/show the account modification window for this account'''
sel = self.accounts_treeview.get_selection()
(model, iter) = sel.get_selected()
if not iter:
return
account = model[iter][0].decode('utf-8')
self.show_modification_window(account)
def on_accounts_treeview_row_activated(self, widget, path, column):
model = widget.get_model()
account = model[path][0].decode('utf-8')
self.show_modification_window(account)
def show_modification_window(self, account):
if gajim.config.get_per('accounts', account, 'is_zeroconf'):
if gajim.interface.instances.has_key('zeroconf_properties'):
gajim.interface.instances['zeroconf_properties'].window.present()
else:
gajim.interface.instances['zeroconf_properties'] = \
ZeroconfPropertiesWindow()
else:
if gajim.interface.instances[account].has_key('account_modification'):
gajim.interface.instances[account]['account_modification'].window.\
present()
else:
gajim.interface.instances[account]['account_modification'] = \
AccountModificationWindow(account)
def on_checkbutton_toggled(self, widget, config_name,
change_sensitivity_widgets = None):
gajim.config.set(config_name, widget.get_active())
if change_sensitivity_widgets:
for w in change_sensitivity_widgets:
w.set_sensitive(widget.get_active())
gajim.interface.save_config()
def on_merge_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'mergeaccounts')
if len(gajim.connections) >= 2: # Do not merge accounts if only one exists
gajim.interface.roster.regroup = gajim.config.get('mergeaccounts')
else:
gajim.interface.roster.regroup = False
gajim.interface.roster.draw_roster()
def on_enable_zeroconf_checkbutton_toggled(self, widget):
# don't do anything if there is an account with the local name but is a
# normal account
if gajim.connections.has_key(gajim.ZEROCONF_ACC_NAME) and not \
gajim.connections[gajim.ZEROCONF_ACC_NAME].is_zeroconf:
gajim.connections[gajim.ZEROCONF_ACC_NAME].dispatch('ERROR',
(_('Account Local already exists.'),
_('Please rename or remove it before enabling link-local messaging'
'.')))
widget.disconnect(self.zeroconf_toggled_id)
widget.set_active(False)
self.zeroconf_toggled_id = widget.connect('toggled',
self.on_enable_zeroconf_checkbutton_toggled)
return
if gajim.config.get('enable_zeroconf'):
#disable
gajim.interface.roster.close_all(gajim.ZEROCONF_ACC_NAME)
gajim.connections[gajim.ZEROCONF_ACC_NAME].disable_account()
del gajim.connections[gajim.ZEROCONF_ACC_NAME]
gajim.interface.save_config()
del gajim.interface.instances[gajim.ZEROCONF_ACC_NAME]
del gajim.nicks[gajim.ZEROCONF_ACC_NAME]
del gajim.block_signed_in_notifications[gajim.ZEROCONF_ACC_NAME]
del gajim.groups[gajim.ZEROCONF_ACC_NAME]
gajim.contacts.remove_account(gajim.ZEROCONF_ACC_NAME)
del gajim.gc_connected[gajim.ZEROCONF_ACC_NAME]
del gajim.automatic_rooms[gajim.ZEROCONF_ACC_NAME]
del gajim.to_be_removed[gajim.ZEROCONF_ACC_NAME]
del gajim.newly_added[gajim.ZEROCONF_ACC_NAME]
del gajim.sleeper_state[gajim.ZEROCONF_ACC_NAME]
del gajim.encrypted_chats[gajim.ZEROCONF_ACC_NAME]
del gajim.last_message_time[gajim.ZEROCONF_ACC_NAME]
del gajim.status_before_autoaway[gajim.ZEROCONF_ACC_NAME]
del gajim.transport_avatar[gajim.ZEROCONF_ACC_NAME]
if len(gajim.connections) >= 2:
# Do not merge accounts if only one exists
gajim.interface.roster.regroup = gajim.config.get('mergeaccounts')
else:
gajim.interface.roster.regroup = False
gajim.interface.roster.draw_roster()
gajim.interface.roster.actions_menu_needs_rebuild = True
if gajim.interface.instances.has_key('accounts'):
gajim.interface.instances['accounts'].init_accounts()
else:
# enable (will create new account if not present)
gajim.connections[gajim.ZEROCONF_ACC_NAME] = common.zeroconf.\
connection_zeroconf.ConnectionZeroconf(gajim.ZEROCONF_ACC_NAME)
# update variables
gajim.interface.instances[gajim.ZEROCONF_ACC_NAME] = {'infos': {},
'disco': {}, 'gc_config': {}, 'search': {}}
gajim.interface.minimized_controls[gajim.ZEROCONF_ACC_NAME] = {}
gajim.connections[gajim.ZEROCONF_ACC_NAME].connected = 0
gajim.groups[gajim.ZEROCONF_ACC_NAME] = {}
gajim.contacts.add_account(gajim.ZEROCONF_ACC_NAME)
gajim.gc_connected[gajim.ZEROCONF_ACC_NAME] = {}
gajim.automatic_rooms[gajim.ZEROCONF_ACC_NAME] = {}
gajim.newly_added[gajim.ZEROCONF_ACC_NAME] = []
gajim.to_be_removed[gajim.ZEROCONF_ACC_NAME] = []
gajim.nicks[gajim.ZEROCONF_ACC_NAME] = gajim.ZEROCONF_ACC_NAME
gajim.block_signed_in_notifications[gajim.ZEROCONF_ACC_NAME] = True
gajim.sleeper_state[gajim.ZEROCONF_ACC_NAME] = 'off'
gajim.encrypted_chats[gajim.ZEROCONF_ACC_NAME] = []
gajim.last_message_time[gajim.ZEROCONF_ACC_NAME] = {}
gajim.status_before_autoaway[gajim.ZEROCONF_ACC_NAME] = ''
gajim.transport_avatar[gajim.ZEROCONF_ACC_NAME] = {}
# refresh accounts window
if gajim.interface.instances.has_key('accounts'):
gajim.interface.instances['accounts'].init_accounts()
# refresh roster
if len(gajim.connections) >= 2:
# Do not merge accounts if only one exists
gajim.interface.roster.regroup = gajim.config.get('mergeaccounts')
else:
gajim.interface.roster.regroup = False
gajim.interface.roster.draw_roster()
gajim.interface.roster.actions_menu_needs_rebuild = True
gajim.interface.save_config()
gajim.connections[gajim.ZEROCONF_ACC_NAME].change_status('online', '')
self.on_checkbutton_toggled(widget, 'enable_zeroconf')
class FakeDataForm(gtk.Table, object):
'''Class for forms that are in XML format <entry1>value1</entry1>
infos in a table {entry1: value1, }'''
def __init__(self, infos):
gtk.Table.__init__(self)
self.infos = infos
self.entries = {}
self._draw_table()
def _draw_table(self):
'''Draw the table'''
nbrow = 0
if self.infos.has_key('instructions'):
nbrow = 1
self.resize(rows = nbrow, columns = 2)
label = gtk.Label(self.infos['instructions'])
self.attach(label, 0, 2, 0, 1, 0, 0, 0, 0)
for name in self.infos.keys():
if name in ('key', 'instructions', 'x', 'registered'):
continue
if not name:
continue
nbrow = nbrow + 1
self.resize(rows = nbrow, columns = 2)
label = gtk.Label(name.capitalize() + ':')
self.attach(label, 0, 1, nbrow - 1, nbrow, 0, 0, 0, 0)
entry = gtk.Entry()
entry.set_activates_default(True)
if self.infos[name]:
entry.set_text(self.infos[name])
if name == 'password':
entry.set_visibility(False)
self.attach(entry, 1, 2, nbrow - 1, nbrow, 0, 0, 0, 0)
self.entries[name] = entry
if nbrow == 1:
entry.grab_focus()
def get_infos(self):
for name in self.entries.keys():
self.infos[name] = self.entries[name].get_text().decode('utf-8')
return self.infos
class ServiceRegistrationWindow:
'''Class for Service registration window:
Window that appears when we want to subscribe to a service
if is_form we use dataforms_widget else we use service_registarion_window'''
def __init__(self, service, infos, account, is_form):
self.service = service
self.account = account
self.is_form = is_form
self.xml = gtkgui_helpers.get_glade('service_registration_window.glade')
self.window = self.xml.get_widget('service_registration_window')
self.window.set_transient_for(gajim.interface.roster.window)
if self.is_form:
dataform = dataforms.ExtendForm(node = infos)
self.data_form_widget = dataforms_widget.DataFormWidget(dataform)
if self.data_form_widget.title:
self.window.set_title('%s - Gajim' % self.data_form_widget.title)
table = self.xml.get_widget('table')
table.attach(self.data_form_widget, 0, 2, 0, 1)
else:
if infos.has_key('registered'):
self.window.set_title(_('Edit %s') % service)
else:
self.window.set_title(_('Register to %s') % service)
self.data_form_widget = FakeDataForm(infos)
table = self.xml.get_widget('table')
table.attach(self.data_form_widget, 0, 2, 0, 1)
self.xml.signal_autoconnect(self)
self.window.show_all()
def on_cancel_button_clicked(self, widget):
self.window.destroy()
def on_ok_button_clicked(self, widget):
# send registration info to the core
if self.is_form:
form = self.data_form_widget.data_form
gajim.connections[self.account].register_agent(self.service,
form, True) # True is for is_form
else:
infos = self.data_form_widget.get_infos()
if infos.has_key('instructions'):
del infos['instructions']
if infos.has_key('registered'):
del infos['registered']
gajim.connections[self.account].register_agent(self.service, infos)
self.window.destroy()
class GroupchatConfigWindow:
'''GroupchatConfigWindow class'''
def __init__(self, account, room_jid, form = None):
self.account = account
self.room_jid = room_jid
self.form = form
self.remove_button = {}
self.affiliation_treeview = {}
self.list_init = {} # list at the beginning
ui_list = {'outcast': _('Ban List'),
'member': _('Member List'),
'owner': _('Owner List'),
'admin':_('Administrator List')}
self.xml = gtkgui_helpers.get_glade('data_form_window.glade', 'data_form_window')
self.window = self.xml.get_widget('data_form_window')
self.window.set_transient_for(gajim.interface.roster.window)
if self.form:
config_vbox = self.xml.get_widget('config_vbox')
dataform = dataforms.ExtendForm(node = self.form)
self.data_form_widget = dataforms_widget.DataFormWidget(dataform)
# hide scrollbar of this data_form_widget, we already have in this
# widget
sw = self.data_form_widget.xml.get_widget('single_form_scrolledwindow')
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
self.data_form_widget.show()
config_vbox.pack_start(self.data_form_widget)
# Draw the edit affiliation list things
add_on_vbox = self.xml.get_widget('add_on_vbox')
for affiliation in ('outcast', 'member', 'owner', 'admin'):
self.list_init[affiliation] = {}
hbox = gtk.HBox(spacing = 5)
add_on_vbox.pack_start(hbox, False)
label = gtk.Label(ui_list[affiliation])
hbox.pack_start(label, False)
bb = gtk.HButtonBox()
bb.set_layout(gtk.BUTTONBOX_END)
bb.set_spacing(5)
hbox.pack_start(bb)
add_button = gtk.Button(stock = gtk.STOCK_ADD)
add_button.connect('clicked', self.on_add_button_clicked, affiliation)
bb.pack_start(add_button)
self.remove_button[affiliation] = gtk.Button(stock = gtk.STOCK_REMOVE)
self.remove_button[affiliation].set_sensitive(False)
self.remove_button[affiliation].connect('clicked',
self.on_remove_button_clicked, affiliation)
bb.pack_start(self.remove_button[affiliation])
liststore = gtk.ListStore(str, str, str, str) # Jid, reason, nick, role
self.affiliation_treeview[affiliation] = gtk.TreeView(liststore)
self.affiliation_treeview[affiliation].get_selection().set_mode(
gtk.SELECTION_MULTIPLE)
self.affiliation_treeview[affiliation].connect('cursor-changed',
self.on_affiliation_treeview_cursor_changed, affiliation)
renderer = gtk.CellRendererText()
col = gtk.TreeViewColumn(_('JID'), renderer)
col.add_attribute(renderer, 'text', 0)
self.affiliation_treeview[affiliation].append_column(col)
if affiliation == 'outcast':
renderer = gtk.CellRendererText()
renderer.set_property('editable', True)
renderer.connect('edited', self.on_cell_edited)
col = gtk.TreeViewColumn(_('Reason'), renderer)
col.add_attribute(renderer, 'text', 1)
self.affiliation_treeview[affiliation].append_column(col)
elif affiliation == 'member':
renderer = gtk.CellRendererText()
col = gtk.TreeViewColumn(_('Nick'), renderer)
col.add_attribute(renderer, 'text', 2)
self.affiliation_treeview[affiliation].append_column(col)
renderer = gtk.CellRendererText()
col = gtk.TreeViewColumn(_('Role'), renderer)
col.add_attribute(renderer, 'text', 3)
self.affiliation_treeview[affiliation].append_column(col)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_NEVER)
sw.add(self.affiliation_treeview[affiliation])
add_on_vbox.pack_start(sw)
gajim.connections[self.account].get_affiliation_list(self.room_jid,
affiliation)
self.xml.signal_autoconnect(self)
self.window.show_all()
def on_cancel_button_clicked(self, widget):
self.window.destroy()
def on_cell_edited(self, cell, path, new_text):
model = self.affiliation_treeview['outcast'].get_model()
new_text = new_text.decode('utf-8')
iter = model.get_iter(path)
model[iter][1] = new_text
def on_add_button_clicked(self, widget, affiliation):
if affiliation == 'outcast':
title = _('Banning...')
#You can move '\n' before user@domain if that line is TOO BIG
prompt = _('<b>Whom do you want to ban?</b>\n\n')
elif affiliation == 'member':
title = _('Adding Member...')
prompt = _('<b>Whom do you want to make a member?</b>\n\n')
elif affiliation == 'owner':
title = _('Adding Owner...')
prompt = _('<b>Whom do you want to make an owner?</b>\n\n')
else:
title = _('Adding Administrator...')
prompt = _('<b>Whom do you want to make an administrator?</b>\n\n')
prompt += _('Can be one of the following:\n'
'1. user@domain/resource (only that resource matches).\n'
'2. user@domain (any resource matches).\n'
'3. domain/resource (only that resource matches).\n'
'4. domain (the domain itself matches, as does any user@domain,\n'
'domain/resource, or address containing a subdomain.')
instance = dialogs.InputDialog(title, prompt)
response = instance.get_response()
if response != gtk.RESPONSE_OK:
return
jid = instance.input_entry.get_text().decode('utf-8')
if not jid:
return
model = self.affiliation_treeview[affiliation].get_model()
model.append((jid,'', '', ''))
def on_remove_button_clicked(self, widget, affiliation):
selection = self.affiliation_treeview[affiliation].get_selection()
model, paths = selection.get_selected_rows()
row_refs = []
for path in paths:
row_refs.append(gtk.TreeRowReference(model, path))
for row_ref in row_refs:
path = row_ref.get_path()
iter = model.get_iter(path)
jid = model[iter][0]
model.remove(iter)
self.remove_button[affiliation].set_sensitive(False)
def on_affiliation_treeview_cursor_changed(self, widget, affiliation):
self.remove_button[affiliation].set_sensitive(True)
def affiliation_list_received(self, affiliation, list):
'''Fill the affiliation treeview'''
self.list_init[affiliation] = list
if not affiliation:
return
tv = self.affiliation_treeview[affiliation]
model = tv.get_model()
for jid in list:
reason = ''
if list[jid].has_key('reason'):
reason = list[jid]['reason']
nick = ''
if list[jid].has_key('nick'):
nick = list[jid]['nick']
role = ''
if list[jid].has_key('role'):
role = list[jid]['role']
model.append((jid,reason, nick, role))
def on_data_form_window_destroy(self, widget):
del gajim.interface.instances[self.account]['gc_config'][self.room_jid]
def on_ok_button_clicked(self, widget):
if self.form:
form = self.data_form_widget.data_form
gajim.connections[self.account].send_gc_config(self.room_jid, form)
for affiliation in ('outcast', 'member', 'owner', 'admin'):
list = {}
actual_jid_list = []
model = self.affiliation_treeview[affiliation].get_model()
iter = model.get_iter_first()
# add new jid
while iter:
jid = model[iter][0].decode('utf-8')
actual_jid_list.append(jid)
if jid not in self.list_init[affiliation] or \
(affiliation == 'outcast' and self.list_init[affiliation]\
[jid].has_key('reason') and self.list_init[affiliation][jid]\
['reason'] != model[iter][1].decode('utf-8')):
list[jid] = {'affiliation': affiliation}
if affiliation == 'outcast':
list[jid]['reason'] = model[iter][1].decode('utf-8')
iter = model.iter_next(iter)
# remove removed one
for jid in self.list_init[affiliation]:
if jid not in actual_jid_list:
list[jid] = {'affiliation': 'none'}
if list:
gajim.connections[self.account].send_gc_affiliation_list(
self.room_jid, list)
self.window.destroy()
#---------- RemoveAccountWindow class -------------#
class RemoveAccountWindow:
'''ask for removing from gajim only or from gajim and server too
and do removing of the account given'''
def on_remove_account_window_destroy(self, widget):
if gajim.interface.instances.has_key(self.account):
del gajim.interface.instances[self.account]['remove_account']
def on_cancel_button_clicked(self, widget):
self.window.destroy()
def __init__(self, account):
self.account = account
xml = gtkgui_helpers.get_glade('remove_account_window.glade')
self.window = xml.get_widget('remove_account_window')
self.window.set_transient_for(gajim.interface.roster.window)
self.remove_and_unregister_radiobutton = xml.get_widget(
'remove_and_unregister_radiobutton')
self.window.set_title(_('Removing %s account') % self.account)
xml.signal_autoconnect(self)
self.window.show_all()
def on_remove_button_clicked(self, widget):
def remove(widget):
if self.dialog:
self.dialog.destroy()
if gajim.connections[self.account].connected and \
not self.remove_and_unregister_radiobutton.get_active():
# change status to offline only if we will not remove this JID from
# server
gajim.connections[self.account].change_status('offline', 'offline')
if self.remove_and_unregister_radiobutton.get_active():
if not gajim.connections[self.account].password:
passphrase = ''
w = dialogs.PassphraseDialog(
_('Password Required'),
_('Enter your password for account %s') % self.account,
_('Save password'))
passphrase, save = w.run()
if passphrase == -1:
# We don't remove account cause we canceled pw window
return
gajim.connections[self.account].password = passphrase
gajim.connections[self.account].unregister_account(
self._on_remove_success)
else:
self._on_remove_success(True)
self.dialog = None
if gajim.connections[self.account].connected:
self.dialog = dialogs.ConfirmationDialog(
_('Account "%s" is connected to the server') % self.account,
_('If you remove it, the connection will be lost.'),
on_response_ok = remove)
else:
remove(None)
def _on_remove_success(self, res):
# action of unregistration has failed, we don't remove the account
# Error message is send by connect_and_auth()
if not res:
return
# Close all opened windows
gajim.interface.roster.close_all(self.account, force = True)
gajim.connections[self.account].disconnect(on_purpose = True)
del gajim.connections[self.account]
gajim.config.del_per('accounts', self.account)
gajim.interface.save_config()
del gajim.interface.instances[self.account]
del gajim.interface.minimized_controls[self.account]
del gajim.nicks[self.account]
del gajim.block_signed_in_notifications[self.account]
del gajim.groups[self.account]
gajim.contacts.remove_account(self.account)
del gajim.gc_connected[self.account]
del gajim.automatic_rooms[self.account]
del gajim.to_be_removed[self.account]
del gajim.newly_added[self.account]
del gajim.sleeper_state[self.account]
del gajim.encrypted_chats[self.account]
del gajim.last_message_time[self.account]
del gajim.status_before_autoaway[self.account]
del gajim.transport_avatar[self.account]
if len(gajim.connections) >= 2: # Do not merge accounts if only one exists
gajim.interface.roster.regroup = gajim.config.get('mergeaccounts')
else:
gajim.interface.roster.regroup = False
gajim.interface.roster.draw_roster()
gajim.interface.roster.actions_menu_needs_rebuild = True
if gajim.interface.instances.has_key('accounts'):
gajim.interface.instances['accounts'].init_accounts()
self.window.destroy()
#---------- ManageBookmarksWindow class -------------#
class ManageBookmarksWindow:
def __init__(self):
self.xml = gtkgui_helpers.get_glade('manage_bookmarks_window.glade')
self.window = self.xml.get_widget('manage_bookmarks_window')
self.window.set_transient_for(gajim.interface.roster.window)
# Account-JID, RoomName, Room-JID, Autojoin, Minimize, Passowrd, Nick,
# Show_Status
self.treestore = gtk.TreeStore(str, str, str, bool, bool, str, str, str)
# Store bookmarks in treeview.
for account in gajim.connections:
if gajim.connections[account].connected <= 1:
continue
if gajim.connections[account].is_zeroconf:
continue
iter = self.treestore.append(None, [None, account, None, None,
None, None, None, None])
for bookmark in gajim.connections[account].bookmarks:
if bookmark['name'] == '':
# No name was given for this bookmark.
# Use the first part of JID instead...
name = bookmark['jid'].split("@")[0]
bookmark['name'] = name
# make '1', '0', 'true', 'false' (or other) to True/False
autojoin = helpers.from_xs_boolean_to_python_boolean(
bookmark['autojoin'])
minimize = helpers.from_xs_boolean_to_python_boolean(
bookmark['minimize'])
print_status = bookmark.get('print_status', '')
if print_status not in ('', 'all', 'in_and_out', 'none'):
print_status = ''
self.treestore.append( iter, [
account,
bookmark['name'],
bookmark['jid'],
autojoin,
minimize,
bookmark['password'],
bookmark['nick'],
print_status ])
self.print_status_combobox = self.xml.get_widget('print_status_combobox')
model = gtk.ListStore(str, str)
self.option_list = {'': _('Default'), 'all': Q_('?print_status:All'),
'in_and_out': _('Enter and leave only'),
'none': Q_('?print_status:None')}
opts = self.option_list.keys()
opts.sort()
for opt in opts:
model.append([self.option_list[opt], opt])
self.print_status_combobox.set_model(model)
self.print_status_combobox.set_active(1)
self.view = self.xml.get_widget('bookmarks_treeview')
self.view.set_model(self.treestore)
self.view.expand_all()
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Bookmarks', renderer, text=1)
self.view.append_column(column)
self.selection = self.view.get_selection()
self.selection.connect('changed', self.bookmark_selected)
#Prepare input fields
self.title_entry = self.xml.get_widget('title_entry')
self.title_entry.connect('changed', self.on_title_entry_changed)
self.nick_entry = self.xml.get_widget('nick_entry')
self.nick_entry.connect('changed', self.on_nick_entry_changed)
self.server_entry = self.xml.get_widget('server_entry')
self.server_entry.connect('changed', self.on_server_entry_changed)
self.room_entry = self.xml.get_widget('room_entry')
self.room_entry.connect('changed', self.on_room_entry_changed)
self.pass_entry = self.xml.get_widget('pass_entry')
self.pass_entry.connect('changed', self.on_pass_entry_changed)
self.autojoin_checkbutton = self.xml.get_widget('autojoin_checkbutton')
self.minimize_checkbutton = self.xml.get_widget('minimize_checkbutton')
self.xml.signal_autoconnect(self)
self.window.show_all()
def on_bookmarks_treeview_button_press_event(self, widget, event):
(model, iter) = self.selection.get_selected()
if not iter:
# Removed a bookmark before
return
if model.iter_parent(iter):
# The currently selected node is a bookmark
return not self.check_valid_bookmark()
def on_manage_bookmarks_window_destroy(self, widget, event):
del gajim.interface.instances['manage_bookmarks']
def on_add_bookmark_button_clicked(self, widget):
'''Add a new bookmark.'''
# Get the account that is currently used
# (the parent of the currently selected item)
(model, iter) = self.selection.get_selected()
if not iter: # Nothing selected, do nothing
return
parent = model.iter_parent(iter)
if parent:
# We got a bookmark selected, so we add_to the parent
add_to = parent
else:
# No parent, so we got an account -> add to this.
add_to = iter
account = model[add_to][1].decode('utf-8')
nick = gajim.nicks[account]
iter_ = self.treestore.append(add_to, [account, _('New Group Chat'), '',
False, False, '', nick, 'in_and_out'])
self.view.expand_row(model.get_path(add_to), True)
self.view.set_cursor(model.get_path(iter_))
def on_remove_bookmark_button_clicked(self, widget):
'''
Remove selected bookmark.
'''
(model, iter) = self.selection.get_selected()
if not iter: # Nothing selected
return
if not model.iter_parent(iter):
# Don't remove account iters
return
model.remove(iter)
self.clear_fields()
def check_valid_bookmark(self):
'''
Check if all neccessary fields are entered correctly.
'''
(model, iter) = self.selection.get_selected()
if not model.iter_parent(iter):
#Account data can't be changed
return
if self.server_entry.get_text().decode('utf-8') == '' or \
self.room_entry.get_text().decode('utf-8') == '':
dialogs.ErrorDialog(_('This bookmark has invalid data'),
_('Please be sure to fill out server and room fields or remove this'
' bookmark.'))
return False
return True
def on_ok_button_clicked(self, widget):
'''
Parse the treestore data into our new bookmarks array,
then send the new bookmarks to the server.
'''
(model, iter) = self.selection.get_selected()
if iter and model.iter_parent(iter):
#bookmark selected, check it
if not self.check_valid_bookmark():
return
for account in self.treestore:
account_unicode = account[1].decode('utf-8')
gajim.connections[account_unicode].bookmarks = []
for bm in account.iterchildren():
#Convert True/False/None to '1' or '0'
autojoin = unicode(int(bm[3]))
minimize = unicode(int(bm[4]))
#create the bookmark-dict
bmdict = { 'name': bm[1], 'jid': bm[2], 'autojoin': autojoin,
'minimize': minimize, 'password': bm[5], 'nick': bm[6],
'print_status': bm[7]}
gajim.connections[account_unicode].bookmarks.append(bmdict)
gajim.connections[account_unicode].store_bookmarks()
gajim.interface.roster.actions_menu_needs_rebuild = True
self.window.destroy()
def on_cancel_button_clicked(self, widget):
self.window.destroy()
def bookmark_selected(self, selection):
'''
Fill in the bookmark's data into the fields.
'''
(model, iter) = selection.get_selected()
if not iter:
# After removing the last bookmark for one account
# this will be None, so we will just:
return
widgets = [ self.title_entry, self.nick_entry, self.room_entry,
self.server_entry, self.pass_entry, self.autojoin_checkbutton,
self.minimize_checkbutton, self.print_status_combobox]
if model.iter_parent(iter):
# make the fields sensitive
for field in widgets:
field.set_sensitive(True)
else:
# Top-level has no data (it's the account fields)
# clear fields & make them insensitive
self.clear_fields()
for field in widgets:
field.set_sensitive(False)
return
# Fill in the data for childs
self.title_entry.set_text(model[iter][1])
room_jid = model[iter][2].decode('utf-8')
try:
(room, server) = room_jid.split('@')
except ValueError:
# We just added this one
room = ''
server = ''
self.room_entry.set_text(room)
self.server_entry.set_text(server)
self.autojoin_checkbutton.set_active(model[iter][3])
self.minimize_checkbutton.set_active(model[iter][4])
# sensitive only if auto join is checked
self.minimize_checkbutton.set_sensitive(model[iter][3])
if model[iter][5] is not None:
password = model[iter][5].decode('utf-8')
else:
password = None
if password:
self.pass_entry.set_text(password)
else:
self.pass_entry.set_text('')
nick = model[iter][5]
if nick:
nick = nick.decode('utf-8')
self.nick_entry.set_text(nick)
else:
self.nick_entry.set_text('')
print_status = model[iter][7]
opts = self.option_list.keys()
opts.sort()
self.print_status_combobox.set_active(opts.index(print_status))
def on_title_entry_changed(self, widget):
(model, iter) = self.selection.get_selected()
if iter: # After removing a bookmark, we got nothing selected
if model.iter_parent(iter):
# Don't clear the title field for account nodes
model[iter][1] = self.title_entry.get_text()
def on_nick_entry_changed(self, widget):
(model, iter) = self.selection.get_selected()
if iter:
model[iter][6] = self.nick_entry.get_text()
def on_server_entry_changed(self, widget):
(model, iter) = self.selection.get_selected()
if iter:
room_jid = self.room_entry.get_text().decode('utf-8') + '@' + \
self.server_entry.get_text().decode('utf-8')
model[iter][2] = room_jid
def on_room_entry_changed(self, widget):
(model, iter) = self.selection.get_selected()
if iter:
room_jid = self.room_entry.get_text().decode('utf-8') + '@' + \
self.server_entry.get_text().decode('utf-8')
model[iter][2] = room_jid
def on_pass_entry_changed(self, widget):
(model, iter) = self.selection.get_selected()
if iter:
model[iter][5] = self.pass_entry.get_text()
def on_autojoin_checkbutton_toggled(self, widget):
(model, iter) = self.selection.get_selected()
if iter:
model[iter][3] = self.autojoin_checkbutton.get_active()
self.minimize_checkbutton.set_sensitive(model[iter][3])
def on_minimize_checkbutton_toggled(self, widget):
(model, iter) = self.selection.get_selected()
if iter:
model[iter][4] = self.minimize_checkbutton.get_active()
def on_print_status_combobox_changed(self, widget):
active = widget.get_active()
model = widget.get_model()
print_status = model[active][1]
(model2, iter) = self.selection.get_selected()
if iter:
model2[iter][7] = print_status
def clear_fields(self):
widgets = [ self.title_entry, self.nick_entry, self.room_entry,
self.server_entry, self.pass_entry ]
for field in widgets:
field.set_text('')
self.autojoin_checkbutton.set_active(False)
self.minimize_checkbutton.set_active(False)
self.print_status_combobox.set_active(1)
class AccountCreationWizardWindow:
def __init__(self):
self.xml = gtkgui_helpers.get_glade(
'account_creation_wizard_window.glade')
self.window = self.xml.get_widget('account_creation_wizard_window')
completion = gtk.EntryCompletion()
# Connect events from comboboxentry.child
server_comboboxentry = self.xml.get_widget('server_comboboxentry')
entry = server_comboboxentry.child
entry.connect('key_press_event',
self.on_server_comboboxentry_key_press_event, server_comboboxentry)
entry.set_completion(completion)
# Do the same for the other server comboboxentry
server_comboboxentry1 = self.xml.get_widget('server_comboboxentry1')
entry = server_comboboxentry1.child
entry.connect('key_press_event',
self.on_server_comboboxentry_key_press_event, server_comboboxentry1)
entry.set_completion(completion)
self.update_proxy_list()
# parse servers.xml
servers_xml = os.path.join(gajim.DATA_DIR, 'other', 'servers.xml')
servers = gtkgui_helpers.parse_server_xml(servers_xml)
servers_model = gtk.ListStore(str, int)
for server in servers:
if not server[2]['hidden']:
servers_model.append((str(server[0]), int(server[1])))
completion.set_model(servers_model)
completion.set_text_column(0)
# Put servers into comboboxentries
server_comboboxentry.set_model(servers_model)
server_comboboxentry.set_text_column(0)
server_comboboxentry1.set_model(servers_model)
server_comboboxentry1.set_text_column(0)
# Generic widgets
self.notebook = self.xml.get_widget('notebook')
self.cancel_button = self.xml.get_widget('cancel_button')
self.back_button = self.xml.get_widget('back_button')
self.forward_button = self.xml.get_widget('forward_button')
self.finish_button = self.xml.get_widget('finish_button')
self.advanced_button = self.xml.get_widget('advanced_button')
self.finish_label = self.xml.get_widget('finish_label')
self.go_online_checkbutton = self.xml.get_widget(
'go_online_checkbutton')
self.show_vcard_checkbutton = self.xml.get_widget(
'show_vcard_checkbutton')
self.progressbar = self.xml.get_widget('progressbar')
# some vars
self.update_progressbar_timeout_id = None
self.notebook.set_current_page(0)
self.advanced_button.set_no_show_all(True)
self.finish_button.set_no_show_all(True)
self.xml.signal_autoconnect(self)
self.window.show_all()
def on_wizard_window_destroy(self, widget):
del gajim.interface.instances['account_creation_wizard']
def on_register_server_features_button_clicked(self, widget):
helpers.launch_browser_mailer('url',
'http://www.jabber.org/network/oldnetwork.shtml')
def on_save_password_checkbutton_toggled(self, widget):
self.xml.get_widget('password_entry').grab_focus()
def on_cancel_button_clicked(self, widget):
self.window.destroy()
def on_back_button_clicked(self, widget):
if self.notebook.get_current_page() in (1, 2):
self.notebook.set_current_page(0)
self.back_button.set_sensitive(False)
elif self.notebook.get_current_page() == 3:
self.notebook.set_current_page(2)
self.xml.get_widget('form_vbox').remove(self.data_form_widget)
elif self.notebook.get_current_page() == 5: # finish page
self.forward_button.show()
if self.modify:
self.notebook.set_current_page(1) # Go to parameters page
else:
self.notebook.set_current_page(2) # Go to server page
def on_forward_button_clicked(self, widget):
cur_page = self.notebook.get_current_page()
if cur_page == 0:
widget = self.xml.get_widget('use_existing_account_radiobutton')
if widget.get_active():
self.modify = True
self.notebook.set_current_page(1)
else:
self.modify = False
self.notebook.set_current_page(2)
self.back_button.set_sensitive(True)
return
elif cur_page == 1:
# We are adding an existing account
username = self.xml.get_widget('username_entry').get_text().decode(
'utf-8')
if not username:
pritext = _('Invalid username')
sectext = _(
'You must provide a username to configure this account.')
dialogs.ErrorDialog(pritext, sectext)
return
server = self.xml.get_widget('server_comboboxentry').child.get_text().\
decode('utf-8')
savepass = self.xml.get_widget('save_password_checkbutton').\
get_active()
password = self.xml.get_widget('password_entry').get_text().decode(
'utf-8')
jid = username + '@' + server
# check if jid is conform to RFC and stringprep it
try:
jid = helpers.parse_jid(jid)
except helpers.InvalidFormat, s:
pritext = _('Invalid Jabber ID')
dialogs.ErrorDialog(pritext, str(s))
return
already_in_jids = []
for account in gajim.connections:
j = gajim.config.get_per('accounts', account, 'name')
j += '@' + gajim.config.get_per('accounts', account, 'hostname')
already_in_jids.append(j)
if jid in already_in_jids:
pritext = _('Duplicate Jabber ID')
sectext = _('This account is already configured in Gajim.')
dialogs.ErrorDialog(pritext, sectext)
return
self.account = server
i = 1
while self.account in gajim.connections:
self.account = server + str(i)
i += 1
username, server = gajim.get_name_and_server_from_jid(jid)
self.save_account(username, server, savepass, password)
self.cancel_button.hide()
self.back_button.hide()
self.forward_button.hide()
if self.modify:
finish_text = '<big><b>%s</b></big>\n\n%s' % (
_('Account has been added successfully'),
_('You can set advanced account options by pressing the '
'Advanced button, or later by choosing the Accounts menuitem '
'under the Edit menu from the main window.'))
self.finish_label.set_markup(finish_text)
self.finish_button.show()
self.finish_button.set_property('has-default', True)
self.advanced_button.show()
self.go_online_checkbutton.show()
img = self.xml.get_widget('finish_image')
img.set_from_stock(gtk.STOCK_APPLY, gtk.ICON_SIZE_DIALOG)
self.notebook.set_current_page(5) # show finish page
self.show_vcard_checkbutton.set_active(False)
elif cur_page == 2:
server = self.xml.get_widget('server_comboboxentry1').child.get_text()\
.decode('utf-8')
if not server:
dialogs.ErrorDialog(_('Invalid server'),
_('Please provide a server on which you want to register.'))
return
self.account = server
i = 1
while self.account in gajim.connections:
self.account = server + str(i)
i += 1
config = self.get_config('', server, '', '')
# Get advanced options
proxies_combobox = self.xml.get_widget('proxies_combobox')
active = proxies_combobox.get_active()
proxy = proxies_combobox.get_model()[active][0].decode('utf-8')
if proxy == _('None'):
proxy = ''
config['proxy'] = proxy
config['use_custom_host'] = self.xml.get_widget(
'custom_host_port_checkbutton').get_active()
custom_port = self.xml.get_widget('custom_port_entry').get_text()
try:
custom_port = int(custom_port)
except:
dialogs.ErrorDialog(_('Invalid entry'),
_('Custom port must be a port number.'))
return
config['custom_port'] = custom_port
config['custom_host'] = self.xml.get_widget(
'custom_host_entry').get_text().decode('utf-8')
self.notebook.set_current_page(4) # show creating page
self.back_button.hide()
self.forward_button.hide()
self.update_progressbar_timeout_id = gobject.timeout_add(100,
self.update_progressbar)
# Get form from serveur
con = connection.Connection(self.account)
con.new_account(self.account, config)
gajim.connections[self.account] = con
elif cur_page == 3:
if self.is_form:
form = self.data_form_widget.data_form
else:
form = self.data_form_widget.get_infos()
gajim.connections[self.account].send_new_account_infos(form,
self.is_form)
self.xml.get_widget('form_vbox').remove(self.data_form_widget)
self.xml.get_widget('progressbar_label').set_markup('<b>Account is being created</b>\n\nPlease wait...')
self.notebook.set_current_page(4) # show creating page
self.back_button.hide()
self.forward_button.hide()
self.update_progressbar_timeout_id = gobject.timeout_add(100,
self.update_progressbar)
def update_proxy_list(self):
proxies_combobox = self.xml.get_widget('proxies_combobox')
model = gtk.ListStore(str)
proxies_combobox.set_model(model)
l = gajim.config.get_per('proxies')
l.insert(0, _('None'))
for i in xrange(len(l)):
model.append([l[i]])
proxies_combobox.set_active(0)
def on_manage_proxies_button_clicked(self, widget):
if gajim.interface.instances.has_key('manage_proxies'):
gajim.interface.instances['manage_proxies'].window.present()
else:
gajim.interface.instances['manage_proxies'] = \
ManageProxiesWindow()
def on_custom_host_port_checkbutton_toggled(self, widget):
self.xml.get_widget('custom_host_hbox').set_sensitive(widget.get_active())
def update_progressbar(self):
self.progressbar.pulse()
return True # loop forever
def new_acc_connected(self, form, is_form):
'''connection to server succeded, present the form to the user'''
if self.update_progressbar_timeout_id is not None:
gobject.source_remove(self.update_progressbar_timeout_id)
self.back_button.show()
self.forward_button.show()
self.notebook.set_current_page(3) # show form page
self.is_form = is_form
if is_form:
dataform = dataforms.ExtendForm(node = form)
self.data_form_widget = dataforms_widget.DataFormWidget(dataform)
else:
self.data_form_widget = FakeDataForm(form)
self.data_form_widget.show_all()
self.xml.get_widget('form_vbox').pack_start(self.data_form_widget)
def new_acc_not_connected(self, reason):
'''Account creation failed: connection to server failed'''
if self.update_progressbar_timeout_id is not None:
gobject.source_remove(self.update_progressbar_timeout_id)
del gajim.connections[self.account]
self.back_button.show()
self.cancel_button.show()
self.go_online_checkbutton.hide()
self.show_vcard_checkbutton.hide()
img = self.xml.get_widget('finish_image')
img.set_from_stock(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_DIALOG)
finish_text = '<big><b>%s</b></big>\n\n%s' % (
_('An error occurred during account creation') , reason)
self.finish_label.set_markup(finish_text)
self.notebook.set_current_page(5) # show finish page
def acc_is_ok(self, config):
'''Account creation succeeded'''
self.create_vars(config)
self.cancel_button.hide()
self.back_button.hide()
self.forward_button.hide()
self.finish_button.show()
self.finish_button.set_property('has-default', True)
self.advanced_button.show()
self.go_online_checkbutton.show()
self.show_vcard_checkbutton.show()
img = self.xml.get_widget('finish_image')
path_to_file = os.path.join(gajim.DATA_DIR, 'pixmaps', 'gajim.png')
img.set_from_file(path_to_file)
finish_text = '<big><b>%s</b></big>\n\n%s' % (
_('Your new account has been created successfully'),
_('You can set advanced account options by pressing the Advanced '
'button, or later by choosing the Accounts menuitem under the Edit '
'menu from the main window.'))
self.finish_label.set_markup(finish_text)
self.notebook.set_current_page(5) # show finish page
if self.update_progressbar_timeout_id is not None:
gobject.source_remove(self.update_progressbar_timeout_id)
def acc_is_not_ok(self, reason):
'''Account creation failed'''
self.back_button.show()
self.cancel_button.show()
self.go_online_checkbutton.hide()
self.show_vcard_checkbutton.hide()
del gajim.connections[self.account]
img = self.xml.get_widget('finish_image')
img.set_from_stock(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_DIALOG)
finish_text = '<big><b>%s</b></big>\n\n%s' % (_('An error occurred during '
'account creation') , reason)
self.finish_label.set_markup(finish_text)
self.notebook.set_current_page(5) # show finish page
if self.update_progressbar_timeout_id is not None:
gobject.source_remove(self.update_progressbar_timeout_id)
def on_advanced_button_clicked(self, widget):
gajim.interface.instances[self.account]['account_modification'] = \
AccountModificationWindow(self.account)
self.window.destroy()
def on_finish_button_clicked(self, widget):
go_online = self.xml.get_widget('go_online_checkbutton').get_active()
show_vcard = self.xml.get_widget('show_vcard_checkbutton').get_active()
self.window.destroy()
if show_vcard:
gajim.interface.show_vcard_when_connect.append(self.account)
if go_online:
gajim.interface.roster.send_status(self.account, 'online', '')
def on_username_entry_changed(self, widget):
self.update_jid(widget)
def on_server_comboboxentry_changed(self, widget):
self.update_jid(widget)
def on_username_entry_key_press_event(self, widget, event):
# Check for pressed @ and jump to combobox if found
if event.keyval == gtk.keysyms.at:
combobox = self.xml.get_widget('server_comboboxentry')
combobox.grab_focus()
combobox.child.set_position(-1)
return True
def on_server_comboboxentry_key_press_event(self, widget, event, combobox):
# If backspace is pressed in empty field, return to the nick entry field
backspace = event.keyval == gtk.keysyms.BackSpace
empty = len(combobox.get_active_text()) == 0
if backspace and empty and self.modify:
username_entry = self.xml.get_widget('username_entry')
username_entry.grab_focus()
username_entry.set_position(-1)
return True
def update_jid(self,widget):
username_entry = self.xml.get_widget('username_entry')
name = username_entry.get_text().decode('utf-8')
combobox = self.xml.get_widget('server_comboboxentry')
server = combobox.get_active_text()
jid_label = self.xml.get_widget('jid_label')
if len(name) == 0 or len(server) == 0:
jid_label.set_label('')
else:
string = '<b>%s@%s</b>' % (name, server)
jid_label.set_label(string)
def get_config(self, login, server, savepass, password):
config = {}
config['name'] = login
config['hostname'] = server
config['savepass'] = savepass
config['password'] = password
config['resource'] = 'Gajim'
config['priority'] = 5
config['autoconnect'] = True
config['no_log_for'] = ''
config['sync_with_global_status'] = True
config['proxy'] = ''
config['usessl'] = False
config['use_custom_host'] = False
config['custom_port'] = 0
config['custom_host'] = ''
config['keyname'] = ''
config['keyid'] = ''
config['savegpgpass'] = False
config['gpgpassword'] = ''
return config
def save_account(self, login, server, savepass, password):
if self.account in gajim.connections:
dialogs.ErrorDialog(_('Account name is in use'),
_('You already have an account using this name.'))
return
con = connection.Connection(self.account)
con.password = password
config = self.get_config(login, server, savepass, password)
if not self.modify:
con.new_account(self.account, config)
return
gajim.connections[self.account] = con
self.create_vars(config)
def create_vars(self, config):
gajim.config.add_per('accounts', self.account)
if not config['savepass']:
config['password'] = ''
for opt in config:
gajim.config.set_per('accounts', self.account, opt, config[opt])
# update variables
gajim.interface.instances[self.account] = {'infos': {}, 'disco': {},
'gc_config': {}, 'search': {}}
gajim.interface.minimized_controls[self.account] = {}
gajim.connections[self.account].connected = 0
gajim.groups[self.account] = {}
gajim.contacts.add_account(self.account)
gajim.gc_connected[self.account] = {}
gajim.automatic_rooms[self.account] = {}
gajim.newly_added[self.account] = []
gajim.to_be_removed[self.account] = []
gajim.nicks[self.account] = config['name']
gajim.block_signed_in_notifications[self.account] = True
gajim.sleeper_state[self.account] = 'off'
gajim.encrypted_chats[self.account] = []
gajim.last_message_time[self.account] = {}
gajim.status_before_autoaway[self.account] = ''
gajim.transport_avatar[self.account] = {}
# refresh accounts window
if gajim.interface.instances.has_key('accounts'):
gajim.interface.instances['accounts'].init_accounts()
# refresh roster
if len(gajim.connections) >= 2: # Do not merge accounts if only one exists
gajim.interface.roster.regroup = gajim.config.get('mergeaccounts')
else:
gajim.interface.roster.regroup = False
gajim.interface.roster.draw_roster()
gajim.interface.roster.actions_menu_needs_rebuild = True
gajim.interface.save_config()
#---------- ZeroconfPropertiesWindow class -------------#
class ZeroconfPropertiesWindow:
def __init__(self):
self.xml = gtkgui_helpers.get_glade('zeroconf_properties_window.glade')
self.window = self.xml.get_widget('zeroconf_properties_window')
self.window.set_transient_for(gajim.interface.roster.window)
self.xml.signal_autoconnect(self)
self.init_account()
self.init_account_gpg()
self.xml.get_widget('save_button').grab_focus()
self.window.show_all()
def init_account(self):
st = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME,
'autoconnect')
if st:
self.xml.get_widget('autoconnect_checkbutton').set_active(st)
list_no_log_for = gajim.config.get_per('accounts',
gajim.ZEROCONF_ACC_NAME,'no_log_for').split()
if gajim.ZEROCONF_ACC_NAME in list_no_log_for:
self.xml.get_widget('log_history_checkbutton').set_active(0)
else:
self.xml.get_widget('log_history_checkbutton').set_active(1)
st = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME,
'sync_with_global_status')
if st:
self.xml.get_widget('sync_with_global_status_checkbutton').set_active(
st)
for opt in ('first_name', 'last_name', 'jabber_id', 'email'):
st = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME,
'zeroconf_' + opt)
if st:
self.xml.get_widget(opt + '_entry').set_text(st)
st = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME,
'custom_port')
if st:
self.xml.get_widget('custom_port_entry').set_text(str(st))
st = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME,
'use_custom_host')
if st:
self.xml.get_widget('custom_port_checkbutton').set_active(st)
self.xml.get_widget('custom_port_entry').set_sensitive(bool(st))
if not st:
gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME,
'custom_port', '5298')
def init_account_gpg(self):
keyid = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'keyid')
keyname = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME,
'keyname')
savegpgpass = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME,
'savegpgpass')
if not keyid or not gajim.config.get('usegpg'):
return
self.xml.get_widget('gpg_key_label').set_text(keyid)
self.xml.get_widget('gpg_name_label').set_text(keyname)
gpg_save_password_checkbutton = \
self.xml.get_widget('gpg_save_password_checkbutton')
gpg_save_password_checkbutton.set_sensitive(True)
gpg_save_password_checkbutton.set_active(savegpgpass)
if savegpgpass:
entry = self.xml.get_widget('gpg_password_entry')
entry.set_sensitive(True)
gpgpassword = gajim.config.get_per('accounts',
gajim.ZEROCONF_ACC_NAME, 'gpgpassword')
entry.set_text(gpgpassword)
def on_zeroconf_properties_window_destroy(self, widget):
# close window
if gajim.interface.instances.has_key('zeroconf_properties'):
del gajim.interface.instances['zeroconf_properties']
def on_custom_port_checkbutton_toggled(self, widget):
st = self.xml.get_widget('custom_port_checkbutton').get_active()
self.xml.get_widget('custom_port_entry').set_sensitive(bool(st))
def on_cancel_button_clicked(self, widget):
self.window.destroy()
def on_save_button_clicked(self, widget):
config = {}
st = self.xml.get_widget('autoconnect_checkbutton').get_active()
config['autoconnect'] = st
list_no_log_for = gajim.config.get_per('accounts',
gajim.ZEROCONF_ACC_NAME, 'no_log_for').split()
if gajim.ZEROCONF_ACC_NAME in list_no_log_for:
list_no_log_for.remove(gajim.ZEROCONF_ACC_NAME)
if not self.xml.get_widget('log_history_checkbutton').get_active():
list_no_log_for.append(gajim.ZEROCONF_ACC_NAME)
config['no_log_for'] = ' '.join(list_no_log_for)
st = self.xml.get_widget('sync_with_global_status_checkbutton').\
get_active()
config['sync_with_global_status'] = st
st = self.xml.get_widget('first_name_entry').get_text()
config['zeroconf_first_name'] = st.decode('utf-8')
st = self.xml.get_widget('last_name_entry').get_text()
config['zeroconf_last_name'] = st.decode('utf-8')
st = self.xml.get_widget('jabber_id_entry').get_text()
config['zeroconf_jabber_id'] = st.decode('utf-8')
st = self.xml.get_widget('email_entry').get_text()
config['zeroconf_email'] = st.decode('utf-8')
use_custom_port = self.xml.get_widget('custom_port_checkbutton').\
get_active()
config['use_custom_host'] = use_custom_port
old_port = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME,
'custom_port')
if use_custom_port:
port = self.xml.get_widget('custom_port_entry').get_text()
else:
port = 5298
config['custom_port'] = port
config['keyname'] = self.xml.get_widget('gpg_name_label').get_text().\
decode('utf-8')
if config['keyname'] == '': #no key selected
config['keyid'] = ''
config['savegpgpass'] = False
config['gpgpassword'] = ''
else:
config['keyid'] = self.xml.get_widget('gpg_key_label').get_text().\
decode('utf-8')
config['savegpgpass'] = self.xml.get_widget(
'gpg_save_password_checkbutton').get_active()
config['gpgpassword'] = self.xml.get_widget('gpg_password_entry'
).get_text().decode('utf-8')
reconnect = False
for opt in ('zeroconf_first_name','zeroconf_last_name',
'zeroconf_jabber_id', 'zeroconf_email', 'custom_port'):
if gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, opt) != \
config[opt]:
reconnect = True
for opt in config:
gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, opt,
config[opt])
if gajim.connections.has_key(gajim.ZEROCONF_ACC_NAME):
if port != old_port or reconnect:
gajim.connections[gajim.ZEROCONF_ACC_NAME].update_details()
self.window.destroy()
def on_gpg_choose_button_clicked(self, widget, data = None):
if gajim.connections.has_key(gajim.ZEROCONF_ACC_NAME):
secret_keys = gajim.connections[gajim.ZEROCONF_ACC_NAME].\
ask_gpg_secrete_keys()
# self.account is None and/or gajim.connections is {}
else:
from common import GnuPG
if GnuPG.USE_GPG:
secret_keys = GnuPG.GnuPG().get_secret_keys()
else:
secret_keys = []
if not secret_keys:
dialogs.ErrorDialog(_('Failed to get secret keys'),
_('There was a problem retrieving your OpenPGP secret keys.'))
return
secret_keys[_('None')] = _('None')
instance = dialogs.ChooseGPGKeyDialog(_('OpenPGP Key Selection'),
_('Choose your OpenPGP key'), secret_keys)
keyID = instance.run()
if keyID is None:
return
checkbutton = self.xml.get_widget('gpg_save_password_checkbutton')
gpg_key_label = self.xml.get_widget('gpg_key_label')
gpg_name_label = self.xml.get_widget('gpg_name_label')
if keyID[0] == _('None'):
gpg_key_label.set_text(_('No key selected'))
gpg_name_label.set_text('')
checkbutton.set_sensitive(False)
self.xml.get_widget('gpg_password_entry').set_sensitive(False)
else:
gpg_key_label.set_text(keyID[0])
gpg_name_label.set_text(keyID[1])
checkbutton.set_sensitive(True)
checkbutton.set_active(False)
self.xml.get_widget('gpg_password_entry').set_text('')
def on_gpg_save_password_checkbutton_toggled(self, widget):
st = widget.get_active()
w = self.xml.get_widget('gpg_password_entry')
w.set_sensitive(bool(st))