GazeTK

/*! jQuery UI Virtual Keyboard v1.26.4 *//*

Author: Jeremy Satterfield

Maintained: Rob Garrison (Mottie on github)

Licensed under the MIT License

An on-screen virtual keyboard embedded within the browser window which

will popup when a specified entry field is focused. The user can then

type and preview their input before Accepting or Canceling.

This plugin adds default class names to match jQuery UI theme styling.

Bootstrap & custom themes may also be applied - See

https://github.com/Mottie/Keyboard#themes

Requires:

    jQuery v1.4.3+

    Caret plugin (included)

Optional:

    jQuery UI (position utility only) & CSS theme

    jQuery mousewheel

Setup/Usage:

    Please refer to https://github.com/Mottie/Keyboard/wiki

-----------------------------------------

Caret code modified from jquery.caret.1.02.js

Licensed under the MIT License:

http://www.opensource.org/licenses/mit-license.php

-----------------------------------------

*/

/*jshint browser:true, jquery:true, unused:false */

/*global require:false, define:false, module:false */

;(function (factory) {

    if (typeof define === 'function' && define.amd) {

        define(['jquery'], factory);

    } else if (typeof module === 'object' && typeof module.exports === 'object') {

        module.exports = factory(require('jquery'));

    } else {

        factory(jQuery);

    }

}(function ($) {

    'use strict';

    var $keyboard = $.keyboard = function (el, options) {

    var o, base = this;

    base.version = '1.26.4';

    // Access to jQuery and DOM versions of element

    base.$el = $(el);

    base.el = el;

    // Add a reverse reference to the DOM object

    base.$el.data('keyboard', base);

    base.init = function () {

        var k, position, tmp,

            kbcss = $keyboard.css,

            kbevents = $keyboard.events;

        base.settings = options || {};

        // shallow copy position to prevent performance issues; see #357

        if (options && options.position) {

            position = $.extend({}, options.position);

            options.position = null;

        }

        base.options = o = $.extend(true, {}, $keyboard.defaultOptions, options);

        if (position) {

            o.position = position;

            options.position = position;

        }

        // keyboard is active (not destroyed);

        base.el.active = true;

        // unique keyboard namespace

        base.namespace = '.keyboard' + Math.random().toString(16).slice(2);

        // extension namespaces added here (to unbind listeners on base.$el upon destroy)

        base.extensionNamespace = [];

        // Shift and Alt key toggles, sets is true if a layout has more than one keyset

        // used for mousewheel message

        base.shiftActive = base.altActive = base.metaActive = base.sets = base.capsLock = false;

        // Class names of the basic key set - meta keysets are handled by the keyname

        base.rows = ['', '-shift', '-alt', '-alt-shift'];

        base.inPlaceholder = base.$el.attr('placeholder') || '';

        // html 5 placeholder/watermark

        base.watermark = $keyboard.watermark && base.inPlaceholder !== '';

        // convert mouse repeater rate (characters per second) into a time in milliseconds.

        base.repeatTime = 1000 / (o.repeatRate || 20);

        // delay in ms to prevent mousedown & touchstart from both firing events at the same time

        o.preventDoubleEventTime = o.preventDoubleEventTime || 100;

        // flag indication that a keyboard is open

        base.isOpen = false;

        // is mousewheel plugin loaded?

        base.wheel = $.isFunction($.fn.mousewheel);

        // special character in regex that need to be escaped

        base.escapeRegex = /[-\/\\^$*+?.()|[\]{}]/g;

        // keyCode of keys always allowed to be typed

        k = $keyboard.keyCodes;

        // base.alwaysAllowed = [20,33,34,35,36,37,38,39,40,45,46];

        base.alwaysAllowed = [

            k.capsLock,

            k.pageUp,

            k.pageDown,

            k.end,

            k.home,

            k.left,

            k.up,

            k.right,

            k.down,

            k.insert,

            k.delete

        ];

        base.$keyboard = [];

        // keyboard enabled; set to false on destroy

        base.enabled = true;

        // make a copy of the original keyboard position

        if (!$.isEmptyObject(o.position)) {

            o.position.orig_at = o.position.at;

        }

        base.checkCaret = (o.lockInput || $keyboard.checkCaretSupport());

        base.last = {

            start: 0,

            end: 0,

            key: '',

            val: '',

            preVal: '',

            layout: '',

            virtual: true,

            keyset: [false, false, false], // [shift, alt, meta]

            wheel_$Keys: null,

            wheelIndex: 0,

            wheelLayers: []

        };

        // used when building the keyboard - [keyset element, row, index]

        base.temp = ['', 0, 0];

        // Callbacks

        $.each([

            kbevents.kbInit,

            kbevents.kbBeforeVisible,

            kbevents.kbVisible,

            kbevents.kbHidden,

            kbevents.inputCanceled,

            kbevents.inputAccepted,

            kbevents.kbBeforeClose,

            kbevents.inputRestricted

        ], function (i, callback) {

            if ($.isFunction(o[callback])) {

                // bind callback functions within options to triggered events

                base.$el.bind(callback + base.namespace + 'callbacks', o[callback]);

            }

        });

        // Close with esc key & clicking outside

        if (o.alwaysOpen) {

            o.stayOpen = true;

        }

        tmp = $(document);

        if (base.el.ownerDocument !== document) {

            tmp = tmp.add(base.el.ownerDocument);

        }

        var bindings = 'keyup checkkeyboard mousedown touchstart ';

        if (o.closeByClickEvent) {

            bindings += 'click ';

        }

        tmp.bind(bindings.split(' ').join(base.namespace + ' '), base.checkClose);

        // Display keyboard on focus

        base.$el

            .addClass(kbcss.input + ' ' + o.css.input)

            .attr({

                'aria-haspopup': 'true',

                'role': 'textbox'

            });

        // set lockInput if the element is readonly; or make the element readonly if lockInput is set

        if (o.lockInput || base.el.readOnly) {

            o.lockInput = true;

            base.$el

                .addClass(kbcss.locked)

                .attr({

                    'readonly': 'readonly'

                });

        }

        // add disabled/readonly class - dynamically updated on reveal

        if (base.$el.is(':disabled') || (base.$el.attr('readonly') &&

                !base.$el.hasClass(kbcss.locked))) {

            base.$el.addClass(kbcss.noKeyboard);

        }

        if (o.openOn) {

            base.bindFocus();

        }

        // Add placeholder if not supported by the browser

        if (!base.watermark && base.$el.val() === '' && base.inPlaceholder !== '' &&

            base.$el.attr('placeholder') !== '') {

            base.$el

                .addClass(kbcss.placeholder) // css watermark style (darker text)

                .val(base.inPlaceholder);

        }

        base.$el.trigger(kbevents.kbInit, [base, base.el]);

        // initialized with keyboard open

        if (o.alwaysOpen) {

            base.reveal();

        }

    };

    base.toggle = function () {

        var $toggle = base.$keyboard.find('.' + $keyboard.css.keyToggle),

            locked = !base.enabled;

        // prevent physical keyboard from working

        base.$preview.prop('readonly', locked || base.options.lockInput);

        // disable all buttons

        base.$keyboard

            .toggleClass($keyboard.css.keyDisabled, locked)

            .find('.' + $keyboard.css.keyButton)

            .not($toggle)

            .prop('disabled', locked)

            .attr('aria-disabled', locked);

        $toggle.toggleClass($keyboard.css.keyDisabled, locked);

        // stop auto typing

        if (locked && base.typing_options) {

            base.typing_options.text = '';

        }

    };

    base.setCurrent = function () {

        var kbcss = $keyboard.css,

            // close any "isCurrent" keyboard (just in case they are always open)

            $current = $('.' + kbcss.isCurrent),

            kb = $current.data('keyboard');

        // close keyboard, if not self

        if (!$.isEmptyObject(kb) && kb.el !== base.el) {

            kb.close(kb.options.autoAccept ? 'true' : false);

        }

        $current.removeClass(kbcss.isCurrent);

        // ui-keyboard-has-focus is applied in case multiple keyboards have

        // alwaysOpen = true and are stacked

        $('.' + kbcss.hasFocus).removeClass(kbcss.hasFocus);

        base.$el.addClass(kbcss.isCurrent);

        base.$keyboard.addClass(kbcss.hasFocus);

        base.isCurrent(true);

        base.isOpen = true;

    };

    base.isCurrent = function (set) {

        var cur = $keyboard.currentKeyboard || false;

        if (set) {

            cur = $keyboard.currentKeyboard = base.el;

        } else if (set === false && cur === base.el) {

            cur = $keyboard.currentKeyboard = '';

        }

        return cur === base.el;

    };

    base.isVisible = function () {

        return base.$keyboard && base.$keyboard.length ? base.$keyboard.is(':visible') : false;

    };

    base.focusOn = function () {

        if (!base && base.el.active) {

            // keyboard was destroyed

            return;

        }

        if (!base.isVisible()) {

            clearTimeout(base.timer);

            base.reveal();

        }

    };

    // add redraw method to make API more clear

    base.redraw = function () {

        // update keyboard after a layout change

        if (base.$keyboard.length) {

            base.last.preVal = '' + base.last.val;

            base.last.val = base.$preview && base.$preview.val() || base.$el.val();

            base.$el.val( base.last.val );

            base.removeKeyboard();

            base.shiftActive = base.altActive = base.metaActive = false;

        }

        base.isOpen = o.alwaysOpen;

        base.reveal(true);

    };

    base.reveal = function (redraw) {

        var alreadyOpen = base.isOpen,

            kbcss = $keyboard.css;

        base.opening = !alreadyOpen;

        // remove all 'extra' keyboards by calling close function

        $('.' + kbcss.keyboard).not('.' + kbcss.alwaysOpen).each(function(){

            var kb = $(this).data('keyboard');

            if (!$.isEmptyObject(kb)) {

                kb.close(kb.options.autoAccept && kb.options.autoAcceptOnEsc ? 'true' : false);

            }

        });

        // Don't open if disabled

        if (base.$el.is(':disabled') || (base.$el.attr('readonly') && !base.$el.hasClass(kbcss.locked))) {

            base.$el.addClass(kbcss.noKeyboard);

            return;

        } else {

            base.$el.removeClass(kbcss.noKeyboard);

        }

        // Unbind focus to prevent recursion - openOn may be empty if keyboard is opened externally

        if (o.openOn) {

            base.$el.unbind($.trim((o.openOn + ' ').split(/\s+/).join(base.namespace + ' ')));

        }

        // build keyboard if it doesn't exist; or attach keyboard if it was removed, but not cleared

        if (!base.$keyboard || base.$keyboard &&

            (!base.$keyboard.length || $.contains(document.body, base.$keyboard[0]))) {

            base.startup();

        }

        // clear watermark

        if (!base.watermark && base.el.value === base.inPlaceholder) {

            base.$el

                .removeClass(kbcss.placeholder)

                .val('');

        }

        // save starting content, in case we cancel

        base.originalContent = base.$el.val();

        base.$preview.val(base.originalContent);

        // disable/enable accept button

        if (o.acceptValid) {

            base.checkValid();

        }

        if (o.resetDefault) {

            base.shiftActive = base.altActive = base.metaActive = false;

        }

        base.showSet();

        // beforeVisible event

        if (!base.isVisible()) {

            base.$el.trigger($keyboard.events.kbBeforeVisible, [base, base.el]);

        }

        base.setCurrent();

        // update keyboard - enabled or disabled?

        base.toggle();

        // show keyboard

        base.$keyboard.show();

        // adjust keyboard preview window width - save width so IE won't keep expanding (fix issue #6)

        if (o.usePreview && $keyboard.msie) {

            if (typeof base.width === 'undefined') {

                base.$preview.hide(); // preview is 100% browser width in IE7, so hide the damn thing

                base.width = Math.ceil(base.$keyboard.width()); // set input width to match the widest keyboard row

                base.$preview.show();

            }

            base.$preview.width(base.width);

        }

        base.position = $.isEmptyObject(o.position) ? false : o.position;

        // position after keyboard is visible (required for UI position utility) and appropriately sized

        if ($.ui && $.ui.position && base.position) {

            // get single target position || target stored in element data (multiple targets) || default @ element

            base.position.of = base.position.of || base.$el.data('keyboardPosition') || base.$el;

            base.position.collision = base.position.collision || 'flipfit flipfit';

            o.position.at = o.usePreview ? o.position.orig_at : o.position.at2;

            base.$keyboard.position(base.position);

        }

        base.checkDecimal();

        // get preview area line height

        // add roughly 4px to get line height from font height, works well for font-sizes from 14-36px

        // needed for textareas

        base.lineHeight = parseInt(base.$preview.css('lineHeight'), 10) ||

            parseInt(base.$preview.css('font-size'), 10) + 4;

        if (o.caretToEnd) {

            base.saveCaret(base.originalContent.length, base.originalContent.length);

        }

        // IE caret haxx0rs

        if ($keyboard.allie) {

            // sometimes end = 0 while start is > 0

            if (base.last.end === 0 && base.last.start > 0) {

                base.last.end = base.last.start;

            }

            // IE will have start -1, end of 0 when not focused (see demo: https://jsfiddle.net/Mottie/fgryQ/3/)

            if (base.last.start < 0) {

                // ensure caret is at the end of the text (needed for IE)

                base.last.start = base.last.end = base.originalContent.length;

            }

        }

        if (alreadyOpen || redraw) {

            // restore caret position (userClosed)

            $keyboard.caret(base.$preview, base.last);

            return base;

        }

        // opening keyboard flag; delay allows switching between keyboards without immediately closing

        // the keyboard

        base.timer2 = setTimeout(function () {

            var undef;

            base.opening = false;

            // Number inputs don't support selectionStart and selectionEnd

            // Number/email inputs don't support selectionStart and selectionEnd

            if (!/(number|email)/i.test(base.el.type) && !o.caretToEnd) {

                // caret position is always 0,0 in webkit; and nothing is focused at this point... odd

                // save caret position in the input to transfer it to the preview

                // inside delay to get correct caret position

                base.saveCaret(undef, undef, base.$el);

            }

            if (o.initialFocus) {

                $keyboard.caret(base.$preview, base.last);

            }

            // save event time for keyboards with stayOpen: true

            base.last.eventTime = new Date().getTime();

            base.$el.trigger($keyboard.events.kbVisible, [base, base.el]);

            base.timer = setTimeout(function () {

                // get updated caret information after visible event - fixes #331

                if (base) { // Check if base exists, this is a case when destroy is called, before timers fire

                    base.saveCaret();

                }

            }, 200);

        }, 10);

        // return base to allow chaining in typing extension

        return base;

    };

    base.updateLanguage = function () {

        // change language if layout is named something like 'french-azerty-1'

        var layouts = $keyboard.layouts,

            lang = o.language || layouts[o.layout] && layouts[o.layout].lang &&

                layouts[o.layout].lang || [o.language || 'en'],

            kblang = $keyboard.language;

        // some languages include a dash, e.g. 'en-gb' or 'fr-ca'

        // allow o.language to be a string or array...

        // array is for future expansion where a layout can be set for multiple languages

        lang = ($.isArray(lang) ? lang[0] : lang).split('-')[0];

        // set keyboard language

        o.display = $.extend(true, {},

            kblang.en.display,

            kblang[lang] && kblang[lang].display || {},

            base.settings.display

        );

        o.combos = $.extend(true, {},

            kblang.en.combos,

            kblang[lang] && kblang[lang].combos || {},

            base.settings.combos

        );

        o.wheelMessage = kblang[lang] && kblang[lang].wheelMessage || kblang.en.wheelMessage;

        // rtl can be in the layout or in the language definition; defaults to false

        o.rtl = layouts[o.layout] && layouts[o.layout].rtl || kblang[lang] && kblang[lang].rtl || false;

        // save default regex (in case loading another layout changes it)

        base.regex = kblang[lang] && kblang[lang].comboRegex || $keyboard.comboRegex;

        // determine if US '.' or European ',' system being used

        base.decimal = /^\./.test(o.display.dec);

        base.$el

            .toggleClass('rtl', o.rtl)

            .css('direction', o.rtl ? 'rtl' : '');

    };

    base.startup = function () {

        var kbcss = $keyboard.css;

        // ensure base.$preview is defined; but don't overwrite it if keyboard is always visible

        if (!((o.alwaysOpen || o.userClosed) && base.$preview)) {

            base.makePreview();

        }

        if (!(base.$keyboard && base.$keyboard.length)) {

            // custom layout - create a unique layout name based on the hash

            if (o.layout === 'custom') {

                o.layoutHash = 'custom' + base.customHash();

            }

            base.layout = o.layout === 'custom' ? o.layoutHash : o.layout;

            base.last.layout = base.layout;

            base.updateLanguage();

            if (typeof $keyboard.builtLayouts[base.layout] === 'undefined') {

                if ($.isFunction(o.create)) {

                    // create must call buildKeyboard() function; or create it's own keyboard

                    base.$keyboard = o.create(base);

                } else if (!base.$keyboard.length) {

                    base.buildKeyboard(base.layout, true);

                }

            }

            base.$keyboard = $keyboard.builtLayouts[base.layout].$keyboard.clone();

            base.$keyboard.data('keyboard', base);

            if ((base.el.id || '') !== '') {

                // add ID to keyboard for styling purposes

                base.$keyboard.attr('id', base.el.id + $keyboard.css.idSuffix);

            }

            base.makePreview();

            // build preview display

            if (o.usePreview) {

                // restore original positioning (in case usePreview option is altered)

                if (!$.isEmptyObject(o.position)) {

                    o.position.at = o.position.orig_at;

                }

            } else {

                // No preview display, use element and reposition the keyboard under it.

                if (!$.isEmptyObject(o.position)) {

                    o.position.at = o.position.at2;

                }

            }

        }

        base.$decBtn = base.$keyboard.find('.' + kbcss.keyPrefix + 'dec');

        // add enter to allowed keys; fixes #190

        if (o.enterNavigation || base.el.nodeName === 'TEXTAREA') {

            base.alwaysAllowed.push(13);

        }

        base.bindKeyboard();

        base.$keyboard.appendTo(o.appendLocally ? base.$el.parent() : o.appendTo || 'body');

        base.bindKeys();

        // adjust with window resize; don't check base.position

        // here in case it is changed dynamically

        if (o.reposition && $.ui && $.ui.position && o.appendTo == 'body') {

            $(window).bind('resize' + base.namespace, function () {

                if (base.position && base.isVisible()) {

                    base.$keyboard.position(base.position);

                }

            });

        }

    };

    base.makePreview = function () {

        if (o.usePreview) {

            var indx, attrs, attr, removedAttr,

                kbcss = $keyboard.css;

            base.$preview = base.$el.clone(false)

                .data('keyboard', base)

                .removeClass(kbcss.placeholder + ' ' + kbcss.input)

                .addClass(kbcss.preview + ' ' + o.css.input)

                .attr('tabindex', '-1')

                .show(); // for hidden inputs

            base.preview = base.$preview[0];

            // Switch the number input field to text so the caret positioning will work again

            if (base.preview.type === 'number') {

                base.preview.type = 'text';

            }

            // remove extraneous attributes.

            removedAttr = /^(data-|id|aria-haspopup)/i;

            attrs = base.$preview.get(0).attributes;

            for (indx = attrs.length - 1; indx >= 0; indx--) {

                attr = attrs[indx] && attrs[indx].name;

                if (removedAttr.test(attr)) {

                    // remove data-attributes - see #351

                    base.preview.removeAttribute(attr);

                }

            }

            // build preview container and append preview display

            $('<div />')

                .addClass(kbcss.wrapper)

                .append(base.$preview)

                .prependTo(base.$keyboard);

        } else {

            base.$preview = base.$el;

            base.preview = base.el;

        }

    };

    base.saveCaret = function (start, end, $el) {

        var p = $keyboard.caret($el || base.$preview, start, end);

        base.last.start = typeof start === 'undefined' ? p.start : start;

        base.last.end = typeof end === 'undefined' ? p.end : end;

    };

    base.setScroll = function () {

        // Set scroll so caret & current text is in view

        // needed for virtual keyboard typing, NOT manual typing - fixes #23

        if (base.last.virtual) {

            var scrollWidth, clientWidth, adjustment, direction,

                isTextarea = base.preview.nodeName === 'TEXTAREA',

                value = base.last.val.substring(0, Math.max(base.last.start, base.last.end));

            if (!base.$previewCopy) {

                // clone preview

                base.$previewCopy = base.$preview.clone()

                    .removeAttr('id') // fixes #334

                    .css({

                        position: 'absolute',

                        left: 0,

                        zIndex: -10,

                        visibility: 'hidden'

                    })

                    .addClass($keyboard.css.inputClone);

                if (!isTextarea) {

                    // make input zero-width because we need an accurate scrollWidth

                    base.$previewCopy.css({

                        'white-space': 'pre',

                        'width': 0

                    });

                }

                if (o.usePreview) {

                    // add clone inside of preview wrapper

                    base.$preview.after(base.$previewCopy);

                } else {

                    // just slap that thing in there somewhere

                    base.$keyboard.prepend(base.$previewCopy);

                }

            }

            if (isTextarea) {

                // need the textarea scrollHeight, so set the clone textarea height to be the line height

                base.$previewCopy

                    .height(base.lineHeight)

                    .val(value);

                // set scrollTop for Textarea

                base.preview.scrollTop = base.lineHeight *

                    (Math.floor(base.$previewCopy[0].scrollHeight / base.lineHeight) - 1);

            } else {

                // add non-breaking spaces

                base.$previewCopy.val(value.replace(/\s/g, '\xa0'));

                // if scrollAdjustment option is set to "c" or "center" then center the caret

                adjustment = /c/i.test(o.scrollAdjustment) ? base.preview.clientWidth / 2 : o.scrollAdjustment;

                scrollWidth = base.$previewCopy[0].scrollWidth - 1;

                // set initial state as moving right

                if (typeof base.last.scrollWidth === 'undefined') {

                    base.last.scrollWidth = scrollWidth;

                    base.last.direction = true;

                }

                // if direction = true; we're scrolling to the right

                direction = base.last.scrollWidth === scrollWidth ?

                    base.last.direction :

                    base.last.scrollWidth < scrollWidth;

                clientWidth = base.preview.clientWidth - adjustment;

                // set scrollLeft for inputs; try to mimic the inherit caret positioning + scrolling:

                // hug right while scrolling right...

                if (direction) {

                    if (scrollWidth < clientWidth) {

                        base.preview.scrollLeft = 0;

                    } else {

                        base.preview.scrollLeft = scrollWidth - clientWidth;

                    }

                } else {

                    // hug left while scrolling left...

                    if (scrollWidth >= base.preview.scrollWidth - clientWidth) {

                        base.preview.scrollLeft = base.preview.scrollWidth - adjustment;

                    } else if (scrollWidth - adjustment > 0) {

                        base.preview.scrollLeft = scrollWidth - adjustment;

                    } else {

                        base.preview.scrollLeft = 0;

                    }

                }

                base.last.scrollWidth = scrollWidth;

                base.last.direction = direction;

            }

        }

    };

    base.bindFocus = function () {

        if (o.openOn) {

            // make sure keyboard isn't destroyed

            // Check if base exists, this is a case when destroy is called, before timers have fired

            if (base && base.el.active) {

                base.$el.bind(o.openOn + base.namespace, function () {

                    base.focusOn();

                });

                // remove focus from element (needed for IE since blur doesn't seem to work)

                if ($(':focus')[0] === base.el) {

                    base.$el.blur();

                }

            }

        }

    };

    base.bindKeyboard = function () {

        var evt,

            keyCodes = $keyboard.keyCodes,

            layout = $keyboard.builtLayouts[base.layout];

        base.$preview

            .unbind(base.namespace)

            .bind('click' + base.namespace + ' touchstart' + base.namespace, function () {

                if (o.alwaysOpen && !base.isCurrent()) {

                    base.reveal();

                }

                // update last caret position after user click, use at least 150ms or it doesn't work in IE

                base.timer2 = setTimeout(function () {

                    if (base){

                        base.saveCaret();

                    }

                }, 150);

            })

            .bind('keypress' + base.namespace, function (e) {

                if (o.lockInput || !base.isCurrent()) {

                    return false;

                }

                var k = e.charCode || e.which,

                    // capsLock can only be checked while typing a-z

                    k1 = k >= keyCodes.A && k <= keyCodes.Z,

                    k2 = k >= keyCodes.a && k <= keyCodes.z,

                    str = base.last.key = String.fromCharCode(k);

                base.last.virtual = false;

                base.last.event = e;

                base.last.$key = []; // not a virtual keyboard key

                if (base.checkCaret) {

                    base.saveCaret();

                }

                // update capsLock

                if (k !== keyCodes.capsLock && (k1 || k2)) {

                    base.capsLock = (k1 && !e.shiftKey) || (k2 && e.shiftKey);

                    // if shifted keyset not visible, then show it

                    if (base.capsLock && !base.shiftActive) {

                        base.shiftActive = true;

                        base.showSet();

                    }

                }

                // restrict input - keyCode in keypress special keys:

                // see http://www.asquare.net/javascript/tests/KeyCode.html

                if (o.restrictInput) {

                    // allow navigation keys to work - Chrome doesn't fire a keypress event (8 = bksp)

                    if ((e.which === keyCodes.backSpace || e.which === 0) &&

                        $.inArray(e.keyCode, base.alwaysAllowed)) {

                        return;

                    }

                    // quick key check

                    if ($.inArray(str, layout.acceptedKeys) === -1) {

                        e.preventDefault();

                        // copy event object in case e.preventDefault() breaks when changing the type

                        evt = $.extend({}, e);

                        evt.type = $keyboard.events.inputRestricted;

                        base.$el.trigger(evt, [base, base.el]);

                    }

                } else if ((e.ctrlKey || e.metaKey) &&

                    (e.which === keyCodes.A || e.which === keyCodes.C || e.which === keyCodes.V ||

                        (e.which >= keyCodes.X && e.which <= keyCodes.Z))) {

                    // Allow select all (ctrl-a), copy (ctrl-c), paste (ctrl-v) & cut (ctrl-x) &

                    // redo (ctrl-y)& undo (ctrl-z); meta key for mac

                    return;

                }

                // Mapped Keys - allows typing on a regular keyboard and the mapped key is entered

                // Set up a key in the layout as follows: 'm(a):label'; m = key to map, (a) = actual keyboard key

                // to map to (optional), ':label' = title/tooltip (optional)

                // example: \u0391 or \u0391(A) or \u0391:alpha or \u0391(A):alpha

                if (layout.hasMappedKeys && layout.mappedKeys.hasOwnProperty(str)) {

                    base.last.key = layout.mappedKeys[str];

                    base.insertText(base.last.key);

                    e.preventDefault();

                }

                if (typeof o.beforeInsert === 'function') {

                    base.insertText(base.last.key);

                    e.preventDefault();

                }

                base.checkMaxLength();

            })

            .bind('keyup' + base.namespace, function (e) {

                if (!base.isCurrent()) { return; }

                base.last.virtual = false;

                switch (e.which) {

                    // Insert tab key

                case keyCodes.tab:

                    // Added a flag to prevent from tabbing into an input, keyboard opening, then adding the tab

                    // to the keyboard preview area on keyup. Sadly it still happens if you don't release the tab

                    // key immediately because keydown event auto-repeats

                    if (base.tab && o.tabNavigation && !o.lockInput) {

                        base.shiftActive = e.shiftKey;

                        // when switching inputs, the tab keyaction returns false

                        var notSwitching = $keyboard.keyaction.tab(base);

                        base.tab = false;

                        if (!notSwitching) {

                            return false;

                        }

                    } else {

                        e.preventDefault();

                    }

                    break;

                    // Escape will hide the keyboard

                case keyCodes.escape:

                    if (!o.ignoreEsc) {

                        base.close(o.autoAccept && o.autoAcceptOnEsc ? 'true' : false);

                    }

                    return false;

                }

                // throttle the check combo function because fast typers will have an incorrectly positioned caret

                clearTimeout(base.throttled);

                base.throttled = setTimeout(function () {

                    // fix error in OSX? see issue #102

                    if (base && base.isVisible()) {

                        base.checkCombos();

                    }

                }, 100);

                base.checkMaxLength();

                base.last.preVal = '' + base.last.val;

                base.last.val = base.$preview.val();

                e.type = $keyboard.events.kbChange;

                // base.last.key may be empty string (shift, enter, tab, etc) when keyboard is first visible

                // use e.key instead, if browser supports it

                e.action = base.last.key;

                base.$el.trigger(e, [base, base.el]);

                // change callback is no longer bound to the input element as the callback could be

                // called during an external change event with all the necessary parameters (issue #157)

                if ($.isFunction(o.change)) {

                    e.type = $keyboard.events.inputChange;

                    o.change(e, base, base.el);

                    return false;

                }