Functionality for step button.
513218
function(event) {

        event.preventDefault();

        if ((window.kelmu.data[id].definitions['step' + window.kelmu.data[id].stepNumber] || [null]).length - 1 === window.kelmu.data[id].subStepNumber) {

          // Move to next step
          clearAnnotations();
          window.kelmu.data[id].stepNumber += 1;
          window.kelmu.data[id].subStepNumber = 0;
          if (window.kelmu.data[id].actions.updateEditor) {
            window.kelmu.data[id].actions.updateEditor(true, true);
          }
          originalStep(event);

          // If the animator is not able to report when the animation is ready,
          // create the annotations for the next step after a delay
          if (!window.kelmu.data[id].animationReadyAvailable) {
            setTimeout(function() {
              createAnnotations();
              if (window.kelmu.data[id].actions.updateEditor) {
                window.kelmu.data[id].actions.updateEditor(true, true);
              }
            }, window.kelmu.data[id].settings.animationLength);
          }
        } else {

          // Move to next substep
          window.kelmu.data[id].subStepNumber += 1;
          window.kelmu.data[id].actions.setSubstep(window.kelmu.data[id].subStepNumber);
          if (window.kelmu.data[id].actions.updateEditor) {
            window.kelmu.data[id].actions.updateEditor(true, true);
          }
        }

        if (window.kelmu.data[id].stepsToRun === 0) {
          // Add the current state to the undo stack if there are no more steps to run
          window.kelmu.data[id].undoStack.splice(window.kelmu.data[id].undoStackPointer + 1, window.kelmu.data[id].undoStack.length);
          window.kelmu.data[id].undoStack.push([window.kelmu.data[id].stepNumber, window.kelmu.data[id].subStepNumber]);
          window.kelmu.data[id].undoStackPointer += 1;
        }

      }
1258867
public void setSteps(java.util.Collection<Step> steps) {
        if (steps == null) {
            this.steps = null;
            return;
        }

        this.steps = new java.util.ArrayList<Step>(steps);
    }
1249853
function() {
		if ( this.options.step ) {
			this.options.step.call( this.elem, this.now, this );
		}

		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );

		// Set display property to block for height/width animations
		if ( ( this.prop === "height" || this.prop === "width" ) && this.elem.style ) {
			this.elem.style.display = "block";
		}
	}
1249310
def _set_step(self, step):
        """"""
        new_tab = self.tab_widget.currentIndex() + step
        assert new_tab < self.tab_widget.count() and new_tab >= 0
        if new_tab == self.tab_widget.count()-1:
            try:
                self.table_widget.open_data(self._get_plain_text(),
                                        self.text_widget.get_col_sep(),
                                        self.text_widget.get_row_sep(),
                                        self.text_widget.trnsp_box.isChecked(),
                                        self.text_widget.get_skiprows(),
                                        self.text_widget.get_comments())
                self.done_btn.setEnabled(True)
                self.done_btn.setDefault(True)
                self.fwd_btn.setEnabled(False)
                self.back_btn.setEnabled(True)
            except (SyntaxError, AssertionError) as error:
                QMessageBox.critical(self, _("Import wizard"),
                            _("<b>Unable to proceed to next step</b>"
                              "<br><br>Please check your entries."
                              "<br><br>Error message:<br>%s") % str(error))
                return
        elif new_tab == 0:
            self.done_btn.setEnabled(False)
            self.fwd_btn.setEnabled(True)
            self.back_btn.setEnabled(False)
        self._focus_tab(new_tab)
359505
def stepBy(self, steps):
        
        self.setValue(self.value() + steps*self.singleStep())
524844
def go_to_step(self, step):
        
        self.stackedWidget.setCurrentWidget(step)

        # Disable the Next button unless new data already entered
        self.pbnNext.setEnabled(step.is_ready_to_next_step())

        # Enable the Back button unless it's not the first step
        self.pbnBack.setEnabled(
            step not in [self.step_kw_purpose, self.step_fc_functions1]
            or self.parent_step is not None)

        # Set Next button label
        if (step in [self.step_kw_summary, self.step_fc_analysis]
                and self.parent_step is None):
            self.pbnNext.setText(tr('Finish'))
        elif step == self.step_fc_summary:
            self.pbnNext.setText(tr('Run'))
        else:
            self.pbnNext.setText(tr('Next'))

        # Run analysis after switching to the new step
        if step == self.step_fc_analysis:
            self.step_fc_analysis.setup_and_run_analysis()

        # Set lblSelectCategory label if entering the kw mode
        # from the ifcw mode
        if step == self.step_kw_purpose and self.parent_step:
            if self.parent_step in [self.step_fc_hazlayer_from_canvas,
                                    self.step_fc_hazlayer_from_browser]:
                text_label = category_question_hazard
            elif self.parent_step in [self.step_fc_explayer_from_canvas,
                                      self.step_fc_explayer_from_browser]:
                text_label = category_question_exposure
            else:
                text_label = category_question_aggregation
            self.step_kw_purpose.lblSelectCategory.setText(text_label)
66684
function() {
                var editMode = $scope.editMode;
                if (angular.isUndefined(editMode) || (editMode === null)) return;

                //Set completed for all steps to the value of editMode
                angular.forEach($scope.steps, function (step) {
                    step.completed = editMode;
                });

                //If editMode is false, set ONLY ENABLED steps with index lower then completedIndex to completed
                if (!editMode) {
                    var completedStepsIndex = $scope.currentStepNumber() - 1;
                    angular.forEach($scope.getEnabledSteps(), function(step, stepIndex) {
                        if(stepIndex < completedStepsIndex) {
                            step.completed = true;
                        }
                    });
                }
            }
