Paliers vers lesquels l'objet sera attiré
@returns {Steps}
164066
function Steps(list,strength) {
        /**
         * liste des paliers
         */
        this.list = list || [];
        /**
         * force de l'aimantation
         */
        this.strength = JSYG.isNumeric(strength) ? strength : 10;
        /**
         * type de données ("scale" pour liste d'échelles ou "dim" pour liste de dimensions)
         */
        this.type = 'dim';
    }
1290694
function(numbers) {
    var stepsize = stepSize(numbers);
    if( !numbers ) {
      return { beginning: 'second', text: '' };
    }
    if( isEveryOther( stepsize, numbers ) ) {
      return { beginning: '', text: 'other second' };
    } else if( isStepValue( stepsize, numbers ) ) {
      return { beginning: '', text: stepsize + ' seconds' };
    } else {
      return { beginning: 'minute', text: 'starting on the ' + (numbers.length === 2 && stepsize === 30 ? 'first and 30th second' : numberList(numbers) + ' second') };
    }
  }
523108
function (steps) {
            for (var i = 0; i < steps.length; i++) {
                steps[i].style.display = 'none';
            }
        }
1221769
function getBodyItems (privateKey, currentDate, uid, items) {
  return {
    Hlavicka: getHeaderItems(uid, currentDate, items.prvniZaslani, items.overeni),
    Data: getDataItems(items),
    KontrolniKody: getFooterItems(privateKey, items)
  }
}
634713
def steps(self):
        """"""
        def _iter(uri, acc):
            acc.appendleft(uri.name if uri.name else '')
            return _iter(uri.parent, acc) if uri.parent else acc
        return _iter(self, acc=deque())
526089
function step1 ( srcs ) {
				var map = Object.create ( null );
				function next ( source, parts, map ) {
					var part = parts.shift ();
					if ( !parts.length ) {
						map [ part ] = source;
					} else {
						map [ part ] = map [ part ] || Object.create ( null );
						next ( source, parts, map [ part ]);
					}
				}
				srcs.forEach ( function ( source ) {
					next ( source, source.split ( "/" ), map );
				});
				return map;
			}
817535
function idStep (obj, name, inherit) {
    return function (id) {
        var ctx = obj ? new obj(inherit ? this : undefined) : this;
        ctx.steps.push(name);
        ctx.steps.push(id);
        return ctx;
    };
}
135753
protected function processSteps()
    {
        return [
            Steps\CheckTables::class,
            Steps\LoadRawData::class,
            Steps\DutchModeInteractive::class,
            Steps\ResolveModuleNames::class,
            Steps\AnalyzeModels::class,
            Steps\UnsetRawData::class,
            Steps\AnalyzeSluggableInteractive::class,
        ];
    }
453322
function (steps) {
            var scenarioArrowCollection = document.querySelectorAll('.scenario-arrow'),
                allBtn = document.querySelector('.all-btn');
            for (var i = 0; i < steps.length; i++) {
                var display = steps[i].style.display;
                if (display === 'none' || display === '') {
                    this.addArrowUp(scenarioArrowCollection);
                    steps[i].style.display = 'block';
                    allBtn.classList.add('active');
                } else {
                    this.addArrowDown(scenarioArrowCollection);
                    allBtn.classList.add('active');
                    steps[i].style.display = 'none';
                }
            }
        }
225731
private int getCurrentStep() {
        int step = -1;
        try {
            XPropertySet xDialogModelPropertySet = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, m_xMSFDialogModel);
            step = ((Integer) xDialogModelPropertySet.getPropertyValue("Step")).intValue();
        } catch (com.sun.star.uno.Exception exception) {
            exception.printStackTrace(System.out);
        }
        return step;
    }
648783
public function getSteps()
    {
        // Carregar step do conexto e atual
        $step = $this->flow(router()->current()->parameter('step'));

        // Carregar view
        $view_id = sprintf('%s.%s', $this->prefixViewName, $step->key);
        if (! view()->exists($view_id)) {
            error('View of step "%s" not found', $view_id);
        }

        $view = view($view_id);
        $view->with('steps', $this->model->steps);
        $view->with('step', $step);
        $view->with('model', $this->model);
        $view->with($this->viewParams);

        $view->with('step_url', function ($step, $method = 'get') {
            return $this->stepUrl($step, $method);
        });

        return $view;
    }
20107
function subSteps (obj, items) {
    util.inherits(obj, Ctx);

    var key = "teamcontacts versions successors predecessors".split(" ")
    ,   propKey = "team-contacts version-history successor-version predecessor-version".split(" ");
    items.forEach(function (it) {
        obj.prototype[it] = function () {
            this.steps.push(it);
            this.type = "list";
            var i = key.indexOf(it);
            this.linkKey = (i >= 0) ? propKey[i] : it;
            return this;
        };
    });
}
208610
function getCurrentStep ( ) {

            // Check all locations, map them to their stepping point.
            // Get the step point, then find it in the input list.
            return scope_Locations.map(function( location, index ){

                var nearbySteps = scope_Spectrum.getNearbySteps( location );
                var value = scope_Values[index];
                var increment = nearbySteps.thisStep.step;
                var decrement = null;

                // If the next value in this step moves into the next step,
                // the increment is the start of the next step - the current value
                if ( increment !== false ) {
                    if ( value + increment > nearbySteps.stepAfter.startValue ) {
                        increment = nearbySteps.stepAfter.startValue - value;
                    }
                }


                // If the value is beyond the starting point
                if ( value > nearbySteps.thisStep.startValue ) {
                    decrement = nearbySteps.thisStep.step;
                }

                else if ( nearbySteps.stepBefore.step === false ) {
                    decrement = false;
                }

                // If a handle is at the start of a step, it always steps back into the previous step first
                else {
                    decrement = value - nearbySteps.stepBefore.highestStep;
                }


                // Now, if at the slider edges, there is not in/decrement
                if ( location === 100 ) {
                    increment = null;
                }

                else if ( location === 0 ) {
                    decrement = null;
                }

                // As per #391, the comparison for the decrement step can have some rounding issues.
                var stepDecimals = scope_Spectrum.countStepDecimals();

                // Round per #391
                if ( increment !== null && increment !== false ) {
                    increment = Number(increment.toFixed(stepDecimals));
                }

                if ( decrement !== null && decrement !== false ) {
                    decrement = Number(decrement.toFixed(stepDecimals));
                }

                return [decrement, increment];
            });
        }
824857
function getAfterScreenshotStep(step) {
        var template = grunt.file.read(templates.screenshotTemplate),
            stepTemplate;
        stepTemplate = grunt.template.process(template, {
            data: {
                screenshot: step.embeddings && step.embeddings[0] ? step.embeddings[0].data : ''
            }
        });
        return stepTemplate;
    }
208969
public List getSteps() {
	// simply merge our 'step' with our 'next'
	List l;
	if (next != null)
	    l = next.getSteps();
	else
	    l = new Vector();
	l.add(0, step);
	return l;
    }
312751
function () {
        const items = []
        _.each(this._items, (item) => {
          items.push(item.toObject())
        })
        return items
      }
284874
function() {
            var next = steps.indexOf( activeStep ) + 1;
            next = next < steps.length ? steps[ next ] : steps[ 0 ];
            impressHI.trigger('impress:next');

            return goto( next );
        }