Update the information elements in the display
@param {object} settings dataTables settings object
@memberof DataTable#oApi
14223
function _fnUpdateInfo ( settings )
	{
		/* Show information about the table */
		var nodes = settings.aanFeatures.i;
		if ( nodes.length === 0 ) {
			return;
		}
	
		var
			lang  = settings.oLanguage,
			start = settings._iDisplayStart+1,
			end   = settings.fnDisplayEnd(),
			max   = settings.fnRecordsTotal(),
			total = settings.fnRecordsDisplay(),
			out   = total ?
				lang.sInfo :
				lang.sInfoEmpty;
	
		if ( total !== max ) {
			/* Record set after filtering */
			out += ' ' + lang.sInfoFiltered;
		}
	
		// Convert the macros
		out += lang.sInfoPostFix;
		out = _fnInfoMacros( settings, out );
	
		var callback = lang.fnInfoCallback;
		if ( callback !== null ) {
			out = callback.call( settings.oInstance,
				settings, start, end, max, total, out
			);
		}
	
		$(nodes).html( out );
	}
870077
private void applySettings() {
		buttonContainer.reset();
		WButton exampleButton = new WButton(tfButtonLabel.getText());

		exampleButton.setRenderAsLink(cbRenderAsLink.isSelected());

		exampleButton.setText(tfButtonLabel.getText());

		if (cbSetImage.isSelected()) {
			exampleButton.setImage("/image/pencil.png");
			exampleButton.setImagePosition((ImagePosition) ddImagePosition.getSelected());
		}

		exampleButton.setDisabled(cbDisabled.isSelected());

		if (tfAccesskey.getText() != null && tfAccesskey.getText().length() > 0) {
			exampleButton.setAccessKey(tfAccesskey.getText().toCharArray()[0]);
		}

		buttonContainer.add(exampleButton);
	}
569046
public void setSettings(java.util.Collection<OutputDestinationSettings> settings) {
        if (settings == null) {
            this.settings = null;
            return;
        }

        this.settings = new java.util.ArrayList<OutputDestinationSettings>(settings);
    }
686636
private void loadSettings(HieroSettings settings) {
		paddingTop = settings.getPaddingTop();
		paddingLeft = settings.getPaddingLeft();
		paddingBottom = settings.getPaddingBottom();
		paddingRight = settings.getPaddingRight();
		paddingAdvanceX = settings.getPaddingAdvanceX();
		paddingAdvanceY = settings.getPaddingAdvanceY();
		glyphPageWidth = settings.getGlyphPageWidth();
		glyphPageHeight = settings.getGlyphPageHeight();
		effects.addAll(settings.getEffects());
	}
267761
function updateUserSettings(userId, settings, overwrite, callback) {
        return _updateUserObjectField(userId, ['settings'], settings, overwrite)
            .then(function (userData) {
                return userData.settings;
            })
            .nodeify(callback);
    }
214172
function(items, settings) {
            // Param mapping
            if (typeof settings === 'undefined' && $.isPlainObject(items)) {
                // (settings)
                settings = items;
                items = null;
            }

            settings = $.extend({}, Garnish.Drag.defaults, settings);
            this.base(items, settings);
        }
1231925
function _fnAjaxUpdate( oSettings )
		{
			if ( oSettings.bAjaxDataGet )
			{
				oSettings.iDraw++;
				_fnProcessingDisplay( oSettings, true );
				var iColumns = oSettings.aoColumns.length;
				var aoData = _fnAjaxParameters( oSettings );
				_fnServerParams( oSettings, aoData );
				
				oSettings.fnServerData.call( oSettings.oInstance, oSettings.sAjaxSource, aoData,
					function(json) {
						_fnAjaxUpdateDraw( oSettings, json );
					}, oSettings );
				return false;
			}
			else
			{
				return true;
			}
		}
1008610
function(el, value) {
	        if (el.holderData) {
	            el.holderData.resizeUpdate = !!value;
	            if (el.holderData.resizeUpdate) {
	                updateResizableElements(el);
	            }
	        }
	    }
493455
function (settings) {
        settings = {
          border: 1,
          padding: 20,
          layout: 'flex',
          pack: "center",
          align: "center",
          containerCls: 'panel',
          autoScroll: true,
          buttons: { type: "button", text: "Ok", action: "ok" },
          items: {
            type: "label",
            multiline: true,
            maxWidth: 500,
            maxHeight: 200
          }
        };

        this._super(settings);
      }
1140356
public void setSettings(java.util.Collection<Setting> settings) {
        if (settings == null) {
            this.settings = null;
            return;
        }

        this.settings = new com.amazonaws.internal.SdkInternalList<Setting>(settings);
    }
