<|start_filename|>_previo/css/ion.checkRadio.html5.css<|end_filename|>
/* Ion.CheckRadio, Cloudy Skin
// Version 2.0.0
//
// © <NAME>, 2015
// https://github.com/IonDen
// ===================================================================================================================*/

.icr-label {
    padding-right: 2px;
    margin: 0 5px 5px 0;
}

.icr-item {
    width: 18px; height: 18px;
    border: 1px solid #ccc;
}

.icr-item.type_radio {
    -moz-border-radius: 18px;
    border-radius: 18px;
}
.icr-label.checked .type_radio:after {
    position: absolute;
    display: block;
    content: "";
    top: 50%; left: 50%;
    width: 8px; height: 8px;
    margin: -4px 0 0 -4px;
    -moz-border-radius: 8px;
    border-radius: 8px;
    background: #999;
}
.icr-label.focused .icr-item {
    -webkit-box-shadow: 0 0 5px rgba(0, 0, 0, 0.4);
    -moz-box-shadow: 0 0 5px rgba(0, 0, 0, 0.4);
    box-shadow: 0 0 5px rgba(0, 0, 0, 0.4);
}
.lt-ie9 .icr-label.focused .icr-item {
    border-color: #555;
}

.icr-item.type_checkbox {
    -moz-border-radius: 2px;
    border-radius: 2px;
}

.icr-label.checked .type_checkbox:after {
    position: absolute;
    display: block;
    content: "";
    top: 50%; left: 50%;
    width: 4px; height: 12px;
    margin: -6px 0 0 -2px;
    background: #999;

    -webkit-transform-origin: 50% 50%;
    -moz-transform-origin: 50% 50%;
    -o-transform-origin: 50% 50%;
    transform-origin: 50% 50%;

    -webkit-transform: rotate(45deg);
    -moz-transform: rotate(45deg);
    -o-transform: rotate(45deg);
    transform: rotate(45deg);
}

.icr-label.checked .type_checkbox:before {
    position: absolute;
    display: block;
    content: "";
    top: 50%; left: 50%;
    width: 12px; height: 4px;
    margin: -2px 0 0 -6px;
    background: #999;

    -webkit-transform-origin: 50% 50%;
    -moz-transform-origin: 50% 50%;
    -o-transform-origin: 50% 50%;
    transform-origin: 50% 50%;

    -webkit-transform: rotate(45deg);
    -moz-transform: rotate(45deg);
    -o-transform: rotate(45deg);
    transform: rotate(45deg);
}


.icr-label:hover .icr-item, .icr-label.checked .icr-item {
    border-color: #999;
}

.icr-label.checked:hover .icr-item:after, .icr-label.checked:hover .icr-item:before {
    background: #999;
}

.icr-label.disabled.checked:hover .icr-item:after, .icr-label.disabled.checked:hover .icr-item:before {
    background: #ccc;
}


<|start_filename|>_previo/js/ion.checkRadio.js<|end_filename|>
﻿/**
 * Ion.CheckRadio
 * version 2.0.0 Build 42
 * © <NAME>, 2015
 *
 * Project page:    http://ionden.com/a/plugins/ion.CheckRadio/en.html
 * GitHub page:     https://github.com/IonDen/ion.CheckRadio
 *
 * Released under MIT licence:
 * http://ionden.com/a/plugins/licence-en.html
 */

