void EyedropperTool::mouseReleaseEvent(QMouseEvent *event)
{
Layer* layer = mEditor->layers()->currentLayer();
if (layer == NULL) { return; }
if (event->button() == Qt::LeftButton)
{
if (layer->type() == Layer::BITMAP)
{
BitmapImage* targetImage = ((LayerBitmap *)layer)->getLastBitmapImageAtFrame( mEditor->currentFrame(), 0);
//QColor pickedColour = targetImage->pixel(getLastPoint().x(), getLastPoint().y());
QColor pickedColour;
pickedColour.setRgba( targetImage->pixel( getLastPoint().x(), getLastPoint().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)
{
mEditor->color()->setColor(pickedColour);
}
}
else if (layer->type() == Layer::VECTOR)
{
VectorImage *vectorImage = ((LayerVector *)layer)->getLastVectorImageAtFrame(mEditor->currentFrame(), 0);
int colourNumber = vectorImage->getColourNumber(getLastPoint());
if (colourNumber != -1)
{
mEditor->color()->setColorNumber(colourNumber);
}
}
}
}
void BucketTool::mouseReleaseEvent(QMouseEvent *event)
{
Layer *layer = m_pEditor->getCurrentLayer();
if (layer == NULL) { return; }
if (event->button() == Qt::LeftButton)
{
if (layer->type == Layer::BITMAP)
{
BitmapImage *sourceImage = ((LayerBitmap *)layer)->getLastBitmapImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0);
Layer *targetLayer = layer; // by default
int layerNumber = m_pEditor->m_nCurrentLayerIndex; // by default
if (m_pEditor->m_nCurrentLayerIndex > 0)
{
Layer *layer2 = m_pEditor->getCurrentLayer(-1);
if (layer2->type == Layer::BITMAP)
{
targetLayer = layer2;
layerNumber = layerNumber - 1;
}
}
BitmapImage *targetImage = ((LayerBitmap *)targetLayer)->getLastBitmapImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0);
BitmapImage::floodFill(sourceImage,
targetImage,
getLastPoint().toPoint(),
qRgba(0, 0, 0, 0),
m_pEditor->colorManager()->frontColor().rgba(),
10 * 10,
true);
m_pScribbleArea->setModified(layerNumber, m_pEditor->m_nCurrentFrameIndex);
m_pScribbleArea->setAllDirty();
}
else if (layer->type == Layer::VECTOR)
{
VectorImage *vectorImage = ((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0);
if (event->modifiers() == Qt::AltModifier)
{
vectorImage->removeArea(getLastPoint());
}
else
{
m_pScribbleArea->floodFill(vectorImage, getLastPixel().toPoint(), qRgba(0, 0, 0, 0), qRgb(200, 200, 200), 100 * 100);
}
m_pScribbleArea->setModified(m_pEditor->m_nCurrentLayerIndex, m_pEditor->m_nCurrentFrameIndex);
m_pScribbleArea->setAllDirty();
}
}
}
void markPoint(){
if(!followPoints){
getLastPoint();
if(!isOnRadius(x, y, lastPointX, lastPointY, 100)){
addPoint(x,y);
}
}
}
void MoveTool::setAreaSelected(VectorImage* vectorImage, Qt::KeyboardModifiers keyMod)
{
int areaNumber = vectorImage->getLastAreaNumber(getLastPoint());
if (!vectorImage->isAreaSelected(areaNumber))
{
if (keyMod != Qt::ShiftModifier)
{
applyTransformation();
}
vectorImage->setAreaSelected(areaNumber, true);
mScribbleArea->setSelection(vectorImage->getSelectionRect());
}
}
/**
* @brief MoveTool::createVectorSelection
* In vector the selection rectangle is based on the bounding box of the curves
* We can therefore create a selection just by clicking near/on a curve
*/
void MoveTool::createVectorSelection(Qt::KeyboardModifiers keyMod, Layer* layer)
{
assert(layer->type() == Layer::VECTOR);
LayerVector* vecLayer = static_cast<LayerVector*>(layer);
VectorImage* vectorImage = vecLayer->getLastVectorImageAtFrame(mEditor->currentFrame(), 0);
if (!mScribbleArea->mClosestCurves.empty()) // the user clicks near a curve
{
setCurveSelected(vectorImage, keyMod);
}
else if (vectorImage->getLastAreaNumber(getLastPoint()) > -1)
{
setAreaSelected(vectorImage, keyMod);
}
mScribbleArea->update();
}
void SelectTool::mousePressEvent( QMouseEvent *event )
{
Layer *layer = mEditor->layers()->currentLayer();
if ( layer == NULL ) { return; }
mScribbleArea->myFlipX = 1.0;
mScribbleArea->myFlipY = 1.0;
mScribbleArea->myRotatedAngle = 0;
if ( event->button() == Qt::LeftButton )
{
if ( layer->type() == Layer::BITMAP || layer->type() == Layer::VECTOR )
{
if ( layer->type() == Layer::VECTOR )
{
( ( LayerVector * )layer )->getLastVectorImageAtFrame( mEditor->currentFrame(), 0 )->deselectAll();
}
mScribbleArea->setMoveMode( ScribbleArea::MIDDLE );
mEditor->backup( typeName() );
if ( mScribbleArea->somethingSelected ) // there is something selected
{
if ( BezierCurve::mLength( getLastPoint() - mScribbleArea->myTransformedSelection.topLeft() ) < 6 )
{
mScribbleArea->setMoveMode( ScribbleArea::TOPLEFT );
}
if ( BezierCurve::mLength( getLastPoint() - mScribbleArea->myTransformedSelection.topRight() ) < 6 )
{
mScribbleArea->setMoveMode( ScribbleArea::TOPRIGHT );
}
if ( BezierCurve::mLength( getLastPoint() - mScribbleArea->myTransformedSelection.bottomLeft() ) < 6 )
{
mScribbleArea->setMoveMode( ScribbleArea::BOTTOMLEFT );
}
if ( BezierCurve::mLength( getLastPoint() - mScribbleArea->myTransformedSelection.bottomRight() ) < 6 )
{
mScribbleArea->setMoveMode( ScribbleArea::BOTTOMRIGHT );
}
if ( mScribbleArea->getMoveMode() == ScribbleArea::MIDDLE )
{
mScribbleArea->paintTransformedSelection();
mScribbleArea->deselectAll();
} // the user did not click on one of the corners
}
else // there is nothing selected
{
mScribbleArea->mySelection.setTopLeft( getLastPoint() );
mScribbleArea->mySelection.setBottomRight( getLastPoint() );
mScribbleArea->setSelection( mScribbleArea->mySelection, true );
}
mScribbleArea->update();
}
}
}
int removePoint(){
printf("Removed point %d %d!\n", pointsList[0][pointsListPointer-1], pointsList[1][pointsListPointer-1]);
pointsListPointer--;
if(pointsListPointer==0){
if(radiusConst!=200){ // if point 0,0 was found with radius 150, end!
return 1;
}
else // if point 0,0 was found with radius 300, switch to radius 100
{
pointsListPointer++;
radiusConst=151;
}
}
//newPointMark();
atBeacon();
getLastPoint();
return 0;
}
void servoControl(){
//printf("BeaconVisible=%d beaconDir=%d left=%d right=%d ServoPos=%d\n", beaconVisible, beaconDir, left, right, currServoPos);
//led(3,visible);
if(followPoints){
//printf("FOLLOW POINT\n");
getLastPoint();
targetX=lastPointX;
targetY=lastPointY;
if( checkPointsRadius() ){
if(removePoint()){
// update point
printf("Found home!\n");
setVel2(0,0);
while (!startButton());
}
}
//double myNorm, targetNorm;
double meToTargetVector [2];
double myDirectionVector [2];
double myX=x, myY=y, myDir=t; // 0.35 radians
meToTargetVector[0]=(targetX-myX);
meToTargetVector[1]=(targetY-myY);
myDirectionVector[0]=cos(myDir);
myDirectionVector[1]=sin(myDir);
double radianBeaconDir = atan2(meToTargetVector[1], meToTargetVector[0]) - atan2(myDirectionVector[1], myDirectionVector[0]);
beaconDir=-normalizeAngle(radianBeaconDir)*(180 / PI);
int servoPos = beaconDir/6;
printf("My position %2.1f,%2.1f; Target Position %d,%d; MyAngle %2.0f AngleToNextPoint %d\n",
myX, myY, targetX, targetY, (myDir*180/PI), beaconDir); //NEGATIVO PRA ESQUERDA
if(servoPos > POS_RIGHT)
setServoPos(POS_RIGHT);
else if( servoPos < POS_LEFT )
setServoPos(POS_LEFT);
else
setServoPos(servoPos);
}else{
bVis=readBeaconSens();
if(bVis && !oldBVis){ // Started seeing beacon!
if(rotate_right){
left = currServoPos;
//if(left<0 && right>=POS_RIGHT)
// right=left+15;
}
else {
right = currServoPos;
//if(right>0 && left<=POS_LEFT)
// left=right-15;
}
if(currServoPos==POS_RIGHT || currServoPos==POS_LEFT){ // Got to the end of the line
rotate_right=!rotate_right;
}
}
else if(!bVis && oldBVis){ // Stopped seeing beacon!
if(rotate_right){ right = currServoPos-1; }
else { left = currServoPos+1; }
rotate_right=!rotate_right;
} else if(currServoPos==POS_RIGHT || currServoPos==POS_LEFT){ // Got to the end of the line
if(currServoPos==POS_RIGHT){ right = POS_RIGHT+1; }
else { left = POS_LEFT-1; }
rotate_right=!rotate_right;
}
visible = bVis||oldBVis||oldBVis2;
//led(2, visible);
oldBVis2=oldBVis;
oldBVis=bVis;
beaconDir = (left + right)/2*6;
//printf("Beacon at %d\n",beaconDir);
modder = rotate_right ? 1 : -1;
//currServoPos+=modder;
currServoPos = visible ? currServoPos+modder*1 : currServoPos+modder*2;
if(currServoPos>POS_RIGHT){ currServoPos=POS_RIGHT; }
else if(currServoPos<POS_LEFT){ currServoPos=POS_LEFT; }
setServoPos(currServoPos);
}
}
void MoveTool::mousePressEvent( QMouseEvent *event )
{
Layer *layer = mEditor->layers()->currentLayer();
if ( layer == NULL ) {
return;
}
if ( event->button() == Qt::LeftButton )
{
// ----------------------------------------------------------------------
if ( (layer->type() == Layer::BITMAP || layer->type() == Layer::VECTOR) )
{
mEditor->backup( tr( "Move" ) );
mScribbleArea->setMoveMode( ScribbleArea::MIDDLE );
if ( mScribbleArea->somethingSelected ) // there is an area selection
{
if ( BezierCurve::mLength( getLastPoint() - mScribbleArea->myTransformedSelection.topLeft() ) < 6 )
{
mScribbleArea->setMoveMode( ScribbleArea::TOPLEFT );
}
if ( BezierCurve::mLength( getLastPoint() - mScribbleArea->myTransformedSelection.topRight() ) < 6 )
{
mScribbleArea->setMoveMode( ScribbleArea::TOPRIGHT );
}
if ( BezierCurve::mLength( getLastPoint() - mScribbleArea->myTransformedSelection.bottomLeft() ) < 6 )
{
mScribbleArea->setMoveMode( ScribbleArea::BOTTOMLEFT );
}
if ( BezierCurve::mLength( getLastPoint() - mScribbleArea->myTransformedSelection.bottomRight() ) < 6 )
{
mScribbleArea->setMoveMode( ScribbleArea::BOTTOMRIGHT );
}
}
if ( mScribbleArea->getMoveMode() == ScribbleArea::MIDDLE )
{
if ( layer->type() == Layer::BITMAP )
{
if ( !(mScribbleArea->myTransformedSelection.contains( getLastPoint() )) ) // click is outside the transformed selection with the MOVE tool
{
mScribbleArea->paintTransformedSelection();
mScribbleArea->deselectAll();
}
else if ( event->modifiers() == Qt::ControlModifier ) // --- rotation
{
mScribbleArea->setMoveMode( ScribbleArea::ROTATION );
//qDebug() << "ROTATION";
}
else if (event->modifiers() == Qt::AltModifier ) // --- symmetry
{
mScribbleArea->setMoveMode(ScribbleArea::SYMMETRY );
//qDebug() << "SYMMETRY";
}
}
else if ( layer->type() == Layer::VECTOR )
{
VectorImage *vectorImage = ((LayerVector *)layer)->getLastVectorImageAtFrame( mEditor->currentFrame(), 0 );
if ( mScribbleArea->mClosestCurves.size() > 0 ) // the user clicks near a curve
{
// editor->backup();
if ( !vectorImage->isSelected( mScribbleArea->mClosestCurves ) )
{
mScribbleArea->paintTransformedSelection();
if ( event->modifiers() != Qt::ShiftModifier )
{
mScribbleArea->deselectAll();
}
vectorImage->setSelected( mScribbleArea->mClosestCurves, true );
mScribbleArea->setSelection( vectorImage->getSelectionRect(), true );
mScribbleArea->update();
}
}
else
{
int areaNumber = vectorImage->getLastAreaNumber( getLastPoint() );
if ( areaNumber != -1 ) // the user clicks on an area
{
if ( !vectorImage->isAreaSelected( areaNumber ) )
{
if ( event->modifiers() != Qt::ShiftModifier )
{
mScribbleArea->deselectAll();
}
vectorImage->setAreaSelected( areaNumber, true );
//setSelection( vectorImage->getSelectionRect() );
mScribbleArea->setSelection( QRectF( 0, 0, 0, 0 ), true );
mScribbleArea->update();
}
}
else // the user doesn't click near a curve or an area
{
if ( !(mScribbleArea->myTransformedSelection.contains( getLastPoint() )) ) // click is outside the transformed selection with the MOVE tool
{
mScribbleArea->paintTransformedSelection();
mScribbleArea->deselectAll();
}
}
}
}
}
}
}
}
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 MoveTool::setAnchorToLastPoint()
{
anchorOriginPoint = getLastPoint();
}
void BucketTool::mouseReleaseEvent( QMouseEvent *event )
{
Layer* layer = mEditor->layers()->currentLayer();
if ( layer == NULL ) { return; }
if ( event->button() == Qt::LeftButton )
{
if ( layer->type() == Layer::BITMAP )
{
BitmapImage *sourceImage = ( ( LayerBitmap * )layer )->getLastBitmapImageAtFrame( mEditor->currentFrame(), 0 );
Layer *targetLayer = layer; // by default
int layerNumber = mEditor->layers()->currentLayerIndex(); // by default
if ( mEditor->layers()->currentLayerIndex() > 0 )
{
Layer *layer2 = mEditor->layers()->currentLayer( -1 );
if ( layer2->type() == Layer::BITMAP )
{
targetLayer = layer2;
layerNumber = layerNumber - 1;
}
}
BitmapImage *targetImage = ( ( LayerBitmap * )targetLayer )->getLastBitmapImageAtFrame( mEditor->currentFrame(), 0 );
BitmapImage::floodFill( sourceImage,
targetImage,
getLastPoint().toPoint(),
qRgba( 0, 0, 0, 0 ),
mEditor->color()->frontColor().rgba(),
10 * 10,
true );
mScribbleArea->setModified( layerNumber, mEditor->currentFrame() );
mScribbleArea->setAllDirty();
}
else if ( layer->type() == Layer::VECTOR )
{
mScribbleArea->clearBitmapBuffer();
VectorImage *vectorImage = ( ( LayerVector * )layer )->getLastVectorImageAtFrame( mEditor->currentFrame(), 0 );
if ( event->modifiers() == Qt::AltModifier )
{
vectorImage->removeArea( getLastPoint() );
}
else
{
QList<QPointF> path = mStrokePoints;
if (path.size() < 10) {
vectorImage->fill( getLastPoint(),
mEditor->color()->frontColorNumber(),
3.0 / mEditor->view()->scaling() );
}
else {
vectorImage->fill( path,
mEditor->color()->frontColorNumber(),
10.0 / mEditor->view()->scaling() );
}
}
mScribbleArea->setModified( mEditor->layers()->currentLayerIndex(), mEditor->currentFrame() );
mScribbleArea->setAllDirty();
}
}
endStroke();
}
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();
}
}
}
