Find the proper step when user clicks the Next button.

        :returns: The step to be switched to
        :rtype: WizardStep instance or None
420884
def get_next_step(self):
        
        layer_purpose = self.parent.step_kw_purpose.selected_purpose()
        if layer_purpose['key'] != layer_purpose_aggregation['key']:
            subcategory = self.parent.step_kw_subcategory. \
                selected_subcategory()
        else:
            subcategory = {'key': None}

        # We don't use field mapping for populated place exposure. Use the
        # population point instead.

        # inasafe_fields = self.get_inasafe_fields()
        # If population field is set, must go to field mapping step first.
        # if population_count_field['key'] in inasafe_fields.keys():
        #     return self.parent.step_kw_fields_mapping

        # Check if it can go to inasafe default field step
        default_inasafe_fields = get_fields(
            layer_purpose['key'],
            subcategory['key'],
            replace_null=True,
            in_group=False)
        if default_inasafe_fields:
            return self.parent.step_kw_default_inasafe_fields

        # Any other case
        return self.parent.step_kw_source
296154
private void showStep(int index) {
		if (index >= 0 && index < wizardSteps.size()) {
			currentStep = wizardSteps.get(index);
			// only show current step
			for (WizardStepView view : wizardSteps) {
				view.getWidget().setVisible(currentStep == view);
			}
			controllerButtonsWindow.setSubTitle(currentStep.getTitle());
			controllerButtonsWindow.setPreviousButtonEnabled(index > 0);
			controllerButtonsWindow.setNextButtonEnabled(index + 1 < wizardSteps.size());
			controllerButtonsWindow.setWarningLabelText(null, false);

			//only allow save on last step
			controllerButtonsWindow.setSaveButtonEnabled(index + 1 == wizardSteps.size());
			logger.info("Client WMS layer wizard, current step "
					+ (currentStep != null ? currentStep.getClass().toString() : "none"));
		} else {
			hideAndCleanWindow();
		}
	}
1333639
def get_next_step(self):
        
        subcategory = self.parent.step_kw_subcategory.selected_subcategory()
        is_raster = is_raster_layer(self.parent.layer)
        has_classifications = get_classifications(subcategory['key'])

        # Vector
        if not is_raster:
            return self.parent.step_kw_field
        # Raster and has classifications
        elif has_classifications:
            return self.parent.step_kw_multi_classifications
        # else go to source
        return self.parent.step_kw_source
226816
def next_pos(self):
        
        result = None
        if self._index <= len(self._steps):
            result = self._steps[self._index]
            self._index += 1
        return result
1182215
function( origEvent ) {
            var next = steps.indexOf( activeStep ) + 1;
            next = next < steps.length ? steps[ next ] : steps[ 0 ];

            return goto( next, undefined, "next", origEvent );
        }
520072
def get_step(self, tol):
        ''' '''
        return 2 * numpy.log(tol/2.)/numpy.log(self.base)
694627
def step(self, viewer=None):
        ""
        if not self.is_completed(self.state):
            for agent in self.agents:
                action = agent.program(self.percept(agent, self.state))
                next_state = self.do_action(self.state, action, agent)
                if viewer:
                    viewer.event(self.state, action, next_state, agent)
                self.state = next_state
                if self.is_completed(self.state):
                    return
1103680
def on_pbnBack_released(self):
        
        current_step = self.get_current_step()
        if current_step.step_type == STEP_FC:
            new_step = self.impact_function_steps.pop()
        elif current_step.step_type == STEP_KW:
            try:
                new_step = self.keyword_steps.pop()
            except IndexError:
                new_step = self.impact_function_steps.pop()
        else:
            raise InvalidWizardStep

        # set focus to table widgets, as the inactive selection style is gray
        if new_step == self.step_fc_functions1:
            self.step_fc_functions1.tblFunctions1.setFocus()
        if new_step == self.step_fc_functions2:
            self.step_fc_functions2.tblFunctions2.setFocus()
        # Re-connect disconnected signals when coming back to the Extent step
        if new_step == self.step_fc_extent:
            self.step_fc_extent.set_widgets()
        # Set Next button label
        self.pbnNext.setText(tr('Next'))
        self.pbnNext.setEnabled(True)
        self.go_to_step(new_step)
113868
def set_step(self, value, block_events=False):
        
        if block_events: self.block_events()
        self._widget.setSingleStep(value)
        if block_events: self.unblock_events()
492027
function(step, next) {
      if (step.options.data != null) {
        step.data = step.options.data;
      } else {
        step.data = {};
      }
      return next();
    }
730953
def is_ready_to_next_step(self):
        
        return (bool(self.rbAggLayerFromCanvas.isChecked()
                     or self.rbAggLayerFromBrowser.isChecked()
                     or self.rbAggLayerNoAggregation.isChecked()))
1082126
function(step){
		this.cancelEvent = false;
		this.mousestart = (step===0);
		this.mousemove  = (step===1);
		this.mouseend   = (step===2);
		
		var puzzle = this.puzzle;
		puzzle.emit('mouse');
		if(!this.cancelEvent && (this.btn==='left' || this.btn==='right')){
			if(this.mousestart){
				puzzle.opemgr.newOperation();
				puzzle.errclear();
			}
			else{ puzzle.opemgr.newChain();}
			
			this.mouseinput();
		}
	}
1208342
def steps(self):
        
        if self._steps is None:
            self._steps = ExecutionStepList(
                self._version,
                flow_sid=self._solution['flow_sid'],
                execution_sid=self._solution['sid'],
            )
        return self._steps
1093457
def walk(self):
        
        if conf.core.snapshots is not None:
            return self.snaps[conf.core.snapshots]
        elif conf.core.timesteps is not None:
            return self.steps[conf.core.timesteps]
        return self.snaps[-1:]
722321
def select_row(self, steps):
        
        row = self.current_row() + steps
        if 0 <= row < self.count():
            self.set_current_row(row)
1192548
def get_next_step(self):
        
        if self.rbExpLayerFromCanvas.isChecked():
            new_step = self.parent.step_fc_explayer_from_canvas
        else:
            new_step = self.parent.step_fc_explayer_from_browser
        return new_step
918697
def step_next(self):
        """"""
        window_start = around(self.parent.value('window_start') +
                              self.parent.value('window_length') /
                              self.parent.value('window_step'), 2)

        self.parent.overview.update_position(window_start)