;(function ($, window) {
    "use strict";

    if ($.fn.ionCheckRadio) {
        return;
    }

    if (!String.prototype.trim) {
        (function() {
            var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
            String.prototype.trim = function() {
                return this.replace(rtrim, '');
            };
        })();
    }



    var collection = {},
        instances = {};

    var IonCheckRadio = function (group) {
        this.group = group.content;
        this.type = group.type;
        this.$group = $(this.group);
        this.old = null;
        this.observer = null;

        this.init();
    };

    IonCheckRadio.prototype = {
        init: function () {
            var ready = this.$group.eq(0).hasClass("icr-input");

            if (ready) {
                this.prepare();
            } else {
                this.createHTML();
            }
        },

        prepare: function () {
            var self = this,
                $item,
                $parent,
                i;

            for (i = 0; i < this.group.length; i++) {
                $item = $(this.group[i]);
                $parent = $item.parent().parent();
                $.data(this.group[i], "icr-parent", $parent);

                this.presetChecked(this.group[i]);
                this.presetDisabled(this.group[i]);
            }

            this.$group.on("change", function () {
                self.change(this);
            });

            this.$group.on("focus", function () {
                self.focus(this);
            });

            this.$group.on("blur", function () {
                self.blur(this);
            });

            // Trace input "disabled" attribute mutation
            // Only for modern browsers. IE11+
            // To add cross browser support, install this:
            // https://github.com/megawac/MutationObserver.js
            if (window.MutationObserver) {
                this.setUpObserver();
            }
        },

        setUpObserver: function () {
            var self = this,
                node,
                i;

            this.observer = new MutationObserver(function (mutations) {
                mutations.forEach(function (mutation) {
                    node = mutation.target;

                    if (mutation.attributeName === "disabled") {
                        self.toggle(self.getParent(node), node.disabled, "disabled");
                    }
                });
            });

            for (i = 0; i < this.group.length; i++) {
                this.observer.observe(this.group[i], {
                    attributes: true
                });
            }
        },

        destroy: function () {
            this.$group.off();

            if (this.observer) {
                this.observer.disconnect();
                this.observer = null;
            }
        },

        presetChecked: function (node) {
            if (node.checked) {
                this.toggle(this.getParent(node), true, "checked");

                if (this.type === "radio") {
                    this.old = node;
                }
            }
        },

        presetDisabled: function (node) {
            if (node.disabled) {
                this.toggle(this.getParent(node), true, "disabled");
            }
        },

        change: function (node) {
            this.toggle(this.getParent(node), node.checked, "checked");

            if (this.type === "radio" && this.old && this.old !== node) {
                this.toggle(this.getParent(this.old), this.old.checked, "checked");
            }

            this.old = node;
        },

        focus: function (node) {
            this.toggle(this.getParent(node), true, "focused");
        },

        blur: function (node) {
            this.toggle(this.getParent(node), false, "focused");
        },

        toggle: function ($node, state, class_name) {
            if (state) {
                $node.addClass(class_name);
            } else {
                $node.removeClass(class_name);
            }
        },

        getParent: function (node) {
            return $.data(node, "icr-parent");
        },

        // auto transform code to correct layout
        // VERY SLOW(!) for lazy developers
        // to avoid this, use recommended html layout
        createHTML: function () {
            var tpl =
                    '<label class="icr-label">' +
                    '   <span class="icr-item type_{type}"></span>' +
                    '   <span class="icr-hidden"><input class="icr-input {class_list}" type="{type}" name="{name}" value="{value}" {disabled} {checked} /></span>' +
                    '   <span class="icr-text">{text}</span>' +
                    '</label>',

                classes = [],
                types = [],
                names = [],
                values = [],
                texts = [],
                checked_list = [],
                disabled_list = [],
                nc = [],
                self = this;

            var getTextParent = function ($label) {
                var label = $label[0],
                    queue = [],
                    nodes = label.childNodes,
                    cur, text, html,
                    start, end, i;

                for (i = 0; i < nodes.length; i++) {
                    queue.push(nodes[i]);
                }

                while (queue.length) {
                    cur = queue[0];

                    if (cur.nodeType === 3) {
                        text = cur.nodeValue.trim();

                        if (text) {
                            break;
                        }
                    } else if (cur.nodeType === 1) {
                        nodes = cur.childNodes;

                        for (i = 0; i < nodes.length; i++) {
                            queue.push(nodes[i]);
                        }
                    }

                    Array.prototype.splice.call(queue, 0, 1);
                }

                html = cur.parentNode.innerHTML;

                if (html.indexOf('<input') >= 0) {
                    start = html.indexOf('<input');
                    html = html.slice(start);
                    end = html.indexOf('>');
                    html = html.slice(end + 1).trim();
                }

                return html;
            };

            var getHTML = function (i) {
                var tp = tpl.replace(/\{class_list\}/, classes[i]);
                tp = tp.replace(/\{type\}/g, types[i]);
                tp = tp.replace(/\{name\}/, names[i]);
                tp = tp.replace(/\{value\}/, values[i]);
                tp = tp.replace(/\{text\}/, texts[i]);

                if (disabled_list[i]) {
                    tp = tp.replace(/\{disabled\}/, "disabled");
                } else {
                    tp = tp.replace(/\{disabled\}/, "");
                }

                if (checked_list[i]) {
                    tp = tp.replace(/\{checked\}/, "checked");
                } else {
                    tp = tp.replace(/\{checked\}/, "");
                }

                return tp;
            };

            this.$group.each(function (i) {
                var $label,
                    $next,
                    $cur = $(this),
                    class_list = $cur.prop("className"),
                    type = $cur.prop("type"),
                    name = $cur.prop("name"),
                    val = $cur.prop("value"),
                    checked = $cur.prop("checked"),
                    disabled = $cur.prop("disabled"),
                    id = $cur.prop("id"),
                    html;

                classes.push(class_list);
                types.push(type);
                names.push(name);
                values.push(val);
                checked_list.push(checked);
                disabled_list.push(disabled);

                if (id) {
                    $label = $("label[for='" + id + "']");
                } else {
                    $label = $cur.closest("label");
                }

                texts.push(getTextParent($label));

                html = getHTML(i);
                $label.after(html);
                $next = $label.next();
                nc.push($next[0]);

                $cur.remove();
                $label.remove();
            });

            this.$group = $(nc).find("input");
            this.$group.each(function (i) {
                self.group[i] = this;
                collection[names[0]][i] = this;
            });

            this.prepare();
        }
    };

    $.fn.ionCheckRadio = function () {
        var i,
            local = [],
            input,
            name;

        var warn = function (text) {
            window.console && window.console.warn && window.console.warn(text);
        };

        for (i = 0; i < this.length; i++) {
            input = this[i];
            name = input.name;

            if (input.type !== "radio" && input.type !== "checkbox" || !name) {
                warn("Ion.CheckRadio: Some inputs have wrong type or absent name attribute!");
                continue;
            }

            collection[name] = {
                type: input.type,
                content: []
            };
            local.push(input);
        }

        for (i = 0; i < local.length; i++) {
            input = local[i];
            name = input.name;

            collection[name].content.push(input);
        }

        for (i in collection) {
            if (instances[i]) {
                instances[i].destroy();
                instances[i] = null;
            }

            instances[i] = new IonCheckRadio(collection[i]);
        }
    };

})(jQuery, window);


