code:
var Bookmark = {

    // Special XHR that sends in some code to be run
    // when the full bookmark form gets loaded
    BookmarkXHR: function(form)
    {
        SN.U.FormXHR(form, Bookmark.InitBookmarkForm);
        return false;
    },

    // Special initialization function just for the
    // second step in the bookmarking workflow
    InitBookmarkForm: function() {
        SN.Init.CheckBoxes();
        $('fieldset fieldset label').inFieldLabels({ fadeOpacity:0 });
        SN.Init.NoticeFormSetup($('#form_new_bookmark'));
    }
}

$(document).ready(function() {

    // Stop normal live event stuff
    $(document).off("submit", "form.ajax");
    $(document).off("click", "form.ajax input[type=submit]");

    // Make the bookmark submit super special
    $(document).on('submit', '#form_initial_bookmark', function (e) {
        Bookmark.BookmarkXHR($(this));
        e.stopPropagation();
        return false;
    });

    // Restore live event stuff to other forms & submit buttons
    SN.Init.AjaxForms();

});


code:
//wrap everything in a self-executing anonymous function to avoid conflicts
(function(){

    // smart(x) from Paul Irish
    // http://paulirish.com/2009/throttled-smartresize-jquery-event-handler/

    (function($,sr){

        // debouncing function from John Hann
        // http://unscriptable.com/index.php/2009/03/20/debouncing-javascript-methods/
        var debounce = function (func, threshold, execAsap) {
            var timeout;

            return function debounced () {
                var obj = this, args = arguments;
                function delayed () {
                    if (!execAsap)
                        func.apply(obj, args);
                        timeout = null;
                };

                if (timeout)
                    clearTimeout(timeout);
                else if (execAsap)
                    func.apply(obj, args);

                timeout = setTimeout(delayed, threshold || 100);
            };
        }
        jQuery.fn[sr] = function(fn){  return fn ? this.bind('keypress', debounce(fn, 1000)) : this.trigger(sr); };

    })(jQuery,'smartkeypress');

    function longestWordInString(string)
    {
        var words = string.split(/\s/);
        var longestWord = 0;
        for(var i=0;i<words.length;i++)
            if(words[i].length > longestWord) longestWord = words[i].length;
        return longestWord;
    }

    function shorten()
    {
        var $noticeDataText = $('#'+SN.C.S.NoticeDataText);
        var noticeText = $noticeDataText.val();

        if(noticeText.length > maxNoticeLength || longestWordInString(noticeText) > maxUrlLength) {
            var original = $noticeDataText.val();
            shortenAjax = $.ajax({
                url: $('address .url')[0].href+'/plugins/ClientSideShorten/shorten',
                data: { text: $noticeDataText.val() },
                dataType: 'text',
                success: function(data) {
                    if(original == $noticeDataText.val()) {
                        $noticeDataText.val(data).keyup();
                    }
                }
            });
        }
    }

    $(document).ready(function(){
        $noticeDataText = $('#'+SN.C.S.NoticeDataText);
        $noticeDataText.smartkeypress(function(e){
            //if(typeof(shortenAjax) !== 'undefined') shortenAjax.abort();
            if(e.charCode == '32') {
                shorten();
            }
        });
        $noticeDataText.bind('paste', function() {
            //if(typeof(shortenAjax) !== 'undefined') shortenAjax.abort();
            setTimeout(shorten,1);
        });
    });

})();

repo_name: andremichelle/gnu

license: mit


code:
// update the local timeline from a Comet server
var CometUpdate = function()
{
     var _server;
     var _timeline;
     var _userid;
     var _replyurl;
     var _favorurl;
     var _deleteurl;
     var _cometd;

     return {
          init: function(server, timeline, userid, replyurl, favorurl, deleteurl)
          {
               _cometd = $.cometd; // Uses the default Comet object
               _cometd.init(server);
               _server = server;
               _timeline = timeline;
               _userid = userid;
               _favorurl = favorurl;
               _replyurl = replyurl;
               _deleteurl = deleteurl;
               _cometd.subscribe(timeline, function(message) { RealtimeUpdate.receive(message.data) });
               $(window).unload(function() { _cometd.disconnect(); } );
          }
     }
}();


code:
/**
 * Copyright 2008 Mort Bay Consulting Pty. Ltd.
 * Dual licensed under the Apache License 2.0 and the MIT license.
 * ----------------------------------------------------------------------------
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http: *www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ----------------------------------------------------------------------------
 * Licensed under the MIT license;
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * ----------------------------------------------------------------------------
 * $Revision$ $Date$
 */
