copyleftie/gajim-plural
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

the old self.plugin variable becomes gajim.interface, no need to pass it to every functions/classes

Browse source
This commit is contained in:
Yann Leboulanger 2005-10-20 11:17:17 +00:00
parent 0b1bf176e9
commit 726640ef4b
18 changed files with 523 additions and 557 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/advanced.py
View file

@ -41,9 +41,7 @@ C_TYPE
GTKGUI_GLADE = 'gtkgui.glade' GTKGUI_GLADE = 'gtkgui.glade'
class AdvancedConfigurationWindow: class AdvancedConfigurationWindow:
def __init__(self, plugin): def __init__(self):
self.plugin = plugin
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'advanced_configuration_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'advanced_configuration_window', APP)
self.window = self.xml.get_widget('advanced_configuration_window') self.window = self.xml.get_widget('advanced_configuration_window')
self.entry = self.xml.get_widget('advanced_entry') self.entry = self.xml.get_widget('advanced_entry')
@ -86,7 +84,7 @@ class AdvancedConfigurationWindow:
self.xml.signal_autoconnect(self) self.xml.signal_autoconnect(self)
self.window.show_all() self.window.show_all()
self.plugin.windows['advanced_config'] = self gajim.interface.windows['advanced_config'] = self
def cb_value_column_data(self, col, cell, model, iter): def cb_value_column_data(self, col, cell, model, iter):
optname = model[iter][C_PREFNAME] optname = model[iter][C_PREFNAME]
@ -123,7 +121,7 @@ class AdvancedConfigurationWindow:
gajim.config.set_per(optname, key, option, newval) gajim.config.set_per(optname, key, option, newval)
else: else:
gajim.config.set(option, newval) gajim.config.set(option, newval)
self.plugin.save_config() gajim.interface.save_config()
modelrow[1] = newval modelrow[1] = newval
def on_config_edited(self, cell, path, text): def on_config_edited(self, cell, path, text):
@ -140,13 +138,13 @@ class AdvancedConfigurationWindow:
gajim.config.set_per(optname, key, option, text) gajim.config.set_per(optname, key, option, text)
else: else:
gajim.config.set(option, text) gajim.config.set(option, text)
self.plugin.save_config() gajim.interface.save_config()
modelrow[1] = text modelrow[1] = text
def on_advanced_configuration_window_destroy(self, widget): def on_advanced_configuration_window_destroy(self, widget):
# update ui of preferences window to get possible changes we did # update ui of preferences window to get possible changes we did
self.plugin.windows['preferences'].update_preferences_window() gajim.interface.windows['preferences'].update_preferences_window()
del self.plugin.windows['advanced_config'] del gajim.interface.windows['advanced_config']
def on_advanced_close_button_clicked(self, widget): def on_advanced_close_button_clicked(self, widget):
self.window.destroy() self.window.destroy()

69
src/chat.py
View file

@ -1,4 +1,4 @@
## plugins/tabbed_chat_window.py ## chat.py
## ##
## Gajim Team: ## Gajim Team:
## - Yann Le Boulanger <asterix@lagaule.org> ## - Yann Le Boulanger <asterix@lagaule.org>
@ -45,13 +45,12 @@ GTKGUI_GLADE = 'gtkgui.glade'
class Chat: class Chat:
'''Class for chat/groupchat windows''' '''Class for chat/groupchat windows'''
def __init__(self, plugin, account, widget_name): def __init__(self, account, widget_name):
self.xml = gtk.glade.XML(GTKGUI_GLADE, widget_name, APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, widget_name, APP)
self.window = self.xml.get_widget(widget_name) self.window = self.xml.get_widget(widget_name)
self.widget_name = widget_name self.widget_name = widget_name
self.plugin = plugin
self.account = account self.account = account
self.change_cursor = None self.change_cursor = None
self.xmls = {} self.xmls = {}
@ -264,16 +263,16 @@ class Chat:
return 'pm' return 'pm'
def on_window_destroy(self, widget, kind): #kind is 'chats' or 'gc' def on_window_destroy(self, widget, kind): #kind is 'chats' or 'gc'
'''clean self.plugin.windows[self.account][kind]''' '''clean gajim.interface.windows[self.account][kind]'''
for jid in self.xmls: for jid in self.xmls:
windows = self.plugin.windows[self.account][kind] windows = gajim.interface.windows[self.account][kind]
if kind == 'chats': if kind == 'chats':
# send 'gone' chatstate to every tabbed chat tab # send 'gone' chatstate to every tabbed chat tab
windows[jid].send_chatstate('gone', jid) windows[jid].send_chatstate('gone', jid)
gobject.source_remove(self.possible_paused_timeout_id[jid]) gobject.source_remove(self.possible_paused_timeout_id[jid])
gobject.source_remove(self.possible_inactive_timeout_id[jid]) gobject.source_remove(self.possible_inactive_timeout_id[jid])
if self.plugin.systray_enabled and self.nb_unread[jid] > 0: if gajim.interface.systray_enabled and self.nb_unread[jid] > 0:
self.plugin.systray.remove_jid(jid, self.account, gajim.interface.systray.remove_jid(jid, self.account,
self.get_message_type(jid)) self.get_message_type(jid))
del windows[jid] del windows[jid]
if self.print_time_timeout_id.has_key(jid): if self.print_time_timeout_id.has_key(jid):
@ -299,11 +298,11 @@ class Chat:
'''When history menuitem is pressed: call history window''' '''When history menuitem is pressed: call history window'''
if jid is None: if jid is None:
jid = self.get_active_jid() jid = self.get_active_jid()
if self.plugin.windows['logs'].has_key(jid): if gajim.interface.windows['logs'].has_key(jid):
self.plugin.windows['logs'][jid].window.present() gajim.interface.windows['logs'][jid].window.present()
else: else:
self.plugin.windows['logs'][jid] = history_window.HistoryWindow( gajim.interface.windows['logs'][jid] = history_window.HistoryWindow(jid,
self.plugin, jid, self.account) self.account)
def on_chat_window_focus_in_event(self, widget, event): def on_chat_window_focus_in_event(self, widget, event):
'''When window gets focus''' '''When window gets focus'''
@ -319,8 +318,8 @@ class Chat:
if self.nb_unread[jid] > 0: if self.nb_unread[jid] > 0:
self.nb_unread[jid] = 0 + self.get_specific_unread(jid) self.nb_unread[jid] = 0 + self.get_specific_unread(jid)
self.show_title() self.show_title()
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.remove_jid(jid, self.account, gajim.interface.systray.remove_jid(jid, self.account,
self.get_message_type(jid)) self.get_message_type(jid))
'''TC/GC window received focus, so if we had urgency REMOVE IT '''TC/GC window received focus, so if we had urgency REMOVE IT
@ -483,8 +482,8 @@ class Chat:
self.nb_unread[new_jid] = 0 + self.get_specific_unread(new_jid) self.nb_unread[new_jid] = 0 + self.get_specific_unread(new_jid)
self.redraw_tab(new_jid) self.redraw_tab(new_jid)
self.show_title() self.show_title()
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.remove_jid(new_jid, self.account, gajim.interface.systray.remove_jid(new_jid, self.account,
self.get_message_type(new_jid)) self.get_message_type(new_jid))
conversation_textview.grab_focus() conversation_textview.grab_focus()
@ -520,8 +519,8 @@ class Chat:
else: else:
if self.nb_unread[jid] > 0: if self.nb_unread[jid] > 0:
self.nb_unread[jid] = 0 self.nb_unread[jid] = 0
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.remove_jid(jid, self.account, gajim.interface.systray.remove_jid(jid, self.account,
self.get_message_type(jid)) self.get_message_type(jid))
if self.print_time_timeout_id.has_key(jid): if self.print_time_timeout_id.has_key(jid):
gobject.source_remove(self.print_time_timeout_id[jid]) gobject.source_remove(self.print_time_timeout_id[jid])
@ -529,8 +528,8 @@ class Chat:
self.notebook.remove_page(self.notebook.page_num(self.childs[jid])) self.notebook.remove_page(self.notebook.page_num(self.childs[jid]))
if self.plugin.windows[self.account][kind].has_key(jid): if gajim.interface.windows[self.account][kind].has_key(jid):
del self.plugin.windows[self.account][kind][jid] del gajim.interface.windows[self.account][kind][jid]
del self.nb_unread[jid] del self.nb_unread[jid]
del gajim.last_message_time[self.account][jid] del gajim.last_message_time[self.account][jid]
del self.last_time_printout[jid] del self.last_time_printout[jid]
@ -842,8 +841,8 @@ class Chat:
self.nb_unread[jid] = 0 + self.get_specific_unread(jid) self.nb_unread[jid] = 0 + self.get_specific_unread(jid)
self.redraw_tab(jid) self.redraw_tab(jid)
self.show_title() self.show_title()
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.remove_jid(jid, self.account, gajim.interface.systray.remove_jid(jid, self.account,
self.get_message_type(jid)) self.get_message_type(jid))
def on_conversation_textview_motion_notify_event(self, widget, event): def on_conversation_textview_motion_notify_event(self, widget, event):
@ -1016,24 +1015,24 @@ class Chat:
clip.set_text(text) clip.set_text(text)
def on_start_chat_activate(self, widget, jid): def on_start_chat_activate(self, widget, jid):
self.plugin.roster.new_chat_from_jid(self.account, jid) gajim.interface.roster.new_chat_from_jid(self.account, jid)
def on_join_group_chat_menuitem_activate(self, widget, jid): def on_join_group_chat_menuitem_activate(self, widget, jid):
room, server = jid.split('@') room, server = jid.split('@')
if self.plugin.windows[self.account].has_key('join_gc'): if gajim.interface.windows[self.account].has_key('join_gc'):
instance = self.plugin.windows[self.account]['join_gc'] instance = gajim.interface.windows[self.account]['join_gc']
instance.xml.get_widget('server_entry').set_text(server) instance.xml.get_widget('server_entry').set_text(server)
instance.xml.get_widget('room_entry').set_text(room) instance.xml.get_widget('room_entry').set_text(room)
self.plugin.windows[self.account]['join_gc'].window.present() gajim.interface.windows[self.account]['join_gc'].window.present()
else: else:
try: try:
self.plugin.windows[self.account]['join_gc'] = \ gajim.interface.windows[self.account]['join_gc'] = \
dialogs.JoinGroupchatWindow(self.plugin, self.account, server, room) dialogs.JoinGroupchatWindow(self.account, server, room)
except RuntimeError: except RuntimeError:
pass pass
def on_add_to_roster_activate(self, widget, jid): def on_add_to_roster_activate(self, widget, jid):
dialogs.AddNewContactWindow(self.plugin, self.account, jid) dialogs.AddNewContactWindow(self.account, jid)
def make_link_menu(self, event, kind, text): def make_link_menu(self, event, kind, text):
xml = gtk.glade.XML(GTKGUI_GLADE, 'chat_context_menu', APP) xml = gtk.glade.XML(GTKGUI_GLADE, 'chat_context_menu', APP)
@ -1102,9 +1101,9 @@ class Chat:
# basic: links + mail + formatting is always checked (we like that) # basic: links + mail + formatting is always checked (we like that)
if gajim.config.get('useemoticons'): # search for emoticons & urls if gajim.config.get('useemoticons'): # search for emoticons & urls
iterator = self.plugin.emot_and_basic_re.finditer(otext) iterator = gajim.interface.emot_and_basic_re.finditer(otext)
else: # search for just urls + mail + formatting else: # search for just urls + mail + formatting
iterator = self.plugin.basic_pattern_re.finditer(otext) iterator = gajim.interface.basic_pattern_re.finditer(otext)
for match in iterator: for match in iterator:
start, end = match.span() start, end = match.span()
special_text = otext[start:end] special_text = otext[start:end]
@ -1127,13 +1126,13 @@ class Chat:
buffer = textview.get_buffer() buffer = textview.get_buffer()
possible_emot_ascii_caps = special_text.upper() # emoticons keys are CAPS possible_emot_ascii_caps = special_text.upper() # emoticons keys are CAPS
if possible_emot_ascii_caps in self.plugin.emoticons.keys(): if possible_emot_ascii_caps in gajim.interface.emoticons.keys():
#it's an emoticon #it's an emoticon
emot_ascii = possible_emot_ascii_caps emot_ascii = possible_emot_ascii_caps
end_iter = buffer.get_end_iter() end_iter = buffer.get_end_iter()
anchor = buffer.create_child_anchor(end_iter) anchor = buffer.create_child_anchor(end_iter)
img = gtk.Image() img = gtk.Image()
img.set_from_file(self.plugin.emoticons[emot_ascii]) img.set_from_file(gajim.interface.emoticons[emot_ascii])
img.show() img.show()
#add with possible animation #add with possible animation
textview.add_child_at_anchor(img, anchor) textview.add_child_at_anchor(img, anchor)
@ -1141,7 +1140,7 @@ class Chat:
#it's a mail #it's a mail
tags.append('mail') tags.append('mail')
use_other_tags = False use_other_tags = False
elif self.plugin.sth_at_sth_dot_sth_re.match(special_text): elif gajim.interface.sth_at_sth_dot_sth_re.match(special_text):
#it's a mail #it's a mail
tags.append('mail') tags.append('mail')
use_other_tags = False use_other_tags = False
@ -1309,9 +1308,9 @@ class Chat:
if not gajim.config.get('notify_on_all_muc_messages'): if not gajim.config.get('notify_on_all_muc_messages'):
return return
self.nb_unread[jid] += 1 self.nb_unread[jid] += 1
if self.plugin.systray_enabled and gajim.config.get( if gajim.interface.systray_enabled and gajim.config.get(
'trayicon_notification_on_new_messages'): 'trayicon_notification_on_new_messages'):
self.plugin.systray.add_jid(jid, self.account, self.get_message_type(jid)) gajim.interface.systray.add_jid(jid, self.account, self.get_message_type(jid))
self.redraw_tab(jid) self.redraw_tab(jid)
self.show_title(urgent) self.show_title(urgent)

3
src/check_for_new_version.py
View file

@ -32,8 +32,7 @@ gtk.glade.textdomain(APP)
GTKGUI_GLADE='gtkgui.glade' GTKGUI_GLADE='gtkgui.glade'
class Check_for_new_version_dialog: class Check_for_new_version_dialog:
def __init__(self, plugin): def __init__(self):
self.plugin = plugin
try: try:
self.check_for_new_version() self.check_for_new_version()
except: except:

1
src/common/gajim.py
View file

@ -24,6 +24,7 @@ import mutex
import common.config import common.config
import common.logger import common.logger
interface = None # The actual interface (the gtk one for the moment)
version = '0.9' version = '0.9'
config = common.config.Config() config = common.config.Config()
connections = {} connections = {}

324
src/config.py
View file

