mobiscroll-rails 2.3.1.0

data/vendor/assets/javascripts/mobiscroll.ios.js

@@ -0,0 +1,14 @@
+(function ($) {
+
+    $.mobiscroll.themes.ios = {
+        defaults: {
+            dateOrder: 'MMdyy',
+            rows: 5,
+            height: 30,
+            width: 55,
+            headerText: false,
+            showLabel: false
+        }
+    }
+
+})(jQuery);

data/vendor/assets/javascripts/mobiscroll.jqm.js

@@ -0,0 +1,30 @@
+(function ($) {
+
+    $.mobiscroll.themes.jqm = {
+        defaults: {
+            jqmBody: 'c',
+            jqmHeader:'b',
+            jqmWheel: 'd',
+            jqmClickPick: 'c',
+            jqmSet: 'b',
+            jqmCancel: 'c'
+        },
+        init: function(elm, inst) {
+            var s = inst.settings;
+            $('.dw', elm).removeClass('dwbg').addClass('ui-overlay-shadow ui-corner-all ui-body-a');
+            $('.dwb-s span', elm).attr('data-role', 'button').attr('data-theme', s.jqmSet);
+            $('.dwb-n span', elm).attr('data-role', 'button').attr('data-theme', s.jqmCancel);
+            $('.dwb-c span', elm).attr('data-role', 'button').attr('data-theme', s.jqmCancel);
+            $('.dwwb', elm).attr('data-role', 'button').attr('data-theme', s.jqmClickPick);
+            $('.dwv', elm).addClass('ui-header ui-bar-' + s.jqmHeader);
+            $('.dwwr', elm).addClass('ui-body-' + s.jqmBody);
+            $('.dwpm .dww', elm).addClass('ui-body-' + s.jqmWheel);
+            if (s.display != 'inline')
+                $('.dw', elm).addClass('pop in');
+            elm.trigger('create');
+            // Hide on overlay click
+            $('.dwo', elm).click(function() { inst.hide(); });
+        }
+    }
+
+})(jQuery);

data/vendor/assets/javascripts/mobiscroll.js

@@ -0,0 +1,18 @@
+//  Core javascript required to use Mobiscroll
+//= require mobiscroll.core
+
+//  Add datetime support
+//= require mobiscroll.datetime
+
+//  Add select support
+//= require mobiscroll.select
+
+//  Add list support
+//= require mobiscroll.list
+
+//  Additional themes
+//= require mobiscroll.android-ics
+//= require mobiscroll.android
+//= require mobiscroll.ios
+//= require mobiscroll.jqm
+//= require mobiscroll.wp

data/vendor/assets/javascripts/mobiscroll.list.js

