extension.js

/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */

/*
 * Pidgin GnomeShell Integration.
 *
 * Credits to the author of Gajim extension as this extension code was modified
 * from it.
 *
 */

/** Taken from php.js **/
function get_html_translation_table (table, quote_style) {
    var entities = {},
        hash_map = {},
        decimal = 0,
        symbol = '';
    var constMappingTable = {},
        constMappingQuoteStyle = {};
    var useTable = {},
        useQuoteStyle = {};

    // Translate arguments
    constMappingTable[0] = 'HTML_SPECIALCHARS';
    constMappingTable[1] = 'HTML_ENTITIES';
    constMappingQuoteStyle[0] = 'ENT_NOQUOTES';
    constMappingQuoteStyle[2] = 'ENT_COMPAT';
    constMappingQuoteStyle[3] = 'ENT_QUOTES';

    useTable = !isNaN(table) ? constMappingTable[table] : table ? table.toUpperCase() : 'HTML_SPECIALCHARS';
    useQuoteStyle = !isNaN(quote_style) ? constMappingQuoteStyle[quote_style] : quote_style ? quote_style.toUpperCase() : 'ENT_COMPAT';

    if (useTable !== 'HTML_SPECIALCHARS' && useTable !== 'HTML_ENTITIES') {
        throw new Error("Table: " + useTable + ' not supported');
        // return false;
    }

    entities['38'] = '&';
    if (useTable === 'HTML_ENTITIES') {
        entities['160'] = ' ';
        entities['161'] = '¡';
        entities['162'] = '¢';
        entities['163'] = '£';
        entities['164'] = '¤';
        entities['165'] = '¥';
        entities['166'] = '¦';
        entities['167'] = '§';
        entities['168'] = '¨';
        entities['169'] = '©';
        entities['170'] = 'ª';
        entities['171'] = '«';
        entities['172'] = '¬';
        entities['173'] = '­';
        entities['174'] = '®';
        entities['175'] = '¯';
        entities['176'] = '°';
        entities['177'] = '±';
        entities['178'] = '²';
        entities['179'] = '³';
        entities['180'] = '´';
        entities['181'] = 'µ';
        entities['182'] = '¶';
        entities['183'] = '·';
        entities['184'] = '¸';
        entities['185'] = '¹';
        entities['186'] = 'º';
        entities['187'] = '»';
        entities['188'] = '¼';
        entities['189'] = '½';
        entities['190'] = '¾';
        entities['191'] = '¿';
        entities['192'] = 'À';
        entities['193'] = 'Á';
        entities['194'] = 'Â';
        entities['195'] = 'Ã';
        entities['196'] = 'Ä';
        entities['197'] = 'Å';
        entities['198'] = 'Æ';
        entities['199'] = 'Ç';
        entities['200'] = 'È';
        entities['201'] = 'É';
        entities['202'] = 'Ê';
        entities['203'] = 'Ë';
        entities['204'] = 'Ì';
        entities['205'] = 'Í';
        entities['206'] = 'Î';
        entities['207'] = 'Ï';
        entities['208'] = 'Ð';
        entities['209'] = 'Ñ';
        entities['210'] = 'Ò';
        entities['211'] = 'Ó';
        entities['212'] = 'Ô';
        entities['213'] = 'Õ';
        entities['214'] = 'Ö';
        entities['215'] = '×';
        entities['216'] = 'Ø';
        entities['217'] = 'Ù';
        entities['218'] = 'Ú';
        entities['219'] = 'Û';
        entities['220'] = 'Ü';
        entities['221'] = 'Ý';
        entities['222'] = 'Þ';
        entities['223'] = 'ß';
        entities['224'] = 'à';
        entities['225'] = 'á';
        entities['226'] = 'â';
        entities['227'] = 'ã';
        entities['228'] = 'ä';
        entities['229'] = 'å';
        entities['230'] = 'æ';
        entities['231'] = 'ç';
        entities['232'] = 'è';
        entities['233'] = 'é';
        entities['234'] = 'ê';
        entities['235'] = 'ë';
        entities['236'] = 'ì';
        entities['237'] = 'í';
        entities['238'] = 'î';
        entities['239'] = 'ï';
        entities['240'] = 'ð';
        entities['241'] = 'ñ';
        entities['242'] = 'ò';
        entities['243'] = 'ó';
        entities['244'] = 'ô';
        entities['245'] = 'õ';
        entities['246'] = 'ö';
        entities['247'] = '÷';
        entities['248'] = 'ø';
        entities['249'] = 'ù';
        entities['250'] = 'ú';
        entities['251'] = 'û';
        entities['252'] = 'ü';
        entities['253'] = 'ý';
        entities['254'] = 'þ';
        entities['255'] = 'ÿ';
    }

    if (useQuoteStyle !== 'ENT_NOQUOTES') {
        entities['34'] = '"';
    }
    if (useQuoteStyle === 'ENT_QUOTES') {
        entities['39'] = ''';
    }
    entities['60'] = '<';
    entities['62'] = '>';


    // ascii decimals to real symbols
    for (decimal in entities) {
        symbol = String.fromCharCode(decimal);
        hash_map[symbol] = entities[decimal];
    }

    return hash_map;
}

/** Taken from php.js **/
function html_entity_decode (string, quote_style) {

    var hash_map = {},
        symbol = '',
        tmp_str = '',
        entity = '';
    tmp_str = string.toString();

    if (false === (hash_map = this.get_html_translation_table('HTML_ENTITIES', quote_style))) {
        return false;
    }

    delete(hash_map['&']);
    hash_map['&'] = '&';

    for (symbol in hash_map) {
        entity = hash_map[symbol];
        tmp_str = tmp_str.split(entity).join(symbol);
    }
    tmp_str = tmp_str.split(''').join("'");

    return tmp_str;
}