@ -67,11 +67,10 @@ class PreferencesWindow:
def on_close_button_clicked(self, widget): def on_close_button_clicked(self, widget):
self.window.hide() self.window.hide()
def __init__(self, plugin): def __init__(self):
'''Initialize Preferences window''' '''Initialize Preferences window'''
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'preferences_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'preferences_window', APP)
self.window = self.xml.get_widget('preferences_window') self.window = self.xml.get_widget('preferences_window')
self.plugin = plugin
self.iconset_combobox = self.xml.get_widget('iconset_combobox') self.iconset_combobox = self.xml.get_widget('iconset_combobox')
self.notify_on_new_message_radiobutton = self.xml.get_widget \ self.notify_on_new_message_radiobutton = self.xml.get_widget \
('notify_on_new_message_radiobutton') ('notify_on_new_message_radiobutton')
@ -96,7 +95,7 @@ class PreferencesWindow:
self.notebook = self.xml.get_widget('preferences_notebook') self.notebook = self.xml.get_widget('preferences_notebook')
#trayicon #trayicon
if self.plugin.systray_capabilities: if gajim.interface.systray_capabilities:
st = gajim.config.get('trayicon') st = gajim.config.get('trayicon')
self.trayicon_checkbutton.set_active(st) self.trayicon_checkbutton.set_active(st)
else: else:
@ -450,38 +449,38 @@ class PreferencesWindow:
if change_sensitivity_widgets: if change_sensitivity_widgets:
for w in change_sensitivity_widgets: for w in change_sensitivity_widgets:
w.set_sensitive(widget.get_active()) w.set_sensitive(widget.get_active())
self.plugin.save_config() gajim.interface.save_config()
def on_trayicon_checkbutton_toggled(self, widget): def on_trayicon_checkbutton_toggled(self, widget):
if widget.get_active(): if widget.get_active():
gajim.config.set('trayicon', True) gajim.config.set('trayicon', True)
self.plugin.show_systray() gajim.interface.show_systray()
self.plugin.roster.update_status_comboxbox() gajim.interface.roster.update_status_comboxbox()
else: else:
gajim.config.set('trayicon', False) gajim.config.set('trayicon', False)
self.plugin.hide_systray() gajim.interface.hide_systray()
gajim.config.set('show_roster_on_startup', True) # no tray, show roster! gajim.config.set('show_roster_on_startup', True) # no tray, show roster!
self.plugin.roster.draw_roster() gajim.interface.roster.draw_roster()
self.plugin.save_config() gajim.interface.save_config()
def on_save_position_checkbutton_toggled(self, widget): def on_save_position_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'saveposition') self.on_checkbutton_toggled(widget, 'saveposition')
def on_merge_checkbutton_toggled(self, widget): def on_merge_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'mergeaccounts') self.on_checkbutton_toggled(widget, 'mergeaccounts')
self.plugin.roster.regroup = gajim.config.get('mergeaccounts') gajim.interface.roster.regroup = gajim.config.get('mergeaccounts')
self.plugin.roster.draw_roster() gajim.interface.roster.draw_roster()
def on_sort_by_show_checkbutton_toggled(self, widget): def on_sort_by_show_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'sort_by_show') self.on_checkbutton_toggled(widget, 'sort_by_show')
self.plugin.roster.draw_roster() gajim.interface.roster.draw_roster()
def on_use_emoticons_checkbutton_toggled(self, widget): def on_use_emoticons_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'useemoticons', self.on_checkbutton_toggled(widget, 'useemoticons',
[self.xml.get_widget('add_remove_emoticons_button')]) [self.xml.get_widget('add_remove_emoticons_button')])
def on_add_remove_emoticons_button_clicked(self, widget): def on_add_remove_emoticons_button_clicked(self, widget):
window = self.plugin.windows['add_remove_emoticons'].window window = gajim.interface.windows['add_remove_emoticons'].window
if window.get_property('visible'): if window.get_property('visible'):
window.present() window.present()
else: else:
@ -492,15 +491,15 @@ class PreferencesWindow:
active = widget.get_active() active = widget.get_active()
icon_string = model[active][1].decode('utf-8') icon_string = model[active][1].decode('utf-8')
gajim.config.set('iconset', icon_string) gajim.config.set('iconset', icon_string)
self.plugin.roster.reload_jabber_state_images() gajim.interface.roster.reload_jabber_state_images()
self.plugin.save_config() gajim.interface.save_config()
def on_transports_iconsets_checkbutton_toggled(self, widget): def on_transports_iconsets_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'use_transports_iconsets') self.on_checkbutton_toggled(widget, 'use_transports_iconsets')
self.plugin.roster.draw_roster() gajim.interface.roster.draw_roster()
def on_manage_theme_button_clicked(self, widget): def on_manage_theme_button_clicked(self, widget):
dialogs.GajimThemesWindow(self.plugin) dialogs.GajimThemesWindow()
def on_theme_combobox_changed(self, widget): def on_theme_combobox_changed(self, widget):
model = widget.get_model() model = widget.get_model()
@ -510,9 +509,9 @@ class PreferencesWindow:
gajim.config.set('roster_theme', config_theme) gajim.config.set('roster_theme', config_theme)
# begin repainting themed widgets throughout # begin repainting themed widgets throughout
self.plugin.roster.repaint_themed_widgets() gajim.interface.roster.repaint_themed_widgets()
self.plugin.roster.change_roster_style(None) gajim.interface.roster.change_roster_style(None)
self.plugin.save_config() gajim.interface.save_config()
def merge_windows(self, kind): def merge_windows(self, kind):
for acct in gajim.connections: for acct in gajim.connections:
@ -520,7 +519,7 @@ class PreferencesWindow:
buf1 = {} buf1 = {}
buf2 = {} buf2 = {}
saved_var = {} saved_var = {}
windows = self.plugin.windows[acct][kind] windows = gajim.interface.windows[acct][kind]
jids = windows.keys() jids = windows.keys()
for jid in jids: for jid in jids:
window = windows[jid] window = windows[jid]
@ -534,9 +533,9 @@ class PreferencesWindow:
for jid in jids: for jid in jids:
if kind == 'chats': if kind == 'chats':
c = gajim.get_contact_instance_with_highest_priority(acct, jid) c = gajim.get_contact_instance_with_highest_priority(acct, jid)
self.plugin.roster.new_chat(c, acct) gajim.interface.roster.new_chat(c, acct)
if kind == 'gc': if kind == 'gc':
self.plugin.roster.new_room(jid, saved_var[jid]['nick'], acct) gajim.interface.roster.new_room(jid, saved_var[jid]['nick'], acct)
window = windows[jid] window = windows[jid]
window.xmls[jid].get_widget('conversation_textview').set_buffer( window.xmls[jid].get_widget('conversation_textview').set_buffer(
buf1[jid]) buf1[jid])
@ -550,7 +549,7 @@ class PreferencesWindow:
buf1 = {} buf1 = {}
buf2 = {} buf2 = {}
saved_var = {} saved_var = {}
windows = self.plugin.windows[acct][kind] windows = gajim.interface.windows[acct][kind]
jids = windows.keys() jids = windows.keys()
if not 'tabbed' in jids: if not 'tabbed' in jids:
continue continue
@ -567,9 +566,9 @@ class PreferencesWindow:
for jid in jids: for jid in jids:
if kind == 'chats': if kind == 'chats':
c = gajim.get_contact_instance_with_highest_priority(acct, jid) c = gajim.get_contact_instance_with_highest_priority(acct, jid)
self.plugin.roster.new_chat(c, acct) gajim.interface.roster.new_chat(c, acct)
if kind == 'gc': if kind == 'gc':
self.plugin.roster.new_room(jid, saved_var[jid]['nick'], acct) gajim.interface.roster.new_room(jid, saved_var[jid]['nick'], acct)
window = windows[jid] window = windows[jid]
window.xmls[jid].get_widget('conversation_textview').set_buffer( window.xmls[jid].get_widget('conversation_textview').set_buffer(
buf1[jid]) buf1[jid])
@ -589,11 +588,11 @@ class PreferencesWindow:
else: else:
self.split_windows('chats') self.split_windows('chats')
self.split_windows('gc') self.split_windows('gc')
self.plugin.save_config() gajim.interface.save_config()
def apply_speller(self, kind): def apply_speller(self, kind):
for acct in gajim.connections: for acct in gajim.connections:
windows = self.plugin.windows[acct][kind] windows = gajim.interface.windows[acct][kind]
jids = windows.keys() jids = windows.keys()
for jid in jids: for jid in jids:
if jid == 'tabbed': if jid == 'tabbed':
@ -604,7 +603,7 @@ class PreferencesWindow:
def remove_speller(self, kind): def remove_speller(self, kind):
for acct in gajim.connections: for acct in gajim.connections:
windows = self.plugin.windows[acct][kind] windows = gajim.interface.windows[acct][kind]
jids = windows.keys() jids = windows.keys()
for jid in jids: for jid in jids:
if jid == 'tabbed': if jid == 'tabbed':
@ -618,7 +617,7 @@ class PreferencesWindow:
def on_speller_checkbutton_toggled(self, widget): def on_speller_checkbutton_toggled(self, widget):
active = widget.get_active() active = widget.get_active()
gajim.config.set('use_speller', active) gajim.config.set('use_speller', active)
self.plugin.save_config() gajim.interface.save_config()
if active: if active:
self.apply_speller('chats') self.apply_speller('chats')
self.apply_speller('gc') self.apply_speller('gc')
@ -629,7 +628,7 @@ class PreferencesWindow:
def update_print_time(self): def update_print_time(self):
'''Update time in Opened Chat Windows''' '''Update time in Opened Chat Windows'''
for a in gajim.connections: for a in gajim.connections:
window = self.plugin.windows[a]['chats'] window = gajim.interface.windows[a]['chats']
if window.has_key('tabbed'): if window.has_key('tabbed'):
window['tabbed'].update_print_time() window['tabbed'].update_print_time()
else: else:
@ -640,41 +639,41 @@ class PreferencesWindow:
if widget.get_active(): if widget.get_active():
gajim.config.set('print_time', 'never') gajim.config.set('print_time', 'never')
self.update_print_time() self.update_print_time()
self.plugin.save_config() gajim.interface.save_config()
def on_time_sometimes_radiobutton_toggled(self, widget): def on_time_sometimes_radiobutton_toggled(self, widget):
if widget.get_active(): if widget.get_active():
gajim.config.set('print_time', 'sometimes') gajim.config.set('print_time', 'sometimes')
self.update_print_time() self.update_print_time()
self.plugin.save_config() gajim.interface.save_config()
def on_time_always_radiobutton_toggled(self, widget): def on_time_always_radiobutton_toggled(self, widget):
if widget.get_active(): if widget.get_active():
gajim.config.set('print_time', 'always') gajim.config.set('print_time', 'always')
self.update_print_time() self.update_print_time()
self.plugin.save_config() gajim.interface.save_config()
def on_before_time_entry_focus_out_event(self, widget, event): def on_before_time_entry_focus_out_event(self, widget, event):
gajim.config.set('before_time', widget.get_text().decode('utf-8')) gajim.config.set('before_time', widget.get_text().decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def on_after_time_entry_focus_out_event(self, widget, event): def on_after_time_entry_focus_out_event(self, widget, event):
gajim.config.set('after_time', widget.get_text().decode('utf-8')) gajim.config.set('after_time', widget.get_text().decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def on_before_nickname_entry_focus_out_event(self, widget, event): def on_before_nickname_entry_focus_out_event(self, widget, event):
gajim.config.set('before_nickname', widget.get_text().decode('utf-8')) gajim.config.set('before_nickname', widget.get_text().decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def on_after_nickname_entry_focus_out_event(self, widget, event): def on_after_nickname_entry_focus_out_event(self, widget, event):
gajim.config.set('after_nickname', widget.get_text().decode('utf-8')) gajim.config.set('after_nickname', widget.get_text().decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def update_text_tags(self): def update_text_tags(self):
'''Update color tags in Opened Chat Windows''' '''Update color tags in Opened Chat Windows'''
for a in gajim.connections: for a in gajim.connections:
for kind in ['chats', 'gc']: for kind in ['chats', 'gc']:
windows = self.plugin.windows[a][kind] windows = gajim.interface.windows[a][kind]
if windows.has_key('tabbed'): if windows.has_key('tabbed'):
windows['tabbed'].update_tags() windows['tabbed'].update_tags()
else: else:
@ -685,7 +684,7 @@ class PreferencesWindow:
'''Update text font in Opened Chat Windows''' '''Update text font in Opened Chat Windows'''
for a in gajim.connections: for a in gajim.connections:
for kind in ['chats', 'gc']: for kind in ['chats', 'gc']:
windows = self.plugin.windows[a][kind] windows = gajim.interface.windows[a][kind]
if windows.has_key('tabbed'): if windows.has_key('tabbed'):
windows['tabbed'].update_font() windows['tabbed'].update_font()
else: else:
@ -697,13 +696,13 @@ class PreferencesWindow:
color_string = mk_color_string(color) color_string = mk_color_string(color)
gajim.config.set(text, color_string) gajim.config.set(text, color_string)
self.update_text_tags() self.update_text_tags()
self.plugin.save_config() gajim.interface.save_config()
def on_preference_widget_font_set(self, widget, text): def on_preference_widget_font_set(self, widget, text):
font = widget.get_font_name() font = widget.get_font_name()
gajim.config.set(text, font) gajim.config.set(text, font)
self.update_text_font() self.update_text_font()
self.plugin.save_config() gajim.interface.save_config()
def on_incoming_msg_colorbutton_color_set(self, widget): def on_incoming_msg_colorbutton_color_set(self, widget):
self.on_preference_widget_color_set(widget, 'inmsgcolor') self.on_preference_widget_color_set(widget, 'inmsgcolor')
@ -719,7 +718,7 @@ class PreferencesWindow:
def on_reset_colors_button_clicked(self, widget): def on_reset_colors_button_clicked(self, widget):
for i in ['inmsgcolor', 'outmsgcolor', 'statusmsgcolor']: for i in ['inmsgcolor', 'outmsgcolor', 'statusmsgcolor']:
gajim.config.set(i, self.plugin.default_values[i]) gajim.config.set(i, gajim.interface.default_values[i])
self.xml.get_widget('incoming_msg_colorbutton').set_color(\ self.xml.get_widget('incoming_msg_colorbutton').set_color(\
gtk.gdk.color_parse(gajim.config.get('inmsgcolor'))) gtk.gdk.color_parse(gajim.config.get('inmsgcolor')))
@ -728,7 +727,7 @@ class PreferencesWindow:
self.xml.get_widget('status_msg_colorbutton').set_color(\ self.xml.get_widget('status_msg_colorbutton').set_color(\
gtk.gdk.color_parse(gajim.config.get('statusmsgcolor'))) gtk.gdk.color_parse(gajim.config.get('statusmsgcolor')))
self.update_text_tags() self.update_text_tags()
self.plugin.save_config() gajim.interface.save_config()
def on_notify_on_new_message_radiobutton_toggled(self, widget): def on_notify_on_new_message_radiobutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'notify_on_new_message', self.on_checkbutton_toggled(widget, 'notify_on_new_message',
@ -772,7 +771,7 @@ class PreferencesWindow:
def on_soundplayer_entry_changed(self, widget): def on_soundplayer_entry_changed(self, widget):
gajim.config.set('soundplayer', widget.get_text().decode('utf-8')) gajim.config.set('soundplayer', widget.get_text().decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def on_prompt_online_status_message_checkbutton_toggled(self, widget): def on_prompt_online_status_message_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'ask_online_status') self.on_checkbutton_toggled(widget, 'ask_online_status')
@ -786,7 +785,7 @@ class PreferencesWindow:
bool(model[path][1])) bool(model[path][1]))
gajim.config.set_per('soundevents', sound_event, 'path', gajim.config.set_per('soundevents', sound_event, 'path',
model[iter][2].decode('utf-8')) model[iter][2].decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def on_auto_away_checkbutton_toggled(self, widget): def on_auto_away_checkbutton_toggled(self, widget):
self.on_checkbutton_toggled(widget, 'autoaway', self.on_checkbutton_toggled(widget, 'autoaway',
@ -795,10 +794,10 @@ class PreferencesWindow:
def on_auto_away_time_spinbutton_value_changed(self, widget): def on_auto_away_time_spinbutton_value_changed(self, widget):
aat = widget.get_value_as_int() aat = widget.get_value_as_int()
gajim.config.set('autoawaytime', aat) gajim.config.set('autoawaytime', aat)
self.plugin.sleeper = common.sleepy.Sleepy( gajim.interface.sleeper = common.sleepy.Sleepy(
gajim.config.get('autoawaytime') * 60, gajim.config.get('autoawaytime') * 60,
gajim.config.get('autoxatime') * 60) gajim.config.get('autoxatime') * 60)
self.plugin.save_config() gajim.interface.save_config()
def on_auto_away_message_entry_changed(self, widget): def on_auto_away_message_entry_changed(self, widget):
gajim.config.set('autoaway_message', widget.get_text().decode('utf-8')) gajim.config.set('autoaway_message', widget.get_text().decode('utf-8'))
@ -810,10 +809,10 @@ class PreferencesWindow:
def on_auto_xa_time_spinbutton_value_changed(self, widget): def on_auto_xa_time_spinbutton_value_changed(self, widget):
axt = widget.get_value_as_int() axt = widget.get_value_as_int()
gajim.config.set('autoxatime', axt) gajim.config.set('autoxatime', axt)
self.plugin.sleeper = common.sleepy.Sleepy( gajim.interface.sleeper = common.sleepy.Sleepy(
gajim.config.get('autoawaytime') * 60, gajim.config.get('autoawaytime') * 60,
gajim.config.get('autoxatime') * 60) gajim.config.get('autoxatime') * 60)
self.plugin.save_config() gajim.interface.save_config()
def on_auto_xa_message_entry_changed(self, widget): def on_auto_xa_message_entry_changed(self, widget):
gajim.config.set('autoxa_message', widget.get_text().decode('utf-8')) gajim.config.set('autoxa_message', widget.get_text().decode('utf-8'))
@ -828,7 +827,7 @@ class PreferencesWindow:
gajim.config.set_per('statusmsg', val, 'message', gajim.config.set_per('statusmsg', val, 'message',
model[iter][1].decode('utf-8')) model[iter][1].decode('utf-8'))
iter = model.iter_next(iter) iter = model.iter_next(iter)
self.plugin.save_config() gajim.interface.save_config()
def on_msg_treemodel_row_changed(self, model, path, iter): def on_msg_treemodel_row_changed(self, model, path, iter):
self.save_status_messages(model) self.save_status_messages(model)
@ -849,35 +848,35 @@ class PreferencesWindow:
elif widget.get_active() == 2: elif widget.get_active() == 2:
gajim.config.set('openwith', 'kfmclient exec') gajim.config.set('openwith', 'kfmclient exec')
self.xml.get_widget('custom_apps_frame').set_sensitive(False) self.xml.get_widget('custom_apps_frame').set_sensitive(False)
self.plugin.save_config() gajim.interface.save_config()
def on_custom_browser_entry_changed(self, widget): def on_custom_browser_entry_changed(self, widget):
gajim.config.set('custombrowser', widget.get_text().decode('utf-8')) gajim.config.set('custombrowser', widget.get_text().decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def on_custom_mail_client_entry_changed(self, widget): def on_custom_mail_client_entry_changed(self, widget):
gajim.config.set('custommailapp', widget.get_text().decode('utf-8')) gajim.config.set('custommailapp', widget.get_text().decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def on_custom_file_manager_entry_changed(self, widget): def on_custom_file_manager_entry_changed(self, widget):
gajim.config.set('custom_file_manager', widget.get_text().decode('utf-8')) gajim.config.set('custom_file_manager', widget.get_text().decode('utf-8'))
self.plugin.save_config() gajim.interface.save_config()
def on_log_in_contact_checkbutton_toggled(self, widget): def on_log_in_contact_checkbutton_toggled(self, widget):
gajim.config.set('log_notif_in_user_file', widget.get_active()) gajim.config.set('log_notif_in_user_file', widget.get_active())
self.plugin.save_config() gajim.interface.save_config()
def on_log_in_extern_checkbutton_toggled(self, widget): def on_log_in_extern_checkbutton_toggled(self, widget):
gajim.config.set('log_notif_in_sep_file', widget.get_active()) gajim.config.set('log_notif_in_sep_file', widget.get_active())
self.plugin.save_config() gajim.interface.save_config()
def on_send_os_info_checkbutton_toggled(self, widget): def on_send_os_info_checkbutton_toggled(self, widget):
gajim.config.set('send_os_info', widget.get_active()) gajim.config.set('send_os_info', widget.get_active())
self.plugin.save_config() gajim.interface.save_config()
def on_check_for_new_version_checkbutton_toggled(self, widget): def on_check_for_new_version_checkbutton_toggled(self, widget):
gajim.config.set('check_for_new_version', widget.get_active()) gajim.config.set('check_for_new_version', widget.get_active())
self.plugin.save_config() gajim.interface.save_config()
def fill_msg_treeview(self): def fill_msg_treeview(self):
self.xml.get_widget('delete_msg_button').set_sensitive(False) self.xml.get_widget('delete_msg_button').set_sensitive(False)
@ -1008,31 +1007,30 @@ class PreferencesWindow:
model.set_value(iter, 1, 1) model.set_value(iter, 1, 1)
def on_open_advanced_editor_button_clicked(self, widget, data = None): def on_open_advanced_editor_button_clicked(self, widget, data = None):
if self.plugin.windows.has_key('advanced_config'): if gajim.interface.windows.has_key('advanced_config'):
self.plugin.windows['advanced_config'].window.present() gajim.interface.windows['advanced_config'].window.present()
else: else:
self.plugin.windows['advanced_config'] = \ gajim.interface.windows['advanced_config'] = \
dialogs.AdvancedConfigurationWindow(self.plugin) dialogs.AdvancedConfigurationWindow(gajim.interface)
#---------- AccountModificationWindow class -------------# #---------- AccountModificationWindow class -------------#
class AccountModificationWindow: class AccountModificationWindow:
'''Class for account informations''' '''Class for account informations'''
def on_account_modification_window_destroy(self, widget): def on_account_modification_window_destroy(self, widget):
'''close window''' '''close window'''
if self.plugin.windows.has_key(self.account): if gajim.interface.windows.has_key(self.account):
if self.plugin.windows[self.account].has_key('account_modification'): if gajim.interface.windows[self.account].has_key('account_modification'):
del self.plugin.windows[self.account]['account_modification'] del gajim.interface.windows[self.account]['account_modification']
return return
if self.plugin.windows.has_key('account_modification'): if gajim.interface.windows.has_key('account_modification'):
del self.plugin.windows['account_modification'] del gajim.interface.windows['account_modification']
def on_cancel_button_clicked(self, widget): def on_cancel_button_clicked(self, widget):
self.window.destroy() self.window.destroy()
def __init__(self, plugin, account = ''): def __init__(self, account = ''):
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'account_modification_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'account_modification_window', APP)
self.window = self.xml.get_widget('account_modification_window') self.window = self.xml.get_widget('account_modification_window')
self.plugin = plugin
self.account = account self.account = account
self.modify = False # if we 're modifying an existing or creating a new account self.modify = False # if we 're modifying an existing or creating a new account
@ -1262,7 +1260,7 @@ _('To change the account name, you must be disconnected.')).get_response()
#if we modify the name of the account #if we modify the name of the account
if name != self.account: if name != self.account:
#update variables #update variables
self.plugin.windows[name] = self.plugin.windows[self.account] gajim.interface.windows[name] = gajim.interface.windows[self.account]
gajim.awaiting_events[name] = gajim.awaiting_events[self.account] gajim.awaiting_events[name] = gajim.awaiting_events[self.account]
gajim.nicks[name] = gajim.nicks[self.account] gajim.nicks[name] = gajim.nicks[self.account]
gajim.allow_notifications[name] = \ gajim.allow_notifications[name] = \
@ -1283,16 +1281,16 @@ _('To change the account name, you must be disconnected.')).get_response()
#upgrade account variable in opened windows #upgrade account variable in opened windows
for kind in ['infos', 'chats', 'gc', 'gc_config']: for kind in ['infos', 'chats', 'gc', 'gc_config']:
for j in self.plugin.windows[name][kind]: for j in gajim.interface.windows[name][kind]:
self.plugin.windows[name][kind][j].account = name gajim.interface.windows[name][kind][j].account = name
#upgrade account in systray #upgrade account in systray
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
for list in self.plugin.systray.jids: for list in gajim.interface.systray.jids:
if list[0] == self.account: if list[0] == self.account:
list[0] = name list[0] = name
del self.plugin.windows[self.account] del gajim.interface.windows[self.account]
del gajim.awaiting_events[self.account] del gajim.awaiting_events[self.account]
del gajim.nicks[self.account] del gajim.nicks[self.account]
del gajim.allow_notifications[self.account] del gajim.allow_notifications[self.account]
@ -1319,11 +1317,11 @@ _('To change the account name, you must be disconnected.')).get_response()
if config['savepass']: if config['savepass']:
gajim.connections[name].password = config['password'] gajim.connections[name].password = config['password']
#refresh accounts window #refresh accounts window
if self.plugin.windows.has_key('accounts'): if gajim.interface.windows.has_key('accounts'):
self.plugin.windows['accounts'].init_accounts() gajim.interface.windows['accounts'].init_accounts()
#refresh roster #refresh roster
self.plugin.roster.draw_roster() gajim.interface.roster.draw_roster()
self.plugin.save_config() gajim.interface.save_config()
self.window.destroy() self.window.destroy()
return return
#if it's a new account #if it's a new account
@ -1332,7 +1330,7 @@ _('To change the account name, you must be disconnected.')).get_response()
_('You already have an account using this name.')).get_response() _('You already have an account using this name.')).get_response()
return return
con = connection.Connection(name) con = connection.Connection(name)
self.plugin.register_handlers(con) gajim.interface.register_handlers(con)
#if we need to register a new account #if we need to register a new account
if new_account: if new_account:
gajim.events_for_ui[name] = [] gajim.events_for_ui[name] = []
@ -1346,10 +1344,10 @@ _('To change the account name, you must be disconnected.')).get_response()
if config['savepass']: if config['savepass']:
gajim.connections[name].password = config['password'] gajim.connections[name].password = config['password']
#update variables #update variables
self.plugin.windows[name] = {'infos': {}, 'chats': {}, 'gc': {}, \ gajim.interface.windows[name] = {'infos': {}, 'chats': {}, 'gc': {}, \
'gc_config': {}} 'gc_config': {}}
self.plugin.windows[name]['xml_console'] = \ gajim.interface.windows[name]['xml_console'] = \
dialogs.XMLConsoleWindow(self.plugin, name) dialogs.XMLConsoleWindow(name)
gajim.awaiting_events[name] = {} gajim.awaiting_events[name] = {}
gajim.connections[name].connected = 0 gajim.connections[name].connected = 0
gajim.groups[name] = {} gajim.groups[name] = {}
@ -1366,16 +1364,16 @@ _('To change the account name, you must be disconnected.')).get_response()
gajim.status_before_autoaway[name] = '' gajim.status_before_autoaway[name] = ''
gajim.events_for_ui[name] = [] gajim.events_for_ui[name] = []
#refresh accounts window #refresh accounts window
if self.plugin.windows.has_key('accounts'): if gajim.interface.windows.has_key('accounts'):
self.plugin.windows['accounts'].init_accounts() gajim.interface.windows['accounts'].init_accounts()
#refresh roster #refresh roster
self.plugin.roster.draw_roster() gajim.interface.roster.draw_roster()
self.plugin.save_config() gajim.interface.save_config()
self.window.destroy() self.window.destroy()
def on_change_password_button_clicked(self, widget): def on_change_password_button_clicked(self, widget):
try: try:
dialog = dialogs.ChangePasswordDialog(self.plugin, self.account) dialog = dialogs.ChangePasswordDialog(self.account)
except RuntimeError: except RuntimeError:
#if we showed ErrorDialog, there will not be dialog instance #if we showed ErrorDialog, there will not be dialog instance
return return
@ -1394,7 +1392,7 @@ _('To change the account name, you must be disconnected.')).get_response()
self.account = acct self.account = acct
def on_edit_details_button_clicked(self, widget): def on_edit_details_button_clicked(self, widget):
if not self.plugin.windows.has_key(self.account): if not gajim.interface.windows.has_key(self.account):
dialogs.ErrorDialog(_('No such account available'), dialogs.ErrorDialog(_('No such account available'),
_('You must create your account before editing your personal information.')).get_response() _('You must create your account before editing your personal information.')).get_response()
return return
@ -1407,17 +1405,17 @@ _('To change the account name, you must be disconnected.')).get_response()
_('Without a connection, you can not edit your personal information.') _('Without a connection, you can not edit your personal information.')
).get_response() ).get_response()
return return
if not self.plugin.windows[self.account]['infos'].has_key('vcard'): if not gajim.interface.windows[self.account]['infos'].has_key('vcard'):
self.plugin.windows[self.account]['infos'][jid] = \ gajim.interface.windows[self.account]['infos'][jid] = \
dialogs.VcardWindow(jid, self.plugin, self.account, True) dialogs.VcardWindow(jid, self.account, True)
gajim.connections[self.account].request_vcard(jid) gajim.connections[self.account].request_vcard(jid)
def on_manage_proxies_button_clicked(self, widget): def on_manage_proxies_button_clicked(self, widget):
if self.plugin.windows.has_key('manage_proxies'): if gajim.interface.windows.has_key('manage_proxies'):
self.plugin.windows['manage_proxies'].window.present() gajim.interface.windows['manage_proxies'].window.present()
else: else:
self.plugin.windows['manage_proxies'] = \ gajim.interface.windows['manage_proxies'] = \
ManageProxiesWindow(self.plugin) ManageProxiesWindow()
def on_gpg_choose_button_clicked(self, widget, data = None): def on_gpg_choose_button_clicked(self, widget, data = None):
if gajim.connections.has_key(self.account): if gajim.connections.has_key(self.account):
@ -1498,8 +1496,7 @@ _('There was a problem retrieving your OpenPGP secret keys.')).get_response()
#---------- ManageProxiesWindow class -------------# #---------- ManageProxiesWindow class -------------#
class ManageProxiesWindow: class ManageProxiesWindow:
def __init__(self, plugin): def __init__(self):
self.plugin = plugin
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'manage_proxies_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'manage_proxies_window', APP)
self.window = self.xml.get_widget('manage_proxies_window') self.window = self.xml.get_widget('manage_proxies_window')
self.proxies_treeview = self.xml.get_widget('proxies_treeview') self.proxies_treeview = self.xml.get_widget('proxies_treeview')
@ -1533,12 +1530,12 @@ class ManageProxiesWindow:
def on_manage_proxies_window_destroy(self, widget): def on_manage_proxies_window_destroy(self, widget):
for account in gajim.connections: for account in gajim.connections:
if self.plugin.windows[account].has_key('account_modification'): if gajim.interface.windows[account].has_key('account_modification'):
self.plugin.windows[account]['account_modification'].\ gajim.interface.windows[account]['account_modification'].\
update_proxy_list() update_proxy_list()
if self.plugin.windows.has_key('account_modification'): if gajim.interface.windows.has_key('account_modification'):
self.plugin.windows['account_modification'].update_proxy_list() gajim.interface.windows['account_modification'].update_proxy_list()
del self.plugin.windows['manage_proxies'] del gajim.interface.windows['manage_proxies']
def on_add_proxy_button_clicked(self, widget): def on_add_proxy_button_clicked(self, widget):
model = self.proxies_treeview.get_model() model = self.proxies_treeview.get_model()
@ -1658,13 +1655,12 @@ class ManageProxiesWindow:
class AccountsWindow: class AccountsWindow:
'''Class for accounts window: list of accounts''' '''Class for accounts window: list of accounts'''
def on_accounts_window_destroy(self, widget): def on_accounts_window_destroy(self, widget):
del self.plugin.windows['accounts'] del gajim.interface.windows['accounts']
def on_close_button_clicked(self, widget): def on_close_button_clicked(self, widget):
self.window.destroy() self.window.destroy()
def __init__(self, plugin): def __init__(self):
self.plugin = plugin
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'accounts_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'accounts_window', APP)
self.window = self.xml.get_widget('accounts_window') self.window = self.xml.get_widget('accounts_window')
self.accounts_treeview = self.xml.get_widget('accounts_treeview') self.accounts_treeview = self.xml.get_widget('accounts_treeview')
@ -1705,11 +1701,11 @@ class AccountsWindow:
def on_new_button_clicked(self, widget): def on_new_button_clicked(self, widget):
'''When new button is clicked: open an account information window''' '''When new button is clicked: open an account information window'''
if self.plugin.windows.has_key('account_modification'): if gajim.interface.windows.has_key('account_modification'):
self.plugin.windows['account_modification'].window.present() gajim.interface.windows['account_modification'].window.present()
else: else:
self.plugin.windows['account_modification'] = \ gajim.interface.windows['account_modification'] = \
AccountModificationWindow(self.plugin, '') AccountModificationWindow('')
def on_remove_button_clicked(self, widget): def on_remove_button_clicked(self, widget):
'''When delete button is clicked: '''When delete button is clicked:
@ -1719,11 +1715,11 @@ class AccountsWindow:
if not iter: if not iter:
return return
account = model.get_value(iter, 0).decode('utf-8') account = model.get_value(iter, 0).decode('utf-8')
if self.plugin.windows[account].has_key('remove_account'): if gajim.interface.windows[account].has_key('remove_account'):
self.plugin.windows[account]['remove_account'].window.present() gajim.interface.windows[account]['remove_account'].window.present()
else: else:
self.plugin.windows[account]['remove_account'] = \ gajim.interface.windows[account]['remove_account'] = \
RemoveAccountWindow(self.plugin, account) RemoveAccountWindow(account)
def on_modify_button_clicked(self, widget): def on_modify_button_clicked(self, widget):
'''When modify button is clicked: '''When modify button is clicked:
@ -1742,15 +1738,14 @@ class AccountsWindow:
self.show_modification_window(account) self.show_modification_window(account)
def show_modification_window(self, account): def show_modification_window(self, account):
if self.plugin.windows[account].has_key('account_modification'): if gajim.interface.windows[account].has_key('account_modification'):
self.plugin.windows[account]['account_modification'].window.present() gajim.interface.windows[account]['account_modification'].window.present()
else: else:
self.plugin.windows[account]['account_modification'] = \ gajim.interface.windows[account]['account_modification'] = \
AccountModificationWindow(self.plugin, account) AccountModificationWindow(account)
class DataFormWindow: class DataFormWindow:
def __init__(self, plugin, account, config): def __init__(self, account, config):
self.plugin = plugin
self.account = account self.account = account
self.config = config self.config = config
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'data_form_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'data_form_window', APP)
@ -1907,7 +1902,7 @@ class ServiceRegistrationWindow(DataFormWindow):
groups = [_('Transports')], show = 'offline', status = 'offline', groups = [_('Transports')], show = 'offline', status = 'offline',
sub = 'from') sub = 'from')
gajim.contacts[self.account][self.service] = [user1] gajim.contacts[self.account][self.service] = [user1]
self.plugin.roster.add_contact_to_roster(self.service, self.account) gajim.interface.roster.add_contact_to_roster(self.service, self.account)
def on_ok_button_clicked(self, widget): def on_ok_button_clicked(self, widget):
'''When Ok button is clicked: '''When Ok button is clicked:
@ -1933,13 +1928,12 @@ class ServiceRegistrationWindow(DataFormWindow):
True) # True is for is_form True) # True is for is_form
self.window.destroy() self.window.destroy()
def __init__(self, service, infos, plugin, account, is_form): def __init__(self, service, infos, account, is_form):
self.service = service self.service = service
self.infos = infos self.infos = infos
self.plugin = plugin
self.account = account self.account = account
if is_form: if is_form:
DataFormWindow.__init__(self, plugin, account, infos) DataFormWindow.__init__(self, account, infos)
else: else:
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'service_registration_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'service_registration_window', APP)
self.window = self.xml.get_widget('service_registration_window') self.window = self.xml.get_widget('service_registration_window')
@ -1956,10 +1950,9 @@ class ServiceRegistrationWindow(DataFormWindow):
#---------- ManageEmoticonsWindow class -------------# #---------- ManageEmoticonsWindow class -------------#
class ManageEmoticonsWindow: class ManageEmoticonsWindow:
def __init__(self, plugin): def __init__(self):
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'manage_emoticons_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'manage_emoticons_window', APP)
self.window = self.xml.get_widget('manage_emoticons_window') self.window = self.xml.get_widget('manage_emoticons_window')
self.plugin = plugin
#emoticons #emoticons
self.emot_tree = self.xml.get_widget('emoticons_treeview') self.emot_tree = self.xml.get_widget('emoticons_treeview')
@ -1984,12 +1977,11 @@ class ManageEmoticonsWindow:
self.emot_tree.get_model().connect('row-changed', self.emot_tree.get_model().connect('row-changed',
self.on_emoticons_treemodel_row_changed) self.on_emoticons_treemodel_row_changed)
self.plugin = plugin
self.xml.signal_autoconnect(self) self.xml.signal_autoconnect(self)
def on_add_remove_emoticons_window_delete_event(self, widget, event): def on_add_remove_emoticons_window_delete_event(self, widget, event):
self.window.hide() self.window.hide()
self.plugin.init_regexp() # update regexp [emoticons included] gajim.interface.init_regexp() # update regexp [emoticons included]
return True # do NOT destroy the window return True # do NOT destroy the window
def on_close_button_clicked(self, widget): def on_close_button_clicked(self, widget):
@ -2000,12 +1992,12 @@ class ManageEmoticonsWindow:
emot = model.get_value(iter, 0).decode('utf-8').upper() emot = model.get_value(iter, 0).decode('utf-8').upper()
if not emot in emots: if not emot in emots:
gajim.config.add_per('emoticons', emot) gajim.config.add_per('emoticons', emot)
self.plugin.init_regexp() # update regexp [emoticons included] gajim.interface.init_regexp() # update regexp [emoticons included]
image = model[iter][1] image = model[iter][1]
if image: if image:
image = image.decode('utf-8') image = image.decode('utf-8')
gajim.config.set_per('emoticons', emot, 'path', image) gajim.config.set_per('emoticons', emot, 'path', image)
self.plugin.save_config() gajim.interface.save_config()
def image_is_ok(self, image): def image_is_ok(self, image):
if not os.path.exists(image): if not os.path.exists(image):
@ -2060,11 +2052,11 @@ class ManageEmoticonsWindow:
model.remove(iter) model.remove(iter)
else: else:
gajim.config.add_per('emoticons', emot) gajim.config.add_per('emoticons', emot)
self.plugin.init_regexp() # update regexp (emoticons included) gajim.interface.init_regexp() # update regexp (emoticons included)
gajim.config.set_per('emoticons', emot, 'path', gajim.config.set_per('emoticons', emot, 'path',
model[iter][1].decode('utf-8')) model[iter][1].decode('utf-8'))
model[iter][0] = emot model[iter][0] = emot
self.plugin.save_config() gajim.interface.save_config()
def update_preview(self, widget): def update_preview(self, widget):
path_to_file = widget.get_preview_filename() path_to_file = widget.get_preview_filename()
@ -2157,8 +2149,8 @@ class ManageEmoticonsWindow:
if not iter: if not iter:
return return
gajim.config.del_per('emoticons', model.get_value(iter, 0).decode('utf-8')) gajim.config.del_per('emoticons', model.get_value(iter, 0).decode('utf-8'))
self.plugin.init_regexp() # update regexp [emoticons included] gajim.interface.init_regexp() # update regexp [emoticons included]
self.plugin.save_config() gajim.interface.save_config()
model.remove(iter) model.remove(iter)
def on_emoticons_treeview_key_press_event(self, widget, event): def on_emoticons_treeview_key_press_event(self, widget, event):
@ -2171,13 +2163,12 @@ class ServiceDiscoveryWindow:
'''Class for Service Discovery Window: '''Class for Service Discovery Window:
to know the services on a server''' to know the services on a server'''
def on_service_discovery_window_destroy(self, widget): def on_service_discovery_window_destroy(self, widget):
del self.plugin.windows[self.account]['disco'] del gajim.interface.windows[self.account]['disco']
def on_close_button_clicked(self, widget): def on_close_button_clicked(self, widget):
self.window.destroy() self.window.destroy()
def __init__(self, plugin, account): def __init__(self, account):
self.plugin = plugin
self.account = account self.account = account
self.agent_infos = {} self.agent_infos = {}
self.items_asked = [] #we already asked items to these jids self.items_asked = [] #we already asked items to these jids
@ -2395,10 +2386,10 @@ _('Without a connection, you can not browse available services')).get_response()
services = service.split('@') services = service.split('@')
room = services[0] room = services[0]
service = services[1] service = services[1]
if not self.plugin.windows[self.account].has_key('join_gc'): if not gajim.interface.windows[self.account].has_key('join_gc'):
dialogs.JoinGroupchatWindow(self.plugin, self.account, service, room) dialogs.JoinGroupchatWindow(self.account, service, room)
else: else:
self.plugin.windows[self.account]['join_gc'].window.present() gajim.interface.windows[self.account]['join_gc'].window.present()
def on_register_button_clicked(self, widget): def on_register_button_clicked(self, widget):
'''When we want to register an agent: '''When we want to register an agent:
@ -2473,16 +2464,16 @@ _('Without a connection, you can not browse available services')).get_response()
self.services_treeview.get_model().clear() self.services_treeview.get_model().clear()
self.items_asked = [] self.items_asked = []
self.browse(server_address) self.browse(server_address)
self.plugin.save_config() gajim.interface.save_config()
class GroupchatConfigWindow(DataFormWindow): class GroupchatConfigWindow(DataFormWindow):
'''GroupchatConfigWindow class''' '''GroupchatConfigWindow class'''
def __init__(self, plugin, account, room_jid, config): def __init__(self, account, room_jid, config):
DataFormWindow.__init__(self, plugin, account, config) DataFormWindow.__init__(self, account, config)
self.room_jid = room_jid self.room_jid = room_jid
def on_data_form_window_destroy(self, widget): def on_data_form_window_destroy(self, widget):
del self.plugin.windows[self.account]['gc_config'][self.room_jid] del gajim.interface.windows[self.account]['gc_config'][self.room_jid]
def on_apply_button_clicked(self, widget): def on_apply_button_clicked(self, widget):
gajim.connections[self.account].send_gc_config(self.room_jid, self.config) gajim.connections[self.account].send_gc_config(self.room_jid, self.config)
@ -2494,14 +2485,13 @@ class RemoveAccountWindow:
and do removing of the account given''' and do removing of the account given'''
def on_remove_account_window_destroy(self, widget): def on_remove_account_window_destroy(self, widget):
if self.plugin.windows.has_key(self.account): if gajim.interface.windows.has_key(self.account):
del self.plugin.windows[self.account]['remove_account'] del gajim.interface.windows[self.account]['remove_account']
def on_cancel_button_clicked(self, widget): def on_cancel_button_clicked(self, widget):
self.window.destroy() self.window.destroy()
def __init__(self, plugin, account): def __init__(self, account):
self.plugin = plugin
self.account = account self.account = account
xml = gtk.glade.XML(GTKGUI_GLADE, 'remove_account_window', APP) xml = gtk.glade.XML(GTKGUI_GLADE, 'remove_account_window', APP)
self.window = xml.get_widget('remove_account_window') self.window = xml.get_widget('remove_account_window')
@ -2524,8 +2514,8 @@ class RemoveAccountWindow:
gajim.connections[self.account].unregister_account() gajim.connections[self.account].unregister_account()
del gajim.connections[self.account] del gajim.connections[self.account]
gajim.config.del_per('accounts', self.account) gajim.config.del_per('accounts', self.account)
self.plugin.save_config() gajim.interface.save_config()
del self.plugin.windows[self.account] del gajim.interface.windows[self.account]
del gajim.awaiting_events[self.account] del gajim.awaiting_events[self.account]
del gajim.nicks[self.account] del gajim.nicks[self.account]
del gajim.allow_notifications[self.account] del gajim.allow_notifications[self.account]
@ -2540,15 +2530,14 @@ class RemoveAccountWindow:
del gajim.last_message_time[self.account] del gajim.last_message_time[self.account]
del gajim.status_before_autoaway[self.account] del gajim.status_before_autoaway[self.account]
del gajim.events_for_ui[self.account] del gajim.events_for_ui[self.account]
self.plugin.roster.draw_roster() gajim.interface.roster.draw_roster()
if self.plugin.windows.has_key('accounts'): if gajim.interface.windows.has_key('accounts'):
self.plugin.windows['accounts'].init_accounts() gajim.interface.windows['accounts'].init_accounts()
self.window.destroy() self.window.destroy()
#---------- ManageBookmarksWindow class -------------# #---------- ManageBookmarksWindow class -------------#
class ManageBookmarksWindow: class ManageBookmarksWindow:
def __init__(self, plugin): def __init__(self):
self.plugin = plugin
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'manage_bookmarks_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'manage_bookmarks_window', APP)
self.window = self.xml.get_widget('manage_bookmarks_window') self.window = self.xml.get_widget('manage_bookmarks_window')
@ -2620,7 +2609,7 @@ class ManageBookmarksWindow:
return not self.check_valid_bookmark() return not self.check_valid_bookmark()
def on_manage_bookmarks_window_destroy(self, widget, event): def on_manage_bookmarks_window_destroy(self, widget, event):
del self.plugin.windows['manage_bookmarks'] del gajim.interface.windows['manage_bookmarks']
def on_add_bookmark_button_clicked(self,widget): def on_add_bookmark_button_clicked(self,widget):
''' '''
@ -2704,7 +2693,7 @@ _('Please be sure to fill out server and room fields or remove this bookmark.'))
gajim.connections[account_unicode].bookmarks.append(bmdict) gajim.connections[account_unicode].bookmarks.append(bmdict)
gajim.connections[account_unicode].store_bookmarks() gajim.connections[account_unicode].store_bookmarks()
self.plugin.roster.make_menu() gajim.interface.roster.make_menu()
self.window.destroy() self.window.destroy()
def on_cancel_button_clicked(self, widget): def on_cancel_button_clicked(self, widget):
@ -2796,8 +2785,7 @@ _('Please be sure to fill out server and room fields or remove this bookmark.'))
self.autojoin_checkbutton.set_active(False) self.autojoin_checkbutton.set_active(False)
class FirstTimeWizardWindow: class FirstTimeWizardWindow:
def __init__(self, plugin): def __init__(self):
self.plugin = plugin
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'wizard_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'wizard_window', APP)
self.window = self.xml.get_widget('wizard_window') self.window = self.xml.get_widget('wizard_window')
self.xml.signal_autoconnect(self) self.xml.signal_autoconnect(self)
@ -2993,7 +2981,7 @@ _('You need to enter a valid server address to continue.')).get_response()
_('You already have an account using this name.')).get_response() _('You already have an account using this name.')).get_response()
return return
con = connection.Connection(name) con = connection.Connection(name)
self.plugin.register_handlers(con) gajim.interface.register_handlers(con)
if new_account: if new_account:
gajim.events_for_ui[name] = [] gajim.events_for_ui[name] = []
con.new_account(name, config) con.new_account(name, config)
@ -3006,10 +2994,10 @@ _('You need to enter a valid server address to continue.')).get_response()
if config['savepass']: if config['savepass']:
gajim.connections[name].password = config['password'] gajim.connections[name].password = config['password']
# update variables # update variables
self.plugin.windows[name] = {'infos': {}, 'chats': {}, 'gc': {}, gajim.interface.windows[name] = {'infos': {}, 'chats': {}, 'gc': {},
'gc_config': {}} 'gc_config': {}}
self.plugin.windows[name]['xml_console'] = \ gajim.interface.windows[name]['xml_console'] = \
dialogs.XMLConsoleWindow(self.plugin, name) dialogs.XMLConsoleWindow(name)
gajim.awaiting_events[name] = {} gajim.awaiting_events[name] = {}
gajim.connections[name].connected = 0 gajim.connections[name].connected = 0
gajim.groups[name] = {} gajim.groups[name] = {}
@ -3026,8 +3014,8 @@ _('You need to enter a valid server address to continue.')).get_response()
gajim.status_before_autoaway[name] = '' gajim.status_before_autoaway[name] = ''
gajim.events_for_ui[name] = [] gajim.events_for_ui[name] = []
# refresh accounts window # refresh accounts window
if self.plugin.windows.has_key('accounts'): if gajim.interface.windows.has_key('accounts'):
self.plugin.windows['accounts'].init_accounts() gajim.interface.windows['accounts'].init_accounts()
# refresh roster # refresh roster
self.plugin.roster.draw_roster() gajim.interface.roster.draw_roster()
self.plugin.save_config() gajim.interface.save_config()

