text:
/**
 * @requires OpenLayers/Control.js
 * @requires OpenLayers/Dimension/Model.js
 */

/**
 * Class: OpenLayers.Control.DimensionManager
 * Control to display and animate map layers across a non-geographic dimension (time, elevation, etc..).
 *
 * Inherits From:
 *  - <OpenLayers.Control>
 */
OpenLayers.Control.DimensionManager = OpenLayers.Class(OpenLayers.Control, {

    /**
     * Constant: EVENT_TYPES
     *
     * Supported event types:
     *  - *tick* Triggered when the control advances one step in value.
     *      Listeners receive an event object with a *currentValue* parameter.
     *      Event is fired after the value has been incremented but before the
     *      map or layer display is modified.
     *  - *play* Triggered when the play function is called.
     *      Returning 'false' from this event will prevent the control
     *      from playing the animation.
     *  - *stop* Triggered when the control stops a series animation.
     *      Listeners receive an event object with a {Boolean} *rangeExceeded*
     *      property indicating the control stopped due to reaching the end of
     *      its configured value range (true) or due to the stop function call
     *      (false).
     *  - *rangemodified* Triggered when the control's animationRange is set
     *      programattically.
     *  - *reset* Triggered when the control resets a series animation.
     *      Listeners receive an event object with a {Boolean} *looped*
     *      property indicating the control reset due to running in looped mode
     *      (true) or the reset function call (false)
     *  - *prebuffer* Triggered on each prebuffering step.
     *      Listeners receive an event object with a {Float} *progress*
     *      property indicating the progress of the prebuffering, value ranges
     *      from 0 to 1.
     */
    EVENT_TYPES : ["beforetick", "tick", "play", "stop", "reset", "rangemodified", "prebuffer"],

    /**
     * APIProperty: model
     * {OpenLayers.Dimension.Model}
     */
    model : null,

    /**
     * APIProperty: prebuffer
     * {Boolean}
     */
    prebuffer: null,

    /** APIProperty: maxframes
     * {Integer}
     */
    maxframes: null,

    /**
     * APIProperty: autoSync
     * {Boolean} Automatically adjust the available animationRange and
     *    possibly the currentValue of this control in response to
     *    a 'rangemodified' event from the 'model' (fired when layers
     *    are added or removed from the map and affect the overall range
     *    of valid values)
     */
    autoSync : true,

    /**
     * APIProperty: dimension
     * {String} The dimension this control manages
     *     Examples: 'time', 'elevation'
     */
    dimension : null,

    /**
     * APIProperty: animationRange
     * {Array(Number)} 2 member array containing the minimum and maximum
     *     values that the animation will use. The 1st value should ALWAYS
     *     be less than the second value. Use negative step values to do
     *     reverse stepping. This is separate from the model's range and
     *     should be equal to or a subset of that range.
     */
    animationRange : null,

    /**
     * APIProperty: step
     * {Number} The number of units each tick will advance the current
     *     dimension. Negative units will tick the dimension in reverse.
     *     Default : 1.
     */
    step : 1,

    /**
     * APIProperty: timeUnits
     * {<OpenLayers.TimeUnit>} (Optional) Only used when 'dimension' is 'time'.
     *     The date part the time value will be incremented by. Use of this
     *     property will make time value changes more accurate over a long
     *     period.
     */
    timeUnits: null,

    /**
     * APIProperty: timeStep
     * {Number} (Optional) Only used when 'dimension' is 'time'.
     *     The amount of timeUnits the time value will be incremented by. Use of this
     *     property will make time value changes more accurate over a long
     *     period.
     */
    timeStep: null,

    /**
     * APIProperty: frameRate
     * {Number} A positive floating point number of frames (or ticks) per
     *     second to use in series animations. Values less than 1 will
     *     make each tick last for more than 1 second. Example: 0.5 = 1 tick
     *     every 2 seconds. 3 = 3 ticks per second.
     *     Default : 1.
     */
    frameRate : 1,

    /**
     * APIProperty: loop
     * {Boolean} true to continue running the animation until stop is called
     *     Default:false
     */
    loop : false,

    /**
     * APIProperty: snapToList
     * {Boolean} If valuesList is configured and this property is true then
     *     tick will advance to the next value in the valuesList array
     *     regardless of the step value.
     */
    snapToList : null,

    /**
     * APIProperty: maxFrameDelay
     * {Number} The number of frame counts to delay the firing of the tick event
     *     while the control waits for its dimension agents to be ready to advance.
     *     Default: 1
     */
    maxFrameDelay : 1,

    /**
     * APIProperty: currentValue
     * {Number} The current value of the series animation
     */
    currentValue : null,

    /**
     * Property: agents
     * {Array(<OpenLayers.Dimension.Agent>)} An array of the agents that
     *     this control "manages". Read-Only
     */
    agents : null,

    /**
     * Property: lastValueIndex
     * {Number} The array index of the last value used in the control when
     * snapToList is true.
     */
    lastValueIndex : -1,

    triggerPrebuffer: function() {
        var progress = this.counter / this.totalCount;
        return this.events.triggerEvent("prebuffer", {progress: progress});
    },

    /**
     * Constructor: OpenLayers.Control.DimensionManager
     * Create a new dimension manager control.
     *
     * Parameters:
     * options - {Object} Optional object whose properties will be set on the
     *     control.
     */
    initialize : function(options) {
        options = options || {};
        OpenLayers.Control.prototype.initialize.call(this, options);
        if(this.model){
            this.syncToModel();
        }
        if(this.agents) {
            var i, len, agent;
            this.totalCount = 0;
            for (i=0, len=this.agents.length; i<len; i++) {
                agent = this.agents[i];
                if (agent instanceof OpenLayers.Dimension.Agent.WMS) {
                    this.totalCount += agent.getNumberOfSteps();
                }
            }
            this.counter = 0;
            for(i = 0, len = this.agents.length; i < len; i++) {
                agent = this.agents[i];
                agent.dimensionManager = this;
                // there are two code paths where we need to prebuffer, one is where
                // a control is configured with agents in its config, the other one is
                // where we use buildAgents to build the agents on the fly.
                if (agent instanceof OpenLayers.Dimension.Agent.WMS) {
                    agent.prebuffer();
                }
                this.events.on({
                    'tick' : agent.onTick,
                    scope : agent
                });
            }
        }
        this.events.on({
            'play' : function() {
                if(!this.agents || !this.agents.length) {
                    console.warn("Attempting to play a dimension manager control without any dimensional layers");
                    return false;
                }
            },
            scope : this
        });
    },

    /**
     * APIMethod: destroy
     * Destroys the control
     */
    destroy : function() {
        for(var i = this.agents.length - 1; i > -1; i--) {
            this.agents[i].destroy();
        }
        OpenLayers.Control.prototype.destroy.call(this);
    },

    /**
     * APIMethod: setMap
     * Sets the map parameter of the control. Also called automattically when
     * the control is added to the map.
     * Parameter:
     *    map {<OpenLayers.Map>}
     */
    setMap : function(map) {
        OpenLayers.Control.prototype.setMap.call(this, map);
        //if the control was not directly initialized with a model, then
        //get layers from map and build the model and the dimension agents
        if(!this.model){
            this.model = new OpenLayers.Dimension.Model({
                map:map,
                dimension:this.dimension,
                syncToMap:this.autoSync
            });
        } else {
            //TODO don't recalc model if it is provided, unless autoSync is true
            if(this.model && !(this.model instanceof OpenLayers.Dimension.Model)){
                this.model = new OpenLayers.Dimension.Model(OpenLayers.Util.applyDefaults(this.model,{'map':map}));
            }
        }
        this.syncToModel();
        if(this.autoSync){
            this.model.events.on({
                'rangemodified': this.onModelRangeModified,
                'valuesmodified': this.onModelValuesModified,
                'addlayer': this.onModelLayerAdded,
                'removelayer': this.onModelLayerRemoved,
                scope: this
            });
        }
        if(!this.agents && map.layers.length) {
            this.agents = this.buildAgents(this.model);
            // loop over the agents created with buildAgents if any and prebuffer
            if (this.agents !== null) {
                var i, ii, agent;
                this.totalCount = 0;
                for (i=0, ii=this.agents.length; i<ii; i++) {
                    agent = this.agents[i];
                    if (agent instanceof OpenLayers.Dimension.Agent.WMS) {
                        this.totalCount += agent.getNumberOfSteps();
                    }
                }
                this.counter = 0;
                for (i=0, ii=this.agents.length; i<ii; ++i) {
                    agent = this.agents[i];
                    if (agent instanceof OpenLayers.Dimension.Agent.WMS) {
                        agent.prebuffer();
                    }
                }
            }
        }
        if(this.modelCache && this.modelCache.range && !this.animationRange){
            this.setAnimationRange(this.modelCache.range);
        }
        if(this.animationRange && !this.currentValue){
            this.setCurrentValue(this.animationRange[0]);
        } else if(this.currentValue) {
            this.setCurrentValue(this.currentValue);
        }
    },

    /**
     * Method: tick
     * Advance/reverse dimension values one step forward/backward. Fires the 'tick' event
     * if value can be incremented without exceeding the value range.
     *
     */
    tick : function() {
        var model = this.modelCache;
        if(model.values && this.snapToList) {
            var values = model.values;
            var newIndex = this.lastValueIndex + ((this.step > 0) ? 1 : -1);
            if(newIndex < values.length && newIndex > -1) {
                this.currentValue = values[newIndex];
                this.lastValueIndex = newIndex;
            }
            else {
                //force the currentValue beyond the range
                this.currentValue = (this.step > 0) ? this.animationRange[1] + 100 : this.animationRange[0] - 100;
            }
        }
        else {
            this.incrementValue();
        }
        //test if we have reached the end of our range
        if(this.currentValue > this.model.range[1] || this.currentValue < this.model.range[0]) {
            //loop in looping mode
            if(this.loop) {
                this.clearTimer();
                this.reset(true);
                this.play();
            }
            //stop in normal mode
            else {
                this.clearTimer();
                this._stopped = true;
                this.events.triggerEvent('stop', {
                    'rangeExceeded' : true
                });
            }
        }
        else {
            if(this.canTickCheck()) {
                this.events.triggerEvent('tick', {
                    currentValue : this.currentValue
                });
            }
            else {
                var intervalId, checkCount = 0, maxDelays = this.maxFrameDelay * 4;
                var playing = !!this.timer;
                this.clearTimer();
                intervalId = setInterval(OpenLayers.Function.bind(function() {
                    var doTick = this.canTickCheck() || checkCount++ >= maxDelays;
                    if(doTick) {
                        clearInterval(intervalId);
                        this.events.triggerEvent('tick', {
                            currentValue : this.currentValue
                        });
                        if(!this._stopped && playing){
                            this.clearTimer();
                            this.timer = setInterval(OpenLayers.Function.bind(this.tick, this), 1000 / this.frameRate);
                        }
                    }
                }, this), 1000 / (this.frameRate * 4));
            }
        }
    },

    /**
     * APIMethod: play
     * Begins/resumes the series animation. Fires the 'play' event,
     * then calls 'tick' at the interval set by the frameRate property
     */
    play : function() {
        //ensure that we don't have multiple timers running
        this.clearTimer();
        //start playing
        if(this.events.triggerEvent('play') !== false) {
            delete this._stopped;
            this.tick();
            this.clearTimer(); //no seriously we really really only want 1 timer
            this.timer = setInterval(OpenLayers.Function.bind(this.tick, this), 1000 / this.frameRate);
        }
    },

    /**
     * APIMethod: stop
     * Stops the time-series animation. Fires the 'stop' event.
     */
    stop : function() {
        this.clearTimer();
        this._stopped = true;
        this.events.triggerEvent('stop', {
            'rangeExceeded' : false
        });
    },

    /**
     * APIMethod: setAnimationRange
     * Sets the value range used by this control. Will modify the
     * current value only if the animation is not currently running
     *
     * Parameters:
     * range - {Array(Number)}
     * setTime - {Boolean} false to avoid affecting the currentTime
     *    true to set affect the currentTime even if playback has started
     *    default is undefined. anything other than strictly true or false
     *    will be disregarded.
     */
    setAnimationRange : function(range, setTime) {
        var oldRange = this.animationRange || this.model.range.slice(0) || [NaN,NaN];
        this.animationRange = range;
        //set current value to correct location if the timer isn't running yet.
        if(!this.timer && setTime !== false || setTime === true) {
            this.currentValue = range[(this.step > 0) ? 0 : 1];
        }
        if(range[0] != oldRange[0] || range[1] != oldRange[1]) {
            this.events.triggerEvent("rangemodified");
        }
    },

    /**
     * APIMethod: setAnimationStart
     * Sets the start value for an animation. If the step is negative then this
     * sets the maximum value in the control's range parameter. Will only effect
     * the currentValue if an animation has not begun.
     *
     * Parameters:
     * value - {Number}
     */
    setAnimationStart : function(value) {
        if(this.step>0){
            this.setAnimationRange([value,this.animationRange[1]]);
        } else {
            this.setAnimationRange([this.animationRange[0],value]);
        }
    },

    /**
     * APIMethod: setAnimationEnd
     * Sets the end value for an animation. If the step is negative then this
     * sets the minimum value in the control's range parameter. Will not effect
     * the current value.
     *
     * Parameters:
     * value - {Number}
     */
    setAnimationEnd : function(value) {
        //set the end but don't change current time
        if(this.step>0){
            this.setAnimationRange([this.animationRange[0],value], false);
        } else {
            this.setAnimationRange([value,this.animationRange[1]], false);
        }
    },

    /**
     * APIMethod:setCurrentValue
     * Manually sets the currentValue used in the control's animation.
     *
     * Parameters:
     * value - {Number}
     * silent - {Boolean} true to prevent tick event from firing
     *   default is false.
     */
    setCurrentValue : function(value, silent) {
        if(this.snapToList && this.modelCache.values) {
            var values = this.modelCache.values;
            var nearest = OpenLayers.Control.DimensionManager.findNearestValues(value, values);
            if(!nearest){
                return;
            }
            var index = this.lastValueIndex;
            if(nearest.exact > -1){
                index = nearest.exact;
            } else if(nearest.before > -1 &&  nearest.after > -1) {
                //requested value is somewhere between 2 valid values
                //find the actual closest one.
                var bdiff = Math.abs(values[nearest.before] - this.currentValue);
                var adiff = Math.abs(this.currentValue - values[nearest.after]);
                index = (adiff > bdiff) ? nearest.before : nearest.after;
            } else if (nearest.before > -1){
                index = nearest.before;
            } else if (nearest.after >-1){
                index = nearest.after;
            }
            this.currentValue = values[index];
            if (index === this.lastValueIndex) {
                silent = true;
            }
            this.lastValueIndex = index;
        }
        else {
            this.currentValue = value;
        }
        if(silent !== true){
            this.events.triggerEvent('tick', {
                'currentValue' : this.currentValue
            });
        }
    },

    /**
     * APIMethod:setFrameRate
     * Sets the control's playback frameRate (ticks/second)
     * Parameters: {Number} rate - the ticks/second rate
     */
    setFrameRate: function(rate){
        var playing = !!this.timer;
        this.clearTimer();
        this.frameRate = rate;
        if(playing){
            //this.tick();
            this.timer = setInterval(OpenLayers.Function.bind(this.tick, this), 1000 / this.frameRate);
        }
    },
    /**
     * APIMethod:reset
     * Resets the current value to the animation start value. Fires the 'reset'
     *    event.
     *
     * Returns:
     * {Number} the control's currentValue, which is also the control's start
     *    value
     */
    reset : function(looped) {
        this.clearTimer();
        this.setCurrentValue(this.animationRange[(this.step > 0) ? 0 : 1]);
        this.events.triggerEvent('reset', {
            'looped' : !!looped
        });
        return this.currentValue;
    },

    /**
     * APIMethod: incrementValue
     * Moves the current animation value forward by the specified step
     *
     * Parameters:
     * step - {Number}
     */
    incrementValue : function(step) {
        var newVal;
        if(this.dimension == 'time' && this.timeUnits){
            newVal = this.incrementTimeValue();
        } else {
            step = step || this.step;
            newVal = parseFloat(this.currentValue) + parseFloat(step);
        }
        this.setCurrentValue(newVal, true);
    },

    /**
     * Method: incrementTimeValue
     * (Private) Returns a new value incremented by step * timeUnit
     *
     * Parameter:
     * step - {Number} number of time units to advance by
     * timeUnits - {OpenLayers.TimeUnit}
     * value - {Date}/{Number}
     *
     * Returns:
     * {Number} the new value
     */
    incrementTimeValue : function(step, timeUnits, value){
        step = step || this.timeStep;
        timeUnits = timeUnits || this.timeUnits;
        value = value || this.currentValue;
        if(!(value instanceof Date)){
            value = new Date(value);
        }
        var newPart = parseFloat(value['getUTC'+timeUnits]()) + parseFloat(step);
        value['setUTC'+timeUnits](newPart);
        return value.getTime();
    },

    /**
     * Method: buildAgents
     * Creates the agents "managed" by this control.
     *
     * Parameters:
     * model - {OpenLayers.Dimension.Model} or {OpenLayers.Layer} with dimensional metadata
     *    Defaults to this.model. Also supports passing a single layer with
     *     dimensional metadata (ie layer.metadata.timeInfo).
     * dimension - {String} (OPTIONAL) Dimension agents will control.
     *    Defaults to this.dimension
     *
     * Returns:
     * {Array(<OpenLayers.Dimension.Agent>)}
     */
    buildAgents : function(model, dimension) {
        model = model || this.model;
        if(!model){ return []; }
        dimension = dimension || this.dimension || this.model.dimension;
        var layers = model.layers;
        if(!layers && model instanceof OpenLayers.Layer && model.metadata[dimension+'Info']){
            layers = [model];
            model = model.metadata[dimension+'Info'];
        }
        var layerTypes = {};
        var agents = [], agent;
        //categorize layers and separate into arrays for use in subclasses
        for(var i = 0, len = layers.length; i < len; i++) {
            var lyr = layers[i];
            if(!((lyr.dimensions && dimension in lyr.dimensions) || (lyr.metadata && dimension+'Info' in lyr.metadata))){
                //don't build agents for layers without this dimension
                continue;
            }
            //allow user specified overrides and custom behavior
            if(lyr.dimensionAgent) {
                if(lyr.dimensionAgent instanceof Function) {
                    agent = new OpenLayers.Dimension.Agent({
                        onTick : lyr.dimensionAgent,
                        layers : [lyr],
                        'dimension' : dimension,
                        dimensionManager : this
                    });
                    delete lyr.dimensionAgent;
                }
                this.events.on({
                    tick : agent.onTick,
                    scope : agent
                });
                agents.push(agent);
            }
            else {
                var lyrClass = lyr.CLASS_NAME.match(/\.Layer\.(\w+)/)[1];
                if(!OpenLayers.Dimension.Agent[lyrClass]) {
                    lyrClass = 'base';
                    console.warn("No OpenLayers.Dimension.Agent subclass available for " + lyr.CLASS_NAME + ". Using base class instead");
                }
                if(!layerTypes[lyrClass]) {
                    layerTypes[lyrClass] = [];
                }
                layerTypes[lyrClass].push(lyr);
            }
        }

        //create subclassed dimension agents
        for(var k in layerTypes) {
            var agentOpts = {
                layers : layerTypes[k],
                'dimension' : dimension,
                dimensionManager : this
            };

            if(this.agentOptions && this.agentOptions[k]) {
                OpenLayers.Util.applyDefaults(agentOpts, this.agentOptions[k]);
            }

            if(k == 'base'){
                agent = new OpenLayers.Dimension.Agent(agentOpts);
            } else {
                agent = new OpenLayers.Dimension.Agent[k](agentOpts);
            }

            this.events.on({
                'tick' : agent.onTick,
                scope : agent
            });
            agents.push(agent);
        }
        return (agents.length) ? agents : null;
    },

    removeAgentLayer : function(lyr) {
        //find the agent with the layer
        if(this.agents && this.agents.length){
            for(var i = 0, len = this.agents.length; i < len; i++) {
                var agent = this.agents[i];
                if(OpenLayers.Util.indexOf(agent.layers, lyr) > -1) {
                    agent.removeLayer(lyr);
                    //if the agent doesn't handle any layers, get rid of it
                    if(!agent.layers || !agent.layers.length) {
                        this.agents.splice(i, 1);
                        agent.destroy();
                    }
                    break;
                }
            }
        }
    },

    addAgentLayer : function(layer) {
        var added = false;
        var agentClass = layer.CLASS_NAME.match(/\.Layer\.(\w+)/)[1];
        if(agentClass in OpenLayers.Dimension.Agent) {
            if(!this.agents){ this.agents = []; }
            for(var i = 0, len = this.agents.length; i < len; i++) {
                if(!layer.dimensionAgent && this.agents[i] instanceof OpenLayers.Dimension.Agent[agentClass]) {
                    this.agents[i].addLayer(layer);
                    added = true;
                    break;
                }
            }
        }
        if(!added) {
            var agents = this.buildAgents(layer);
            if(agents) {
                this.agents.push(agents[0]);
                added = true;
            }
        }
        return added;
    },

    syncToModel: function(model){
        model = model || this.model;
        this.modelCache = {
            range: model.range,
            values: model.values,
            resolution: model.resolution
        };
        return this.modelCache;
    },

    onModelRangeModified: function(evtObj){
        var range = evtObj.range;
        this.syncToModel(evtObj.object);
        this.setAnimationRange(range);
    },

    onModelValuesModified: function(evtObj){
        var values = evtObj.values;
        this.syncToModel(evtObj.object);
    },

    onModelLayerAdded: function(evtObj){
        this.addAgentLayer(evtObj.layer);
    },

    onModelLayerRemoved: function(evtObj){
        this.removeAgentLayer(evtObj.layer);
    },

    guessPlaybackRate : function(model) {
        if(!this.agents) {
            return;
        } else {
            model = model || this.model;
            if(model.values) {
                this.snapToList = true;
            } else {
                var settings = model.guessPlaybackRate();
                OpenLayers.Util.extend(this, settings);
            }
        }
    },

    canTickCheck : function() {
        var canTick = false;
        for(var i = 0, len = this.agents.length; i < len; i++) {
            canTick = this.agents[i].canTick;
            if(!canTick) {
                break;
            }
        }
        return canTick;
    },

    clearTimer : function() {
        if(this.timer) {
            clearInterval(this.timer);
            this.timer = null;
        }
    },

    CLASS_NAME : 'OpenLayers.Control.DimensionManager'
});

