C++ singleStep函数代码示例

void IntValueEditor::keyPressEvent(QKeyEvent* e)
{
	switch (e->key())
	{
		case Qt::Key_BracketLeft:
			setSingleStep((int)(singleStep() * 10.0));
			QSettings().setValue(QString("intvalueeditor/%1/singlestep").arg(objectName()), singleStep());
			break;

		case Qt::Key_BracketRight:
			setSingleStep(qMax((int)(default_step * 0.10), 1));
			QSettings().setValue(QString("intvalueeditor/%1/singlestep").arg(objectName()), singleStep());
			break;

		case Qt::Key_Return:
			QSpinBox::keyPressEvent(e);
			emit undoStateSignal();
			break;

		case Qt::Key_Backslash:
			WheelValueEditor::WHEEL_EVENTS_ENABLED
			= ! WheelValueEditor::WHEEL_EVENTS_ENABLED;
			break;

		default:
			QSpinBox::keyPressEvent(e);
	}
}

void SliderDoubleSpinBox::mousePressEvent(QMouseEvent * event)
{
    if (event->buttons() & Qt::LeftButton) {
        QStyleOptionSpinBox spinOpts = d->spinBoxOptions();
        // mouse in progress area?
        if (d->progressRect(spinOpts).contains(event->pos())
            && ! lineEdit()->isVisible())
        {
            setValue(d->valueForX(event->pos().x()));
        }
        // mouse over up-button?
        else if (d->upButtonRect(spinOpts).contains(event->pos())) {
            setValue(value() + singleStep());
            d->pressedInButton = true;
        }
        // mouse over down-button?
        else if (d->downButtonRect(spinOpts).contains(event->pos())) {
            setValue(value() - singleStep());
            d->pressedInButton = true;
        } else {
            // whatever this mouse press is, just pass it on
            QDoubleSpinBox::mousePressEvent(event);
        }
    } else if (event->buttons() & Qt::RightButton) {
        // right now, RMB switches into line edit mode
        d->showLineEdit();
    }
}

void ModQDoubleSpinBox::stepBy(int steps)
{
	double cpValue = 0, crValue = 0, newValue = 0; double delta = 0;
	if (_discreteValuesMode)
	{
		// Get current round value:
		crValue = pow(10,-decimals()) * round( value()*pow(10,decimals()) );
		if (singleStep() < pow(10, -decimals()))
		{
			// Calculate new value:
			newValue = crValue + (steps * pow(10, -decimals()));
			newValue = roundToNextDiscreteValue( newValue );
		}
		else
		{
			// Get current precise value:
			cpValue = roundToNextDiscreteValue( value() );
			// Correct nr of steps (if necessary):
			if (steps > 0)
				delta = cpValue - crValue;
			else // < 0 (= 0 ???)
				delta = crValue - cpValue;
			if (delta >= (pow(10, -decimals()) - _precCorrVal))
				steps -= steps/abs(steps);
			// Calculate new value:
			newValue = cpValue + (steps * singleStep());
		}
		// Set new value (automatic round to decimals):
		QDoubleSpinBox::setValue( newValue );
	}
	else
		QDoubleSpinBox::stepBy(steps);
}

//! A size hint
QSize QwtCounter::sizeHint() const
{
    QString tmp;

    int w = tmp.setNum( minimum() ).length();
    int w1 = tmp.setNum( maximum() ).length();
    if ( w1 > w )
        w = w1;
    w1 = tmp.setNum( minimum() + singleStep() ).length();
    if ( w1 > w )
        w = w1;
    w1 = tmp.setNum( maximum() - singleStep() ).length();
    if ( w1 > w )
        w = w1;

    tmp.fill( '9', w );

    QFontMetrics fm( d_data->valueEdit->font() );
    w = fm.width( tmp ) + 2;
    if ( d_data->valueEdit->hasFrame() )
        w += 2 * style()->pixelMetric( QStyle::PM_DefaultFrameWidth );

    // Now we replace default sizeHint contribution of d_data->valueEdit by
    // what we really need.

    w += QWidget::sizeHint().width() - d_data->valueEdit->sizeHint().width();

    const int h = qMin( QWidget::sizeHint().height(),
        d_data->valueEdit->minimumSizeHint().height() );
    return QSize( w, h );
}

