SGJP / Kuznia

function list_searchoptions(list) {
    "use strict";
    return {
        searchhidden: true,
        sopt: ['eq', 'ne'],
        value: list
    };
}

function list_column(name, displayed, list) {
    "use strict";
    return {
        name: name,
        index: name,
        hidden: true,
        hidedlg: !displayed,
        sortable: false,
        searchoptions: list_searchoptions(list),
        stype: 'select'
    };
}

function text_column(name) {
    "use strict";
    return {
        name: name,
        index: name,
        hidden: true,
        hidedlg: true,
        sortable: false,
        searchoptions: {searchhidden: true}
    };
}

function lip_column(name) {
    "use strict";
    return {
        name: name,
        index: name,
        hidden: true,
        sortable: false,
        searchoptions: {searchhidden: true, sopt: ['eq', 'ne']}
    };
}

function count_column(name) {
    "use strict";
    return {
        name: name,
        index: name,
        hidden: true,
        hidedlg: true,
        sortable: false,
        searchoptions: {searchhidden: true, sopt: ['eq', 'ge', 'le']}
    };
}

var text_ops = ['eq', 'ne', 'bw', 'bn', 'ew', 'en', 'cn', 'nc', 're', 'nr'];
var eqne = ['eq', 'ne'];
var count_ops = ['eq', 'ge', 'le'];

$.extend(slickgrid, {
    grid_element_id: 'lexeme-grid',
    main_field: 'entry',
    columns: [
        {id: "entry", name: "Hasło", field: "entry"},
        {id: "pos", name: "Część mowy", field: "pos"}
    ],
    all_columns: {
        id: {id: "id", name: "Nr", field: "id"},
        entry: {id: "entry", name: "Hasło", field: "entry"},
        pos: {id: "pos", name: "Część mowy", field: "pos"},
        patterns: {id: "patterns", name: "Wzory", field: "patterns"},
        ics: {id: "ics", name: "Char. fleks.", field: "ics"},
        vocabs: {id: "vocabs", name: "Słowniki", field: "vocabs"},
        owner: {id: "owner", name: "Sł. właściciel", field: "owner"},
        status: {id: "status", name: "Status", field: "status"}
    },
    filter_fields: {
        'entry': {name: 'Hasło', gender: 'n', ops: text_ops},
        'part_of_speech': {
            name: 'Część mowy',
            gender: 'f',
            ops: eqne,
            options: $dj.parts_of_speech
        },
        'pattern_name': {name: 'Wzór', gender: 'm', ops: eqne},
        'pattern_count': {name: 'Liczba wzorów', gender: 'f', ops: count_ops},
        'inflection_characteristic': {
            name: 'Char. fleks.', gender: 'f', ops: eqne},
        'ic_count': {name: 'Liczba char. fleks.', gender: 'f', ops: count_ops},
        'form': {name: 'Forma', gender: 'f', ops: text_ops},
        'containing_vocabulary': {
            name: 'Słownik',
            gender: 'm',
            ops: eqne,
            options: $dj.visible_vocabularies
        },
        'owner_vocabulary': {
            name: 'Słownik właściciel',
            gender: 'm',
            ops: eqne,
            options: $dj.visible_vocabularies
        },
        'status': {
            name: 'Status',
            gender: 'm',
            ops: eqne,
            options: $dj.status_options
        },
        'comment': {name: 'Komentarz', gender: 'm', ops: text_ops},
        'lexeme_qualifier': {
            name: 'Kwal. leksemu',
            gender: 'm',
            ops: eqne,
            options: $dj.qualifier_options
        },
        'lip_qualifier': {
            name: 'Kwal. odmieniasia',
            gender: 'm',
            ops: eqne,
            options: $dj.qualifier_options
        },
        'qualifier': {
            name: 'Kwal. przy dow. formie',
            gender: 'm',
            ops: eqne,
            options: $dj.qualifier_options
        },
        'classification_value': {
            name: 'Wartość klasyfikacji',
            gender: 'f',
            ops: eqne,
            options: $dj.cv_options
        },
        'gloss': {name: 'Glosa', gender: 'f', ops: text_ops},
        'nota': {name: 'Nota', gender: 'f', ops: text_ops},
        'cr_type': {
            name: 'Typ odsyłacza',
            gender: 'm',
            ops: eqne,
            options: $dj.cr_type_options
        }
    },
    initial_sort_rules: [
        {field: 'entry', order: 'asc', a_tergo: false},
        {field: 'part_of_speech', order: 'asc'},
        {field: 'id', order: 'asc'}
    ],
    grid_caption: "Leksemy"
});