/** Static Methods **/

OpenLayers.Util.extend(OpenLayers.Control.DimensionManager, {

    /**
     * Method: findNearestValues
     *    Finds the nearest value(s) index for a given test value. If an exact
     *    match is found, it will return the index for that value. However, if
     *    no exact match is found, then it will return the indexes before &
     *    after the test values. If the nearest value is a the end of the range
     *    then it returns -1 for the other values.
     * Parameters:
     *    testValue - {Number} the value to test against the value array.
     *    values - {Array{Number}} the sorted value array.
     * Returns: {Object} or {Boolean} with the following properties:
     *    exact, before, after
     *    All values will be either -1 or the index of the appropriate key. If
     *    an exact value is found both 'before'  and 'after' will always be -1.
     *    If the test value is outside of the range of the values array, then
     *    the function returns false.
     */

    findNearestValues : function(testValue, values) {
        var retObj = {
            exact : -1,
            before : -1,
            after : -1
        };
        //first check if this value is in the array
        var index = OpenLayers.Util.indexOf(values, testValue);
        if(index > -1) {
            //found an exact value
            retObj.exact = index;
        }
        else {
            //no exact value was found. test that this is even in the range
            if(testValue < values[0] || testValue > values[values.length - 1]) {
                //outside of the range, return false
                return false;
            }
            else {
                //value is within the range, find the nearest indices
                for(var i = 0, len = values.length; i < len; i++) {
                    var diff = testValue - values[i];
                    if(diff < 0) {
                        retObj.after = i;
                        retObj.before = i - 1;
                        break;
                    }
                    else {
                        retObj.before = i;
                    }
                }
            }
        }
        return retObj;
    }

});