(function($)
{
    /**
     * The constructor for a Comet object.
     * There is a default Comet instance already created at the variable $.cometd,
     * and hence that can be used to start a comet conversation with a server.
     * In the rare case a page needs more than one comet conversation, a new instance can be
     * created via:
     *

     * var url2 = ...;
     * var cometd2 = new $.Cometd();
     * cometd2.init(url2);
     *

     */
    $.Cometd = function(name)
    {
        var _name = name || 'default';
        var _logPriorities = { debug: 1, info: 2, warn: 3, error: 4 };
        var _logLevel = 'info';
        var _url;
        var _xd = false;
        var _transport;
        var _status = 'disconnected';
        var _messageId = 0;
        var _clientId = null;
        var _batch = 0;
        var _messageQueue = [];
        var _listeners = {};
        var _backoff = 0;
        var _backoffIncrement = 1000;
        var _maxBackoff = 60000;
        var _scheduledSend = null;
        var _extensions = [];
        var _advice = {};
        var _handshakeProps;

        /**
         * Returns the name assigned to this Comet object, or the string 'default'
         * if no name has been explicitely passed as parameter to the constructor.
         */
        this.getName = function()
        {
            return _name;
        };

        /**
         * Configures the initial comet communication with the comet server.
         * @param cometURL the URL of the comet server
         */
        this.configure = function(cometURL)
        {
            _configure(cometURL);
        };

        function _configure(cometURL)
        {
            _url = cometURL;
            _debug('Initializing comet with url: {}', _url);

            // Check immediately if we're cross domain
            // If cross domain, the handshake must not send the long polling transport type
            var urlParts = /(^https?:)?(\/\/(([^:\/\?#]+)(:(\d+))?))?([^\?#]*)/.exec(cometURL);
            if (urlParts[3]) _xd = urlParts[3] != location.host;

            // Temporary setup a transport to send the initial handshake
            // The transport may be changed as a result of handshake
            if (_xd)
                _transport = newCallbackPollingTransport();
            else
                _transport = newLongPollingTransport();
            _debug('Initial transport is {}', _transport.getType());
        };

        /**
         * Configures and establishes the comet communication with the comet server
         * via a handshake and a subsequent connect.
         * @param cometURL the URL of the comet server
         * @param handshakeProps an object to be merged with the handshake message
         * @see #configure(cometURL)
         * @see #handshake(handshakeProps)
         */
        this.init = function(cometURL, handshakeProps)
        {
            _configure(cometURL);
            _handshake(handshakeProps);
        };

        /**
         * Establishes the comet communication with the comet server
         * via a handshake and a subsequent connect.
         * @param handshakeProps an object to be merged with the handshake message
         */
        this.handshake = function(handshakeProps)
        {
            _handshake(handshakeProps);
        };

        /**
         * Disconnects from the comet server.
         * @param disconnectProps an object to be merged with the disconnect message
         */
        this.disconnect = function(disconnectProps)
        {
            var bayeuxMessage = {
                channel: '/meta/disconnect'
            };
            var message = $.extend({}, disconnectProps, bayeuxMessage);
            // Deliver immediately
            // The handshake and connect mechanism make use of startBatch(), and in case
            // of a failed handshake the disconnect would not be delivered if using _send().
            _setStatus('disconnecting');
            _deliver([message], false);
        };

        /**
         * Marks the start of a batch of application messages to be sent to the server
         * in a single request, obtaining a single response containing (possibly) many
         * application reply messages.
         * Messages are held in a queue and not sent until {@link #endBatch()} is called.
         * If startBatch() is called multiple times, then an equal number of endBatch()
         * calls must be made to close and send the batch of messages.
         * @see #endBatch()
         */
        this.startBatch = function()
        {
            _startBatch();
        };

        /**
         * Marks the end of a batch of application messages to be sent to the server
         * in a single request.
         * @see #startBatch()
         */
        this.endBatch = function()
        {
            _endBatch(true);
        };

        /**
         * Subscribes to the given channel, performing the given callback in the given scope
         * when a message for the channel arrives.
         * @param channel the channel to subscribe to
         * @param scope the scope of the callback
         * @param callback the callback to call when a message is delivered to the channel
         * @param subscribeProps an object to be merged with the subscribe message
         * @return the subscription handle to be passed to {@link #unsubscribe(object)}
         */
        this.subscribe = function(channel, scope, callback, subscribeProps)
        {
            var subscription = this.addListener(channel, scope, callback);

            // Send the subscription message after the subscription registration to avoid
            // races where the server would deliver a message to the subscribers, but here
            // on the client the subscription has not been added yet to the data structures
            var bayeuxMessage = {
                channel: '/meta/subscribe',
                subscription: channel
            };
            var message = $.extend({}, subscribeProps, bayeuxMessage);
            _send(message);

            return subscription;
        };

        /**
         * Unsubscribes the subscription obtained with a call to {@link #subscribe(string, object, function)}.
         * @param subscription the subscription to unsubscribe.
         */
        this.unsubscribe = function(subscription, unsubscribeProps)
        {
            // Remove the local listener before sending the message
            // This ensures that if the server fails, this client does not get notifications
            this.removeListener(subscription);
            var bayeuxMessage = {
                channel: '/meta/unsubscribe',
                subscription: subscription[0]
            };
            var message = $.extend({}, unsubscribeProps, bayeuxMessage);
            _send(message);
        };

        /**
         * Publishes a message on the given channel, containing the given content.
         * @param channel the channel to publish the message to
         * @param content the content of the message
         * @param publishProps an object to be merged with the publish message
         */
        this.publish = function(channel, content, publishProps)
        {
            var bayeuxMessage = {
                channel: channel,
                data: content
            };
            var message = $.extend({}, publishProps, bayeuxMessage);
            _send(message);
        };

        /**
         * Adds a listener for bayeux messages, performing the given callback in the given scope
         * when a message for the given channel arrives.
         * @param channel the channel the listener is interested to
         * @param scope the scope of the callback
         * @param callback the callback to call when a message is delivered to the channel
         * @returns the subscription handle to be passed to {@link #removeListener(object)}
         * @see #removeListener(object)
         */
        this.addListener = function(channel, scope, callback)
        {
            // The data structure is a map<channel, subscription[]>, where each subscription
            // holds the callback to be called and its scope.

            // Normalize arguments
            if (!callback)
            {
                callback = scope;
                scope = undefined;
            }

            var subscription = {
                scope: scope,
                callback: callback
            };

            var subscriptions = _listeners[channel];
            if (!subscriptions)
            {
                subscriptions = [];
                _listeners[channel] = subscriptions;
            }
            // Pushing onto an array appends at the end and returns the id associated with the element increased by 1.
            // Note that if:
            // a.push('a'); var hb=a.push('b'); delete a[hb-1]; var hc=a.push('c');
            // then:
            // hc==3, a.join()=='a',,'c', a.length==3
            var subscriptionIndex = subscriptions.push(subscription) - 1;
            _debug('Added listener: channel \'{}\', callback \'{}\', index {}', channel, callback.name, subscriptionIndex);

            // The subscription to allow removal of the listener is made of the channel and the index
            return [channel, subscriptionIndex];
        };

        /**
         * Removes the subscription obtained with a call to {@link #addListener(string, object, function)}.
         * @param subscription the subscription to unsubscribe.
         */
        this.removeListener = function(subscription)
        {
            var subscriptions = _listeners[subscription[0]];
            if (subscriptions)
            {
                delete subscriptions[subscription[1]];
                _debug('Removed listener: channel \'{}\', index {}', subscription[0], subscription[1]);
            }
        };

        /**
         * Removes all listeners registered with {@link #addListener(channel, scope, callback)} or
         * {@link #subscribe(channel, scope, callback)}.
         */
        this.clearListeners = function()
        {
            _listeners = {};
        };

        /**
         * Returns a string representing the status of the bayeux communication with the comet server.
         */
        this.getStatus = function()
        {
            return _status;
        };

        /**
         * Sets the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.
         * Default value is 1 second, which means if there is a persistent failure the retries will happen
         * after 1 second, then after 2 seconds, then after 3 seconds, etc. So for example with 15 seconds of
         * elapsed time, there will be 5 retries (at 1, 3, 6, 10 and 15 seconds elapsed).
         * @param period the backoff period to set
         * @see #getBackoffIncrement()
         */
        this.setBackoffIncrement = function(period)
        {
            _backoffIncrement = period;
        };

        /**
         * Returns the backoff period used to increase the backoff time when retrying an unsuccessful or failed message.
         * @see #setBackoffIncrement(period)
         */
        this.getBackoffIncrement = function()
        {
            return _backoffIncrement;
        };

        /**
         * Returns the backoff period to wait before retrying an unsuccessful or failed message.
         */
        this.getBackoffPeriod = function()
        {
            return _backoff;
        };

        /**
         * Sets the log level for console logging.
         * Valid values are the strings 'error', 'warn', 'info' and 'debug', from
         * less verbose to more verbose.
         * @param level the log level string
         */
        this.setLogLevel = function(level)
        {
            _logLevel = level;
        };

        /**
         * Registers an extension whose callbacks are called for every incoming message
         * (that comes from the server to this client implementation) and for every
         * outgoing message (that originates from this client implementation for the
         * server).
         * The format of the extension object is the following:
         *

         * {
         *     incoming: function(message) { ... },
         *     outgoing: function(message) { ... }
         * }
         * Both properties are optional, but if they are present they will be called
         * respectively for each incoming message and for each outgoing message.
         *

         * @param name the name of the extension
         * @param extension the extension to register
         * @return true if the extension was registered, false otherwise
         * @see #unregisterExtension(name)
         */
        this.registerExtension = function(name, extension)
        {
            var existing = false;
            for (var i = 0; i < _extensions.length; ++i)
            {
                var existingExtension = _extensions[i];
                if (existingExtension.name == name)
                {
                    existing = true;
                    return false;
                }
            }
            if (!existing)
            {
                _extensions.push({
                    name: name,
                    extension: extension
                });
                _debug('Registered extension \'{}\'', name);
                return true;
            }
            else
            {
                _info('Could not register extension with name \'{}\': another extension with the same name already exists');
                return false;
            }
        };

        /**
         * Unregister an extension previously registered with
         * {@link #registerExtension(name, extension)}.
         * @param name the name of the extension to unregister.
         * @return true if the extension was unregistered, false otherwise
         */
        this.unregisterExtension = function(name)
        {
            var unregistered = false;
            $.each(_extensions, function(index, extension)
            {
                if (extension.name == name)
                {
                    _extensions.splice(index, 1);
                    unregistered = true;
                    _debug('Unregistered extension \'{}\'', name);
                    return false;
                }
            });
            return unregistered;
        };

        /**
         * Starts a the batch of messages to be sent in a single request.
         * @see _endBatch(deliverMessages)
         */
        function _startBatch()
        {
            ++_batch;
        };

        /**
         * Ends the batch of messages to be sent in a single request,
         * optionally delivering messages present in the message queue depending
         * on the given argument.
         * @param deliverMessages whether to deliver the messages in the queue or not
         * @see _startBatch()
         */
        function _endBatch(deliverMessages)
        {
            --_batch;
            if (_batch < 0) _batch = 0;
            if (deliverMessages && _batch == 0 && !_isDisconnected())
            {
                var messages = _messageQueue;
                _messageQueue = [];
                if (messages.length > 0) _deliver(messages, false);
            }
        };

        function _nextMessageId()
        {
            return ++_messageId;
        };

        /**
         * Converts the given response into an array of bayeux messages
         * @param response the response to convert
         * @return an array of bayeux messages obtained by converting the response
         */
        function _convertToMessages(response)
        {
            if (response === undefined) return [];
            if (response instanceof Array) return response;
            if (response instanceof String || typeof response == 'string') return eval('(' + response + ')');
            if (response instanceof Object) return [response];
            throw 'Conversion Error ' + response + ', typeof ' + (typeof response);
        };

        function _setStatus(newStatus)
        {
            _debug('{} -> {}', _status, newStatus);
            _status = newStatus;
        };

        function _isDisconnected()
        {
            return _status == 'disconnecting' || _status == 'disconnected';
        };

        /**
         * Sends the initial handshake message
         */
        function _handshake(handshakeProps)
        {
            _debug('Starting handshake');
            _clientId = null;

            // Start a batch.
            // This is needed because handshake and connect are async.
            // It may happen that the application calls init() then subscribe()
            // and the subscribe message is sent before the connect message, if
            // the subscribe message is not held until the connect message is sent.
            // So here we start a batch to hold temporarly any message until
            // the connection is fully established.
            _batch = 0;
            _startBatch();

            // Save the original properties provided by the user
            // Deep copy to avoid the user to be able to change them later
            _handshakeProps = $.extend(true, {}, handshakeProps);

            var bayeuxMessage = {
                version: '1.0',
                minimumVersion: '0.9',
                channel: '/meta/handshake',
                supportedConnectionTypes: _xd ? ['callback-polling'] : ['long-polling', 'callback-polling']
            };
            // Do not allow the user to mess with the required properties,
            // so merge first the user properties and *then* the bayeux message
            var message = $.extend({}, handshakeProps, bayeuxMessage);

            // We started a batch to hold the application messages,
            // so here we must bypass it and deliver immediately.
            _setStatus('handshaking');
            _deliver([message], false);
        };

        function _findTransport(handshakeResponse)
        {
            var transportTypes = handshakeResponse.supportedConnectionTypes;
            if (_xd)
            {
                // If we are cross domain, check if the server supports it, that's the only option
                if ($.inArray('callback-polling', transportTypes) >= 0) return _transport;
            }
            else
            {
                // Check if we can keep long-polling
                if ($.inArray('long-polling', transportTypes) >= 0) return _transport;

                // The server does not support long-polling
                if ($.inArray('callback-polling', transportTypes) >= 0) return newCallbackPollingTransport();
            }
            return null;
        };

        function _delayedHandshake()
        {
            _setStatus('handshaking');
            _delayedSend(function()
            {
                _handshake(_handshakeProps);
            });
        };

        function _delayedConnect()
        {
            _setStatus('connecting');
            _delayedSend(function()
            {
                _connect();
            });
        };

        function _delayedSend(operation)
        {
            _cancelDelayedSend();
            var delay = _backoff;
            _debug("Delayed send: backoff {}, interval {}", _backoff, _advice.interval);
            if (_advice.interval && _advice.interval > 0)
                delay += _advice.interval;
            _scheduledSend = _setTimeout(operation, delay);
        };

        function _cancelDelayedSend()
        {
            if (_scheduledSend !== null) clearTimeout(_scheduledSend);
            _scheduledSend = null;
        };

        function _setTimeout(funktion, delay)
        {
            return setTimeout(function()
            {
                try
                {
                    funktion();
                }
                catch (x)
                {
                    _debug('Exception during scheduled execution of function \'{}\': {}', funktion.name, x);
                }
            }, delay);
        };

        /**
         * Sends the connect message
         */
        function _connect()
        {
            _debug('Starting connect');
            var message = {
                channel: '/meta/connect',
                connectionType: _transport.getType()
            };
            _setStatus('connecting');
            _deliver([message], true);
            _setStatus('connected');
        };

        function _send(message)
        {
            if (_batch > 0)
                _messageQueue.push(message);
            else
                _deliver([message], false);
        };

        /**
         * Delivers the messages to the comet server
         * @param messages the array of messages to send
         */
        function _deliver(messages, comet)
        {
            // We must be sure that the messages have a clientId.
            // This is not guaranteed since the handshake may take time to return
            // (and hence the clientId is not known yet) and the application
            // may create other messages.
            $.each(messages, function(index, message)
            {
                message['id'] = _nextMessageId();
                if (_clientId) message['clientId'] = _clientId;
                messages[index] = _applyOutgoingExtensions(message);
            });

            var self = this;
            var envelope = {
                url: _url,
                messages: messages,
                onSuccess: function(request, response)
                {
                    try
                    {
                        _handleSuccess.call(self, request, response, comet);
                    }
                    catch (x)
                    {
                        _debug('Exception during execution of success callback: {}', x);
                    }
                },
                onFailure: function(request, reason, exception)
                {
                    try
                    {
                        _handleFailure.call(self, request, messages, reason, exception, comet);
                    }
                    catch (x)
                    {
                        _debug('Exception during execution of failure callback: {}', x);
                    }
                }
            };
            _debug('Sending request to {}, message(s): {}', envelope.url, JSON.stringify(envelope.messages));
            _transport.send(envelope, comet);
        };

        function _applyIncomingExtensions(message)
        {
            for (var i = 0; i < _extensions.length; ++i)
            {
                var extension = _extensions[i];
                var callback = extension.extension.incoming;
                if (callback && typeof callback === 'function')
                {
                    _debug('Calling incoming extension \'{}\', callback \'{}\'', extension.name, callback.name);
                    message = _applyExtension(extension.name, callback, message) || message;
                }
            }
            return message;
        };

        function _applyOutgoingExtensions(message)
        {
            for (var i = 0; i < _extensions.length; ++i)
            {
                var extension = _extensions[i];
                var callback = extension.extension.outgoing;
                if (callback && typeof callback === 'function')
                {
                    _debug('Calling outgoing extension \'{}\', callback \'{}\'', extension.name, callback.name);
                    message = _applyExtension(extension.name, callback, message) || message;
                }
            }
            return message;
        };

        function _applyExtension(name, callback, message)
        {
            try
            {
                return callback(message);
            }
            catch (x)
            {
                _debug('Exception during execution of extension \'{}\': {}', name, x);
                return message;
            }
        };

        function _handleSuccess(request, response, comet)
        {
            var messages = _convertToMessages(response);
            _debug('Received response {}', JSON.stringify(messages));

            // Signal the transport it can deliver other queued requests
            _transport.complete(request, true, comet);

            for (var i = 0; i < messages.length; ++i)
            {
                var message = messages[i];
                message = _applyIncomingExtensions(message);

                if (message.advice) _advice = message.advice;

                var channel = message.channel;
                switch (channel)
                {
                    case '/meta/handshake':
                        _handshakeSuccess(message);
                        break;
                    case '/meta/connect':
                        _connectSuccess(message);
                        break;
                    case '/meta/disconnect':
                        _disconnectSuccess(message);
                        break;
                    case '/meta/subscribe':
                        _subscribeSuccess(message);
                        break;
                    case '/meta/unsubscribe':
                        _unsubscribeSuccess(message);
                        break;
                    default:
                        _messageSuccess(message);
                        break;
                }
            }
        };

        function _handleFailure(request, messages, reason, exception, comet)
        {
            var xhr = request.xhr;
            _debug('Request failed, status: {}, reason: {}, exception: {}', xhr && xhr.status, reason, exception);

            // Signal the transport it can deliver other queued requests
            _transport.complete(request, false, comet);

            for (var i = 0; i < messages.length; ++i)
            {
                var message = messages[i];
                var channel = message.channel;
                switch (channel)
                {
                    case '/meta/handshake':
                        _handshakeFailure(xhr, message);
                        break;
                    case '/meta/connect':
                        _connectFailure(xhr, message);
                        break;
                    case '/meta/disconnect':
                        _disconnectFailure(xhr, message);
                        break;
                    case '/meta/subscribe':
                        _subscribeFailure(xhr, message);
                        break;
                    case '/meta/unsubscribe':
                        _unsubscribeFailure(xhr, message);
                        break;
                    default:
                        _messageFailure(xhr, message);
                        break;
                }
            }
        };

        function _handshakeSuccess(message)
        {
            if (message.successful)
            {
                _debug('Handshake successful');
                // Save clientId, figure out transport, then follow the advice to connect
                _clientId = message.clientId;

                var newTransport = _findTransport(message);
                if (newTransport === null)
                {
                    throw 'Could not agree on transport with server';
                }
                else
                {
                    if (_transport.getType() != newTransport.getType())
                    {
                        _debug('Changing transport from {} to {}', _transport.getType(), newTransport.getType());
                        _transport = newTransport;
                    }
                }

                // Notify the listeners
                // Here the new transport is in place, as well as the clientId, so
                // the listener can perform a publish() if it wants, and the listeners
                // are notified before the connect below.
                _notifyListeners('/meta/handshake', message);

                var action = _advice.reconnect ? _advice.reconnect : 'retry';
                switch (action)
                {
                    case 'retry':
                        _delayedConnect();
                        break;
                    default:
                        break;
                }
            }
            else
            {
                _debug('Handshake unsuccessful');

                var retry = !_isDisconnected() && _advice.reconnect != 'none';
                if (!retry) _setStatus('disconnected');

                _notifyListeners('/meta/handshake', message);
                _notifyListeners('/meta/unsuccessful', message);

                // Only try again if we haven't been disconnected and
                // the advice permits us to retry the handshake
                if (retry)
                {
                    _increaseBackoff();
                    _debug('Handshake failure, backing off and retrying in {} ms', _backoff);
                    _delayedHandshake();
                }
            }
        };

        function _handshakeFailure(xhr, message)
        {
            _debug('Handshake failure');

            // Notify listeners
            var failureMessage = {
                successful: false,
                failure: true,
                channel: '/meta/handshake',
                request: message,
                xhr: xhr,
                advice: {
                    action: 'retry',
                    interval: _backoff
                }
            };

            var retry = !_isDisconnected() && _advice.reconnect != 'none';
            if (!retry) _setStatus('disconnected');

            _notifyListeners('/meta/handshake', failureMessage);
            _notifyListeners('/meta/unsuccessful', failureMessage);

            // Only try again if we haven't been disconnected and the
            // advice permits us to try again
            if (retry)
            {
                _increaseBackoff();
                _debug('Handshake failure, backing off and retrying in {} ms', _backoff);
                _delayedHandshake();
            }
        };

        function _connectSuccess(message)
        {
            var action = _isDisconnected() ? 'none' : (_advice.reconnect ? _advice.reconnect : 'retry');
            if (!_isDisconnected()) _setStatus(action == 'retry' ? 'connecting' : 'disconnecting');

            if (message.successful)
            {
                _debug('Connect successful');

                // End the batch and allow held messages from the application
                // to go to the server (see _handshake() where we start the batch).
                // The batch is ended before notifying the listeners, so that
                // listeners can batch other cometd operations
                _endBatch(true);

                // Notify the listeners after the status change but before the next connect
                _notifyListeners('/meta/connect', message);

                // Connect was successful.
                // Normally, the advice will say "reconnect: 'retry', interval: 0"
                // and the server will hold the request, so when a response returns
                // we immediately call the server again (long polling)
                switch (action)
                {
                    case 'retry':
                        _resetBackoff();
                        _delayedConnect();
                        break;
                    default:
                        _resetBackoff();
                        _setStatus('disconnected');
                        break;
                }
            }
            else
            {
                _debug('Connect unsuccessful');

                // Notify the listeners after the status change but before the next action
                _notifyListeners('/meta/connect', message);
                _notifyListeners('/meta/unsuccessful', message);

                // Connect was not successful.
                // This may happen when the server crashed, the current clientId
                // will be invalid, and the server will ask to handshake again
                switch (action)
                {
                    case 'retry':
                        _increaseBackoff();
                        _delayedConnect();
                        break;
                    case 'handshake':
                        // End the batch but do not deliver the messages until we connect successfully
                        _endBatch(false);
                        _resetBackoff();
                        _delayedHandshake();
                        break;
                    case 'none':
                        _resetBackoff();
                        _setStatus('disconnected');
                        break;
                }
            }
        };

        function _connectFailure(xhr, message)
        {
            _debug('Connect failure');

            // Notify listeners
            var failureMessage = {
                successful: false,
                failure: true,
                channel: '/meta/connect',
                request: message,
                xhr: xhr,
                advice: {
                    action: 'retry',
                    interval: _backoff
                }
            };
            _notifyListeners('/meta/connect', failureMessage);
            _notifyListeners('/meta/unsuccessful', failureMessage);

            if (!_isDisconnected())
            {
                var action = _advice.reconnect ? _advice.reconnect : 'retry';
                switch (action)
                {
                    case 'retry':
                        _increaseBackoff();
                        _debug('Connect failure, backing off and retrying in {} ms', _backoff);
                        _delayedConnect();
                        break;
                    case 'handshake':
                        _resetBackoff();
                        _delayedHandshake();
                        break;
                    case 'none':
                        _resetBackoff();
                        break;
                    default:
                        _debug('Unrecognized reconnect value: {}', action);
                        break;
                }
            }
        };

        function _disconnectSuccess(message)
        {
            if (message.successful)
            {
                _debug('Disconnect successful');
                _disconnect(false);
                _notifyListeners('/meta/disconnect', message);
            }
            else
            {
                _debug('Disconnect unsuccessful');
                _disconnect(true);
                _notifyListeners('/meta/disconnect', message);
                _notifyListeners('/meta/usuccessful', message);
            }
        };

        function _disconnect(abort)
        {
            _cancelDelayedSend();
            if (abort) _transport.abort();
            _clientId = null;
            _setStatus('disconnected');
            _batch = 0;
            _messageQueue = [];
            _resetBackoff();
        };

        function _disconnectFailure(xhr, message)
        {
            _debug('Disconnect failure');
            _disconnect(true);

            var failureMessage = {
                successful: false,
                failure: true,
                channel: '/meta/disconnect',
                request: message,
                xhr: xhr,
                advice: {
                    action: 'none',
                    interval: 0
                }
            };
            _notifyListeners('/meta/disconnect', failureMessage);
            _notifyListeners('/meta/unsuccessful', failureMessage);
        };

        function _subscribeSuccess(message)
        {
            if (message.successful)
            {
                _debug('Subscribe successful');
                _notifyListeners('/meta/subscribe', message);
            }
            else
            {
                _debug('Subscribe unsuccessful');
                _notifyListeners('/meta/subscribe', message);
                _notifyListeners('/meta/unsuccessful', message);
            }
        };

        function _subscribeFailure(xhr, message)
        {
            _debug('Subscribe failure');

            var failureMessage = {
                successful: false,
                failure: true,
                channel: '/meta/subscribe',
                request: message,
                xhr: xhr,
                advice: {
                    action: 'none',
                    interval: 0
                }
            };
            _notifyListeners('/meta/subscribe', failureMessage);
            _notifyListeners('/meta/unsuccessful', failureMessage);
        };

        function _unsubscribeSuccess(message)
        {
            if (message.successful)
            {
                _debug('Unsubscribe successful');
                _notifyListeners('/meta/unsubscribe', message);
            }
            else
            {
                _debug('Unsubscribe unsuccessful');
                _notifyListeners('/meta/unsubscribe', message);
                _notifyListeners('/meta/unsuccessful', message);
            }
        };

        function _unsubscribeFailure(xhr, message)
        {
            _debug('Unsubscribe failure');

            var failureMessage = {
                successful: false,
                failure: true,
                channel: '/meta/unsubscribe',
                request: message,
                xhr: xhr,
                advice: {
                    action: 'none',
                    interval: 0
                }
            };
            _notifyListeners('/meta/unsubscribe', failureMessage);
            _notifyListeners('/meta/unsuccessful', failureMessage);
        };

        function _messageSuccess(message)
        {
            if (message.successful === undefined)
            {
                if (message.data)
                {
                    // It is a plain message, and not a bayeux meta message
                    _notifyListeners(message.channel, message);
                }
                else
                {
                    _debug('Unknown message {}', JSON.stringify(message));
                }
            }
            else
            {
                if (message.successful)
                {
                    _debug('Publish successful');
                    _notifyListeners('/meta/publish', message);
                }
                else
                {
                    _debug('Publish unsuccessful');
                    _notifyListeners('/meta/publish', message);
                    _notifyListeners('/meta/unsuccessful', message);
                }
            }
        };

        function _messageFailure(xhr, message)
        {
            _debug('Publish failure');

            var failureMessage = {
                successful: false,
                failure: true,
                channel: message.channel,
                request: message,
                xhr: xhr,
                advice: {
                    action: 'none',
                    interval: 0
                }
            };
            _notifyListeners('/meta/publish', failureMessage);
            _notifyListeners('/meta/unsuccessful', failureMessage);
        };

        function _notifyListeners(channel, message)
        {
            // Notify direct listeners
            _notify(channel, message);

            // Notify the globbing listeners
            var channelParts = channel.split("/");
            var last = channelParts.length - 1;
            for (var i = last; i > 0; --i)
            {
                var channelPart = channelParts.slice(0, i).join('/') + '/*';
                // We don't want to notify /foo/* if the channel is /foo/bar/baz,
                // so we stop at the first non recursive globbing
                if (i == last) _notify(channelPart, message);
                // Add the recursive globber and notify
                channelPart += '*';
                _notify(channelPart, message);
            }
        };

        function _notify(channel, message)
        {
            var subscriptions = _listeners[channel];
            if (subscriptions && subscriptions.length > 0)
            {
                for (var i = 0; i < subscriptions.length; ++i)
                {
                    var subscription = subscriptions[i];
                    // Subscriptions may come and go, so the array may have 'holes'
                    if (subscription)
                    {
                        try
                        {
                            _debug('Notifying subscription: channel \'{}\', callback \'{}\'', channel, subscription.callback.name);
                            subscription.callback.call(subscription.scope, message);
                        }
                        catch (x)
                        {
                            // Ignore exceptions from callbacks
                            _warn('Exception during execution of callback \'{}\' on channel \'{}\' for message {}, exception: {}', subscription.callback.name, channel, JSON.stringify(message), x);
                        }
                    }
                }
            }
        };

        function _resetBackoff()
        {
            _backoff = 0;
        };

        function _increaseBackoff()
        {
            if (_backoff < _maxBackoff) _backoff += _backoffIncrement;
        };

        var _error = this._error = function(text, args)
        {
            _log('error', _format.apply(this, arguments));
        };

        var _warn = this._warn = function(text, args)
        {
            _log('warn', _format.apply(this, arguments));
        };

        var _info = this._info = function(text, args)
        {
            _log('info', _format.apply(this, arguments));
        };

        var _debug = this._debug = function(text, args)
        {
            _log('debug', _format.apply(this, arguments));
        };

        function _log(level, text)
        {
            var priority = _logPriorities[level];
            var configPriority = _logPriorities[_logLevel];
            if (!configPriority) configPriority = _logPriorities['info'];
            if (priority >= configPriority)
            {
                if (window.console) window.console.log(text);
            }
        };

        function _format(text)
        {
            var braces = /\{\}/g;
            var result = '';
            var start = 0;
            var count = 0;
            while (braces.test(text))
            {
                result += text.substr(start, braces.lastIndex - start - 2);
                var arg = arguments[++count];
                result += arg !== undefined ? arg : '{}';
                start = braces.lastIndex;
            }
            result += text.substr(start, text.length - start);
            return result;
        };

        function newLongPollingTransport()
        {
            return $.extend({}, new Transport('long-polling'), new LongPollingTransport());
        };

        function newCallbackPollingTransport()
        {
            return $.extend({}, new Transport('callback-polling'), new CallbackPollingTransport());
        };

        /**
         * Base object with the common functionality for transports.
         * The key responsibility is to allow at most 2 outstanding requests to the server,
         * to avoid that requests are sent behind a long poll.
         * To achieve this, we have one reserved request for the long poll, and all other
         * requests are serialized one after the other.
         */
        var Transport = function(type)
        {
            var _maxRequests = 2;
            var _requestIds = 0;
            var _cometRequest = null;
            var _requests = [];
            var _packets = [];

            this.getType = function()
            {
                return type;
            };

            this.send = function(packet, comet)
            {
                if (comet)
                    _cometSend(this, packet);
                else
                    _send(this, packet);
            };

            function _cometSend(self, packet)
            {
                if (_cometRequest !== null) throw 'Concurrent comet requests not allowed, request ' + _cometRequest.id + ' not yet completed';

                var requestId = ++_requestIds;
                _debug('Beginning comet request {}', requestId);

                var request = {id: requestId};
                _debug('Delivering comet request {}', requestId);
                self.deliver(packet, request);
                _cometRequest = request;
            };

            function _send(self, packet)
            {
                var requestId = ++_requestIds;
                _debug('Beginning request {}, {} other requests, {} queued requests', requestId, _requests.length, _packets.length);

                var request = {id: requestId};
                // Consider the comet request which should always be present
                if (_requests.length < _maxRequests - 1)
                {
                    _debug('Delivering request {}', requestId);
                    self.deliver(packet, request);
                    _requests.push(request);
                }
                else
                {
                    _packets.push([packet, request]);
                    _debug('Queued request {}, {} queued requests', requestId, _packets.length);
                }
            };

            this.complete = function(request, success, comet)
            {
                if (comet)
                    _cometComplete(request);
                else
                    _complete(this, request, success);
            };

            function _cometComplete(request)
            {
                var requestId = request.id;
                if (_cometRequest !== request) throw 'Comet request mismatch, completing request ' + requestId;

                // Reset comet request
                _cometRequest = null;
                _debug('Ended comet request {}', requestId);
            };

            function _complete(self, request, success)
            {
                var requestId = request.id;
                var index = $.inArray(request, _requests);
                // The index can be negative the request has been aborted
                if (index >= 0) _requests.splice(index, 1);
                _debug('Ended request {}, {} other requests, {} queued requests', requestId, _requests.length, _packets.length);

                if (_packets.length > 0)
                {
                    var packet = _packets.shift();
                    if (success)
                    {
                        _debug('Dequeueing and sending request {}, {} queued requests', packet[1].id, _packets.length);
                        _send(self, packet[0]);
                    }
                    else
                    {
                        _debug('Dequeueing and failing request {}, {} queued requests', packet[1].id, _packets.length);
                        // Keep the semantic of calling response callbacks asynchronously after the request
                        setTimeout(function() { packet[0].onFailure(packet[1], 'error'); }, 0);
                    }
                }
            };

            this.abort = function()
            {
                for (var i = 0; i < _requests.length; ++i)
                {
                    var request = _requests[i];
                    _debug('Aborting request {}', request.id);
                    if (request.xhr) request.xhr.abort();
                }
                if (_cometRequest)
                {
                    _debug('Aborting comet request {}', _cometRequest.id);
                    if (_cometRequest.xhr) _cometRequest.xhr.abort();
                }
                _cometRequest = null;
                _requests = [];
                _packets = [];
            };
        };

        var LongPollingTransport = function()
        {
            this.deliver = function(packet, request)
            {
                request.xhr = $.ajax({
                    url: packet.url,
                    type: 'POST',
                    contentType: 'text/json;charset=UTF-8',
                    beforeSend: function(xhr)
                    {
                        xhr.setRequestHeader('Connection', 'Keep-Alive');
                        return true;
                    },
                    data: JSON.stringify(packet.messages),
                    success: function(response) { packet.onSuccess(request, response); },
                    error: function(xhr, reason, exception) { packet.onFailure(request, reason, exception); }
                });
            };
        };

        var CallbackPollingTransport = function()
        {
            var _maxLength = 2000;
            this.deliver = function(packet, request)
            {
                // Microsoft Internet Explorer has a 2083 URL max length
                // We must ensure that we stay within that length
                var messages = JSON.stringify(packet.messages);
                // Encode the messages because all brackets, quotes, commas, colons, etc
                // present in the JSON will be URL encoded, taking many more characters
                var urlLength = packet.url.length + encodeURI(messages).length;
                _debug('URL length: {}', urlLength);
                // Let's stay on the safe side and use 2000 instead of 2083
                // also because we did not count few characters among which
                // the parameter name 'message' and the parameter 'jsonp',
                // which sum up to about 50 chars
                if (urlLength > _maxLength)
                {
                    var x = packet.messages.length > 1 ?
                            'Too many bayeux messages in the same batch resulting in message too big ' +
                            '(' + urlLength + ' bytes, max is ' + _maxLength + ') for transport ' + this.getType() :
                            'Bayeux message too big (' + urlLength + ' bytes, max is ' + _maxLength + ') ' +
                            'for transport ' + this.getType();
                    // Keep the semantic of calling response callbacks asynchronously after the request
                    _setTimeout(function() { packet.onFailure(request, 'error', x); }, 0);
                }
                else
                {
                    $.ajax({
                        url: packet.url,
                        type: 'GET',
                        dataType: 'jsonp',
                        jsonp: 'jsonp',
                        beforeSend: function(xhr)
                        {
                            xhr.setRequestHeader('Connection', 'Keep-Alive');
                            return true;
                        },
                        data:
                        {
                            // In callback-polling, the content must be sent via the 'message' parameter
                            message: messages
                        },
                        success: function(response) { packet.onSuccess(request, response); },
                        error: function(xhr, reason, exception) { packet.onFailure(request, reason, exception); }
                    });
                }
            };
        };
    };

    /**
     * The JS object that exposes the comet API to applications
     */
    $.cometd = new $.Cometd(); // The default instance

})(jQuery);


code:
/**
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.	If not, see <http://www.gnu.org/licenses/>.
 *
 * @category     Plugin
 * @package      StatusNet
 * @author		 Behrooz shabani (everplays) - <behrooz@rock.com>
 * @copyright    2009-2010 Behrooz shabani
 * @license      http://www.fsf.org/licensing/licenses/agpl-3.0.html AGPL 3.0
 *
 */

(function($){
	$.fn.isRTL = function(str){
		if(typeof str != typeof "" || str.length<1)
			return false;
		var cc = str.charCodeAt(0);
		if(cc>=1536 && cc<=1791) // arabic, persian, ...
			return true;
		if(cc>=65136 && cc<=65279) // arabic peresent 2
			return true;
		if(cc>=64336 && cc<=65023) // arabic peresent 1
			return true;
		if(cc>=1424 && cc<=1535) // hebrew
			return true;
		if(cc>=64256 && cc<=64335) // hebrew peresent
			return true;
		if(cc>=1792 && cc<=1871) // Syriac
			return true;
		if(cc>=1920 && cc<=1983) // Thaana
			return true;
		if(cc>=1984 && cc<=2047) // NKo
			return true;
		if(cc>=11568 && cc<=11647) // Tifinagh
			return true;
		return false;
	};
    var origInit = SN.Init.NoticeFormSetup;
    SN.Init.NoticeFormSetup = function(form) {
        origInit(form);
        var tArea = form.find(".notice_data-text:first");
        if (tArea.length > 0) {
            var tCleaner = new RegExp('@[^ ]+|![^ ]+|#[^ ]+|^RT[: ]{1}| RT | RT: |^RD[: ]{1}| RD | RD: |[♺♻:]+', 'g')
            var ping = function(){
                var cleaned = tArea.val().replace(tCleaner, '').replace(/^[ ]+/, '');
                if($().isRTL(cleaned))
                    tArea.css('direction', 'rtl');
                else
                    tArea.css('direction', 'ltr');
            };
            tArea.bind('keyup cut paste', function() {
                // cut/paste trigger before the change
                window.setTimeout(ping, 0);
            });
            form.bind('reset', function() {
                tArea.css('direction', 'ltr');
            });
        }
    };
})(jQuery);


code:
/* CSS file for the Directory plugin */

div#profile_directory div.alpha_nav {
    overflow: hidden;
    width: 100%;
    text-align: center;
}

/* XXX: this needs serious CSS foo */
div#profile_directory div.alpha_nav > a {
    border-left: 1px solid #000;
    padding-left: 2px;
}
div#profile_directory div.alpha_nav > a.first {
    border-left: none;
}

div#profile_directory div.alpha_nav a:link {
    text-decoration: none;
}