const DBus = imports.dbus;
const GLib = imports.gi.GLib;
const Lang = imports.lang;
const St = imports.gi.St;
const Main = imports.ui.main;
const MessageTray = imports.ui.messageTray;
const Shell = imports.gi.Shell;
const TelepathyClient = imports.ui.telepathyClient;
const Tp = imports.gi.TelepathyGLib;

const Gettext = imports.gettext.domain('gnome-shell-extensions');
const _ = Gettext.gettext;

function wrappedText(text, sender, timestamp, direction) {
    let currentTime = (Date.now() / 1000);
	let type = Tp.ChannelTextMessageType.NORMAL;

    if (timestamp == null) {
        timestamp = currentTime;
    }
	
	text = _fixText(text);
	if (text.substr(0, 3) == '/me' && direction != TelepathyClient.NotificationDirection.SENT) {
		text = text.substr(4);
		type = Tp.ChannelTextMessageType.ACTION;
	}

    return {
        text: text,
		messageType: type,
        sender: sender,
        timestamp: timestamp,
        direction: direction
    };
}

function _fixText(text) {
    // remove all tags
    let _text = text.replace(/<\/?[^>]+(>|$)/g, "");
    _text = _text.replace(/&lt;/g, "<");
    _text = _text.replace(/&gt;/g, ">");
    _text = _text.replace(/&apos;/g, "'");
    _text = _text.replace(/&quot;/g, "\"")
    _text = _text.replace(/&amp;/g, "&");

    return _text;
}

function Source(client, account, author, initialMessage, conversation, flag) {
    this._init(client, account, author, initialMessage, conversation, flag);
}

