/**
* @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());
}
bool Editor::importVectorImage(QString filePath)
{
Q_ASSERT(layers()->currentLayer()->type() == Layer::VECTOR);
auto layer = static_cast<LayerVector*>(layers()->currentLayer());
VectorImage* vectorImage = (static_cast<LayerVector*>(layer))->getVectorImageAtFrame(currentFrame());
if (vectorImage == nullptr)
{
addNewKey();
vectorImage = (static_cast<LayerVector*>(layer))->getVectorImageAtFrame(currentFrame());
}
VectorImage importedVectorImage;
bool ok = importedVectorImage.read(filePath);
if (ok)
{
importedVectorImage.selectAll();
vectorImage->paste(importedVectorImage);
backup(tr("Import Image"));
}
return ok;
}
bool Editor::importVectorImage( QString filePath )
{
Q_ASSERT( layers()->currentLayer()->type() == Layer::VECTOR );
backup( tr( "ImportImg" ) );
auto layer = static_cast<LayerVector*>( layers()->currentLayer() );
VectorImage* vectorImage = ( ( LayerVector* )layer )->getVectorImageAtFrame( currentFrame() );
if ( vectorImage == NULL )
{
addNewKey();
vectorImage = ( ( LayerVector* )layer )->getVectorImageAtFrame( currentFrame() );
}
VectorImage* importedVectorImage = new VectorImage;
bool ok = importedVectorImage->read( filePath );
if ( ok )
{
importedVectorImage->selectAll();
vectorImage->paste( *importedVectorImage );
}
/*
else
{
QMessageBox::warning( mMainWindow,
tr( "Warning" ),
tr( "Unable to load vector image.<br><b>TIP:</b> Use Vector layer to import vectors." ),
QMessageBox::Ok,
QMessageBox::Ok );
}
*/
return ok;
}
void SelectTool::mouseReleaseEvent( QMouseEvent *event )
{
Layer *layer = mEditor->layers()->currentLayer();
if ( layer == NULL ) { return; }
if ( event->button() == Qt::LeftButton )
{
if ( layer->type() == Layer::VECTOR )
{
if ( mScribbleArea->somethingSelected )
{
mEditor->tools()->setCurrentTool( MOVE );
VectorImage *vectorImage = ( ( LayerVector * )layer )->getLastVectorImageAtFrame( mEditor->currentFrame(), 0 );
mScribbleArea->setSelection( vectorImage->getSelectionRect(), true );
if ( mScribbleArea->mySelection.size() == QSizeF( 0, 0 ) )
{
mScribbleArea->somethingSelected = false;
}
}
mScribbleArea->updateCurrentFrame();
mScribbleArea->setAllDirty();
}
else if ( layer->type() == Layer::BITMAP )
{
mScribbleArea->updateCurrentFrame();
mScribbleArea->setAllDirty();
}
}
}
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 Editor::duplicateKey()
{
Layer* layer = mObject->getLayer( layers()->currentLayerIndex() );
if ( layer != NULL )
{
if ( layer->type() == Layer::VECTOR )
{
mScribbleArea->selectAll();
clipboardVectorOk = true;
g_clipboardVectorImage = *( ( ( LayerVector* )layer )->getLastVectorImageAtFrame( currentFrame(), 0 ) ); // copy the image (that works but I should also provide a copy() method)
addNewKey();
VectorImage* vectorImage = ( ( LayerVector* )layer )->getLastVectorImageAtFrame( currentFrame(), 0 );
vectorImage->paste( g_clipboardVectorImage ); // paste the clipboard
mScribbleArea->setModified( layers()->currentLayerIndex(), currentFrame() );
mScribbleArea->update();
}
if ( layer->type() == Layer::BITMAP )
{
mScribbleArea->selectAll();
copy();
addNewKey();
paste();
}
}
}
void SmudgeTool::mouseReleaseEvent(QMouseEvent *event)
{
Layer *layer = m_pEditor->getCurrentLayer();
if (layer == NULL) {
return;
}
if (event->button() == Qt::LeftButton)
{
if (layer->type == Layer::BITMAP)
{
drawStroke();
m_pScribbleArea->paintBitmapBuffer();
m_pScribbleArea->setAllDirty();
endStroke();
}
else if (layer->type == Layer::VECTOR)
{
VectorImage *vectorImage = ((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0);
vectorImage->applySelectionTransformation();
m_pScribbleArea->selectionTransformation.reset();
for (int k = 0; k < m_pScribbleArea->vectorSelection.curve.size(); k++)
{
int curveNumber = m_pScribbleArea->vectorSelection.curve.at(k);
vectorImage->curve[curveNumber].smoothCurve();
}
m_pScribbleArea->setModified(m_pEditor->m_nCurrentLayerIndex, m_pEditor->m_nCurrentFrameIndex);
}
}
}
void EraserTool::mouseReleaseEvent(QMouseEvent *event)
{
Layer *layer = m_pEditor->getCurrentLayer();
if (event->button() == Qt::LeftButton)
{
if (m_pScribbleArea->isLayerPaintable())
{
drawStroke();
}
if (layer->type == Layer::BITMAP)
{
m_pScribbleArea->paintBitmapBuffer();
m_pScribbleArea->setAllDirty();
}
else if (layer->type == Layer::VECTOR)
{
VectorImage *vectorImage = ((LayerVector *)layer)->getLastVectorImageAtFrame(m_pEditor->m_nCurrentFrameIndex, 0);
// Clear the area containing the last point
//vectorImage->removeArea(lastPoint);
// Clear the temporary pixel path
m_pScribbleArea->clearBitmapBuffer();
vectorImage->deleteSelectedPoints();
//update();
m_pScribbleArea->setModified(m_pEditor->m_nCurrentLayerIndex, m_pEditor->m_nCurrentFrameIndex);
m_pScribbleArea->setAllDirty();
}
}
endStroke();
}
QImage* LayerVector::getImageAtIndex( int index,
QSize size,
bool simplified,
bool showThinLines,
qreal curveOpacity,
bool antialiasing)
{
if ( index < 0 || index >= framesImage.size() )
{
return NULL;
}
else
{
VectorImage* vectorImage = getVectorImageAtIndex(index);
QImage* image = framesImage.at(index);
if (vectorImage->isModified() || size != image->size() )
{
if ( image->size() != size)
{
delete image;
framesImage[index] = image = new QImage(size, QImage::Format_ARGB32_Premultiplied);
}
vectorImage->outputImage(image, size, myView,
simplified, showThinLines,
curveOpacity, antialiasing );
vectorImage->setModified(false);
}
return image;
}
}
bool LayerVector::saveKeyFrame( KeyFrame* pKeyFrame, QString path )
{
VectorImage* pVecImage = static_cast< VectorImage* >( pKeyFrame );
QString theFileName = fileName( pKeyFrame->pos() );
QString strFilePath = QDir( path ).filePath( theFileName );
pVecImage->write( strFilePath, "VEC" );
return true;
}
void Editor::paste()
{
if((cutFlag||copyFlag)&&layers()->currentLayerIndex()>2)
{
newBitmapLayer();
}
Layer* layer = mObject->getLayer( layers()->currentLayerIndex() );
if ( layer != NULL )
{
if ( layer->type() == Layer::BITMAP && g_clipboardBitmapImage.image() != NULL )
{
backup( tr( "Paste" ) );
BitmapImage tobePasted = g_clipboardBitmapImage.copy();
qDebug() << "to be pasted --->" << tobePasted.image()->size();
if ( mScribbleArea->somethingSelected )
{
QRectF selection = mScribbleArea->getSelection();
if ( g_clipboardBitmapImage.width() <= selection.width() && g_clipboardBitmapImage.height() <= selection.height() )
{
tobePasted.moveTopLeft( selection.topLeft() );
}
else
{
tobePasted.transform( selection, true );
}
}
auto pLayerBitmap = static_cast< LayerBitmap* >( layer );
pLayerBitmap->getLastBitmapImageAtFrame( currentFrame(), 0 )->paste( &tobePasted ); // paste the clipboard
}
else if ( layer->type() == Layer::VECTOR && clipboardVectorOk )
{
backup( tr( "Paste" ) );
mScribbleArea->deselectAll();
VectorImage* vectorImage = ( ( LayerVector* )layer )->getLastVectorImageAtFrame( currentFrame(), 0 );
vectorImage->paste( g_clipboardVectorImage ); // paste the clipboard
mScribbleArea->setSelection( vectorImage->getSelectionRect(), true );
//((LayerVector*)layer)->getLastVectorImageAtFrame(backupFrame, 0)->modification(); ????
}
}
mScribbleArea->updateCurrentFrame();
if((cutFlag&&!mScribbleArea->somethingSelected)||(copyFlag&&mScribbleArea->somethingSelected))
{
mScribbleArea->mySelection=cutArea;
mScribbleArea->setSelection( mScribbleArea->mySelection, true );
mScribbleArea->myTransformedSelection = mScribbleArea->mySelection.adjusted( 0, 0, 0, 0 );
mScribbleArea->myTempTransformedSelection = mScribbleArea->mySelection.adjusted( 0, 0, 0, 0 );
mScribbleArea->update();
mScribbleArea->mIncludeImg[mLayerManager->currentLayerIndex()]=mScribbleArea->mySelection;
tools()->setCurrentTool(MOVE);
}
cutFlag =0;
copyFlag =0;
}
void LayerVector::loadImageAtFrame(QString path, int frameNumber)
{
if ( keyExists( frameNumber ) )
{
removeKeyFrame( frameNumber, false );
}
VectorImage* vecImg = new VectorImage;
vecImg->setPos( frameNumber );
vecImg->setObject( object() );
vecImg->read( path );
addKeyFrame( frameNumber, vecImg );
}
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 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();
}
}
}
}
bool Editor::importVectorImage( QString filePath )
{
Q_ASSERT( layers()->currentLayer()->type() == Layer::VECTOR );
backup( tr( "ImportImg" ) );
auto layer = static_cast<LayerVector*>( layers()->currentLayer() );
VectorImage* vectorImage = ( ( LayerVector* )layer )->getVectorImageAtFrame( currentFrame() );
if ( vectorImage == NULL )
{
addNewKey();
vectorImage = ( ( LayerVector* )layer )->getVectorImageAtFrame( currentFrame() );
}
// 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( mScribbleArea->usePressure() );
// curve.setColourNumber( mEditor->color()->frontColorNumber() );
// auto pLayerVector = static_cast< LayerVector* >( layer );
// VectorImage* vectorImage = pLayerVector->getLastVectorImageAtFrame( mEditor->currentFrame(), 0 );
// vectorImage->addCurve( curve, mEditor->view()->scaling() );
// mScribbleArea->setModified( mEditor->layers()->currentLayerIndex(), mEditor->currentFrame() );
// mScribbleArea->setAllDirty();
VectorImage* importedVectorImage = new VectorImage;
bool ok = importedVectorImage->read( filePath );
if ( ok )
{
importedVectorImage->selectAll();
vectorImage->paste( *importedVectorImage );
}
/*
else
{
QMessageBox::warning( mMainWindow,
tr( "Warning" ),
tr( "Unable to load vector image.<br><b>TIP:</b> Use Vector layer to import vectors." ),
QMessageBox::Ok,
QMessageBox::Ok );
}
*/
return ok;
}
/**
* @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();
}
Status Editor::setObject(Object* newObject)
{
if (newObject == nullptr)
{
Q_ASSERT(false);
return Status::INVALID_ARGUMENT;
}
if (newObject == mObject.get())
{
return Status::SAFE;
}
clearUndoStack();
mObject.reset(newObject);
for (BaseManager* m : mAllManagers)
{
m->load(mObject.get());
}
g_clipboardVectorImage.setObject(newObject);
updateObject();
if (mViewManager)
{
connect(newObject, &Object::layerViewChanged, mViewManager, &ViewManager::viewChanged);
}
emit objectLoaded();
return Status::OK;
}
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 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 Editor::setObject( Object* newObject )
{
if ( newObject == NULL ) { return; }
if ( newObject == mObject.get() ) { return; }
mObject.reset( newObject );
//qDebug( "New object loaded." );
// the default selected layer is the last one
layers()->setCurrentLayer( mObject->getLayerCount() - 1 );
g_clipboardVectorImage.setObject( newObject );
}
void Editor::paste()
{
Layer* layer = mObject->getLayer( layers()->currentLayerIndex() );
if ( layer != NULL )
{
if ( layer->type() == Layer::BITMAP && g_clipboardBitmapImage.image() != NULL )
{
backup( tr( "Paste" ) );
BitmapImage tobePasted = g_clipboardBitmapImage.copy();
qDebug() << "to be pasted --->" << tobePasted.image()->size();
if ( mScribbleArea->somethingSelected )
{
QRectF selection = mScribbleArea->getSelection();
if ( g_clipboardBitmapImage.width() <= selection.width() && g_clipboardBitmapImage.height() <= selection.height() )
{
tobePasted.moveTopLeft( selection.topLeft() );
}
else
{
tobePasted.transform( selection, true );
}
}
auto pLayerBitmap = static_cast< LayerBitmap* >( layer );
pLayerBitmap->getLastBitmapImageAtFrame( currentFrame(), 0 )->paste( &tobePasted ); // paste the clipboard
}
else if ( layer->type() == Layer::VECTOR && clipboardVectorOk )
{
backup( tr( "Paste" ) );
mScribbleArea->deselectAll();
VectorImage* vectorImage = ( ( LayerVector* )layer )->getLastVectorImageAtFrame( currentFrame(), 0 );
vectorImage->paste( g_clipboardVectorImage ); // paste the clipboard
mScribbleArea->setSelection( vectorImage->getSelectionRect(), true );
//((LayerVector*)layer)->getLastVectorImageAtFrame(backupFrame, 0)->modification(); ????
}
}
mScribbleArea->updateCurrentFrame();
}
void PencilTool::paintVectorStroke(Layer* layer)
{
if (mStrokePoints.empty())
return;
// Clear the temporary pixel path
mScribbleArea->clearBitmapBuffer();
qreal tol = mScribbleArea->getCurveSmoothing() / mEditor->view()->scaling();
BezierCurve curve(mStrokePoints, mStrokePressures, tol);
curve.setWidth(0);
curve.setFeather(0);
curve.setFilled(false);
curve.setInvisibility(true);
curve.setVariableWidth(false);
curve.setColourNumber(mEditor->color()->frontColorNumber());
VectorImage* vectorImage = ((LayerVector *)layer)->getLastVectorImageAtFrame(mEditor->currentFrame(), 0);
vectorImage->addCurve(curve, qAbs(mEditor->view()->scaling()), properties.vectorMergeEnabled);
if (properties.useFillContour)
{
vectorImage->fillContour(mStrokePoints,
mEditor->color()->frontColorNumber());
}
if (vectorImage->isAnyCurveSelected() || mScribbleArea->isSomethingSelected())
{
mScribbleArea->deselectAll();
}
// select last/newest curve
vectorImage->setSelected(vectorImage->getLastCurveNumber(), true);
// TODO: selection doesn't apply on enter
mScribbleArea->setModified(mEditor->layers()->currentLayerIndex(), mEditor->currentFrame());
mScribbleArea->setAllDirty();
}
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 CanvasRenderer::paintVectorFrame( QPainter& painter,
int layerId,
int nFrame,
bool colorize,
bool useLastKeyFrame )
{
Layer* layer = mObject->getLayer( layerId );
if ( !layer->visible() )
{
return;
}
LayerVector* vectorLayer = dynamic_cast< LayerVector* >( layer );
if ( vectorLayer == nullptr )
{
Q_ASSERT( vectorLayer );
return;
}
qCDebug( mLog ) << "Paint Onion skin vector, Frame = " << nFrame;
VectorImage* vectorImage;
if (useLastKeyFrame)
{
vectorImage = vectorLayer->getLastVectorImageAtFrame( nFrame, 0 );
}
else
{
vectorImage = vectorLayer->getVectorImageAtFrame( nFrame );
}
if ( vectorImage == nullptr )
{
return;
}
QImage* pImage = new QImage( mCanvas->size(), QImage::Format_ARGB32_Premultiplied );
vectorImage->outputImage( pImage, mViewTransform, mOptions.bOutlines, mOptions.bThinLines, mOptions.bAntiAlias );
//painter.drawImage( QPoint( 0, 0 ), *pImage );
// Go through a Bitmap image to paint the onion skin colour
//
BitmapImage* tempBitmapImage = new BitmapImage();
tempBitmapImage->setImage(pImage);
if ( colorize )
{
QBrush colorBrush = QBrush(Qt::transparent); //no color for the current frame
if (nFrame < mFrameNumber)
{
colorBrush = QBrush(Qt::red);
}
else if (nFrame > mFrameNumber)
{
colorBrush = QBrush(Qt::blue);
}
tempBitmapImage->drawRect( pImage->rect(),
Qt::NoPen,
colorBrush,
QPainter::CompositionMode_SourceIn,
false);
}
painter.setWorldMatrixEnabled( false ); //Don't tranform the image here as we used the viewTransform in the image output
tempBitmapImage->paintImage( painter );
delete tempBitmapImage;
}
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();
}
}