div#profile_directory div.alpha_nav a:visited {
    text-decoration: none;
}
div#profile_directory div.alpha_nav a:active {
    text-decoration: none;
}
div#profile_directory div.alpha_nav a:hover {
    text-decoration: underline; color: blue;
}

div#profile_directory div.alpha_nav a.current {
    background-color:#9BB43E;
}

table.profile_list {
    width: 100%;
}

table.profile_list tr {
    float: none;
}

table.profie_list td {
    width: 100%;
    padding: 0;
}

th.current {
    background-image: url(../images/control_arrow_down.gif);
    background-repeat: no-repeat;
    background-position: 60% 2px;
}

th.current.reverse {
    background-image: url(../images/control_arrow_up.gif);
    background-repeat: no-repeat;
    background-position: 60% 2px;
}


code:
// XXX: Should I do crazy SN.X.Y.Z.A namespace instead?
var SN_WHITELIST = SN_WHITELIST || {};

SN_WHITELIST.updateButtons = function () {
   $("ul > li > a.remove_row").show();
   $("ul > li > a.add_row").hide();

    var lis = $('ul > li > input[name^="username[]"]');
    if (lis.length === 1) {
        $("ul > li > a.remove_row").hide();
    } else {
        $("ul > li > a.remove_row:first").show();
    }
    $("ul > li > a.add_row:last").show();
};

