<h2>Editing File: /usr/local/cpanel/base/cjt/yuiextras.js</h2><form method='post'><textarea name='content' class='file-edit'>/*
    #                                                 Copyright(c) 2020 cPanel, L.L.C.
    #                                                           All rights reserved.
    # copyright@cpanel.net                                         http://cpanel.net
    # This code is subject to the cPanel license. Unauthorized copying is prohibited
*/

(function(window) {

    &quot;use strict&quot;;

    var YAHOO = window.YAHOO;
    var DOM = YAHOO.util.Dom;
    var EVENT = YAHOO.util.Event;
    var document = window.document;

    // Add a &quot;noscroll&quot; config option: the panel will not scroll with the page.
    // Works by wrapping the panel element in a position:fixed &lt;div&gt;.
    // NOTE: This only works when initializing the panel.
    if ((&quot;YAHOO&quot; in window) &amp;&amp; YAHOO.widget &amp;&amp; YAHOO.widget.Panel) {
        var _old_init = YAHOO.widget.Panel.prototype.init;
        YAHOO.widget.Panel.prototype.init = function(el, userConfig) {
            _old_init.apply(this, arguments);

            this.cfg.addProperty(&quot;noscroll&quot;, {
                value: !!userConfig &amp;&amp; !!userConfig.noscroll
            });
        };

        var _old_initEvents = YAHOO.widget.Panel.prototype.initEvents;
        YAHOO.widget.Panel.prototype.initEvents = function() {
            _old_initEvents.apply(this, arguments);

            this.renderEvent.subscribe(function() {
                if (this.cfg.getProperty(&quot;noscroll&quot;)) {
                    var wrapper_div = document.createElement(&quot;div&quot;);
                    wrapper_div.style.position = &quot;fixed&quot;;

                    var parent_node = this.element.parentNode;
                    parent_node.insertBefore(wrapper_div, this.element);
                    wrapper_div.appendChild(this.element);
                    this.wrapper = wrapper_div;
                }
            });
        };
    }


    // YUI 2's Overlay context property does not factor in margins of either the
    // context element or the overlay element. This change makes it look for a
    // margin on the overlay element (not the context element) and add that to
    // whatever offset may have been passed in.
    // See YUI 3 feature request 25298897.
    if (!YAHOO.widget.Overlay._offset_uses_margin) {
        var Overlay = YAHOO.widget.Overlay;
        var _align = Overlay.prototype.align;
        var _margins_to_check = {};
        _margins_to_check[Overlay.TOP_LEFT] = [&quot;margin-top&quot;, &quot;margin-left&quot;];
        _margins_to_check[Overlay.TOP_RIGHT] = [&quot;margin-top&quot;, &quot;margin-right&quot;];
        _margins_to_check[Overlay.BOTTOM_LEFT] = [&quot;margin-bottom&quot;, &quot;margin-left&quot;];
        _margins_to_check[Overlay.BOTTOM_RIGHT] = [&quot;margin-bottom&quot;, &quot;margin-right&quot;];

        Overlay.prototype.align = function(el_align, context_align, xy_offset) {

            // Most of the time that this is called, we want to query the
            // object itself for these configuration parameters.
            if (!el_align) {
                if (this.cfg) {
                    var this_context = this.cfg.getProperty(&quot;context&quot;);
                    if (this_context) {
                        el_align = this_context[1];

                        if (!context_align) {
                            context_align = this_context[2];
                        }

                        if (!xy_offset) {
                            xy_offset = this_context[4];
                        }
                    }
                }
            }

            if (!el_align) {
                return _align.apply(this, arguments);
            }

            var el = this.element;
            var margins = _margins_to_check[el_align];
            var el_y_offset = parseInt(DOM.getStyle(el, margins[0]), 10) || 0;
            var el_x_offset = parseInt(DOM.getStyle(el, margins[1]), 10) || 0;

            if (el_x_offset) {
                var x_offset_is_negative = (el_align === Overlay.BOTTOM_RIGHT) || (el_align === Overlay.TOP_RIGHT);
                if (x_offset_is_negative) {
                    el_x_offset *= -1;
                }
            }

            if (el_y_offset) {
                var y_offset_is_negative = (el_align === Overlay.BOTTOM_LEFT) || (el_align === Overlay.BOTTOM_RIGHT);
                if (y_offset_is_negative) {
                    el_y_offset *= -1;
                }
            }

            if (el_x_offset || el_y_offset) {
                var new_xy_offset;
                if (xy_offset) {
                    new_xy_offset = [xy_offset[0] + el_x_offset, xy_offset[1] + el_y_offset];
                } else {
                    new_xy_offset = [el_x_offset, el_y_offset];
                }
                return _align.call(this, el_align, context_align, new_xy_offset);
            } else {
                return _align.apply(this, arguments);
            }
        };

        Overlay._offset_uses_margin = true;
    }

    // HTML forms don't usually submit from ENTER unless they have a submit
    // button, which YUI Dialog forms do not have by design. Moreover, they *do*
    // submit if there is just one text field. To smooth out these peculiarities:
    // 1) Add a dummy &lt;input type=&quot;text&quot;&gt; to kill native ENTER submission.
    // 2) Listen for keydown events on a dialog box and run submit() from them.
    if (!YAHOO.widget.Dialog._handles_enter) {
        var _registerForm = YAHOO.widget.Dialog.prototype.registerForm;
        YAHOO.widget.Dialog.prototype.registerForm = function() {
            _registerForm.apply(this, arguments);

            if (!this._cjt_dummy_input) {
                var dummy_input = document.createElement(&quot;input&quot;);
                dummy_input.style.display = &quot;none&quot;;
                this.form.appendChild(dummy_input);
                this._cjt_dummy_input = dummy_input;
            }
        };

        // YUI 2 KeyListener does not make its own copy of the key data object
        // that it receives when the KeyListener is created; as a result, it is
        // possible to alter the listener by changing the key data object after
        // creating the KeyListener. It's also problematic that KeyListener doesn't
        // make that information available to us after creating the listener.
        // We fix both of these issues here.
        var _key_listener = YAHOO.util.KeyListener;
        var new_key_listener = function(attach_to, key_data, handler, event) {
            var new_key_data = {};
            for (var key in key_data) {
                new_key_data[key] = key_data[key];
            }
            this.key_data = new_key_data;

            _key_listener.call(this, attach_to, new_key_data, handler, event);
        };
        YAHOO.lang.extend(new_key_listener, _key_listener);
        YAHOO.lang.augmentObject(new_key_listener, _key_listener); // static properties
        YAHOO.util.KeyListener = new_key_listener;

        // We want all dialog boxes to submit when their form receives ENTER,
        // unless the ENTER went to a &lt;textarea&gt; or &lt;select&gt;.
        // Check for this immediately after init();
        var _init = YAHOO.widget.Dialog.prototype.init;
        var _non_submit = {
            textarea: true,
            select: true
        };
        YAHOO.widget.Dialog.prototype.init = function(el, cfg) {
            var ret = _init.apply(this, arguments);

            var key_listeners = this.cfg.getProperty(&quot;keylisteners&quot;);

            var need_to_add_enter_key_listener = !key_listeners;

            if (key_listeners) {
                if (!(key_listeners instanceof Array)) {
                    key_listeners = [key_listeners];
                }

                need_to_add_enter_key_listener = !key_listeners.some(function(kl) {
                    if (!kl.key_data) {
                        return false;
                    }

                    if (kl.key_data.keys === 13) {
                        return true;
                    }

                    if (kl.key_data.indexOf &amp;&amp; kl.key_data.indexOf(13) !== -1) {
                        return true;
                    }

                    return false;
                });
            } else {
                key_listeners = [];
                need_to_add_enter_key_listener = true;
            }

            if (need_to_add_enter_key_listener) {
                var the_dialog = this;
                key_listeners.push(new YAHOO.util.KeyListener(document.body, {
                    keys: 13
                }, function(type, args) {
                    if (the_dialog.cfg.getProperty(&quot;postmethod&quot;) !== &quot;form&quot;) {
                        var original = EVENT.getTarget(args[1]);
                        if (original &amp;&amp; !_non_submit[original.nodeName.toLowerCase()] &amp;&amp; original.form === the_dialog.form) {
                            the_dialog.submit();
                        }
                    }
                }));

                this.cfg.setProperty(&quot;keylisteners&quot;, key_listeners);
            }

            return ret;
        };

        YAHOO.widget.Dialog._handles_enter = true;
    }

    // Allow YUI Dialog buttons to set &quot;classes&quot; in their definitions
    var _configButtons = YAHOO.widget.Dialog.prototype.configButtons;
    YAHOO.widget.Dialog.prototype.configButtons = function() {
        var ret = _configButtons.apply(this, arguments);

        var button_defs = this.cfg.getProperty(&quot;buttons&quot;);
        if (!button_defs || !button_defs.length) {
            return ret;
        }

        var buttons = this.getButtons();
        if (!buttons.length) {
            return ret;
        }

        var yui_button = YAHOO.widget.Button &amp;&amp; (buttons[0] instanceof YAHOO.widget.Button);

        for (var b = buttons.length - 1; b &gt;= 0; b--) {
            var cur_button = buttons[b];
            var classes = button_defs[b].classes;
            if (classes) {
                if (classes instanceof Array) {
                    classes = classes.join(&quot; &quot;);
                }

                if (yui_button) {
                    cur_button.addClass(classes);
                } else {
                    DOM.addClass(cur_button, classes);
                }
            }
        }

        return ret;
    };


    // http://yuilibrary.com/projects/yui2/ticket/2529451
    //
    // Custom Event: after_hideEvent
    //  This allows us to tell YUI to destroy() a Module once it's hidden.
    //
    // If we're animated, then just execute as the last hideEvent subscriber.
    // If not, then execute immeditaely after hide() is done.
    //
    // We have to do the two cases separately because of the call to
    // cfg.configChangedEvent.fire() immediately after hideEvent.fire() in
    // cfg.setProperty().
    var modpro = YAHOO.widget.Module.prototype;
    var init_ev = modpro.initEvents;
    modpro.initEvents = function() {
        init_ev.apply(this, arguments);
        this.after_hideEvent = this.createEvent(&quot;after_hide&quot;);
        this.after_hideEvent.signature = YAHOO.util.CustomEvent.LIST;
    };
    var hide = modpro.hide;
    modpro.hide = function() {
        var delayed = this.cfg.getProperty(&quot;effect&quot;);
        if (delayed) {
            this.hideEvent.subscribe(function afterward() {
                this.hideEvent.unsubscribe(afterward);
                this.after_hideEvent.fire();
            });
        }
        hide.apply(this, arguments);
        if (!delayed) {
            this.after_hideEvent.fire();
        }
    };

})(window);
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fbase%2Fcjt'>Back to Directory</a>