text:
angular.module('todo-list', ['todo-services']);

require('./list-controller.js');
require('./list-directive.js');

redpajama_set_name: RedPajamaGithub


text:
namespace XenAdmin.TabPages
{
    partial class GeneralTabPage
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                if (licenseStatus != null)
                    licenseStatus.Dispose();

                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Component Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(GeneralTabPage));
            this.buttonProperties = new System.Windows.Forms.Button();
            this.buttonViewConsole = new System.Windows.Forms.Button();
            this.buttonViewLog = new System.Windows.Forms.Button();
            this.linkLabelExpand = new System.Windows.Forms.LinkLabel();
            this.linkLabelCollapse = new System.Windows.Forms.LinkLabel();
            this.panel2 = new XenAdmin.Controls.PanelNoFocusScroll();
            this.panelReadCaching = new System.Windows.Forms.Panel();
            this.pdSectionReadCaching = new XenAdmin.Controls.PDSection();
            this.panelDockerInfo = new System.Windows.Forms.Panel();
            this.pdSectionDockerInfo = new XenAdmin.Controls.PDSection();
            this.panelDockerVersion = new System.Windows.Forms.Panel();
            this.pdSectionDockerVersion = new XenAdmin.Controls.PDSection();
            this.panelStorageLinkSystemCapabilities = new System.Windows.Forms.Panel();
            this.pdSectionStorageLinkSystemCapabilities = new XenAdmin.Controls.PDSection();
            this.panelMultipathBoot = new System.Windows.Forms.Panel();
            this.pdSectionMultipathBoot = new XenAdmin.Controls.PDSection();
            this.panelStorageLink = new System.Windows.Forms.Panel();
            this.pdStorageLink = new XenAdmin.Controls.PDSection();
            this.panelMemoryAndVCPUs = new System.Windows.Forms.Panel();
            this.pdSectionVCPUs = new XenAdmin.Controls.PDSection();
            this.panelMultipathing = new System.Windows.Forms.Panel();
            this.pdSectionMultipathing = new XenAdmin.Controls.PDSection();
            this.panelStatus = new System.Windows.Forms.Panel();
            this.pdSectionStatus = new XenAdmin.Controls.PDSection();
            this.panelHighAvailability = new System.Windows.Forms.Panel();
            this.pdSectionHighAvailability = new XenAdmin.Controls.PDSection();
            this.panelBootOptions = new System.Windows.Forms.Panel();
            this.pdSectionBootOptions = new XenAdmin.Controls.PDSection();
            this.panelCPU = new System.Windows.Forms.Panel();
            this.pdSectionCPU = new XenAdmin.Controls.PDSection();
            this.panelMemory = new System.Windows.Forms.Panel();
            this.pdSectionMemory = new XenAdmin.Controls.PDSection();
            this.panelManagementInterfaces = new System.Windows.Forms.Panel();
            this.pdSectionManagementInterfaces = new XenAdmin.Controls.PDSection();
            this.panelUpdates = new System.Windows.Forms.Panel();
            this.pdSectionUpdates = new XenAdmin.Controls.PDSection();
            this.panelVersion = new System.Windows.Forms.Panel();
            this.pdSectionVersion = new XenAdmin.Controls.PDSection();
            this.panelLicense = new System.Windows.Forms.Panel();
            this.pdSectionLicense = new XenAdmin.Controls.PDSection();
            this.panelCustomFields = new System.Windows.Forms.Panel();
            this.pdSectionCustomFields = new XenAdmin.Controls.PDSection();
            this.panelGeneral = new System.Windows.Forms.Panel();
            this.pdSectionGeneral = new XenAdmin.Controls.PDSection();
            this.tableLayoutPanelButtons = new System.Windows.Forms.TableLayoutPanel();
            this.pageContainerPanel.SuspendLayout();
            this.panel2.SuspendLayout();
            this.panelReadCaching.SuspendLayout();
            this.panelDockerInfo.SuspendLayout();
            this.panelDockerVersion.SuspendLayout();
            this.panelStorageLinkSystemCapabilities.SuspendLayout();
            this.panelMultipathBoot.SuspendLayout();
            this.panelStorageLink.SuspendLayout();
            this.panelMemoryAndVCPUs.SuspendLayout();
            this.panelMultipathing.SuspendLayout();
            this.panelStatus.SuspendLayout();
            this.panelHighAvailability.SuspendLayout();
            this.panelBootOptions.SuspendLayout();
            this.panelCPU.SuspendLayout();
            this.panelMemory.SuspendLayout();
            this.panelManagementInterfaces.SuspendLayout();
            this.panelUpdates.SuspendLayout();
            this.panelVersion.SuspendLayout();
            this.panelLicense.SuspendLayout();
            this.panelCustomFields.SuspendLayout();
            this.panelGeneral.SuspendLayout();
            this.tableLayoutPanelButtons.SuspendLayout();
            this.SuspendLayout();
            //
            // pageContainerPanel
            //
            this.pageContainerPanel.Controls.Add(this.panel2);
            this.pageContainerPanel.Controls.Add(this.tableLayoutPanelButtons);
            resources.ApplyResources(this.pageContainerPanel, "pageContainerPanel");
            //
            // buttonProperties
            //
            resources.ApplyResources(this.buttonProperties, "buttonProperties");
            this.buttonProperties.Name = "buttonProperties";
            this.buttonProperties.UseVisualStyleBackColor = true;
            this.buttonProperties.Click += new System.EventHandler(this.EditButton_Click);
            //
            // buttonViewConsole
            //
            resources.ApplyResources(this.buttonViewConsole, "buttonViewConsole");
            this.buttonViewConsole.Name = "buttonViewConsole";
            this.buttonViewConsole.UseVisualStyleBackColor = true;
            this.buttonViewConsole.Click += new System.EventHandler(this.buttonViewConsole_Click);
            //
            // buttonViewLog
            //
            resources.ApplyResources(this.buttonViewLog, "buttonViewLog");
            this.buttonViewLog.Name = "buttonViewLog";
            this.buttonViewLog.UseVisualStyleBackColor = true;
            this.buttonViewLog.Click += new System.EventHandler(this.buttonViewLog_Click);
            //
            // linkLabelExpand
            //
            resources.ApplyResources(this.linkLabelExpand, "linkLabelExpand");
            this.linkLabelExpand.Name = "linkLabelExpand";
            this.linkLabelExpand.TabStop = true;
            this.linkLabelExpand.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabelExpand_LinkClicked);
            //
            // linkLabelCollapse
            //
            resources.ApplyResources(this.linkLabelCollapse, "linkLabelCollapse");
            this.linkLabelCollapse.Name = "linkLabelCollapse";
            this.linkLabelCollapse.TabStop = true;
            this.linkLabelCollapse.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabelCollapse_LinkClicked);
            //
            // panel2
            //
            resources.ApplyResources(this.panel2, "panel2");
            this.panel2.Controls.Add(this.panelReadCaching);
            this.panel2.Controls.Add(this.panelDockerInfo);
            this.panel2.Controls.Add(this.panelDockerVersion);
            this.panel2.Controls.Add(this.panelStorageLinkSystemCapabilities);
            this.panel2.Controls.Add(this.panelMultipathBoot);
            this.panel2.Controls.Add(this.panelStorageLink);
            this.panel2.Controls.Add(this.panelMemoryAndVCPUs);
            this.panel2.Controls.Add(this.panelMultipathing);
            this.panel2.Controls.Add(this.panelStatus);
            this.panel2.Controls.Add(this.panelHighAvailability);
            this.panel2.Controls.Add(this.panelBootOptions);
            this.panel2.Controls.Add(this.panelCPU);
            this.panel2.Controls.Add(this.panelMemory);
            this.panel2.Controls.Add(this.panelManagementInterfaces);
            this.panel2.Controls.Add(this.panelUpdates);
            this.panel2.Controls.Add(this.panelVersion);
            this.panel2.Controls.Add(this.panelLicense);
            this.panel2.Controls.Add(this.panelCustomFields);
            this.panel2.Controls.Add(this.panelGeneral);
            this.panel2.Name = "panel2";
            //
            // panelReadCaching
            //
            resources.ApplyResources(this.panelReadCaching, "panelReadCaching");
            this.panelReadCaching.Controls.Add(this.pdSectionReadCaching);
            this.panelReadCaching.Name = "panelReadCaching";
            //
            // pdSectionReadCaching
            //
            this.pdSectionReadCaching.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionReadCaching, "pdSectionReadCaching");
            this.pdSectionReadCaching.Name = "pdSectionReadCaching";
            this.pdSectionReadCaching.ShowCellToolTips = false;
            this.pdSectionReadCaching.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelDockerInfo
            //
            resources.ApplyResources(this.panelDockerInfo, "panelDockerInfo");
            this.panelDockerInfo.Controls.Add(this.pdSectionDockerInfo);
            this.panelDockerInfo.Name = "panelDockerInfo";
            //
            // pdSectionDockerInfo
            //
            this.pdSectionDockerInfo.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionDockerInfo, "pdSectionDockerInfo");
            this.pdSectionDockerInfo.Name = "pdSectionDockerInfo";
            this.pdSectionDockerInfo.ShowCellToolTips = false;
            //
            // panelDockerVersion
            //
            resources.ApplyResources(this.panelDockerVersion, "panelDockerVersion");
            this.panelDockerVersion.Controls.Add(this.pdSectionDockerVersion);
            this.panelDockerVersion.Name = "panelDockerVersion";
            //
            // pdSectionDockerVersion
            //
            this.pdSectionDockerVersion.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionDockerVersion, "pdSectionDockerVersion");
            this.pdSectionDockerVersion.Name = "pdSectionDockerVersion";
            this.pdSectionDockerVersion.ShowCellToolTips = false;
            //
            // panelStorageLinkSystemCapabilities
            //
            resources.ApplyResources(this.panelStorageLinkSystemCapabilities, "panelStorageLinkSystemCapabilities");
            this.panelStorageLinkSystemCapabilities.Controls.Add(this.pdSectionStorageLinkSystemCapabilities);
            this.panelStorageLinkSystemCapabilities.Name = "panelStorageLinkSystemCapabilities";
            //
            // pdSectionStorageLinkSystemCapabilities
            //
            this.pdSectionStorageLinkSystemCapabilities.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionStorageLinkSystemCapabilities, "pdSectionStorageLinkSystemCapabilities");
            this.pdSectionStorageLinkSystemCapabilities.Name = "pdSectionStorageLinkSystemCapabilities";
            this.pdSectionStorageLinkSystemCapabilities.ShowCellToolTips = false;
            //
            // panelMultipathBoot
            //
            resources.ApplyResources(this.panelMultipathBoot, "panelMultipathBoot");
            this.panelMultipathBoot.Controls.Add(this.pdSectionMultipathBoot);
            this.panelMultipathBoot.Name = "panelMultipathBoot";
            //
            // pdSectionMultipathBoot
            //
            this.pdSectionMultipathBoot.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionMultipathBoot, "pdSectionMultipathBoot");
            this.pdSectionMultipathBoot.Name = "pdSectionMultipathBoot";
            this.pdSectionMultipathBoot.ShowCellToolTips = false;
            //
            // panelStorageLink
            //
            resources.ApplyResources(this.panelStorageLink, "panelStorageLink");
            this.panelStorageLink.Controls.Add(this.pdStorageLink);
            this.panelStorageLink.Name = "panelStorageLink";
            //
            // pdStorageLink
            //
            this.pdStorageLink.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdStorageLink, "pdStorageLink");
            this.pdStorageLink.Name = "pdStorageLink";
            this.pdStorageLink.ShowCellToolTips = false;
            this.pdStorageLink.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelMemoryAndVCPUs
            //
            resources.ApplyResources(this.panelMemoryAndVCPUs, "panelMemoryAndVCPUs");
            this.panelMemoryAndVCPUs.Controls.Add(this.pdSectionVCPUs);
            this.panelMemoryAndVCPUs.Name = "panelMemoryAndVCPUs";
            //
            // pdSectionVCPUs
            //
            this.pdSectionVCPUs.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionVCPUs, "pdSectionVCPUs");
            this.pdSectionVCPUs.Name = "pdSectionVCPUs";
            this.pdSectionVCPUs.ShowCellToolTips = false;
            this.pdSectionVCPUs.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelMultipathing
            //
            resources.ApplyResources(this.panelMultipathing, "panelMultipathing");
            this.panelMultipathing.Controls.Add(this.pdSectionMultipathing);
            this.panelMultipathing.Name = "panelMultipathing";
            //
            // pdSectionMultipathing
            //
            this.pdSectionMultipathing.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionMultipathing, "pdSectionMultipathing");
            this.pdSectionMultipathing.Name = "pdSectionMultipathing";
            this.pdSectionMultipathing.ShowCellToolTips = false;
            this.pdSectionMultipathing.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelStatus
            //
            resources.ApplyResources(this.panelStatus, "panelStatus");
            this.panelStatus.Controls.Add(this.pdSectionStatus);
            this.panelStatus.Name = "panelStatus";
            //
            // pdSectionStatus
            //
            this.pdSectionStatus.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionStatus, "pdSectionStatus");
            this.pdSectionStatus.Name = "pdSectionStatus";
            this.pdSectionStatus.ShowCellToolTips = false;
            this.pdSectionStatus.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelHighAvailability
            //
            resources.ApplyResources(this.panelHighAvailability, "panelHighAvailability");
            this.panelHighAvailability.Controls.Add(this.pdSectionHighAvailability);
            this.panelHighAvailability.Name = "panelHighAvailability";
            //
            // pdSectionHighAvailability
            //
            this.pdSectionHighAvailability.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionHighAvailability, "pdSectionHighAvailability");
            this.pdSectionHighAvailability.Name = "pdSectionHighAvailability";
            this.pdSectionHighAvailability.ShowCellToolTips = false;
            this.pdSectionHighAvailability.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelBootOptions
            //
            resources.ApplyResources(this.panelBootOptions, "panelBootOptions");
            this.panelBootOptions.Controls.Add(this.pdSectionBootOptions);
            this.panelBootOptions.Name = "panelBootOptions";
            //
            // pdSectionBootOptions
            //
            this.pdSectionBootOptions.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionBootOptions, "pdSectionBootOptions");
            this.pdSectionBootOptions.Name = "pdSectionBootOptions";
            this.pdSectionBootOptions.ShowCellToolTips = false;
            this.pdSectionBootOptions.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelCPU
            //
            resources.ApplyResources(this.panelCPU, "panelCPU");
            this.panelCPU.Controls.Add(this.pdSectionCPU);
            this.panelCPU.Name = "panelCPU";
            //
            // pdSectionCPU
            //
            this.pdSectionCPU.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionCPU, "pdSectionCPU");
            this.pdSectionCPU.Name = "pdSectionCPU";
            this.pdSectionCPU.ShowCellToolTips = false;
            this.pdSectionCPU.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelMemory
            //
            resources.ApplyResources(this.panelMemory, "panelMemory");
            this.panelMemory.Controls.Add(this.pdSectionMemory);
            this.panelMemory.Name = "panelMemory";
            //
            // pdSectionMemory
            //
            this.pdSectionMemory.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionMemory, "pdSectionMemory");
            this.pdSectionMemory.Name = "pdSectionMemory";
            this.pdSectionMemory.ShowCellToolTips = false;
            this.pdSectionMemory.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelManagementInterfaces
            //
            resources.ApplyResources(this.panelManagementInterfaces, "panelManagementInterfaces");
            this.panelManagementInterfaces.Controls.Add(this.pdSectionManagementInterfaces);
            this.panelManagementInterfaces.Name = "panelManagementInterfaces";
            //
            // pdSectionManagementInterfaces
            //
            this.pdSectionManagementInterfaces.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionManagementInterfaces, "pdSectionManagementInterfaces");
            this.pdSectionManagementInterfaces.Name = "pdSectionManagementInterfaces";
            this.pdSectionManagementInterfaces.ShowCellToolTips = false;
            this.pdSectionManagementInterfaces.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelUpdates
            //
            resources.ApplyResources(this.panelUpdates, "panelUpdates");
            this.panelUpdates.Controls.Add(this.pdSectionUpdates);
            this.panelUpdates.Name = "panelUpdates";
            //
            // pdSectionUpdates
            //
            this.pdSectionUpdates.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionUpdates, "pdSectionUpdates");
            this.pdSectionUpdates.Name = "pdSectionUpdates";
            this.pdSectionUpdates.ShowCellToolTips = false;
            this.pdSectionUpdates.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelVersion
            //
            resources.ApplyResources(this.panelVersion, "panelVersion");
            this.panelVersion.Controls.Add(this.pdSectionVersion);
            this.panelVersion.Name = "panelVersion";
            //
            // pdSectionVersion
            //
            this.pdSectionVersion.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionVersion, "pdSectionVersion");
            this.pdSectionVersion.Name = "pdSectionVersion";
            this.pdSectionVersion.ShowCellToolTips = false;
            this.pdSectionVersion.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelLicense
            //
            resources.ApplyResources(this.panelLicense, "panelLicense");
            this.panelLicense.Controls.Add(this.pdSectionLicense);
            this.panelLicense.Name = "panelLicense";
            //
            // pdSectionLicense
            //
            this.pdSectionLicense.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionLicense, "pdSectionLicense");
            this.pdSectionLicense.Name = "pdSectionLicense";
            this.pdSectionLicense.ShowCellToolTips = false;
            this.pdSectionLicense.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelCustomFields
            //
            resources.ApplyResources(this.panelCustomFields, "panelCustomFields");
            this.panelCustomFields.Controls.Add(this.pdSectionCustomFields);
            this.panelCustomFields.Name = "panelCustomFields";
            //
            // pdSectionCustomFields
            //
            this.pdSectionCustomFields.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionCustomFields, "pdSectionCustomFields");
            this.pdSectionCustomFields.Name = "pdSectionCustomFields";
            this.pdSectionCustomFields.ShowCellToolTips = true;
            this.pdSectionCustomFields.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // panelGeneral
            //
            resources.ApplyResources(this.panelGeneral, "panelGeneral");
            this.panelGeneral.Controls.Add(this.pdSectionGeneral);
            this.panelGeneral.Name = "panelGeneral";
            //
            // pdSectionGeneral
            //
            this.pdSectionGeneral.BackColor = System.Drawing.Color.Gainsboro;
            resources.ApplyResources(this.pdSectionGeneral, "pdSectionGeneral");
            this.pdSectionGeneral.Name = "pdSectionGeneral";
            this.pdSectionGeneral.ShowCellToolTips = false;
            this.pdSectionGeneral.ExpandedChanged += new System.Action<XenAdmin.Controls.PDSection>(this.pdSection_ExpandedChanged);
            //
            // tableLayoutPanelButtons
            //
            resources.ApplyResources(this.tableLayoutPanelButtons, "tableLayoutPanelButtons");
            this.tableLayoutPanelButtons.Controls.Add(this.buttonViewLog, 2, 0);
            this.tableLayoutPanelButtons.Controls.Add(this.buttonViewConsole, 1, 0);
            this.tableLayoutPanelButtons.Controls.Add(this.buttonProperties, 0, 0);
            this.tableLayoutPanelButtons.Controls.Add(this.linkLabelCollapse, 5, 0);
            this.tableLayoutPanelButtons.Controls.Add(this.linkLabelExpand, 4, 0);
            this.tableLayoutPanelButtons.Name = "tableLayoutPanelButtons";
            //
            // GeneralTabPage
            //
            resources.ApplyResources(this, "$this");
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
            this.DoubleBuffered = true;
            this.Name = "GeneralTabPage";
            this.pageContainerPanel.ResumeLayout(false);
            this.pageContainerPanel.PerformLayout();
            this.panel2.ResumeLayout(false);
            this.panel2.PerformLayout();
            this.panelReadCaching.ResumeLayout(false);
            this.panelDockerInfo.ResumeLayout(false);
            this.panelDockerVersion.ResumeLayout(false);
            this.panelStorageLinkSystemCapabilities.ResumeLayout(false);
            this.panelMultipathBoot.ResumeLayout(false);
            this.panelStorageLink.ResumeLayout(false);
            this.panelMemoryAndVCPUs.ResumeLayout(false);
            this.panelMultipathing.ResumeLayout(false);
            this.panelStatus.ResumeLayout(false);
            this.panelHighAvailability.ResumeLayout(false);
            this.panelBootOptions.ResumeLayout(false);
            this.panelCPU.ResumeLayout(false);
            this.panelMemory.ResumeLayout(false);
            this.panelManagementInterfaces.ResumeLayout(false);
            this.panelUpdates.ResumeLayout(false);
            this.panelVersion.ResumeLayout(false);
            this.panelLicense.ResumeLayout(false);
            this.panelCustomFields.ResumeLayout(false);
            this.panelGeneral.ResumeLayout(false);
            this.tableLayoutPanelButtons.ResumeLayout(false);
            this.tableLayoutPanelButtons.PerformLayout();
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Button buttonProperties;
        private XenAdmin.Controls.PanelNoFocusScroll panel2;
        private System.Windows.Forms.Panel panelGeneral;
        private XenAdmin.Controls.PDSection pdSectionGeneral;
        private System.Windows.Forms.Panel panelMemoryAndVCPUs;
        private XenAdmin.Controls.PDSection pdSectionVCPUs;
        private System.Windows.Forms.Panel panelBootOptions;
        private XenAdmin.Controls.PDSection pdSectionBootOptions;
        private System.Windows.Forms.Panel panelMultipathing;
        private XenAdmin.Controls.PDSection pdSectionMultipathing;
        private System.Windows.Forms.Panel panelStatus;
        private XenAdmin.Controls.PDSection pdSectionStatus;
        private System.Windows.Forms.Panel panelHighAvailability;
        private XenAdmin.Controls.PDSection pdSectionHighAvailability;
        private System.Windows.Forms.Panel panelCustomFields;
        private XenAdmin.Controls.PDSection pdSectionCustomFields;
        private System.Windows.Forms.Panel panelManagementInterfaces;
        private XenAdmin.Controls.PDSection pdSectionManagementInterfaces;
        private System.Windows.Forms.Panel panelCPU;
        private XenAdmin.Controls.PDSection pdSectionCPU;
        private System.Windows.Forms.Panel panelVersion;
        private XenAdmin.Controls.PDSection pdSectionVersion;
        private System.Windows.Forms.Panel panelLicense;
        private XenAdmin.Controls.PDSection pdSectionLicense;
        private System.Windows.Forms.Panel panelMemory;
        private XenAdmin.Controls.PDSection pdSectionMemory;
        private System.Windows.Forms.Panel panelUpdates;
        private XenAdmin.Controls.PDSection pdSectionUpdates;
        private System.Windows.Forms.LinkLabel linkLabelExpand;
        private System.Windows.Forms.LinkLabel linkLabelCollapse;
        private System.Windows.Forms.Panel panelStorageLink;
        private XenAdmin.Controls.PDSection pdStorageLink;
        private System.Windows.Forms.Panel panelMultipathBoot;
        private XenAdmin.Controls.PDSection pdSectionMultipathBoot;
        private System.Windows.Forms.Panel panelStorageLinkSystemCapabilities;
        private XenAdmin.Controls.PDSection pdSectionStorageLinkSystemCapabilities;
        private System.Windows.Forms.Panel panelDockerInfo;
        private System.Windows.Forms.Panel panelDockerVersion;
        private Controls.PDSection pdSectionDockerVersion;
        private Controls.PDSection pdSectionDockerInfo;
        private System.Windows.Forms.Panel panelReadCaching;
        private Controls.PDSection pdSectionReadCaching;
        private System.Windows.Forms.Button buttonViewConsole;
        private System.Windows.Forms.Button buttonViewLog;
        private System.Windows.Forms.TableLayoutPanel tableLayoutPanelButtons;
    }
}


