js/config.js

   1 /* vim: set expandtab sw=4 ts=4 sts=4: */
   2 /**
   3  * Functions used in configuration forms and on user preferences pages
   4  */
   5
   6 // default values for fields
   7 var defaultValues = {};
   8
   9 // language strings
  10 var PMA_messages = {};
  11
  12 /**
  13  * Returns field type
  14  *
  15  * @param {Element} field
  16  */
  17 function getFieldType(field)
  18 {
  19     field = $(field);
  20     var tagName = field.prop('tagName');
  21     if (tagName == 'INPUT') {
  22         return field.attr('type');
  23     } else if (tagName == 'SELECT') {
  24         return 'select';
  25     } else if (tagName == 'TEXTAREA') {
  26         return 'text';
  27     }
  28     return '';
  29 }
  30
  31 /**
  32  * Sets field value
  33  *
  34  * value must be of type:
  35  * o undefined (omitted) - restore default value (form default, not PMA default)
  36  * o String - if field_type is 'text'
  37  * o boolean - if field_type is 'checkbox'
  38  * o Array of values - if field_type is 'select'
  39  *
  40  * @param {Element} field
  41  * @param {String}  field_type  see {@link #getFieldType}
  42  * @param {String|Boolean}  [value]
  43  */
  44 function setFieldValue(field, field_type, value)
  45 {
  46     field = $(field);
  47     switch (field_type) {
  48         case 'text':
  49             field.attr('value', (value != undefined ? value : field.attr('defaultValue')));
  50             break;
  51         case 'checkbox':
  52             field.attr('checked', (value != undefined ? value : field.attr('defaultChecked')));
  53             break;
  54         case 'select':
  55             var options = field.prop('options');
  56             var i, imax = options.length;
  57             if (value == undefined) {
  58                 for (i = 0; i < imax; i++) {
  59                     options[i].selected = options[i].defaultSelected;
  60                 }
  61             } else {
  62                 for (i = 0; i < imax; i++) {
  63                     options[i].selected = (value.indexOf(options[i].value) != -1);
  64                 }
  65             }
  66             break;
  67     }
  68     markField(field);
  69 }
  70
  71 /**
  72  * Gets field value
  73  *
  74  * Will return one of:
  75  * o String - if type is 'text'
  76  * o boolean - if type is 'checkbox'
  77  * o Array of values - if type is 'select'
  78  *
  79  * @param {Element} field
  80  * @param {String}  field_type returned by {@link #getFieldType}
  81  * @type Boolean|String|String[]
  82  */
  83 function getFieldValue(field, field_type)
  84 {
  85     field = $(field);
  86     switch (field_type) {
  87         case 'text':
  88             return field.prop('value');
  89         case 'checkbox':
  90             return field.prop('checked');
  91         case 'select':
  92             var options = field.prop('options');
  93             var i, imax = options.length, items = [];
  94             for (i = 0; i < imax; i++) {
  95                 if (options[i].selected) {
  96                     items.push(options[i].value);
  97                 }
  98             }
  99             return items;
 100     }
 101     return null;
 102 }
 103
 104 /**
 105  * Returns values for all fields in fieldsets
 106  */
 107 function getAllValues()
 108 {
 109     var elements = $('fieldset input, fieldset select, fieldset textarea');
 110     var values = {};
 111     var type, value;
 112     for (var i = 0; i < elements.length; i++) {
 113         type = getFieldType(elements[i]);
 114         value = getFieldValue(elements[i], type);
 115         if (typeof value != 'undefined') {
 116             // we only have single selects, fatten array
 117             if (type == 'select') {
 118                 value = value[0];
 119             }
 120             values[elements[i].name] = value;
 121         }
 122     }
 123     return values;
 124 }
 125
 126 /**
 127  * Checks whether field has its default value
 128  *
 129  * @param {Element} field
 130  * @param {String}  type
 131  * @return boolean
 132  */
 133 function checkFieldDefault(field, type)
 134 {
 135     field = $(field);
 136     var field_id = field.attr('id');
 137     if (typeof defaultValues[field_id] == 'undefined') {
 138         return true;
 139     }
 140     var isDefault = true;
 141     var currentValue = getFieldValue(field, type);
 142     if (type != 'select') {
 143         isDefault = currentValue == defaultValues[field_id];
 144     } else {
 145         // compare arrays, will work for our representation of select values
 146         if (currentValue.length != defaultValues[field_id].length) {
 147             isDefault = false;
 148         }
 149         else {
 150             for (var i = 0; i < currentValue.length; i++) {
 151                 if (currentValue[i] != defaultValues[field_id][i]) {
 152                     isDefault = false;
 153                     break;
 154                 }
 155             }
 156         }
 157     }
 158     return isDefault;
 159 }
 160
 161 /**
 162  * Returns element's id prefix
 163  * @param {Element} element
 164  */
 165 function getIdPrefix(element)
 166 {
 167     return $(element).attr('id').replace(/[^-]+$/, '');
 168 }
 169
 170 // ------------------------------------------------------------------
 171 // Form validation and field operations
 172 //
 173
 174 // form validator assignments
 175 var validate = {};
 176
 177 // form validator list
 178 var validators = {
 179     // regexp: numeric value
 180     _regexp_numeric: /^[0-9]+$/,
 181     // regexp: extract parts from PCRE expression
 182     _regexp_pcre_extract: /(.)(.*)\1(.*)?/,
 183     /**
 184      * Validates positive number
 185      *
 186      * @param {boolean} isKeyUp
 187      */
 188     validate_positive_number: function (isKeyUp) {
 189         if (isKeyUp && this.value == '') {
 190             return true;
 191         }
 192         var result = this.value != '0' && validators._regexp_numeric.test(this.value);
 193         return result ? true : PMA_messages['error_nan_p'];
 194     },
 195     /**
 196      * Validates non-negative number
 197      *
 198      * @param {boolean} isKeyUp
 199      */
 200     validate_non_negative_number: function (isKeyUp) {
 201         if (isKeyUp && this.value == '') {
 202             return true;
 203         }
 204         var result = validators._regexp_numeric.test(this.value);
 205         return result ? true : PMA_messages['error_nan_nneg'];
 206     },
 207     /**
 208      * Validates port number
 209      *
 210      * @param {boolean} isKeyUp
 211      */
 212     validate_port_number: function(isKeyUp) {
 213         if (this.value == '') {
 214             return true;
 215         }
 216         var result = validators._regexp_numeric.test(this.value) && this.value != '0';
 217         return result && this.value <= 65535 ? true : PMA_messages['error_incorrect_port'];
 218     },
 219     /**
 220      * Validates value according to given regular expression
 221      *
 222      * @param {boolean} isKeyUp
 223      * @param {string}  regexp
 224      */
 225     validate_by_regex: function(isKeyUp, regexp) {
 226         if (isKeyUp && this.value == '') {
 227             return true;
 228         }
 229         // convert PCRE regexp
 230         var parts = regexp.match(validators._regexp_pcre_extract);
 231         var valid = this.value.match(new RegExp(parts[2], parts[3])) != null;
 232         return valid ? true : PMA_messages['error_invalid_value'];
 233     },
 234     /**
 235      * Validates upper bound for numeric inputs
 236      *
 237      * @param {boolean} isKeyUp
 238      * @param {int} max_value
 239      */
 240     validate_upper_bound: function(isKeyUp, max_value) {
 241         var val = parseInt(this.value);
 242         if (isNaN(val)) {
 243             return true;
 244         }
 245         return val <= max_value ? true : PMA_messages['error_value_lte'].replace('%s', max_value);
 246     },
 247     // field validators
 248     _field: {
 249     },
 250     // fieldset validators
 251     _fieldset: {
 252     }
 253 };
 254
 255 /**
 256  * Registers validator for given field
 257  *
 258  * @param {String}  id       field id
 259  * @param {String}  type     validator (key in validators object)
 260  * @param {boolean} onKeyUp  whether fire on key up
 261  * @param {Array}   params   validation function parameters
 262  */
 263 function validateField(id, type, onKeyUp, params)
 264 {
 265     if (typeof validators[type] == 'undefined') {
 266         return;
 267     }
 268     if (typeof validate[id] == 'undefined') {
 269         validate[id] = [];
 270     }
 271     validate[id].push([type, params, onKeyUp]);
 272 }
 273
 274 /**
 275  * Returns valdiation functions associated with form field
 276  *
 277  * @param  {String}  field_id     form field id
 278  * @param  {boolean} onKeyUpOnly  see validateField
 279  * @type Array
 280  * @return array of [function, paramseters to be passed to function]
 281  */
 282 function getFieldValidators(field_id, onKeyUpOnly)
 283 {
 284     // look for field bound validator
 285     var name = field_id.match(/[^-]+$/)[0];
 286     if (typeof validators._field[name] != 'undefined') {
 287         return [[validators._field[name], null]];
 288     }
 289
 290     // look for registered validators
 291     var functions = [];
 292     if (typeof validate[field_id] != 'undefined') {
 293         // validate[field_id]: array of [type, params, onKeyUp]
 294         for (var i = 0, imax = validate[field_id].length; i < imax; i++) {
 295             if (onKeyUpOnly && !validate[field_id][i][2]) {
 296                 continue;
 297             }
 298             functions.push([validators[validate[field_id][i][0]], validate[field_id][i][1]]);
 299         }
 300     }
 301
 302     return functions;
 303 }
 304
 305 /**
 306  * Displays errors for given form fields
 307  *
 308  * WARNING: created DOM elements must be identical with the ones made by
 309  * display_input() in FormDisplay.tpl.php!
 310  *
 311  * @param {Object} error_list list of errors in the form {field id: error array}
 312  */
 313 function displayErrors(error_list)
 314 {
 315     for (var field_id in error_list) {
 316         var errors = error_list[field_id];
 317         var field = $('#'+field_id);
 318         var isFieldset = field.attr('tagName') == 'FIELDSET';
 319         var errorCnt = isFieldset
 320             ? field.find('dl.errors')
 321             : field.siblings('.inline_errors');
 322
 323         // remove empty errors (used to clear error list)
 324         errors = $.grep(errors, function(item) {
 325             return item != '';
 326         });
 327
 328         // CSS error class
 329         if (!isFieldset) {
 330             // checkboxes uses parent <span> for marking
 331             var fieldMarker = (field.attr('type') == 'checkbox') ? field.parent() : field;
 332             fieldMarker[errors.length ? 'addClass' : 'removeClass']('field-error');
 333         }
 334
 335         if (errors.length) {
 336             // if error container doesn't exist, create it
 337             if (errorCnt.length == 0) {
 338                 if (isFieldset) {
 339                     errorCnt = $('<dl class="errors" />');
 340                     field.find('table').before(errorCnt);
 341                 } else {
 342                     errorCnt = $('<dl class="inline_errors" />');
 343                     field.closest('td').append(errorCnt);
 344                 }
 345             }
 346
 347             var html = '';
 348             for (var i = 0, imax = errors.length; i < imax; i++) {
 349                 html += '<dd>' + errors[i] + '</dd>';
 350             }
 351             errorCnt.html(html);
 352         } else if (errorCnt !== null) {
 353             // remove useless error container
 354             errorCnt.remove();
 355         }
 356     }
 357 }
 358
 359 /**
 360  * Validates fieldset and puts errors in 'errors' object
 361  *
 362  * @param {Element} fieldset
 363  * @param {boolean} isKeyUp
 364  * @param {Object}  errors
 365  */
 366 function validate_fieldset(fieldset, isKeyUp, errors)
 367 {
 368     fieldset = $(fieldset);
 369     if (fieldset.length && typeof validators._fieldset[fieldset.attr('id')] != 'undefined') {
 370         var fieldset_errors = validators._fieldset[fieldset.attr('id')].apply(fieldset[0], [isKeyUp]);
 371         for (var field_id in fieldset_errors) {
 372             if (typeof errors[field_id] == 'undefined') {
 373                 errors[field_id] = [];
 374             }
 375             if (typeof fieldset_errors[field_id] == 'string') {
 376                 fieldset_errors[field_id] = [fieldset_errors[field_id]];
 377             }
 378             $.merge(errors[field_id], fieldset_errors[field_id]);
 379         }
 380     }
 381 }
 382
 383 /**
 384  * Validates form field and puts errors in 'errors' object
 385  *
 386  * @param {Element} field
 387  * @param {boolean} isKeyUp
 388  * @param {Object}  errors
 389  */
 390 function validate_field(field, isKeyUp, errors)
 391 {
 392     field = $(field);
 393     var field_id = field.attr('id');
 394     errors[field_id] = [];
 395     var functions = getFieldValidators(field_id, isKeyUp);
 396     for (var i = 0; i < functions.length; i++) {
 397         var args = functions[i][1] != null
 398             ? functions[i][1].slice(0)
 399             : [];
 400         args.unshift(isKeyUp);
 401         var result = functions[i][0].apply(field[0], args);
 402         if (result !== true) {
 403             if (typeof result == 'string') {
 404                 result = [result];
 405             }
 406             $.merge(errors[field_id], result);
 407         }
 408     }
 409 }
 410
 411 /**
 412  * Validates form field and parent fieldset
 413  *
 414  * @param {Element} field
 415  * @param {boolean} isKeyUp
 416  */
 417 function validate_field_and_fieldset(field, isKeyUp)
 418 {
 419     field = $(field);
 420     var errors = {};
 421     validate_field(field, isKeyUp, errors);
 422     validate_fieldset(field.closest('fieldset'), isKeyUp, errors);
 423     displayErrors(errors);
 424 }
 425
 426 /**
 427  * Marks field depending on its value (system default or custom)
 428  *
 429  * @param {Element} field
 430  */
 431 function markField(field)
 432 {
 433     field = $(field);
 434     var type = getFieldType(field);
 435     var isDefault = checkFieldDefault(field, type);
 436
 437     // checkboxes uses parent <span> for marking
 438     var fieldMarker = (type == 'checkbox') ? field.parent() : field;
 439     setRestoreDefaultBtn(field, !isDefault);
 440     fieldMarker[isDefault ? 'removeClass' : 'addClass']('custom');
 441 }
 442
 443 /**
 444  * Enables or disables the "restore default value" button
 445  *
 446  * @param {Element} field
 447  * @param {boolean} display
 448  */
 449 function setRestoreDefaultBtn(field, display)
 450 {
 451     var el = $(field).closest('td').find('.restore-default img');
 452     el[display ? 'show' : 'hide']();
 453 }
 454
 455 $(function() {
 456     // register validators and mark custom values
 457     var elements = $('input[id], select[id], textarea[id]');
 458     $('input[id], select[id], textarea[id]').each(function(){
 459         markField(this);
 460         var el = $(this);
 461         el.bind('change', function() {
 462             validate_field_and_fieldset(this, false);
 463             markField(this);
 464         });
 465         var tagName = el.attr('tagName');
 466         // text fields can be validated after each change
 467         if (tagName == 'INPUT' && el.attr('type') == 'text') {
 468             el.keyup(function() {
 469                 validate_field_and_fieldset(el, true);
 470                 markField(el);
 471             });
 472         }
 473         // disable textarea spellcheck
 474         if (tagName == 'TEXTAREA') {
 475            el.attr('spellcheck', false);
 476         }
 477     });
 478
 479     // check whether we've refreshed a page and browser remembered modified
 480     // form values
 481     var check_page_refresh = $('#check_page_refresh');
 482     if (check_page_refresh.length == 0 || check_page_refresh.val() == '1') {
 483         // run all field validators
 484         var errors = {};
 485         for (var i = 0; i < elements.length; i++) {
 486             validate_field(elements[i], false, errors);
 487         }
 488         // run all fieldset validators
 489         $('fieldset').each(function(){
 490             validate_fieldset(this, false, errors);
 491         });
 492
 493         displayErrors(errors);
 494     } else if (check_page_refresh) {
 495         check_page_refresh.val('1');
 496     }
 497 });
 498
 499 //
 500 // END: Form validation and field operations
 501 // ------------------------------------------------------------------
 502
 503 // ------------------------------------------------------------------
 504 // Tabbed forms
 505 //
 506
 507 /**
 508  * Sets active tab
 509  *
 510  * @param {String} tab_id
 511  */
 512 function setTab(tab_id)
 513 {
 514     $('.tabs li').removeClass('active').find('a[href=#' + tab_id + ']').parent().addClass('active');
 515     $('.tabs_contents fieldset').hide().filter('#' + tab_id).show();
 516     location.hash = 'tab_' + tab_id;
 517     $('.config-form input[name=tab_hash]').val(location.hash);
 518 }
 519
 520 $(function() {
 521     var tabs = $('.tabs');
 522     if (!tabs.length) {
 523         return;
 524     }
 525     // add tabs events and activate one tab (the first one or indicated by location hash)
 526     tabs.find('a')
 527         .click(function(e) {
 528             e.preventDefault();
 529             setTab($(this).attr('href').substr(1));
 530         })
 531         .filter(':first')
 532         .parent()
 533         .addClass('active');
 534     $('.tabs_contents fieldset').hide().filter(':first').show();
 535
 536     // tab links handling, check each 200ms
 537     // (works with history in FF, further browser support here would be an overkill)
 538     var prev_hash;
 539     var tab_check_fnc = function() {
 540         if (location.hash != prev_hash) {
 541             prev_hash = location.hash;
 542             if (location.hash.match(/^#tab_.+/) && $('#' + location.hash.substr(5)).length) {
 543                 setTab(location.hash.substr(5));
 544             }
 545         }
 546     };
 547     tab_check_fnc();
 548     setInterval(tab_check_fnc, 200);
 549 });
 550
 551 //
 552 // END: Tabbed forms
 553 // ------------------------------------------------------------------
 554
 555 // ------------------------------------------------------------------
 556 // Form reset buttons
 557 //
 558
 559 $(function() {
 560     $('input[type=button][name=submit_reset]').click(function() {
 561         var fields = $(this).closest('fieldset').find('input, select, textarea');
 562         for (var i = 0, imax = fields.length; i < imax; i++) {
 563             setFieldValue(fields[i], getFieldType(fields[i]));
 564         }
 565     });
 566 });
 567
 568 //
 569 // END: Form reset buttons
 570 // ------------------------------------------------------------------
 571
 572 // ------------------------------------------------------------------
 573 // "Restore default" and "set value" buttons
 574 //
 575
 576 /**
 577  * Restores field's default value
 578  *
 579  * @param {String} field_id
 580  */
 581 function restoreField(field_id)
 582 {
 583     var field = $('#'+field_id);
 584     if (field.length == 0 || defaultValues[field_id] == undefined) {
 585         return;
 586     }
 587     setFieldValue(field, getFieldType(field), defaultValues[field_id]);
 588 }
 589
 590 $(function() {
 591     $('.tabs_contents')
 592         .delegate('.restore-default, .set-value', 'mouseenter', function(){$(this).css('opacity', 1)})
 593         .delegate('.restore-default, .set-value', 'mouseleave', function(){$(this).css('opacity', 0.25)})
 594         .delegate('.restore-default, .set-value', 'click', function(e) {
 595             e.preventDefault();
 596             var href = $(this).attr('href');
 597             var field_sel;
 598             if ($(this).hasClass('restore-default')) {
 599                 field_sel = href;
 600                 restoreField(field_sel.substr(1));
 601             } else {
 602                 field_sel = href.match(/^[^=]+/)[0];
 603                 var value = href.match(/=(.+)$/)[1];
 604                 setFieldValue($(field_sel), 'text', value);
 605             }
 606             $(field_sel).trigger('change');
 607         })
 608         .find('.restore-default, .set-value')
 609         // inline-block for IE so opacity inheritance works
 610         .css({display: 'inline-block', opacity: 0.25});
 611 });
 612
 613 //
 614 // END: "Restore default" and "set value" buttons
 615 // ------------------------------------------------------------------
 616
 617 // ------------------------------------------------------------------
 618 // User preferences import/export
 619 //
 620
 621 $(function() {
 622     offerPrefsAutoimport();
 623     var radios = $('#import_local_storage, #export_local_storage');
 624     if (!radios.length) {
 625         return;
 626     }
 627
 628     // enable JavaScript dependent fields
 629     radios
 630         .attr('disabled', false)
 631         .add('#export_text_file, #import_text_file')
 632         .click(function(){
 633             var enable_id = $(this).attr('id');
 634             var disable_id = enable_id.match(/local_storage$/)
 635                 ? enable_id.replace(/local_storage$/, 'text_file')
 636                 : enable_id.replace(/text_file$/, 'local_storage');
 637             $('#opts_'+disable_id).addClass('disabled').find('input').attr('disabled', true);
 638             $('#opts_'+enable_id).removeClass('disabled').find('input').attr('disabled', false);
 639         });
 640
 641     // detect localStorage state
 642     var ls_supported = window.localStorage || false;
 643     var ls_exists = ls_supported ? (window.localStorage['config'] || false) : false;
 644     $('.localStorage-'+(ls_supported ? 'un' : '')+'supported').hide();
 645     $('.localStorage-'+(ls_exists ? 'empty' : 'exists')).hide();
 646     if (ls_exists) {
 647         updatePrefsDate();
 648     }
 649     $('form.prefs-form').change(function(){
 650         var form = $(this);
 651         var disabled = false;
 652         if (!ls_supported) {
 653             disabled = form.find('input[type=radio][value$=local_storage]').attr('checked');
 654         } else if (!ls_exists && form.attr('name') == 'prefs_import'
 655                 && $('#import_local_storage')[0].checked) {
 656             disabled = true;
 657         }
 658         form.find('input[type=submit]').attr('disabled', disabled);
 659     }).submit(function(e) {
 660         var form = $(this);
 661         if (form.attr('name') == 'prefs_export' && $('#export_local_storage')[0].checked) {
 662             e.preventDefault();
 663             // use AJAX to read JSON settings and save them
 664             savePrefsToLocalStorage(form);
 665         } else if (form.attr('name') == 'prefs_import' && $('#import_local_storage')[0].checked) {
 666             // set 'json' input and submit form
 667             form.find('input[name=json]').val(window.localStorage['config']);
 668         }
 669     });
 670
 671     $('.click-hide-message').live('click', function(){
 672         var div = $(this);
 673         div.hide().parent('.group').css('height', '');
 674         div.next('form').show();
 675     });
 676 });
 677
 678 /**
 679  * Saves user preferences to localStorage
 680  *
 681  * @param {Element} form
 682  */
 683 function savePrefsToLocalStorage(form)
 684 {
 685     form = $(form);
 686     var submit = form.find('input[type=submit]');
 687     submit.attr('disabled', true);
 688     $.ajax({
 689         url: 'prefs_manage.php',
 690         cache: false,
 691         type: 'POST',
 692         data: {
 693             token: form.find('input[name=token]').val(),
 694             submit_get_json: true
 695         },
 696         success: function(response) {
 697             window.localStorage['config'] = response.prefs;
 698             window.localStorage['config_mtime'] = response.mtime;
 699             window.localStorage['config_mtime_local'] = (new Date()).toUTCString();
 700             updatePrefsDate();
 701             $('.localStorage-empty').hide();
 702             $('.localStorage-exists').show();
 703             var group = form.parent('.group');
 704             group.css('height', group.height() + 'px');
 705             form.hide('fast');
 706             form.prev('.click-hide-message').show('fast');
 707         },
 708         complete: function() {
 709             submit.attr('disabled', false);
 710         }
 711     });
 712 }
 713
 714 /**
 715  * Updates preferences timestamp in Import form
 716  */
 717 function updatePrefsDate()
 718 {
 719     var d = new Date(window.localStorage['config_mtime_local']);
 720     var msg = PMA_messages['strSavedOn'].replace('@DATE@', formatDate(d));
 721     $('#opts_import_local_storage .localStorage-exists').html(msg);
 722 }
 723
 724 /**
 725  * Returns date formatted as YYYY-MM-DD HH:II
 726  *
 727  * @param {Date} d
 728  */
 729 function formatDate(d)
 730 {
 731     return d.getFullYear() + '-'
 732         + (d.getMonth() < 10 ? '0'+d.getMonth() : d.getMonth())
 733         + '-' + (d.getDate() < 10 ? '0'+d.getDate() : d.getDate())
 734         + ' ' + (d.getHours() < 10 ? '0'+d.getHours() : d.getHours())
 735         + ':' + (d.getMinutes() < 10 ? '0'+d.getMinutes() : d.getMinutes());
 736 }
 737
 738 /**
 739  * Prepares message which informs that localStorage preferences are available and can be imported
 740  */
 741 function offerPrefsAutoimport()
 742 {
 743     var has_config = (window.localStorage || false) && (window.localStorage['config'] || false);
 744     var cnt = $('#prefs_autoload');
 745     if (!cnt.length || !has_config) {
 746         return;
 747     }
 748     cnt.find('a').click(function(e) {
 749         e.preventDefault();
 750         var a = $(this);
 751         if (a.attr('href') == '#no') {
 752             cnt.remove();
 753             $.post('main.php', {
 754                 token: cnt.find('input[name=token]').val(),
 755                 prefs_autoload: 'hide'});
 756             return;
 757         }
 758         cnt.find('input[name=json]').val(window.localStorage['config']);
 759         cnt.find('form').submit();
 760     });
 761     cnt.show();
 762 }
 763
 764 //
 765 // END: User preferences import/export
 766 // ------------------------------------------------------------------