jsxgrid 2.0.0

package/src/fields/jsgrid.field.control.js

@@ -0,0 +1,224 @@
+(function(jsGrid, $, undefined) {
+
+    var Field = jsGrid.Field;
+
+    function ControlField(config) {
+        Field.call(this, config);
+        this.includeInDataExport = false;
+        this._configInitialized = false;
+    }
+
+    ControlField.prototype = new Field({
+        css: "jsgrid-control-field",
+        align: "center",
+        width: 50,
+        filtering: false,
+        inserting: false,
+        editing: false,
+        sorting: false,
+
+        buttonClass: "jsgrid-button",
+        modeButtonClass: "jsgrid-mode-button",
+
+        modeOnButtonClass: "jsgrid-mode-on-button",
+        searchModeButtonClass: "jsgrid-search-mode-button",
+        insertModeButtonClass: "jsgrid-insert-mode-button",
+        editButtonClass: "jsgrid-edit-button",
+        deleteButtonClass: "jsgrid-delete-button",
+        searchButtonClass: "jsgrid-search-button",
+        clearFilterButtonClass: "jsgrid-clear-filter-button",
+        insertButtonClass: "jsgrid-insert-button",
+        updateButtonClass: "jsgrid-update-button",
+        cancelEditButtonClass: "jsgrid-cancel-edit-button",
+
+        searchModeButtonTooltip: "Switch to searching",
+        insertModeButtonTooltip: "Switch to inserting",
+        editButtonTooltip: "Edit",
+        deleteButtonTooltip: "Delete",
+        searchButtonTooltip: "Search",
+        clearFilterButtonTooltip: "Clear filter",
+        insertButtonTooltip: "Insert",
+        updateButtonTooltip: "Update",
+        cancelEditButtonTooltip: "Cancel edit",
+
+        editButton: true,
+        deleteButton: true,
+        clearFilterButton: true,
+        modeSwitchButton: true,
+
+        _initConfig: function() {
+            this._hasFiltering = this._grid.filtering;
+            this._hasInserting = this._grid.inserting;
+
+            if(this._hasInserting && this.modeSwitchButton) {
+                this._grid.inserting = false;
+            }
+
+            this._configInitialized = true;
+        },
+
+        headerTemplate: function() {
+            if(!this._configInitialized) {
+                this._initConfig();
+            }
+
+            var hasFiltering = this._hasFiltering;
+            var hasInserting = this._hasInserting;
+
+            if(!this.modeSwitchButton || (!hasFiltering && !hasInserting))
+                return "";
+
+            if(hasFiltering && !hasInserting)
+                return this._createFilterSwitchButton();
+
+            if(hasInserting && !hasFiltering)
+                return this._createInsertSwitchButton();
+
+            return this._createModeSwitchButton();
+        },
+
+        itemTemplate: function(value, item) {
+            var $result = $([]);
+
+            if(this.editButton) {
+                $result = $result.add(this._createEditButton(item));
+            }
+
+            if(this.deleteButton) {
+                $result = $result.add(this._createDeleteButton(item));
+            }
+
+            return $result;
+        },
+
+        filterTemplate: function() {
+            var $result = this._createSearchButton();
+            return this.clearFilterButton ? $result.add(this._createClearFilterButton()) : $result;
+        },
+
+        insertTemplate: function() {
+            return this._createInsertButton();
+        },
+
+        editTemplate: function() {
+            return this._createUpdateButton().add(this._createCancelEditButton());
+        },
+
+        _createFilterSwitchButton: function() {
+            return this._createOnOffSwitchButton("filtering", this.searchModeButtonClass, true);
+        },
+
+        _createInsertSwitchButton: function() {
+            return this._createOnOffSwitchButton("inserting", this.insertModeButtonClass, false);
+        },
+
+        _createOnOffSwitchButton: function(option, cssClass, isOnInitially) {
+            var isOn = isOnInitially;
+
+            var updateButtonState = $.proxy(function() {
+                $button.toggleClass(this.modeOnButtonClass, isOn);
+            }, this);
+
+            var $button = this._createGridButton(this.modeButtonClass + " " + cssClass, "", function(grid) {
+                isOn = !isOn;
+                grid.option(option, isOn);
+                updateButtonState();
+            });
+
+            updateButtonState();
+
+            return $button;
+        },
+
+        _createModeSwitchButton: function() {
+            var isInserting = false;
+
+            var updateButtonState = $.proxy(function() {
+                $button.attr("title", isInserting ? this.searchModeButtonTooltip : this.insertModeButtonTooltip)
+                    .toggleClass(this.insertModeButtonClass, !isInserting)
+                    .toggleClass(this.searchModeButtonClass, isInserting);
+            }, this);
+
+            var $button = this._createGridButton(this.modeButtonClass, "", function(grid) {
+                isInserting = !isInserting;
+                grid.option("inserting", isInserting);
+                grid.option("filtering", !isInserting);
+                updateButtonState();
+            });
+
+            updateButtonState();
+
+            return $button;
+        },
+
+        _createEditButton: function(item) {
+            return this._createGridButton(this.editButtonClass, this.editButtonTooltip, function(grid, e) {
+                grid.editItem(item);
+                e.stopPropagation();
+            });
+        },
+
+        _createDeleteButton: function(item) {
+            return this._createGridButton(this.deleteButtonClass, this.deleteButtonTooltip, function(grid, e) {
+                grid.deleteItem(item);
+                e.stopPropagation();
+            });
+        },
+
+        _createSearchButton: function() {
+            return this._createGridButton(this.searchButtonClass, this.searchButtonTooltip, function(grid) {
+                grid.search();
+            });
+        },
+
+        _createClearFilterButton: function() {
+            return this._createGridButton(this.clearFilterButtonClass, this.clearFilterButtonTooltip, function(grid) {
+                grid.clearFilter();
+            });
+        },
+
+        _createInsertButton: function() {
+            return this._createGridButton(this.insertButtonClass, this.insertButtonTooltip, function(grid) {
+                grid.insertItem().done(function() {
+                    grid.clearInsert();
+                });
+            });
+        },
+
+        _createUpdateButton: function() {
+            return this._createGridButton(this.updateButtonClass, this.updateButtonTooltip, function(grid, e) {
+                grid.updateItem();
+                e.stopPropagation();
+            });
+        },
+
+        _createCancelEditButton: function() {
+            return this._createGridButton(this.cancelEditButtonClass, this.cancelEditButtonTooltip, function(grid, e) {
+                grid.cancelEdit();
+                e.stopPropagation();
+            });
+        },
+
+        _createGridButton: function(cls, tooltip, clickHandler) {
+            var grid = this._grid;
+
+            return $("<input>").addClass(this.buttonClass)
+                .addClass(cls)
+                .attr({
+                    type: "button",
+                    title: tooltip
+                })
+                .on("click", function(e) {
+                    clickHandler(grid, e);
+                });
+        },
+
+        editValue: function() {
+            return "";
+        }
+
+    });
+
+    jsGrid.fields.control = jsGrid.ControlField = ControlField;
+
+}(jsGrid, jQuery));