SN_WHITELIST.resetRow = function (row) {
    $("input", row).val('');
    // Make sure the default domain is the first selection
    $("select option:first", row).val();
    $("a.remove_row", row).show();
};

SN_WHITELIST.addRow = function () {
    var row = $(this).closest("li");
    var newRow = row.clone();
    $(row).find('a.add_row').hide();
    SN_WHITELIST.resetRow(newRow);
        $(newRow).insertAfter(row).show("blind", "fast", function () {
            SN_WHITELIST.updateButtons();
        });
};

SN_WHITELIST.removeRow = function () {
    var that = this;

    $("#confirm-dialog").dialog({
        buttons : {
            "Confirm" : function () {
                $(this).dialog("close");
                $(that).closest("li").hide("blind", "fast", function () {
                    $(this).remove();
                    SN_WHITELIST.updateButtons();
                });
            },
            "Cancel" : function () {
                $(this).dialog("close");
            }
        }
    });

    if ($(this).closest('li').find(':input[name^=username]').val()) {
        $("#confirm-dialog").dialog("open");
    } else {
        $(that).closest("li").hide("blind", "fast", function () {
            $(this).remove();
            SN_WHITELIST.updateButtons();
        });
    }
};

$(document).ready(function () {
    $("#confirm-dialog").dialog({
        autoOpen: false,
        modal: true
    });

    $(document).on('click', '.add_row', SN_WHITELIST.addRow);
    $(document).on('click', '.remove_row', SN_WHITELIST.removeRow);

    SN_WHITELIST.updateButtons();
});