text:
namespace vv {

namespace value {

// Vivaldi class for iterating through an Array.
struct array_iterator : public basic_object {
public:
  // Constructs an array_iterator pointing to the start of arr.
  array_iterator(gc::managed_ptr arr);

  struct value_type {
    // Owning array.
    gc::managed_ptr arr;
    // Position within arr. Implemented as size_t, and not as an std::vector
    // iterator, so as to persist through vector resizes.
    size_t idx;
  };

  value_type value;
};

}

}

#endif


text:
namespace BrowserAutomationStudioFramework
{
    IDiffPatcher::IDiffPatcher(QObject *parent) :
        QObject(parent)
    {

    }

}


text:
using System.Data.Entity;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;

namespace RiskApp.Models
{
    // Чтобы добавить данные профиля для пользователя, можно добавить дополнительные свойства в класс ApplicationUser. Дополнительные сведения см. по адресу: http://go.microsoft.com/fwlink/?LinkID=317594.
    public class ApplicationUser : IdentityUser
    {
        public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
        {
            // Обратите внимание, что authenticationType должен совпадать с типом, определенным в CookieAuthenticationOptions.AuthenticationType
            var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
            // Здесь добавьте утверждения пользователя
            return userIdentity;
        }
    }

    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
    {
        public ApplicationDbContext()
            : base("DefaultConnection", throwIfV1Schema: false)
        {
        }

        public static ApplicationDbContext Create()
        {
            return new ApplicationDbContext();
        }
    }
}