Source.prototype = {
    __proto__: MessageTray.Source.prototype,

    _init: function(client, account, author, initialMessage, conversation, flag) {

        let proxy = client.proxy();
        this._client = client;
        this._author = author;
        this._authors = {};
        this._authors[author] = true;
        this._account = account;
        this._conversation = conversation;
        this._initialMessage = initialMessage;
        this._initialFlag = flag;
        this._iconUri = null;
        this._presence = 'online';
        this.isChat = true;
        this._notification = new TelepathyClient.ChatNotification(this);
        this._notification.setUrgency(MessageTray.Urgency.HIGH);
        this._chatState = Tp.ChannelChatState.ACTIVE;
        this._pendingMessages = [];
        proxy.PurpleConversationGetTitleRemote(this._conversation, Lang.bind(this, this._async_set_title));
    },

    _async_set_author_buddy: function (author_buddy) {
        let proxy = this._client.proxy();
        this._author_buddy = author_buddy;
        proxy.PurpleConvImRemote(this._conversation, Lang.bind(this, this._async_set_conversation_im));
    },

    _async_set_conversation_im: function (conversation_im) {
        let proxy = this._client.proxy();
        this._conversation_im = conversation_im;
        proxy.PurpleBuddyGetIconRemote(this._author_buddy, Lang.bind(this, this._async_get_icon));
    },

    _async_set_title: function (title) {
        let proxy = this._client.proxy();
        this.title = _fixText(title);
        proxy.PurpleFindBuddyRemote(this._account, this._author, Lang.bind(this, this._async_set_author_buddy))
    },

    _async_get_icon: function (iconobj) {
        let proxy = this._client.proxy();
        if (iconobj) {
            proxy.PurpleBuddyIconGetFullPathRemote(iconobj, Lang.bind(this, this._async_set_icon));
        } else {
            this._start();
        }
    },

    _async_set_icon: function (iconpath) {
        this._iconUri = 'file://' + iconpath;
        this._start();
    },

    _start: function () {

        let proxy = this._client.proxy();
        MessageTray.Source.prototype._init.call(this, this.title);

        this._setSummaryIcon(this.createNotificationIcon());

        Main.messageTray.add(this);
        this.pushNotification(this._notification);

        let direction = null;
        if (this._initialFlag == 1) {
            direction = TelepathyClient.NotificationDirection.SENT;
        } else if (this._initialFlag == 2) {
            direction = TelepathyClient.NotificationDirection.RECEIVED;
        }

        this._notification.connect('clicked', Lang.bind(this, this._flushAttention));
        this.connect('summary-item-clicked', Lang.bind(this, this._flushAttention));
        
        let message = wrappedText(this._initialMessage, this._author, null, direction);
        this._notification.appendMessage(message, false);

        if (direction == TelepathyClient.NotificationDirection.RECEIVED) {
            this._addPendingMessage(message);
        }

        this._buddyStatusChangeId = proxy.connect('BuddyStatusChanged', Lang.bind(this, this._onBuddyStatusChange));
        this._buddySignedOffId = proxy.connect('BuddySignedOff', Lang.bind(this, this._onBuddySignedOff));
        this._buddySignedOnId = proxy.connect('BuddySignedOn', Lang.bind(this, this._onBuddySignedOn));
        this._messageDisplayedId = proxy.connect('DisplayedImMsg', Lang.bind(this, this._onDisplayedImMessage));
        this._deleteConversationId = proxy.connect('DeletingConversation', Lang.bind(this, this._onDeleteConversation));
        this._conversationUpdatedId = proxy.connect('ConversationUpdated', Lang.bind(this, this._onConversationUpdated));

        this.notify();
    },

    destroy: function () {
        let proxy = this._client.proxy();
        proxy.disconnect(this._buddyStatusChangeId);
        proxy.disconnect(this._buddySignedOffId);
        proxy.disconnect(this._buddySignedOnId);
        proxy.disconnect(this._deleteConversationId);
        proxy.disconnect(this._messageDisplayedId);
        proxy.disconnect(this._conversationUpdatedId);
        MessageTray.Source.prototype.destroy.call(this);
    },

    setChatState: function (state) {
        if (state != this._chatState) {
            this._chatState = state;
            let proxy = this._client.proxy();
            let pidginstate = 0;
            if (state == Tp.ChannelChatState.PAUSED) {
                pidginstate = 1;
            } else if (state == Tp.ChannelChatState.COMPOSING) {
                pidginstate = 2;
            }
            // no idea why i didnt see typing state, but lets leave this here for now
            proxy.PurpleConvImSetTypingStateRemote(this._conversation_im, pidginstate);
        }
    },

    _flushAttention: function () {
        let proxy = this._client.proxy();
        proxy.PurpleConversationUpdateRemote(this._conversation, 4);
        this._flushPendingMessages();
    },

    _onConversationUpdated: function (emitter, conversation, flags) {
        if (conversation != this._conversation) return;

        const PURPLE_CONV_UPDATE_UNSEEN = 4;
        if(flags & PURPLE_CONV_UPDATE_UNSEEN) {
            this._flushPendingMessages();
        }
    },

    createNotificationIcon: function() {
        let iconBox = new St.Bin({ style_class: 'avatar-box' });
        iconBox._size = this.ICON_SIZE;

        if (!this._iconUri) {
            iconBox.child = new St.Icon({ icon_name: 'avatar-default',
                                          icon_type: St.IconType.FULLCOLOR,
                                          icon_size: iconBox._size });
        } else {
            let textureCache = St.TextureCache.get_default();
            iconBox.child = textureCache.load_uri_async(this._iconUri, iconBox._size, iconBox._size);
        }
        return iconBox;
    },

    open: function(notification) {
        let proxy = this._client.proxy();
        proxy.PurpleConversationPresentRemote(this._conversation);
    },

    notify: function () {
        let proxy = this._client.proxy();
        proxy.PurpleConversationHasFocusRemote(this._conversation, Lang.bind(this, this._async_notify));
    },

    _async_notify: function (stats) {
        if (!stats) {
            this._notification.scrollTo(St.Side.BOTTOM);
            MessageTray.Source.prototype.notify.call(this, this._notification);
        }
    },

    respond: function(text) {
        let proxy = this._client.proxy();
        let _text = GLib.markup_escape_text(text, -1);
        proxy.PurpleConvImSendRemote(this._conversation_im, _text);
        this._flushAttention();
    },

    _onBuddyStatusChange: function (emitter, buddy, old_status_id, new_status_id) {
        if (!this.title) return;

        let self = this;

        let proxy = this._client.proxy();

        if (buddy != this._author_buddy) return;

        let presenceInfo = {};

        let notify_presence = function () {

            let presence = presenceInfo.presence;
            let message = presenceInfo.message;
            if (self._presence == presence) return;
    
            let title = self.title;
            let presenceMessage, shouldNotify;
            if (presence == "away") {
                presenceMessage = _("%s is away.").format(title);
            } else if (presence == "available") {
                presenceMessage = _("%s is available.").format(title);
            } else if (presence == "dnd") {
                presenceMessage = _("%s is busy.").format(title);
            } else {
                return;
            }
    
            self._presence = presence;
    
            if (message)
                presenceMessage += ' <i>(' + _fixText(message) + ')</i>';
    
            self._notification.appendPresence(presenceMessage, false);
        };
 
        let set_presence_message = function (message) {
            presenceInfo.message = message;
            notify_presence();
        };
        let set_presence = function (presence) {
            presenceInfo.presence = presence;
            proxy.PurpleStatusGetAttrStringRemote(new_status_id, 'message', set_presence_message);
        };

        proxy.PurpleStatusGetIdRemote(new_status_id, set_presence);

    },

    _onBuddySignedOff: function(emitter, buddy) {
        if (buddy != this._author_buddy) return;

        let shouldNotify = this._presence != 'offline';
        let presenceMessage = _("%s is offline.").format(this.title);
        this._notification.appendPresence(presenceMessage, shouldNotify);
        this._presence = 'offline';
        if (shouldNotify) 
            this.notify();
    },

    _onBuddySignedOn: function(emitter, buddy) {
        if (buddy != this._author_buddy) return;

        let shouldNotify = this._presence == 'offline';
        let presenceMessage = _("%s is online.").format(this.title);
        this._notification.appendPresence(presenceMessage, shouldNotify);
        this._presence = 'online';
        if (shouldNotify) 
            this.notify();
    },

    _onDeleteConversation: function(emitter, conversation) {
        if (conversation != this._conversation) return;
        this.destroy();
    },

    _onDisplayedImMessage: function(emitter, account, author, text, conversation, flag) {

        if (text && (this._conversation == conversation)) {
            let direction = null;
            if (flag == 1) {
                direction = TelepathyClient.NotificationDirection.SENT;
            } else if (flag == 2) {
                direction = TelepathyClient.NotificationDirection.RECEIVED;
            }

            let message = wrappedText(text, author, null, direction);

            if (direction != null) {
                this._notification.appendMessage(message, false);
            }

            if (direction == TelepathyClient.NotificationDirection.RECEIVED) {
                this._addPendingMessage(message);
                this.notify();
            } else if (direction == TelepathyClient.NotificationDirection.SENT) {
                this._flushPendingMessages();
                this.notify();
            }
        }

    },

    _addPendingMessage: function (message) {
        this._pendingMessages.push(message);
        this._updateCount();
    },

    _updateCount: function () {
        this._setCount(this._pendingMessages.length, this._pendingMessages.length > 0);
    },

    _flushPendingMessages: function() {
        this._pendingMessages = [];
        this._updateCount();
    }

}