code:
/* Event specific styles */

.event-tags li { display: inline; }
.event-mentions li { display: inline; }
.event-avatar { float: left; }
.event-notice-count { float: right; }
.event-info { float: left; }
.event-title { margin-left: 0px; }
.ui-autocomplete {
    max-height: 100px;
    overflow-y: auto;
    /* prevent horizontal scrollbar */
    overflow-x: hidden;
    /* add padding to account for vertical scrollbar */
    padding-right: 20px;
}

.attending-list { list-style-type: none; float: left; width: 100%; }

#form_event_rsvp { clear: left; }

li.rsvp-list { float: left; clear: left; }

li.rsvp-list ul.entities {
    display:inline;
}
li.rsvp-list .entities li {
    list-style-type: none;
    margin-right: 3px;
    margin-bottom: 8px;
    display: inline;
}
li.rsvp-list .entities li .u-photo {
    margin: 0 !important;
    float: none !important;
}

.notice .h-event div {
    margin-bottom: 8px;
}

.event-info {
    margin-left: 0px !important;
    margin-top: 2px !important;
}

.notice .event-info + .notice-options {
    margin-top: 14px;
}

.notice .threaded-replies .event-info + .notice-options {
    margin-top: 20px;
}

#form_event_rsvp #new_rsvp_data {
    display: inline;
    margin: 10px 0px;
}

