void SmudgeTool::mousePressEvent(QMouseEvent *event)
{
//qDebug() << "smudgetool: mousePressEvent";
Layer *layer = m_pEditor->getCurrentLayer();
if (layer == NULL) {
return;
}
if (event->button() == Qt::LeftButton)
{
if (layer->type == Layer::BITMAP)
{
m_pEditor->backup(typeName());
m_pScribbleArea->setAllDirty();
startStroke();
lastBrushPoint = getCurrentPoint();
}
else if (layer->type == Layer::VECTOR)
{
m_pScribbleArea->closestCurves = ((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0)
->getCurvesCloseTo(getCurrentPoint(), m_pScribbleArea->tol / m_pScribbleArea->getTempViewScaleX());
m_pScribbleArea->closestVertices = ((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0)
->getVerticesCloseTo(getCurrentPoint(), m_pScribbleArea->tol / m_pScribbleArea->getTempViewScaleX());
if (m_pScribbleArea->closestVertices.size() > 0 || m_pScribbleArea->closestCurves.size() > 0) // the user clicks near a vertex or a curve
{
//qDebug() << "closestCurves:" << closestCurves << " | closestVertices" << closestVertices;
m_pEditor->backup(typeName());
VectorImage *vectorImage = ((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0);
if (event->modifiers() != Qt::ShiftModifier && !vectorImage->isSelected(m_pScribbleArea->closestVertices))
{
m_pScribbleArea->paintTransformedSelection();
m_pScribbleArea->deselectAll();
}
vectorImage->setSelected(m_pScribbleArea->closestVertices, true);
m_pScribbleArea->vectorSelection.add(m_pScribbleArea->closestCurves);
m_pScribbleArea->vectorSelection.add(m_pScribbleArea->closestVertices);
m_pScribbleArea->update();
}
else
{
m_pScribbleArea->deselectAll();
}
}
}
}
void BrushTool::mousePressEvent( QMouseEvent *event )
{
if ( event->button() == Qt::LeftButton )
{
mEditor->backup( typeName() );
mScribbleArea->setAllDirty();
}
mMouseDownPoint = getCurrentPoint();
mLastBrushPoint = getCurrentPoint();
startStroke();
}
void PencilTool::pointerPressEvent(PointerEvent*)
{
mScribbleArea->setAllDirty();
mMouseDownPoint = getCurrentPoint();
mLastBrushPoint = getCurrentPoint();
startStroke();
// note: why are we doing this on device press event?
if ( !mEditor->preference()->isOn(SETTING::INVISIBLE_LINES) )
{
mScribbleArea->toggleThinLines();
}
}
/**
* @brief MoveTool::storeClosestVectorCurve
* stores the curves closest to the mouse position in mClosestCurves
*/
void MoveTool::storeClosestVectorCurve(Layer* layer)
{
auto layerVector = static_cast<LayerVector*>(layer);
VectorImage* pVecImg = layerVector->getLastVectorImageAtFrame(mEditor->currentFrame(), 0);
mScribbleArea->mClosestCurves = pVecImg->getCurvesCloseTo(getCurrentPoint(),
mScribbleArea->mSelectionTolerance / mEditor->view()->scaling());
}
void PolylineTool::mousePressEvent( QMouseEvent *event )
{
Layer* layer = mEditor->layers()->currentLayer();
if ( event->button() == Qt::LeftButton )
{
if ( layer->type() == Layer::BITMAP || layer->type() == Layer::VECTOR )
{
if ( points.size() == 0 )
{
mEditor->backup( tr( "Line" ) );
}
if ( layer->type() == Layer::VECTOR )
{
( ( LayerVector * )layer )->getLastVectorImageAtFrame( mEditor->currentFrame(), 0 )->deselectAll();
if ( mScribbleArea->makeInvisible() && !mEditor->preference()->isOn(EFFECT::INVISIBLE_LINES) )
{
mScribbleArea->toggleThinLines();
}
}
points << getCurrentPoint();
mScribbleArea->setAllDirty();
}
}
}
void SmudgeTool::mouseMoveEvent(QMouseEvent *event)
{
Layer* layer = mEditor->layers()->currentLayer();
if (layer == NULL) { return; }
if (layer->type() == Layer::BITMAP || layer->type() == Layer::VECTOR)
{
if (event->buttons() & Qt::LeftButton) // the user is also pressing the mouse (dragging) {
{
if (layer->type() == Layer::BITMAP)
{
drawStroke();
}
else if (layer->type() == Layer::VECTOR)
{
if (event->modifiers() != Qt::ShiftModifier) // (and the user doesn't press shift)
{
// transforms the selection
mScribbleArea->selectionTransformation = QTransform().translate(mScribbleArea->mOffset.x(), mScribbleArea->mOffset.y());
((LayerVector *)layer)->getLastVectorImageAtFrame( mEditor->currentFrame(), 0)->setSelectionTransformation(mScribbleArea->selectionTransformation);
}
}
}
else // the user is moving the mouse without pressing it
{
if (layer->type() == Layer::VECTOR)
{
mScribbleArea->mClosestVertices = ((LayerVector *)layer)->getLastVectorImageAtFrame(mEditor->currentFrame(), 0)
->getVerticesCloseTo( getCurrentPoint(), mScribbleArea->tol / mEditor->view()->scaling() );
}
}
mScribbleArea->update();
mScribbleArea->setAllDirty();
}
}
void EyedropperTool::mouseMoveEvent(QMouseEvent *event)
{
Q_UNUSED(event);
Layer* layer = mEditor->layers()->currentLayer();
if (layer == NULL) { return; }
if (layer->type() == Layer::BITMAP)
{
BitmapImage *targetImage = ((LayerBitmap *)layer)->getLastBitmapImageAtFrame(mEditor->currentFrame(), 0);
if (targetImage->contains(getCurrentPoint()))
{
QColor pickedColour;
//pickedColour.setRgba(targetImage->pixel(getCurrentPoint().x(), getCurrentPoint().y()));
pickedColour.setRgba( targetImage->pixel( getCurrentPoint().x(), getCurrentPoint().y() ) );
int transp = 255 - pickedColour.alpha();
pickedColour.setRed( pickedColour.red() + transp );
pickedColour.setGreen( pickedColour.green() + transp );
pickedColour.setBlue( pickedColour.blue() + transp );
if (pickedColour.alpha() != 0)
{
mScribbleArea->setCursor(cursor(pickedColour));
}
else
{
mScribbleArea->setCursor(cursor());
}
}
else
{
mScribbleArea->setCursor(cursor());
}
}
if (layer->type() == Layer::VECTOR)
{
VectorImage *vectorImage = ((LayerVector *)layer)->getLastVectorImageAtFrame(mEditor->currentFrame(), 0);
int colourNumber = vectorImage->getColourNumber(getCurrentPoint());
if (colourNumber != -1)
{
mScribbleArea->setCursor(cursor(mEditor->object()->getColour(colourNumber).colour));
}
else
{
mScribbleArea->setCursor(cursor());
}
}
}
void PolylineTool::mouseMoveEvent( QMouseEvent *event )
{
Q_UNUSED( event );
Layer* layer = mEditor->layers()->currentLayer();
if ( layer->type() == Layer::BITMAP || layer->type() == Layer::VECTOR )
{
mScribbleArea->drawPolyline( points, getCurrentPoint() );
}
}
void EraserTool::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::LeftButton)
{
m_pEditor->backup(typeName());
m_pScribbleArea->setAllDirty();
}
startStroke();
lastBrushPoint = getCurrentPoint();
}
void SelectTool::mouseMoveEvent(QMouseEvent *event)
{
Layer *layer = m_pEditor->getCurrentLayer();
if (layer == NULL) { return; }
if ((event->buttons() & Qt::LeftButton) && m_pScribbleArea->somethingSelected && (layer->type == Layer::BITMAP || layer->type == Layer::VECTOR))
{
switch (m_pScribbleArea->getMoveMode())
{
case ScribbleArea::MIDDLE:
m_pScribbleArea->mySelection.setBottomRight(getCurrentPoint());
break;
case ScribbleArea::TOPLEFT:
m_pScribbleArea->mySelection.setTopLeft(getCurrentPoint());
break;
case ScribbleArea::TOPRIGHT:
m_pScribbleArea->mySelection.setTopRight(getCurrentPoint());
break;
case ScribbleArea::BOTTOMLEFT:
m_pScribbleArea->mySelection.setBottomLeft(getCurrentPoint());
break;
case ScribbleArea::BOTTOMRIGHT:
m_pScribbleArea->mySelection.setBottomRight(getCurrentPoint());
break;
}
m_pScribbleArea->myTransformedSelection = m_pScribbleArea->mySelection.adjusted(0, 0, 0, 0);
m_pScribbleArea->myTempTransformedSelection = m_pScribbleArea->mySelection.adjusted(0, 0, 0, 0);
if (layer->type == Layer::VECTOR)
{
((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0)->select(m_pScribbleArea->mySelection);
}
m_pScribbleArea->update();
}
}
void PathAnimator::drawMarker()
{
if (!isRunning)
{
return;
}
QVector3D currentPoint = getCurrentPoint();
glColor3f(0.3f, 0.6f, 0.3f);
glPointSize(12.0f);
glBegin(GL_POINTS);
glVertex3d(currentPoint.x(), currentPoint.y(), currentPoint.z());
glEnd();
}
void BrushTool::mouseReleaseEvent( QMouseEvent *event )
{
Layer* layer = mEditor->layers()->currentLayer();
if ( event->button() == Qt::LeftButton )
{
if ( mScribbleArea->isLayerPaintable() )
{
if (getCurrentPoint()==mMouseDownPoint)
{
paintAt(mMouseDownPoint);
}
else
{
drawStroke();
}
}
if ( layer->type() == Layer::BITMAP )
{
mScribbleArea->paintBitmapBuffer();
mScribbleArea->setAllDirty();
mScribbleArea->clearBitmapBuffer();
}
else if ( layer->type() == Layer::VECTOR && mStrokePoints.size() > -1 )
{
// Clear the temporary pixel path
mScribbleArea->clearBitmapBuffer();
qreal tol = mScribbleArea->getCurveSmoothing() / mEditor->view()->scaling();
BezierCurve curve( mStrokePoints, mStrokePressures, tol );
curve.setWidth( properties.width );
curve.setFeather( properties.feather );
curve.setInvisibility( false );
curve.setVariableWidth( properties.pressure );
curve.setColourNumber( mEditor->color()->frontColorNumber() );
auto pLayerVector = static_cast< LayerVector* >( layer );
VectorImage* vectorImage = pLayerVector->getLastVectorImageAtFrame( mEditor->currentFrame(), 0 );
vectorImage->insertCurve( 0, curve, mEditor->view()->scaling(), false );
mScribbleArea->setModified( mEditor->layers()->currentLayerIndex(), mEditor->currentFrame() );
mScribbleArea->setAllDirty();
}
}
endStroke();
}
void Game::playStep(){
//TODO if maxNumPoints < LIMIT
if (!this->isEnded()){ // Game in progress
// get current Point
Point* toPlay = getCurrentPoint();
// play current point
toPlay->playStep();
} else { // Game over
// Game::isEnded() = true,
// this game will be deconstructed by the server.
}
}
void PencilTool::pointerReleaseEvent(PointerEvent*)
{
mEditor->backup(typeName());
qreal distance = QLineF(getCurrentPoint(), mMouseDownPoint).length();
if (distance < 1)
{
paintAt(mMouseDownPoint);
}
else
{
drawStroke();
}
Layer* layer = mEditor->layers()->currentLayer();
if (layer->type() == Layer::BITMAP)
paintBitmapStroke();
else if (layer->type() == Layer::VECTOR)
paintVectorStroke(layer);
endStroke();
}
void EraserTool::mouseMoveEvent(QMouseEvent *event)
{
Layer *layer = m_pEditor->getCurrentLayer();
if (event->buttons() & Qt::LeftButton)
{
if (layer->type == Layer::BITMAP || layer->type == Layer::VECTOR)
{
drawStroke();
}
if (layer->type == Layer::VECTOR)
{
qreal radius = (properties.width / 2) / m_pScribbleArea->getTempViewScaleX();
QList<VertexRef> nearbyVertices = ((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0)
->getVerticesCloseTo(getCurrentPoint(), radius);
for (int i = 0; i < nearbyVertices.size(); i++)
{
((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0)->setSelected(nearbyVertices.at(i), true);
}
//update();
m_pScribbleArea->setAllDirty();
}
}
}
bool MoveTool::shouldDeselect()
{
return (!mScribbleArea->myTransformedSelection.contains(getCurrentPoint())
&& mScribbleArea->getMoveMode() == MoveMode::NONE);
}
void SmudgeTool::drawStroke()
{
if ( !m_pScribbleArea->isLayerPaintable() ) return;
Layer *layer = m_pEditor->getCurrentLayer();
if (layer == NULL) {
return;
}
BitmapImage *targetImage = ((LayerBitmap *)layer)->getLastBitmapImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0);
StrokeTool::drawStroke();
QList<QPointF> p = m_pStrokeManager->interpolateStroke(currentWidth);
for (int i = 0; i < p.size(); i++) {
p[i] = m_pScribbleArea->pixelToPoint(p[i]);
}
qreal opacity = 1.0;
qreal brushWidth = currentWidth + 0.0 * properties.feather;
qreal offset = qMax(0.0, currentWidth - 0.5 * properties.feather) / brushWidth;
//opacity = currentPressure; // todo: Probably not interesting?!
//brushWidth = brushWidth * opacity;
BlitRect rect;
QPointF a = lastBrushPoint;
QPointF b = getCurrentPoint();
if (toolMode == 0) // default mode = blur smudge
{
qreal brushStep = 0.5 * ( currentWidth + properties.feather ) / 40.0;
qreal distance = QLineF(b, a).length()*2;
brushStep = qMax( 1.0, brushStep * opacity );
//brushStep = 2.0;
//currentWidth = properties.width; // here ?
int steps = qRound(distance / brushStep);
int rad = qRound(brushWidth / 2.0) + 2;
QPointF sourcePoint = lastBrushPoint;
for (int i = 0; i < steps; i++)
{
QPointF targetPoint = lastBrushPoint + (i + 1) * (brushStep) * (b - lastBrushPoint) / distance;
rect.extend(targetPoint.toPoint());
m_pScribbleArea->blurBrush( targetImage,
sourcePoint,
targetPoint,
brushWidth,
offset,
opacity);
if (i == (steps - 1))
{
lastBrushPoint = targetPoint;
}
sourcePoint = targetPoint;
m_pScribbleArea->refreshBitmap(rect, rad);
m_pScribbleArea->paintBitmapBuffer();
}
}
else // hard smudge (liquify)
{
qreal brushStep = 0.5 * ( currentWidth + properties.feather ) / 80.0;
qreal distance = QLineF(b, a).length()/4.0;
brushStep = qMax( 1.0, brushStep * opacity );
//currentWidth = properties.width; // here ?
int steps = qRound(distance / brushStep);
int rad = qRound(brushWidth / 2.0) + 2;
QPointF sourcePoint = lastBrushPoint;
for (int i = 0; i < steps; i++)
{
QPointF targetPoint = lastBrushPoint + (i + 1) * (brushStep) * (b - lastBrushPoint) / distance;
rect.extend(targetPoint.toPoint());
m_pScribbleArea->liquifyBrush( targetImage,
sourcePoint,
targetPoint,
brushWidth,
offset,
opacity);
if (i == (steps - 1))
{
lastBrushPoint = targetPoint;
}
sourcePoint = targetPoint;
m_pScribbleArea->refreshBitmap(rect, rad);
m_pScribbleArea->paintBitmapBuffer();
}
}
}
void SmudgeTool::drawStroke()
{
if ( !mScribbleArea->isLayerPaintable() ) return;
Layer* layer = mEditor->layers()->currentLayer();
if (layer == NULL) { return; }
BitmapImage *targetImage = ((LayerBitmap *)layer)->getLastBitmapImageAtFrame(mEditor->currentFrame(), 0);
StrokeTool::drawStroke();
QList<QPointF> p = m_pStrokeManager->interpolateStroke();
for (int i = 0; i < p.size(); i++)
{
p[ i ] = mEditor->view()->mapScreenToCanvas( p[ i ] );
}
qreal opacity = 1.0;
qreal brushWidth = mCurrentWidth + 0.0 * properties.feather;
qreal offset = qMax(0.0, mCurrentWidth - 0.5 * properties.feather) / brushWidth;
//opacity = currentPressure; // todo: Probably not interesting?!
//brushWidth = brushWidth * opacity;
BlitRect rect;
QPointF a = mLastBrushPoint;
QPointF b = getCurrentPoint();
if (toolMode == 0) // liquify hard (default)
{
qreal brushStep = 2;
qreal distance = QLineF(b, a).length()/2.0;
int steps = qRound(distance / brushStep);
int rad = qRound(brushWidth / 2.0) + 2;
QPointF sourcePoint = mLastBrushPoint;
for (int i = 0; i < steps; i++)
{
QPointF targetPoint = mLastBrushPoint + (i + 1) * (brushStep) * (b - mLastBrushPoint) / distance;
rect.extend(targetPoint.toPoint());
mScribbleArea->liquifyBrush( targetImage,
sourcePoint,
targetPoint,
brushWidth,
offset,
opacity);
if (i == (steps - 1))
{
mLastBrushPoint = targetPoint;
}
sourcePoint = targetPoint;
mScribbleArea->refreshBitmap(rect, rad);
mScribbleArea->paintBitmapBuffer();
}
}
else // liquify smooth
{
qreal brushStep = 2.0;
qreal distance = QLineF(b, a).length();
int steps = qRound(distance / brushStep);
int rad = qRound(brushWidth / 2.0) + 2;
QPointF sourcePoint = mLastBrushPoint;
for (int i = 0; i < steps; i++)
{
QPointF targetPoint = mLastBrushPoint + (i + 1) * (brushStep) * (b - mLastBrushPoint) / distance;
rect.extend(targetPoint.toPoint());
mScribbleArea->blurBrush( targetImage,
sourcePoint,
targetPoint,
brushWidth,
offset,
opacity);
if (i == (steps - 1))
{
mLastBrushPoint = targetPoint;
}
sourcePoint = targetPoint;
mScribbleArea->refreshBitmap(rect, rad);
mScribbleArea->paintBitmapBuffer();
}
}
}
void BrushTool::drawStroke()
{
StrokeTool::drawStroke();
QList<QPointF> p = m_pStrokeManager->interpolateStroke(currentWidth);
Layer *layer = m_pEditor->getCurrentLayer();
if (layer->type == Layer::BITMAP)
{
for (int i = 0; i < p.size(); i++) {
p[i] = m_pScribbleArea->pixelToPoint(p[i]);
}
qreal opacity = 1.0;
qreal brushWidth = currentWidth + 0.5 * properties.feather;
qreal offset = qMax(0.0, currentWidth - 0.5 * properties.feather) / brushWidth;
opacity = currentPressure;
brushWidth = brushWidth * currentPressure;
// if (tabletInUse) { opacity = tabletPressure; }
// if (usePressure) { brushWidth = brushWidth * tabletPressure; }
qreal brushStep = 0.5 * currentWidth + 0.5 * properties.feather;
brushStep = brushStep * currentPressure;
// if (usePressure) { brushStep = brushStep * tabletPressure; }
brushStep = qMax(1.0, brushStep);
currentWidth = properties.width;
BlitRect rect;
QRadialGradient radialGrad(QPointF(0,0), 0.5 * brushWidth);
m_pScribbleArea->setGaussianGradient(radialGrad,
m_pEditor->colorManager()->frontColor(),
opacity,
offset);
QPointF a = lastBrushPoint;
QPointF b = getCurrentPoint();
// foreach (QSegment segment, calculateStroke(brushWidth))
// {
// QPointF a = lastBrushPoint;
// QPointF b = m_pScribbleArea->pixelToPoint(segment.second);
qreal distance = 4 * QLineF(b, a).length();
int steps = qRound(distance) / brushStep;
for (int i = 0; i < steps; i++)
{
QPointF point = lastBrushPoint + (i + 1) * (brushStep) * (b - lastBrushPoint) / distance;
rect.extend(point.toPoint());
m_pScribbleArea->drawBrush( point,
brushWidth,
offset,
m_pEditor->colorManager()->frontColor(),
opacity);
if (i == (steps - 1))
{
lastBrushPoint = point;
}
}
// }
int rad = qRound(brushWidth) / 2 + 2;
m_pScribbleArea->refreshBitmap(rect, rad);
}
else if (layer->type == Layer::VECTOR)
{
QPen pen(Qt::gray, 1, Qt::DashLine, Qt::RoundCap, Qt::RoundJoin);
int rad = qRound((currentWidth / 2 + 2) * qAbs(m_pScribbleArea->getTempViewScaleX()));
// foreach (QSegment segment, calculateStroke(currentWidth))
// {
// QPointF a = segment.first;
// QPointF b = segment.second;
// m_pScribbleArea->drawLine(a, b, pen, QPainter::CompositionMode_SourceOver);
// m_pScribbleArea->refreshVector(QRect(a.toPoint(), b.toPoint()), rad);
// }
if (p.size() == 4) {
QSizeF size(2,2);
QPainterPath path(p[0]);
path.cubicTo(p[1],
p[2],
p[3]);
m_pScribbleArea->drawPath(path, pen, Qt::NoBrush, QPainter::CompositionMode_Source);
m_pScribbleArea->refreshVector(path.boundingRect().toRect(), rad);
}
}
}
void PencilTool::drawStroke()
{
StrokeTool::drawStroke();
QList<QPointF> p = strokeManager()->interpolateStroke();
Layer* layer = mEditor->layers()->currentLayer();
if (layer->type() == Layer::BITMAP)
{
qreal pressure = (properties.pressure) ? mCurrentPressure : 1.0;
qreal opacity = (properties.pressure) ? (mCurrentPressure * 0.5) : 1.0;
qreal brushWidth = properties.width * pressure;
mCurrentWidth = brushWidth;
qreal fixedBrushFeather = properties.feather;
qreal brushStep = qMax(1.0, (0.5 * brushWidth));
BlitRect rect;
QPointF a = mLastBrushPoint;
QPointF b = getCurrentPoint();
qreal distance = 4 * QLineF(b, a).length();
int steps = qRound(distance / brushStep);
for (int i = 0; i < steps; i++)
{
QPointF point = mLastBrushPoint + (i + 1) * brushStep * (getCurrentPoint() - mLastBrushPoint) / distance;
rect.extend(point.toPoint());
mScribbleArea->drawPencil(point,
brushWidth,
fixedBrushFeather,
mEditor->color()->frontColor(),
opacity);
if (i == (steps - 1))
{
mLastBrushPoint = getCurrentPoint();
}
}
int rad = qRound(brushWidth) / 2 + 2;
mScribbleArea->paintBitmapBufferRect(rect);
mScribbleArea->refreshBitmap(rect, rad);
}
else if (layer->type() == Layer::VECTOR)
{
properties.useFeather = false;
mCurrentWidth = 0; // FIXME: WTF?
QPen pen(mEditor->color()->frontColor(),
1,
Qt::DotLine,
Qt::RoundCap,
Qt::RoundJoin);
int rad = qRound((mCurrentWidth / 2 + 2) * mEditor->view()->scaling());
if (p.size() == 4)
{
QPainterPath path(p[0]);
path.cubicTo(p[1],
p[2],
p[3]);
mScribbleArea->drawPath(path, pen, Qt::NoBrush, QPainter::CompositionMode_Source);
mScribbleArea->refreshVector(path.boundingRect().toRect(), rad);
}
}
}
void MoveTool::mouseMoveEvent( QMouseEvent *event )
{
Layer* layer = mEditor->layers()->currentLayer();
if ( layer == NULL ) {
return;
}
if ( layer->type() != Layer::BITMAP && layer->type() != Layer::VECTOR )
{
return;
}
if ( event->buttons() & Qt::LeftButton ) // the user is also pressing the mouse (dragging)
{
if ( mScribbleArea->somethingSelected ) // there is something selected
{
if ( event->modifiers() != Qt::ShiftModifier ) // (and the user doesn't press shift)
{
switch ( mScribbleArea->mMoveMode )
{
case ScribbleArea::MIDDLE:
if ( QLineF( getLastPressPixel(), getCurrentPixel() ).length() > 4 )
{
mScribbleArea->myTempTransformedSelection = mScribbleArea->myTransformedSelection.translated( mScribbleArea->mOffset );
}
break;
case ScribbleArea::TOPRIGHT:
mScribbleArea->myTempTransformedSelection =
mScribbleArea->myTransformedSelection.adjusted( 0, mScribbleArea->mOffset.y(), mScribbleArea->mOffset.x(), 0 );
break;
case ScribbleArea::TOPLEFT:
mScribbleArea->myTempTransformedSelection =
mScribbleArea->myTransformedSelection.adjusted( mScribbleArea->mOffset.x(), mScribbleArea->mOffset.y(), 0, 0 );
break;
// TOPRIGHT XXX
case ScribbleArea::BOTTOMLEFT:
mScribbleArea->myTempTransformedSelection =
mScribbleArea->myTransformedSelection.adjusted( mScribbleArea->mOffset.x(), 0, 0, mScribbleArea->mOffset.y() );
break;
case ScribbleArea::BOTTOMRIGHT:
mScribbleArea->myTempTransformedSelection =
mScribbleArea->myTransformedSelection.adjusted( 0, 0, mScribbleArea->mOffset.x(), mScribbleArea->mOffset.y() );
break;
case ScribbleArea::ROTATION:
mScribbleArea->myTempTransformedSelection =
mScribbleArea->myTransformedSelection; // @ necessary?
mScribbleArea->myRotatedAngle = getCurrentPixel().x() - getLastPressPixel().x();
//qDebug() << "rotation" << m_pScribbleArea->myRotatedAngle;
break;
}
mScribbleArea->calculateSelectionTransformation();
mScribbleArea->update();
mScribbleArea->setAllDirty();
}
}
else // there is nothing selected
{
// we switch to the select tool
mEditor->tools()->setCurrentTool( SELECT );
mScribbleArea->mMoveMode = ScribbleArea::MIDDLE;
mScribbleArea->mySelection.setTopLeft( getLastPoint() );
mScribbleArea->mySelection.setBottomRight( getLastPoint() );
mScribbleArea->setSelection( mScribbleArea->mySelection, true );
}
}
else // the user is moving the mouse without pressing it
{
if ( layer->type() == Layer::VECTOR )
{
auto layerVector = static_cast< LayerVector* >( layer );
VectorImage* pVecImg = layerVector->getLastVectorImageAtFrame( mEditor->currentFrame(), 0 );
mScribbleArea->mClosestCurves = pVecImg->getCurvesCloseTo( getCurrentPoint(), mScribbleArea->tol / mEditor->view()->scaling() );
}
mScribbleArea->update();
}
}
void BrushTool::drawStroke()
{
StrokeTool::drawStroke();
QList<QPointF> p = m_pStrokeManager->interpolateStroke();
Layer* layer = mEditor->layers()->currentLayer();
if ( layer->type() == Layer::BITMAP )
{
for ( int i = 0; i < p.size(); i++ )
{
p[ i ] = mEditor->view()->mapScreenToCanvas( p[ i ] );
}
qreal opacity = 1.0;
qreal brushWidth = mCurrentWidth + 0.5 * properties.feather;
qreal offset = qMax( 0.0, mCurrentWidth - 0.5 * properties.feather ) / brushWidth;
opacity = mCurrentPressure;
brushWidth = brushWidth * mCurrentPressure;
qreal brushStep = 0.5 * mCurrentWidth + 0.5 * properties.feather;
brushStep = brushStep * mCurrentPressure;
// if (usePressure) { brushStep = brushStep * tabletPressure; }
brushStep = qMax( 1.0, brushStep );
mCurrentWidth = properties.width;
BlitRect rect;
QRadialGradient radialGrad( QPointF( 0, 0 ), 0.5 * brushWidth );
mScribbleArea->setGaussianGradient( radialGrad,
mEditor->color()->frontColor(),
opacity,
offset );
QPointF a = lastBrushPoint;
QPointF b = getCurrentPoint();
// foreach (QSegment segment, calculateStroke(brushWidth))
// {
// QPointF a = lastBrushPoint;
// QPointF b = m_pScribbleArea->pixelToPoint(segment.second);
qreal distance = 4 * QLineF( b, a ).length();
int steps = qRound( distance ) / brushStep;
for ( int i = 0; i < steps; i++ )
{
QPointF point = lastBrushPoint + ( i + 1 ) * ( brushStep )* ( b - lastBrushPoint ) / distance;
rect.extend( point.toPoint() );
mScribbleArea->drawBrush( point,
brushWidth,
offset,
mEditor->color()->frontColor(),
opacity );
if ( i == ( steps - 1 ) )
{
lastBrushPoint = point;
}
}
int rad = qRound( brushWidth ) / 2 + 2;
mScribbleArea->refreshBitmap( rect, rad );
}
else if ( layer->type() == Layer::VECTOR )
{
qreal brushWidth = properties.width * mCurrentPressure;
int rad = qRound( ( brushWidth / 2 + 2 ) * mEditor->view()->scaling() );
QPen pen( mEditor->color()->frontColor(),
brushWidth * mEditor->view()->scaling(),
Qt::SolidLine,
Qt::RoundCap,
Qt::RoundJoin );
if ( p.size() == 4 )
{
QPainterPath path( p[ 0 ] );
path.cubicTo( p[ 1 ],
p[ 2 ],
p[ 3 ] );
mScribbleArea->drawPath( path, pen, Qt::NoBrush, QPainter::CompositionMode_Source );
mScribbleArea->refreshVector( path.boundingRect().toRect(), rad );
}
}
}
void BrushTool::drawStroke()
{
StrokeTool::drawStroke();
QList<QPointF> p = m_pStrokeManager->interpolateStroke();
Layer* layer = mEditor->layers()->currentLayer();
if ( layer->type() == Layer::BITMAP )
{
for ( int i = 0; i < p.size(); i++ )
{
p[ i ] = mEditor->view()->mapScreenToCanvas( p[ i ] );
}
qreal opacity = 1.0f;
if (properties.pressure == true)
{
opacity = mCurrentPressure / 2;
}
mCurrentWidth = properties.width;
qreal brushWidth = mCurrentWidth;
qreal brushStep = (0.5 * brushWidth) - ((properties.feather/100.0) * brushWidth * 0.5);
brushStep = qMax( 1.0, brushStep );
BlitRect rect;
QPointF a = mLastBrushPoint;
QPointF b = getCurrentPoint();
qreal distance = 4 * QLineF( b, a ).length();
int steps = qRound( distance ) / brushStep;
for ( int i = 0; i < steps; i++ )
{
QPointF point = mLastBrushPoint + ( i + 1 ) * ( brushStep )* ( b - mLastBrushPoint ) / distance;
rect.extend( point.toPoint() );
mScribbleArea->drawBrush( point,
brushWidth,
properties.feather,
mEditor->color()->frontColor(),
opacity,
properties.useFeather );
if ( i == ( steps - 1 ) )
{
mLastBrushPoint = point;
}
}
int rad = qRound( brushWidth ) / 2 + 2;
mScribbleArea->paintBitmapBufferRect(rect);
mScribbleArea->refreshBitmap( rect, rad );
}
else if ( layer->type() == Layer::VECTOR )
{
qreal brushWidth = properties.width * mCurrentPressure;
int rad = qRound( ( brushWidth / 2 + 2 ) * mEditor->view()->scaling() );
QPen pen( mEditor->color()->frontColor(),
brushWidth * mEditor->view()->scaling(),
Qt::SolidLine,
Qt::RoundCap,
Qt::RoundJoin );
if ( p.size() == 4 )
{
QPainterPath path( p[ 0 ] );
path.cubicTo( p[ 1 ],
p[ 2 ],
p[ 3 ] );
mScribbleArea->drawPath( path, pen, Qt::NoBrush, QPainter::CompositionMode_Source );
mScribbleArea->refreshVector( path.boundingRect().toRect(), rad );
}
}
}
void MoveTool::mouseMoveEvent(QMouseEvent *event)
{
Layer *layer = m_pEditor->getCurrentLayer();
if (layer == NULL) { return; }
if (layer->type == Layer::BITMAP || layer->type == Layer::VECTOR)
{
if (event->buttons() & Qt::LeftButton) // the user is also pressing the mouse (dragging)
{
if (m_pScribbleArea->somethingSelected) // there is something selected
{
if (event->modifiers() != Qt::ShiftModifier) // (and the user doesn't press shift)
{
switch (m_pScribbleArea->m_moveMode)
{
case ScribbleArea::MIDDLE:
if (QLineF(getLastPressPixel(), getCurrentPixel()).length() > 4)
{
m_pScribbleArea->myTempTransformedSelection = m_pScribbleArea->myTransformedSelection.translated(m_pScribbleArea->offset);
}
break;
case ScribbleArea::TOPRIGHT:
m_pScribbleArea->myTempTransformedSelection =
m_pScribbleArea->myTransformedSelection.adjusted(0, m_pScribbleArea->offset.y(), m_pScribbleArea->offset.x(), 0);
break;
case ScribbleArea::TOPLEFT:
m_pScribbleArea->myTempTransformedSelection =
m_pScribbleArea->myTransformedSelection.adjusted(m_pScribbleArea->offset.x(), m_pScribbleArea->offset.y(), 0, 0);
break;
// TOPRIGHT XXX
case ScribbleArea::BOTTOMLEFT:
m_pScribbleArea->myTempTransformedSelection =
m_pScribbleArea->myTransformedSelection.adjusted(m_pScribbleArea->offset.x(), 0, 0, m_pScribbleArea->offset.y());
break;
case ScribbleArea::BOTTOMRIGHT:
m_pScribbleArea->myTempTransformedSelection =
m_pScribbleArea->myTransformedSelection.adjusted(0, 0, m_pScribbleArea->offset.x(), m_pScribbleArea->offset.y());
break;
case ScribbleArea::ROTATION:
m_pScribbleArea->myTempTransformedSelection =
m_pScribbleArea->myTransformedSelection; // @ necessary?
m_pScribbleArea->myRotatedAngle = getCurrentPixel().x() - getLastPressPixel().x();
//qDebug() << "rotation" << m_pScribbleArea->myRotatedAngle;
break;
}
m_pScribbleArea->calculateSelectionTransformation();
m_pScribbleArea->update();
m_pScribbleArea->setAllDirty();
}
}
else // there is nothing selected
{
//selectionTransformation = selectionTransformation.translate(offset.x(), offset.y());
//if (layer->type == Layer::VECTOR) ((LayerVector*)layer)->getLastVectorImageAtFrame(editor->currentFrame, 0)->setSelectionTransformation(selectionTransformation);
//VectorImage* vectorImage = ((LayerVector*)layer)->getLastVectorImageAtFrame(editor->currentFrame, 0);
//setSelection( vectorImage->getSelectionRect() );
// we switch to the select tool
m_pScribbleArea->switchTool(SELECT);
m_pScribbleArea->m_moveMode = ScribbleArea::MIDDLE;
m_pScribbleArea->mySelection.setTopLeft(getLastPoint());
m_pScribbleArea->mySelection.setBottomRight(getLastPoint());
m_pScribbleArea->setSelection(m_pScribbleArea->mySelection, true);
}
}
else // the user is moving the mouse without pressing it
{
if (layer->type == Layer::VECTOR)
{
m_pScribbleArea->closestCurves =
((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0)
->getCurvesCloseTo(getCurrentPoint(), m_pScribbleArea->tol / m_pScribbleArea->getTempViewScaleX());
}
m_pScribbleArea->update();
}
}
}