void IntValueEditor::restoreSettings()
{
	if (objectName().isEmpty())
		logWarn("IntValueEditor::restoreSettings : nameless object found");

	setSingleStep(QSettings().value(
		QString("intvalueeditor/%1/singlestep").arg(objectName()), singleStep()).toInt());

	default_step = singleStep();
}

void CSliderMultiPos::triggerAction(QAbstractSlider::SliderAction action){
    bool noAction = false;
    int newPos = 0;
    int minPos;
    int maxPos;

    if( lastPressedIndex==0 ){
        minPos = minimum();
    }
    else{
        minPos = handles.at(lastPressedIndex-1).getPosition();
    }
    if( lastPressedIndex==(nbValues()-1) ){
        maxPos = maximum();
    }
    else{
        minPos = handles.at(lastPressedIndex-1).getPosition();
    }

    blockTracking = true;
    switch( action ){
        case QAbstractSlider::SliderSingleStepAdd :
            newPos = qBound( minPos,minPos + singleStep(),maxPos );
            break;
        case QAbstractSlider::SliderSingleStepSub :
            newPos = qBound( minPos,maxPos - singleStep(),maxPos );
            break;
        case QAbstractSlider::SliderToMinimum :
            newPos = minPos;
            break;
        case QAbstractSlider::SliderToMaximum :
            newPos = maxPos;
            break;
        case QAbstractSlider::SliderMove :
        case QAbstractSlider::SliderNoAction :
            noAction = true;
            break;
        default :
            qWarning( "QxtSpanSliderPrivate::triggerAction: Unknown action" );
            break;
    }

    if( noAction ){
        // Nothing to do for this action
    }
    else{
        newPos = collisionDetection(newPos);
        setCurPosition( lastPressedIndex,newPos );
    }
    blockTracking = false;
}

void DoubleValueEditor::restoreSettings()
{
	QSettings settings;

	if (objectName().isEmpty())
		logWarn("DoubleValueEditor::restoreSettings : nameless object found");

	setSingleStep(settings.value(
		QString("doublevalueeditor/%1/singlestep").arg(objectName()), singleStep()).toDouble());
	setDecimals(settings.value(
		QString("doublevalueeditor/%1/decimals").arg(objectName()), decimals()).toInt());

	default_step = singleStep();
}

/******************************************************************************
* Return the initial adjustment to the value for a shift step up or down, for
* the main (visible) spin box.
* Normally this is a line step, but with a right-to-left language where the
* button functions are reversed, this is a page step.
*/
int SpinBox2::MainSpinBox::shiftStepAdjustment(int oldValue, int shiftStep)
{
    if (owner->reverseButtons())
    {
        // The button pairs have the opposite function from normal.
        // Page shift stepping - step up or down to a multiple of the
        // shift page increment, leaving unchanged the part of the value
        // which is the remainder from the page increment.
        if (oldValue >= 0)
            oldValue -= oldValue % singleStep();
        else
            oldValue += (-oldValue) % singleStep();
    }
    return SpinBox::shiftStepAdjustment(oldValue, shiftStep);
}

// normal sizeHint doesn't always work right for our case, 
// because the min/max/special text aren't necessarily the longest text
QSize MinSecSpinBox::sizeHint() const
{
    QSize normal = QSpinBox::sizeHint();
    
    //this first portion copied from QAbstractSpinBox
    const QFontMetrics fm(fontMetrics());
    int w = 0;
    QString s;
    s = prefix() + textFromValue(minimum()) + suffix() + QLatin1Char(' ');
    s.truncate(18);
    w = qMax(w, fm.width(s));
    s = prefix() + textFromValue(maximum()) + suffix() + QLatin1Char(' ');
    s.truncate(18);
    w = qMax(w, fm.width(s));
    if (specialValueText().size()) {
        s = specialValueText();
        w = qMax(w, fm.width(s));
    }
    w += 2; // cursor blinking space
    
    //new part (see if max - singlestep is longer)
    s = textFromValue(maximum()-singleStep()) + QLatin1Char(' ');
    int longwidth = fm.width(s) + 2;
    int dif = longwidth - w;
    if (dif > 0)
        normal += QSize(dif, 0);
    
    return normal;
}