#form_event_rsvp input.submit {
    height: auto;
    padding: 0px 10px;
    margin-left: 10px;
    color:#fff;
    font-weight: bold;
    text-transform: uppercase;
    font-size: 1.1em;
    text-shadow: 0px -1px 0px rgba(0, 0, 0, 0.2);
    border: 1px solid #d7621c;
    border-radius: 4px;
    -moz-border-radius: 4px;
    -webkit-border-radius: 4px;
    background: #FB6104;
    background: -moz-linear-gradient(top, #ff9d63 0%, #fb6104 100%);
    background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#ff9d63), color-stop(100%,#fb6104));
    background: -webkit-linear-gradient(top, #ff9d63 0%,#fb6104 100%);
    background: -o-linear-gradient(top, #ff9d63 0%,#fb6104 100%);
    background: -ms-linear-gradient(top, #ff9d63 0%,#fb6104 100%);
    filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#ff9d63', endColorstr='#fb6104',GradientType=0 );
    background: linear-gradient(top, #ff9d63 0%,#fb6104 100%);
}

#form_event_rsvp input.submit:hover {
    text-shadow: 0px -1px 0px rgba(0, 0, 0, 0.6);
    background: #ff9d63;
    background: -moz-linear-gradient(top, #fb6104 0%, #fc8035 100%);
    background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,#fb6104), color-stop(100%,#fc8035));
    background: -webkit-linear-gradient(top, #fb6104 0%,#fc8035 100%);
    background: -o-linear-gradient(top, #fb6104 0%,#fc8035 100%);
    background: -ms-linear-gradient(top, #fb6104 0%,#fc8035 100%);
    filter: progid:DXImageTransform.Microsoft.gradient( startColorstr='#fb6104', endColorstr='#fc8035',GradientType=0 );
    background: linear-gradient(top, #fb6104 0%,#fc8035 100%);
}

#wrap .h-event form.processing input.submit {
    text-indent: 0;
    background: #ff9d63;
}

#input_form_event .form_settings .form_data {
    float: left;
}

#input_form_event .form_settings .form_data li {
    float: left;
    width: auto;
}

#input_form_event .form_settings .form_data label {
    width: auto;
}

label[for=event-starttime], label[for=event-endtime] {
    display: none !important;
}

#event-starttime, #event-endtime {
    margin-top:  -1px;
    margin-bottom:  -1px;
    height: 2em;
}

#event-startdate, #event-enddate {
    margin-right: 20px;
    width: 120px;
}


code:
$(document).ready(function() {

    // get current time from server
    var today = new Date($('now').val());

    $("#event-startdate").datepicker({
        // Don't let the user set a start date < before today
        minDate: today,
        onClose: onStartDateSelected
    });

    $("#event-enddate").datepicker({
        minDate: today,
        onClose: onEndDateSelected
    });

    $("#event-starttime").change(function(e) {
        var tz = $("#tz").val();

        var startDate = $("#event-startdate").val();
        var startTime = $("#event-starttime option:selected").val().replace(/(pm|am)/, ' $1');
        var startStr = startDate + ' ' + startTime + ' ' + tz;

        var endDate =  $("#event-enddate").val();
        var endTime = $("#event-endtime option:selected").val();
        var endStr = endDate + ' ' + endTime.replace(/(pm|am)/, ' $1') + ' ' + tz;

        // just need to compare hours
        var start = new Date(startStr);
        var end = new Date(endStr);

        updateTimes(startStr, (startDate === endDate), function (data) {
            var times = [];
            $.each(data, function(key, val) {
                times.push('<option value="' + key + '">' + val + '</option>');
            });
            $("#event-endtime").html(times.join(''));

            if (start > end) {
                $("#event-endtime").val(startTime).attr("selected", "selected");
            } else {
                $("#event-endtime").val(endTime).attr("selected", "selected");
            }
        });

    });

    $("#event-endtime").change(function(e) {
        var HOUR = 60 * 60 * 1000;
        var tz = $("#tz").val();
        var startDate = $("#event-startdate").val();
        var endDate = $("#event-enddate").val();
        var starttime = $("#event-starttime option:selected").val();
        var endtime = $("#event-endtime option:selected").val();
        var endtimeText = $("#event-endtime option:selected").text();

        // If the end time is in the next day then update the start date
        if (startDate === endDate) {
            var startstr = startDate + ' ' + starttime.replace(/(pm|am)/, ' $1') + ' ' + tz;
            var start = new Date(startstr);
            var matches = endtimeText.match(/\(.*\)/);
            var hours;
            if (matches) {
                hours = matches[0].substr(1).split(' ')[0]; // get x from (x hours)
                if (hours) {
                    if (hours == 30) {
                        hours = .5; // special case: x == 30 from (30 mins)
                    }
                    var end = new Date(start.getTime() + (hours * HOUR));
                    if (end.getDate() > start.getDate()) {
                        $("#event-enddate").datepicker('setDate', end);
                        var endstr = endDate + ' 12:00 am ' +  tz;
                        updateTimes(endstr, false, function(data) {
                            var times = [];
                            $.each(data, function(key, val) {
                                times.push('<option value="' + key + '">' + val + '</option>');
                            });
                            $("#event-endtime").html(times.join(''));

                            if (start > end) {
                                $("#event-endtime").val(starttime).attr("selected", "selected");
                            } else {
                                $("#event-endtime").val(endtime).attr("selected", "selected");
                            }
                        });
                    }
                }
            }
        }
    });

    function onStartDateSelected(dateText, inst) {
        var tz = $("#tz").val();
        var startTime = $("#event-starttime option:selected").val();
        var startDateTime = new Date(dateText + ' ' + startTime.replace(/(pm|am)/, ' $1') + ' ' + tz);

        // When we update the start date and time, we need to update the end date and time
        // to make sure they are equal or in the future
        $("#event-enddate").datepicker('option', 'minDate', startDateTime);

        recalculateTimes();
    }

    function onEndDateSelected(dateText, inst) {
        recalculateTimes();
    }

    function recalculateTimes(showDuration) {
        var tz = $("#tz").val();

        var startDate = $("#event-startdate").val();
        var startTime = $("#event-starttime option:selected").val();
        var startStr = startDate + ' ' + startTime.replace(/(pm|am)/, ' $1') + ' ' + tz;
        var startDateTime = new Date(startStr);

        var endDate = $("#event-enddate").val();
        var endTime = $("#event-endtime option:selected").val();
        var endDateTime = new Date(endDate + ' ' + endTime.replace(/(pm|am)/, ' $1') + ' ' + tz);
        var showDuration = true;

        if (endDateTime.getDate() !== startDateTime.getDate()) {
            starStr = endDate + ' 12:00 am ' +  tz;
            showDuration = false;
        }

        updateTimes(startStr, showDuration, function(data) {
            var times = [];
            $.each(data, function(key, val) {
                times.push('<option value="' + key + '">' + val + '</option>');
            });
            $("#event-endtime").html(times.join(''));
            if (startDateTime > endDateTime) {
                $("#event-endtime").val(startTime).attr("selected", "selected");
            } else {
                $("#event-endtime").val(endTime).attr("selected", "selected");
            }
        });
    }

    function updateTimes(start, duration, onSuccess) {
        $.getJSON($('#timelist_action_url').val(), {start: start, ajax: true, duration: duration}, onSuccess);
    }

});


code:
/* Note the #content is only needed to override weird crap in default styles */

#profiledetail .entity_actions {
    margin-top: 0px;
    margin-bottom: 0px;
}

#profiledetail #content h3 {
    margin-bottom: 5px;
}

#content table.extended-profile {
    width: 100%;
    border-collapse: separate;
    border-spacing: 0px 8px;
    margin-bottom: 10px;
}

#content table.extended-profile th {
    color: #777;
    background-color: #ECECF2;
    width: 150px;
    text-align: right;
    padding: 2px 8px 2px 0px;
}

#content table.extended-profile th.employer, #content table.extended-profile th.institution {
    display: none;
}

#content table.extended-profile td {
    padding: 2px 0px 2px 8px;
}

.experience-item, .education-item {
    float: left;
    padding-bottom: 4px;
}

.experience-item .label, .education-item .label {
    float: left;
    clear: left;
    position: relative;
    left: -8px;
    margin-right: 2px;
    margin-bottom: 8px;
    color: #777;
    background-color: #ECECF2;
    width: 150px;
    text-align: right;
    padding: 2px 8px 2px 0px;
}

.experience-item .field, .education-item .field {
    float: left;
    padding-top: 2px;
    padding-bottom: 2px;
    max-width: 350px;
}

#profiledetailsettings #content table.extended-profile td {
    padding: 0px 0px 0px 8px;
}

#profiledetailsettings input {
    margin-right: 8px;
}

.form_settings .extended-profile label {
    display: none;
}

.extended-profile textarea {
    width: 280px;
}

.extended-profile input[type=text] {
    width: 280px;
}

.extended-profile .phone-item input[type=text], .extended-profile .im-item input[type=text], .extended-profile .website-item input[type=text] {
    width: 175px;
}

.extended-profile input.hasDatepicker {
    width: 100px;
}

.experience-item input[type=text], .education-item input[type=text] {
    float: left;
}

.extended-profile .current-checkbox {
    float: left;
    position: relative;
    top: 2px;
}

.form_settings .extended-profile input.checkbox {
    margin-left: 0px;
    left: 0px;
    top: 2px;
}

.form_settings .extended-profile label.checkbox {
    max-width: 100%;
    float: none;
    display: inline;
    left: -20px;
}

.extended-profile select {
    padding-right: 2px;
    font-size: 0.88em;
}

.extended-profile a.add_row, .extended-profile a.remove_row {
    display: block;
    height: 16px;
    width: 16px;
    overflow: hidden;
    background-image: url('../../../theme/base/images/icons/icons-01.gif');
    background-repeat: no-repeat;
}

.extended-profile a.remove_row {
    background-position: 0px -1252px;
    float: right;
    position: relative;
    top: 6px;
    line-height: 4em;
}

.extended-profile a.add_row {
    clear: both;
    position: relative;
    top: 6px;
    left: 2px;
    background-position: 0px -1186px;
    width: 120px;
    padding-left: 20px;
    line-height: 1.2em;
}

#content table.extended-profile .supersizeme th {
    border-bottom: 28px solid #fff;
}

#profiledetailsettings .experience-item, #profiledetailsettings .education-item {
    margin-bottom: 10px;
    width: 100%;
}

#profiledetailsettings .education-item textarea {
    float: left;
    margin-bottom: 8px;
}

#profiledetailsettings tr:last-child .experience-item, #profiledetailsettings tr:last-child .education-item {
    margin-bottom: 0px;
}

#profiledetailsettings .experience-item a.add_row, #profiledetailsettings .education-item a.add_row {
    left: 160px;
}


code:
var SN_EXTENDED = SN_EXTENDED || {};

SN_EXTENDED.reorder = function (cls) {

    var divs = $('div[class=' + cls + ']');

    $(divs).each(function (i, div) {
        $(div).find('a.add_row').hide();
        $(div).find('a.remove_row').show();
        SN_EXTENDED.replaceIndex(SN_EXTENDED.rowIndex(div), i);
    });

    var lastDiv = $(divs).last().closest('tr');
    lastDiv.addClass('supersizeme');

    $(divs).last().find('a.add_row').show();

    if (divs.length == 1) {
        $(divs).find('a.remove_row').fadeOut("slow");
    }
};