text:
using System;
using Encog.ML.EA.Genome;
using Encog.ML.EA.Rules;
using Encog.ML.Prg.ExpValue;

namespace Encog.ML.Prg.Train.Rewrite
{
    /// <summary>
    ///     Rewrite any parts of the tree that are constant with a simple constant value.
    /// </summary>
    public class RewriteConstants : IRewriteRule
    {
        /// <summary>
        ///     True if the expression was rewritten.
        /// </summary>
        private bool _rewritten;

        /// <inheritdoc />
        public bool Rewrite(IGenome g)
        {
            var program = ((EncogProgram) g);
            _rewritten = false;
            ProgramNode rootNode = program.RootNode;
            ProgramNode rewrite = RewriteNode(rootNode);
            if (rewrite != null)
            {
                program.RootNode = rewrite;
            }
            return _rewritten;
        }

        /// <summary>
        ///     Attempt to rewrite the specified node.
        /// </summary>
        /// <param name="node">The node to attempt to rewrite.</param>
        /// <returns>The rewritten node, the original node, if no rewrite occured.</returns>
        private ProgramNode RewriteNode(ProgramNode node)
        {
            // first try to rewrite the child node
            ProgramNode rewrite = TryNodeRewrite(node);
            if (rewrite != null)
            {
                return rewrite;
            }

            // if we could not rewrite the entire node, rewrite as many children as
            // we can
            for (int i = 0; i < node.ChildNodes.Count; i++)
            {
                var childNode = (ProgramNode) node.ChildNodes[i];
                rewrite = RewriteNode(childNode);
                if (rewrite != null)
                {
                    node.ChildNodes.RemoveAt(i);
                    node.ChildNodes.Insert(i, rewrite);
                    _rewritten = true;
                }
            }

            // we may have rewritten some children, but the parent was not
            // rewritten, so return null.
            return null;
        }

        /// <summary>
        ///     Try to rewrite the specified node.
        /// </summary>
        /// <param name="parentNode">The node to attempt rewrite.</param>
        /// <returns>The rewritten node, or original node, if no rewrite could happen.</returns>
        private ProgramNode TryNodeRewrite(ProgramNode parentNode)
        {
            ProgramNode result = null;

            if (parentNode.IsLeaf)
            {
                return null;
            }

            if (parentNode.AllConstDescendants())
            {
                ExpressionValue v = parentNode.Evaluate();
                double ck = v.ToFloatValue();

                // do not rewrite if it produces a div by 0 or other bad result.
                if (Double.IsNaN(ck) || Double.IsInfinity(ck))
                {
                    return null;
                }

                result = parentNode.Owner.Context.Functions
                                   .FactorProgramNode("#const", parentNode.Owner,
                                                      new ProgramNode[] {});

                // is it an integer?
                if (Math.Abs(ck - ((int) ck)) < EncogFramework.DefaultDoubleEqual)
                {
                    result.Data[0] = new ExpressionValue((int) ck);
                }
                else
                {
                    result.Data[0] = v;
                }
            }
            return result;
        }
    }
}