<|start_filename|>_previo/css/ion.checkRadio.cloudy.css<|end_filename|>
/* Ion.CheckRadio, Cloudy Skin
// Version 2.0.0
//
// © <NAME>, 2015
// https://github.com/IonDen
// ===================================================================================================================*/

.icr-label {
    padding-right: 2px;
    margin: 0 5px 5px 0;
}

.icr-item {
    width: 18px; height: 18px;
    background: url(../img/icr-cloudy-skin.png) no-repeat;
}

.icr-label.disabled {
    opacity: 0.4;
}

.icr-label.focused .icr-item:after {
    position: absolute;
    display: block;
    content: "";
    top: -1px; left: -1px;
    width: 18px; height: 18px;
    border: 1px dotted rgba(0, 0, 0, 0.3);
}
.icr-label.focused .type_checkbox:after {
    -webkit-border-radius: 4px;
    -moz-border-radius: 4px;
    border-radius: 4px;
}
.icr-label.focused .type_radio:after {
    -webkit-border-radius: 18px;
    -moz-border-radius: 18px;
    border-radius: 18px;
}


<|start_filename|>_previo/js/jquery.monthpicker.js<|end_filename|>
/**
 * monthPicker - a simple but useful month/year picker
 * this plugin creates two selectboxes where the user can can select month and year. afterwars a unix-timestamp is written into the
 * original input field.
 *
 * Copyright (c) <NAME> <http://www.werzahltmehr.de/>.
 * Released under MIT License
 *
 *
 * <usage>
 *
 * $('#id-selector').monthpicker([options]);
 *
 * [options] accepts following JSON properties:
 *  minYear     - the minimum year the selectbox should show
 *  maxYear     - the maximum year the selectbox should show
 *  lang        - language in which all labels should be generated
 *  month       - a map of month labels (overrides the lang parameter if set)
 *  class       - a custom class of selectbox tags
 *  f.e. german months
 *   month : ['January','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember']
 * </usage>
 *
 *
 * @author <NAME>
 * @version 2.0.0
 * @date May 26, 2014
 *
 */