@@ -0,0 +1,377 @@
+/*jslint eqeq: true, plusplus: true, undef: true, sloppy: true, vars: true, forin: true */
+(function ($) {
+    var ms = $.mobiscroll,
+        defaults = {
+            invalid: [],
+            showInput: true,
+            inputClass: ''
+        },
+        preset =  function (inst) {
+            var s = $.extend({}, defaults, inst.settings),
+                elm = $(this),
+                input,
+                id = this.id + '_dummy',
+                lvl = 0,
+                ilvl = 0,
+                wa = s.wheelArray || createWheelArray(elm),
+                labels = generateLabels(lvl),
+                currWheelVector = [],
+                fwv = firstWheelVector(wa),
+                w = generateWheelsFromVector(fwv, lvl);
+
+            /**
+             * Disables the invalid items on the wheels
+             * @param {Object} dw - the jQuery mobiscroll object
+             * @param {Number} nrWheels - the number of the current wheels
+             * @param {Array} whArray - The wheel array objects containing the wheel tree
+             * @param {Array} whVector - the wheel vector containing the current keys
+             */
+            function setDisabled(dw, nrWheels, whArray, whVector) {
+                var i = 0;
+                while (i < nrWheels) {
+                    var currWh = $('.dwwl' + i, dw),
+                        inv = getInvalidKeys(whVector, i, whArray);
+                    $.each(inv, function (i, v) {
+                        $('li[data-val="' + v + '"]', currWh).removeClass('dw-v');
+                    });
+                    i++;
+                }
+            }
+
+            /**
+             * Returns the invalid keys of one wheel as an array
+             * @param {Array} whVector - the wheel vector used to search for the wheel in the wheel array
+             * @param {Number} index - index of the wheel in the wheel vector, that we are interested in
+             * @param {Array} whArray - the wheel array we are searching in
+             * @return {Array} - list of invalid keys
+             */
+            function getInvalidKeys(whVector, index, whArray) {
+                var i = 0,
+                    whObjA = whArray,
+                    invalids = [];
+
+                while (i < index) {
+                    var ii = whVector[i];
+                    //whObjA = whObjA[ii].children;
+                    for (var n in whObjA) {
+                        if (whObjA[n].key == ii) {
+                            whObjA = whObjA[n].children;
+                            break;
+                        }
+                    }
+                    i++;
+                }
+                i = 0;
+                while (i < whObjA.length) {
+                    if (whObjA[i].invalid) {
+                        invalids.push(whObjA[i].key);
+                    }
+                    i++;
+                }
+                return invalids;
+            }
+
+            /**
+             * Creates a Boolean vector with true values (except one) that can be used as the readonly vector
+             * n - the length of the vector
+             * i - the index of the value that's going to be false
+             */
+            function createROVector(n, i) {
+                var a = [];
+                while (n) {
+                    a[--n] = true;
+                }
+                a[i] = false;
+                return a;
+            }
+
+            /**
+             * Creates a labels vector, from values if they are defined, otherwise from numbers
+             * l - the length of the vector
+             */
+            function generateLabels(l) {
+                var a = [],
+                    i;
+                for (i = 0; i < l; i++) {
+                    a[i] = s.labels && s.labels[i] ? s.labels[i] : i;
+                }
+                return a;
+            }
+
+            /**
+             * Creates the wheel array from the vector provided
+             * wv - wheel vector containing the values that should be selected on the wheels
+             * l - the length of the wheel array
+             */
+            function generateWheelsFromVector(wv, l, index) {
+                var i = 0, j, obj, chInd,
+                    w = [{}],
+                    wtObjA = wa;
+
+                if (l) { // if length is defined we need to generate that many wheels (even if they are empty)
+                    for (j = 0; j < l; j++) {
+                        w[j] = {};
+                        w[j][labels[j]] = {}; // each wheel will have a label generated by the generateLabels method
+                    }
+                }
+                while (i < wv.length) { // we generate the wheels until the length of the wheel vector
+                    w[i] = {};
+                    w[i][labels[i]] = getWheelFromObjA(wtObjA);
+
+                    j = 0;
+                    chInd = undefined;
+
+                    while (j < wtObjA.length && chInd === undefined) {
+                        if (wtObjA[j].key == wv[i] && ((index !== undefined && i <= index) || index === undefined)) {
+                            chInd = j;
+                        }
+                        j++;
+                    }
+
+                    if (chInd !== undefined && wtObjA[chInd].children) {
+                        i++;
+                        wtObjA = wtObjA[chInd].children;
+                    } else if ((obj = getFirstValidItemObjOrInd(wtObjA)) && obj.children) {
+                        i++;
+                        wtObjA = obj.children;
+                    } else {
+                        return w;
+                    }
+                }
+                return w;
+            }
+
+            /**
+             * Returns the first valid Wheel Node Object or its index from a Wheel Node Object Array
+             * getInd - if it is true then the return value is going to be the index, otherwise the object itself
+             */
+            function getFirstValidItemObjOrInd(wtObjA, getInd) {
+                if (!wtObjA) {
+                    return false;
+                }
+
+                var i = 0,
+                    obj;
+
+                while (i < wtObjA.length) {
+                    if (!(obj = wtObjA[i++]).invalid) {
+                        return getInd ? i - 1 : obj;
+                    }
+                }
+                return false;
+            }
+
+            function getWheelFromObjA(objA) {
+                var wheel = {},
+                    j = 0;
+
+                while (j < objA.length) {
+                    wheel[objA[j].key] = objA[j++].value;
+                }
+                return wheel;
+            }
+
+            /**
+             * Hides the last i number of wheels
+             * i - the last number of wheels that has to be hidden
+             */
+            function hideWheels(dw, i) {
+                $('.dwc', dw).css('display', '').slice(i).hide();
+            }
+
+            /**
+             * Generates the first wheel vector from the wheeltree
+             * wt - the wheel tree object
+             * uses the lvl global variable to determine the length of the vector
+             */
+            function firstWheelVector(wa) {
+                var t = [],
+                    ndObjA = wa,
+                    obj,
+                    ok = true,
+                    i = 0;
+
+                while (ok) {
+                    obj = getFirstValidItemObjOrInd(ndObjA);
+                    t[i++] = obj.key;
+                    if (ok = obj.children) {
+                        ndObjA = obj.children;
+                    }
+                }
+                return t;
+            }
+
+            /**
+             * Calculates the level of a wheel vector and the new wheel vector, depending on current wheel vector and the index of the changed wheel
+             * wv - current wheel vector
+             * index - index of the changed wheel
+             */
+            function calcLevelOfVector2(wv, index) {
+                var t = [],
+                    ndObjA = wa,
+                    lvl = 0,
+                    next = false,
+                    i,
+                    childName,
+                    chInd;
+
+                if (wv[lvl] !== undefined && lvl <= index) {
+                    i = 0;
+
+                    childName = wv[lvl];
+                    chInd = undefined;
+
+                    while (i < ndObjA.length && chInd === undefined) {
+                        if (ndObjA[i].key == wv[lvl] && !ndObjA[i].invalid) {
+                            chInd = i;
+                        }
+                        i++;
+                    }
+                } else {
+                    chInd = getFirstValidItemObjOrInd(ndObjA, true);
+                    childName = ndObjA[chInd].key;
+                }
+
+                next = chInd !== undefined ? ndObjA[chInd].children : false;
+
+                t[lvl] = childName;
+
+                while (next) {
+                    ndObjA = ndObjA[chInd].children;
+                    lvl++;
+                    next = false;
+                    chInd = undefined;
+
+                    if (wv[lvl] !== undefined && lvl <= index) {
+                        i = 0;
+
+                        childName = wv[lvl];
+                        chInd = undefined;
+
+                        while (i < ndObjA.length && chInd === undefined) {
+                            if (ndObjA[i].key == wv[lvl] && !ndObjA[i].invalid) {
+                                chInd = i;
+                            }
+                            i++;
+                        }
+                    } else {
+                        chInd = getFirstValidItemObjOrInd(ndObjA, true);
+                        chInd = chInd === false ? undefined : chInd;
+                        childName = ndObjA[chInd].key;
+                    }
+                    next = chInd !== undefined && getFirstValidItemObjOrInd(ndObjA[chInd].children) ? ndObjA[chInd].children : false;
+                    t[lvl] = childName;
+                }
+                return {
+                    lvl: lvl + 1,
+                    nVector: t
+                }; // return the calculated level and the wheel vector as an object
+            }
+
+            function createWheelArray(ul) {
+                var wheelArray = [];
+
+                lvl = lvl > ilvl++ ? lvl : ilvl;
+
+                ul.children('li').each(function (index) {
+                    var that = $(this),
+                        c = that.clone();
+
+                    c.children('ul,ol').remove();
+
+                    var v = c.html().replace(/^\s\s*/, '').replace(/\s\s*$/, ''),
+                        inv = that.data('invalid') ? true : false,
+                        wheelObj = {
+                            key: that.data('val') || index,
+                            value: v,
+                            invalid: inv,
+                            children: null
+                        },
+                        nest = that.children('ul,ol');
+
+                    if (nest.length) {
+                        wheelObj.children = createWheelArray(nest);
+                    }
+
+                    wheelArray.push(wheelObj);
+                });
+
+                ilvl--;
+                return wheelArray;
+            }
+
+            $('#' + id).remove(); // Remove input if exists
+
+            if (s.showInput) {
+                input = $('<input type="text" id="' + id + '" value="" class="' + s.inputClass + '" readonly />').insertBefore(elm);
+                inst.settings.anchor = input; // give the core the input element for the bubble positioning
+
+                if (s.showOnFocus) {
+                    input.focus(function () {
+                        inst.show();
+                    });
+                }
+            }
+
+            if (!s.wheelArray) {
+                elm.hide().closest('.ui-field-contain').trigger('create');
+            }
+
+            return {
+                width: 50,
+                wheels: w,
+                headerText: false,
+                onBeforeShow: function (dw) {
+                    var t = inst.temp;
+                    currWheelVector = inst.temp.slice(0);
+                    inst.settings.wheels = generateWheelsFromVector(t, lvl, lvl);
+                },
+                onSelect: function (v, inst) {
+                    if (input) {
+                        input.val(v);
+                    }
+                },
+                onChange: function (v, inst) {
+                    if (input && s.display == 'inline') {
+                        input.val(v);
+                    }
+                },
+                onClose: function () {
+                    if (input) {
+                        input.blur();
+                    }
+                },
+                onAnimStart: function(index) {
+                    inst.settings.readonly = createROVector(lvl, index);
+                },
+                validate: function (dw, index) {
+                    var t = inst.temp;
+                    if (index !== undefined && currWheelVector[index] != t[index]) {
+                        inst.settings.wheels = generateWheelsFromVector(t, null, index);
+                        var args = [],
+                            i = index,
+                            o = calcLevelOfVector2(t, index);
+                        inst.temp = o.nVector.slice(0);
+                        while (i < o.lvl) {
+                            args.push(i++);
+                        }
+                        hideWheels(dw, o.lvl);
+                        inst.changeWheel(args);
+                        currWheelVector = inst.temp.slice(0);
+                        setDisabled(dw, o.lvl, wa, inst.temp);
+                    } else {
+                        var o = calcLevelOfVector2(t, t.length);
+                        setDisabled(dw, o.lvl, wa, t);
+                        hideWheels(dw, o.lvl);
+                    }
+                    inst.settings.readonly = false;
+                }
+            };
+        };
+
+    $.each(['list', 'image', 'treelist'], function(i, v) {
+        ms.presets[v] = preset;
+        ms.presetShort(v);
+    });
+
+})(jQuery);