text:
**KOKeyboard** is an iOS drop-in component that adds a new row of keys to the default on-screen keyboard. It consists of swipe buttons with all common symbols, punctuation and brackets, and a special **navigation key**. It was developed for [Kodiak PHP](http://www.becomekodiak.com/), an app which allows you to write and run PHP code directly on the iPad.

## Swipe buttons & Navigation key

A swipe button has 5 symbols on it. If you simply tap it, it will produce the middle symbol. However if you swipe it (tap-and-drag) towards one of the corners, it will produce the symbol in that corner.

The navigation key (the middle one with a circle on it) allows you to navigate in the text by moving the cursor in a direction where you drag. If you drag the navigation key, the cursor will move the same way as you drag. If you double tap and drag it will start selecting text from your current position.

To see the component in action, take a look at the video at [http://www.becomekodiak.com/](http://www.becomekodiak.com/) or try our app called [Kodiak PHP on the App Store](http://itunes.apple.com/us/app/kodiak-php/id542685332?ls=1&mt=8).

## Usage

We included a demo project that shows how to use the component.

First you should have a simple UITextView. To use this component, include the header file `KOKeyboardRow.h` in the top of your source code:

	#import "KOKeyboardRow.h"

Then when you have a UITextView, simply call the static method `[KOKeyboardRow applyToTextView:yourTextView]`:

	UITextView *textView = [[UITextView alloc] initWithFrame:self.view.bounds];
	textView.text = @"some text...";
	[self.view addSubview:textView];
	[KOKeyboardRow applyToTextView:textView];

You will see the additional keyboard after the UITextView gets focus, if you want to do that programmatically, just do this:

	[textView becomeFirstResponder];

And that's it!

## Mark Alldritt's Changes

I have integrated [David Hoerl's CreateButton](https://github.com/dhoerl/CreateShadowedRoundRectButtonImage) iOS7 appearance code into KOKeyboard to make the keyboard accessory view match the look of the iOS7 keyboard.

[David Hoerl](https://github.com/dhoerl) has done is own modifications to the KOKeyboard classes.  While he has added lots of good stuff, there seem to be lots of outstanding issues (e.g. his code does not handle device rotation well while the keyboard is visible).  I'll watch his work, and if it settles down, I'll probably drop my efforts and use his work.

I have added `[KOKeyboardRow applyToTextView:yourTextView keys:@"your key string"]` to make it possible to customize the keyboard keys without having to alter the KOKeyboard source.

## Copyright and license

This product is free and open source and it is distributed under the MIT License. See the file `LICENSE` for the complete text of the license.

## Contact

http://www.becomekodiak.com/

http://www.twitter.com/becomekodiak/

info@becomekodiak.com


text:
module PackageTests.BuildDeps.GlobalBuildDepsNotAdditive1.Check where

import Test.HUnit
import PackageTests.PackageTester
import System.FilePath
import Data.List

suite :: Test
suite = TestCase $ do
    let spec = PackageSpec ("PackageTests" </> "BuildDeps" </> "GlobalBuildDepsNotAdditive1") []
    result <- cabal_build spec
    assertEqual "cabal build should fail - see test-log.txt" False (successful result)
    assertBool "cabal error should be \"Failed to load interface for `Prelude'\"" $
        "Failed to load interface for `Prelude'" `isInfixOf` outputText result


text:
package gwt.material.design.client.ui.text;

import com.google.gwt.safehtml.shared.SafeHtml;
import com.google.gwt.safehtml.shared.SafeHtmlUtils;

public class TextHtmlRenderer extends AbstractSafeHtmlRenderer<String> {

    public TextHtmlRenderer() {
        this(SafeHtmlUtils.fromString("-"));
    }

    public TextHtmlRenderer(SafeHtml defaultHtml) {
        super(defaultHtml);
    }

    @Override
    public SafeHtml safeRender(String object) {
        return SafeHtmlUtils.fromString(object);
    }
}


text:
object Test {
  def precise(x: String)(y: x.type): x.type = y
  val foo = "foo"
  val fun : foo.type => foo.type = precise(foo)
  val bar : foo.type = precise(foo)(foo)
}


text:
from SimpleCV.Color import Color
from SimpleCV.base import time, np
from SimpleCV.Features.Features import Feature, FeatureSet
try:
    import cv2
except ImportError:
    pass

class Track(Feature):
    """
    **SUMMARY**

    Track class is the base of tracking. All different tracking algorithm
    return different classes but they all belong to Track class. All the
    common attributes are kept in this class

    """
    def __init__(self, img, bb):
        """
        **SUMMARY**

        Initializes all the required parameters and attributes of the class.

        **PARAMETERS**

        * *img* - SimpleCV.ImageClass.Image
        * *bb* - A tuple consisting of (x, y, w, h) of the bounding box

        **RETURNS**

        SimpleCV.Tracking.TrackClass.Track object

        **EXAMPLE**

        >>> track = Track(image, bb)
        """
        self.bb = bb
        self.image = img
        self.bb_x, self.bb_y, self.w, self.h = self.bb
        self.x, self.y = self.center = self.getCenter()
        self.sizeRatio = 1
        self.vel = (0,0)
        self.rt_vel = (0,0)
        self.area = self.getArea()
        self.time = time.time()
        self.cv2numpy = self.image.getNumpyCv2()
        return self

    def getCenter(self):
        """
        **SUMMARY**

        Get the center of the bounding box

        **RETURNS**

        * *tuple* - center of the bounding box (x, y)

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> cen = track.getCenter()
        """
        return (self.bb_x+self.w/2,self.bb_y+self.h/2)

    def getArea(self):
        """
        **SUMMARY**

        Get the area of the bounding box

        **RETURNS**

        Area of the bounding box

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> area = track.getArea()
        """
        return self.w*self.h

    def getImage(self):
        """
        **SUMMARY**

        Get the Image

        **RETURNS**

        SimpleCV.ImageClass.Image

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> i = track.getImage()
        """
        return self.image

    def getBB(self):
        """
        **SUMMARY**

        Get the bounding box

        **RETURNS**

        A tuple  - (x, y, w, h)

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> print track.getBB()
        """
        return self.bb

    def draw(self, color=Color.GREEN, rad=1, thickness=1):
        """
        **SUMMARY**

        Draw the center of the object on the image.

        **PARAMETERS**

        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *rad* - Radius of the circle to be plotted on the center of the object.
        * *thickness* - Thickness of the boundary of the center circle.

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.draw()
        >>> img.show()
        """
        f = self
        f.image.drawCircle(f.center, rad, color, thickness)

    def drawBB(self, color=Color.GREEN, thickness=3):
        """
        **SUMMARY**

        Draw the bounding box over the object on the image.

        **PARAMETERS**

        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *thickness* - Thickness of the boundary of the bounding box.

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.drawBB()
        >>> img.show()
        """
        f = self
        f.image.drawRectangle(f.bb_x, f.bb_y, f.w, f.h, color, thickness)

    def showCoordinates(self, pos=None, color=Color.GREEN, size=None):
        """
        **SUMMARY**

        Show the co-ordinates of the object in text on the Image.

        **PARAMETERS**
        * *pos* - A tuple consisting of x, y values. where to put to the text
        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *size* - Fontsize of the text

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.showCoordinates()
        >>> img.show()
        """
        f = self
        img = f.image
        if not pos:
            imgsize = img.size()
            pos = (imgsize[0]-120, 10)
        if not size:
            size = 16
        text = "x = %d  y = %d" % (f.x, f.y)
        img.drawText(text, pos[0], pos[1], color, size)

    def showSizeRatio(self, pos=None, color=Color.GREEN, size=None):
        """
        **SUMMARY**

        Show the sizeRatio of the object in text on the image.

        **PARAMETERS**
        * *pos* - A tuple consisting of x, y values. where to put to the text
        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *size* - Fontsize of the text

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> while True:
            ... img1 = cam.getImage()
            ... ts = img1.track("camshift", ts1, img, bb)
            ... ts[-1].showSizeRatio() # For continuous bounding box
            ... img = img1
        """
        f = self
        img = f.image
        if not pos:
            imgsize = img.size()
            pos = (imgsize[0]-120, 30)
        if not size:
            size = 16
        text = "size = %f" % (f.sizeRatio)
        img.drawText(text, pos[0], pos[1], color, size)

    def showPixelVelocity(self, pos=None, color=Color.GREEN, size=None):
        """
        **SUMMARY**

        Show the Pixel Veloctiy (pixel/frame) of the object in text on the image.

        **PARAMETERS**
        * *pos* - A tuple consisting of x, y values. where to put to the text
        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *size* - Fontsize of the text

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> while True:
            ... img1 = cam.getImage()
            ... ts = img1.track("camshift", ts1, img, bb)
            ... ts[-1].showPixelVelocity() # For continuous bounding box
            ... img = img1
        """
        f = self
        img = f.image
        vel = f.vel
        if not pos:
            imgsize = img.size()
            pos = (imgsize[0]-120, 90)
        if not size:
            size = 16
        text = "Vx = %.2f Vy = %.2f" % (vel[0], vel[1])
        img.drawText(text, pos[0], pos[1], color, size)
        img.drawText("in pixels/frame", pos[0], pos[1]+size, color, size)

    def showPixelVelocityRT(self, pos=None, color=Color.GREEN, size=None):
        """
        **SUMMARY**

        Show the Pixel Veloctiy (pixels/second) of the object in text on the image.

        **PARAMETERS**
        * *pos* - A tuple consisting of x, y values. where to put to the text
        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *size* - Fontsize of the text

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> while True:
            ... img1 = cam.getImage()
            ... ts = img1.track("camshift", ts1, img, bb)
            ... ts[-1].showPixelVelocityRT() # For continuous bounding box
            ... img = img1
        """
        f = self
        img = f.image
        vel_rt = f.vel_rt
        if not pos:
            imgsize = img.size()
            pos = (imgsize[0]-120, 50)
        if not size:
            size = 16
        text = "Vx = %.2f Vy = %.2f" % (vel_rt[0], vel_rt[1])
        img.drawText(text, pos[0], pos[1], color, size)
        img.drawText("in pixels/second", pos[0], pos[1]+size, color, size)

    def processTrack(self, func):
        """
        **SUMMARY**

        This method lets you use your own function on the current image.

        **PARAMETERS**
        * *func* - some user defined function for SimpleCV.ImageClass.Image object

        **RETURNS**

        the value returned by the user defined function

        **EXAMPLE**

        >>> def foo(img):
            ... return img.meanColor()
        >>> mean_color = ts[-1].processTrack(foo)
        """
        return func(self.image)

    def getPredictionPoints(self):
        """
        **SUMMARY**

        get predicted Co-ordinates of the center of the object

        **PARAMETERS**
        None

        **RETURNS**

        * *tuple*

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.getPredictedCoordinates()
        """
        return self.predict_pt

    def drawPredicted(self, color=Color.GREEN, rad=1, thickness=1):
        """
        **SUMMARY**

        Draw the center of the object on the image.

        **PARAMETERS**

        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *rad* - Radius of the circle to be plotted on the center of the object.
        * *thickness* - Thickness of the boundary of the center circle.

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.drawPredicted()
        >>> img.show()
        """
        f = self
        f.image.drawCircle(f.predict_pt, rad, color, thickness)

    def showPredictedCoordinates(self, pos=None, color=Color.GREEN, size=None):
        """
        **SUMMARY**

        Show the co-ordinates of the object in text on the Image.

        **PARAMETERS**
        * *pos* - A tuple consisting of x, y values. where to put to the text
        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *size* - Fontsize of the text

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.showPredictedCoordinates()
        >>> img.show()
        """
        f = self
        img = f.image
        if not pos:
            imgsize = img.size()
            pos = (5, 10)
        if not size:
            size = 16
        text = "Predicted: x = %d  y = %d" % (f.predict_pt[0], f.predict_pt[1])
        img.drawText(text, pos[0], pos[1], color, size)

    def getCorrectedPoints(self):
        """
        **SUMMARY**

        Corrected Co-ordinates of the center of the object

        **PARAMETERS**
        None

        **RETURNS**

        * *tuple*

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.getCorrectedCoordinates()
        """
        return self.state_pt

    def showCorrectedCoordinates(self, pos=None, color=Color.GREEN, size=None):
        """
        **SUMMARY**

        Show the co-ordinates of the object in text on the Image.

        **PARAMETERS**
        * *pos* - A tuple consisting of x, y values. where to put to the text
        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *size* - Fontsize of the text

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.showCorrectedCoordinates()
        >>> img.show()
        """
        f = self
        img = f.image
        if not pos:
            imgsize = img.size()
            pos = (5, 40)
        if not size:
            size = 16
        text = "Corrected: x = %d  y = %d" % (f.state_pt[0], f.state_pt[1])
        img.drawText(text, pos[0], pos[1], color, size)

    def drawCorrected(self, color=Color.GREEN, rad=1, thickness=1):
        """
        **SUMMARY**

        Draw the center of the object on the image.

        **PARAMETERS**

        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *rad* - Radius of the circle to be plotted on the center of the object.
        * *thickness* - Thickness of the boundary of the center circle.

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**

        >>> track = Track(img, bb)
        >>> track.drawCorrected()
        >>> img.show()
        """
        f = self
        f.image.drawCircle(f.state_pt, rad, color, thickness)

class CAMShiftTrack(Track):
    """
    **SUMMARY**

    CAMShift Class is returned by track when CAMShift tracking is required.
    This class is a superset of Track Class. And all of Track class'
    attributes can be accessed.

    CAMShift class has "ellipse" attribute which is not present in Track
    """
    def __init__(self, img, bb, ellipse):
        """
        **SUMMARY**

        Initializes all the required parameters and attributes of the CAMShift class.

        **PARAMETERS**

        * *img* - SimpleCV.ImageClass.Image
        * *bb* - A tuple consisting of (x, y, w, h) of the bounding box
        * ellipse* - A tuple

        **RETURNS**

        SimpleCV.Tracking.TrackClass.CAMShiftTrack object

        **EXAMPLE**

        >>> track = CAMShiftTrack(image, bb, ellipse)
        """
        self = Track.__init__(self, img, bb)
        self.ellipse = ellipse

    def getEllipse(self):
        """
        **SUMMARY**

        Returns the ellipse.

        **RETURNS**

        A tuple

        **EXAMPLE**

        >>> track = CAMShiftTrack(image, bb, ellipse)
        >>> e = track.getEllipse()
        """
        return self.ellipse

class LKTrack(Track):
    """
    **SUMMARY**

    LK Tracking class is used for Lucas-Kanade Track algorithm. It's
    derived from Track Class. Apart from all the properties of Track class,
    LK has few other properties. Since in LK tracking method, we obtain tracking
    points, we have functionalities to draw those points on the image.

    """

    def __init__(self, img, bb, pts):
        """
        **SUMMARY**

        Initializes all the required parameters and attributes of the class.

        **PARAMETERS**

        * *img* - SimpleCV.ImageClass.Image
        * *bb* - A tuple consisting of (x, y, w, h) of the bounding box
        * *pts* - List of all the tracking points

        **RETURNS**

        SimpleCV.Tracking.TrackClass.LKTrack object

        **EXAMPLE**

        >>> track = LKTrack(image, bb, pts)
        """

        self = Track.__init__(self, img, bb)
        self.pts = pts

    def getTrackedPoints(self):
        """
        **SUMMARY**

        Returns all the points which are being tracked.

        **RETURNS**

        A list

        **EXAMPLE**

        >>> track = LKTrack(image, bb, pts)
        >>> pts = track.getTrackedPoints()
        """
        return self.pts

    def drawTrackerPoints(self, color=Color.GREEN, radius=1, thickness=1):
        """
        **SUMMARY**

        Draw all the points which are being tracked.

        **PARAMETERS**
        * *color* - Color of the point
        * *radius* - Radius of the point
        *thickness* - thickness of the circle point

        **RETURNS**

        Nothing

        **EXAMPLE**

        >>> track = LKTrack(image, bb, pts)
        >>> track.drawTrackerPoints()
        """
        if type(self.pts) is not type(None):
            for pt in self.pts:
                self.image.drawCircle(ctr=pt, rad=radius, thickness=thickness, color=color)

class SURFTrack(Track):
    """
    **SUMMARY**

    SURFTracker class is used for SURF Based keypoints matching tracking algorithm.
    It's derived from Track Class. Apart from all the properties of Track class SURFTracker
    has few other properties.

    Matches keypoints from the template image and the current frame.
    flann based matcher is used to match the keypoints.
    Density based clustering is used classify points as in-region (of bounding box)
    and out-region points. Using in-region points, new bounding box is predicted using
    k-means.
    """
    def __init__(self, img, new_pts, detector, descriptor, templateImg, skp, sd, tkp, td):
        """
        **SUMMARY**

        Initializes all the required parameters and attributes of the class.

        **PARAMETERS**

        * *img* - SimpleCV.Image
        * *new_pts* - List of all the tracking points found in the image. - list of cv2.KeyPoint
        * *detector* - SURF detector - cv2.FeatureDetector
        * *descriptor* - SURF descriptor - cv2.DescriptorExtractor
        * *templateImg* - Template Image (First image) - SimpleCV.Image
        * *skp* - image keypoints - list of cv2.KeyPoint
        * *sd* - image descriptor - numpy.ndarray
        * *tkp* - Template Imaeg keypoints - list of cv2.KeyPoint
        * *td* - Template image descriptor - numpy.ndarray

        **RETURNS**

        SimpleCV.Tracking.TrackClass.SURFTrack object

        **EXAMPLE**
        >>> track = SURFTracker(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        """
        if td is None:
            bb = (1, 1, 1, 1)
            self = Track.__init__(self, img, bb)
            return
        if len(new_pts) < 1:
            bb = (1, 1, 1, 1)
            self = Track.__init__(self, img, bb)
            self.pts = None
            self.templateImg = templateImg
            self.skp = skp
            self.sd = sd
            self.tkp = tkp
            self.td = td
            self.detector = detector
            self.descriptor = descriptor
            return
        if sd is None:
            bb = (1, 1, 1, 1)
            self = Track.__init__(self, img, bb)
            self.pts = None
            self.templateImg = templateImg
            self.skp = skp
            self.sd = sd
            self.tkp = tkp
            self.td = td
            self.detector = detector
            self.descriptor = descriptor
            return

        np_pts = np.asarray([kp.pt for kp in new_pts])
        t, pts, center = cv2.kmeans(np.asarray(np_pts, dtype=np.float32), K=1, bestLabels=None,
                            criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_MAX_ITER, 1, 10), attempts=1,
                            flags=cv2.KMEANS_RANDOM_CENTERS)
        max_x = int(max(np_pts[:, 0]))
        min_x = int(min(np_pts[:, 0]))
        max_y = int(max(np_pts[:, 1]))
        min_y = int(min(np_pts[:, 1]))

        bb =  (min_x-5, min_y-5, max_x-min_x+5, max_y-min_y+5)

        self = Track.__init__(self, img, bb)
        self.templateImg = templateImg
        self.skp = skp
        self.sd = sd
        self.tkp = tkp
        self.td = td
        self.pts = np_pts
        self.detector = detector
        self.descriptor = descriptor

    def getTrackedPoints(self):
        """
        **SUMMARY**

        Returns all the points which are being tracked.

        **RETURNS**

        A list of points.

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> pts = track.getTrackedPoints()
        """
        return self.pts

    def drawTrackerPoints(self, color=Color.GREEN, radius=1, thickness=1):
        """
        **SUMMARY**

        Draw all the points which are being tracked.

        **PARAMETERS**
        * *color* - Color of the point
        * *radius* - Radius of the point
        *thickness* - thickness of the circle point

        **RETURNS**

        Nothing

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> track.drawTrackerPoints()
        """
        if type(self.pts) is not type(None):
            for pt in self.pts:
                self.image.drawCircle(ctr=pt, rad=radius, thickness=thickness, color=color)

    def getDetector(self):
        """
        **SUMMARY**

        Returns SURF detector which is being used.

        **RETURNS**

        detector - cv2.Detctor

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> detector = track.getDetector()
        """
        return self.detector

    def getDescriptor(self):
        """
        **SUMMARY**

        Returns SURF descriptor extractor which is being used.

        **RETURNS**

        detector - cv2.DescriptorExtractor

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> descriptor= track.getDescriptor()
        """
        return self.descriptor

    def getImageKeyPoints(self):
        """
        **SUMMARY**

        Returns all the keypoints which are found on the image.

        **RETURNS**

        A list of points.

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> skp = track.getImageKeyPoints()
        """
        return self.skp

    def getImageDescriptor(self):
        """
        **SUMMARY**

        Returns the image descriptor.

        **RETURNS**

        Image descriptor - numpy.ndarray

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> sd = track.getImageDescriptor()
        """
        return self.sd

    def getTemplateKeyPoints(self):
        """
        **SUMMARY**

        Returns all the keypoints which are found on the template Image.

        **RETURNS**

        A list of points.

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> tkp = track.getTemplateKeyPoints()
        """
        return self.tkp

    def getTemplateDescriptor(self):
        """
        **SUMMARY**

        Returns the template image descriptor.

        **RETURNS**

        Image descriptor - numpy.ndarray

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> td = track.getTemplateDescriptor()
        """
        return self.td

    def getTemplateImage(self):
        """
        **SUMMARY**

        Returns Template Image.

        **RETURNS**

        Template Image - SimpleCV.Image

        **EXAMPLE**

        >>> track = SURFTrack(image, pts, detector, descriptor, temp, skp, sd, tkp, td)
        >>> templateImg = track.getTemplateImage()
        """
        return self.templateImg

class MFTrack(Track):
    """
    **SUMMARY**

    MFTracker class is used for Median Flow Tracking algorithm. It's
    derived from Track Class. Apart from all the properties of Track class,
    MFTracker has few other properties.

    Media Flow Tracker is the base tracker that is used in OpenTLD. It is based on
    Optical Flow. It calculates optical flow of the points in the bounding box from
    frame 1 to frame 2 and from frame 2 to frame 1 and using back track error, removes
    false positives. As the name suggests, it takes the median of the flow, and eliminates
    points.

    """
    def __init__(self, img, bb, shift):
        """
        **SUMMARY**

        Initializes all the required parameters and attributes of the class.

        **PARAMETERS**

        * *img* - SimpleCV.ImageClass.Image
        * *bb* - A tuple consisting of (x, y, w, h) of the bounding box
        * *shift* - Object Shift calcluated in Median Flow

        **RETURNS**

        SimpleCV.Tracking.TrackClass.MFTrack object

        **EXAMPLE**

        >>> track = MFTrack(image, bb, shift)
        """
        self = Track.__init__(self, img, bb)
        self.shift = shift

    def getShift(self):
        """
        **SUMMARY**

        Returns object shift that was calcluated in Median Flow.

        **RETURNS**

        float

        **EXAMPLE**

        >>> track = MFTrack(image, bb, pts)
        >>> pts = track.getShift()
        """
        return self.shift

    def showShift(self, pos=None, color=Color.GREEN, size=None):
        """
        **SUMMARY**

        Show the Pixel Veloctiy (pixels/second) of the object in text on the image.

        **PARAMETERS**
        * *pos* - A tuple consisting of x, y values. where to put to the text
        * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
        * *size* - Fontsize of the text

        **RETURNS**

        Nada. Nothing. Zilch.

        **EXAMPLE**
        >>> ts = []
        >>> while True:
            ... img1 = cam.getImage()
            ... ts = img1.track("mftrack", ts, img, bb)
            ... ts[-1].showShift()
            ... img1.show()
        """
        f = self
        img = f.image
        shift = f.shift
        if not pos:
            imgsize = img.size()
            pos = (imgsize[0]-120, 50)
        if not size:
            size = 16
        text = "Shift = %.2f" % (shift)
        img.drawText(text, pos[0], pos[1], color, size)
        img.drawText("in pixels/second", pos[0], pos[1]+size, color, size)


text:
BOOST_FIXTURE_TEST_SUITE(getarg_tests, BasicTestingSetup)

static void ResetArgs(const std::string& strArg)
{
    std::vector<std::string> vecArg;
    if (strArg.size())
      boost::split(vecArg, strArg, boost::is_space(), boost::token_compress_on);

    // Insert dummy executable name:
    vecArg.insert(vecArg.begin(), "testbitcoin");

    // Convert to char*:
    std::vector<const char*> vecChar;
    BOOST_FOREACH(std::string& s, vecArg)
        vecChar.push_back(s.c_str());

    ParseParameters(vecChar.size(), &vecChar[0], AllowedArgs::Bitcoind());
}

BOOST_AUTO_TEST_CASE(boolarg)
{
    ResetArgs("-listen");
    BOOST_CHECK(GetBoolArg("-listen", false));
    BOOST_CHECK(GetBoolArg("-listen", true));

    BOOST_CHECK(!GetBoolArg("-fo", false));
    BOOST_CHECK(GetBoolArg("-fo", true));

    BOOST_CHECK(!GetBoolArg("-fooo", false));
    BOOST_CHECK(GetBoolArg("-fooo", true));

    for (auto strValue : std::list<std::string>{"0", "f", "n", "false", "no"}) {
        ResetArgs("-listen=" + strValue);
        BOOST_CHECK(!GetBoolArg("-listen", false));
        BOOST_CHECK(!GetBoolArg("-listen", true));
    }

    for (auto strValue : std::list<std::string>{"", "1", "t", "y", "true", "yes"}) {
        ResetArgs("-listen=" + strValue);
        BOOST_CHECK(GetBoolArg("-listen", false));
        BOOST_CHECK(GetBoolArg("-listen", true));
    }

    // New 0.6 feature: auto-map -nosomething to !-something:
    ResetArgs("-nolisten");
    BOOST_CHECK(!GetBoolArg("-listen", false));
    BOOST_CHECK(!GetBoolArg("-listen", true));

    ResetArgs("-nolisten=1");
    BOOST_CHECK(!GetBoolArg("-listen", false));
    BOOST_CHECK(!GetBoolArg("-listen", true));

    ResetArgs("-listen -nolisten");  // -nolisten should win
    BOOST_CHECK(!GetBoolArg("-listen", false));
    BOOST_CHECK(!GetBoolArg("-listen", true));

    ResetArgs("-listen=1 -nolisten=1");  // -nolisten should win
    BOOST_CHECK(!GetBoolArg("-listen", false));
    BOOST_CHECK(!GetBoolArg("-listen", true));

    ResetArgs("-listen=0 -nolisten=0");  // -nolisten=0 should win
    BOOST_CHECK(GetBoolArg("-listen", false));
    BOOST_CHECK(GetBoolArg("-listen", true));

    // New 0.6 feature: treat -- same as -:
    ResetArgs("--listen=1");
    BOOST_CHECK(GetBoolArg("-listen", false));
    BOOST_CHECK(GetBoolArg("-listen", true));

    ResetArgs("--nolisten=1");
    BOOST_CHECK(!GetBoolArg("-listen", false));
    BOOST_CHECK(!GetBoolArg("-listen", true));

    BOOST_CHECK_THROW(ResetArgs("-listen=text"), std::runtime_error);
}

BOOST_AUTO_TEST_CASE(stringarg)
{
    ResetArgs("");
    BOOST_CHECK_EQUAL(GetArg("-uacomment", ""), "");
    BOOST_CHECK_EQUAL(GetArg("-uacomment", "eleven"), "eleven");

    ResetArgs("-connect -listen"); // -connect is an optional string argument
    BOOST_CHECK_EQUAL(GetArg("-connect", ""), "");
    BOOST_CHECK_EQUAL(GetArg("-connect", "eleven"), "");

    ResetArgs("-connect=");
    BOOST_CHECK_EQUAL(GetArg("-connect", ""), "");
    BOOST_CHECK_EQUAL(GetArg("-connect", "eleven"), "");

    ResetArgs("-uacomment=11");
    BOOST_CHECK_EQUAL(GetArg("-uacomment", ""), "11");
    BOOST_CHECK_EQUAL(GetArg("-uacomment", "eleven"), "11");

    ResetArgs("-uacomment=eleven");
    BOOST_CHECK_EQUAL(GetArg("-uacomment", ""), "eleven");
    BOOST_CHECK_EQUAL(GetArg("-uacomment", "eleven"), "eleven");

    BOOST_CHECK_THROW(ResetArgs("-uacomment"), std::runtime_error);
    BOOST_CHECK_THROW(ResetArgs("-uacomment="), std::runtime_error);
}

BOOST_AUTO_TEST_CASE(intarg)
{
    ResetArgs("");
    BOOST_CHECK_EQUAL(GetArg("-maxconnections", 11), 11);
    BOOST_CHECK_EQUAL(GetArg("-maxconnections", 0), 0);

    ResetArgs("-maxconnections"); // -maxconnections is an optional int argument
    BOOST_CHECK_EQUAL(GetArg("-maxconnections", 11), 0);

    ResetArgs("-maxconnections=11 -maxreceivebuffer=12");
    BOOST_CHECK_EQUAL(GetArg("-maxconnections", 0), 11);
    BOOST_CHECK_EQUAL(GetArg("-maxreceivebuffer", 11), 12);

    ResetArgs("-par=-1");
    BOOST_CHECK_EQUAL(GetArg("-par", 0), -1);

    BOOST_CHECK_THROW(ResetArgs("-maxreceivebuffer"), std::runtime_error);
    BOOST_CHECK_THROW(ResetArgs("-maxreceivebuffer="), std::runtime_error);
    BOOST_CHECK_THROW(ResetArgs("-maxreceivebuffer=NaN"), std::runtime_error);
}

BOOST_AUTO_TEST_CASE(doubledash)
{
    ResetArgs("--listen");
    BOOST_CHECK_EQUAL(GetBoolArg("-listen", false), true);

    ResetArgs("--uacomment=verbose --maxconnections=1");
    BOOST_CHECK_EQUAL(GetArg("-uacomment", ""), "verbose");
    BOOST_CHECK_EQUAL(GetArg("-maxconnections", 0), 1);
}

BOOST_AUTO_TEST_CASE(boolargno)
{
    ResetArgs("-nolisten");
    BOOST_CHECK(!GetBoolArg("-listen", true));
    BOOST_CHECK(!GetBoolArg("-listen", false));

    ResetArgs("-nolisten=1");
    BOOST_CHECK(!GetBoolArg("-listen", true));
    BOOST_CHECK(!GetBoolArg("-listen", false));

    ResetArgs("-nolisten=0");
    BOOST_CHECK(GetBoolArg("-listen", true));
    BOOST_CHECK(GetBoolArg("-listen", false));

    ResetArgs("-listen --nolisten"); // --nolisten should win
    BOOST_CHECK(!GetBoolArg("-listen", true));
    BOOST_CHECK(!GetBoolArg("-listen", false));

    ResetArgs("-nolisten -listen"); // -listen always wins:
    BOOST_CHECK(GetBoolArg("-listen", true));
    BOOST_CHECK(GetBoolArg("-listen", false));
}

BOOST_AUTO_TEST_CASE(blockSizeAcceptLimit)
{
    ResetArgs("-excessiveblocksize=5004000");
    BOOST_CHECK_EQUAL(Policy::blockSizeAcceptLimit(), 5004000);

    ResetArgs("-blocksizeacceptlimitbytes=5004000");
    BOOST_CHECK_EQUAL(Policy::blockSizeAcceptLimit(), 5004000);

    // blocksizeacceptlimit always wins
    ResetArgs("-excessiveblocksize=5004000 -blocksizeacceptlimit=1.2");
    BOOST_CHECK_EQUAL(Policy::blockSizeAcceptLimit(), 1200000);

    // blocksizeacceptlimit always wins
    ResetArgs("-blocksizeacceptlimitbytes=5004000 -blocksizeacceptlimit=1.2");
    BOOST_CHECK_EQUAL(Policy::blockSizeAcceptLimit(), 1200000);

    // blocksizeacceptlimitbytes always wins
    ResetArgs("-excessiveblocksize=5004000 -blocksizeacceptlimitbytes=6004000");
    BOOST_CHECK_EQUAL(Policy::blockSizeAcceptLimit(), 6004000);

    ResetArgs("-blocksizeacceptlimit=1.2");
    BOOST_CHECK_EQUAL(Policy::blockSizeAcceptLimit(), 1200000);

    ResetArgs("-blocksizeacceptlimit=1.25");
    BOOST_CHECK_EQUAL(Policy::blockSizeAcceptLimit(), 1200000);
}

BOOST_AUTO_TEST_CASE(unrecognizedArgs)
{
    BOOST_CHECK_THROW(ResetArgs("-unrecognized_arg"), std::runtime_error);
    BOOST_CHECK_THROW(ResetArgs("-listen -unrecognized_arg"), std::runtime_error);
}

BOOST_AUTO_TEST_SUITE_END()


text:
The following page has been submitted for your approval to be published.

	<?
	foreach ($pages as $page) {
		echo '' . $page['title'] . ''
			. '
'
			. $page['path']
			. '
'
			. date(DATE_DISPLAY_FORMAT, strtotime($page['update_date']))
			. '

';
	}
	?>

This email is being sent automatically by your CMS. If you no longer which to receive these notifications please contact your website administrator.


text:
import { Component, OnInit, Input } from '@angular/core';

import { ContentService } from '@services/content.service';
import { ContentItem } from '@services/classes/content-item';

@Component({
  selector: 'single-content',
  templateUrl: './single-content.html'
})

export class SingleContentComponent implements OnInit {
  @Input() public contentId: string;

  public content: ContentItem;

  constructor(public contentService: ContentService) {
  }

  public ngOnInit(): void {
    const content: any = this.contentService.getContent(this.contentId);

    this.content = content;
  }
}