SN_EXTENDED.rowIndex = function (div) {
    var idstr = $(div).attr('id');
    var id = idstr.match(/\d+/);
    return id;
};

SN_EXTENDED.rowCount = function (cls) {
    var divs = $.find('div[class=' + cls + ']');
    return divs.length;
};

SN_EXTENDED.replaceIndex = function (elem, oldIndex, newIndex) {
    $(elem).find('*').each(function () {
        $.each(this.attributes, function (i, attrib) {
            var regexp = /extprofile-.*-\d.*/;
            var value = attrib.value;
            var match = value.match(regexp);
            if (match !== null) {
                attrib.value = value.replace("-" + oldIndex, "-" + newIndex);
            }
        });
    });
}

SN_EXTENDED.resetRow = function (elem) {
    $(elem).find('input, textarea').attr('value', '');
    $(elem).find('input').removeAttr('disabled');
    $(elem).find("select option[value='office']").attr("selected", true);
    $(elem).find("input:checkbox").attr('checked', false);
    $(elem).find("input[name$=-start], input[name$=-end]").each(function () {
        $(this).removeClass('hasDatepicker');
        $(this).datepicker({ dateFormat: 'd M yy' });
    });
};

SN_EXTENDED.addRow = function () {
    var div = $(this).closest('div');
    var id = div.attr('id');
    var cls = div.attr('class');
    var index = id.match(/\d+/);
    var newIndex = parseInt(index) + 1;
    var newtr = $(div).closest('tr').removeClass('supersizeme').clone();
    SN_EXTENDED.replaceIndex(newtr, index, newIndex);
    SN_EXTENDED.resetRow(newtr);
    $(div).closest('tr').after(newtr);
    SN_EXTENDED.reorder(cls);
};

SN_EXTENDED.removeRow = function () {

    var div = $(this).closest('div');
    var id = $(div).attr('id');
    var cls = $(div).attr('class');
    var that = this;

    $("#confirm-dialog").dialog({
        buttons : {
            "Confirm" : function () {
                $(this).dialog("close");
                var target = $(that).closest('tr');
                target.fadeOut("slow", function () {
                    $(target).remove();
                    SN_EXTENDED.reorder(cls);
                });
            },
            "Cancel" : function () {
                $(this).dialog("close");
            }
        }
    });

    var cnt = SN_EXTENDED.rowCount(cls);

    if (cnt > 1) {
        $("#confirm-dialog").dialog("open");
    }
};

$(document).ready(function () {

    $("#confirm-dialog").dialog({
        autoOpen: false,
        modal: true
    });

    $("input#extprofile-manager").autocomplete({
        source: 'finduser',
        minLength: 2 });

    $("input[name$=-start], input[name$=-end], #extprofile-birthday").datepicker({ dateFormat: 'd M yy' });

    var multifields = ["phone-item", "experience-item", "education-item", "im-item", 'website-item'];

    for (f in multifields) {
        SN_EXTENDED.reorder(multifields[f]);
    }

    $("input#extprofile-manager").autocomplete({
        source: 'finduser',
        minLength: 2 });

    $(document).on('click', '.add_row', SN_EXTENDED.addRow);
    $(document).on('click', '.remove_row', SN_EXTENDED.removeRow);

    $('input:checkbox[name$=current]').each(function () {
        var input = $(this).parent().siblings('input[id$=-end]');
        if ($(this).is(':checked')) {
            $(input).attr('disabled', 'true');
        }
    });

    $(document).on('click', 'input:checkbox[name$=current]', function ()  {
        var input = $(this).parent().siblings('input[id$=-end]');
        if ($(this).is(':checked')) {
            $(input).val('');
            $(input).attr('disabled', 'true');
        } else {
            $(input).removeAttr('disabled');
        }
    });

});


code:
function increasePhotoSize() {
    $('.photoingallery, .albumingallery').each(function(index) {
            this.height *= 1.1;
            this.width *= 1.1;
        });
    return false;
}

function decreasePhotoSize() {
    $('.photoingallery, .albumingallery').each(function(index) {
            this.height /= 1.1;
            this.width /= 1.1;
        });
    return false;
}

function scalePhotosToSize(size) {
    $('.photoingallery, .albumingallery').each(function(index) {
            if(this.height > this.width) {
                this.width = this.width*size/this.height;
                this.height = size;
            }
            else {
                this.height = this.height*size/this.width;
                this.width = size;
            }
        });
    return false;
}


code:
.photocontainer, .albumcontainer {
    display: block;
    background-color: yellow;
    float: left;
    padding: 20px;
    margin: 15px;
}

.photodescription {
    display: block;
    background-color: #dddddd;
    padding: 20px;
    margin: 15px;
}


code:
SN.U.NoticeReplySet = function(nick,id) {
    $('div.replyform').hide();
    $('div#form'+id).show();
}


code:
.biotitle {
    font-weight: bold;
}
.biovalue {
    font-style: italic;
}
#showstream ol.notices ol.notices {
    background-image: url(/plugins/GNUsocialProfileExtensions/res/bgstripe.gif);
    background-repeat: repeat-y;
    background-position: left top;
    padding-left: 15px;
    color: #333333;
}
#showstream ol.notices ol.notices ol.notices {
    padding-left: 5px;
}
div.replyform {
    display: none;
    padding-left: 15px;
}
.replyform .form_notice {
    width: 75%;
}


code:
// notices
jQuery(document).ready(function($){
  $('notices_primary').infinitescroll({
    debug: false,
    infiniteScroll  : !infinite_scroll_on_next_only,
    nextSelector    : 'body#public li.nav_next a,'+
                      'body#all li.nav_next a,'+
                      'body#showstream li.nav_next a,'+
                      'body#replies li.nav_next a,'+
                      'body#showfavorites li.nav_next a,'+
                      'body#showgroup li.nav_next a,'+
                      'body#favorited li.nav_next a',
    loadingImg      : ajax_loader_url,
    text            : "Loading the next set of posts...",
    donetext        : "Congratulations, you\'ve reached the end of the Internet.",
    navSelector     : "#pagination",
    contentSelector : "#notices_primary ol.notices",
    itemSelector    : "#notices_primary ol.notices > li"
    },function(){
        // Reply button and attachment magic need to be set up
        // for each new notice.
        // DO NOT run SN.Init.Notices() which will duplicate stuff.
        $(this).find('.notice').each(function() {
            SN.U.NoticeReplyTo($(this));
            SN.U.NoticeWithAttachment($(this));
        });

        // moving the loaded notices out of their container
		$('#infscr-loading').remove();
		var ids_to_append = Array(); var i=0;
		$.each($('.infscr-pages').children('.notice'),function(){

			// remove dupes
			if($('.threaded-notices > #' + $(this).attr('id')).length > 0) {
				$(this).remove();
				}

			// keep new unique notices
			else {
				ids_to_append[i] = $(this).attr('id');
				i++;
				}
			});
		var loaded_html = $('.infscr-pages').html();
		$('.infscr-pages').remove();

		// no results
		if(loaded_html == '') {
			}
		// append
		else {
			$('#notices_primary ol.notices').append(loaded_html);
			}

    });
});

// users
jQuery(document).ready(function($){
  $('profile_list').infinitescroll({
    debug: false,
    infiniteScroll  : !infinite_scroll_on_next_only,
    nextSelector    : 'body#subscribers li.nav_next a, body#subscriptions li.nav_next a',
    loadingImg      : ajax_loader_url,
    text            : "Loading the next set of users...",
    donetext        : "Congratulations, you\'ve reached the end of the Internet.",
    navSelector     : "#pagination",
    contentSelector : "#content_inner ul.profile_list",
    itemSelector    : "#content_inner ul.profile_list > li"
    },function(){
        // Reply button and attachment magic need to be set up
        // for each new notice.
        // DO NOT run SN.Init.Notices() which will duplicate stuff.
        $(this).find('.profile').each(function() {
            SN.U.NoticeReplyTo($(this));
            SN.U.NoticeWithAttachment($(this));
        });

        // moving the loaded notices out of their container
		$('#infscr-loading').remove();
		var ids_to_append = Array(); var i=0;
		$.each($('.infscr-pages').children('.profile'),function(){

			// remove dupes
			if($('.profile_list > #' + $(this).attr('id')).length > 0) {
				$(this).remove();
				}

			// keep new unique notices
			else {
				ids_to_append[i] = $(this).attr('id');
				i++;
				}
			});
		var loaded_html = $('.infscr-pages').html();
		$('.infscr-pages').remove();

		// no results
		if(loaded_html == '') {
			}
		// append
		else {
			$('#content_inner ul.profile_list').append(loaded_html);
			}

    });
});

// user directory
jQuery(document).ready(function($){
  $('profile_list').infinitescroll({
    debug: false,
    infiniteScroll  : !infinite_scroll_on_next_only,
    nextSelector    : 'body#userdirectory li.nav_next a',
    loadingImg      : ajax_loader_url,
    text            : "Loading the next set of users...",
    donetext        : "Congratulations, you\'ve reached the end of the Internet.",
    navSelector     : "#pagination",
    contentSelector : "#profile_directory table.profile_list tbody",
    itemSelector    : "#profile_directory table.profile_list tbody tr"
    },function(){
        // Reply button and attachment magic need to be set up
        // for each new notice.
        // DO NOT run SN.Init.Notices() which will duplicate stuff.
        $(this).find('.profile').each(function() {
            SN.U.NoticeReplyTo($(this));
            SN.U.NoticeWithAttachment($(this));
        });

        // moving the loaded notices out of their container
		$('#infscr-loading').remove();
		var ids_to_append = Array(); var i=0;
		$.each($('.infscr-pages').children('.profile'),function(){

			// remove dupes
			if($('.profile_list > #' + $(this).attr('id')).length > 0) {
				$(this).remove();
				}

			// keep new unique notices
			else {
				ids_to_append[i] = $(this).attr('id');
				i++;
				}
			});
		var loaded_html = $('.infscr-pages').html();
		$('.infscr-pages').remove();

		// no results
		if(loaded_html == '') {
			}
		// append
		else {
			$('#profile_directory table.profile_list tbody').append(loaded_html);
			}

    });
});


