~ubuntu-branches/ubuntu/trusty/gnome-shell/trusty-proposed

// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-

 

const Gio = imports.gi.Gio;

const GLib = imports.gi.GLib;

const Lang = imports.lang;

    RECEIVED: 'chat-received'

};

 

function makeMessageFromTpMessage(tpMessage, direction) {

    let [text, flags] = tpMessage.to_text();

 

    };

}

 

 

    _init : function() {

        // channel path -> ChatSource

        this._chatSources = {};

        // account path -> AccountNotification

        this._accountNotifications = {};

 

        // Set up a SimpleObserver, which will call _observeChannels whenever a

        // channel matching its filters is detected.

        // The second argument, recover, means _observeChannels will be run

        // for any existing channel as well.

        this._tpClient = new Shell.TpClient({ 'account-manager': this._accountManager,

                                              'name': 'GnomeShell',

                                              'uniquify-name': true })

            throw new Error('Couldn\'t register Telepathy client. Error: \n' + e);

        }

 

        // Watch subscription requests and connection errors

        this._subscriptionSource = null;

        this._accountSource = null;

 

        this._accountManager.connect('account-validity-changed',

            Lang.bind(this, this._accountValidityChanged));

 

    _observeChannels: function(observer, account, conn, channels,

                               dispatchOp, requests, context) {

        let len = channels.length;

        for (let i = 0; i < len; i++) {

            let channel = channels[i];

               targetHandleType != Tp.HandleType.CONTACT)

               continue;

 

        }

 

        context.accept();

 

    _handleChannels: function(handler, account, conn, channels,

                              requests, user_action_time, context) {

        context.accept();

    },

 

        let len = channels.length;

        for (let i = 0; i < len; i++) {

            let channel = channels[i];

                continue;

            }

 

                // We are already handling the channel, display the source

                let source = this._chatSources[channel.get_object_path()];

                if (source)

 

    _displayRoomInvitation: function(conn, channel, dispatchOp, context) {

        // We can only approve the rooms if we have been invited to it

            Shell.decline_dispatch_op(context, 'Not invited to the room');

            return;

        }

 

        if (!invited) {

            Shell.decline_dispatch_op(context, 'Not invited to the room');

            return;

        }

 

        // FIXME: We don't have a 'chat room' icon (bgo #653737) use

        // system-users for now as Empathy does.

        let source = new ApproverSource(dispatchOp, _("Invitation"),

                                        Gio.icon_new_for_string('system-users'));

        Main.messageTray.add(source);

 

        source.notify(notif);

        context.accept();

    },

 

        if (chanType == Tp.IFACE_CHANNEL_TYPE_TEXT)

            this._approveTextChannel(account, conn, channel, dispatchOp, context);

            this._approveCall(account, conn, channel, dispatchOp, context);

        else if (chanType == Tp.IFACE_CHANNEL_TYPE_FILE_TRANSFER)

            this._approveFileTransfer(account, conn, channel, dispatchOp, context);

                                        Lang.bind(this, function(dispatchOp, result) {

                try {

                    dispatchOp.claim_with_finish(result);

                } catch (err) {

                    throw new Error('Failed to Claim channel: ' + err);

                }}));

    },

 

    _approveCall: function(account, conn, channel, dispatchOp, context) {

        let isVideo = false;

 

        let props = channel.borrow_immutable_properties();

 

          isVideo = true;

 

        // We got the TpContact

                                        Gio.icon_new_for_string('audio-input-microphone'));

        Main.messageTray.add(source);

 

        source.notify(notif);

        context.accept();

    },

 

    _approveFileTransfer: function(account, conn, channel, dispatchOp, context) {

        // Use the icon of the file being transferred

        let gicon = Gio.content_type_get_icon(channel.get_mime_type());

 

        let source = new ApproverSource(dispatchOp, _("File Transfer"), gicon);

        Main.messageTray.add(source);

 

        source.notify(notif);

        context.accept();

    },

 

        return this._accountSource;

    }

 

    _init: function(account, conn, channel, contact, client) {

 

        this.isChat = true;

 

        this._notification.setUrgency(MessageTray.Urgency.HIGH);

        this._notifyTimeoutId = 0;

 

 

        this._presence = contact.get_presence_type();

 

    },

 

    notify: function() {

    },

 

    respond: function(text) {

        if (presence == Tp.ConnectionPresenceType.AVAILABLE) {

            msg = _("%s is online.").format(title);

            shouldNotify = (this._presence == Tp.ConnectionPresenceType.OFFLINE);

            presence = Tp.ConnectionPresenceType.OFFLINE;

            msg = _("%s is offline.").format(title);

            shouldNotify = (this._presence != Tp.ConnectionPresenceType.OFFLINE);

            msg = _("%s is away.").format(title);

            shouldNotify = false;

        } else if (presence == Tp.ConnectionPresenceType.BUSY) {

        // 'pending-message-removed' for each one.

        this._channel.ack_all_pending_messages_async(Lang.bind(this, function(src, result) {

            this._channel.ack_all_pending_messages_finish(result);}));

    }

 

    _init: function(source) {

        this.setResident(true);

 

        this._responseEntry = new St.Entry({ style_class: 'chat-response',

        }

 

        let groups = this._contentArea.get_children();

            let group = groups[i];

            if (group.get_children().length == 0)

                group.destroy();

        let body = highlighter.actor;

 

        let styles = props.styles;

            body.add_style_class_name(styles[i]);

 

        let group = props.group;

            this.source.setChatState(Tp.ChannelChatState.ACTIVE);

        }

    }

 

    _init: function(dispatchOp, text, gicon) {

 

        this._gicon = gicon;

        this._setSummaryIcon(this.createNotificationIcon());

            this._invalidId = 0;

        }

 

    },

 

    createNotificationIcon: function() {

                             icon_type: St.IconType.FULLCOLOR,

                             icon_size: this.ICON_SIZE });

    }

 

    _init: function(source, dispatchOp, channel, inviter) {

        this.setResident(true);

 

        /* translators: first argument is the name of a contact and the second

            this.destroy();

        }));

    }

 

// Audio Video

 

    _init: function(source, dispatchOp, channel, contact, isVideo) {

        let title = '';

             /* translators: argument is a contact name like Alice for example. */

            title = _("Call from %s").format(contact.get_alias());

 

        this.setResident(true);

 

        this.addButton('reject', _("Reject"));

            this.destroy();

        }));

    }

 