91
src/dialogs.py
View file

@ -43,10 +43,9 @@ GTKGUI_GLADE = 'gtkgui.glade'
class EditGroupsDialog: class EditGroupsDialog:
'''Class for the edit group dialog window''' '''Class for the edit group dialog window'''
def __init__(self, user, account, plugin): def __init__(self, user, account):
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'edit_groups_dialog', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'edit_groups_dialog', APP)
self.dialog = self.xml.get_widget('edit_groups_dialog') self.dialog = self.xml.get_widget('edit_groups_dialog')
self.plugin = plugin
self.account = account self.account = account
self.user = user self.user = user
self.changes_made = False self.changes_made = False
@ -70,8 +69,8 @@ class EditGroupsDialog:
self.dialog.destroy() self.dialog.destroy()
def update_contact(self): def update_contact(self):
self.plugin.roster.remove_contact(self.user, self.account) gajim.interface.roster.remove_contact(self.user, self.account)
self.plugin.roster.add_contact_to_roster(self.user.jid, self.account) gajim.interface.roster.add_contact_to_roster(self.user.jid, self.account)
gajim.connections[self.account].update_contact(self.user.jid, gajim.connections[self.account].update_contact(self.user.jid,
self.user.name, self.user.groups) self.user.name, self.user.groups)
@ -204,7 +203,7 @@ class ChooseGPGKeyDialog:
class ChangeStatusMessageDialog: class ChangeStatusMessageDialog:
def __init__(self, plugin, show = None): def __init__(self, show = None):
self.show = show self.show = show
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'change_status_message_dialog', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'change_status_message_dialog', APP)
self.window = self.xml.get_widget('change_status_message_dialog') self.window = self.xml.get_widget('change_status_message_dialog')
@ -269,8 +268,7 @@ class ChangeStatusMessageDialog:
class AddNewContactWindow: class AddNewContactWindow:
'''Class for AddNewContactWindow''' '''Class for AddNewContactWindow'''
def __init__(self, plugin, account, jid = None): def __init__(self, account, jid = None):
self.plugin = plugin
self.account = account self.account = account
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'add_new_contact_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'add_new_contact_window', APP)
self.window = self.xml.get_widget('add_new_contact_window') self.window = self.xml.get_widget('add_new_contact_window')
@ -364,7 +362,7 @@ _('Contact names must be of the form "user@servername".')).get_response()
end_iter = message_buffer.get_end_iter() end_iter = message_buffer.get_end_iter()
message = message_buffer.get_text(start_iter, end_iter).decode('utf-8') message = message_buffer.get_text(start_iter, end_iter).decode('utf-8')
group = self.group_comboboxentry.child.get_text().decode('utf-8') group = self.group_comboboxentry.child.get_text().decode('utf-8')
self.plugin.roster.req_sub(self, jid, message, self.account, gajim.interface.roster.req_sub(self, jid, message, self.account,
group = group, pseudo = nickname) group = group, pseudo = nickname)
if self.xml.get_widget('auto_authorize_checkbutton').get_active(): if self.xml.get_widget('auto_authorize_checkbutton').get_active():
gajim.connections[self.account].send_authorization(jid) gajim.connections[self.account].send_authorization(jid)
@ -568,10 +566,9 @@ ok_handler = None):
class SubscriptionRequestWindow: class SubscriptionRequestWindow:
def __init__(self, plugin, jid, text, account): def __init__(self, jid, text, account):
xml = gtk.glade.XML(GTKGUI_GLADE, 'subscription_request_window', APP) xml = gtk.glade.XML(GTKGUI_GLADE, 'subscription_request_window', APP)
self.window = xml.get_widget('subscription_request_window') self.window = xml.get_widget('subscription_request_window')
self.plugin = plugin
self.jid = jid self.jid = jid
self.account = account self.account = account
if len(gajim.connections) >= 2: if len(gajim.connections) >= 2:
@ -592,17 +589,17 @@ class SubscriptionRequestWindow:
gajim.connections[self.account].send_authorization(self.jid) gajim.connections[self.account].send_authorization(self.jid)
self.window.destroy() self.window.destroy()
if not gajim.contacts[self.account].has_key(self.jid): if not gajim.contacts[self.account].has_key(self.jid):
AddNewContactWindow(self.plugin, self.account, self.jid) AddNewContactWindow(self.account, self.jid)
def on_contact_info_button_clicked(self, widget): def on_contact_info_button_clicked(self, widget):
'''ask vcard''' '''ask vcard'''
if self.plugin.windows[self.account]['infos'].has_key(self.jid): if gajim.interface.windows[self.account]['infos'].has_key(self.jid):
self.plugin.windows[self.account]['infos'][self.jid].window.present() gajim.interface.windows[self.account]['infos'][self.jid].window.present()
else: else:
self.plugin.windows[self.account]['infos'][self.jid] = \ gajim.interface.windows[self.account]['infos'][self.jid] = \
VcardWindow(self.jid, self.plugin, self.account, True) VcardWindow(self.jid, self.account, True)
#remove the publish / retrieve buttons #remove the publish / retrieve buttons
vcard_xml = self.plugin.windows[self.account]['infos'][self.jid].xml vcard_xml = gajim.interface.windows[self.account]['infos'][self.jid].xml
hbuttonbox = vcard_xml.get_widget('information_hbuttonbox') hbuttonbox = vcard_xml.get_widget('information_hbuttonbox')
children = hbuttonbox.get_children() children = hbuttonbox.get_children()
hbuttonbox.remove(children[0]) hbuttonbox.remove(children[0])
@ -616,8 +613,7 @@ class SubscriptionRequestWindow:
self.window.destroy() self.window.destroy()
class JoinGroupchatWindow: class JoinGroupchatWindow:
def __init__(self, plugin, account, server = '', room = '', nick = ''): def __init__(self, account, server = '', room = '', nick = ''):
self.plugin = plugin
self.account = account self.account = account
if nick == '': if nick == '':
nick = gajim.nicks[self.account] nick = gajim.nicks[self.account]
@ -632,7 +628,7 @@ _('You can not join a group chat unless you are connected.')).get_response()
self.xml.get_widget('room_entry').set_text(room) self.xml.get_widget('room_entry').set_text(room)
self.xml.get_widget('nickname_entry').set_text(nick) self.xml.get_widget('nickname_entry').set_text(nick)
self.xml.signal_autoconnect(self) self.xml.signal_autoconnect(self)
self.plugin.windows[account]['join_gc'] = self #now add us to open windows gajim.interface.windows[account]['join_gc'] = self #now add us to open windows
our_jid = gajim.config.get_per('accounts', self.account, 'name') + '@' + \ our_jid = gajim.config.get_per('accounts', self.account, 'name') + '@' + \
gajim.config.get_per('accounts', self.account, 'hostname') gajim.config.get_per('accounts', self.account, 'hostname')
if len(gajim.connections) > 1: if len(gajim.connections) > 1:
@ -659,7 +655,7 @@ _('You can not join a group chat unless you are connected.')).get_response()
def on_join_groupchat_window_destroy(self, widget): def on_join_groupchat_window_destroy(self, widget):
'''close window''' '''close window'''
# remove us from open windows # remove us from open windows
del self.plugin.windows[self.account]['join_gc'] del gajim.interface.windows[self.account]['join_gc']
def on_join_groupchat_window_key_press_event(self, widget, event): def on_join_groupchat_window_key_press_event(self, widget, event):
if event.keyval == gtk.keysyms.Escape: # ESCAPE if event.keyval == gtk.keysyms.Escape: # ESCAPE
@ -690,13 +686,12 @@ _('You can not join a group chat unless you are connected.')).get_response()
self.recently_groupchat = self.recently_groupchat[0:10] self.recently_groupchat = self.recently_groupchat[0:10]
gajim.config.set('recently_groupchat', ' '.join(self.recently_groupchat)) gajim.config.set('recently_groupchat', ' '.join(self.recently_groupchat))
self.plugin.roster.join_gc_room(self.account, jid, nickname, password) gajim.interface.roster.join_gc_room(self.account, jid, nickname, password)
self.window.destroy() self.window.destroy()
class NewMessageDialog: class NewMessageDialog:
def __init__(self, plugin, account): def __init__(self, account):
self.plugin = plugin
self.account = account self.account = account
our_jid = gajim.config.get_per('accounts', self.account, 'name') + '@' + \ our_jid = gajim.config.get_per('accounts', self.account, 'name') + '@' + \
@ -724,16 +719,15 @@ class NewMessageDialog:
_('Contact ID must be of the form "username@servername".')).get_response() _('Contact ID must be of the form "username@servername".')).get_response()
return return
self.plugin.roster.new_chat_from_jid(self.account, jid) gajim.interface.roster.new_chat_from_jid(self.account, jid)
class ChangePasswordDialog: class ChangePasswordDialog:
def __init__(self, plugin, account): def __init__(self, account):
# 'account' can be None if we are about to create our first one # 'account' can be None if we are about to create our first one
if not account or gajim.connections[account].connected < 2: if not account or gajim.connections[account].connected < 2:
ErrorDialog(_('You are not connected to the server'), ErrorDialog(_('You are not connected to the server'),
_('Without a connection, you can not change your password.')).get_response() _('Without a connection, you can not change your password.')).get_response()
raise RuntimeError, 'You are not connected to the server' raise RuntimeError, 'You are not connected to the server'
self.plugin = plugin
self.account = account self.account = account
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'change_password_dialog', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'change_password_dialog', APP)
self.dialog = self.xml.get_widget('change_password_dialog') self.dialog = self.xml.get_widget('change_password_dialog')
@ -767,8 +761,7 @@ _('Without a connection, you can not change your password.')).get_response()
class PopupNotificationWindow: class PopupNotificationWindow:
def __init__(self, plugin, event_type, jid, account, msg_type = '', file_props = None): def __init__(self, event_type, jid, account, msg_type = '', file_props = None):
self.plugin = plugin
self.account = account self.account = account
self.jid = jid self.jid = jid
self.msg_type = msg_type self.msg_type = msg_type
@ -849,9 +842,9 @@ class PopupNotificationWindow:
event_description_label.set_text(txt) event_description_label.set_text(txt)
# position the window to bottom-right of screen # position the window to bottom-right of screen
window_width, self.window_height = self.window.get_size() window_width, self.window_height = self.window.get_size()
self.plugin.roster.popups_notification_height += self.window_height gajim.interface.roster.popups_notification_height += self.window_height
self.window.move(gtk.gdk.screen_width() - window_width, self.window.move(gtk.gdk.screen_width() - window_width,
gtk.gdk.screen_height() - self.plugin.roster.popups_notification_height) gtk.gdk.screen_height() - gajim.interface.roster.popups_notification_height)
xml.signal_autoconnect(self) xml.signal_autoconnect(self)
self.window.show_all() self.window.show_all()
@ -865,20 +858,20 @@ class PopupNotificationWindow:
def adjust_height_and_move_popup_notification_windows(self): def adjust_height_and_move_popup_notification_windows(self):
#remove #remove
self.plugin.roster.popups_notification_height -= self.window_height gajim.interface.roster.popups_notification_height -= self.window_height
self.window.destroy() self.window.destroy()
if len(self.plugin.roster.popup_notification_windows) > 0: if len(gajim.interface.roster.popup_notification_windows) > 0:
# we want to remove the first window added in the list # we want to remove the first window added in the list
self.plugin.roster.popup_notification_windows.pop(0) # remove 1st item gajim.interface.roster.popup_notification_windows.pop(0) # remove 1st item
# move the rest of popup windows # move the rest of popup windows
self.plugin.roster.popups_notification_height = 0 gajim.interface.roster.popups_notification_height = 0
for window_instance in self.plugin.roster.popup_notification_windows: for window_instance in gajim.interface.roster.popup_notification_windows:
window_width, window_height = window_instance.window.get_size() window_width, window_height = window_instance.window.get_size()
self.plugin.roster.popups_notification_height += window_height gajim.interface.roster.popups_notification_height += window_height
window_instance.window.move(gtk.gdk.screen_width() - window_width, window_instance.window.move(gtk.gdk.screen_width() - window_width,
gtk.gdk.screen_height() - self.plugin.roster.popups_notification_height) gtk.gdk.screen_height() - gajim.interface.roster.popups_notification_height)
def on_popup_notification_window_button_press_event(self, widget, event): def on_popup_notification_window_button_press_event(self, widget, event):
# use Contact class, new_chat expects it that way # use Contact class, new_chat expects it that way
@ -903,23 +896,23 @@ class PopupNotificationWindow:
groups = [_('not in the roster')], show = 'not in the roster', groups = [_('not in the roster')], show = 'not in the roster',
status = _('not in the roster'), sub = 'none', keyID = keyID) status = _('not in the roster'), sub = 'none', keyID = keyID)
gajim.contacts[self.account][self.jid] = [contact] gajim.contacts[self.account][self.jid] = [contact]
self.plugin.roster.add_contact_to_roster(contact.jid, gajim.interface.roster.add_contact_to_roster(contact.jid,
self.account) self.account)
if self.msg_type == 'pm': # It's a private message if self.msg_type == 'pm': # It's a private message
self.plugin.roster.new_chat(contact, self.account) gajim.interface.roster.new_chat(contact, self.account)
chats_window = self.plugin.windows[self.account]['chats'][self.jid] chats_window = gajim.interface.windows[self.account]['chats'][self.jid]
chats_window.set_active_tab(self.jid) chats_window.set_active_tab(self.jid)
chats_window.window.present() chats_window.window.present()
elif self.msg_type in ('normal', 'file-request', 'file-request-error', elif self.msg_type in ('normal', 'file-request', 'file-request-error',
'file-send-error', 'file-error', 'file-stopped', 'file-completed'): 'file-send-error', 'file-error', 'file-stopped', 'file-completed'):
# Get the first single message event # Get the first single message event
ev = gajim.get_first_event(self.account, self.jid, self.msg_type) ev = gajim.get_first_event(self.account, self.jid, self.msg_type)
self.plugin.roster.open_event(self.account, self.jid, ev) gajim.interface.roster.open_event(self.account, self.jid, ev)
else: # 'chat' else: # 'chat'
self.plugin.roster.new_chat(contact, self.account) gajim.interface.roster.new_chat(contact, self.account)
chats_window = self.plugin.windows[self.account]['chats'][self.jid] chats_window = gajim.interface.windows[self.account]['chats'][self.jid]
chats_window.set_active_tab(self.jid) chats_window.set_active_tab(self.jid)
chats_window.window.present() chats_window.window.present()
@ -929,9 +922,8 @@ class PopupNotificationWindow:
class SingleMessageWindow: class SingleMessageWindow:
'''SingleMessageWindow can send or show a received '''SingleMessageWindow can send or show a received
singled message depending on action argument''' singled message depending on action argument'''
def __init__(self, plugin, account, to = '', action = '', from_whom = '', def __init__(self, account, to = '', action = '', from_whom = '',
subject = '', message = ''): subject = '', message = ''):
self.plugin = plugin
self.account = account self.account = account
self.action = action self.action = action
@ -1086,7 +1078,7 @@ class SingleMessageWindow:
self.subject = _('RE: %s') % self.subject self.subject = _('RE: %s') % self.subject
self.message = _('\n\n\n== Original Message ==\n%s') % self.message self.message = _('\n\n\n== Original Message ==\n%s') % self.message
self.window.destroy() self.window.destroy()
SingleMessageWindow(self.plugin, self.account, to = self.from_whom, SingleMessageWindow(self.account, to = self.from_whom,
action = 'send', from_whom = self.from_whom, subject = self.subject, action = 'send', from_whom = self.from_whom, subject = self.subject,
message = self.message) message = self.message)
@ -1101,8 +1093,7 @@ class SingleMessageWindow:
self.window.destroy() self.window.destroy()
class XMLConsoleWindow: class XMLConsoleWindow:
def __init__(self, plugin, account): def __init__(self, account):
self.plugin = plugin
self.account = account self.account = account
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'xml_console_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'xml_console_window', APP)
@ -1206,7 +1197,7 @@ class XMLConsoleWindow:
self.input_textview.grab_focus() self.input_textview.grab_focus()
class InvitationReceivedDialog: class InvitationReceivedDialog:
def __init__(self, plugin, account, room_jid, contact_jid, password = None, comment = None): def __init__(self, account, room_jid, contact_jid, password = None, comment = None):
xml = gtk.glade.XML(GTKGUI_GLADE, 'invitation_received_dialog', APP) xml = gtk.glade.XML(GTKGUI_GLADE, 'invitation_received_dialog', APP)
dialog = xml.get_widget('invitation_received_dialog') dialog = xml.get_widget('invitation_received_dialog')
@ -1223,5 +1214,5 @@ class InvitationReceivedDialog:
dialog.destroy() dialog.destroy()
if response == gtk.RESPONSE_YES: if response == gtk.RESPONSE_YES:
room, server = gajim.get_room_name_and_server_from_room_jid(room_jid) room, server = gajim.get_room_name_and_server_from_room_jid(room_jid)
JoinGroupchatWindow(plugin, account, server = server, room = room) JoinGroupchatWindow(account, server = server, room = room)