package/src/fields/jsgrid.field.number.js

@@ -0,0 +1,41 @@
+(function(jsGrid, $, undefined) {
+
+    var TextField = jsGrid.TextField;
+
+    function NumberField(config) {
+        TextField.call(this, config);
+    }
+
+    NumberField.prototype = new TextField({
+
+        sorter: "number",
+        align: "right",
+		readOnly: false,
+
+        filterValue: function() {
+            return this.filterControl.val()
+                ? parseInt(this.filterControl.val() || 0, 10)
+                : undefined;
+        },
+
+        insertValue: function() {
+            return this.insertControl.val()
+                ? parseInt(this.insertControl.val() || 0, 10)
+                : undefined;
+        },
+
+        editValue: function() {
+            return this.editControl.val()
+                ? parseInt(this.editControl.val() || 0, 10)
+                : undefined;
+        },
+
+        _createTextBox: function() {
+			return $("<input>").attr("type", "number")
+                .prop("readonly", !!this.readOnly);
+        }
+    });
+
+    jsGrid.fields.number = jsGrid.NumberField = NumberField;
+
+}(jsGrid, jQuery));

package/src/fields/jsgrid.field.select.js

@@ -0,0 +1,130 @@
+(function(jsGrid, $, undefined) {
+
+    var NumberField = jsGrid.NumberField;
+    var numberValueType = "number";
+    var stringValueType = "string";
+
+    function SelectField(config) {
+        this.items = [];
+        this.selectedIndex = -1;
+        this.valueField = "";
+        this.textField = "";
+
+        if(config.valueField && config.items.length) {
+            var firstItemValue = config.items[0][config.valueField];
+            this.valueType = (typeof firstItemValue) === numberValueType ? numberValueType : stringValueType;
+        }
+
+        this.sorter = this.valueType;
+
+        NumberField.call(this, config);
+    }
+
+    SelectField.prototype = new NumberField({
+
+        align: "center",
+        valueType: numberValueType,
+
+        itemTemplate: function(value) {
+            var items = this.items,
+                valueField = this.valueField,
+                textField = this.textField,
+                resultItem;
+
+            if(valueField) {
+                if(typeof(value) === "object"){
+                    resultItem = value;
+                }
+                else{
+                    resultItem = $.grep(items, function(item, index) {
+                        return item[valueField] === value;
+                    })[0] || {};
+                }
+            }
+            else {
+                resultItem = items[value];
+            }
+
+            var result = (textField ? resultItem[textField] : resultItem);
+
+            return (result === undefined || result === null) ? "" : result;
+        },
+
+        filterTemplate: function() {
+            if(!this.filtering)
+                return "";
+
+            var grid = this._grid,
+                $result = this.filterControl = this._createSelect();
+
+            if(this.autosearch) {
+                $result.on("change", function(e) {
+                    grid.search();
+                });
+            }
+
+            return $result;
+        },
+
+        insertTemplate: function() {
+            if(!this.inserting)
+                return "";
+
+            return this.insertControl = this._createSelect();
+        },
+
+        editTemplate: function(value) {
+            if(!this.editing)
+                return this.itemTemplate.apply(this, arguments);
+
+            var $result = this.editControl = this._createSelect();
+            var editValue = value;
+            if(typeof(value) === "object"){
+                editValue = value[this.valueField];
+            }
+            (editValue !== undefined) && $result.val(editValue);
+            return $result;
+        },
+
+        filterValue: function() {
+            var val = this.filterControl.val();
+            return this.valueType === numberValueType ? parseInt(val || 0, 10) : val;
+        },
+
+        insertValue: function() {
+            var val = this.insertControl.val();
+            return this.valueType === numberValueType ? parseInt(val || 0, 10) : val;
+        },
+
+        editValue: function() {
+            var val = this.editControl.val();
+            return this.valueType === numberValueType ? parseInt(val || 0, 10) : val;
+        },
+
+        _createSelect: function() {
+            var $result = $("<select>"),
+                valueField = this.valueField,
+                textField = this.textField,
+                selectedIndex = this.selectedIndex;
+
+            $.each(this.items, function(index, item) {
+                var value = valueField ? item[valueField] : index,
+                    text = textField ? item[textField] : item;
+
+                var $option = $("<option>")
+                    .attr("value", value)
+                    .text(text)
+                    .appendTo($result);
+
+            });
+
+            $result.prop("disabled", !!this.readOnly);
+            $result.prop("selectedIndex", selectedIndex);
+			
+            return $result;
+        }
+    });
+
+    jsGrid.fields.select = jsGrid.SelectField = SelectField;
+
+}(jsGrid, jQuery));