946453
function _fnFeatureHtmlInfo ( settings )
	{
		var
			tid = settings.sTableId,
			nodes = settings.aanFeatures.i,
			n = $('<div/>', {
				'class': settings.oClasses.sInfo,
				'id': ! nodes ? tid+'_info' : null
			} );
	
		if ( ! nodes ) {
			// Update display on each draw
			settings.aoDrawCallback.push( {
				"fn": _fnUpdateInfo,
				"sName": "information"
			} );
	
			n
				.attr( 'role', 'alert' )
				.attr( 'aria-live', 'polite' )
				.attr( 'aria-relevant', 'all' );
	
			// Table is described by our info div
			$(settings.nTable).attr( 'aria-describedby', tid+'_info' );
		}
	
		return n[0];
	}
1042670
function(settings) {
    this.events = [];
    this.setSettings(settings);
    this.bytesLoaded = 0;
    this.bytesTotal = 0;
    this.paused = !this.settings.autoStart;

    var _self = this;
    var _fileList = [];
    var _completed = new List('item.uuid');
    var _errors = new List('item.uuid');
    var _queue = new List('item.uuid');

    var onStart = function(event) {
        var e = new FileManagerEvent('file_start', {
            bytesLoaded: event.bytesLoaded,
            bytesTotal: event.bytesTotal,
            totalBytesLoaded: _self.bytesLoaded,
            totalBytesTotal: _self.bytesTotal,
            currentTarget: event.target,
            file: event.file,
            queue: _queue.toArray(),
            errors: _errors.toArray(),
            fileList: _fileList,
            completed: _completed.toArray()
        });

        _self.dispatchEvent(e);
    };

    var onPause = function(event) {
        var e = new FileManagerEvent('file_pause', {
            bytesLoaded: event.bytesLoaded,
            bytesTotal: event.bytesTotal,
            totalBytesLoaded: _self.bytesLoaded,
            totalBytesTotal: _self.bytesTotal,
            currentTarget: event.target,
            file: event.file,
            queue: _queue.toArray(),
            errors: _errors.toArray(),
            fileList: _fileList,
            completed: _completed.toArray()
        });

        _self.dispatchEvent(e);
    };

    var onProgress = function(event) {
        _self.bytesLoaded += event.bytesLoaded;

        // @deprecated
        var e = new FileManagerEvent('file_progress', {
            bytesLoaded: event.bytesLoaded,
            bytesTotal: event.bytesTotal,
            totalBytesLoaded: _self.bytesLoaded,
            totalBytesTotal: _self.bytesTotal,
            currentTarget: event.target,
            file: event.file,
            queue: _queue.toArray(),
            errors: _errors.toArray(),
            fileList: _fileList,
            completed: _completed.toArray()
        });

        _self.dispatchEvent(e);

        e = new FileManagerEvent('progress', {
            bytesLoaded: event.bytesLoaded,
            bytesTotal: event.bytesTotal,
            totalBytesLoaded: _self.bytesLoaded,
            totalBytesTotal: _self.bytesTotal,
            currentTarget: event.target,
            file: event.file,
            queue: _queue.toArray(),
            errors: _errors.toArray(),
            fileList: _fileList,
            completed: _completed.toArray()
        });

        _self.dispatchEvent(e);
    };

    var onError = function(event) {
        _queue.remove(event.target);
        _errors.add(event.target);

        // @deprecated
        var e = new FileManagerEvent('file_error', {
            bytesLoaded: 0,
            bytesTotal: event.bytesTotal,
            totalBytesLoaded: _self.bytesLoaded,
            totalBytesTotal: _self.bytesTotal,
            currentTarget: event.target,
            file: event.file,
            queue: _queue.toArray(),
            errors: _errors.toArray(),
            fileList: _fileList,
            completed: _completed.toArray(),
            fileError: event
        });

        _self.dispatchEvent(e);

        e = new FileManagerEvent('error', {
            bytesLoaded: 0,
            bytesTotal: event.bytesTotal,
            totalBytesLoaded: _self.bytesLoaded,
            totalBytesTotal: _self.bytesTotal,
            currentTarget: event.target,
            file: event.file,
            queue: _queue.toArray(),
            errors: _errors.toArray(),
            fileList: _fileList,
            completed: _completed.toArray(),
            fileError: event
        });

        _self.dispatchEvent(e);
        
        queue.apply(_self);
    };

    var onComplete = function(event) {
        _completed.add(event.target);
        _queue.remove(event.target);

        // @deprecated
        var e = new FileManagerEvent('file_complete', {
            bytesLoaded: event.bytesLoaded,
            bytesTotal: event.bytesTotal,
            totalBytesLoaded: _self.bytesLoaded,
            totalBytesTotal: _self.bytesTotal,
            currentTarget: event.target,
            file: event.file,
            queue: _queue.toArray(),
            errors: _errors.toArray(),
            fileList: _fileList,
            completed: _completed.toArray(),
            data: event.data
        });

        _self.dispatchEvent(e);

        e = new FileManagerEvent('complete', {
            bytesLoaded: event.bytesLoaded,
            bytesTotal: event.bytesTotal,
            totalBytesLoaded: _self.bytesLoaded,
            totalBytesTotal: _self.bytesTotal,
            currentTarget: event.target,
            file: event.file,
            queue: _queue.toArray(),
            errors: _errors.toArray(),
            fileList: _fileList,
            completed: _completed.toArray(),
            data: event.data
        });

        _self.dispatchEvent(e);
        
        queue.apply(_self);
    };

    _queue.add = function(item) {
        if (!!item.uuid) {
            item.on('start', onStart);
            item.on('pause', onPause);
            item.on('progress', onProgress);
            item.on('error', onError);
            item.on('complete', onComplete);

            this.list[item.uuid] = item;
            ++this.length;
        }
    };
    _queue.remove = function(item) {
        if (!!item.uuid) {
            item.off('start', onStart);
            item.off('pause', onPause);
            item.off('progress', onProgress);
            item.off('error', onError);
            item.off('complete', onComplete);

            delete this.list[item.uuid];
            --this.length;
        }
    };

    this.addFile = function(file) {
        if (!file instanceof File || !this.validate(file)) {
            // If it's an actual file, just throw it in the error queue
            if (file instanceof File) {
                _errors.add(file);
                var e = new FileManagerEvent('invalid', {
                    bytesLoaded: 0,
                    bytesTotal: file.size,
                    totalBytesLoaded: _self.bytesLoaded,
                    totalBytesTotal: _self.bytesTotal,
                    currentTarget: this,
                    queue: _queue.toArray(),
                    file: file,
                    fileList: _fileList,
                    completed: _completed.toArray(),
                    errors: _errors.toArray()
                });

                this.dispatchEvent(e);
            }
            return;
        }

        if (!_fileList) {
            _fileList = [];
        }

        _fileList.push(file);
        
        this.bytesTotal += file.size;

        // Update the queue
        queue.apply(this);

        return this;
    };

    this.setFiles = function(files) {
        if (!files instanceof FileList || !files instanceof Array || files.length === 0) {
            return;
        }

        this.pause();
        _fileList = [];
        var i;

        if (files instanceof FileList) {
            for (i = 0; i < files.length; i++) {
                this.addFile(files.item(i));
            }
        }
        else {
            for (i = 0; i < files.length; i++) {
                this.addFile(files[i]);
            }
        }

        if (this.settings.autoStart === true) {
            this.start();
        }

        return this;
    };

    var queue = function () {
        var _self = this;
        while(_queue.length < _self.settings.maxQueue && _fileList.length > 0) {
            var file = _fileList.shift();
            if (!!file) {
                // Create the FileUpload to queue
                var fu = new FileUpload(file, {
                    url: _self.settings.url,
                    method: _self.settings.method,
                    autoStart: false,
                    maxChunkSize: _self.settings.maxChunkSize,
                    formFileField: _self.settings.formFileField,
                    chunkParameter: _self.settings.chunkParameter,
                    chunksParameter: _self.settings.chunksParameter
                });

                // Update the total queue size
                _self.bytesTotal += file.size;

                // Add the uploader to the queue
                _queue.add(fu);

                // Dispatch an queue event
                _self.dispatchEvent(new FileManagerEvent('queue', {
                    bytesLoaded: 0,
                    bytesTotal: file.size,
                    totalBytesLoaded: _self.bytesLoaded,
                    totalBytesTotal: _self.bytesTotal,
                    currentTarget: fu,
                    queue: _queue.toArray(),
                    file: file,
                    fileList: _fileList,
                    completed: _completed.toArray(),
                    errors: _errors.toArray()
                }));

                // If the manager isn't paused, start the upload
                if (!_self.paused) {
                    fu.start();
                }
            }
        }
    };

    this.start = function() {
        this.paused = false;

        queue.apply(this);
        
        for (var n in _queue.list) {
            _queue.get(n).start();
        }

        this.dispatchEvent(FileManagerEvent('start', {
            bytesLoaded: this.bytesLoaded,
            bytesTotal: this.bytesTotal,
            queue: _queue.toArray(),
            fileList: _fileList,
            completed: _completed.toArray(),
            errors: _errors.toArray()
        }));
    };

    this.pause = function() {
        this.paused = true;
        for (var i = 0; i < _queue.length; i++) {
            _queue[i].pause();
        }

        this.dispatchEvent(new FileManagerEvent('pause', {
            bytesLoaded: this.bytesLoaded,
            bytesTotal: this.bytesTotal,
            queue: _queue.toArray(),
            fileList: _fileList,
            completed: _completed.toArray(),
            errors: _errors.toArray()
        }));
    };
    
    this.clearQueue = function() {
      _queue.clear();
      return this;
    };
    
    this.clearErrors = function() {
      _errors.clear();
      return this;
    };
    
    this.clearCompleted = function() {
      _completed.clear();
      return this;
    }
}
319747
function updateInfo(info, override, source, sourceId) {
  if (source) {
    if (source.minzoom !== undefined) {
      // eslint-disable-next-line no-param-reassign
      info.minzoom = source.minzoom;
    }
    if (source.maxzoom !== undefined) {
      // eslint-disable-next-line no-param-reassign
      info.maxzoom = source.maxzoom;
    }
  }
  if (sourceId !== undefined) {
    // eslint-disable-next-line no-param-reassign
    info.name = sourceId;
  }
  if (override) {
    _.each(override, (v, k) => {
      if (v === null) {
        // When override.key == null, delete that key
        // eslint-disable-next-line no-param-reassign
        delete info[k];
      } else {
        // override info of the parent
        // eslint-disable-next-line no-param-reassign
        info[k] = v;
      }
    });
  }
}
402675
function (settings) {
        var self = this;

        settings.spellcheck = false;

        if (settings.onaction) {
          settings.icon = 'none';
        }

        self._super(settings);

        self.classes.add('colorbox');
        self.on('change keyup postrender', function () {
          self.repaintColor(self.value());
        });
      }