3
src/filetransfers_window.py
View file

@ -51,9 +51,8 @@ C_SID = 6
class FileTransfersWindow: class FileTransfersWindow:
def __init__(self, plugin): def __init__(self):
self.files_props = {'r' : {}, 's': {}} self.files_props = {'r' : {}, 's': {}}
self.plugin = plugin
self.height_diff = 0 self.height_diff = 0
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'file_transfers_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'file_transfers_window', APP)
self.window = self.xml.get_widget('file_transfers_window') self.window = self.xml.get_widget('file_transfers_window')

35
src/gajim.py
View file

@ -526,7 +526,7 @@ class Interface:
def handle_event_subscribe(self, account, array): def handle_event_subscribe(self, account, array):
#('SUBSCRIBE', account, (jid, text)) #('SUBSCRIBE', account, (jid, text))
dialogs.SubscriptionRequestWindow(self, array[0], array[1], account) dialogs.SubscriptionRequestWindow(array[0], array[1], account)
if self.remote and self.remote.is_enabled(): if self.remote and self.remote.is_enabled():
self.remote.raise_signal('Subscribe', (account, array)) self.remote.raise_signal('Subscribe', (account, array))
@ -577,7 +577,7 @@ class Interface:
def handle_event_register_agent_info(self, account, array): def handle_event_register_agent_info(self, account, array):
#('REGISTER_AGENT_INFO', account, (agent, infos, is_form)) #('REGISTER_AGENT_INFO', account, (agent, infos, is_form))
if array[1].has_key('instructions'): if array[1].has_key('instructions'):
config.ServiceRegistrationWindow(array[0], array[1], self, account, config.ServiceRegistrationWindow(array[0], array[1], account,
array[2]) array[2])
else: else:
dialogs.ErrorDialog(_('Contact with "%s" cannot be established'\ dialogs.ErrorDialog(_('Contact with "%s" cannot be established'\
@ -606,7 +606,7 @@ class Interface:
if self.windows.has_key('account_modification'): if self.windows.has_key('account_modification'):
self.windows['account_modification'].account_is_ok(array[0]) self.windows['account_modification'].account_is_ok(array[0])
self.windows[name] = {'infos': {}, 'chats': {}, 'gc': {}, 'gc_config': {}} self.windows[name] = {'infos': {}, 'chats': {}, 'gc': {}, 'gc_config': {}}
self.windows[name]['xml_console'] = dialogs.XMLConsoleWindow(self, name) self.windows[name]['xml_console'] = dialogs.XMLConsoleWindow(name)
gajim.awaiting_events[name] = {} gajim.awaiting_events[name] = {}
# disconnect from server - our status in roster is offline # disconnect from server - our status in roster is offline
gajim.connections[name].connected = 1 gajim.connections[name].connected = 1
@ -633,7 +633,7 @@ class Interface:
self.remote.raise_signal('NewAccount', (account, array)) self.remote.raise_signal('NewAccount', (account, array))
def handle_event_quit(self, p1, p2): def handle_event_quit(self, p1, p2):
self.roster.quit_gtkgui_plugin() self.roster.quit_gtkgui_interface()
def handle_event_myvcard(self, account, array): def handle_event_myvcard(self, account, array):
nick = '' nick = ''
@ -732,11 +732,11 @@ class Interface:
jid = array[0].split('/')[0] jid = array[0].split('/')[0]
if not self.windows[account]['gc_config'].has_key(jid): if not self.windows[account]['gc_config'].has_key(jid):
self.windows[account]['gc_config'][jid] = \ self.windows[account]['gc_config'][jid] = \
config.GroupchatConfigWindow(self, account, jid, array[1]) config.GroupchatConfigWindow(account, jid, array[1])
def handle_event_gc_invitation(self, account, array): def handle_event_gc_invitation(self, account, array):
#('GC_INVITATION', (room_jid, jid_from, reason, password)) #('GC_INVITATION', (room_jid, jid_from, reason, password))
dialogs.InvitationReceivedDialog(self, account, array[0], array[1], dialogs.InvitationReceivedDialog(account, array[0], array[1],
array[3], array[2]) array[3], array[2])
def handle_event_bad_passphrase(self, account, array): def handle_event_bad_passphrase(self, account, array):
@ -910,7 +910,7 @@ class Interface:
if gajim.config.get('notify_on_file_complete') and \ if gajim.config.get('notify_on_file_complete') and \
gajim.config.get('autopopupaway') or \ gajim.config.get('autopopupaway') or \
gajim.connections[account].connected in (2, 3): gajim.connections[account].connected in (2, 3):
instance = dialogs.PopupNotificationWindow(self, event_type, instance = dialogs.PopupNotificationWindow(event_type,
jid, account, msg_type, file_props) jid, account, msg_type, file_props)
self.roster.popup_notification_windows.append(instance) self.roster.popup_notification_windows.append(instance)
@ -1192,7 +1192,7 @@ class Interface:
import remote_control import remote_control
if not hasattr(self, 'remote') or not self.remote: if not hasattr(self, 'remote') or not self.remote:
try: try:
self.remote = remote_control.Remote(self) self.remote = remote_control.Remote()
except remote_control.DbusNotSupported: except remote_control.DbusNotSupported:
self.remote = None self.remote = None
return False return False
@ -1212,6 +1212,7 @@ class Interface:
self.remote = None self.remote = None
def __init__(self): def __init__(self):
gajim.interface = self
self.default_values = { self.default_values = {
'inmsgcolor': gajim.config.get('inmsgcolor'), 'inmsgcolor': gajim.config.get('inmsgcolor'),
'outmsgcolor': gajim.config.get('outmsgcolor'), 'outmsgcolor': gajim.config.get('outmsgcolor'),
@ -1292,7 +1293,7 @@ class Interface:
gajim.status_before_autoaway[a] = '' gajim.status_before_autoaway[a] = ''
gajim.events_for_ui[a] = [] gajim.events_for_ui[a] = []
self.roster = roster_window.RosterWindow(self) self.roster = roster_window.RosterWindow()
if gajim.config.get('use_dbus'): if gajim.config.get('use_dbus'):
self.enable_dbus() self.enable_dbus()
else: else:
@ -1316,7 +1317,7 @@ class Interface:
pass pass
else: else:
self.systray_capabilities = True self.systray_capabilities = True
self.systray = systraywin32.SystrayWin32(self) self.systray = systraywin32.SystrayWin32()
else: else:
try: try:
import egg.trayicon # use gnomepythonextras trayicon import egg.trayicon # use gnomepythonextras trayicon
@ -1327,28 +1328,28 @@ class Interface:
pass pass
else: else:
self.systray_capabilities = True self.systray_capabilities = True
self.systray = systray.Systray(self) self.systray = systray.Systray()
else: else:
self.systray_capabilities = True self.systray_capabilities = True
self.systray = systray.Systray(self) self.systray = systray.Systray()
if self.systray_capabilities and gajim.config.get('trayicon'): if self.systray_capabilities and gajim.config.get('trayicon'):
self.show_systray() self.show_systray()
if gajim.config.get('check_for_new_version'): if gajim.config.get('check_for_new_version'):
check_for_new_version.Check_for_new_version_dialog(self) check_for_new_version.Check_for_new_version_dialog()
self.init_regexp() self.init_regexp()
# get instances for windows/dialogs that will show_all()/hide() # get instances for windows/dialogs that will show_all()/hide()
self.windows['file_transfers'] = dialogs.FileTransfersWindow(self) self.windows['file_transfers'] = dialogs.FileTransfersWindow()
self.windows['preferences'] = config.PreferencesWindow(self) self.windows['preferences'] = config.PreferencesWindow()
self.windows['add_remove_emoticons'] = \ self.windows['add_remove_emoticons'] = \
config.ManageEmoticonsWindow(self) config.ManageEmoticonsWindow()
self.windows['roster'] = self.roster self.windows['roster'] = self.roster
for account in gajim.connections: for account in gajim.connections:
self.windows[account]['xml_console'] = \ self.windows[account]['xml_console'] = \
dialogs.XMLConsoleWindow(self, account) dialogs.XMLConsoleWindow(account)
self.register_handlers(gajim.connections[account]) self.register_handlers(gajim.connections[account])
gobject.timeout_add(100, self.autoconnect) gobject.timeout_add(100, self.autoconnect)

25
src/gajim_themes_window.py
View file

@ -36,10 +36,9 @@ GTKGUI_GLADE = 'gtkgui.glade'
class GajimThemesWindow: class GajimThemesWindow:
def __init__(self, plugin): def __init__(self):
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'gajim_themes_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'gajim_themes_window', APP)
self.window = self.xml.get_widget('gajim_themes_window') self.window = self.xml.get_widget('gajim_themes_window')
self.plugin = plugin
self.options = ['account', 'group', 'contact', 'banner', 'lastmessage'] self.options = ['account', 'group', 'contact', 'banner', 'lastmessage']
self.options_combobox = self.xml.get_widget('options_combobox') self.options_combobox = self.xml.get_widget('options_combobox')
@ -102,7 +101,7 @@ class GajimThemesWindow:
gajim.config.set('roster_theme', new_config_name) gajim.config.set('roster_theme', new_config_name)
model.set_value(iter, 0, new_name) model.set_value(iter, 0, new_name)
self.current_theme = new_name self.current_theme = new_name
self.plugin.windows['preferences'].update_preferences_window() gajim.interface.windows['preferences'].update_preferences_window()
def fill_themes_treeview(self): def fill_themes_treeview(self):
self.xml.get_widget('remove_button').set_sensitive(False) self.xml.get_widget('remove_button').set_sensitive(False)
@ -144,7 +143,7 @@ class GajimThemesWindow:
col = self.themes_tree.get_column(0) col = self.themes_tree.get_column(0)
path = model.get_path(iter) path = model.get_path(iter)
self.themes_tree.set_cursor(path, col, True) self.themes_tree.set_cursor(path, col, True)
self.plugin.windows['preferences'].update_preferences_window() gajim.interface.windows['preferences'].update_preferences_window()
def on_remove_button_clicked(self, widget): def on_remove_button_clicked(self, widget):
(model, iter) = self.themes_tree.get_selection().get_selected() (model, iter) = self.themes_tree.get_selection().get_selected()
@ -157,7 +156,7 @@ class GajimThemesWindow:
self.theme_options_vbox.set_sensitive(False) self.theme_options_vbox.set_sensitive(False)
gajim.config.del_per('themes', self.current_theme) gajim.config.del_per('themes', self.current_theme)
model.remove(iter) model.remove(iter)
self.plugin.windows['preferences'].update_preferences_window() gajim.interface.windows['preferences'].update_preferences_window()
def set_theme_options(self, theme, option = 'account'): def set_theme_options(self, theme, option = 'account'):
self.no_update = True self.no_update = True
@ -193,7 +192,7 @@ class GajimThemesWindow:
self.textfont_checkbutton.set_active(state) self.textfont_checkbutton.set_active(state)
self.text_fontbutton.set_sensitive(state) self.text_fontbutton.set_sensitive(state)
self.no_update = False self.no_update = False
self.plugin.roster.change_roster_style(None) gajim.interface.roster.change_roster_style(None)
def on_textcolor_checkbutton_toggled(self, widget): def on_textcolor_checkbutton_toggled(self, widget):
state = widget.get_active() state = widget.get_active()
@ -248,13 +247,13 @@ class GajimThemesWindow:
self.current_option + option, color_string) self.current_option + option, color_string)
# use faster functions for this # use faster functions for this
if self.current_option == 'banner': if self.current_option == 'banner':
self.plugin.roster.repaint_themed_widgets() gajim.interface.roster.repaint_themed_widgets()
self.plugin.save_config() gajim.interface.save_config()
return return
if self.no_update: if self.no_update:
return return
self.plugin.roster.change_roster_style(self.current_option) gajim.interface.roster.change_roster_style(self.current_option)
self.plugin.save_config() gajim.interface.save_config()
def _set_font(self): def _set_font(self):
''' set font value in prefs and update the UI ''' ''' set font value in prefs and update the UI '''
@ -270,11 +269,11 @@ class GajimThemesWindow:
self.current_option + 'fontattrs', font_attrs) self.current_option + 'fontattrs', font_attrs)
# use faster functions for this # use faster functions for this
if self.current_option == 'banner': if self.current_option == 'banner':
self.plugin.roster.repaint_themed_widgets() gajim.interface.roster.repaint_themed_widgets()
if self.no_update: if self.no_update:
return return
self.plugin.roster.change_roster_style(self.current_option) gajim.interface.roster.change_roster_style(self.current_option)
self.plugin.save_config() gajim.interface.save_config()
def _toggle_font_widgets(self, font_props): def _toggle_font_widgets(self, font_props):
''' toggle font buttons with the bool values of font_props tuple''' ''' toggle font buttons with the bool values of font_props tuple'''

78
src/groupchat_window.py
View file

@ -56,10 +56,10 @@ GTKGUI_GLADE = 'gtkgui.glade'
class GroupchatWindow(chat.Chat): class GroupchatWindow(chat.Chat):
'''Class for Groupchat window''' '''Class for Groupchat window'''
def __init__(self, room_jid, nick, plugin, account): def __init__(self, room_jid, nick, account):
# we check that on opening new windows # we check that on opening new windows
self.always_compact_view = gajim.config.get('always_compact_view_gc') self.always_compact_view = gajim.config.get('always_compact_view_gc')
chat.Chat.__init__(self, plugin, account, 'groupchat_window') chat.Chat.__init__(self, account, 'groupchat_window')
# alphanum sorted # alphanum sorted
self.muc_cmds = ['ban', 'chat', 'query', 'clear', 'close', 'compact', 'help', 'invite', self.muc_cmds = ['ban', 'chat', 'query', 'clear', 'close', 'compact', 'help', 'invite',
@ -82,7 +82,8 @@ class GroupchatWindow(chat.Chat):
self.gc_refer_to_nick_char = gajim.config.get('gc_refer_to_nick_char') self.gc_refer_to_nick_char = gajim.config.get('gc_refer_to_nick_char')
self.new_room(room_jid, nick) self.new_room(room_jid, nick)
self.show_title() self.show_title()
self.tooltip = tooltips.GCTooltip(plugin) self.tooltip = tooltips.GCTooltip()
self.line_tooltip = tooltips.BaseTooltip()
# NOTE: if it not a window event, connect in new_room function # NOTE: if it not a window event, connect in new_room function
@ -351,7 +352,7 @@ class GroupchatWindow(chat.Chat):
def add_contact_to_roster(self, room_jid, nick, show, role, jid, affiliation, status): def add_contact_to_roster(self, room_jid, nick, show, role, jid, affiliation, status):
model = self.list_treeview[room_jid].get_model() model = self.list_treeview[room_jid].get_model()
image = self.plugin.roster.jabber_state_images[show] image = gajim.interface.roster.jabber_state_images[show]
resource = '' resource = ''
role_name = helpers.get_uf_role(role, plural = True) role_name = helpers.get_uf_role(role, plural = True)
@ -365,7 +366,7 @@ class GroupchatWindow(chat.Chat):
role_iter = self.get_role_iter(room_jid, role) role_iter = self.get_role_iter(room_jid, role)
if not role_iter: if not role_iter:
role_iter = model.append(None, role_iter = model.append(None,
(self.plugin.roster.jabber_state_images['closed'], 'role', role, (gajim.interface.roster.jabber_state_images['closed'], 'role', role,
'<b>%s</b>' % role_name)) '<b>%s</b>' % role_name))
iter = model.append(role_iter, (image, 'contact', nick, iter = model.append(role_iter, (image, 'contact', nick,
self.escape(nick))) self.escape(nick)))
@ -385,7 +386,7 @@ class GroupchatWindow(chat.Chat):
return 'visitor' return 'visitor'
def update_state_images(self): def update_state_images(self):
roster = self.plugin.roster roster = gajim.interface.roster
for room_jid in self.list_treeview: for room_jid in self.list_treeview:
model = self.list_treeview[room_jid].get_model() model = self.list_treeview[room_jid].get_model()
role_iter = model.get_iter_root() role_iter = model.get_iter_root()
@ -472,7 +473,7 @@ class GroupchatWindow(chat.Chat):
c.show = show c.show = show
c.affiliation = affiliation c.affiliation = affiliation
c.status = status c.status = status
roster = self.plugin.roster roster = gajim.interface.roster
state_images = roster.get_appropriate_state_images(jid) state_images = roster.get_appropriate_state_images(jid)
image = state_images[show] image = state_images[show]
model[iter][C_IMG] = image model[iter][C_IMG] = image
@ -567,7 +568,7 @@ class GroupchatWindow(chat.Chat):
gajim.connections[self.account].bookmarks.append(bm) gajim.connections[self.account].bookmarks.append(bm)
gajim.connections[self.account].store_bookmarks() gajim.connections[self.account].store_bookmarks()
self.plugin.roster.make_menu() gajim.interface.roster.make_menu()
dialogs.InformationDialog( dialogs.InformationDialog(
_('Bookmark has been added successfully'), _('Bookmark has been added successfully'),
@ -810,14 +811,13 @@ class GroupchatWindow(chat.Chat):
server = servernick server = servernick
nick = '' nick = ''
#join_gc window is needed in order to provide for password entry. #join_gc window is needed in order to provide for password entry.
if self.plugin.windows[self.account].has_key('join_gc'): if gajim.interface.windows[self.account].has_key('join_gc'):
self.plugin.windows[self.account]['join_gc'].\ gajim.interface.windows[self.account]['join_gc'].\
window.present() window.present()
else: else:
try: try:
self.plugin.windows[self.account]['join_gc'] =\ gajim.interface.windows[self.account]['join_gc'] =\
dialogs.JoinGroupchatWindow(self.plugin, dialogs.JoinGroupchatWindow(self.account,
self.account,
server = server, room = room, nick = nick) server = server, room = room, nick = nick)
except RuntimeError: except RuntimeError:
pass pass
@ -1090,15 +1090,15 @@ current room topic.') % command, room_jid)
else: else:
fjid = gajim.construct_fjid(room_jid, nick) fjid = gajim.construct_fjid(room_jid, nick)
jid = fjid jid = fjid
if self.plugin.windows[self.account]['infos'].has_key(jid): if gajim.interface.windows[self.account]['infos'].has_key(jid):
self.plugin.windows[self.account]['infos'][jid].window.present() gajim.interface.windows[self.account]['infos'][jid].window.present()
else: else:
# we copy contact because c.jid must contain the fakeJid for vcard # we copy contact because c.jid must contain the fakeJid for vcard
c2 = Contact(jid = jid, name = c.name, groups = c.groups, c2 = Contact(jid = jid, name = c.name, groups = c.groups,
show = c.show, status = c.status, sub = c.sub, show = c.show, status = c.status, sub = c.sub,
resource = c.resource, role = c.role, affiliation = c.affiliation) resource = c.resource, role = c.role, affiliation = c.affiliation)
self.plugin.windows[self.account]['infos'][jid] = \ gajim.interface.windows[self.account]['infos'][jid] = \
dialogs.VcardWindow(c2, self.plugin, self.account, False) dialogs.VcardWindow(c2, self.account, False)
def on_history(self, widget, room_jid, nick): def on_history(self, widget, room_jid, nick):
c = gajim.gc_contacts[self.account][room_jid][nick] c = gajim.gc_contacts[self.account][room_jid][nick]
@ -1112,7 +1112,7 @@ current room topic.') % command, room_jid)
self.on_history_menuitem_clicked(jid = jid) self.on_history_menuitem_clicked(jid = jid)
def on_add_to_roster(self, widget, jid): def on_add_to_roster(self, widget, jid):
dialogs.AddNewContactWindow(self.plugin, self.account, jid) dialogs.AddNewContactWindow(self.account, jid)
def on_send_pm(self, widget=None, model=None, iter=None, nick=None, msg=None): def on_send_pm(self, widget=None, model=None, iter=None, nick=None, msg=None):
'''opens a chat window and msg is not None sends private message to a '''opens a chat window and msg is not None sends private message to a
@ -1121,18 +1121,18 @@ current room topic.') % command, room_jid)
nick = model[iter][C_NICK].decode('utf-8') nick = model[iter][C_NICK].decode('utf-8')
room_jid = self.get_active_jid() room_jid = self.get_active_jid()
fjid = gajim.construct_fjid(room_jid, nick) # 'fake' jid fjid = gajim.construct_fjid(room_jid, nick) # 'fake' jid
if not self.plugin.windows[self.account]['chats'].has_key(fjid): if not gajim.interface.windows[self.account]['chats'].has_key(fjid):
show = gajim.gc_contacts[self.account][room_jid][nick].show show = gajim.gc_contacts[self.account][room_jid][nick].show
u = Contact(jid = fjid, name = nick, groups = ['none'], show = show, u = Contact(jid = fjid, name = nick, groups = ['none'], show = show,
sub = 'none') sub = 'none')
self.plugin.roster.new_chat(u, self.account) gajim.interface.roster.new_chat(u, self.account)
#make active here in case we need to send a message #make active here in case we need to send a message
self.plugin.windows[self.account]['chats'][fjid].set_active_tab(fjid) gajim.interface.windows[self.account]['chats'][fjid].set_active_tab(fjid)
if msg: if msg:
self.plugin.windows[self.account]['chats'][fjid].send_message(msg) gajim.interface.windows[self.account]['chats'][fjid].send_message(msg)
self.plugin.windows[self.account]['chats'][fjid].window.present() gajim.interface.windows[self.account]['chats'][fjid].window.present()
def on_voice_checkmenuitem_activate(self, widget, room_jid, nick): def on_voice_checkmenuitem_activate(self, widget, room_jid, nick):
if widget.get_active(): if widget.get_active():
@ -1373,8 +1373,8 @@ current room topic.') % command, room_jid)
no_queue = False no_queue = False
# We print if window is opened # We print if window is opened
if self.plugin.windows[self.account]['chats'].has_key(fjid): if gajim.interface.windows[self.account]['chats'].has_key(fjid):
chat_win = self.plugin.windows[self.account]['chats'][fjid] chat_win = gajim.interface.windows[self.account]['chats'][fjid]
chat_win.print_conversation(msg, fjid, tim = tim) chat_win.print_conversation(msg, fjid, tim = tim)
return return
@ -1391,17 +1391,17 @@ current room topic.') % command, room_jid)
gajim.connections[self.account].connected > 2): gajim.connections[self.account].connected > 2):
if no_queue: # We didn't have a queue: we change icons if no_queue: # We didn't have a queue: we change icons
model = self.list_treeview[room_jid].get_model() model = self.list_treeview[room_jid].get_model()
state_images = self.plugin.roster.get_appropriate_state_images(room_jid) state_images = gajim.interface.roster.get_appropriate_state_images(room_jid)
image = state_images['message'] image = state_images['message']
model[iter][C_IMG] = image model[iter][C_IMG] = image
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.add_jid(fjid, self.account, 'pm') gajim.interface.systray.add_jid(fjid, self.account, 'pm')
self.show_title() self.show_title()
else: else:
show = gajim.gc_contacts[self.account][room_jid][nick].show show = gajim.gc_contacts[self.account][room_jid][nick].show
c = Contact(jid = fjid, name = nick, groups = ['none'], show = show, c = Contact(jid = fjid, name = nick, groups = ['none'], show = show,
ask = 'none') ask = 'none')
self.plugin.roster.new_chat(c, self.account) gajim.interface.roster.new_chat(c, self.account)
# Scroll to line # Scroll to line
self.list_treeview[room_jid].expand_row(path[0:1], False) self.list_treeview[room_jid].expand_row(path[0:1], False)
self.list_treeview[room_jid].scroll_to_cell(path) self.list_treeview[room_jid].scroll_to_cell(path)
@ -1506,13 +1506,13 @@ current room topic.') % command, room_jid)
if len(path) == 2: if len(path) == 2:
nick = model[iter][C_NICK].decode('utf-8') nick = model[iter][C_NICK].decode('utf-8')
fjid = gajim.construct_fjid(room_jid, nick) fjid = gajim.construct_fjid(room_jid, nick)
if not self.plugin.windows[self.account]['chats'].has_key(fjid): if not gajim.interface.windows[self.account]['chats'].has_key(fjid):
show = gajim.gc_contacts[self.account][room_jid][nick].show show = gajim.gc_contacts[self.account][room_jid][nick].show
u = Contact(jid = fjid, name = nick, groups = ['none'], u = Contact(jid = fjid, name = nick, groups = ['none'],
show = show, sub = 'none') show = show, sub = 'none')
self.plugin.roster.new_chat(u, self.account) gajim.interface.roster.new_chat(u, self.account)
self.plugin.windows[self.account]['chats'][fjid].set_active_tab(fjid) gajim.interface.windows[self.account]['chats'][fjid].set_active_tab(fjid)
self.plugin.windows[self.account]['chats'][fjid].window.present() gajim.interface.windows[self.account]['chats'][fjid].window.present()
return True return True
elif event.button == 1: # left click elif event.button == 1: # left click
@ -1550,22 +1550,22 @@ current room topic.') % command, room_jid)
room_jid = self.get_active_jid() room_jid = self.get_active_jid()
nick = model[iter][C_NICK].decode('utf-8') nick = model[iter][C_NICK].decode('utf-8')
fjid = gajim.construct_fjid(room_jid, nick) fjid = gajim.construct_fjid(room_jid, nick)
if not self.plugin.windows[self.account]['chats'].has_key(fjid): if not gajim.interface.windows[self.account]['chats'].has_key(fjid):
show = gajim.gc_contacts[self.account][room_jid][nick].show show = gajim.gc_contacts[self.account][room_jid][nick].show
u = Contact(jid = fjid, name = nick, groups = ['none'], show = show, u = Contact(jid = fjid, name = nick, groups = ['none'], show = show,
sub = 'none') sub = 'none')
self.plugin.roster.new_chat(u, self.account) gajim.interface.roster.new_chat(u, self.account)
self.plugin.windows[self.account]['chats'][fjid].set_active_tab(fjid) gajim.interface.windows[self.account]['chats'][fjid].set_active_tab(fjid)
self.plugin.windows[self.account]['chats'][fjid].window.present() gajim.interface.windows[self.account]['chats'][fjid].window.present()
def on_list_treeview_row_expanded(self, widget, iter, path): def on_list_treeview_row_expanded(self, widget, iter, path):
'''When a row is expanded: change the icon of the arrow''' '''When a row is expanded: change the icon of the arrow'''
model = widget.get_model() model = widget.get_model()
image = self.plugin.roster.jabber_state_images['opened'] image = gajim.interface.roster.jabber_state_images['opened']
model[iter][C_IMG] = image model[iter][C_IMG] = image
def on_list_treeview_row_collapsed(self, widget, iter, path): def on_list_treeview_row_collapsed(self, widget, iter, path):
'''When a row is collapsed: change the icon of the arrow''' '''When a row is collapsed: change the icon of the arrow'''
model = widget.get_model() model = widget.get_model()
image = self.plugin.roster.jabber_state_images['closed'] image = gajim.interface.roster.jabber_state_images['closed']
model[iter][C_IMG] = image model[iter][C_IMG] = image

5
src/history_window.py
View file

@ -34,8 +34,7 @@ GTKGUI_GLADE = 'gtkgui.glade'
class HistoryWindow: class HistoryWindow:
'''Class for browsing logs of conversations with contacts''' '''Class for browsing logs of conversations with contacts'''
def __init__(self, plugin, jid, account): def __init__(self, jid, account):
self.plugin = plugin
self.jid = jid self.jid = jid
self.account = account self.account = account
self.no_of_lines = gajim.logger.get_no_of_lines(jid) self.no_of_lines = gajim.logger.get_no_of_lines(jid)
@ -80,7 +79,7 @@ class HistoryWindow:
self.window.show_all() self.window.show_all()
def on_history_window_destroy(self, widget): def on_history_window_destroy(self, widget):
del self.plugin.windows['logs'][self.jid] del gajim.interface.windows['logs'][self.jid]
def on_close_button_clicked(self, widget): def on_close_button_clicked(self, widget):
self.window.destroy() self.window.destroy()

39
src/remote_control.py
View file

@ -49,7 +49,7 @@ OBJ_PATH = '/org/gajim/dbus/RemoteObject'
SERVICE = 'org.gajim.dbus' SERVICE = 'org.gajim.dbus'
class Remote: class Remote:
def __init__(self, plugin): def __init__(self):
self.signal_object = None self.signal_object = None
if 'dbus' not in globals() and not os.name == 'nt': if 'dbus' not in globals() and not os.name == 'nt':
print _('D-Bus python bindings are missing in this computer') print _('D-Bus python bindings are missing in this computer')
@ -66,10 +66,10 @@ class Remote:
if _version[1] >= 41: if _version[1] >= 41:
service = dbus.service.BusName(SERVICE, bus=session_bus) service = dbus.service.BusName(SERVICE, bus=session_bus)
self.signal_object = SignalObject(service, plugin) self.signal_object = SignalObject(service)
elif _version[1] <= 40 and _version[1] >= 20: elif _version[1] <= 40 and _version[1] >= 20:
service=dbus.Service(SERVICE, session_bus) service=dbus.Service(SERVICE, session_bus)
self.signal_object = SignalObject(service, plugin) self.signal_object = SignalObject(service)
def set_enabled(self, status): def set_enabled(self, status):
self.signal_object.disabled = not status self.signal_object.disabled = not status
@ -86,8 +86,7 @@ class SignalObject(DbusPrototype):
''' Local object definition for /org/gajim/dbus/RemoteObject. This doc must ''' Local object definition for /org/gajim/dbus/RemoteObject. This doc must
not be visible, because the clients can access only the remote object. ''' not be visible, because the clients can access only the remote object. '''
def __init__(self, service, plugin): def __init__(self, service):
self.plugin = plugin
self.first_show = True self.first_show = True
self.vcard_account = None self.vcard_account = None
self.disabled = False self.disabled = False
@ -162,7 +161,7 @@ class SignalObject(DbusPrototype):
if connected_account: if connected_account:
if os.path.isfile(file_path): # is it file? if os.path.isfile(file_path): # is it file?
self.plugin.windows['file_transfers'].send_file(account, gajim.interface.windows['file_transfers'].send_file(account,
contact, file_path) contact, file_path)
return True return True
return False return False
@ -220,7 +219,7 @@ class SignalObject(DbusPrototype):
first_connected_acct = None first_connected_acct = None
for acct in accounts: for acct in accounts:
if gajim.connections[acct].connected > 1: # account is online if gajim.connections[acct].connected > 1: # account is online
if self.plugin.windows[acct]['chats'].has_key(jid): if gajim.interface.windows[acct]['chats'].has_key(jid):
connected_account = acct connected_account = acct
break break
# jid is in roster # jid is in roster
@ -239,9 +238,9 @@ class SignalObject(DbusPrototype):
connected_account = first_connected_acct connected_account = first_connected_acct
if connected_account: if connected_account:
self.plugin.roster.new_chat_from_jid(connected_account, jid) gajim.interface.roster.new_chat_from_jid(connected_account, jid)
# preserve the 'steal focus preservation' # preserve the 'steal focus preservation'
win = self.plugin.windows[connected_account]['chats'][jid].window win = gajim.interface.windows[connected_account]['chats'][jid].window
if win.get_property('visible'): if win.get_property('visible'):
win.window.focus() win.window.focus()
return True return True
@ -258,12 +257,12 @@ class SignalObject(DbusPrototype):
# FIXME: raise exception for bad status (dbus0.35) # FIXME: raise exception for bad status (dbus0.35)
return None return None
if account: if account:
gobject.idle_add(self.plugin.roster.send_status, account, gobject.idle_add(gajim.interface.roster.send_status, account,
status, message) status, message)
else: else:
# account not specified, so change the status of all accounts # account not specified, so change the status of all accounts
for acc in gajim.contacts.keys(): for acc in gajim.contacts.keys():
gobject.idle_add(self.plugin.roster.send_status, acc, gobject.idle_add(gajim.interface.roster.send_status, acc,
status, message) status, message)
return None return None
@ -273,17 +272,17 @@ class SignalObject(DbusPrototype):
return return
#FIXME: when systray is disabled this method does nothing. #FIXME: when systray is disabled this method does nothing.
#FIXME: show message from GC that refer to us (like systray does) #FIXME: show message from GC that refer to us (like systray does)
if len(self.plugin.systray.jids) != 0: if len(gajim.interface.systray.jids) != 0:
account = self.plugin.systray.jids[0][0] account = gajim.interface.systray.jids[0][0]
jid = self.plugin.systray.jids[0][1] jid = gajim.interface.systray.jids[0][1]
acc = self.plugin.windows[account] acc = gajim.interface.windows[account]
jid_tab = None jid_tab = None
if acc['gc'].has_key(jid): if acc['gc'].has_key(jid):
jid_tab = acc['gc'][jid] jid_tab = acc['gc'][jid]
elif acc['chats'].has_key(jid): elif acc['chats'].has_key(jid):
jid_tab = acc['chats'][jid] jid_tab = acc['chats'][jid]
else: else:
self.plugin.roster.new_chat( gajim.interface.roster.new_chat(
gajim.contacts[account][jid][0], account) gajim.contacts[account][jid][0], account)
jid_tab = acc['chats'][jid] jid_tab = acc['chats'][jid]
if jid_tab: if jid_tab:
@ -365,7 +364,7 @@ class SignalObject(DbusPrototype):
''' shows/hides the roster window ''' ''' shows/hides the roster window '''
if self.disabled: if self.disabled:
return return
win = self.plugin.roster.window win = gajim.interface.roster.window
if win.get_property('visible'): if win.get_property('visible'):
gobject.idle_add(win.hide) gobject.idle_add(win.hide)
else: else:
@ -392,7 +391,7 @@ class SignalObject(DbusPrototype):
def prefs_store(self, *args): def prefs_store(self, *args):
try: try:
self.plugin.save_config() gajim.interface.save_config()
except Exception, e: except Exception, e:
return False return False
return True return True
@ -426,7 +425,7 @@ class SignalObject(DbusPrototype):
def add_contact(self, *args): def add_contact(self, *args):
[account] = self._get_real_arguments(args, 1) [account] = self._get_real_arguments(args, 1)
if gajim.contacts.has_key(account): if gajim.contacts.has_key(account):
AddNewContactWindow(self.plugin, account) AddNewContactWindow(account)
return True return True
return False return False
@ -444,7 +443,7 @@ class SignalObject(DbusPrototype):
if gajim.contacts[account].has_key(jid): if gajim.contacts[account].has_key(jid):
gajim.connections[account].unsubscribe(jid) gajim.connections[account].unsubscribe(jid)
for contact in gajim.contacts[account][jid]: for contact in gajim.contacts[account][jid]:
self.plugin.roster.remove_contact(contact, account) gajim.interface.roster.remove_contact(contact, account)
del gajim.contacts[account][jid] del gajim.contacts[account][jid]
contact_exists = True contact_exists = True
return contact_exists return contact_exists

256
src/roster_window.py
View file

@ -60,7 +60,7 @@ C_SECPIXBUF, # econdary_pixbuf
GTKGUI_GLADE = 'gtkgui.glade' GTKGUI_GLADE = 'gtkgui.glade'
class RosterWindow: class RosterWindow:
'''Class for main window of gtkgui plugin''' '''Class for main window of gtkgui interface'''
def get_account_iter(self, name): def get_account_iter(self, name):
if self.regroup: if self.regroup:
@ -248,7 +248,7 @@ class RosterWindow:
#FIXME: add avatar #FIXME: add avatar
def join_gc_room(self, account, room_jid, nick, password): def join_gc_room(self, account, room_jid, nick, password):
if room_jid in self.plugin.windows[account]['gc'] and \ if room_jid in gajim.interface.windows[account]['gc'] and \
gajim.gc_connected[account][room_jid]: gajim.gc_connected[account][room_jid]:
dialogs.ErrorDialog(_('You are already in room %s') %room_jid dialogs.ErrorDialog(_('You are already in room %s') %room_jid
).get_response() ).get_response()
@ -259,10 +259,10 @@ class RosterWindow:
).get_response() ).get_response()
return return
room, server = room_jid.split('@') room, server = room_jid.split('@')
if not room_jid in self.plugin.windows[account]['gc']: if not room_jid in gajim.interface.windows[account]['gc']:
self.new_room(room_jid, nick, account) self.new_room(room_jid, nick, account)
self.plugin.windows[account]['gc'][room_jid].set_active_tab(room_jid) gajim.interface.windows[account]['gc'][room_jid].set_active_tab(room_jid)
self.plugin.windows[account]['gc'][room_jid].window.present() gajim.interface.windows[account]['gc'][room_jid].window.present()
gajim.connections[account].join_gc(nick, room, server, password) gajim.connections[account].join_gc(nick, room, server, password)
def on_bookmark_menuitem_activate(self, widget, account, bookmark): def on_bookmark_menuitem_activate(self, widget, account, bookmark):
@ -275,23 +275,23 @@ class RosterWindow:
def on_send_server_message_menuitem_activate(self, widget, account): def on_send_server_message_menuitem_activate(self, widget, account):
server = gajim.config.get_per('accounts', account, 'hostname') server = gajim.config.get_per('accounts', account, 'hostname')
server += '/announce/online' server += '/announce/online'
dialogs.SingleMessageWindow(self.plugin, account, server, 'send') dialogs.SingleMessageWindow(account, server, 'send')
def on_xml_console_menuitem_activate(self, widget, account): def on_xml_console_menuitem_activate(self, widget, account):
if self.plugin.windows[account].has_key('xml_console'): if gajim.interface.windows[account].has_key('xml_console'):
self.plugin.windows[account]['xml_console'].window.present() gajim.interface.windows[account]['xml_console'].window.present()
else: else:
self.plugin.windows[account]['xml_console'].window.show_all() gajim.interface.windows[account]['xml_console'].window.show_all()
def on_set_motd_menuitem_activate(self, widget, account): def on_set_motd_menuitem_activate(self, widget, account):
server = gajim.config.get_per('accounts', account, 'hostname') server = gajim.config.get_per('accounts', account, 'hostname')
server += '/announce/motd' server += '/announce/motd'
dialogs.SingleMessageWindow(self.plugin, account, server, 'send') dialogs.SingleMessageWindow(account, server, 'send')
def on_update_motd_menuitem_activate(self, widget, account): def on_update_motd_menuitem_activate(self, widget, account):
server = gajim.config.get_per('accounts', account, 'hostname') server = gajim.config.get_per('accounts', account, 'hostname')
server += '/announce/motd/update' server += '/announce/motd/update'
dialogs.SingleMessageWindow(self.plugin, account, server, 'send') dialogs.SingleMessageWindow(account, server, 'send')
def on_delete_motd_menuitem_activate(self, widget, account): def on_delete_motd_menuitem_activate(self, widget, account):
server = gajim.config.get_per('accounts', account, 'hostname') server = gajim.config.get_per('accounts', account, 'hostname')
@ -628,28 +628,27 @@ class RosterWindow:
self.add_contact_to_roster(contact.jid, account) self.add_contact_to_roster(contact.jid, account)
self.draw_contact(contact.jid, account) self.draw_contact(contact.jid, account)
# print status in chat window and update status/GPG image # print status in chat window and update status/GPG image
if self.plugin.windows[account]['chats'].has_key(contact.jid): if gajim.interface.windows[account]['chats'].has_key(contact.jid):
jid = contact.jid jid = contact.jid
self.plugin.windows[account]['chats'][jid].set_state_image(jid) gajim.interface.windows[account]['chats'][jid].set_state_image(jid)
name = contact.name name = contact.name
if contact.resource != '': if contact.resource != '':
name += '/' + contact.resource name += '/' + contact.resource
uf_show = helpers.get_uf_show(show) uf_show = helpers.get_uf_show(show)
self.plugin.windows[account]['chats'][jid].print_conversation( gajim.interface.windows[account]['chats'][jid].print_conversation(
_('%s is now %s (%s)') % (name, uf_show, status), jid, 'status') _('%s is now %s (%s)') % (name, uf_show, status), jid, 'status')
if contact == gajim.get_contact_instance_with_highest_priority(\ if contact == gajim.get_contact_instance_with_highest_priority(\
account, contact.jid): account, contact.jid):
self.plugin.windows[account]['chats'][jid].draw_name_banner(contact) gajim.interface.windows[account]['chats'][jid].draw_name_banner(contact)
def on_info(self, widget, user, account): def on_info(self, widget, user, account):
'''Call vcard_information_window class to display user's information''' '''Call vcard_information_window class to display user's information'''
info = self.plugin.windows[account]['infos'] info = gajim.interface.windows[account]['infos']
if info.has_key(user.jid): if info.has_key(user.jid):
info[user.jid].window.present() info[user.jid].window.present()
else: else:
info[user.jid] = dialogs.VcardWindow(user, self.plugin, info[user.jid] = dialogs.VcardWindow(user, account)
account)
def show_tooltip(self, contact): def show_tooltip(self, contact):
pointer = self.tree.get_pointer() pointer = self.tree.get_pointer()
@ -800,24 +799,24 @@ class RosterWindow:
keys[user.jid] = keyID[0] keys[user.jid] = keyID[0]
for u in gajim.contacts[account][user.jid]: for u in gajim.contacts[account][user.jid]:
u.keyID = keyID[0] u.keyID = keyID[0]
if self.plugin.windows[account]['chats'].has_key(user.jid): if gajim.interface.windows[account]['chats'].has_key(user.jid):
self.plugin.windows[account]['chats'][user.jid].draw_widgets(user) gajim.interface.windows[account]['chats'][user.jid].draw_widgets(user)
keys_str = '' keys_str = ''
for jid in keys: for jid in keys:
keys_str += jid + ' ' + keys[jid] + ' ' keys_str += jid + ' ' + keys[jid] + ' '
gajim.config.set_per('accounts', account, 'attached_gpg_keys', keys_str) gajim.config.set_per('accounts', account, 'attached_gpg_keys', keys_str)
def on_edit_groups(self, widget, user, account): def on_edit_groups(self, widget, user, account):
dlg = dialogs.EditGroupsDialog(user, account, self.plugin) dlg = dialogs.EditGroupsDialog(user, account)
dlg.run() dlg.run()
def on_history(self, widget, contact, account): def on_history(self, widget, contact, account):
'''When history menuitem is activated: call log window''' '''When history menuitem is activated: call log window'''
if self.plugin.windows['logs'].has_key(contact.jid): if gajim.interface.windows['logs'].has_key(contact.jid):
self.plugin.windows['logs'][contact.jid].window.present() gajim.interface.windows['logs'][contact.jid].window.present()
else: else:
self.plugin.windows['logs'][contact.jid] = history_window.\ gajim.interface.windows['logs'][contact.jid] = history_window.\
HistoryWindow(self.plugin, contact.jid, account) HistoryWindow(contact.jid, account)
def on_send_single_message_menuitem_activate(self, wiget, account, def on_send_single_message_menuitem_activate(self, wiget, account,
contact = None): contact = None):
@ -827,7 +826,7 @@ class RosterWindow:
dialogs.SingleMessageWindow(self, account, contact.jid, 'send') dialogs.SingleMessageWindow(self, account, contact.jid, 'send')
def on_send_file_menuitem_activate(self, widget, account, contact): def on_send_file_menuitem_activate(self, widget, account, contact):
self.plugin.windows['file_transfers'].show_file_send_request( gajim.interface.windows['file_transfers'].show_file_send_request(
account, contact) account, contact)
def mk_menu_user(self, event, iter): def mk_menu_user(self, event, iter):
@ -990,11 +989,11 @@ class RosterWindow:
menu.show_all() menu.show_all()
def on_edit_account(self, widget, account): def on_edit_account(self, widget, account):
if self.plugin.windows[account].has_key('account_modification'): if gajim.interface.windows[account].has_key('account_modification'):
self.plugin.windows[account]['account_modification'].window.present() gajim.interface.windows[account]['account_modification'].window.present()
else: else:
self.plugin.windows[account]['account_modification'] = \ gajim.interface.windows[account]['account_modification'] = \
config.AccountModificationWindow(self.plugin, account) config.AccountModificationWindow(account)
def get_possible_button_event(self, event): def get_possible_button_event(self, event):
'''mouse or keyboard caused the event?''' '''mouse or keyboard caused the event?'''
@ -1007,7 +1006,7 @@ class RosterWindow:
def on_change_status_message_activate(self, widget, account): def on_change_status_message_activate(self, widget, account):
show = gajim.SHOW_LIST[gajim.connections[account].connected] show = gajim.SHOW_LIST[gajim.connections[account].connected]
dlg = dialogs.ChangeStatusMessageDialog(self.plugin, show) dlg = dialogs.ChangeStatusMessageDialog(show)
message = dlg.run() message = dlg.run()
if message is not None: # None is if user pressed Cancel if message is not None: # None is if user pressed Cancel
self.send_status(account, show, message) self.send_status(account, show, message)
@ -1099,7 +1098,7 @@ class RosterWindow:
account_context_menu.show_all() account_context_menu.show_all()
def on_add_to_roster(self, widget, user, account): def on_add_to_roster(self, widget, user, account):
dialogs.AddNewContactWindow(self.plugin, account, user.jid) dialogs.AddNewContactWindow(account, user.jid)
def authorize(self, widget, jid, account): def authorize(self, widget, jid, account):
'''Authorize a user (by re-sending auth menuitem)''' '''Authorize a user (by re-sending auth menuitem)'''
@ -1228,13 +1227,13 @@ _('If "%s" accepts this request you will know his status.') %jid)
if type in ('agent', 'contact'): if type in ('agent', 'contact'):
account = model[iter][C_ACCOUNT].decode('utf-8') account = model[iter][C_ACCOUNT].decode('utf-8')
jid = model[iter][C_JID].decode('utf-8') jid = model[iter][C_JID].decode('utf-8')
if self.plugin.windows[account]['chats'].has_key(jid): if gajim.interface.windows[account]['chats'].has_key(jid):
self.plugin.windows[account]['chats'][jid].set_active_tab(jid) gajim.interface.windows[account]['chats'][jid].set_active_tab(jid)
elif gajim.contacts[account].has_key(jid): elif gajim.contacts[account].has_key(jid):
c = gajim.get_contact_instance_with_highest_priority(account, jid) c = gajim.get_contact_instance_with_highest_priority(account, jid)
self.new_chat(c, account) self.new_chat(c, account)
self.plugin.windows[account]['chats'][jid].set_active_tab(jid) gajim.interface.windows[account]['chats'][jid].set_active_tab(jid)
self.plugin.windows[account]['chats'][jid].window.present() gajim.interface.windows[account]['chats'][jid].window.present()
elif type == 'account': elif type == 'account':
account = model[iter][C_ACCOUNT] account = model[iter][C_ACCOUNT]
show = gajim.connections[account].connected show = gajim.connections[account].connected
@ -1275,7 +1274,7 @@ _('If "%s" accepts this request you will know his status.') %jid)
for u in gajim.contacts[account][user.jid]: for u in gajim.contacts[account][user.jid]:
self.remove_contact(u, account) self.remove_contact(u, account)
del gajim.contacts[account][u.jid] del gajim.contacts[account][u.jid]
if user.jid in self.plugin.windows[account]['chats']: if user.jid in gajim.interface.windows[account]['chats']:
user1 = Contact(jid = user.jid, name = user.name, user1 = Contact(jid = user.jid, name = user.name,
groups = [_('not in the roster')], show = 'not in the roster', groups = [_('not in the roster')], show = 'not in the roster',
status = '', ask = 'none', keyID = user.keyID) status = '', ask = 'none', keyID = user.keyID)
@ -1292,8 +1291,8 @@ _('If "%s" accepts this request you will know his status.') %jid)
accountIter = self.get_account_iter(account) accountIter = self.get_account_iter(account)
if accountIter: if accountIter:
model[accountIter][0] = self.jabber_state_images['connecting'] model[accountIter][0] = self.jabber_state_images['connecting']
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.change_status('connecting') gajim.interface.systray.change_status('connecting')
def send_status(self, account, status, txt, sync = False, auto = False): def send_status(self, account, status, txt, sync = False, auto = False):
model = self.tree.get_model() model = self.tree.get_model()
@ -1313,8 +1312,8 @@ _('If "%s" accepts this request you will know his status.') %jid)
if passphrase == -1: if passphrase == -1:
if accountIter: if accountIter:
model[accountIter][0] = self.jabber_state_images['offline'] model[accountIter][0] = self.jabber_state_images['offline']
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.change_status('offline') gajim.interface.systray.change_status('offline')
self.update_status_comboxbox() self.update_status_comboxbox()
return return
gajim.connections[account].password = passphrase gajim.connections[account].password = passphrase
@ -1361,12 +1360,12 @@ _('If "%s" accepts this request you will know his status.') %jid)
gajim.connections[account].gpg_passphrase(passphrase) gajim.connections[account].gpg_passphrase(passphrase)
gajim.connections[account].change_status(status, txt, sync, auto) gajim.connections[account].change_status(status, txt, sync, auto)
for room_jid in self.plugin.windows[account]['gc']: for room_jid in gajim.interface.windows[account]['gc']:
if room_jid != 'tabbed': if room_jid != 'tabbed':
nick = self.plugin.windows[account]['gc'][room_jid].nicks[room_jid] nick = gajim.interface.windows[account]['gc'][room_jid].nicks[room_jid]
gajim.connections[account].send_gc_status(nick, room_jid, status, gajim.connections[account].send_gc_status(nick, room_jid, status,
txt) txt)
if status == 'online' and self.plugin.sleeper.getState() != \ if status == 'online' and gajim.interface.sleeper.getState() != \
common.sleepy.STATE_UNKNOWN: common.sleepy.STATE_UNKNOWN:
gajim.sleeper_state[account] = 'online' gajim.sleeper_state[account] = 'online'
else: else:
@ -1376,7 +1375,7 @@ _('If "%s" accepts this request you will know his status.') %jid)
if (show == 'online' and not gajim.config.get('ask_online_status')) or \ if (show == 'online' and not gajim.config.get('ask_online_status')) or \
(show == 'offline' and not gajim.config.get('ask_offline_status')): (show == 'offline' and not gajim.config.get('ask_offline_status')):
return '' return ''
dlg = dialogs.ChangeStatusMessageDialog(self.plugin, show) dlg = dialogs.ChangeStatusMessageDialog(show)
message = dlg.run() message = dlg.run()
return message return message
@ -1423,7 +1422,7 @@ _('If "%s" accepts this request you will know his status.') %jid)
).get_response() ).get_response()
self.update_status_comboxbox() self.update_status_comboxbox()
return return
dlg = dialogs.ChangeStatusMessageDialog(self.plugin) dlg = dialogs.ChangeStatusMessageDialog()
message = dlg.run() message = dlg.run()
if message is not None: # None if user pressed Cancel if message is not None: # None if user pressed Cancel
for acct in accounts: for acct in accounts:
@ -1467,7 +1466,7 @@ _('If "%s" accepts this request you will know his status.') %jid)
self.send_status(acct, status, message) self.send_status(acct, status, message)
def update_status_comboxbox(self): def update_status_comboxbox(self):
# table to change index in plugin.connected to index in combobox # table to change index in connection.connected to index in combobox
table = {0:9, 1:9, 2:0, 3:1, 4:2, 5:3, 6:4, 7:5} table = {0:9, 1:9, 2:0, 3:1, 4:2, 5:3, 6:4, 7:5}
maxi = 0 maxi = 0
for account in gajim.connections: for account in gajim.connections:
@ -1480,8 +1479,8 @@ _('If "%s" accepts this request you will know his status.') %jid)
self.status_combobox.handler_unblock(self.id_signal_cb) self.status_combobox.handler_unblock(self.id_signal_cb)
statuss = ['offline', 'connecting', 'online', 'chat', 'away', statuss = ['offline', 'connecting', 'online', 'chat', 'away',
'xa', 'dnd', 'invisible'] 'xa', 'dnd', 'invisible']
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.change_status(statuss[maxi]) gajim.interface.systray.change_status(statuss[maxi])
def on_status_changed(self, account, status): def on_status_changed(self, account, status):
'''the core tells us that our status has changed''' '''the core tells us that our status has changed'''
@ -1506,17 +1505,17 @@ _('If "%s" accepts this request you will know his status.') %jid)
def new_chat(self, contact, account): def new_chat(self, contact, account):
if gajim.config.get('usetabbedchat'): if gajim.config.get('usetabbedchat'):
if not self.plugin.windows[account]['chats'].has_key('tabbed'): if not gajim.interface.windows[account]['chats'].has_key('tabbed'):
self.plugin.windows[account]['chats']['tabbed'] = \ gajim.interface.windows[account]['chats']['tabbed'] = \
tabbed_chat_window.TabbedChatWindow(contact, self.plugin, account) tabbed_chat_window.TabbedChatWindow(contact, account)
else: else:
self.plugin.windows[account]['chats']['tabbed'].new_tab(contact) gajim.interface.windows[account]['chats']['tabbed'].new_tab(contact)
self.plugin.windows[account]['chats'][contact.jid] = \ gajim.interface.windows[account]['chats'][contact.jid] = \
self.plugin.windows[account]['chats']['tabbed'] gajim.interface.windows[account]['chats']['tabbed']
else: else:
self.plugin.windows[account]['chats'][contact.jid] = \ gajim.interface.windows[account]['chats'][contact.jid] = \
tabbed_chat_window.TabbedChatWindow(contact, self.plugin, account) tabbed_chat_window.TabbedChatWindow(contact, account)
def new_chat_from_jid(self, account, jid): def new_chat_from_jid(self, account, jid):
if gajim.contacts[account].has_key(jid): if gajim.contacts[account].has_key(jid):
@ -1533,24 +1532,23 @@ _('If "%s" accepts this request you will know his status.') %jid)
gajim.contacts[account][jid] = [contact] gajim.contacts[account][jid] = [contact]
self.add_contact_to_roster(contact.jid, account) self.add_contact_to_roster(contact.jid, account)
if not self.plugin.windows[account]['chats'].has_key(jid): if not gajim.interface.windows[account]['chats'].has_key(jid):
self.new_chat(contact, account) self.new_chat(contact, account)
self.plugin.windows[account]['chats'][jid].set_active_tab(jid) gajim.interface.windows[account]['chats'][jid].set_active_tab(jid)
self.plugin.windows[account]['chats'][jid].window.present() gajim.interface.windows[account]['chats'][jid].window.present()
def new_room(self, jid, nick, account): def new_room(self, jid, nick, account):
if gajim.config.get('usetabbedchat'): if gajim.config.get('usetabbedchat'):
if not self.plugin.windows[account]['gc'].has_key('tabbed'): if not gajim.interface.windows[account]['gc'].has_key('tabbed'):
self.plugin.windows[account]['gc']['tabbed'] = \ gajim.interface.windows[account]['gc']['tabbed'] = \
groupchat_window.GroupchatWindow(jid, nick, self.plugin, groupchat_window.GroupchatWindow(jid, nick, account)
account)
else: else:
self.plugin.windows[account]['gc']['tabbed'].new_room(jid, nick) gajim.interface.windows[account]['gc']['tabbed'].new_room(jid, nick)
self.plugin.windows[account]['gc'][jid] = \ gajim.interface.windows[account]['gc'][jid] = \
self.plugin.windows[account]['gc']['tabbed'] gajim.interface.windows[account]['gc']['tabbed']
else: else:
self.plugin.windows[account]['gc'][jid] = \ gajim.interface.windows[account]['gc'][jid] = \
groupchat_window.GroupchatWindow(jid, nick, self.plugin, account) groupchat_window.GroupchatWindow(jid, nick, account)
def on_message(self, jid, msg, tim, account, encrypted = False, def on_message(self, jid, msg, tim, account, encrypted = False,
msg_type = '', subject = None, resource = ''): msg_type = '', subject = None, resource = ''):
@ -1589,18 +1587,18 @@ _('If "%s" accepts this request you will know his status.') %jid)
if msg_type == 'normal': # it's single message if msg_type == 'normal': # it's single message
if popup: if popup:
contact = gajim.contacts[account][jid][0] contact = gajim.contacts[account][jid][0]
dialogs.SingleMessageWindow(self.plugin, account, contact.jid, dialogs.SingleMessageWindow(account, contact.jid,
action = 'receive', from_whom = jid, subject = subject, action = 'receive', from_whom = jid, subject = subject,
message = msg) message = msg)
return return
# We print if window is opened and it's not a single message # We print if window is opened and it's not a single message
if self.plugin.windows[account]['chats'].has_key(jid) and \ if gajim.interface.windows[account]['chats'].has_key(jid) and \
msg_type != 'normal': msg_type != 'normal':
typ = '' typ = ''
if msg_type == 'error': if msg_type == 'error':
typ = 'status' typ = 'status'
self.plugin.windows[account]['chats'][jid].print_conversation(msg, gajim.interface.windows[account]['chats'][jid].print_conversation(msg,
jid, typ, tim = tim, encrypted = encrypted, subject = subject) jid, typ, tim = tim, encrypted = encrypted, subject = subject)
return return
@ -1613,7 +1611,7 @@ _('If "%s" accepts this request you will know his status.') %jid)
qs[jid].append((kind, (msg, subject, msg_type, tim, encrypted))) qs[jid].append((kind, (msg, subject, msg_type, tim, encrypted)))
self.nb_unread += 1 self.nb_unread += 1
if popup: if popup:
if not self.plugin.windows[account]['chats'].has_key(jid): if not gajim.interface.windows[account]['chats'].has_key(jid):
c = gajim.get_contact_instance_with_highest_priority(account, jid) c = gajim.get_contact_instance_with_highest_priority(account, jid)
self.new_chat(c, account) self.new_chat(c, account)
if path: if path:
@ -1624,8 +1622,8 @@ _('If "%s" accepts this request you will know his status.') %jid)
else: else:
if no_queue: # We didn't have a queue: we change icons if no_queue: # We didn't have a queue: we change icons
self.draw_contact(jid, account) self.draw_contact(jid, account)
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.add_jid(jid, account, kind) gajim.interface.systray.add_jid(jid, account, kind)
self.show_title() # we show the * or [n] self.show_title() # we show the * or [n]
if not path: if not path:
self.add_contact_to_roster(jid, account) self.add_contact_to_roster(jid, account)
@ -1637,13 +1635,13 @@ _('If "%s" accepts this request you will know his status.') %jid)
self.tree.set_cursor(path) self.tree.set_cursor(path)
def on_preferences_menuitem_activate(self, widget): def on_preferences_menuitem_activate(self, widget):
if self.plugin.windows['preferences'].window.get_property('visible'): if gajim.interface.windows['preferences'].window.get_property('visible'):
self.plugin.windows['preferences'].window.present() gajim.interface.windows['preferences'].window.present()
else: else:
self.plugin.windows['preferences'].window.show_all() gajim.interface.windows['preferences'].window.show_all()
def on_add_new_contact(self, widget, account): def on_add_new_contact(self, widget, account):
dialogs.AddNewContactWindow(self.plugin, account) dialogs.AddNewContactWindow(account)
def on_join_gc_activate(self, widget, account): def on_join_gc_activate(self, widget, account):
invisible_show = gajim.SHOW_LIST.index('invisible') invisible_show = gajim.SHOW_LIST.index('invisible')
@ -1651,17 +1649,18 @@ _('If "%s" accepts this request you will know his status.') %jid)
dialogs.ErrorDialog(_('You cannot join a room while you are invisible') dialogs.ErrorDialog(_('You cannot join a room while you are invisible')
).get_response() ).get_response()
return return
if self.plugin.windows[account].has_key('join_gc'): if gajim.interface.windows[account].has_key('join_gc'):
self.plugin.windows[account]['join_gc'].window.present() gajim.interface.windows[account]['join_gc'].window.present()
else: else:
# c http://nkour.blogspot.com/2005/05/pythons-init-return-none-doesnt-return.html # c http://nkour.blogspot.com/2005/05/pythons-init-return-none-doesnt-return.html
try: try:
self.plugin.windows[account]['join_gc'] = dialogs.JoinGroupchatWindow(self.plugin, account) gajim.interface.windows[account]['join_gc'] = \
dialogs.JoinGroupchatWindow(account)
except RuntimeError: except RuntimeError:
pass pass
def on_new_message_menuitem_activate(self, widget, account): def on_new_message_menuitem_activate(self, widget, account):
dialogs.NewMessageDialog(self.plugin, account) dialogs.NewMessageDialog(account)
def on_contents_menuitem_activate(self, widget): def on_contents_menuitem_activate(self, widget):
helpers.launch_browser_mailer('url', 'http://trac.gajim.org/wiki') helpers.launch_browser_mailer('url', 'http://trac.gajim.org/wiki')
@ -1673,19 +1672,19 @@ _('If "%s" accepts this request you will know his status.') %jid)
dialogs.AboutDialog() dialogs.AboutDialog()
def on_accounts_menuitem_activate(self, widget): def on_accounts_menuitem_activate(self, widget):
if self.plugin.windows.has_key('accounts'): if gajim.interface.windows.has_key('accounts'):
self.plugin.windows['accounts'].window.present() gajim.interface.windows['accounts'].window.present()
else: else:
self.plugin.windows['accounts'] = config.AccountsWindow(self.plugin) gajim.interface.windows['accounts'] = config.AccountsWindow()
def on_file_transfers_menuitem_activate(self, widget): def on_file_transfers_menuitem_activate(self, widget):
if self.plugin.windows['file_transfers'].window.get_property('visible'): if gajim.interface.windows['file_transfers'].window.get_property('visible'):
self.plugin.windows['file_transfers'].window.present() gajim.interface.windows['file_transfers'].window.present()
else: else:
self.plugin.windows['file_transfers'].window.show_all() gajim.interface.windows['file_transfers'].window.show_all()
def on_manage_bookmarks_menuitem_activate(self, widget): def on_manage_bookmarks_menuitem_activate(self, widget):
config.ManageBookmarksWindow(self.plugin) config.ManageBookmarksWindow()
def close_all(self, dic): def close_all(self, dic):
'''close all the windows in the given dictionary''' '''close all the windows in the given dictionary'''
@ -1697,7 +1696,7 @@ _('If "%s" accepts this request you will know his status.') %jid)
def on_roster_window_delete_event(self, widget, event): def on_roster_window_delete_event(self, widget, event):
'''When we want to close the window''' '''When we want to close the window'''
if self.plugin.systray_enabled and not gajim.config.get('quit_on_roster_x_button'): if gajim.interface.systray_enabled and not gajim.config.get('quit_on_roster_x_button'):
self.tooltip.hide_tooltip() self.tooltip.hide_tooltip()
self.window.hide() self.window.hide()
else: else:
@ -1714,7 +1713,7 @@ _('If "%s" accepts this request you will know his status.') %jid)
for acct in accounts: for acct in accounts:
if gajim.connections[acct].connected: if gajim.connections[acct].connected:
self.send_status(acct, 'offline', message, True) self.send_status(acct, 'offline', message, True)
self.quit_gtkgui_plugin() self.quit_gtkgui_interface()
return True # do NOT destory the window return True # do NOT destory the window
def on_roster_window_focus_in_event(self, widget, event): def on_roster_window_focus_in_event(self, widget, event):
@ -1729,12 +1728,12 @@ _('If "%s" accepts this request you will know his status.') %jid)
if event.keyval == gtk.keysyms.Escape: if event.keyval == gtk.keysyms.Escape:
treeselection = self.tree.get_selection() treeselection = self.tree.get_selection()
model, iter = treeselection.get_selected() model, iter = treeselection.get_selected()
if not iter and self.plugin.systray_enabled and not gajim.config.get('quit_on_roster_x_button'): if not iter and gajim.interface.systray_enabled and not gajim.config.get('quit_on_roster_x_button'):
self.tooltip.hide_tooltip() self.tooltip.hide_tooltip()
self.window.hide() self.window.hide()
def quit_gtkgui_plugin(self): def quit_gtkgui_interface(self):
'''When we quit the gtk plugin : '''When we quit the gtk interface :
tell that to the core and exit gtk''' tell that to the core and exit gtk'''
if gajim.config.get('saveposition'): if gajim.config.get('saveposition'):
# in case show_roster_on_start is False and roster is never shown # in case show_roster_on_start is False and roster is never shown
@ -1748,12 +1747,12 @@ _('If "%s" accepts this request you will know his status.') %jid)
gajim.config.set('roster_height', height) gajim.config.set('roster_height', height)
gajim.config.set('collapsed_rows', '\t'.join(self.collapsed_rows)) gajim.config.set('collapsed_rows', '\t'.join(self.collapsed_rows))
self.plugin.save_config() gajim.interface.save_config()
for account in gajim.connections: for account in gajim.connections:
gajim.connections[account].quit(True) gajim.connections[account].quit(True)
self.close_all(self.plugin.windows) self.close_all(gajim.interface.windows)
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.hide_systray() gajim.interface.hide_systray()
gtk.main_quit() gtk.main_quit()
def on_quit_menuitem_activate(self, widget): def on_quit_menuitem_activate(self, widget):
@ -1773,10 +1772,10 @@ _('If "%s" accepts this request you will know his status.') %jid)
if self.nb_unread > 0: if self.nb_unread > 0:
unread = True unread = True
for account in accounts: for account in accounts:
if self.plugin.windows[account]['chats'].has_key('tabbed'): if gajim.interface.windows[account]['chats'].has_key('tabbed'):
wins = [self.plugin.windows[account]['chats']['tabbed']] wins = [gajim.interface.windows[account]['chats']['tabbed']]
else: else:
wins = self.plugin.windows[account]['chats'].values() wins = gajim.interface.windows[account]['chats'].values()
for win in wins: for win in wins:
unrd = 0 unrd = 0
for jid in win.nb_unread: for jid in win.nb_unread:
@ -1803,16 +1802,16 @@ _('If "%s" accepts this request you will know his status.') %jid)
if gajim.connections[acct].connected: if gajim.connections[acct].connected:
# send status asynchronously # send status asynchronously
self.send_status(acct, 'offline', message, True) self.send_status(acct, 'offline', message, True)
self.quit_gtkgui_plugin() self.quit_gtkgui_interface()
def open_event(self, account, jid, event): def open_event(self, account, jid, event):
'''If an event was handled, return True, else return False''' '''If an event was handled, return True, else return False'''
typ = event[0] typ = event[0]
data = event[1] data = event[1]
ft = self.plugin.windows['file_transfers'] ft = gajim.interface.windows['file_transfers']
self.plugin.remove_first_event(account, jid, typ) gajim.interface.remove_first_event(account, jid, typ)
if typ == 'normal': if typ == 'normal':
dialogs.SingleMessageWindow(self.plugin, account, jid, dialogs.SingleMessageWindow(account, jid,
action = 'receive', from_whom = jid, subject = data[1], action = 'receive', from_whom = jid, subject = data[1],
message = data[0]) message = data[0])
return True return True
@ -1849,13 +1848,13 @@ _('If "%s" accepts this request you will know his status.') %jid)
if self.open_event(account, jid, first_ev): if self.open_event(account, jid, first_ev):
return return
if self.plugin.windows[account]['chats'].has_key(jid): if gajim.interface.windows[account]['chats'].has_key(jid):
self.plugin.windows[account]['chats'][jid].set_active_tab(jid) gajim.interface.windows[account]['chats'][jid].set_active_tab(jid)
elif gajim.contacts[account].has_key(jid): elif gajim.contacts[account].has_key(jid):
c = gajim.get_contact_instance_with_highest_priority(account, jid) c = gajim.get_contact_instance_with_highest_priority(account, jid)
self.new_chat(c, account) self.new_chat(c, account)
self.plugin.windows[account]['chats'][jid].set_active_tab(jid) gajim.interface.windows[account]['chats'][jid].set_active_tab(jid)
self.plugin.windows[account]['chats'][jid].window.present() gajim.interface.windows[account]['chats'][jid].window.present()
def on_roster_treeview_row_expanded(self, widget, iter, path): def on_roster_treeview_row_expanded(self, widget, iter, path):
'''When a row is expanded change the icon of the arrow''' '''When a row is expanded change the icon of the arrow'''
@ -1975,13 +1974,13 @@ _('If "%s" accepts this request you will know his status.') %jid)
model.set_value(iter, 5, False) model.set_value(iter, 5, False)
def on_service_disco_menuitem_activate(self, widget, account): def on_service_disco_menuitem_activate(self, widget, account):
if self.plugin.windows[account].has_key('disco'): if gajim.interface.windows[account].has_key('disco'):
self.plugin.windows[account]['disco'].window.present() gajim.interface.windows[account]['disco'].window.present()
else: else:
# c http://nkour.blogspot.com/2005/05/pythons-init-return-none-doesnt-return.html # c http://nkour.blogspot.com/2005/05/pythons-init-return-none-doesnt-return.html
try: try:
self.plugin.windows[account]['disco'] = \ gajim.interface.windows[account]['disco'] = \
config.ServiceDiscoveryWindow(self.plugin, account) config.ServiceDiscoveryWindow(account)
except RuntimeError: except RuntimeError:
pass pass
@ -2027,27 +2026,27 @@ _('If "%s" accepts this request you will know his status.') %jid)
model[iter][1] = self.jabber_state_images[model[iter][2]] model[iter][1] = self.jabber_state_images[model[iter][2]]
iter = model.iter_next(iter) iter = model.iter_next(iter)
# Update the systray # Update the systray
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.set_img() gajim.interface.systray.set_img()
for account in gajim.connections: for account in gajim.connections:
# Update opened chat windows # Update opened chat windows
for jid in self.plugin.windows[account]['chats']: for jid in gajim.interface.windows[account]['chats']:
if jid != 'tabbed': if jid != 'tabbed':
self.plugin.windows[account]['chats'][jid].set_state_image(jid) gajim.interface.windows[account]['chats'][jid].set_state_image(jid)
# Update opened groupchat windows # Update opened groupchat windows
for jid in self.plugin.windows[account]['gc']: for jid in gajim.interface.windows[account]['gc']:
if jid != 'tabbed': if jid != 'tabbed':
self.plugin.windows[account]['gc'][jid].update_state_images() gajim.interface.windows[account]['gc'][jid].update_state_images()
self.update_status_comboxbox() self.update_status_comboxbox()
def repaint_themed_widgets(self): def repaint_themed_widgets(self):
"""Notify windows that contain themed widgets to repaint them""" """Notify windows that contain themed widgets to repaint them"""
for account in gajim.connections: for account in gajim.connections:
# Update opened chat windows/tabs # Update opened chat windows/tabs
for jid in self.plugin.windows[account]['chats']: for jid in gajim.interface.windows[account]['chats']:
self.plugin.windows[account]['chats'][jid].repaint_colored_widgets() gajim.interface.windows[account]['chats'][jid].repaint_colored_widgets()
for jid in self.plugin.windows[account]['gc']: for jid in gajim.interface.windows[account]['gc']:
self.plugin.windows[account]['gc'][jid].repaint_colored_widgets() gajim.interface.windows[account]['gc'][jid].repaint_colored_widgets()
def on_show_offline_contacts_menuitem_activate(self, widget): def on_show_offline_contacts_menuitem_activate(self, widget):
'''when show offline option is changed: '''when show offline option is changed:
@ -2323,11 +2322,10 @@ _('If "%s" accepts this request you will know his status.') %jid)
return True return True
return False return False
def __init__(self, plugin): def __init__(self):
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'roster_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'roster_window', APP)
self.window = self.xml.get_widget('roster_window') self.window = self.xml.get_widget('roster_window')
self.tree = self.xml.get_widget('roster_treeview') self.tree = self.xml.get_widget('roster_treeview')
self.plugin = plugin
self.nb_unread = 0 self.nb_unread = 0
self.last_save_dir = None self.last_save_dir = None
self.editing_path = None # path of row with cell in edit mode self.editing_path = None # path of row with cell in edit mode
@ -2467,7 +2465,7 @@ _('If "%s" accepts this request you will know his status.') %jid)
self.on_status_combobox_changed) self.on_status_combobox_changed)
self.collapsed_rows = gajim.config.get('collapsed_rows').split('\t') self.collapsed_rows = gajim.config.get('collapsed_rows').split('\t')
self.tooltip = tooltips.RosterTooltip(self.plugin) self.tooltip = tooltips.RosterTooltip()
self.make_menu() self.make_menu()
self.draw_roster() self.draw_roster()
@ -2480,5 +2478,5 @@ _('If "%s" accepts this request you will know his status.') %jid)
gajim.config.set('show_roster_on_startup', True) gajim.config.set('show_roster_on_startup', True)
if len(gajim.connections) == 0: # if we have no account if len(gajim.connections) == 0: # if we have no account
self.plugin.windows['wizard_window'] = \ gajim.interface.windows['wizard_window'] = \
config.FirstTimeWizardWindow(self.plugin) config.FirstTimeWizardWindow()