979425
function taskRunner (ui) {

    return function (item, cb) {

        ui.logger.debug("Starting Step: " + item.step);

        /**
         * Give each step access to the UI Instance
         */
        item.fn(ui, function (err, out) {
            if (err) {
                return cb(err);
            }
            if (out) {
                handleOut(ui, out);
            }
            ui.logger.debug("{green:Step Complete: " + item.step);
            cb();
        });
    };
}
722321
def select_row(self, steps):
        
        row = self.current_row() + steps
        if 0 <= row < self.count():
            self.set_current_row(row)
1335783
function(event, action) {
        var data = window.kelmu.data[id];
        var stepsLeft = Math.max(+(action.parameter || 1), 1);
        var stepsToRun = 0;

        var proceed = function() {
          this('skip', stepsToRun);
        };

        while (stepsLeft > 0) {

          var subSteps = (data.definitions['step' + data.stepNumber] || [null]).length - 1;
          var currentSub = data.subStepNumber;
          var canIncrease = subSteps - currentSub;

          if (canIncrease < stepsLeft) {

            data.stepNumber += 1;
            data.subStepNumber = 0;
            stepsToRun += 1;
            stepsLeft -= canIncrease + 1;

          } else if (canIncrease > 0) {

            if (stepsToRun > 0) {
              $.each(window.kelmu.callbacks[id], proceed);
              stepsToRun = 0;
              clearAnnotations();
              originalStep(event);
            }

            stepsLeft -= canIncrease;
            data.subStepNumber = data.subStepNumber + canIncrease;
          } else {
            data.stepNumber += 1;
            stepsToRun += 1;
            stepsLeft -= 1;
          }

        }

        if (stepsToRun > 0) {
          $.each(window.kelmu.callbacks[id], proceed);
          stepsToRun = 0;
          clearAnnotations();
          originalStep(event);

          if (!window.kelmu.data[id].animationReadyAvailable) {
            setTimeout(function() {
              createAnnotations();
              if (window.kelmu.data[id].actions.updateEditor) {
                window.kelmu.data[id].actions.updateEditor();
              }
            }, window.kelmu.data[id].settings.animationLength);
          }

        } else {
          createAnnotations();
        }

        window.kelmu.data[id].undoStack.splice(window.kelmu.data[id].undoStackPointer + 1, window.kelmu.data[id].undoStack.length);
        window.kelmu.data[id].undoStack.push([window.kelmu.data[id].stepNumber, window.kelmu.data[id].subStepNumber]);
        window.kelmu.data[id].undoStackPointer += 1;

      }
1120700
def scroll_to_end_vertically(self, steps=10, *args, **selectors):
        
        return self.device(**selectors).scroll.vert.toEnd(steps=steps)
1229894
function() {
            var next = steps.indexOf( activeStep ) + 1;
            next = next < steps.length ? steps[ next ] : steps[ 0 ];

            return goto( next );
        }
1132907
async def stepper_step(self, command):
        
        speed = int(command[0])
        num_steps = int(command[1])
        await self.core.stepper_step(speed, num_steps)
844270
function _nextStep() {
    this._direction = 'forward';

    if (typeof this._currentStepNumber !== 'undefined') {
        for (var i = 0, len = this._introItems.length; i < len; i++) {
            var item = this._introItems[i];
            if (item.step === this._currentStepNumber) {
                this._currentStep = i - 1;
                this._currentStepNumber = undefined;
            }
        }
    }

    if (typeof this._currentStep === 'undefined') {
        this._currentStep = 0;
    } else {
        ++this._currentStep;
    }

    if (typeof this._introBeforeChangeCallback !== 'undefined') {
        var continueStep = this._introBeforeChangeCallback.call(this);
    }

    // if `onbeforechange` returned `false`, stop displaying the element
    if (continueStep === false) {
        --this._currentStep;
        return false;
    }

    if (this._introItems.length <= this._currentStep) {
        //end of the intro
        //check if any callback is defined
        if (typeof this._introCompleteCallback === 'function') {
            this._introCompleteCallback.call(this);
        }
        _exitIntro.call(this, this._targetElement);
        return;
    }

    var nextStep = this._introItems[this._currentStep];
    _showElement.call(this, nextStep);
}
1020726
def start_step(self, lineno, name="Unnamed step", timestamp=None):
        """"""
        self.state = self.STATES['step_in_progress']
        self.stepnum += 1
        self.steps.append({
            "name": name,
            "started": timestamp,
            "started_linenumber": lineno,
            "errors": [],
        })
761061
function getStep ( xPct, xSteps, snap, value ) {

        if ( value === 100 ) {
            return value;
        }

        var j = getJ( value, xPct ), a, b;

        // If 'snap' is set, steps are used as fixed points on the slider.
        if ( snap ) {

            a = xPct[j-1];
            b = xPct[j];

            // Find the closest position, a or b.
            if ((value - a) > ((b-a)/2)){
                return b;
            }

            return a;
        }

        if ( !xSteps[j-1] ){
            return value;
        }

        return xPct[j-1] + closest(
                value - xPct[j-1],
                xSteps[j-1]
            );
    }
29618
protected void showStep(A_CmsSetupStep step) {

        Window window = newWindow();
        window.setContent(step);
        window.setCaption(step.getTitle());
        A_CmsUI.get().addWindow(window);
        window.center();
    }