package/src/fields/jsgrid.field.text.js

@@ -0,0 +1,69 @@
+(function(jsGrid, $, undefined) {
+
+    var Field = jsGrid.Field;
+
+    function TextField(config) {
+        Field.call(this, config);
+    }
+
+    TextField.prototype = new Field({
+
+        autosearch: true,
+		readOnly: false,
+
+        filterTemplate: function() {
+            if(!this.filtering)
+                return "";
+
+            var grid = this._grid,
+                $result = this.filterControl = this._createTextBox();
+
+            if(this.autosearch) {
+                $result.on("keypress", function(e) {
+                    if(e.which === 13) {
+                        grid.search();
+                        e.preventDefault();
+                    }
+                });
+            }
+
+            return $result;
+        },
+
+        insertTemplate: function() {
+            if(!this.inserting)
+                return "";
+
+            return this.insertControl = this._createTextBox();
+        },
+
+        editTemplate: function(value) {
+            if(!this.editing)
+                return this.itemTemplate.apply(this, arguments);
+
+            var $result = this.editControl = this._createTextBox();
+            $result.val(value);
+            return $result;
+        },
+
+        filterValue: function() {
+            return this.filterControl.val();
+        },
+
+        insertValue: function() {
+            return this.insertControl.val();
+        },
+
+        editValue: function() {
+            return this.editControl.val();
+        },
+
+        _createTextBox: function() {
+            return $("<input>").attr("type", "text")
+                .prop("readonly", !!this.readOnly);
+        }
+    });
+
+    jsGrid.fields.text = jsGrid.TextField = TextField;
+
+}(jsGrid, jQuery));

package/src/fields/jsgrid.field.textarea.js