47
src/systray.py
View file

@ -52,8 +52,7 @@ class Systray:
This class is both base class (for systraywin32.py) and normal class This class is both base class (for systraywin32.py) and normal class
for trayicon in GNU/Linux''' for trayicon in GNU/Linux'''
def __init__(self, plugin): def __init__(self):
self.plugin = plugin
self.jids = [] # Contain things like [account, jid, type_of_msg] self.jids = [] # Contain things like [account, jid, type_of_msg]
self.new_message_handler_id = None self.new_message_handler_id = None
self.t = None self.t = None
@ -68,7 +67,7 @@ class Systray:
state = 'message' state = 'message'
else: else:
state = self.status state = self.status
image = self.plugin.roster.jabber_state_images[state] image = gajim.interface.roster.jabber_state_images[state]
if image.get_storage_type() == gtk.IMAGE_ANIMATION: if image.get_storage_type() == gtk.IMAGE_ANIMATION:
self.img_tray.set_from_animation(image.get_animation()) self.img_tray.set_from_animation(image.get_animation())
elif image.get_storage_type() == gtk.IMAGE_PIXBUF: elif image.get_storage_type() == gtk.IMAGE_PIXBUF:
@ -95,18 +94,18 @@ class Systray:
self.set_img() self.set_img()
def start_chat(self, widget, account, jid): def start_chat(self, widget, account, jid):
if self.plugin.windows[account]['chats'].has_key(jid): if gajim.interface.windows[account]['chats'].has_key(jid):
self.plugin.windows[account]['chats'][jid].window.present() gajim.interface.windows[account]['chats'][jid].window.present()
self.plugin.windows[account]['chats'][jid].set_active_tab(jid) gajim.interface.windows[account]['chats'][jid].set_active_tab(jid)
elif gajim.contacts[account].has_key(jid): elif gajim.contacts[account].has_key(jid):
self.plugin.roster.new_chat( gajim.interface.roster.new_chat(
gajim.contacts[account][jid][0], account) gajim.contacts[account][jid][0], account)
self.plugin.windows[account]['chats'][jid].set_active_tab(jid) gajim.interface.windows[account]['chats'][jid].set_active_tab(jid)
def on_new_message_menuitem_activate(self, widget, account): def on_new_message_menuitem_activate(self, widget, account):
"""When new message menuitem is activated: """When new message menuitem is activated:
call the NewMessageDialog class""" call the NewMessageDialog class"""
dialogs.NewMessageDialog(self.plugin, account) dialogs.NewMessageDialog(account)
def make_menu(self, event = None): def make_menu(self, event = None):
'''create chat with and new message (sub) menus/menuitems '''create chat with and new message (sub) menus/menuitems
@ -130,7 +129,7 @@ class Systray:
if not iconset: if not iconset:
iconset = 'sun' iconset = 'sun'
path = os.path.join(gajim.DATA_DIR, 'iconsets/' + iconset + '/16x16/') path = os.path.join(gajim.DATA_DIR, 'iconsets/' + iconset + '/16x16/')
state_images = self.plugin.roster.load_iconset(path) state_images = gajim.interface.roster.load_iconset(path)
for show in ['online', 'chat', 'away', 'xa', 'dnd', 'invisible']: for show in ['online', 'chat', 'away', 'xa', 'dnd', 'invisible']:
uf_show = helpers.get_uf_show(show, use_mnemonic = True) uf_show = helpers.get_uf_show(show, use_mnemonic = True)
@ -211,13 +210,13 @@ class Systray:
self.systray_context_menu.show_all() self.systray_context_menu.show_all()
def on_preferences_menuitem_activate(self, widget): def on_preferences_menuitem_activate(self, widget):
if self.plugin.windows['preferences'].window.get_property('visible'): if gajim.interface.windows['preferences'].window.get_property('visible'):
self.plugin.windows['preferences'].window.present() gajim.interface.windows['preferences'].window.present()
else: else:
self.plugin.windows['preferences'].window.show_all() gajim.interface.windows['preferences'].window.show_all()
def on_quit_menuitem_activate(self, widget): def on_quit_menuitem_activate(self, widget):
self.plugin.roster.on_quit_menuitem_activate(widget) gajim.interface.roster.on_quit_menuitem_activate(widget)
def make_groups_submenus_for_chat_with(self, account): def make_groups_submenus_for_chat_with(self, account):
groups_menu = gtk.Menu() groups_menu = gtk.Menu()
@ -252,7 +251,7 @@ class Systray:
return groups_menu return groups_menu
def on_left_click(self): def on_left_click(self):
win = self.plugin.roster.window win = gajim.interface.roster.window
if len(self.jids) == 0: if len(self.jids) == 0:
if win.get_property('visible'): if win.get_property('visible'):
win.hide() win.hide()
@ -262,7 +261,7 @@ class Systray:
account = self.jids[0][0] account = self.jids[0][0]
jid = self.jids[0][1] jid = self.jids[0][1]
typ = self.jids[0][2] typ = self.jids[0][2]
wins = self.plugin.windows[account] wins = gajim.interface.windows[account]
w = None w = None
if typ == 'gc': if typ == 'gc':
if wins['gc'].has_key(jid): if wins['gc'].has_key(jid):
@ -271,7 +270,7 @@ class Systray:
if wins['chats'].has_key(jid): if wins['chats'].has_key(jid):
w = wins['chats'][jid] w = wins['chats'][jid]
else: else:
self.plugin.roster.new_chat( gajim.interface.roster.new_chat(
gajim.contacts[account][jid][0], account) gajim.contacts[account][jid][0], account)
w = wins['chats'][jid] w = wins['chats'][jid]
elif typ == 'pm': elif typ == 'pm':
@ -282,14 +281,14 @@ class Systray:
show = gajim.gc_contacts[account][room_jid][nick].show show = gajim.gc_contacts[account][room_jid][nick].show
c = Contact(jid = jid, name = nick, groups = ['none'], c = Contact(jid = jid, name = nick, groups = ['none'],
show = show, ask = 'none') show = show, ask = 'none')
self.plugin.roster.new_chat(c, account) gajim.interface.roster.new_chat(c, account)
w = wins['chats'][jid] w = wins['chats'][jid]
elif typ in ('normal', 'file-request', 'file-request-error', elif typ in ('normal', 'file-request', 'file-request-error',
'file-send-error', 'file-error', 'file-stopped', 'file-completed'): 'file-send-error', 'file-error', 'file-stopped', 'file-completed'):
# Get the first single message event # Get the first single message event
ev = gajim.get_first_event(account, jid, typ) ev = gajim.get_first_event(account, jid, typ)
# Open the window # Open the window
self.plugin.roster.open_event(account, jid, ev) gajim.interface.roster.open_event(account, jid, ev)
if w: if w:
w.set_active_tab(jid) w.set_active_tab(jid)
w.window.present() w.window.present()
@ -297,7 +296,7 @@ class Systray:
w.scroll_to_end(tv) w.scroll_to_end(tv)
def on_middle_click(self): def on_middle_click(self):
win = self.plugin.roster.window win = gajim.interface.roster.window
if win.is_active(): if win.is_active():
win.hide() win.hide()
else: else:
@ -315,10 +314,10 @@ class Systray:
def on_show_menuitem_activate(self, widget, show): def on_show_menuitem_activate(self, widget, show):
l = ['online', 'chat', 'away', 'xa', 'dnd', 'invisible', 'offline'] l = ['online', 'chat', 'away', 'xa', 'dnd', 'invisible', 'offline']
index = l.index(show) index = l.index(show)
self.plugin.roster.status_combobox.set_active(index) gajim.interface.roster.status_combobox.set_active(index)
def on_change_status_message_activate(self, widget): def on_change_status_message_activate(self, widget):
dlg = dialogs.ChangeStatusMessageDialog(self.plugin) dlg = dialogs.ChangeStatusMessageDialog()
message = dlg.run() message = dlg.run()
if message is not None: # None if user press Cancel if message is not None: # None if user press Cancel
accounts = gajim.connections.keys() accounts = gajim.connections.keys()
@ -327,7 +326,7 @@ class Systray:
'sync_with_global_status'): 'sync_with_global_status'):
continue continue
show = gajim.SHOW_LIST[gajim.connections[acct].connected] show = gajim.SHOW_LIST[gajim.connections[acct].connected]
self.plugin.roster.send_status(acct, show, message) gajim.interface.roster.send_status(acct, show, message)
def show_tooltip(self, widget): def show_tooltip(self, widget):
position = widget.window.get_origin() position = widget.window.get_origin()
@ -364,7 +363,7 @@ class Systray:
eb.connect('button-press-event', self.on_clicked) eb.connect('button-press-event', self.on_clicked)
eb.connect('motion-notify-event', self.on_tray_motion_notify_event) eb.connect('motion-notify-event', self.on_tray_motion_notify_event)
eb.connect('leave-notify-event', self.on_tray_leave_notify_event) eb.connect('leave-notify-event', self.on_tray_leave_notify_event)
self.tooltip = tooltips.NotificationAreaTooltip(self.plugin) self.tooltip = tooltips.NotificationAreaTooltip()
self.img_tray = gtk.Image() self.img_tray = gtk.Image()
eb.add(self.img_tray) eb.add(self.img_tray)