function ChatroomSource(client, account, author, initialMessage, conversation, flag) {
    this._init(client, account, author, initialMessage, conversation, flag);
}

ChatroomSource.prototype = {
    __proto__: MessageTray.Source.prototype,

    _init : function (client, account, author, initialMessage, conversation, flag) {
        this._client = client;
        this._author = author;
        this._account = account;
        this._conversation = conversation;
        this._initialMessage = initialMessage;
        this._initialFlag = flag;

        let proxy = client.proxy();
        proxy.PurpleConversationGetTitleRemote(this._conversation, Lang.bind(this, this._async_set_title));
    },

    _async_set_title: function(title) {
        let proxy = this._client.proxy();
        this.title = _fixText(title);
        this._start();
    },

    _start: function () {
        let proxy = this._client.proxy();
        MessageTray.Source.prototype._init.call(this, this.title);
        this._setSummaryIcon(this.createNotificationIcon());
        Main.messageTray.add(this);
        this.notifyMessage(this._initialMessage);
    },

    notifyMessage: function (message) {
        let banner = '<' + _fixText(this._author) + '> ' + _fixText(message);
        let notification = new MessageTray.Notification(this, this.title, banner, {});
        this.pushNotification(notification);
        notification.connect('destroy', Lang.bind(this, this.destroy));
        this.notify(notification);
    },

    createNotificationIcon: function() {
        let iconBox = new St.Bin({ style_class: 'avatar-box' });
        iconBox._size = this.ICON_SIZE;

        iconBox.child = new St.Icon({ icon_name: 'pidgin',
                                    icon_type: St.IconType.FULLCOLOR,
                                    icon_size: iconBox._size });
        return iconBox;
    },

    open: function(notification) {
        let proxy = this._client.proxy();
        proxy.PurpleConversationPresentRemote(this._conversation);
    }
}