@@ -0,0 +1,34 @@
+(function(jsGrid, $, undefined) {
+
+    var TextField = jsGrid.TextField;
+
+    function TextAreaField(config) {
+        TextField.call(this, config);
+    }
+
+    TextAreaField.prototype = new TextField({
+
+        insertTemplate: function() {
+            if(!this.inserting)
+                return "";
+
+            return this.insertControl = this._createTextArea();
+        },
+
+        editTemplate: function(value) {
+            if(!this.editing)
+                return this.itemTemplate.apply(this, arguments);
+
+            var $result = this.editControl = this._createTextArea();
+            $result.val(value);
+            return $result;
+        },
+
+        _createTextArea: function() {
+            return $("<textarea>").prop("readonly", !!this.readOnly);
+        }
+    });
+
+    jsGrid.fields.textarea = jsGrid.TextAreaField = TextAreaField;
+
+}(jsGrid, jQuery));

package/src/i18n/Ko.js

@@ -0,0 +1,46 @@
+(function(jsGrid) {
+
+    jsGrid.locales.ko = {
+        grid: {
+            noDataContent: "데이터가 없습니다.",
+            deleteConfirm: "데이터를 삭제 하겠습니까?",
+            pagerFormat: "페이지 : {first} {prev} {pages} {next} {last}    {pageIndex} / {pageCount}",
+            pagePrevText: "<",
+            pageNextText: ">",
+            pageFirstText: "<<",
+            pageLastText: ">>",
+            loadMessage: "잠시 기다려주세요...",
+            invalidMessage: "잘못된 데이터가 입력 되었습니다."
+        },
+
+        loadIndicator: {
+            message: "처리중..."
+        },
+
+        fields: {
+            control: {
+                searchModeButtonTooltip: "검색 모드",
+                insertModeButtonTooltip: "등록 모드",
+                editButtonTooltip: "수정",
+                deleteButtonTooltip: "삭제",
+                searchButtonTooltip: "검색",
+                clearFilterButtonTooltip: "초기화",
+                insertButtonTooltip: "등록",
+                updateButtonTooltip: "업데이트",
+                cancelEditButtonTooltip: "변경 취소"
+            }
+        },
+
+        validators: {
+            required: { message: "필수 입력" },
+            rangeLength: { message: "입력된 값의 길이가 범위를 벗어났습니다." },
+            minLength: { message: "입력된 값이 지정된 길이보다 짧습니다." },
+            maxLength: { message: "입력된 값의 지정된 길이보다 깁니다." },
+            pattern: { message: "입력된 값이 지정된 패턴과 일치하지 않습니다." },
+            range: { message: "입력된 값이 범위를 벗어났습니다." },
+            min: { message: "입력된 값이 지정된 범위보다 작습니다." },
+            max: { message: "입력된 값이 지정된 범위보다 큽니다." }
+        }
+    };
+
+}(jsGrid, jQuery));

package/src/i18n/cs.js

@@ -0,0 +1,46 @@
+(function(jsGrid) {
+
+    jsGrid.locales.cs = {
+        grid: {
+            noDataContent: "Nenalezena žádná data",
+            deleteConfirm: "Opravdu chcete smazat data?",
+            pagerFormat: "Stránky: {first} {prev} {pages} {next} {last}    {pageIndex} z {pageCount}",
+            pagePrevText: "<",
+            pageNextText: ">",
+            pageFirstText: "<<",
+            pageLastText: ">>",
+            loadMessage: "Čekejte prosím ...",
+            invalidMessage: "Vložili jste neplatná data!"
+        },
+
+        loadIndicator: {
+            message: "Nahrávám..."
+        },
+
+        fields: {
+            control: {
+                searchModeButtonTooltip: "Přepnout na hledání",
+                insertModeButtonTooltip: "Přepnout na vlkádání",
+                editButtonTooltip: "Upravit",
+                deleteButtonTooltip: "Smazat",
+                searchButtonTooltip: "Hledat",
+                clearFilterButtonTooltip: "Smazat filtr",
+                insertButtonTooltip: "Vložit",
+                updateButtonTooltip: "Upravit",
+                cancelEditButtonTooltip: "Zrušit editaci"
+            }
+        },
+
+        validators: {
+            required: { message: "Povinné pole" },
+            rangeLength: { message: "Délka hodnoty je vetší než je definováno" },
+            minLength: { message: "Hodnota je příliš krátká" },
+            maxLength: { message: "Hodnota je příliš dlouhá" },
+            pattern: { message: "Hodnota neodpovídá nadefinovanému vzoru" },
+            range: { message: "Hodnota je mimo rozsah" },
+            min: { message: "Hodnota je příliš malá" },
+            max: { message: "Hodnota je příliš vysoká" }
+        }
+    };
+
+}(jsGrid, jQuery));