// File Transfer

 

    _init: function(source, dispatchOp, channel, contact) {

        this.setResident(true);

 

        this.addButton('decline', _("Decline"));

            this.destroy();

        }));

    }

 

// A notification source that can embed multiple notifications

 

    _init: function(title, icon) {

 

        this._icon = icon;

        this._setSummaryIcon(this.createNotificationIcon());

    },

 

    notify: function(notification) {

 

        this._nbNotifications += 1;

 

    },

 

    createNotificationIcon: function() {

                             icon_type: St.IconType.FULLCOLOR,

                             icon_size: this.ICON_SIZE });

    }

 

// Subscription request

 

    _init: function(source, contact) {

 

        this._contact = contact;

        this._connection = contact.get_connection();

            this._invalidatedId = 0;

        }

 

    },

 

    _subscriptionStatesChangedCb: function(contact, subscribe, publish, msg) {

        if (publish != Tp.SubscriptionState.ASK)

            this.destroy();

    }

 

// Messages from empathy/libempathy/empathy-utils.c

// create_errors_to_message_hash()

_connectionErrorMessages[Tp.error_get_dbus_name(Tp.Error.CONNECTION_LOST)]

  = _("Connection has been lost");

_connectionErrorMessages[Tp.error_get_dbus_name(Tp.Error.ALREADY_CONNECTED)]

_connectionErrorMessages[Tp.error_get_dbus_name(Tp.Error.CONNECTION_REPLACED)]

  = _("Connection has been replaced by a new connection using the same resource");

_connectionErrorMessages[Tp.error_get_dbus_name(Tp.Error.REGISTRATION_EXISTS)]

  = _("Certificate uses an insecure cipher algorithm or is cryptographically weak");

_connectionErrorMessages[Tp.error_get_dbus_name(Tp.Error.CERT_LIMIT_EXCEEDED)]

  = _("The length of the server certificate, or the depth of the server certificate chain, exceed the limits imposed by the cryptography library");

 

 

    _init: function(source, account, connectionError) {

 

        this._label = new St.Label();

        this.addActor(this._label);

            this._connectionStatusId = 0;

        }

 

    }