921417
function update() {
      if (!hoveredNode)
        return;

      var embedSettings = self.settings.embedObjects({
            prefix: prefix
          });

      // Deleting element before update
      self.domElements.groups.hovers.removeChild(
        self.domElements.hovers[hoveredNode.id]
      );
      delete self.domElements.hovers[hoveredNode.id];

      var hover = (renderers[hoveredNode.type] || renderers.def).create(
        hoveredNode,
        self.domElements.nodes[hoveredNode.id],
        self.measurementCanvas,
        embedSettings
      );

      self.domElements.hovers[hoveredNode.id] = hover;

      // Inserting the hover in the dom
      self.domElements.groups.hovers.appendChild(hover);
    }
1284192
function addMutationObserver(settings) {
    function isLink(node) {
        const isStylesheet = node.tagName === 'LINK' && (node.getAttribute('rel') || '').indexOf('stylesheet') !== -1;

        return isStylesheet && !node.disabled;
    }
    function isStyle(node) {
        return node.tagName === 'STYLE' && !node.disabled;
    }
    function isValidAddMutation(mutationNodes) {
        return Array.apply(null, mutationNodes).some(node => {
            const isElm           = node.nodeType === 1;
            const hasAttr         = isElm && node.hasAttribute('data-cssvars');
            const isStyleWithVars = isStyle(node) && regex.cssVars.test(node.textContent);
            const isValid         = !hasAttr && (isLink(node) || isStyleWithVars);

            return isValid;
        });
    }
    function isValidRemoveMutation(mutationNodes) {
        return Array.apply(null, mutationNodes).some(node => {
            const isElm     = node.nodeType === 1;
            const isOutNode = isElm && node.getAttribute('data-cssvars') === 'out';
            const isSrcNode = isElm && node.getAttribute('data-cssvars') === 'src';
            const isValid   = isSrcNode;

            if (isSrcNode || isOutNode) {
                const dataGroup  = node.getAttribute('data-cssvars-group');
                const orphanNode = settings.rootElement.querySelector(`[data-cssvars-group="${dataGroup}"]`);

                if (isSrcNode) {
                    resetCssNodes(settings.rootElement);
                    variableStore.dom = {};
                }

                if (orphanNode) {
                    orphanNode.parentNode.removeChild(orphanNode);
                }
            }

            return isValid;
        });
    }

    if (!window.MutationObserver) {
        return;
    }

    if (cssVarsObserver) {
        cssVarsObserver.disconnect();
        cssVarsObserver = null;
    }

    cssVarsObserver = new MutationObserver(function(mutations) {
        const hasValidMutation = mutations.some((mutation) => {
            let isValid = false;

            if (mutation.type === 'attributes') {
                isValid = isLink(mutation.target);
            }
            else if (mutation.type === 'childList') {
                isValid = isValidAddMutation(mutation.addedNodes) || isValidRemoveMutation(mutation.removedNodes);
            }

            return isValid;
        });

        if (hasValidMutation) {
            cssVars(settings);
        }
    });

    cssVarsObserver.observe(document.documentElement, {
        attributes     : true,
        attributeFilter: ['disabled', 'href'],
        childList      : true,
        subtree        : true
    });
}
1299509
function(newSettings) {
      var s = '';

      if (typeof newSettings !== 'object') {
        throw new Error('ss.http.set() takes an object e.g. {static: {maxAge: 60000}}');
      }

      for (s in newSettings) {
        if (newSettings.hasOwnProperty(s)) {
          settings[s] = newSettings[s]
        }
      }
    }