const PidginIface = {
    name: 'im.pidgin.purple.PurpleInterface',
    properties: [],
    methods: [
        {name: 'PurpleGetIms', inSignature: '', outSignature: 'ai'},
        {name: 'PurpleAccountsGetAllActive', inSignature: '', outSignature: 'ai'},
        {name: 'PurpleConversationGetType', inSignature: 'i', outSignature: 'u'},
        {name: 'PurpleFindBuddies', inSignature: 'is', outSignature: 'ai'},
        {name: 'PurpleFindBuddy', inSignature: 'is', outSignature: 'i'},
        {name: 'PurpleAccountGetAlias', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleAccountGetNameForDisplay', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleBuddyGetAlias', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleBuddyGetName', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleStatusGetId', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleStatusGetAttrString', inSignature: 'is', outSignature: 's'},
        {name: 'PurpleBuddyIconGetFullPath', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleBuddyGetIcon', inSignature: 'i', outSignature: 'i'},
        {name: 'PurpleConvImSend', inSignature: 'is', outSignature: ''},
        {name: 'PurpleConvChatSend', inSignature: 'is', outSignature: ''},
        {name: 'PurpleConvIm', inSignature: 'i', outSignature: 'i'},
        {name: 'PurpleConvImSetTypingState', inSignature:'ii', outSignature: ''},
        {name: 'PurpleConvChat', inSignature: 'i', outSignature: 'i'},
        {name: 'PurpleConvImGetIcon', inSignature: 'i', outSignature: 'i'},
        {name: 'PurpleConversationGetName', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleConversationGetAccount', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleConversationGetMessageHistory', inSignature: 'i', outSignature: 'ai'},
        {name: 'PurpleConversationMessageGetMessage', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleConversationGetTitle', inSignature: 'i', outSignature: 's'},
        {name: 'PurpleConversationHasFocus', inSignature: 'i', outSignature: 'b'},
        {name: 'PurpleConversationUpdate', inSignature: 'ii', outSignature: ''},
        {name: 'PurpleConversationPresent', inSignature: 'i', outSignature: ''}
    ],
    signals: [
        {name: 'ReceivedImMsg', inSignature: 'issiu'},
        {name: 'ReceivedChatMsg', inSignature: 'issiu'},
        {name: 'DisplayedImMsg', inSignature: 'issiu'},
        {name: 'DisplayedChatMsg', inSignature: 'issiu'},
        {name: 'SentImMsg', inSignature: 'iss'},
        {name: 'SentChatMsg', inSignature: 'iss'},
        {name: 'BuddyStatusChanged', inSignature: 'iii'}, // ????
        {name: 'BuddySignedOff', inSignature: 'i'},
        {name: 'BuddySignedOn', inSignature: 'i'},
        {name: 'DeletingConversation', inSignature: 'i'},
        {name: 'ConversationCreated', inSignature: 'i'},
        {name: 'ConversationUpdated', inSignature: 'ii'}
    ]
};

let Pidgin = DBus.makeProxyClass(PidginIface);

function PidginClient() {
    this._init();
}

PidginClient.prototype = {
    _init: function() {
        this._sources = {};
        this._chatroomsources = {};
        this._proxy = new Pidgin(DBus.session, 'im.pidgin.purple.PurpleService', '/im/pidgin/purple/PurpleObject');
        this._displayedImMsgId = 0;
        this._displayedChatMsgId = 0;
    },

    enable: function() {
        this._displayedImMsgId = this._proxy.connect('DisplayedImMsg', Lang.bind(this, this._messageDisplayed));
        this._displayedChatMsgId = this._proxy.connect('DisplayedChatMsg', Lang.bind(this, this._chatroomMessageDisplayed));
    },
    
    disable: function() {
        if (this._displayedImMsgId > 0) {
            this._proxy.disconnect(this._displayedImMsgId);
            this._displayedImMsgId = 0;
        }
        
        if (this._displayedChatMsgId > 0) {
            this._proxy.disconnect(this._displayedChatMsgId);
            this._displayedChatMsgId = 0;
        }
        
        for (let key in this._sources) {
            if (this._sources.hasOwnProperty(key))
                this._sources[key].destroy();
        }
    },

    proxy: function () {
        return this._proxy;
    },

    _messageDisplayed: function(emitter, account, author, message, conversation, flag) {
        // only trigger on message received/message sent
        if (flag != 2 && flag != 1) return;

        if (conversation) {
            let source = this._sources[conversation];
            if (!source) {
                source = new Source(this, account, author, message, conversation, flag);
                source.connect('destroy', Lang.bind(this, 
                    function() {
                        delete this._sources[conversation];
                    }
                ));
            }
            this._sources[conversation] = source;
        }
    },

    _chatroomMessageDisplayed: function(emitter, account, author, message, conversation, flag) {
        if (flag != (2 | 32)) return;

        if (conversation) {
            let source = this._chatroomsources[conversation];
            if (!source) {
                source = new ChatroomSource(this, account, author, message, conversation, flag);
                source.connect('destroy', Lang.bind(this,
                    function() {
                        delete this._chatroomsources[conversation];
                    }
                ));
            } else {
                source.notifyMessage(message);
            }
            this._chatroomsources[conversation] = source;
        } 
    }
}

function init(metaObject) {
    var LocalDir;

    // gnome-shell 3.4
    if ("metadata" in metaObject) {
        LocalDir = metaObject.metadata.localedir;
    }
    // gnome-shell 3.2
    else if ("localedir" in metaObject) {
        LocalDir = metaObject.localedir;
    }
    // don't know what happends, hardcode it.
    else {
        LocalDir = "/usr/share/locale";
    }

    imports.gettext.bindtextdomain('gnome-shell-extensions', LocalDir);
    return new PidginClient();
}