/*!
\reimp
*/
void QxtStars::mousePressEvent(QMouseEvent* event)
{
if (qxt_d().readOnly)
{
event->ignore();
return;
}
QAbstractSlider::mousePressEvent(event);
if (maximum() == minimum() || (event->buttons() ^ event->button()))
{
event->ignore();
return;
}
event->accept();
QStyleOptionSlider opt = qxt_d().getStyleOption();
const QRect sliderRect = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this);
const QPoint center = sliderRect.center() - sliderRect.topLeft();
const int pos = qxt_d().pixelPosToRangeValue(qxt_d().pick(event->pos() - center));
setSliderPosition(pos);
triggerAction(SliderMove);
setRepeatAction(SliderNoAction);
qxt_d().snapBackPosition = pos;
update();
}
void ScrollBar::mouseMoveEvent(QMouseEvent *ev)
{
if (mouse_grabed_) {
// position diff
int pos = (orientation_ == Qt::Horizontal ? ev->pos().x() : ev->pos().y()) - bar_grabed_position_;
// fix negative
pos = qMax(pos, 0);
Q_ASSERT(pos >= 0);
// fix maximum
const qint64 value = qMin(sliderValueFromPosition(pos, drawBarSize()), maximum_);
Q_ASSERT(value <= maximum_);
if (isSliderDown()) {
setSliderPosition(value);
}
if (hasTracking()) {
setValue(value);
}
} else {
// When mouse hovering
if (isScrollBarArea(ev->pos())) {
// TODO: animation
}
}
}
// Based on code from qslider.cpp
void Slider::mousePressEvent( QMouseEvent *e )
{
qDebug("pressed (%d, %d)", e->pos().x(), e->pos().y());
if( e->button() == Qt::LeftButton )
{
qDebug( "Left button" );
QStyleOptionSlider opt;
initStyleOption( &opt );
const QRect sliderRect = style()->subControlRect( QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this );
const QPoint center = sliderRect.center() - sliderRect.topLeft();
// to take half of the slider off for the setSliderPosition call we use the center - topLeft
if ( ! sliderRect.contains( e->pos() ) )
{
qDebug( "accept" );
e->accept();
int v = pixelPosToRangeValue( pick( e->pos() - center ) );
setSliderPosition( v );
triggerAction( SliderMove );
setRepeatAction( SliderNoAction );
emit sliderMoved( v );//TODO: ok?
emit sliderPressed(); //TODO: ok?
}
else
{
QSlider::mousePressEvent( e );
}
}
else
{
QSlider::mousePressEvent( e );
}
}
//-----------------------------------------------------------------------------
// Name: syncToList
// Desc: Synchronizes this slider's position with the list to which it
// is attached. This method is safe to call at any time and will
// not produce an infinite loop.
//-----------------------------------------------------------------------------
void EvidyonGUIList::ListSlider::syncToList()
{
EvidyonGUIList* owner = myOwner;
myOwner = 0; // prevent recursive calling of any sort (future prevention, doesn't do anything now)
setSliderPosition(owner->getScrollIndexPercent());
myOwner = owner;
}
void ScrollBar::moveSlider(double min, double max)
{
const int sliderTicks = qRound((max - min) /
(d_maxBase - d_minBase) * d_baseTicks);
// setRange initiates a valueChanged of the scrollbars
// in some situations. So we block
// and unblock the signals.
blockSignals(true);
setRange(sliderTicks / 2, d_baseTicks - sliderTicks / 2);
int steps = sliderTicks / 200;
if ( steps <= 0 )
steps = 1;
setSingleStep(steps);
setPageStep(sliderTicks);
int tick = mapToTick(min + (max - min) / 2);
if ( isInverted() )
tick = d_baseTicks - tick;
setSliderPosition(tick);
blockSignals(false);
}
void Knob::updatePosition(int val)
{
setSliderPosition(val);
setToolTip(QString::number(val));
update();
emit sliderMoved(val);
}
void DSlider::mouseMoveEvent(QMouseEvent *event)
{
QAbstractSlider::mouseMoveEvent(event);
Q_D(DSlider);
if(d->mousePressed) {
int newPosition = d->pixelPosToRangeValue(d->pick(event->pos()) - d->clickOffset);
setSliderPosition(newPosition);
emit sliderMoved(newPosition);
}
if (!d->m_hoverShowValue) {
return;
}
QPoint pos = event->pos();
QRect rect(d->getScalePosition(value()) - CustomDrawingLeftPadding, 10, 20, 20);
if (d->m_handleHovering) {
d->m_handleHovering = rect.contains(pos);
} else {
d->m_handleHovering = rect.contains(pos);
if (d->m_handleHovering) {
d->m_hoverTimout = false;
if (d->m_hoverShowValueInterval > 0) {
d->m_hoverTimer.start(d->m_hoverShowValueInterval);
}
}
}
update();
}
void HudSlider::mousePressEvent(QGraphicsSceneMouseEvent* event)
{
if (!d->hasValidRange()) {
return;
}
const int pos = d->positionForX(event->pos().x());
if (d->mHandleRect.contains(event->pos())) {
switch (event->button()) {
case Qt::LeftButton:
d->mIsDown = true;
break;
case Qt::MiddleButton:
setSliderPosition(pos);
triggerAction(QAbstractSlider::SliderMove);
break;
default:
break;
}
} else {
d->mRepeatX = event->pos().x();
d->mRepeatAction = pos < d->mSliderPosition
? QAbstractSlider::SliderPageStepSub
: QAbstractSlider::SliderPageStepAdd;
doRepeatAction(FIRST_REPEAT_DELAY);
}
update();
}
/*!
\reimp
*/
void QScrollBar::mousePressEvent(QMouseEvent *e)
{
Q_D(QScrollBar);
if (d->repeatActionTimer.isActive())
d->stopRepeatAction();
bool midButtonAbsPos = style()->styleHint(QStyle::SH_ScrollBar_MiddleClickAbsolutePosition,
0, this);
QStyleOptionSlider opt;
initStyleOption(&opt);
if (d->maximum == d->minimum // no range
|| (e->buttons() & (~e->button())) // another button was clicked before
|| !(e->button() == Qt::LeftButton || (midButtonAbsPos && e->button() == Qt::MidButton)))
return;
d->pressedControl = style()->hitTestComplexControl(QStyle::CC_ScrollBar, &opt, e->pos(), this);
d->pointerOutsidePressedControl = false;
QRect sr = style()->subControlRect(QStyle::CC_ScrollBar, &opt,
QStyle::SC_ScrollBarSlider, this);
QPoint click = e->pos();
QPoint pressValue = click - sr.center() + sr.topLeft();
d->pressValue = d->orientation == Qt::Horizontal ? d->pixelPosToRangeValue(pressValue.x()) :
d->pixelPosToRangeValue(pressValue.y());
if (d->pressedControl == QStyle::SC_ScrollBarSlider) {
d->clickOffset = HORIZONTAL ? (click.x()-sr.x()) : (click.y()-sr.y());
d->snapBackPosition = d->position;
}
if ((d->pressedControl == QStyle::SC_ScrollBarAddPage
|| d->pressedControl == QStyle::SC_ScrollBarSubPage)
&& ((midButtonAbsPos && e->button() == Qt::MidButton)
|| (style()->styleHint(QStyle::SH_ScrollBar_LeftClickAbsolutePosition, &opt, this)
&& e->button() == Qt::LeftButton))) {
int sliderLength = HORIZONTAL ? sr.width() : sr.height();
setSliderPosition(d->pixelPosToRangeValue((HORIZONTAL ? e->pos().x()
: e->pos().y()) - sliderLength / 2));
d->pressedControl = QStyle::SC_ScrollBarSlider;
d->clickOffset = sliderLength / 2;
}
const int initialDelay = 500; // default threshold
QElapsedTimer time;
time.start();
d->activateControl(d->pressedControl, initialDelay);
repaint(style()->subControlRect(QStyle::CC_ScrollBar, &opt, d->pressedControl, this));
if (time.elapsed() >= initialDelay && d->repeatActionTimer.isActive()) {
// It took more than 500ms (the initial timer delay) to process
// the control activation and repaint(), we therefore need
// to restart the timer in case we have a pending mouse release event;
// otherwise we'll get a timer event right before the release event,
// causing the repeat action to be invoked twice on a single mouse click.
// 50ms is the default repeat time (see activateControl/setRepeatAction).
d->repeatActionTimer.start(50, this);
}
if (d->pressedControl == QStyle::SC_ScrollBarSlider)
setSliderDown(true);
}
QVolumeSlider::QVolumeSlider(QWidget *parent) :
QSlider(parent)
{
setRange(0,1000);
connect(this, SIGNAL(valueChanged(int)), this, SLOT(updateVolume(int)));
setValue(1000);
setSliderPosition(1000);
}
/*!
\reimp
*/
void QSlider::mousePressEvent(QMouseEvent *ev)
{
Q_D(QSlider);
if (d->maximum == d->minimum || (ev->buttons() ^ ev->button())) {
ev->ignore();
return;
}
#ifdef QT_KEYPAD_NAVIGATION
if (QApplication::keypadNavigationEnabled())
setEditFocus(true);
#endif
ev->accept();
if ((ev->button() & style()->styleHint(QStyle::SH_Slider_AbsoluteSetButtons)) == ev->button()) {
QStyleOptionSlider opt;
initStyleOption(&opt);
const QRect sliderRect = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this);
const QPoint center = sliderRect.center() - sliderRect.topLeft();
// to take half of the slider off for the setSliderPosition call we use the center - topLeft
setSliderPosition(d->pixelPosToRangeValue(d->pick(ev->pos() - center)));
triggerAction(SliderMove);
setRepeatAction(SliderNoAction);
d->pressedControl = QStyle::SC_SliderHandle;
update();
} else if ((ev->button() & style()->styleHint(QStyle::SH_Slider_PageSetButtons)) == ev->button()) {
QStyleOptionSlider opt;
initStyleOption(&opt);
d->pressedControl = style()->hitTestComplexControl(QStyle::CC_Slider,
&opt, ev->pos(), this);
SliderAction action = SliderNoAction;
if (d->pressedControl == QStyle::SC_SliderGroove) {
const QRect sliderRect = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this);
int pressValue = d->pixelPosToRangeValue(d->pick(ev->pos() - sliderRect.center() + sliderRect.topLeft()));
d->pressValue = pressValue;
if (pressValue > d->value)
action = SliderPageStepAdd;
else if (pressValue < d->value)
action = SliderPageStepSub;
if (action) {
triggerAction(action);
setRepeatAction(action);
}
}
} else {
ev->ignore();
return;
}
if (d->pressedControl == QStyle::SC_SliderHandle) {
QStyleOptionSlider opt;
initStyleOption(&opt);
setRepeatAction(SliderNoAction);
QRect sr = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this);
d->clickOffset = d->pick(ev->pos() - sr.topLeft());
update(sr);
setSliderDown(true);
}
}
void QScaleSlider::SetPosWithBlockedSignals(double pos)
{
bool const b = signalsBlocked();
blockSignals(true);
setSliderPosition(my::rounds(pos * m_factor));
blockSignals(b);
}
/*!
\reimp
*/
void QScrollBar::mouseMoveEvent(QMouseEvent *e)
{
Q_D(QScrollBar);
if (!d->pressedControl)
return;
QStyleOptionSlider opt;
initStyleOption(&opt);
if (!(e->buttons() & Qt::LeftButton
|| ((e->buttons() & Qt::MidButton)
&& style()->styleHint(QStyle::SH_ScrollBar_MiddleClickAbsolutePosition, &opt, this))))
return;
if (d->pressedControl == QStyle::SC_ScrollBarSlider) {
QPoint click = e->pos();
int newPosition = d->pixelPosToRangeValue((HORIZONTAL ? click.x() : click.y()) -d->clickOffset);
int m = style()->pixelMetric(QStyle::PM_MaximumDragDistance, &opt, this);
if (m >= 0) {
QRect r = rect();
r.adjust(-m, -m, m, m);
if (! r.contains(e->pos()))
newPosition = d->snapBackPosition;
}
setSliderPosition(newPosition);
} else if (!style()->styleHint(QStyle::SH_ScrollBar_ScrollWhenPointerLeavesControl, &opt, this)) {
if (style()->styleHint(QStyle::SH_ScrollBar_RollBetweenButtons, &opt, this)
&& d->pressedControl & (QStyle::SC_ScrollBarAddLine | QStyle::SC_ScrollBarSubLine)) {
QStyle::SubControl newSc = style()->hitTestComplexControl(QStyle::CC_ScrollBar, &opt, e->pos(), this);
if (newSc == d->pressedControl && !d->pointerOutsidePressedControl)
return; // nothing to do
if (newSc & (QStyle::SC_ScrollBarAddLine | QStyle::SC_ScrollBarSubLine)) {
d->pointerOutsidePressedControl = false;
QRect scRect = style()->subControlRect(QStyle::CC_ScrollBar, &opt, newSc, this);
scRect |= style()->subControlRect(QStyle::CC_ScrollBar, &opt, d->pressedControl, this);
d->pressedControl = newSc;
d->activateControl(d->pressedControl, 0);
update(scRect);
return;
}
}
// stop scrolling when the mouse pointer leaves a control
// similar to push buttons
QRect pr = style()->subControlRect(QStyle::CC_ScrollBar, &opt, d->pressedControl, this);
if (pr.contains(e->pos()) == d->pointerOutsidePressedControl) {
if ((d->pointerOutsidePressedControl = !d->pointerOutsidePressedControl)) {
d->pointerOutsidePressedControl = true;
setRepeatAction(SliderNoAction);
repaint(pr);
} else {
d->activateControl(d->pressedControl);
}
}
}
}
void Slider::mousePressEvent(QMouseEvent *e)
{
int handlePos = QStyle::sliderPositionFromValue(minimum(),maximum(),sliderPosition(),width());
if(handlePos<e->pos().x()-5||handlePos>e->pos().x()+5)
{
int position = QStyle::sliderValueFromPosition(minimum(),maximum(),e->pos().x(),width());
setSliderPosition(position);
emit sliderMoved(sliderPosition());
}
}
void ThumbSlider::mouseMoveEvent(QMouseEvent *event)
{
if (event->buttons() && Qt::LeftButton)
{
int value = QStyle::sliderValueFromPosition(minimum(), maximum(), event->x(), width(), false);
setSliderPosition(value);
triggerAction(SliderMove);
}
}
void HudSlider::setValue(int value)
{
value = qBound(d->mMin, value, d->mMax);
if (value != d->mValue) {
d->mValue = value;
setSliderPosition(value);
update();
valueChanged(d->mValue);
}
}
void HudSlider::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
{
if (!d->hasValidRange()) {
return;
}
if (d->mIsDown) {
setSliderPosition(d->positionForX(event->pos().x()));
triggerAction(QAbstractSlider::SliderMove);
update();
}
}
void HudSlider::wheelEvent(QGraphicsSceneWheelEvent* event)
{
if (!d->hasValidRange()) {
return;
}
int step = qMin(QApplication::wheelScrollLines() * d->mSingleStep, d->mPageStep);
if ((event->modifiers() & Qt::ControlModifier) || (event->modifiers() & Qt::ShiftModifier)) {
step = d->mPageStep;
}
setSliderPosition(d->mSliderPosition + event->delta() * step / 120);
triggerAction(QAbstractSlider::SliderMove);
}
void QDial::mouseMoveEvent(QMouseEvent * e)
{
Q_D(QDial);
if (!(e->buttons() & Qt::LeftButton)) {
e->ignore();
return;
}
e->accept();
d->doNotEmit = true;
setSliderPosition(d->valueFromPoint(e->pos()));
d->doNotEmit = false;
}
void HudSlider::triggerAction(QAbstractSlider::SliderAction action)
{
switch (action) {
case QAbstractSlider::SliderSingleStepAdd:
setSliderPosition(d->mValue + d->mSingleStep);
break;
case QAbstractSlider::SliderSingleStepSub:
setSliderPosition(d->mValue - d->mSingleStep);
break;
case QAbstractSlider::SliderPageStepAdd:
setSliderPosition(d->mValue + d->mPageStep);
break;
case QAbstractSlider::SliderPageStepSub:
setSliderPosition(d->mValue - d->mPageStep);
break;
case QAbstractSlider::SliderToMinimum:
setSliderPosition(d->mMin);
break;
case QAbstractSlider::SliderToMaximum:
setSliderPosition(d->mMax);
break;
case QAbstractSlider::SliderMove:
case QAbstractSlider::SliderNoAction:
break;
};
actionTriggered(action);
setValue(d->mSliderPosition);
}
/*! Triggers a slider \a action. Possible actions are \l
SliderSingleStepAdd, \l SliderSingleStepSub, \l SliderPageStepAdd,
\l SliderPageStepSub, \l SliderToMinimum, \l SliderToMaximum, and \l
SliderMove.
\sa actionTriggered()
*/
void QAbstractSlider::triggerAction(SliderAction action)
{
Q_D(QAbstractSlider);
d->blocktracking = true;
switch (action) {
case SliderSingleStepAdd:
setSliderPosition(d->overflowSafeAdd(d->effectiveSingleStep()));
break;
case SliderSingleStepSub:
setSliderPosition(d->overflowSafeAdd(-d->effectiveSingleStep()));
break;
case SliderPageStepAdd:
setSliderPosition(d->overflowSafeAdd(d->pageStep));
break;
case SliderPageStepSub:
setSliderPosition(d->overflowSafeAdd(-d->pageStep));
break;
case SliderToMinimum:
setSliderPosition(d->minimum);
break;
case SliderToMaximum:
setSliderPosition(d->maximum);
break;
case SliderMove:
case SliderNoAction:
break;
};
emit actionTriggered(action);
d->blocktracking = false;
setValue(d->position);
}
void ParameterSlider::setValues(const vint& values, const QStringList& labels)
{
Q_ASSERT(values.size() == labels.size());
m_values = values;
m_labels = labels;
setEnabled(m_values.size() > 1);
if (!m_values.empty()) {
m_ui->slider->setRange(0, m_values.size() - 1);
setSliderPosition(0);
}
}
/*!
\reimp
*/
void QSlider::mouseMoveEvent(QMouseEvent *ev)
{
Q_D(QSlider);
if (d->pressedControl != QStyle::SC_SliderHandle) {
ev->ignore();
return;
}
ev->accept();
int newPosition = d->pixelPosToRangeValue(d->pick(ev->pos()) - d->clickOffset);
QStyleOptionSlider opt;
initStyleOption(&opt);
setSliderPosition(newPosition);
}
void QDial::mousePressEvent(QMouseEvent *e)
{
Q_D(QDial);
if (d->maximum == d->minimum ||
(e->button() != Qt::LeftButton) ||
(e->buttons() ^ e->button())) {
e->ignore();
return;
}
e->accept();
setSliderPosition(d->valueFromPoint(e->pos()));
// ### This isn't quite right,
// we should be doing a hit test and only setting this if it's
// the actual dial thingie (similar to what QSlider does), but we have no
// subControls for QDial.
setSliderDown(true);
}
void ScrollBar::moveSlider(double min, double max)
{
if (mLogScale)
{
min = log(min);
max = log(max);
}
int sliderTicks;
sliderTicks = qRound((max - min) /
(d_maxBase - d_minBase) * d_baseTicks);
// setRange initiates a valueChanged of the scrollbars
// in some situations. So we block
// and unblock the signals.
blockSignals(true);
setRange(sliderTicks / 2, d_baseTicks - sliderTicks / 2);
int steps = sliderTicks / 200;
if (steps <= 0)
steps = 1;
#if QT_VERSION < 0x040000
setSteps(steps, sliderTicks);
#else
setSingleStep(steps);
setPageStep(sliderTicks);
#endif
int tick;
tick = mapToTick(min + (max - min) / 2);
if (isInverted())
tick = d_baseTicks - tick;
#if QT_VERSION < 0x040000
directSetValue(tick);
rangeChange();
#else
setSliderPosition(tick);
#endif
blockSignals(false);
}
const bool Slider::input(const sf::Event& event)
{
switch (event.type)
{
case sf::Event::MouseButtonPressed:
if (m_slider.input(event) || (m_plus && m_plus->input(event)) || (m_minus && m_minus->input(event)))
return true;
else if (m_sliderBar.getGlobalBounds().contains(event.mouseButton.x, event.mouseButton.y))
{
setSliderPosition(event.mouseButton.x - m_slider.getGlobalBounds().width / 2);
return true;
}
return false;
case sf::Event::MouseButtonReleased: break;
case sf::Event::MouseMoved: break;
default: break;
}
return false;
}
FABSTRACTSLIDER_INLINE bool FAbstractSlider::setAttribute(Markup::FMarkup* pMarkup, LPCTSTR pszName, LPCTSTR pszValue)
{
if (_tcscmp(pszName, _T("max")) == 0
|| _tcscmp(pszName, _T("maximum")) == 0)
{
setMaximum(_tcstol(pszValue, NULL, 10));
}
else if (_tcscmp(pszName, _T("min")) == 0
|| _tcscmp(pszName, _T("minimum")) == 0)
{
setMinimum(_tcstol(pszValue, NULL, 10));
}
else if (_tcscmp(pszName, _T("value")) == 0
|| _tcscmp(pszName, _T("sliderposition")) == 0)
{
setSliderPosition(_tcstol(pszValue, NULL, 10));
}
return __super::setAttribute(pMarkup, pszName, pszValue);
}
void MainWindow::step() {
if ((source.sourceMode == MOVIE) && (!ui->positionSlider->isSliderDown())) {
setSliderPosition(source.getPos());
}
// if we can't grab, reset to test screen
if (!source.grab()) {
startScreen();
return;
}
switch (viewMode) {
case FINDER:
finder.step(source.frame);
whatWeSee = finder.combined;
break;
case CAPTURE:
if (!capture.step(source.frame)) {
if (source.sourceMode == MOVIE) {
pauze();
} else {
startScreen();
sourceView();
};
};
whatWeSee = capture.combined;
break;
default:
whatWeSee = source.frame;
break;
};
if (recording) {
if (recMode == OUTPUT) {
recorder.putFrame(whatWeSee);
} else {
recorder.putFrame(source.frame);
};
};
ui->CVWindow->update();
};
/*!
\reimp
*/
void QxtStars::mouseMoveEvent(QMouseEvent* event)
{
if (qxt_d().readOnly)
{
event->ignore();
return;
}
QAbstractSlider::mouseMoveEvent(event);
event->accept();
int newPosition = qxt_d().pixelPosToRangeValue(qxt_d().pick(event->pos()));
QStyleOptionSlider opt = qxt_d().getStyleOption();
int m = style()->pixelMetric(QStyle::PM_MaximumDragDistance, &opt, this);
if (m >= 0)
{
QRect r = rect();
r.adjust(-m, -m, m, m);
if (!r.contains(event->pos()))
newPosition = qxt_d().snapBackPosition;
}
setSliderPosition(newPosition);
}
void HudSlider::doRepeatAction(int time)
{
int step = 0;
switch (d->mRepeatAction) {
case QAbstractSlider::SliderSingleStepAdd:
case QAbstractSlider::SliderSingleStepSub:
step = d->mSingleStep;
break;
case QAbstractSlider::SliderPageStepAdd:
case QAbstractSlider::SliderPageStepSub:
step = d->mPageStep;
break;
case QAbstractSlider::SliderToMinimum:
case QAbstractSlider::SliderToMaximum:
case QAbstractSlider::SliderMove:
qWarning() << "Not much point in repeating action of type" << d->mRepeatAction;
return;
case QAbstractSlider::SliderNoAction:
return;
}
int pos = d->positionForX(d->mRepeatX);
if (qAbs(pos - d->mSliderPosition) >= step) {
// We are far enough from the position where the mouse button was held
// down to be able to repeat the action one more time
triggerAction(d->mRepeatAction);
QTimer::singleShot(time, this, SLOT(doRepeatAction()));
} else {
// We are too close to the held down position, reach the position and
// don't repeat
d->mRepeatAction = QAbstractSlider::SliderNoAction;
setSliderPosition(pos);
triggerAction(QAbstractSlider::SliderMove);
return;
}
}