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 KisToolPolylineBase::beginPrimaryDoubleClickAction(KoPointerEvent *event)
{
endStroke();
// this action will have no continuation
event->ignore();
}
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();
}
void KisToolPolylineBase::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
{
if (action != ChangeSize || !m_dragging) {
KisToolPaint::beginAlternateAction(event, action);
}
if (m_closeSnappingActivated) {
m_points.append(m_points.first());
}
endStroke();
}
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 KisScratchPad::slotMouseRelease(KoPointerEvent *event)
{
if (m_toolMode == PAINTING) {
endStroke(event);
m_toolMode = HOVERING;
event->accept();
}
else if (m_toolMode == PANNING) {
endPan(event);
m_toolMode = HOVERING;
event->accept();
}
else if (m_toolMode == PICKING) {
event->accept();
m_toolMode = HOVERING;
}
}
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 KisToolPolylineBase::beginPrimaryAction(KoPointerEvent *event)
{
Q_UNUSED(event);
if ((m_type == PAINT && (!nodeEditable() || nodePaintAbility() == NONE)) ||
(m_type == SELECT && !selectionEditable())) {
event->ignore();
return;
}
setMode(KisTool::PAINT_MODE);
if(m_dragging && m_closeSnappingActivated) {
m_points.append(m_points.first());
endStroke();
} else {
m_dragging = true;
}
}
void BrushTool::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)
{
}
}
endStroke();
}
void
CGnuPlotStyleBoxErrorBars::
draw2D(CGnuPlotPlot *plot, CGnuPlotRenderer *renderer)
{
CGnuPlotBoxErrorBarsStyleValue *value =
CGnuPlotStyleValueMgrInst->getValue<CGnuPlotBoxErrorBarsStyleValue>(plot);
if (! value) {
value = plot->app()->device()->createBoxErrorBarsStyleValue(plot);
value->init();
CGnuPlotStyleValueMgrInst->setValue<CGnuPlotBoxErrorBarsStyleValue>(plot, value);
}
//---
const CGnuPlotLineStyle &lineStyle = plot->lineStyle();
CGnuPlotFill fill (plot);
CGnuPlotStroke stroke(plot);
bool isCalcColor = lineStyle.isCalcColor();
CBBox2D bbox = plot->bbox2D();
double ymin = bbox.getYMin();
double y2 = std::max(0.0, ymin);
double bw = value->getSpacing();
//---
if (! renderer->isPseudo())
plot->updateBoxBarCacheSize(plot->getPoints2D().size());
//---
int i = 0;
for (const auto &point : plot->getPoints2D()) {
std::vector<double> reals;
(void) point.getReals(reals);
COptReal colorVal;
if (isCalcColor && ! reals.empty()) {
colorVal = reals.back();
reals.pop_back();
}
while (reals.size() < 3)
reals.push_back(0.0);
double x = reals[0];
double y = reals[1];
double dx = bw;
double dy = 0.0;
double yl = y;
double yh = y;
// x y ydelta
if (reals.size() == 3) {
dy = reals[2];
yl = y - dy;
yh = y + dy;
}
else if (reals.size() == 4) {
// x y ydelta xdelta
if (! value->isAutoWidth()) {
dx = reals[2];
dy = reals[3];
yl = y - dy;
yh = y + dy;
}
// x y ylow yhigh
else {
yl = reals[2];
yh = reals[3];
}
}
// x y ylow yhigh xdelta
else if (reals.size() >= 5) {
yl = reals[2];
yh = reals[3];
dx = reals[4];
}
//---
COptRGBA lc;
if (colorVal.isValid()) {
if (renderer->isPseudo())
renderer->setCBValue(colorVal.getValue());
else
lc = lineStyle.calcColor(plot, colorVal.getValue());
}
//---
CBBox2D bbox(x - dx/2, y2, x + dx/2, y);
CPoint2D p1(x, yl);
CPoint2D p2(x, yh);
if (! renderer->isPseudo()) {
CGnuPlotBoxBarObject *bar = plot->boxBarObjects()[i];
bar->setBBox(bbox);
bar->setValues(x, y);
bar->setVertical(true);
if (! bar->testAndSetUsed()) {
CGnuPlotFillP fill (bar->fill ()->dup());
CGnuPlotStrokeP stroke(bar->stroke()->dup());
bar->setFill (fill );
bar->setStroke(stroke);
//---
bar->clearEndBars();
CGnuPlotEndBarP endBar = bar->addEndBar(p1, p2);
endBar->setStartLine(true);
endBar->setEndLine (true);
endBar->setEndWidth (dx/2);
CGnuPlotStrokeP endStroke(bar->stroke()->dup());
endBar->setStroke(endStroke);
}
}
else {
CGnuPlotStroke stroke;
stroke.setEnabled(true);
renderer->strokeRect(bbox, stroke);
renderer->strokeClipLine(p1, p2, stroke);
double w = dx/2;
renderer->strokeClipLine(p1 - CPoint2D(w/2, 0), p1 + CPoint2D(w/2, 0), stroke);
renderer->strokeClipLine(p2 - CPoint2D(w/2, 0), p2 + CPoint2D(w/2, 0), stroke);
}
++i;
}
if (! renderer->isPseudo()) {
for (const auto &bar : plot->boxBarObjects())
bar->draw(renderer);
}
}
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 KisToolPolylineBase::requestStrokeEnd()
{
endStroke();
}
void Stroker::generateStrokeOutlines(SubPath* subPath,
const AffineMatrix& transform)
{
if(subPath->getNumberOfPoints() == 0)
return;
// Iterate over all segments in subpath
Segment* segment = subPath->beginSegmentIteration();
const Path::Segment* pathSegment = segment->getSegment();
// Clear state varibles and helper paths for this subpath
numSegments_ = 0;
innerPoints_.clear();
outerPoints_.clear();
// Store transform
pathTransform_ = transform;
inversePathTransform_ = transform;
inversePathTransform_.invert();
float xScale;
float yScale;
pathTransform_.getScale(xScale,yScale);
scale_.makeIdentity();
scale_.scale(xScale,yScale);
inverseScale_ = scale_;
inverseScale_.invert();
// Handle the case where we start with
// a move to separetely for now
if(pathSegment->command_ == Path::cMoveToAbs ||
pathSegment->command_ == Path::cMoveToRel)
{
updateCurrentPoint(pathSegment);
firstPoint_ = prevPoint_ = currentPoint_;
segment = subPath->getNextSegment();
pathSegment = segment->getSegment();
}
// Iterate over sub path and handle all segments
const Path::Segment* lastSegment = pathSegment;
while(subPath->hasMoreSegments())
{
if(pathSegment->command_ < Path::cQuadBezierToAbs)
handleLineSegment(segment);
else if(pathSegment->command_ > Path::cSmoothCubicBezierToRel)
handleArcSegment(segment);
else
handleBezierSegment(segment);
++numSegments_;
segment = subPath->getNextSegment();
lastSegment = pathSegment;
pathSegment = segment->getSegment();
}
// Join or add ends
if(lastSegment->command_ == Path::cClosePath)
joiner_(this,firstPoint_,prevNormal_,firstNormal_);
else
endStroke();
}
