/**

RhodeCode JS Files

**/

if (typeof console == "undefined" || typeof console.log == "undefined"){

    console = { log: function() {} }

}

var str_repeat = function(i, m) {

    for (var o = []; m > 0; o[--m] = i);

    return o.join('');

};

/**

 * INJECT .format function into String

 * Usage: "My name is {0} {1}".format("Johny","Bravo")

 * Return "My name is Johny Bravo"

 * Inspired by https://gist.github.com/1049426

 */

String.prototype.format = function() {

      function format() {

        var str = this;

        var len = arguments.length+1;

        var safe = undefined;

        var arg = undefined;

        // For each {0} {1} {n...} replace with the argument in that position.  If

        // the argument is an object or an array it will be stringified to JSON.

        for (var i=0; i < len; arg = arguments[i++]) {

          safe = typeof arg === 'object' ? JSON.stringify(arg) : arg;

          str = str.replace(RegExp('\\{'+(i-1)+'\\}', 'g'), safe);

        }

        return str;

      }

      // Save a reference of what may already exist under the property native.

      // Allows for doing something like: if("".format.native) { /* use native */ }

      format.native = String.prototype.format;

      // Replace the prototype property

      return format;

}();

String.prototype.strip = function(char) {

    if(char === undefined){

        char = '\\s';

    }

    return this.replace(new RegExp('^'+char+'+|'+char+'+$','g'), '');

}

String.prototype.lstrip = function(char) {

    if(char === undefined){

        char = '\\s';

    }

    return this.replace(new RegExp('^'+char+'+'),'');

}

String.prototype.rstrip = function(char) {

    if(char === undefined){

        char = '\\s';

    }

    return this.replace(new RegExp(''+char+'+$'),'');

}

if(!Array.prototype.indexOf) {

    Array.prototype.indexOf = function(needle) {

        for(var i = 0; i < this.length; i++) {

            if(this[i] === needle) {

                return i;

            }

        }

        return -1;

    };

}

// IE(CRAP) doesn't support previousElementSibling

var prevElementSibling = function( el ) {

    if( el.previousElementSibling ) {

        return el.previousElementSibling;

    } else {

        while( el = el.previousSibling ) {

            if( el.nodeType === 1 ) return el;

        }

    }

}

/**

 * SmartColorGenerator

 *

 *usage::

 *  var CG = new ColorGenerator();

 *  var col = CG.getColor(key); //returns array of RGB

 *  'rgb({0})'.format(col.join(',')

 *

 * @returns {ColorGenerator}

 */

var ColorGenerator = function(){

    this.GOLDEN_RATIO = 0.618033988749895;

    this.CURRENT_RATIO = 0.22717784590367374 // this can be random

    this.HSV_1 = 0.75;//saturation

    this.HSV_2 = 0.95;

    this.color;

    this.cacheColorMap = {};

};

ColorGenerator.prototype = {

    getColor:function(key){

        if(this.cacheColorMap[key] !== undefined){

            return this.cacheColorMap[key];

        }

        else{

            this.cacheColorMap[key] = this.generateColor();

            return this.cacheColorMap[key];

        }

    },

    _hsvToRgb:function(h,s,v){

        if (s == 0.0)

            return [v, v, v];

        i = parseInt(h * 6.0)

        f = (h * 6.0) - i

        p = v * (1.0 - s)

        q = v * (1.0 - s * f)

        t = v * (1.0 - s * (1.0 - f))

        i = i % 6

        if (i == 0)

            return [v, t, p]

        if (i == 1)

            return [q, v, p]

        if (i == 2)

            return [p, v, t]

        if (i == 3)

            return [p, q, v]

        if (i == 4)

            return [t, p, v]

        if (i == 5)

            return [v, p, q]

    },

    generateColor:function(){

        this.CURRENT_RATIO = this.CURRENT_RATIO+this.GOLDEN_RATIO;

        this.CURRENT_RATIO = this.CURRENT_RATIO %= 1;

        HSV_tuple = [this.CURRENT_RATIO, this.HSV_1, this.HSV_2]

        RGB_tuple = this._hsvToRgb(HSV_tuple[0],HSV_tuple[1],HSV_tuple[2]);

        function toRgb(v){

            return ""+parseInt(v*256)

        }

        return [toRgb(RGB_tuple[0]),toRgb(RGB_tuple[1]),toRgb(RGB_tuple[2])];

    }

}

