gajim-plural/src/systraywin32.py

335 lines
9.4 KiB
Python
Raw Normal View History

#gtkwin32.py
# code initially based on
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/334779
__version__ = '1.01'
import sys
import win32gui
import systray
GWL_WNDPROC = -4
GWL_EXSTYLE = -20
IDI_APPLICATION = 32512
LWA_ALPHA = 0x02
WM_TASKBARCREATED = win32gui.RegisterWindowMessage('TaskbarCreated')
WM_USER = 1024
WM_TRAYMESSAGE = WM_USER + 20
WS_EX_LAYERED = 0x80000
import gtk
WM_LBUTTONUP = 0x0202
WM_RBUTTONUP = 0x0205
from common import gajim
from common import i18n
_ = i18n._
APP = i18n.APP
gtk.glade.bindtextdomain(APP, i18n.DIR)
gtk.glade.textdomain(APP)
GTKGUI_GLADE = 'gtkgui.glade'
class GTKWin32Ext:
def __init__(self, gtk_window):
self._window = gtk_window
self._hwnd = gtk_window.window.handle
self._message_map = {}
self.notify_icon = None
# Sublass the window and inject a WNDPROC to process messages.
self._oldwndproc = win32gui.SetWindowLong(self._hwnd, GWL_WNDPROC,
self._wndproc)
gtk_window.connect('unrealize', self.remove)
def add_notify_icon(self, menu, hicon=None, tooltip=None):
""" Creates a notify icon for the gtk window. """
if not self.notify_icon:
if not hicon:
hicon = win32gui.LoadIcon(0, IDI_APPLICATION)
self.notify_icon = NotifyIcon(self._hwnd, hicon, tooltip)
# Makes redraw if the taskbar is restarted.
self.message_map({WM_TASKBARCREATED: self.notify_icon._redraw})
def message_map(self, msg_map={}):
""" Maps message processing to callback functions ala win32gui. """
if msg_map:
if self._message_map:
duplicatekeys = [key for key in msg_map.keys()
if self._message_map.has_key(key)]
for key in duplicatekeys:
new_value = msg_map[key]
if isinstance(new_value, list):
raise TypeError('Dict cannot have list values')
value = self._message_map[key]
if new_value != value:
new_value = [new_value]
if isinstance(value, list):
value += new_value
else:
value = [value] + new_value
msg_map[key] = value
self._message_map.update(msg_map)
def message_unmap(self, msg, callback=None):
if self._message_map.has_key(msg):
if callback:
cblist = self._message_map[key]
if isinstance(cblist, list):
if not len(cblist) < 2:
for i in range(len(cblist)):
if cblist[i] == callback:
del self._message_map[key][i]
return
del self._message_map[key]
def remove_notify_icon(self):
""" Removes the notify icon. """
if self.notify_icon:
self.notify_icon.remove()
self.notify_icon = None
def remove(self, *args):
""" Unloads the extensions. """
self._message_map = {}
self.remove_notify_icon()
self = None
def show_balloon_tooltip(self, title, text, timeout=10,
icon=win32gui.NIIF_NONE):
""" Shows a baloon tooltip. """
if not self.notify_icon:
self.add_notifyicon()
self.notify_icon.show_balloon(title, text, timeout, icon)
def _wndproc(self, hwnd, msg, wparam, lparam):
""" A WINDPROC to process window messages. """
if self._message_map.has_key(msg):
callback = self._message_map[msg]
if isinstance(callback, list):
for cb in callback:
cb(hwnd, msg, wparam, lparam)
else:
callback(hwnd, msg, wparam, lparam)
return win32gui.CallWindowProc(self._oldwndproc, hwnd, msg, wparam,
lparam)
class NotifyIcon:
def __init__(self, hwnd, hicon, tooltip=None):
self._hwnd = hwnd
self._id = 0
self._flags = win32gui.NIF_MESSAGE | win32gui.NIF_ICON
self._callbackmessage = WM_TRAYMESSAGE
self._hicon = hicon
win32gui.Shell_NotifyIcon(win32gui.NIM_ADD, self._get_nid())
if tooltip: self.set_tooltip(tooltip)
def _get_nid(self):
""" Function to initialise & retrieve the NOTIFYICONDATA Structure. """
nid = (self._hwnd, self._id, self._flags, self._callbackmessage,
self._hicon)
nid = list(nid)
if not hasattr(self, '_tip'): self._tip = ''
nid.append(self._tip)
if not hasattr(self, '_info'): self._info = ''
nid.append(self._info)
if not hasattr(self, '_timeout'): self._timeout = 0
nid.append(self._timeout)
if not hasattr(self, '_infotitle'): self._infotitle = ''
nid.append(self._infotitle)
if not hasattr(self, '_infoflags'):self._infoflags = win32gui.NIIF_NONE
nid.append(self._infoflags)
return tuple(nid)
def remove(self):
""" Removes the tray icon. """
win32gui.Shell_NotifyIcon(win32gui.NIM_DELETE, self._get_nid())
def set_tooltip(self, tooltip):
""" Sets the tray icon tooltip. """
self._flags = self._flags | win32gui.NIF_TIP
self._tip = tooltip
win32gui.Shell_NotifyIcon(win32gui.NIM_MODIFY, self._get_nid())
def show_balloon(self, title, text, timeout=10, icon=win32gui.NIIF_NONE):
""" Shows a balloon tooltip from the tray icon. """
self._flags = self._flags | win32gui.NIF_INFO
self._infotitle = title
self._info = text
self._timeout = timeout * 1000
self._infoflags = icon
win32gui.Shell_NotifyIcon(win32gui.NIM_MODIFY, self._get_nid())
def _redraw(self, *args):
""" Redraws the tray icon. """
self.remove
win32gui.Shell_NotifyIcon(win32gui.NIM_ADD, self._get_nid())
#FIXME: subclass us under Systray
class SystrayWin32(systray.Systray):
def __init__(self, plugin):
# Note: gtk window must be realized before installing extensions.
self.plugin = plugin
self.jids = []
self.status = 'offline'
self.xml = gtk.glade.XML(GTKGUI_GLADE, 'systray_context_menu', APP)
self.systray_context_menu = self.xml.get_widget('systray_context_menu')
self.win32ext = GTKWin32Ext(self.plugin.roster.window)
#self.win32ext.add_notify_icon(self.systray_context_menu)
self.xml.signal_autoconnect(self)
# Set up the callback messages
self.win32ext.message_map({
WM_TRAYMESSAGE: self.on_clicked
})
def show_icon(self):
self.win32ext.add_notify_icon(self.systray_context_menu)
self.win32ext.notify_icon.menu = self.systray_context_menu
def hide_icon(self):
self.win32ext.remove_notify_icon()
def make_menu(self):
"""create chat with and new message (sub) menus/menuitems"""
chat_with_menuitem = self.xml.get_widget('chat_with_menuitem')
new_message_menuitem = self.xml.get_widget('new_message_menuitem')
iskey = len(gajim.connections.keys()) > 0
chat_with_menuitem.set_sensitive(iskey)
new_message_menuitem.set_sensitive(iskey)
if len(gajim.connections.keys()) >= 2: # 2 or more accounts? make submenus
account_menu_for_chat_with = gtk.Menu()
chat_with_menuitem.set_submenu(account_menu_for_chat_with)
account_menu_for_new_message = gtk.Menu()
new_message_menuitem.set_submenu(account_menu_for_new_message)
for account in gajim.connections:
our_jid = gajim.config.get_per('accounts', account, 'name') + '@' +\
gajim.config.get_per('accounts', account, 'hostname')
#for chat_with
item = gtk.MenuItem(_('as ') + our_jid)
account_menu_for_chat_with.append(item)
group_menu = self.make_groups_submenus_for_chat_with(account)
item.set_submenu(group_menu)
#for new_message
item = gtk.MenuItem(_('as ') + our_jid)
item.connect('activate',\
self.on_new_message_menuitem_activate, account)
account_menu_for_new_message.append(item)
def on_clicked(self, hwnd, message, wparam, lparam):
if lparam == WM_RBUTTONUP: # Right click
self.make_menu()
self.win32ext.notify_icon.menu.popup(None, None, None, 0, 0)
elif lparam == WM_LBUTTONUP: # Left click
if len(self.jids) == 0:
win = self.plugin.roster.window
if win.is_active():
win.hide()
else:
win.present()
else:
account = self.jids[0][0]
jid = self.jids[0][1]
acc = self.plugin.windows[account]
if acc['gc'].has_key(jid):
acc['gc'][jid].set_active_tab(jid)
acc['gc'][jid].window.present()
elif acc['chats'].has_key(jid):
acc['chats'][jid].set_active_tab(jid)
acc['chats'][jid].window.present()
else:
self.plugin.roster.new_chat(
self.plugin.roster.contacts[account][jid][0], account)
acc['chats'][jid].set_active_tab(jid)
acc['chats'][jid].window.present()
#self.win32ext.notify_icon.menu.popdown()
#self.win32ext.notify_icon.menu.popup(None, None, None, 0, 0)
def add_jid(self, jid, account):
print 'FIXME: add_jid'
return
list = [account, jid]
if not list in self.jids:
self.jids.append(list)
self.set_img()
#we look for the number of unread messages
#in roster
nb = self.plugin.roster.nb_unread
for acct in gajim.connections:
#in chat / groupchat windows
for kind in ['chats', 'gc']:
jids = self.plugin.windows[acct][kind]
for jid in jids:
if jid != 'tabbed':
nb += jids[jid].nb_unread[jid]
if nb > 1:
label = _('Gajim - %s unread messages') % nb
else:
label = _('Gajim - 1 unread message')
self.tip.set_tip(self.t, label)
def set_img(self):
print 'FIXME: set_img in win32'
def remove_jid(self, jid, account):
print 'FIXME: remove_jid'
return
list = [account, jid]
if list in self.jids:
self.jids.remove(list)
self.set_img()
#we look for the number of unread messages
#in roster
nb = self.plugin.roster.nb_unread
for acct in gajim.connections:
#in chat / groupchat windows
for kind in ['chats', 'gc']:
for jid in self.plugin.windows[acct][kind]:
if jid != 'tabbed':
nb += self.plugin.windows[acct][kind][jid].nb_unread[jid]
if nb > 1:
label = _('Gajim - %s unread messages') % nb
elif nb == 1:
label = _('Gajim - 1 unread message')
else:
label = 'Gajim'
self.tip.set_tip(self.t, label)