/*!
\class HsAnchorPointInBottomRight
\brief Diagonal widget positioning algorithm.
Sets widget's lower right corner to follow content area's diagonal.
Widgets are positioned to certain offset to each other.
*/
HsWidgetPositioningOnWidgetAdd::Result HsAnchorPointInBottomRight::convert(
const QRectF &contentArea,
const QList<QRectF> &existingRects,
const QList<QRectF> &newRects,
const QPointF &startPoint)
{
Q_UNUSED(existingRects);
HsWidgetPositioningOnWidgetAdd::Result result;
QList<QRectF> toGeometries;
//Offset for widgets' bottom right position to each other
qreal k = contentArea.height()/contentArea.width(); //slope of the diagonal
qreal offset_x = offset/(sqrt(k + 1));
qreal offset_y = k*offset_x;
QPointF offsetPoint(offset_x, offset_y);
QPointF anchorPoint;
if(startPoint.isNull()){
QLineF diagonal(contentArea.topLeft(), contentArea.bottomRight());
QLineF widgetRightSide(contentArea.center().x()+ newRects.at(0).width()/2,
contentArea.top(),
contentArea.center().x()+ newRects.at(0).width()/2,
contentArea.bottom());
// right side line intersection with diagonal will be bottom right position
// for the first rect
if(QLineF::BoundedIntersection !=
diagonal.intersect(widgetRightSide, &anchorPoint)) {
result.calculatedRects = newRects;
return result; //Return original since undefined error.
//In this case widget's must be wider than the content area.
}
} else {
anchorPoint = startPoint - offsetPoint;
}
QRectF widgetRect;
for(int i=0;i<newRects.count();++i) {
widgetRect = newRects.at(i);
widgetRect.moveBottomRight(anchorPoint);
//if widget rect doesn't fit, try to move it
if(!contentArea.contains(widgetRect)) {
/*! precondition is that
widget's max height < content area height
widget's max widht < content area width
*/
widgetRect.moveBottomRight(contentArea.bottomRight());
// anchorPoin is always previous bottom right
anchorPoint = widgetRect.bottomRight();
}
toGeometries << widgetRect;
anchorPoint -= offsetPoint;
}
result.calculatedRects = toGeometries;
return result;
}
bool ContentLoader::load( const QString& filename,
const QPointF& windowCenterPosition,
const QSizeF& windowSize )
{
put_flog( LOG_INFO, "opening: '%s'", filename.toLocal8Bit().constData( ));
ContentPtr content = ContentFactory::getContent( filename );
if( !content )
{
put_flog( LOG_WARN, "ignoring unsupported file: '%s'",
filename.toLocal8Bit().constData( ));
return false;
}
ContentWindowPtr contentWindow( new ContentWindow( content ));
ContentWindowController controller( *contentWindow, *displayGroup_ );
if( windowSize.isValid( ))
controller.resize( windowSize );
else
controller.adjustSize( SIZE_LARGE );
if( windowCenterPosition.isNull( ))
controller.moveCenterTo( displayGroup_->getCoordinates().center( ));
else
controller.moveCenterTo( windowCenterPosition );
displayGroup_->addContentWindow( contentWindow );
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
virtual QwtText trackerText(const QPoint& pos) const override
{
QwtText txt;
const RiuSummaryQwtPlot* sumPlot = dynamic_cast<const RiuSummaryQwtPlot*>(this->plot());
if (sumPlot)
{
int closestYAxis = QwtPlot::yLeft;
QString timeString;
QString valueString;
QPointF closestPoint = sumPlot->closestCurvePoint(pos, &valueString, &timeString, &closestYAxis);
if (!closestPoint.isNull())
{
QString str = valueString;
if (!timeString.isEmpty())
{
str += QString(" (%1)").arg(timeString);
}
txt.setText(str);
}
RiuSummaryQwtPlot* nonConstPlot = const_cast<RiuSummaryQwtPlot*>(sumPlot);
nonConstPlot->updateClosestCurvePointMarker(closestPoint, closestYAxis);
}
return txt;
}
void NetworkEditorView::wheelEvent(QWheelEvent* e) {
QPointF numPixels = e->pixelDelta() / 5.0;
QPointF numDegrees = e->angleDelta() / 8.0 / 15;
if (e->modifiers() == Qt::ControlModifier) {
if (!numPixels.isNull()) {
zoom(qPow(1.05, numPixels.y()));
} else if (!numDegrees.isNull()) {
zoom(qPow(1.05, numDegrees.y()));
}
} else {
QGraphicsView::wheelEvent(e);
}
e->accept();
}
void MapWindow::mouseMoveEvent(QMouseEvent *ev)
{
#if QT_VERSION < 0x050000
QPointF delta = ev->posF() - m_lastPos;
#else
QPointF delta = ev->localPos() - m_lastPos;
#endif
if (!delta.isNull()) {
if (ev->buttons() == Qt::LeftButton && ev->modifiers() & Qt::ShiftModifier) {
m_map->setPitch(m_map->pitch() - delta.y());
} else if (ev->buttons() == Qt::LeftButton) {
m_map->moveBy(delta);
} else if (ev->buttons() == Qt::RightButton) {
#if QT_VERSION < 0x050000
m_map->rotateBy(m_lastPos, ev->posF());
#else
m_map->rotateBy(m_lastPos, ev->localPos());
#endif
}
}
#if QT_VERSION < 0x050000
m_lastPos = ev->posF();
#else
m_lastPos = ev->localPos();
#endif
ev->accept();
}
bool PunchFilter::setOption(int option, const QVariant &value)
{
bool bOK = true;
switch (option) {
case QtImageFilter::Radius:
{
double radius = value.toDouble(&bOK);
if (bOK) m_Radius = radius;
}
break;
case QtImageFilter::Center:
{
QPointF center = value.toPointF();
if (center.isNull()) {
bOK = false;
} else {
m_Center = center;
}
}
break;
case QtImageFilter::Force:
{
double force = value.toDouble(&bOK);
if (bOK) m_Force = force;
}
break;
default:
bOK = false;
break;
}
return bOK;
}
void QtBasicGraph::addPoint(const QPointF &value)
{
QPointF oldval;
if (!m_values.isEmpty())
oldval = m_values.last();
if (!oldval.isNull() && value.x() < oldval.x()) {
qWarning("QtBasicGraph::addPoint(): the new point's x value is less than the last point's x value.");
return;
}
m_values << value;
if (!oldval.isNull()) {
qreal deltaf = width() * ((value.x() - oldval.x()) / m_xrange);
int delta = (int) deltaf;
m_scroll_error += (deltaf - qreal(delta));
if (m_scroll_error > qreal(1.0)) {
m_scroll_error--;
delta++;
}
if (delta < width()) {
scroll(-delta, 0);
update(width() - delta - 3, 0, delta + 3, height());
} else {
m_scroll_error = 0;
update();
}
// purge old data
qreal left = value.x() - m_xrange;
int i;
for (i = 0; i < m_values.size(); ++i) {
if (m_values[i].x() > left)
break;
}
i--;
if (i > 0 && i < (m_values.size() - 1))
m_values.erase(m_values.begin(), m_values.begin() + i);
}
}
void TscoreClef::untouched(const QPointF& scenePos) {
if (!scenePos.isNull() && m_tapTimer.hasExpired(300)) {
QGraphicsSceneMouseEvent me(QEvent::MouseButtonPress);
me.setPos(mapFromScene(scenePos));
me.setButton(Qt::LeftButton);
mousePressEvent(&me);
}
}
void SymbolDataEditor::setSymbolData(const QPointF _inPoint, const QPointF _outPoint, const QRectF _limits)
{
if (scene->items().isEmpty())
return;
QRectF symbolRect = scene->items(Qt::AscendingOrder).at(Item::SymbolItem)->boundingRect();
symbolRect.moveTopLeft(scene->items(Qt::AscendingOrder).at(Item::SymbolItem)->pos());
symbolRect.adjust(symbolRect.width() / 4, symbolRect.height() / 4,
-symbolRect.width() / 4, -symbolRect.height() / 4);
//try to set data automatically if they're not set
if (_inPoint.isNull())
{
if (setupPoints)
inPoint = getBeginPoint();
else
{
inPoint = symbolRect.topLeft();
inPoint.ry() += symbolRect.height() / 2;
}
}
else
inPoint = fromStored(_inPoint);
if (_outPoint.isNull())
{
if (setupPoints)
outPoint = getEndPoint();
else
{
outPoint = symbolRect.topRight();
outPoint.ry() += symbolRect.height() / 2;
}
}
else
outPoint = fromStored(_outPoint);
if (_limits.isNull())
limits = symbolRect;
else
limits = QRectF(fromStored(_limits.topLeft()),
fromStored(_limits.bottomRight()));
correctLimits();
addDataItems();
}
void
ZoomWidget::moveViewWorldCs( const QPointF & d )
{
if ( d.isNull() )
return;
wm_.translate( d.x(), -d.y() );
emit matrixChanged( wm_ );
}
void KisPrescaledProjection::viewportMoved(const QPointF &offset)
{
// FIXME: \|/
if (m_d->prescaledQImage.isNull()) return;
if (offset.isNull()) return;
QPoint alignedOffset = offset.toPoint();
if(offset != alignedOffset) {
/**
* We can't optimize anything when offset is float :(
* Just prescale entire image.
*/
dbgRender << "prescaling the entire image because the offset is float";
preScale();
return;
}
QImage newImage = QImage(m_d->viewportSize, QImage::Format_ARGB32);
newImage.fill(0);
/**
* TODO: viewport rects should be cropped by the borders of
* the image, because it may be requested to read/write
* outside QImage and copyQImage will not chatch it
*/
QRect newViewportRect = QRect(QPoint(0,0), m_d->viewportSize);
QRect oldViewportRect = newViewportRect.translated(alignedOffset);
QRegion updateRegion = newViewportRect;
QRect savedArea = newViewportRect & oldViewportRect;
if(!savedArea.isEmpty()) {
copyQImage(alignedOffset.x(), alignedOffset.y(), &newImage, m_d->prescaledQImage);
updateRegion -= savedArea;
}
QPainter gc(&newImage);
QVector<QRect> rects = updateRegion.rects();
foreach(const QRect &rect, rects) {
QRect imageRect =
m_d->coordinatesConverter->viewportToImage(rect).toAlignedRect();
QVector<QRect> patches =
KritaUtils::splitRectIntoPatches(imageRect, m_d->updatePatchSize);
foreach(const QRect& rc, patches) {
QRect viewportPatch =
m_d->coordinatesConverter->imageToViewport(rc).toAlignedRect();
KisPPUpdateInfoSP info = getInitialUpdateInformation(QRect());
fillInUpdateInformation(viewportPatch, info);
drawUsingBackend(gc, info);
}
void NavigationView::plotLineForSelected() {
if (scene()->selectedItems().count()<2)
return;
QLineF vectorLine(scene()->selectedItems().at(0)->pos(), scene()->selectedItems().at(1)->pos());
QLineF sides[4] = {
QLineF(0, 0, 0, scene()->height()),
QLineF(scene()->width(), 0, scene()->width(), scene()->height()),
QLineF(0, 0, scene()->width(), 0),
QLineF(0, scene()->height(), scene()->width(), scene()->height())
};
QPointF yStart;
QPointF xStart;
int i=0;
while(yStart.isNull()) {
if (vectorLine.intersect(sides[i++], &yStart)!=QLineF::BoundedIntersection) {
qDebug("could not intersect y");
}
i++;
}
i=1;
while(xStart.isNull()) {
if (vectorLine.intersect(sides[i++], &xStart)!=QLineF::BoundedIntersection) {
qDebug("could not intersect x");
}
}
//IntersectionLineItem lineItem(QLineF(yStart, xStart);
QPen linePen(Qt::black);
linePen.setWidth(3);
QGraphicsLineItem * line = scene()->addLine(QLineF(yStart, xStart));
line->setPen(linePen);
line->setFlag(QGraphicsItem::ItemIsSelectable, true);
emit newLineAdded(mapSceneToGeo(scene()->selectedItems().at(0)->pos()), mapSceneToGeo(scene()->selectedItems().at(1)->pos()));
}
void updateCurrentTime(int ms) {
QPointF point = m_cache.at(ms);
if (! point.isNull()) {
++ m_hits;
} else {
point = m_path.pointAtPercent(qreal(ms) / m_duration);
m_cache[ms] = point;
++ m_misses;
}
if (m_target) m_target->setPos(point);
}
void QKineticScrollerPrivate::timerEventWhileScrolling()
{
qreal deltaTime = qreal(scrollRelativeTimer.restart()) / 1000;
qreal time = qreal(scrollAbsoluteTimer.elapsed()) / 1000;
// calculate the velocity for the passed interval deltatime.
// using the midpoint of the interval gives a better precision than using just time.
QPointF newVelocity = calculateVelocity(time - deltaTime / 2);
QPointF deltaPos = newVelocity * deltaTime * pixelPerMeter;
// -- move (convert from [m/s] to [pix/frame]
if (!deltaPos.isNull())
setContentPositionHelper(deltaPos);
qKSDebug() << "QKS::timerEventWhileScrolling() -- DeltaPos:" << deltaPos << "- NewVel:" << newVelocity << "- Time:" << time;
if (newVelocity.isNull() ||
(releaseVelocity.isNull() && !scrollToX && !scrollToY && !overshootX && !overshootY))
// if (newVelocity.isNull())
setState(QKineticScroller::StateInactive);
}
void QPolygonF::translate(const QPointF &offset)
{
if (offset.isNull())
return;
QPointF *p = data();
int i = size();
while (i--) {
*p += offset;
++p;
}
}
void applyBrushOrigin(const QPointF &origin)
{
if (brush.brush && !origin.isNull()) {
D2D1_MATRIX_3X2_F transform;
brush.brush->GetTransform(&transform);
brush.brush->SetTransform(*(D2D1::Matrix3x2F::ReinterpretBaseType(&transform))
* D2D1::Matrix3x2F::Translation(origin.x(), origin.y()));
}
currentBrushOrigin = origin;
}
QmlItemNode QmlItemNode::createQmlItemNode(AbstractView *view, const ItemLibraryEntry &itemLibraryEntry, const QPointF &position, NodeAbstractProperty parentproperty)
{
QmlItemNode newQmlItemNode;
try {
RewriterTransaction transaction = view->beginRewriterTransaction(QByteArrayLiteral("QmlItemNode::createQmlItemNode"));
NodeMetaInfo metaInfo = view->model()->metaInfo(itemLibraryEntry.typeName());
int minorVersion = metaInfo.minorVersion();
int majorVersion = metaInfo.majorVersion();
typedef QPair<PropertyName, QString> PropertyBindingEntry;
QList<PropertyBindingEntry> propertyBindingList;
if (itemLibraryEntry.qmlSource().isEmpty()) {
QList<QPair<PropertyName, QVariant> > propertyPairList;
if (!position.isNull()) {
propertyPairList.append(qMakePair(PropertyName("x"), QVariant(qRound(position.x()))));
propertyPairList.append(qMakePair(PropertyName("y"), QVariant(qRound(position.y()))));
}
foreach (const PropertyContainer &property, itemLibraryEntry.properties()) {
if (property.type() == QStringLiteral("binding")) {
propertyBindingList.append(PropertyBindingEntry(property.name(), property.value().toString()));
} else {
propertyPairList.append(qMakePair(property.name(), property.value()));
}
}
newQmlItemNode = QmlItemNode(view->createModelNode(itemLibraryEntry.typeName(), majorVersion, minorVersion, propertyPairList));
} else {
newQmlItemNode = createQmlItemNodeFromSource(view, itemLibraryEntry.qmlSource(), position);
}
if (parentproperty.isValid())
parentproperty.reparentHere(newQmlItemNode);
if (!newQmlItemNode.isValid())
return newQmlItemNode;
newQmlItemNode.setId(view->generateNewId(itemLibraryEntry.name()));
if (!view->currentState().isBaseState()) {
newQmlItemNode.modelNode().variantProperty("opacity").setValue(0);
newQmlItemNode.setVariantProperty("opacity", 1);
}
foreach (const PropertyBindingEntry &propertyBindingEntry, propertyBindingList)
newQmlItemNode.modelNode().bindingProperty(propertyBindingEntry.first).setExpression(propertyBindingEntry.second);
Q_ASSERT(newQmlItemNode.isValid());
}
void XFormView::updateCtrlPoints(const QPolygonF &points)
{
QPointF trans = points.at(0) - ctrlPoints.at(0);
if (qAbs(points.at(0).x() - points.at(1).x()) < 10
&& qAbs(points.at(0).y() - points.at(1).y()) < 10)
pts->setPoints(ctrlPoints);
if (!trans.isNull()) {
ctrlPoints[0] = points.at(0);
ctrlPoints[1] += trans;
pts->setPoints(ctrlPoints);
}
ctrlPoints = points;
QLineF line(ctrlPoints.at(0), ctrlPoints.at(1));
m_rotation = line.angle(QLineF(0, 0, 1, 0));
if (line.dy() < 0)
m_rotation = 360 - m_rotation;
if (trans.isNull())
emit rotationChanged(int(m_rotation*10));
}
void
ZoomWidget::moveView( const QPointF & d )
{
if ( d.isNull() )
return;
QMatrix m;
m = wm_.inverted();
m.translate( -d.x(), -d.y() );
wm_ = m.inverted();
emit matrixChanged( wm_ );
}
myTextItem::myTextItem(const QString &tag, const QString &text,
const QPointF &ps, const QFont &fnt,
const QColor &col, bool v_mode)
: m_tag ( QString("[XXX]") )
, m_text ( QString() )
, m_mode (false)
{
v_mode = m_mode;
if (text.isEmpty()){
this->setEText(tag);
}else{
this->setEText(text);
}
if (v_mode){
this->setPlainText(tag);
}else{
this->setPlainText(text);
}
if (ps.isNull()){
this->setPos( QPointF(100.0,100.0) );
}else{
this->setPos(ps);
}
this->setFont(fnt);
// if (fnt){
// this->setFont(fnt);
// }else{
// this->setFont( QFont("Times", 14, QFont::Bold) ) ;
// }
if( col.isValid() ){
this->setDefaultTextColor( col );
}else{
this->setDefaultTextColor( Qt::black );
}
this->setETag(tag);
this->setZValue(100);
this->setFlag(QGraphicsItem::ItemIsMovable, true);
this->setFlag(QGraphicsItem::ItemIsSelectable, true);
this->setFlag(QGraphicsItem::ItemIsFocusable, true);
this->setData(ObjectName, "tElem");
}
void CChartTable::dragScrPosition( const QPointF& _rqPointFScrPositionOffset )
{
if( bIgnoreUpdate || QTabWidget::currentIndex() < 0 || _rqPointFScrPositionOffset.isNull() ) return;
CChart* __poChart = (CChart*)QTabWidget::currentWidget();
/*
* NOTE: We do not move the chart by calling this->setGeoPosition directly because it leads
* to extra offset artefacts due to the pixel<->geographical position back and forth conversion.
* Instead, we move the chart directly by modifying the pixel positon and
* update the reference geographical position accordingly.
*/
__poChart->move( _rqPointFScrPositionOffset );
// __poChart->update();
if( __poChart->isPositionLocked() ) setGeoPosition( __poChart->getGeoPosition(), true );
}
bool QBezier::deletePoint(const QPointF& c)
{
if (c.isNull() || knowPoints.isEmpty() )
{
return false;
}
QList<QPointF>::iterator itor;
for(itor = knowPoints.begin();itor != knowPoints.end();itor++)
{
if(*itor == c)
break;
}
knowPoints.erase(itor);
return true;
}
QVariant ImageMarker::itemChange(GraphicsItemChange change, const QVariant &value)
{
if (change == ItemPositionChange && scene()) {
QPointF newPos = getLimitPos(value.toPointF());
if (! newPos.isNull()) {
return newPos;
}
}
else if (change == ItemPositionHasChanged && scene()) {
m_view->updateCircles();
}
return QGraphicsItem::itemChange(change, value);
}
void QLagrage::addPoint(const QPointF& p)
{
if( p.isNull())
return;
QList<QPointF>::iterator itor;
for( itor = knowPoints.begin();itor != knowPoints.end();itor++)
{
if(*itor == p || qAbs(p.x() - (*itor).x()) < deta)
return;
if( (*itor).x() > p.x())
break;
}
knowPoints.insert(itor,p);
updateCurve();
}
void ObjectSelectionTool::keyPressed(QKeyEvent *event)
{
if (mAction != NoAction) {
event->ignore();
return;
}
QPointF moveBy;
switch (event->key()) {
case Qt::Key_Up: moveBy = QPointF(0, -1); break;
case Qt::Key_Down: moveBy = QPointF(0, 1); break;
case Qt::Key_Left: moveBy = QPointF(-1, 0); break;
case Qt::Key_Right: moveBy = QPointF(1, 0); break;
default:
AbstractObjectTool::keyPressed(event);
return;
}
const QSet<MapObjectItem*> &items = mapScene()->selectedObjectItems();
const Qt::KeyboardModifiers modifiers = event->modifiers();
if (moveBy.isNull() || items.isEmpty() || (modifiers & Qt::ControlModifier)) {
event->ignore();
return;
}
const bool moveFast = modifiers & Qt::ShiftModifier;
const bool snapToFineGrid = Preferences::instance()->snapToFineGrid();
if (moveFast) {
// TODO: This only makes sense for orthogonal maps
moveBy.rx() *= mapDocument()->map()->tileWidth();
moveBy.ry() *= mapDocument()->map()->tileHeight();
if (snapToFineGrid)
moveBy /= Preferences::instance()->gridFine();
}
QUndoStack *undoStack = mapDocument()->undoStack();
undoStack->beginMacro(tr("Move %n Object(s)", "", items.size()));
int i = 0;
foreach (MapObjectItem *objectItem, items) {
MapObject *object = objectItem->mapObject();
const QPointF oldPos = object->position();
const QPointF newPos = oldPos + moveBy;
undoStack->push(new MoveMapObject(mapDocument(), object, newPos, oldPos));
++i;
}
void MapToVariantConverter::addLayerAttributes(QVariantMap &layerVariant,
const Layer &layer) const
{
layerVariant[QLatin1String("name")] = layer.name();
layerVariant[QLatin1String("x")] = layer.x();
layerVariant[QLatin1String("y")] = layer.y();
layerVariant[QLatin1String("visible")] = layer.isVisible();
layerVariant[QLatin1String("opacity")] = layer.opacity();
const QPointF offset = layer.offset();
if (!offset.isNull()) {
layerVariant[QLatin1String("offsetx")] = offset.x();
layerVariant[QLatin1String("offsety")] = offset.y();
}
addProperties(layerVariant, layer.properties());
}
//没有必要按照X的升序排列
void QBezier::addPoint(const QPointF& c)
{
if (c.isNull())
return;
if ( knowPoints.isEmpty() )
{
knowPoints.append(c);
updateCurve();
return;
}
if(-1 != knowPoints.indexOf(c))
{
return;
}
knowPoints.append(c);
updateCurve();
}
void GpxLayer::zoom(int level)
{
if (m_track.count() > 1) {
int scale = 1 << level;
m_trackOnScreen.clear();
m_trackOffset = map()->raw2screen(m_track.first().x(), m_track.first().y(), scale);
m_trackOnScreen << QPoint(0, 0);
for (int i = 1; i < m_track.count(); ++i) {
QPointF p = m_track.at(i);
if (!p.isNull()) {
m_trackOnScreen << map()->raw2screen(p.x(), p.y(), scale) - m_trackOffset;
} else {
m_trackOnScreen << QPoint();
}
}
}
}
bool QKineticScrollerPrivate::moveWhilePressed(QKineticScroller::Input, const QPointF &position, qint64 timestamp)
{
Q_Q(QKineticScroller);
QPointF deltaPixel = position - pressPosition;
bool moveStarted = ((deltaPixel.manhattanLength() / pixelPerMeter) > dragStartDistance);
if (moveStarted) {
qreal deltaXtoY = qAbs(pressPosition.x() - position.x()) - qAbs(pressPosition.y() - position.y());
deltaXtoY /= pixelPerMeter;
QPointF maxPos = q->maximumContentPosition();
bool canScrollX = (maxPos.x() > 0);
bool canScrollY = (maxPos.y() > 0);
if (hOvershootPolicy == QKineticScroller::OvershootAlwaysOn)
canScrollX = true;
if (vOvershootPolicy == QKineticScroller::OvershootAlwaysOn)
canScrollY = true;
if (deltaXtoY < 0) {
if (!canScrollY && (!canScrollX || (-deltaXtoY >= dragStartDirectionErrorMargin)))
moveStarted = false;
} else {
if (!canScrollX && (!canScrollY || (deltaXtoY >= dragStartDirectionErrorMargin)))
moveStarted = false;
}
}
if (moveStarted) {
if (cancelPress)
q->cancelPress(pressPosition);
setState(QKineticScroller::StateDragging);
// subtract the dragStartDistance
deltaPixel = deltaPixel - deltaPixel * (dragStartDistance / deltaPixel.manhattanLength());
if (!deltaPixel.isNull()) {
// handleDrag updates lastPosition, lastTimestamp and velocity
handleDrag(pressPosition + deltaPixel, timestamp);
}
}
return moveStarted;
}
static PyObject *meth_QPointF_isNull(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
QPointF *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QPointF, &sipCpp))
{
bool sipRes;
Py_BEGIN_ALLOW_THREADS
sipRes = sipCpp->isNull();
Py_END_ALLOW_THREADS
return PyBool_FromLong(sipRes);
}
}