package/src/i18n/de.js

@@ -0,0 +1,46 @@
+(function(jsGrid) {
+
+    jsGrid.locales.de = {
+        grid: {
+            noDataContent: "Die Daten konnten nicht gefunden werden",
+            deleteConfirm: "Möchten Sie die Daten unwiederruflich löschen?",
+            pagerFormat: "Seiten: {first} {prev} {pages} {next} {last}    {pageIndex} von {pageCount}",
+            pagePrevText: "<",
+            pageNextText: ">",
+            pageFirstText: "<<",
+            pageLastText: ">>",
+            loadMessage: "Bitte warten...",
+            invalidMessage: "Ihre Eingabe ist nicht zulässig!"
+        },
+
+        loadIndicator: {
+            message: "Lädt..."
+        },
+
+        fields: {
+            control: {
+                searchModeButtonTooltip: "Suche",
+                insertModeButtonTooltip: "Eintrag hinzufügen",
+                editButtonTooltip: "Bearbeiten",
+                deleteButtonTooltip: "Löschen",
+                searchButtonTooltip: "Eintrag finden",
+                clearFilterButtonTooltip: "Filter zurücksetzen",
+                insertButtonTooltip: "Hinzufügen",
+                updateButtonTooltip: "Speichern",
+                cancelEditButtonTooltip: "Abbrechen"
+            }
+        },
+
+        validators: {
+            required: { message: "Dies ist ein Pflichtfeld" },
+            rangeLength: { message: "Die Länge der Eingabe liegt außerhalb des zulässigen Bereichs" },
+            minLength: { message: "Die Eingabe ist zu kurz" },
+            maxLength: { message: "Die Eingabe ist zu lang" },
+            pattern: { message: "Die Eingabe entspricht nicht dem gewünschten Muster" },
+            range: { message: "Der eingegebene Wert liegt außerhalb des zulässigen Bereichs" },
+            min: { message: "Der eingegebene Wert ist zu niedrig" },
+            max: { message: "Der eingegebene Wert ist zu hoch" }
+        }
+    };
+
+}(jsGrid, jQuery));

package/src/i18n/el.js

@@ -0,0 +1,46 @@
+(function(jsGrid) {
+
+    jsGrid.locales.el = {
+        grid: {
+            noDataContent: "Δεν βρέθηκαν δεδομένα",
+            deleteConfirm: "Θέλετε σίγουρα να κάνετε οριστική διαγραφή των δεδομένων;",
+            pagerFormat: "Σελίδες: {first} {prev} {pages} {next} {last}    {pageIndex} από {pageCount}",
+            pagePrevText: "<",
+            pageNextText: ">",
+            pageFirstText: "<<",
+            pageLastText: ">>",
+            loadMessage: "Παρακαλώ περιμένετε...",
+            invalidMessage: "Η τιμή που δώσατε δεν είναι έγκυρη!"
+        },
+
+        loadIndicator: {
+            message: "Φόρτωση..."
+        },
+
+        fields: {
+            control: {
+                searchModeButtonTooltip: "Αναζήτηση",
+                insertModeButtonTooltip: "Εισάγετε φίλτρο",
+                editButtonTooltip: "Επεξεργασία",
+                deleteButtonTooltip: "Διαγραφή",
+                searchButtonTooltip: "Εύρεση",
+                clearFilterButtonTooltip: "Αφαίρεση φίλτρου",
+                insertButtonTooltip: "Εισαγωγή",
+                updateButtonTooltip: "Αποθήκευση",
+                cancelEditButtonTooltip: "Ακύρωση"
+            }
+        },
+
+        validators: {
+            required: { message: "Είναι υποχρεωτικό πεδίο" },
+            rangeLength: { message: "Το πλήθος των χαρακτήρων είναι εκτός των αποδεκτών ορίων" },
+            minLength: { message: "Το πλήθος των χαρακτήρων είναι μικρότερο το ορίου" },
+            maxLength: { message: "Το πλήθος των χαρακτήρων ξεπερνάει το όριο" },
+            pattern: { message: "Η τιμή που δώσατε δεν είναι έγκυρη" },
+            range: { message: "Η τιμή που δώσατε είναι εκτός των αποδεκτών ορίων" },
+            min: { message: "Η τιμή που δώσατε είναι πολύ μικρή" },
+            max: { message: "Η τιμή που δώσατε είναι πολύ μεγάλη" }
+        }
+    };
+
+}(jsGrid, jQuery));