(function ($) {
    $.fn.monthpicker = function (options, language) {

        var month  = {
            "de" : {
                "month" :  ['Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember' ]
            },
            "at" : {
                "month" :  ['Jänner', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember' ]
            },
            "es" : {
                "month" : ['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre']
            },
            "fr" : {
                "month" : ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'août', 'septembre', 'octobre', 'novembre', 'décembre']
            },
            "hu" : {
                "month" : ['január', 'február', 'március', 'április', 'május', 'június', 'július', 'augusztus', 'szeptember', 'október', 'november', 'december']
            },
            "it" : {
                "month" : ['gennaio', 'febbraio', 'marzo', 'aprile', 'maggio', 'giugno', 'luglio', 'agosto', 'settembre', 'ottobre', 'novembre', 'dicembre']
            },
            "nl" : {
                "month" : ['januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus', 'september', 'oktober', 'november', 'december']
            },
            "pt-BR" : {
                "month" : ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro']
            }
        }, defaults = {
            minYear: "1980",
            maxYear: "2010",
            class: "",
            month: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
        }, i, yearbox, monthbox, obj = $(this);

        if (!$.isEmptyObject(options)) {
            defaults = $.extend(defaults, month[options.lang]);
        }

        options = $.extend(defaults, options);

        obj.hide();

        if (options.minYear > options.maxYear) {
            for (i = options.minYear; i >= options.maxYear; i--) {
                yearbox += '<option value="' + i + '">' + i + '</option>';
            }
        } else {
            for (i = options.minYear; i <= options.maxYear; i++) {
                yearbox += '<option value="' + i + '">' + i + '</option>';
            }
        }

        $.map(options.month, function (n, i) {
            monthbox += '<option value="' + i + '">' + n + '</option>';
        });
        var yearElement = $('<select class="yearpick ' + options.class + '">' + yearbox + '</select>'),
            monthElement = $('<select class="monthpick ' + options.class + '">' + monthbox + '</select>');
      
        monthElement.insertBefore(obj);
        yearElement.insertAfter(obj);

        var createTimestamp = function () {
            obj.attr('value', Math.round(Date.UTC(yearElement.val(), monthElement.val(), 1)) / 1000);
        }

        yearElement.change(createTimestamp);
        monthElement.change(createTimestamp);

        if (obj.val()!= ""){
            var timestamp = new Date(parseInt(obj.val()) * 1000);
            yearElement.val(timestamp.getFullYear());
            monthElement.val(timestamp.getMonth());
        }
    };
})(jQuery);


<|start_filename|>_previo/css/ion.checkRadio.css<|end_filename|>
/* Ion.CheckRadio, Skin Base
// Version 2.0.0
//
// © <NAME>, 2015
// https://github.com/IonDen
// ===================================================================================================================*/

.icr-label {
    position: relative;
    display: inline-block;
}

.icr-hidden {
    position: absolute;
    display: block;
    top: 0; left: 0;
    width: 0; height: 0;
    overflow: hidden;
}

.icr-input {
    position: absolute;
    display: block;
    top: -20px; left: -20px;
}

.icr-text {
    display: inline;
    vertical-align: middle;
}

.icr-item {
    position: relative;
    display: inline-block;
    vertical-align: middle;
}


/* Sprite positions */

.icr-label .type_checkbox {
    background-position: 0 0;
}
.icr-label .type_radio {
    background-position: 0 -50px;
}

.icr-label:hover .type_checkbox {
    background-position: -50px 0;
}
.icr-label:hover .type_radio {
    background-position: -50px -50px;
}


.icr-label.checked .type_checkbox {
    background-position: -150px 0;
}
.icr-label.checked .type_radio {
    background-position: -150px -50px;
}

.icr-label.checked:hover .type_checkbox {
    background-position: -150px 0;
}
.icr-label.checked:hover .type_radio {
    background-position: -150px -50px;
}


.icr-label.disabled {
    opacity: 0.5;
}
.lt-ie9 .icr-label.disabled {
    filter: alpha(opacity=50);
}

.icr-label.disabled .type_checkbox {
    background-position: 0 0 !important;
}
.icr-label.disabled .type_radio {
    background-position: 0 -50px !important;
}

.icr-label.checked.disabled .type_checkbox {
    background-position: -100px 0 !important;
}
.icr-label.checked.disabled .type_radio {
    background-position: -100px -50px !important;
}