data/vendor/assets/javascripts/mobiscroll.select.js

@@ -0,0 +1,257 @@
+/*jslint eqeq: true, plusplus: true, undef: true, sloppy: true, vars: true, forin: true */
+(function ($) {
+
+    var defaults = {
+        inputClass: '',
+        invalid: [],
+        rtl: false,
+        group: false,
+        groupLabel: 'Groups'
+    };
+
+    $.mobiscroll.presetShort('select');
+
+    $.mobiscroll.presets.select = function (inst) {
+        var stg = inst.settings,
+            s = $.extend({}, defaults, stg),
+            elm = $(this),
+            option = elm.val(),
+            group = elm.find('option[value="' + elm.val() + '"]').parent(),
+            prev = group.index() + '',
+            gr = prev,
+            prevent,
+            id = this.id + '_dummy',
+            l1 = $('label[for="' + this.id + '"]').attr('for', id),
+            l2 = $('label[for="' + id + '"]'),
+            label = s.label !== undefined ? s.label : (l2.length ? l2.text() : elm.attr('name')),
+            invalid = [],
+            main = {},
+            grIdx,
+            optIdx,
+            roPre = stg.readonly,
+            w;
+
+        function replace(str) {
+            if (str) {
+                return str.replace(/_/, '');
+            }
+            return '';
+        }
+
+        function genWheels() {
+            var cont,
+                wg = 0,
+                wheel = {},
+                w = [{}];
+
+            if (s.group) {
+                if (s.rtl) {
+                    wg = 1;
+                }
+
+                $('optgroup', elm).each(function (index) {
+                    wheel['_' + index] = $(this).attr('label');
+                });
+
+                w[wg] = {};
+                w[wg][s.groupLabel] = wheel;
+                cont = group;
+                wg += (s.rtl ? -1 : 1);
+
+            } else {
+                cont = elm;
+            }
+            w[wg] = {};
+            w[wg][label] = {};
+
+            $('option', cont).each(function () {
+                var v = $(this).attr('value');
+                w[wg][label]['_' + v] = $(this).text();
+                if ($(this).prop('disabled')) {
+                    invalid.push(v);
+                }
+            });
+
+            return w;
+        }
+
+        // if groups is true and there are no groups fall back to no grouping
+        if (s.group && !$('optgroup', elm).length) {
+            s.group = false;
+        }
+
+        if (!s.invalid.length) {
+            s.invalid = invalid;
+        }
+
+        if (s.group) {
+            if (s.rtl) {
+                grIdx = 1;
+                optIdx = 0;
+            } else {
+                grIdx = 0;
+                optIdx = 1;
+            }
+        } else {
+            grIdx = -1;
+            optIdx = 0;
+        }
+
+        $('#' + id).remove();
+
+        $('option', elm).each(function () {
+            main[$(this).attr('value')] = $(this).text();
+        });
+
+        var input = $('<input type="text" id="' + id + '" value="' + main[elm.val()] + '" class="' + s.inputClass + '" readonly />').insertBefore(elm);
+
+        if (s.showOnFocus) {
+            input.focus(function () {
+                inst.show();
+            });
+        }
+
+        elm.bind('change', function () {
+            if (!prevent && option != elm.val()) {
+                inst.setSelectVal([elm.val()], true);
+            }
+            prevent = false;
+        }).hide().closest('.ui-field-contain').trigger('create');
+
+        inst.setSelectVal = function (d, fill, time) {
+            option = d[0];
+
+            if (s.group) {
+                group = elm.find('option[value="' + option + '"]').parent();
+                gr = group.index();
+                inst.temp = s.rtl ? ['_' + option, '_' + group.index()] : ['_' + group.index(), '_' + option];
+                if (gr !== prev) { // Need to regenerate wheels, if group changed
+                    stg.wheels = genWheels();
+                    inst.changeWheel([optIdx]);
+                    prev = gr + '';
+                }
+            } else {
+                inst.temp = ['_' + option];
+            }
+
+            inst.setValue(true, fill, time);
+
+            // Set input/select values
+            if (fill) {
+                input.val(main[option]);
+                var changed = option !== elm.val();
+                elm.val(option);
+                // Trigger change on element
+                if (changed) {
+                    elm.trigger('change');
+                }
+            }
+        };
+
+        inst.getSelectVal = function (temp) {
+            var val = temp ? inst.temp : inst.values;
+            return replace(val[optIdx]);
+        };
+
+        return {
+            width: 50,
+            wheels: w,
+            headerText: false,
+            anchor: input,
+            formatResult: function (d) {
+                return main[replace(d[optIdx])];
+            },
+            parseValue: function () {
+                option = elm.val();
+                group = elm.find('option[value="' + option + '"]').parent();
+                gr = group.index();
+                return s.group && s.rtl ? ['_' + option, '_' + gr] : s.group ? ['_' + gr, '_' + option] : ['_' + option];
+            },
+            validate: function (dw, i) {
+                if (i === grIdx) {
+                    gr = replace(inst.temp[grIdx]);
+
+                    if (gr !== prev) {
+                        group = elm.find('optgroup').eq(gr);
+                        gr = group.index();
+                        option = group.find('option').eq(0).val();
+                        option = option || elm.val();
+                        stg.wheels = genWheels();
+                        if (s.group) {
+                            inst.temp = s.rtl ? ['_' + option, '_' + gr] : ['_' + gr, '_' + option];
+                            inst.changeWheel([optIdx]);
+                            prev = gr + '';
+                        }
+                    }
+                    stg.readonly = roPre;
+                } else {
+                    option = replace(inst.temp[optIdx]);
+                }
+
+                var t = $('ul', dw).eq(optIdx);
+                $.each(s.invalid, function (i, v) {
+                    $('li[data-val="_' + v + '"]', t).removeClass('dw-v');
+                });
+            },
+            onAnimStart: function(i) {
+                if (i === grIdx) { // If group wheel is scroller, lock the options wheel
+                    stg.readonly = [s.rtl, !s.rtl];
+                }
+            },
+            onBeforeShow: function () {
+                stg.wheels = genWheels();
+                if (s.group) {
+                    inst.temp = s.rtl ? ['_' + option, '_' + group.index()] : ['_' + group.index(), '_' + option];
+                }
+            },
+            onSelect: function (v) {
+                input.val(v);
+                prevent = true;
+                elm.val(replace(inst.values[optIdx])).trigger('change');
+                if (s.group) {
+                    inst.values = null;
+                }
+            },
+            onCancel: function () {
+                if (s.group) {
+                    inst.values = null;
+                }
+            },
+            onChange: function (v) {
+                if (s.display == 'inline') {
+                    input.val(v);
+                    prevent = true;
+                    elm.val(replace(inst.temp[optIdx])).trigger('change');
+                }
+            },
+            onClose: function () {
+                input.blur();
+            },
+            methods: {
+                setValue: function (d, fill, time) {
+                    return this.each(function () {
+                        var inst = $(this).mobiscroll('getInst');
+                        if (inst) {
+                            if (inst.setSelectVal) {
+                                inst.setSelectVal(d, fill, time);
+                            } else {
+                                inst.temp = d;
+                                inst.setValue(true, fill, time);
+                            }
+                        }
+                    });
+                },
+                getValue: function (temp) {
+                    var inst = $(this).mobiscroll('getInst');
+                    if (inst) {
+                        if (inst.getSelectVal) {
+                            return inst.getSelectVal(temp);
+                        }
+                        return inst.values;
+                    }
+                }
+            }
+        };
+    }
+
+})(jQuery);