21
src/systraywin32.py
View file

@ -214,10 +214,9 @@ class NotifyIcon:
class SystrayWin32(systray.Systray): class SystrayWin32(systray.Systray):
def __init__(self, plugin): def __init__(self):
# Note: gtk window must be realized before installing extensions. # Note: gtk window must be realized before installing extensions.
systray.Systray.__init__(self, plugin) systray.Systray.__init__(self)
self.plugin = plugin
self.jids = [] self.jids = []
self.status = 'offline' self.status = 'offline'
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'systray_context_menu', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'systray_context_menu', APP)
@ -226,14 +225,14 @@ class SystrayWin32(systray.Systray):
self.tray_ico_imgs = self.load_icos() self.tray_ico_imgs = self.load_icos()
#self.plugin.roster.window.realize() #gajim.interface.roster.window.realize()
#self.plugin.roster.window.show_all() #gajim.interface.roster.window.show_all()
w = gtk.Window() # just a window to pass w = gtk.Window() # just a window to pass
w.realize() # realize it so gtk window exists w.realize() # realize it so gtk window exists
self.systray_winapi = SystrayWINAPI(w) self.systray_winapi = SystrayWINAPI(w)
# this fails if you move the window # this fails if you move the window
#self.systray_winapi = SystrayWINAPI(self.plugin.roster.window) #self.systray_winapi = SystrayWINAPI(gajim.interface.roster.window)
self.xml.signal_autoconnect(self) self.xml.signal_autoconnect(self)
@ -266,11 +265,11 @@ class SystrayWin32(systray.Systray):
def add_jid(self, jid, account, typ): def add_jid(self, jid, account, typ):
systray.Systray.add_jid(self, jid, account, typ) systray.Systray.add_jid(self, jid, account, typ)
nb = self.plugin.roster.nb_unread nb = gajim.interface.roster.nb_unread
for acct in gajim.connections: for acct in gajim.connections:
# in chat / groupchat windows # in chat / groupchat windows
for kind in ['chats', 'gc']: for kind in ['chats', 'gc']:
jids = self.plugin.windows[acct][kind] jids = gajim.interface.windows[acct][kind]
for jid in jids: for jid in jids:
if jid != 'tabbed': if jid != 'tabbed':
nb += jids[jid].nb_unread[jid] nb += jids[jid].nb_unread[jid]
@ -285,13 +284,13 @@ class SystrayWin32(systray.Systray):
def remove_jid(self, jid, account, typ): def remove_jid(self, jid, account, typ):
systray.Systray.remove_jid(self, jid, account, typ) systray.Systray.remove_jid(self, jid, account, typ)
nb = self.plugin.roster.nb_unread nb = gajim.interface.roster.nb_unread
for acct in gajim.connections: for acct in gajim.connections:
# in chat / groupchat windows # in chat / groupchat windows
for kind in ['chats', 'gc']: for kind in ['chats', 'gc']:
for jid in self.plugin.windows[acct][kind]: for jid in gajim.interface.windows[acct][kind]:
if jid != 'tabbed': if jid != 'tabbed':
nb += self.plugin.windows[acct][kind][jid].nb_unread[jid] nb += gajim.interface.windows[acct][kind][jid].nb_unread[jid]
if nb > 0: if nb > 0:
text = i18n.ngettext( text = i18n.ngettext(

42
src/tabbed_chat_window.py
View file

@ -43,10 +43,10 @@ GTKGUI_GLADE = 'gtkgui.glade'
class TabbedChatWindow(chat.Chat): class TabbedChatWindow(chat.Chat):
'''Class for tabbed chat window''' '''Class for tabbed chat window'''
def __init__(self, contact, plugin, account): def __init__(self, contact, account):
# we check that on opening new windows # we check that on opening new windows
self.always_compact_view = gajim.config.get('always_compact_view_chat') self.always_compact_view = gajim.config.get('always_compact_view_chat')
chat.Chat.__init__(self, plugin, account, 'tabbed_chat_window') chat.Chat.__init__(self, account, 'tabbed_chat_window')
self.contacts = {} self.contacts = {}
# keep check for possible paused timeouts per jid # keep check for possible paused timeouts per jid
self.possible_paused_timeout_id = {} self.possible_paused_timeout_id = {}
@ -123,14 +123,14 @@ class TabbedChatWindow(chat.Chat):
for uri in uri_splitted: for uri in uri_splitted:
path = helpers.get_file_path_from_dnd_dropped_uri(uri) path = helpers.get_file_path_from_dnd_dropped_uri(uri)
if os.path.isfile(path): # is it file? if os.path.isfile(path): # is it file?
self.plugin.windows['file_transfers'].send_file(self.account, gajim.interface.windows['file_transfers'].send_file(self.account,
contact, path) contact, path)
def on_avatar_eventbox_enter_notify_event(self, widget, event): def on_avatar_eventbox_enter_notify_event(self, widget, event):
'''we enter the eventbox area so we under conditions add a timeout '''we enter the eventbox area so we under conditions add a timeout
to show a bigger avatar after 0.5 sec''' to show a bigger avatar after 0.5 sec'''
jid = self.get_active_jid() jid = self.get_active_jid()
avatar_pixbuf = self.plugin.avatar_pixbufs[jid] avatar_pixbuf = gajim.interface.avatar_pixbufs[jid]
avatar_w = avatar_pixbuf.get_width() avatar_w = avatar_pixbuf.get_width()
avatar_h = avatar_pixbuf.get_height() avatar_h = avatar_pixbuf.get_height()
@ -154,7 +154,7 @@ class TabbedChatWindow(chat.Chat):
'''resizes the avatar, if needed, so it has at max half the screen size '''resizes the avatar, if needed, so it has at max half the screen size
and shows it''' and shows it'''
jid = self.get_active_jid() jid = self.get_active_jid()
avatar_pixbuf = self.plugin.avatar_pixbufs[jid] avatar_pixbuf = gajim.interface.avatar_pixbufs[jid]
screen_w = gtk.gdk.screen_width() screen_w = gtk.gdk.screen_width()
screen_h = gtk.gdk.screen_height() screen_h = gtk.gdk.screen_height()
avatar_w = avatar_pixbuf.get_width() avatar_w = avatar_pixbuf.get_width()
@ -289,11 +289,11 @@ class TabbedChatWindow(chat.Chat):
if not xml: if not xml:
return return
if self.plugin.avatar_pixbufs[jid] is None: if gajim.interface.avatar_pixbufs[jid] is None:
# contact has no avatar # contact has no avatar
scaled_buf = None scaled_buf = None
else: else:
pixbuf = self.plugin.avatar_pixbufs[jid] pixbuf = gajim.interface.avatar_pixbufs[jid]
# resize to a width / height for the avatar not to have distortion # resize to a width / height for the avatar not to have distortion
# (keep aspect ratio) # (keep aspect ratio)
@ -330,7 +330,7 @@ class TabbedChatWindow(chat.Chat):
child = self.childs[jid] child = self.childs[jid]
hb = self.notebook.get_tab_label(child).get_children()[0] hb = self.notebook.get_tab_label(child).get_children()[0]
status_image = hb.get_children()[0] status_image = hb.get_children()[0]
state_images = self.plugin.roster.get_appropriate_state_images(jid) state_images = gajim.interface.roster.get_appropriate_state_images(jid)
# Set banner image # Set banner image
banner_image = state_images[show] banner_image = state_images[show]
@ -379,7 +379,7 @@ class TabbedChatWindow(chat.Chat):
gajim.config.set('chat-height', height) gajim.config.set('chat-height', height)
def on_tabbed_chat_window_destroy(self, widget): def on_tabbed_chat_window_destroy(self, widget):
#clean self.plugin.windows[self.account]['chats'] #clean gajim.interface.windows[self.account]['chats']
chat.Chat.on_window_destroy(self, widget, 'chats') chat.Chat.on_window_destroy(self, widget, 'chats')
def on_tabbed_chat_window_focus_in_event(self, widget, event): def on_tabbed_chat_window_focus_in_event(self, widget, event):
@ -393,12 +393,12 @@ class TabbedChatWindow(chat.Chat):
def on_send_file_menuitem_activate(self, widget): def on_send_file_menuitem_activate(self, widget):
jid = self.get_active_jid() jid = self.get_active_jid()
contact = gajim.get_first_contact_instance_from_jid(self.account, jid) contact = gajim.get_first_contact_instance_from_jid(self.account, jid)
self.plugin.windows['file_transfers'].show_file_send_request( gajim.interface.windows['file_transfers'].show_file_send_request(
self.account, contact) self.account, contact)
def on_add_to_roster_menuitem_activate(self, widget): def on_add_to_roster_menuitem_activate(self, widget):
jid = self.get_active_jid() jid = self.get_active_jid()
dialogs.AddNewContactWindow(self.plugin, self.account, jid) dialogs.AddNewContactWindow(self.account, jid)
def on_send_button_clicked(self, widget): def on_send_button_clicked(self, widget):
'''When send button is pressed: send the current message''' '''When send button is pressed: send the current message'''
@ -439,7 +439,7 @@ class TabbedChatWindow(chat.Chat):
# this is to prove cache code works: # this is to prove cache code works:
# should we ask vcard? (only the first time we should ask) # should we ask vcard? (only the first time we should ask)
if not self.plugin.avatar_pixbufs.has_key(contact.jid): if not gajim.interface.avatar_pixbufs.has_key(contact.jid):
# it's the first time, so we should ask vcard # it's the first time, so we should ask vcard
gajim.connections[self.account].request_vcard(contact.jid) gajim.connections[self.account].request_vcard(contact.jid)
#please do not remove this commented print until I'm done with showing #please do not remove this commented print until I'm done with showing
@ -780,7 +780,7 @@ class TabbedChatWindow(chat.Chat):
def on_contact_information_menuitem_clicked(self, widget): def on_contact_information_menuitem_clicked(self, widget):
jid = self.get_active_jid() jid = self.get_active_jid()
contact = self.contacts[jid] contact = self.contacts[jid]
self.plugin.roster.on_info(widget, contact, self.account) gajim.interface.roster.on_info(widget, contact, self.account)
def read_queue(self, jid): def read_queue(self, jid):
'''read queue and print messages containted in it''' '''read queue and print messages containted in it'''
@ -789,7 +789,7 @@ class TabbedChatWindow(chat.Chat):
# Is it a pm ? # Is it a pm ?
is_pm = False is_pm = False
room_jid = jid.split('/', 1)[0] room_jid = jid.split('/', 1)[0]
gcs = self.plugin.windows[self.account]['gc'] gcs = gajim.interface.windows[self.account]['gc']
if gcs.has_key(room_jid): if gcs.has_key(room_jid):
is_pm = True is_pm = True
events_to_keep = [] events_to_keep = []
@ -811,12 +811,12 @@ class TabbedChatWindow(chat.Chat):
if is_pm: if is_pm:
gcs[room_jid].nb_unread[room_jid] -= 1 gcs[room_jid].nb_unread[room_jid] -= 1
else: else:
self.plugin.roster.nb_unread -= 1 gajim.interface.roster.nb_unread -= 1
if is_pm: if is_pm:
gcs[room_jid].show_title() gcs[room_jid].show_title()
else: else:
self.plugin.roster.show_title() gajim.interface.roster.show_title()
# Keep only non-messages events # Keep only non-messages events
if len(events_to_keep): if len(events_to_keep):
gajim.awaiting_events[self.account][jid] = events_to_keep gajim.awaiting_events[self.account][jid] = events_to_keep
@ -825,19 +825,19 @@ class TabbedChatWindow(chat.Chat):
typ = 'chat' # Is it a normal chat or a pm ? typ = 'chat' # Is it a normal chat or a pm ?
# reset to status image in gc if it is a pm # reset to status image in gc if it is a pm
room_jid = jid.split('/', 1)[0] room_jid = jid.split('/', 1)[0]
gcs = self.plugin.windows[self.account]['gc'] gcs = gajim.interface.windows[self.account]['gc']
if gcs.has_key(room_jid): if gcs.has_key(room_jid):
gcs[room_jid].update_state_images() gcs[room_jid].update_state_images()
typ = 'pm' typ = 'pm'
self.plugin.roster.draw_contact(jid, self.account) gajim.interface.roster.draw_contact(jid, self.account)
if self.plugin.systray_enabled: if gajim.interface.systray_enabled:
self.plugin.systray.remove_jid(jid, self.account, typ) gajim.interface.systray.remove_jid(jid, self.account, typ)
showOffline = gajim.config.get('showoffline') showOffline = gajim.config.get('showoffline')
if (contact.show == 'offline' or contact.show == 'error') and \ if (contact.show == 'offline' or contact.show == 'error') and \
not showOffline: not showOffline:
if len(gajim.contacts[self.account][jid]) == 1: if len(gajim.contacts[self.account][jid]) == 1:
self.plugin.roster.really_remove_contact(contact, self.account) gajim.interface.roster.really_remove_contact(contact, self.account)
def print_conversation(self, text, jid, frm = '', tim = None, def print_conversation(self, text, jid, frm = '', tim = None,
encrypted = False, subject = None): encrypted = False, subject = None):

15
src/tooltips.py
View file

@ -173,8 +173,7 @@ class StatusTable:
class NotificationAreaTooltip(BaseTooltip, StatusTable): class NotificationAreaTooltip(BaseTooltip, StatusTable):
''' Tooltip that is shown in the notification area ''' ''' Tooltip that is shown in the notification area '''
def __init__(self, plugin): def __init__(self):
self.plugin = plugin
BaseTooltip.__init__(self) BaseTooltip.__init__(self)
StatusTable.__init__(self) StatusTable.__init__(self)
@ -204,14 +203,14 @@ class NotificationAreaTooltip(BaseTooltip, StatusTable):
accounts.append({'name': account, 'status_line': single_line, accounts.append({'name': account, 'status_line': single_line,
'show': status, 'message': message}) 'show': status, 'message': message})
unread_chat = self.plugin.roster.nb_unread unread_chat = gajim.interface.roster.nb_unread
unread_single_chat = 0 unread_single_chat = 0
unread_gc = 0 unread_gc = 0
unread_pm = 0 unread_pm = 0
for acct in gajim.connections: for acct in gajim.connections:
# we count unread chat/pm messages # we count unread chat/pm messages
chat_wins = self.plugin.windows[acct]['chats'] chat_wins = gajim.interface.windows[acct]['chats']
for jid in chat_wins: for jid in chat_wins:
if jid != 'tabbed': if jid != 'tabbed':
if gajim.contacts[acct].has_key(jid): if gajim.contacts[acct].has_key(jid):
@ -219,7 +218,7 @@ class NotificationAreaTooltip(BaseTooltip, StatusTable):
else: else:
unread_pm += chat_wins[jid].nb_unread[jid] unread_pm += chat_wins[jid].nb_unread[jid]
# we count unread gc/pm messages # we count unread gc/pm messages
gc_wins = self.plugin.windows[acct]['gc'] gc_wins = gajim.interface.windows[acct]['gc']
for jid in gc_wins: for jid in gc_wins:
if jid != 'tabbed': if jid != 'tabbed':
pm_msgs = gc_wins[jid].get_specific_unread(jid) pm_msgs = gc_wins[jid].get_specific_unread(jid)
@ -291,9 +290,8 @@ class NotificationAreaTooltip(BaseTooltip, StatusTable):
class GCTooltip(BaseTooltip, StatusTable): class GCTooltip(BaseTooltip, StatusTable):
''' Tooltip that is shown in the GC treeview ''' ''' Tooltip that is shown in the GC treeview '''
def __init__(self, plugin): def __init__(self):
self.account = None self.account = None
self.plugin = plugin
self.text_lable = gtk.Label() self.text_lable = gtk.Label()
self.text_lable.set_line_wrap(True) self.text_lable.set_line_wrap(True)
@ -339,9 +337,8 @@ class GCTooltip(BaseTooltip, StatusTable):
class RosterTooltip(BaseTooltip, StatusTable): class RosterTooltip(BaseTooltip, StatusTable):
''' Tooltip that is shown in the roster treeview ''' ''' Tooltip that is shown in the roster treeview '''
def __init__(self, plugin): def __init__(self):
self.account = None self.account = None
self.plugin = plugin
self.image = gtk.Image() self.image = gtk.Image()
self.image.set_alignment(0., 0.) self.image.set_alignment(0., 0.)

10
src/vcard.py
View file

@ -42,7 +42,7 @@ GTKGUI_GLADE = 'gtkgui.glade'
class VcardWindow: class VcardWindow:
'''Class for contact's information window''' '''Class for contact's information window'''
def __init__(self, contact, plugin, account, vcard = False): def __init__(self, contact, account, vcard = False):
#the contact variable is the jid if vcard is true #the contact variable is the jid if vcard is true
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'vcard_information_window', APP) self.xml = gtk.glade.XML(GTKGUI_GLADE, 'vcard_information_window', APP)
self.window = self.xml.get_widget('vcard_information_window') self.window = self.xml.get_widget('vcard_information_window')
@ -53,7 +53,6 @@ class VcardWindow:
self.publish_button.set_no_show_all(True) self.publish_button.set_no_show_all(True)
self.retrieve_button.set_no_show_all(True) self.retrieve_button.set_no_show_all(True)
self.plugin = plugin
self.contact = contact #don't use it if vcard is true self.contact = contact #don't use it if vcard is true
self.account = account self.account = account
self.vcard = vcard self.vcard = vcard
@ -74,7 +73,7 @@ class VcardWindow:
self.window.show_all() self.window.show_all()
def on_vcard_information_window_destroy(self, widget = None): def on_vcard_information_window_destroy(self, widget = None):
del self.plugin.windows[self.account]['infos'][self.jid] del gajim.interface.windows[self.account]['infos'][self.jid]
def on_vcard_information_window_key_press_event(self, widget, event): def on_vcard_information_window_key_press_event(self, widget, event):
if event.keyval == gtk.keysyms.Escape: if event.keyval == gtk.keysyms.Escape:
@ -90,8 +89,9 @@ class VcardWindow:
new_name = name_entry.get_text().decode('utf-8') new_name = name_entry.get_text().decode('utf-8')
if new_name != self.contact.name and new_name != '': if new_name != self.contact.name and new_name != '':
self.contact.name = new_name self.contact.name = new_name
for i in self.plugin.roster.get_contact_iter(self.contact.jid, self.account): for i in gajim.interface.roster.get_contact_iter(self.contact.jid,
self.plugin.roster.tree.get_model().set_value(i, 1, new_name) self.account):
gajim.interface.roster.tree.get_model().set_value(i, 1, new_name)
gajim.connections[self.account].update_contact(self.contact.jid, gajim.connections[self.account].update_contact(self.contact.jid,
self.contact.name, self.contact.groups) self.contact.name, self.contact.groups)
#log history ? #log history ?