/**

 *

 * Usage pyroutes.url('mark_error_fixed',{"error_id":error_id}) // /mark_error_fixed/<error_id>

 */

var pyroutes = (function() {

    // access global map defined in special file pyroutes

    var matchlist = PROUTES_MAP;

    var sprintf = (function() {

        function get_type(variable) {

            return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();

        }

        function str_repeat(input, multiplier) {

            for (var output = []; multiplier > 0; output[--multiplier] = input) {/* do nothing */}

            return output.join('');

        }

        var str_format = function() {

            if (!str_format.cache.hasOwnProperty(arguments[0])) {

                str_format.cache[arguments[0]] = str_format.parse(arguments[0]);

            }

            return str_format.format.call(null, str_format.cache[arguments[0]], arguments);

        };

        str_format.format = function(parse_tree, argv) {

            var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length;

            for (i = 0; i < tree_length; i++) {

                node_type = get_type(parse_tree[i]);

                if (node_type === 'string') {

                    output.push(parse_tree[i]);

                }

                else if (node_type === 'array') {

                    match = parse_tree[i]; // convenience purposes only

                    if (match[2]) { // keyword argument

                        arg = argv[cursor];

                        for (k = 0; k < match[2].length; k++) {

                            if (!arg.hasOwnProperty(match[2][k])) {

                                throw(sprintf('[sprintf] property "%s" does not exist', match[2][k]));

                            }

                            arg = arg[match[2][k]];

                        }

                    }

                    else if (match[1]) { // positional argument (explicit)

                        arg = argv[match[1]];

                    }

                    else { // positional argument (implicit)

                        arg = argv[cursor++];

                    }

                    if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) {

                        throw(sprintf('[sprintf] expecting number but found %s', get_type(arg)));

                    }

                    switch (match[8]) {

                        case 'b': arg = arg.toString(2); break;

                        case 'c': arg = String.fromCharCode(arg); break;

                        case 'd': arg = parseInt(arg, 10); break;

                        case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break;

                        case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break;

                        case 'o': arg = arg.toString(8); break;

                        case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break;

                        case 'u': arg = Math.abs(arg); break;

                        case 'x': arg = arg.toString(16); break;

                        case 'X': arg = arg.toString(16).toUpperCase(); break;

                    }

                    arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg);

                    pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' ';

                    pad_length = match[6] - String(arg).length;

                    pad = match[6] ? str_repeat(pad_character, pad_length) : '';

                    output.push(match[5] ? arg + pad : pad + arg);

                }

            }

            return output.join('');

        };

        str_format.cache = {};

        str_format.parse = function(fmt) {

            var _fmt = fmt, match = [], parse_tree = [], arg_names = 0;

            while (_fmt) {

                if ((match = /^[^\x25]+/.exec(_fmt)) !== null) {

                    parse_tree.push(match[0]);

                }

                else if ((match = /^\x25{2}/.exec(_fmt)) !== null) {

                    parse_tree.push('%');

                }

                else if ((match = /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(_fmt)) !== null) {

                    if (match[2]) {

                        arg_names |= 1;

                        var field_list = [], replacement_field = match[2], field_match = [];

                        if ((field_match = /^([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {

                            field_list.push(field_match[1]);

                            while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {

                                if ((field_match = /^\.([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {

                                    field_list.push(field_match[1]);

                                }

                                else if ((field_match = /^\[(\d+)\]/.exec(replacement_field)) !== null) {

                                    field_list.push(field_match[1]);

                                }

                                else {

                                    throw('[sprintf] huh?');

                                }

                            }

                        }

                        else {

                            throw('[sprintf] huh?');

                        }

                        match[2] = field_list;

                    }

                    else {

                        arg_names |= 2;

                    }

                    if (arg_names === 3) {

                        throw('[sprintf] mixing positional and named placeholders is not (yet) supported');

                    }

                    parse_tree.push(match);

                }

                else {

                    throw('[sprintf] huh?');

                }

                _fmt = _fmt.substring(match[0].length);

            }

            return parse_tree;

        };

        return str_format;

    })();

    var vsprintf = function(fmt, argv) {

        argv.unshift(fmt);

        return sprintf.apply(null, argv);

    };

    return {

        'url': function(route_name, params) {

            var result = route_name;

            if (typeof(params) != 'object'){

                params = {};

            }

            if (matchlist.hasOwnProperty(route_name)) {

                var route = matchlist[route_name];

                // param substitution

                for(var i=0; i < route[1].length; i++) {

                   if (!params.hasOwnProperty(route[1][i]))

                        throw new Error(route[1][i] + ' missing in "' + route_name + '" route generation');

                }

                result = sprintf(route[0], params);

                var ret = [];

                //extra params => GET

                for(param in params){

                    if (route[1].indexOf(param) == -1){

                        ret.push(encodeURIComponent(param) + "=" + encodeURIComponent(params[param]));

                    }

                }

                var _parts = ret.join("&");

                if(_parts){

                    result = result +'?'+ _parts

                }

            }

            return result;

        },

        'register': function(route_name, route_tmpl, req_params) {

            if (typeof(req_params) != 'object') {

                req_params = [];

            }

            //fix escape

            route_tmpl = unescape(route_tmpl);

            keys = [];

            for (o in req_params){

                keys.push(req_params[o])

            }

            matchlist[route_name] = [

                route_tmpl,

                keys

            ]

        },

        '_routes': function(){

            return matchlist;

        }

    }

})();

/**

 * GLOBAL YUI Shortcuts

 */

var YUC = YAHOO.util.Connect;

var YUD = YAHOO.util.Dom;

var YUE = YAHOO.util.Event;

var YUQ = YAHOO.util.Selector.query;

// defines if push state is enabled for this browser ?

var push_state_enabled = Boolean(

        window.history && window.history.pushState && window.history.replaceState

        && !(   /* disable for versions of iOS before version 4.3 (8F190) */

                (/ Mobile\/([1-7][a-z]|(8([abcde]|f(1[0-8]))))/i).test(navigator.userAgent)

                /* disable for the mercury iOS browser, or at least older versions of the webkit engine */

                || (/AppleWebKit\/5([0-2]|3[0-2])/i).test(navigator.userAgent)

        )

);

var _run_callbacks = function(callbacks){

    if (callbacks !== undefined){

        var _l = callbacks.length;

        for (var i=0;i<_l;i++){

            var func = callbacks[i];

            if(typeof(func)=='function'){

                try{

                    func();

                }catch (err){};

            }

        }

    }

}

/**

 * turns objects into GET query string

 */

var toQueryString = function(o) {

    if(typeof o !== 'object') {

        return false;

    }

    var _p, _qs = [];

    for(_p in o) {

        _qs.push(encodeURIComponent(_p) + '=' + encodeURIComponent(o[_p]));

    }

    return _qs.join('&');

};

/**

 * Partial Ajax Implementation

 *

 * @param url: defines url to make partial request

 * @param container: defines id of container to input partial result

 * @param s_call: success callback function that takes o as arg

 *  o.tId

 *  o.status

 *  o.statusText

 *  o.getResponseHeader[ ]

 *  o.getAllResponseHeaders

 *  o.responseText

 *  o.responseXML

 *  o.argument

 * @param f_call: failure callback

 * @param args arguments

 */

function ypjax(url,container,s_call,f_call,args){

    var method='GET';

    if(args===undefined){

        args=null;

    }

    // Set special header for partial ajax == HTTP_X_PARTIAL_XHR

    YUC.initHeader('X-PARTIAL-XHR',true);

    // wrapper of passed callback

    var s_wrapper = (function(o){

        return function(o){

            YUD.get(container).innerHTML=o.responseText;

            YUD.setStyle(container,'opacity','1.0');

            //execute the given original callback

            if (s_call !== undefined){

                s_call(o);

            }

        }

    })()

    YUD.setStyle(container,'opacity','0.3');

    YUC.asyncRequest(method,url,{

        success:s_wrapper,

        failure:function(o){

            console.log(o);

            YUD.get(container).innerHTML='<span class="error_red">ERROR: {0}</span>'.format(o.status);

            YUD.setStyle(container,'opacity','1.0');

        },

        cache:false

    },args);

};

var ajaxGET = function(url,success) {

    // Set special header for ajax == HTTP_X_PARTIAL_XHR

    YUC.initHeader('X-PARTIAL-XHR',true);

    var sUrl = url;

    var callback = {

        success: success,

        failure: function (o) {

            if (o.status != 0) {

                alert("error: " + o.statusText);

            };

        },

    };

    var request = YAHOO.util.Connect.asyncRequest('GET', sUrl, callback);

    return request;

};

var ajaxPOST = function(url,postData,success) {

    // Set special header for ajax == HTTP_X_PARTIAL_XHR

    YUC.initHeader('X-PARTIAL-XHR',true);

    var sUrl = url;

    var callback = {

        success: success,

        failure: function (o) {

            alert("error");

        },

    };

    var postData = toQueryString(postData);

    var request = YAHOO.util.Connect.asyncRequest('POST', sUrl, callback, postData);

    return request;

};

/**

 * tooltip activate

 */

var tooltip_activate = function(){

    yt = YAHOO.yuitip.main;

    YUE.onDOMReady(yt.init);

};

/**

 * show more

 */

var show_more_event = function(){

    YUE.on(YUD.getElementsByClassName('show_more'),'click',function(e){

        var el = e.target;

        YUD.setStyle(YUD.get(el.id.substring(1)),'display','');

        YUD.setStyle(el.parentNode,'display','none');

    });

};

/**

 * show changeset tooltip

 */

var show_changeset_tooltip = function(){

    YUE.on(YUD.getElementsByClassName('lazy-cs'), 'mouseover', function(e){

        var target = e.currentTarget;

        var rid = YUD.getAttribute(target,'raw_id');

        var repo_name = YUD.getAttribute(target,'repo_name');

        var ttid = 'tt-'+rid;

        var success = function(o){

            var json = JSON.parse(o.responseText);

            YUD.addClass(target,'tooltip')

            YUD.setAttribute(target, 'title',json['message']);

            YAHOO.yuitip.main.show_yuitip(e, target);

        }

        if(rid && !YUD.hasClass(target, 'tooltip')){

            YUD.setAttribute(target,'id',ttid);

            YUD.setAttribute(target, 'title',_TM['loading ...']);

            YAHOO.yuitip.main.set_listeners(target);

            YAHOO.yuitip.main.show_yuitip(e, target);

            var url = pyroutes.url('changeset_info', {"repo_name":repo_name, "revision": rid});

            ajaxGET(url, success)

        }

    });

};

var onSuccessFollow = function(target){

    var f = YUD.get(target);

    var f_cnt = YUD.get('current_followers_count');

    if(YUD.hasClass(f, 'follow')){

        f.setAttribute('class','following');

        f.setAttribute('title',_TM['Stop following this repository']);

        if(f_cnt){

            var cnt = Number(f_cnt.innerHTML)+1;

            f_cnt.innerHTML = cnt;

        }

    }

    else{

        f.setAttribute('class','follow');

        f.setAttribute('title',_TM['Start following this repository']);

        if(f_cnt){

            var cnt = Number(f_cnt.innerHTML)-1;

            f_cnt.innerHTML = cnt;

        }

    }

}

var toggleFollowingUser = function(target,fallows_user_id,token,user_id){

    args = 'follows_user_id='+fallows_user_id;

    args+= '&auth_token='+token;

    if(user_id != undefined){

        args+="&user_id="+user_id;

    }

    YUC.asyncRequest('POST',TOGGLE_FOLLOW_URL,{

        success:function(o){

            onSuccessFollow(target);

        }

    },args);

    return false;

}

var toggleFollowingRepo = function(target,fallows_repo_id,token,user_id){

    args = 'follows_repo_id='+fallows_repo_id;

    args+= '&auth_token='+token;

    if(user_id != undefined){

        args+="&user_id="+user_id;

    }

    YUC.asyncRequest('POST',TOGGLE_FOLLOW_URL,{

        success:function(o){

            onSuccessFollow(target);

        }

    },args);

    return false;

}

var showRepoSize = function(target, repo_name, token){

    var args= 'auth_token='+token;

    if(!YUD.hasClass(target, 'loaded')){

        YUD.get(target).innerHTML = _TM['Loading ...'];

        var url = pyroutes.url('repo_size', {"repo_name":repo_name});

        YUC.asyncRequest('POST',url,{

            success:function(o){

                YUD.get(target).innerHTML = JSON.parse(o.responseText);

                YUD.addClass(target, 'loaded');

            }

        },args);

    }

    return false;

}

/**

 * TOOLTIP IMPL.

 */

YAHOO.namespace('yuitip');

YAHOO.yuitip.main = {

    $:          YAHOO.util.Dom.get,

    bgColor:    '#000',

    speed:      0.3,

    opacity:    0.9,

    offset:     [15,15],

    useAnim:    false,

    maxWidth:   600,

    add_links:  false,

    yuitips:    [],

    set_listeners: function(tt){

        YUE.on(tt, 'mouseover', yt.show_yuitip,  tt);

        YUE.on(tt, 'mousemove', yt.move_yuitip,  tt);

        YUE.on(tt, 'mouseout',  yt.close_yuitip, tt);

    },

    init: function(){

        yt.tipBox = yt.$('tip-box');

        if(!yt.tipBox){

            yt.tipBox = document.createElement('div');

            document.body.appendChild(yt.tipBox);

            yt.tipBox.id = 'tip-box';

        }

        YUD.setStyle(yt.tipBox, 'display', 'none');

        YUD.setStyle(yt.tipBox, 'position', 'absolute');

        if(yt.maxWidth !== null){

            YUD.setStyle(yt.tipBox, 'max-width', yt.maxWidth+'px');

        }

        var yuitips = YUD.getElementsByClassName('tooltip');

        if(yt.add_links === true){

            var links = document.getElementsByTagName('a');

            var linkLen = links.length;

            for(i=0;i<linkLen;i++){

                yuitips.push(links[i]);

            }

        }

        var yuiLen = yuitips.length;

        for(i=0;i<yuiLen;i++){

            yt.set_listeners(yuitips[i]);

        }

    },

    show_yuitip: function(e, el){

        YUE.stopEvent(e);

        if(el.tagName.toLowerCase() === 'img'){

            yt.tipText = el.alt ? el.alt : '';

        } else {

            yt.tipText = el.title ? el.title : '';

        }

        if(yt.tipText !== ''){

            // save org title

            YUD.setAttribute(el, 'tt_title', yt.tipText);

            // reset title to not show org tooltips

            YUD.setAttribute(el, 'title', '');

            yt.tipBox.innerHTML = yt.tipText;

            YUD.setStyle(yt.tipBox, 'display', 'block');

            if(yt.useAnim === true){

                YUD.setStyle(yt.tipBox, 'opacity', '0');

                var newAnim = new YAHOO.util.Anim(yt.tipBox,

                    {

                        opacity: { to: yt.opacity }

                    }, yt.speed, YAHOO.util.Easing.easeOut

                );

                newAnim.animate();

            }

        }

    },

    move_yuitip: function(e, el){

        YUE.stopEvent(e);

        var movePos = YUE.getXY(e);

        YUD.setStyle(yt.tipBox, 'top', (movePos[1] + yt.offset[1]) + 'px');

        YUD.setStyle(yt.tipBox, 'left', (movePos[0] + yt.offset[0]) + 'px');

    },

    close_yuitip: function(e, el){

        YUE.stopEvent(e);

        if(yt.useAnim === true){

            var newAnim = new YAHOO.util.Anim(yt.tipBox,

                {

                    opacity: { to: 0 }

                }, yt.speed, YAHOO.util.Easing.easeOut

            );

            newAnim.animate();

        } else {

            YUD.setStyle(yt.tipBox, 'display', 'none');

        }

        YUD.setAttribute(el,'title', YUD.getAttribute(el, 'tt_title'));

    }

}

/**

 * Quick filter widget

 *

 * @param target: filter input target

 * @param nodes: list of nodes in html we want to filter.

 * @param display_element function that takes current node from nodes and

 *    does hide or show based on the node

 *

 */

var q_filter = function(target,nodes,display_element){

    var nodes = nodes;

    var q_filter_field = YUD.get(target);

    var F = YAHOO.namespace(target);

    YUE.on(q_filter_field,'keyup',function(e){

        clearTimeout(F.filterTimeout);

        F.filterTimeout = setTimeout(F.updateFilter,600);

    });

    F.filterTimeout = null;

    var show_node = function(node){

        YUD.setStyle(node,'display','')

    }

    var hide_node = function(node){

        YUD.setStyle(node,'display','none');

    }

    F.updateFilter  = function() {

       // Reset timeout

       F.filterTimeout = null;

       var obsolete = [];

       var req = q_filter_field.value.toLowerCase();

       var l = nodes.length;

       var i;

       var showing = 0;

       for (i=0;i<l;i++ ){

           var n = nodes[i];

           var target_element = display_element(n)

           if(req && n.innerHTML.toLowerCase().indexOf(req) == -1){

               hide_node(target_element);

           }

           else{

               show_node(target_element);

               showing+=1;

           }

       }

       // if repo_count is set update the number

       var cnt = YUD.get('repo_count');

       if(cnt){

           YUD.get('repo_count').innerHTML = showing;

       }

    }

};

var tableTr = function(cls, body){

    var _el = document.createElement('div');

    var cont = new YAHOO.util.Element(body);

    var comment_id = fromHTML(body).children[0].id.split('comment-')[1];

    var id = 'comment-tr-{0}'.format(comment_id);

    var _html = ('<table><tbody><tr id="{0}" class="{1}">'+

                  '<td class="lineno-inline new-inline"></td>'+

                  '<td class="lineno-inline old-inline"></td>'+

                  '<td>{2}</td>'+

                 '</tr></tbody></table>').format(id, cls, body);

    _el.innerHTML = _html;

    return _el.children[0].children[0].children[0];

};

/** comments **/

var removeInlineForm = function(form) {

    form.parentNode.removeChild(form);

};

var createInlineForm = function(parent_tr, f_path, line) {

    var tmpl = YUD.get('comment-inline-form-template').innerHTML;

    tmpl = tmpl.format(f_path, line);

    var form = tableTr('comment-form-inline',tmpl)

    // create event for hide button

    form = new YAHOO.util.Element(form);

    var form_hide_button = new YAHOO.util.Element(YUD.getElementsByClassName('hide-inline-form',null,form)[0]);

    form_hide_button.on('click', function(e) {

        var newtr = e.currentTarget.parentNode.parentNode.parentNode.parentNode.parentNode;

        if(YUD.hasClass(newtr.nextElementSibling,'inline-comments-button')){

            YUD.setStyle(newtr.nextElementSibling,'display','');

        }

        removeInlineForm(newtr);

        YUD.removeClass(parent_tr, 'form-open');

        YUD.removeClass(parent_tr, 'hl-comment');

    });

    return form

};

/**

 * Inject inline comment for on given TR this tr should be always an .line

 * tr containing the line. Code will detect comment, and always put the comment

 * block at the very bottom

 */

var injectInlineForm = function(tr){

      if(!YUD.hasClass(tr, 'line')){

          return

      }

      var submit_url = AJAX_COMMENT_URL;

      var _td = YUD.getElementsByClassName('code',null,tr)[0];

      if(YUD.hasClass(tr,'form-open') || YUD.hasClass(tr,'context') || YUD.hasClass(_td,'no-comment')){

          return

      }

      YUD.addClass(tr,'form-open');

      YUD.addClass(tr,'hl-comment');

      var node = YUD.getElementsByClassName('full_f_path',null,tr.parentNode.parentNode.parentNode)[0];

      var f_path = YUD.getAttribute(node,'path');

      var lineno = getLineNo(tr);

      var form = createInlineForm(tr, f_path, lineno, submit_url);

      var parent = tr;

      while (1){

          var n = parent.nextElementSibling;

          // next element are comments !

          if(YUD.hasClass(n,'inline-comments')){

              parent = n;

          }

          else{

              break;

          }

      }

      YUD.insertAfter(form,parent);

      var f = YUD.get(form);

      var overlay = YUD.getElementsByClassName('overlay',null,f)[0];

      var _form = YUD.getElementsByClassName('inline-form',null,f)[0];

      YUE.on(YUD.get(_form), 'submit',function(e){

          YUE.preventDefault(e);

          //ajax submit

          var text = YUD.get('text_'+lineno).value;

          var postData = {

                'text':text,

                'f_path':f_path,

                'line':lineno

          };

          if(lineno === undefined){

              alert('missing line !');

              return

          }

          if(f_path === undefined){

              alert('missing file path !');

              return

          }

          if(text == ""){

              return

          }

          var success = function(o){

              YUD.removeClass(tr, 'form-open');

              removeInlineForm(f);

              var json_data = JSON.parse(o.responseText);

              renderInlineComment(json_data);

          };

          if (YUD.hasClass(overlay,'overlay')){

              var w = _form.offsetWidth;

              var h = _form.offsetHeight;

              YUD.setStyle(overlay,'width',w+'px');

              YUD.setStyle(overlay,'height',h+'px');

          }

          YUD.addClass(overlay, 'submitting');

          ajaxPOST(submit_url, postData, success);

      });

      YUE.on('preview-btn_'+lineno, 'click', function(e){

           var _text = YUD.get('text_'+lineno).value;

           if(!_text){

               return

           }