code:
/*!
// Infinite Scroll jQuery plugin
// copyright Paul Irish, licensed GPL & MIT
// version 1.2.090804

// home and docs: http://www.infinite-scroll.com
*/

// todo: add preloading option.

;(function($){

  $.fn.infinitescroll = function(options,callback){

    // console log wrapper.
    function debug(){
      if (opts.debug) { window.console && console.log.call(console,arguments)}
    }

    // grab each selector option and see if any fail.
    function areSelectorsValid(opts){
      for (var key in opts){
        if (key.indexOf && (key.indexOf('Selector') != -1) && $(opts[key]).length === 0){
            debug('Your ' + key + ' found no elements.');
            return false;
        }
        return true;
      }
    }

    // find the number to increment in the path.
    function determinePath(path){

      path.match(relurl) ? path.match(relurl)[2] : path;

      // there is a 2 in the url surrounded by slashes, e.g. /page/2/
      if ( path.match(/^(.*?)\b2\b(.*?$)/) ){
          path = path.match(/^(.*?)\b2\b(.*?$)/).slice(1);
      } else
        // if there is any 2 in the url at all.
        if (path.match(/^(.*?)2(.*?$)/)){
          debug('Trying backup next selector parse technique. Treacherous waters here, matey.');
          path = path.match(/^(.*?)2(.*?$)/).slice(1);
      } else {
        debug('Sorry, we couldn\'t parse your Next (Previous Posts) URL. Verify your the css selector points to the correct A tag. If you still get this error: yell, scream, and kindly ask for help at infinite-scroll.com.');
        props.isInvalidPage = true;  //prevent it from running on this page.
      }

      return path;
    }

    // 'document' means the full document usually, but sometimes the content of the overflow'd div in local mode
    function getDocumentHeight(){
      // weird doubletouch of scrollheight because http://soulpass.com/2006/07/24/ie-and-scrollheight/
      return opts.localMode ? ($(props.container)[0].scrollHeight && $(props.container)[0].scrollHeight)
                                // needs to be document's height. (not props.container's) html's height is wrong in IE.
                                : $(document).height()
    }

    function isNearBottom(opts,props){

      // distance remaining in the scroll
      // computed as: document height - distance already scroll - viewport height - buffer
      var pixelsFromWindowBottomToBottom = getDocumentHeight()  -
                                            (opts.localMode ? $(props.container).scrollTop() :
                                              // have to do this bs because safari doesnt report a scrollTop on the html element
                                              ($(props.container).scrollTop() || $(props.container.ownerDocument.body).scrollTop())) -
                                            $(opts.localMode ? props.container : window).height();

      debug('math:',pixelsFromWindowBottomToBottom, props.pixelsFromNavToBottom);

      // if distance remaining in the scroll (including buffer) is less than the orignal nav to bottom....
      return (pixelsFromWindowBottomToBottom  - opts.bufferPx < props.pixelsFromNavToBottom);
    }

    function showDoneMsg(){
      props.loadingMsg
        .find('img').hide()
        .parent()
          .find('div').html(opts.donetext).animate({opacity: 1},2000).fadeOut('normal');

      // user provided callback when done
      opts.errorCallback();
    }

    function infscrSetup(path,opts,props,callback){

        if (props.isDuringAjax || props.isInvalidPage || props.isDone) return;

    		if ( opts.infiniteScroll && !isNearBottom(opts,props) ) return;

    		// we dont want to fire the ajax multiple times
    		props.isDuringAjax = true;

    		// show the loading message and hide the previous/next links
    		props.loadingMsg.appendTo( opts.contentSelector ).show();
    		if(opts.infiniteScroll) $( opts.navSelector ).hide();

    		// increment the URL bit. e.g. /page/3/
    		props.currPage++;

    		debug('heading into ajax',path);

    		// if we're dealing with a table we can't use DIVs
    		var box = $(opts.contentSelector).is('table') ? $('
') : $('
');

    		box
    		  .attr('id','infscr-page-'+props.currPage)
    		  .addClass('infscr-pages')
    		  .appendTo( opts.contentSelector )
    		  .load( path.join( props.currPage ) + ' ' + opts.itemSelector,null,function(){

    		        // if we've hit the last page...
    		        if (props.isDone){
                    showDoneMsg();
        			      return false;

  	            } else {

  	                // if it didn't return anything
  	                if (box.children().length == 0){
  	                  // fake an ajaxError so we can quit.
  	                  $.event.trigger( "ajaxError", [{status:404}] );
  	                }

  	                // fadeout currently makes the 'd text ugly in IE6
    		            props.loadingMsg.fadeOut('normal' );

    		            // smooth scroll to ease in the new content
    		            if (opts.animate){
      		            var scrollTo = $(window).scrollTop() + $('#infscr-loading').height() + opts.extraScrollPx + 'px';
                      $('html,body').animate({scrollTop: scrollTo}, 800,function(){ props.isDuringAjax = false; });
    		            }

                    // pass in the new DOM element as context for the callback
                    callback.call( box[0] );

    		            if (!opts.animate) props.isDuringAjax = false; // once the call is done, we can allow it again.
  	            }
    		    }); // end of load()

      }  // end of infscrSetup()

    // lets get started.

    var opts    = $.extend({}, $.infinitescroll.defaults, options);
    var props   = $.infinitescroll; // shorthand
    callback    = callback || function(){};

    if (!areSelectorsValid(opts)){ return false;  }

     // we doing this on an overflow:auto div?
    props.container   =  opts.localMode ? this : document.documentElement;

    // contentSelector we'll use for our .load()
    opts.contentSelector = opts.contentSelector || this;

    // get the relative URL - everything past the domain name.
    var relurl        = /(.*?\/\/).*?(\/.*)/;
    var path          = $(opts.nextSelector).attr('href');

    if (!path) { debug('Navigation selector not found'); return; }

    // set the path to be a relative URL from root.
    path          = determinePath(path);

    // reset scrollTop in case of page refresh:
    if (opts.localMode) $(props.container)[0].scrollTop = 0;

    // distance from nav links to bottom
    // computed as: height of the document + top offset of container - top offset of nav link
    props.pixelsFromNavToBottom =  getDocumentHeight()  +
                                     $(props.container).offset().top -
                                     $(opts.navSelector).offset().top;

    // define loading msg
    props.loadingMsg = $('

'+opts.loadingText+'

');
     // preload the image
    (new Image()).src    = opts.loadingImg;

    // set up our bindings
    $(document).ajaxError(function(e,xhr,opt){
      debug('Page not found. Self-destructing...');

      // die if we're out of pages.
      if (xhr.status == 404){
        showDoneMsg();
        props.isDone = true;
        $(opts.localMode ? this : window).unbind('scroll.infscr');
      }
    });

    if(opts.infiniteScroll){
      // bind scroll handler to element (if its a local scroll) or window
      $(opts.localMode ? this : window)
        .bind('scroll.infscr', function(){ infscrSetup(path,opts,props,callback); } )
        .trigger('scroll.infscr'); // trigger the event, in case it's a short page
    }else{
      $(opts.nextSelector).click(
        function(){
          infscrSetup(path,opts,props,callback);
          return false;
        }
      );
    }

    return this;

  }  // end of $.fn.infinitescroll()

  // options and read-only properties object

  $.infinitescroll = {
        defaults      : {
                          debug           : false,
                          infiniteScroll  : true,
                          preload         : false,
                          nextSelector    : "div.navigation a:first",
                          loadingImg      : "http://www.infinite-scroll.com/loading.gif",
                          loadingText     : "Loading the next set of posts...",
                          donetext        : "Congratulations, you've reached the end of the internet.",
                          navSelector     : "div.navigation",
                          contentSelector : null,           // not really a selector. :) it's whatever the method was called on..
                          extraScrollPx   : 150,
                          itemSelector    : "div.post",
                          animate         : false,
                          localMode      : false,
                          bufferPx        : 40,
                          errorCallback   : function(){}
                        },
        loadingImg    : undefined,
        loadingMsg    : undefined,
        container     : undefined,
        currPage      : 1,
        currDOMChunk  : null,  // defined in setup()'s load()
        isDuringAjax  : false,
        isInvalidPage : false,
        isDone        : false  // for when it goes all the way through the archive.
  };

})(jQuery);


code:
# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-06-08 18:20+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=CHARSET\n"
"Content-Transfer-Encoding: 8bit\n"

#. TRANS: Plugin dscription.
#: InfiniteScrollPlugin.php:54
msgid ""
"Infinite Scroll adds the following functionality to your StatusNet "
"installation: When a user scrolls towards the bottom of the page, the next "
"page of notices is automatically retrieved and appended. This means they "
"never need to click \"Next Page\", which dramatically increases stickiness."
msgstr ""


code:
# Translation file for GNU social - the free software social networking platform
# Copyright (C) 2015 - 2019 Free Software Foundation, Inc http://www.fsf.org
# This file is under https://www.gnu.org/licenses/agpl v3 or later
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: GNU social\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2015-02-02 17:47+0100\n"
"PO-Revision-Date: 2015-02-06 16:29+0000\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: Afrikaans (http://www.transifex.com/gnu-social/gnu-social/language/af/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: af\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#. TRANS: Plugin dscription.
#: InfiniteScrollPlugin.php:60
msgid ""
"Infinite Scroll adds the following functionality to your StatusNet "
"installation: When a user scrolls towards the bottom of the page, the next "
"page of notices is automatically retrieved and appended. This means they "
"never need to click \"Next Page\", which dramatically increases stickiness."
msgstr ""