void IntValueEditor::wheelEvent(QWheelEvent* e)
{
	if (!QSpinBox::isActiveWindow())
		QSpinBox::activateWindow();
	QSpinBox::setFocus(Qt::MouseFocusReason);

	int step = default_step = singleStep();
	if (e->modifiers() & Qt::ShiftModifier)
	{
		if (step >= 10.0)
			setSingleStep(step = (int)(step / 10.0));
	}
	else if (e->modifiers() & Qt::ControlModifier)
		setSingleStep(step = step * 10);

	if (e->delta() > 0)
		stepUp();
	else
		stepDown();

	if (step != default_step)
		setSingleStep(default_step);

	if (wheelEventSignal && WheelValueEditor::WHEEL_EVENTS_ENABLED)
		emit valueUpdated();
}

void ModQDoubleSpinBox::recalcPrecCorrValue()
{
	int base_decimals = static_cast<int>(-floor(log10(_DVMbaseValue)));
	int singleStep_decimals = static_cast<int>(-floor(log10(singleStep())));
	int corrVal_decimals = 1 + std::max(decimals(), std::max(base_decimals, singleStep_decimals));
	_precCorrVal = pow(10,-corrVal_decimals);
}

void DoubleValueEditor::mouseMoveEvent(QMouseEvent* e)
{
	if (e->buttons() & Qt::LeftButton)
	{
		double dy = e->y() - last_pos.y();
		double step = default_step = singleStep();
		last_pos = e->posF();
		last_press = 0;

		if (e->modifiers() & Qt::ShiftModifier)
			setSingleStep(step /= 10.0);
		else if (e->modifiers() & Qt::ControlModifier)
			setSingleStep(step *= 10.0);

		if (dy < 0)
		{
			stepUp();
			emit valueUpdated();
		}
		else if (dy > 0)
		{
			stepDown();
			emit valueUpdated();
		}

		if (step != default_step)
			setSingleStep(default_step);
	}
}

double ModQDoubleSpinBox::roundToNextDiscreteValue(double inValue)
{
	double d_new = 0;
	double kcorr = 0;
	if (singleStep() != 0)
	{
		if ((inValue >= 0))
			kcorr = _precCorrVal;
		if ((inValue < 0))
			kcorr = - _precCorrVal;
		d_new = singleStep() * round(((inValue - _DVMbaseValue + kcorr) / singleStep())) + _DVMbaseValue;
	}
	else
		d_new = inValue;
	return d_new;
}

// Function copied from qslider.cpp and modified to make it compile
void Slider::initStyleOption_Qt430( QStyleOptionSlider *option ) const
{
	if (!option)
		return;

	option->initFrom( this );
	option->subControls       = QStyle::SC_None;
	option->activeSubControls = QStyle::SC_None;
	option->orientation       = orientation();
	option->maximum           = maximum();
	option->minimum           = minimum();
	option->tickPosition      = (QSlider::TickPosition) tickPosition();
	option->tickInterval      = tickInterval();
	option->upsideDown        = (orientation() == Qt::Horizontal) ?
								   (invertedAppearance() != (option->direction == Qt::RightToLeft))
								 : (!invertedAppearance());
	option->direction         = Qt::LeftToRight; // we use the upsideDown option instead
	option->sliderPosition    = sliderPosition();
	option->sliderValue       = value();
	option->singleStep        = singleStep();
	option->pageStep          = pageStep();

	if (orientation() == Qt::Horizontal)
		option->state |= QStyle::State_Horizontal;
}

void CalculationThread::run() {

    seedmap->resetMatches();

    while(singleStep()) {}


}