slickgrid.sort_rule_special_features = function(rule) {
    "use strict";
    $('#entries_a_tergo').prop('checked', rule.a_tergo);
};

slickgrid.prepare_sort_rules = function(sort_rules, old_sort_rules) {
    "use strict";
    if (sort_rules[0].field === 'entry') {
        var a_tergo = false;
        $.each(old_sort_rules, function (i, rule) {
            if (rule.field === 'entry') {
                a_tergo = rule.a_tergo;
                return false;
            }
            return null;
        });
        sort_rules[0].a_tergo = a_tergo;
    }
};

slickgrid.load_content = function(id, is_created) {
    "use strict";
    function check() {
        return id === slickgrid.active_id();
    }
    edit.load_content(id, is_created, check);
};

// filtry

function create_button(button_class, icon_class, text) {
    "use strict";
    var button = $('<a/>')
        .addClass('ui-state-default ui-corner-all ' + button_class)
        .addClass('fm-button fm-button-icon-left');
    var icon = $('<span/>').addClass('ui-icon ' + icon_class);
    button.append(icon).append(text);
    return button;
}

slickgrid.add_filter_buttons = function(f) {
    "use strict";
    if (f[0].p) {
        var button_save = create_button(
            'ui-save', 'ui-icon-disk', 'Zapisz filtr');
        var button_load = create_button(
            'ui-load', 'ui-icon-arrowthickstop-1-s', 'Załaduj filtr');
        f.next().find('tr').last().children().first()
            .append(button_save).append(button_load);
        button_save.click(function () {
            var filter_name, filters, post_data;
            filter_name = window.prompt("Wybierz nazwę filtru do zapisania");
            if (filter_name) {
                filters = $('.searchFilter').jqFilter('filterData');
                post_data = {
                    name: filter_name,
                    serialized_filter: $.toJSON(filters)
                };
                var save_filter_data = {
                    method: 'post',
                    url: $dj.ajax_save_filter,
                    data: post_data,
                    description: 'Zapisanie filtru'
                };
                $.ajaxJSON($.extend(save_filter_data, {
                    callback: function (data) {
                        if (data.exists && window.confirm(
                                "Filtr o tej nazwie już istnieje. Nadpisać?")) {
                            $.ajaxJSON($.extend(save_filter_data, {
                                data: $.extend(post_data, {force: true})
                            }));
                        }
                    }
                }));
            }
            return false;
        });
        button_load.click(function () {
            $.ajaxJSON({
                method: 'get',
                url: $dj.ajax_get_filters,
                data: {},
                description: 'Pobranie listy filtrów',
                callback: filter_choice
            });
            return false;
        });
    }
};

function filter_choice(ajax_data) {
    "use strict";
    var filters = ajax_data.filters;
    var list = $('#filter-list');
    list.html('');
    // napakować okienko na podstawie wyniku z ajaxa
    $.each(filters, function (i, filter) {
        var item = $('<li/>').addClass('ui-state-default').attr('id', filter.id);
        var delete_button = $('<span/>')
            .addClass('remove ui-icon ui-icon-closethick');
        delete_button.click(function () {
            if (window.confirm('Usunąć filtr "' + filter.name + '"?')) {
                $.ajaxJSON({
                    method: 'post',
                    url: $dj.ajax_delete_filter,
                    data: {id: filter.id},
                    description: 'Usunięcie filtru',
                    callback: function () {
                        item.remove();
                    }
                });
            }
            return false;
        });
        item.append(delete_button);
        item.append(filter.name);
        item.click(function () {
            slickgrid.put_filter(filter.json);
            $("#load-filter-dialog").dialog('close');
        });
        list.append(item);
    });
    $("#load-filter-dialog").dialog('open');
}