void KisStroke::cancelStroke()
{
// case 6
if (m_isCancelled) return;
if(!m_strokeInitialized) {
/**
* FIXME: this assert is probably a bit too optimistic,
* because the LODN stroke that suspends the other one
* can be easily non-initialized
*/
KIS_ASSERT_RECOVER_NOOP(sanityCheckAllJobsAreCancellable());
clearQueueOnCancel();
}
else if(m_strokeInitialized &&
(!m_jobsQueue.isEmpty() || !m_strokeEnded)) {
clearQueueOnCancel();
enqueue(m_cancelStrategy.data(),
m_strokeStrategy->createCancelData());
}
// else {
// too late ...
// }
m_isCancelled = true;
m_strokeEnded = true;
}
/**
* name - "h", "s" or "v"
* (h)ue in range <-1.0, 1.0> ( for user, show as -180, 180 or 0, 360 for colorize)
* (s)aturation in range <-1.0, 1.0> ( for user, show -100, 100, or 0, 100 for colorize)
* (v)alue in range <-1.0, 1.0> (for user, show -100, 100)
* type: 0:HSV, 1:HSL, 2:HSI, 3:HSY, 4:YUV
* m_colorize: Use colorize formula instead
* luma Red/Green/Blue: Used for luma calculations.
*/
virtual void setParameter(int id, const QVariant& parameter)
{
switch(id)
{
case 0:
m_adj_h = parameter.toDouble();
break;
case 1:
m_adj_s = parameter.toDouble();
break;
case 2:
m_adj_v = parameter.toDouble();
break;
case 3:
m_type = parameter.toDouble();
break;
case 4:
m_colorize = parameter.toBool();
break;
case 5:
m_lumaRed = parameter.toDouble();
break;
case 6:
m_lumaGreen = parameter.toDouble();
break;
case 7:
m_lumaBlue = parameter.toDouble();
break;
default:
KIS_ASSERT_RECOVER_NOOP(false && "Unknown parameter ID. Ignored!");
;
}
}
void KisFreeTransformStrategy::Private::recalculateTransformations()
{
KisTransformUtils::MatricesPack m(currentArgs);
QTransform sanityCheckMatrix = m.TS * m.SC * m.S * m.projectedP;
/**
* The center of the original image should still
* stay the origin of CS
*/
KIS_ASSERT_RECOVER_NOOP(sanityCheckMatrix.map(currentArgs.originalCenter()).manhattanLength() < 1e-4);
transform = m.finalTransform();
QTransform viewScaleTransform = converter->imageToDocumentTransform() * converter->documentToFlakeTransform();
handlesTransform = transform * viewScaleTransform;
QTransform tl = QTransform::fromTranslate(transaction.originalTopLeft().x(), transaction.originalTopLeft().y());
paintingTransform = tl.inverted() * q->thumbToImageTransform() * tl * transform * viewScaleTransform;
paintingOffset = transaction.originalTopLeft();
// check whether image is too big to be displayed or not
imageTooBig = KisTransformUtils::checkImageTooBig(transaction.originalRect(), m);
// recalculate cached handles position
recalculateTransformedHandles();
emit q->requestShowImageTooBig(imageTooBig);
}
QRect KisFilterMask::decorateRect(KisPaintDeviceSP &src,
KisPaintDeviceSP &dst,
const QRect & rc,
PositionToFilthy maskPos) const
{
Q_UNUSED(maskPos);
KisSafeFilterConfigurationSP filterConfig = filter();
Q_ASSERT(nodeProgressProxy());
Q_ASSERT_X(src != dst, "KisFilterMask::decorateRect",
"src must be != dst, because we cant create transactions "
"during merge, as it breaks reentrancy");
if (!filterConfig) {
return QRect();
}
KisFilterSP filter =
KisFilterRegistry::instance()->value(filterConfig->name());
if (!filter) {
warnKrita << "Could not retrieve filter \"" << filterConfig->name() << "\"";
return QRect();
}
KIS_ASSERT_RECOVER_NOOP(this->busyProgressIndicator());
this->busyProgressIndicator()->update();
filter->process(src, dst, 0, rc, filterConfig.data(), 0);
QRect r = filter->changedRect(rc, filterConfig.data(), dst->defaultBounds()->currentLevelOfDetail());
return r;
}
static void addToHashLazy(MovedNodesHash *hash, MoveNodeStructSP moveStruct) {
if (hash->contains(moveStruct->node)) {
bool result = hash->value(moveStruct->node)->tryMerge(*moveStruct);
KIS_ASSERT_RECOVER_NOOP(result);
} else {
hash->insert(moveStruct->node, moveStruct);
}
}
KisRasterKeyframeChannel::KisRasterKeyframeChannel(const KisRasterKeyframeChannel &rhs, const KisNodeWSP newParentNode, const KisPaintDeviceWSP newPaintDevice)
: KisKeyframeChannel(rhs, newParentNode),
m_d(new Private(newPaintDevice))
{
KIS_ASSERT_RECOVER_NOOP(&rhs != this);
m_d->frameFilenames = rhs.m_d->frameFilenames;
m_d->onionSkinsEnabled = rhs.m_d->onionSkinsEnabled;
}
KisStrokeStrategyUndoCommandBased::
KisStrokeStrategyUndoCommandBased(const KisStrokeStrategyUndoCommandBased &rhs,
bool suppressUndo)
: KisSimpleStrokeStrategy(rhs),
m_undo(false),
m_initCommand(rhs.m_initCommand),
m_finishCommand(rhs.m_finishCommand),
m_undoAdapter(!suppressUndo ? rhs.m_undoAdapter : 0),
m_macroCommand(0)
{
KIS_ASSERT_RECOVER_NOOP(!rhs.m_macroCommand &&
!rhs.m_undo &&
"After the stroke has been started, no copying must happen");
}
float KisBSpline2D::value(float x, float y) const
{
/**
* The spline works for an open interval only, so include the last point
* explicitly
*/
if (x == m_xEnd) {
x -= x * std::numeric_limits<float>::epsilon();
}
if (y == m_yEnd) {
y -= y * std::numeric_limits<float>::epsilon();
}
KIS_ASSERT_RECOVER_NOOP(x >= m_xStart && x < m_xEnd);
KIS_ASSERT_RECOVER_NOOP(y >= m_yStart && y < m_yEnd);
float value;
eval_UBspline_2d_s (m_d->spline, x, y, &value);
return value;
}
KisDelayedSaveDialog::KisDelayedSaveDialog(KisImageSP image, QWidget *parent)
: QDialog(parent),
ui(new Ui::KisDelayedSaveDialog),
m_d(new Private(image))
{
KIS_ASSERT_RECOVER_NOOP(image);
ui->setupUi(this);
connect(ui->btnCancel, SIGNAL(clicked()), SLOT(slotCancelRequested()));
connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(slotTimerTimeout()));
m_d->image->compositeProgressProxy()->addProxy(ui->progressBar);
}
void KisColorSmudgeOp::updateMask(const KisPaintInformation& info, double scale, double rotation, const QPointF &cursorPoint)
{
static const KoColorSpace *cs = KoColorSpaceRegistry::instance()->alpha8();
static KoColor color(Qt::black, cs);
m_maskDab = m_dabCache->fetchDab(cs,
color,
cursorPoint,
scale, scale,
rotation,
info,
1.0,
&m_dstDabRect);
// sanity check
KIS_ASSERT_RECOVER_NOOP(m_dstDabRect.size() == m_maskDab->bounds().size());
}
void KisStroke::suspendStroke(KisStrokeSP recipient)
{
if (!m_strokeInitialized || m_strokeSuspended ||
(m_strokeEnded && !hasJobs())) {
return;
}
KIS_ASSERT_RECOVER_NOOP(m_suspendStrategy && m_resumeStrategy);
prepend(m_resumeStrategy.data(),
m_strokeStrategy->createResumeData(),
worksOnLevelOfDetail(), false);
recipient->prepend(m_suspendStrategy.data(),
m_strokeStrategy->createSuspendData(),
worksOnLevelOfDetail(), false);
m_strokeSuspended = true;
}
void KisPerspectiveTransformWorker::run()
{
KIS_ASSERT_RECOVER_RETURN(m_dev);
if (m_isIdentity) return;
KisPaintDeviceSP cloneDevice = new KisPaintDevice(*m_dev.data());
// Clear the destination device, since all the tiles are already
// shared with cloneDevice
m_dev->clear();
KIS_ASSERT_RECOVER_NOOP(!m_isIdentity);
KisProgressUpdateHelper progressHelper(m_progressUpdater, 100, m_dstRegion.rectCount());
KisRandomSubAccessorSP srcAcc = cloneDevice->createRandomSubAccessor();
KisRandomAccessorSP accessor = m_dev->createRandomAccessorNG(0, 0);
foreach(const QRect &rect, m_dstRegion.rects()) {
for (int y = rect.y(); y < rect.y() + rect.height(); ++y) {
for (int x = rect.x(); x < rect.x() + rect.width(); ++x) {
QPointF dstPoint(x, y);
QPointF srcPoint = m_backwardTransform.map(dstPoint);
if (m_srcRect.contains(srcPoint)) {
accessor->moveTo(dstPoint.x(), dstPoint.y());
srcAcc->moveTo(srcPoint.x(), srcPoint.y());
srcAcc->sampledOldRawData(accessor->rawData());
}
}
}
progressHelper.step();
}
}
void PSDLayerRecord::write(QIODevice* io,
KisPaintDeviceSP layerContentDevice,
KisNodeSP onlyTransparencyMask,
const QRect &maskRect,
psd_section_type sectionType,
const QDomDocument &stylesXmlDoc)
{
dbgFile << "writing layer info record" << "at" << io->pos();
m_layerContentDevice = layerContentDevice;
m_onlyTransparencyMask = onlyTransparencyMask;
m_onlyTransparencyMaskRect = maskRect;
dbgFile << "saving layer record for " << layerName << "at pos" << io->pos();
dbgFile << "\ttop" << top << "left" << left << "bottom" << bottom << "right" << right << "number of channels" << nChannels;
Q_ASSERT(left <= right);
Q_ASSERT(top <= bottom);
Q_ASSERT(nChannels > 0);
try {
const QRect layerRect(left, top, right - left, bottom - top);
KisAslWriterUtils::writeRect(layerRect, io);
{
quint16 realNumberOfChannels = nChannels + bool(m_onlyTransparencyMask);
SAFE_WRITE_EX(io, realNumberOfChannels);
}
foreach(ChannelInfo *channel, channelInfoRecords) {
SAFE_WRITE_EX(io, (quint16)channel->channelId);
channel->channelInfoPosition = io->pos();
// to be filled in when we know how big channel block is
const quint32 fakeChannelSize = 0;
SAFE_WRITE_EX(io, fakeChannelSize);
}
if (m_onlyTransparencyMask) {
const quint16 userSuppliedMaskChannelId = -2;
SAFE_WRITE_EX(io, userSuppliedMaskChannelId);
m_transparencyMaskSizeOffset = io->pos();
const quint32 fakeTransparencyMaskSize = 0;
SAFE_WRITE_EX(io, fakeTransparencyMaskSize);
}
// blend mode
dbgFile << ppVar(blendModeKey) << ppVar(io->pos());
KisAslWriterUtils::writeFixedString("8BIM", io);
KisAslWriterUtils::writeFixedString(blendModeKey, io);
SAFE_WRITE_EX(io, opacity);
SAFE_WRITE_EX(io, clipping); // unused
// visibility and protection
quint8 flags = 0;
if (transparencyProtected) flags |= 1;
if (!visible) flags |= 2;
if (irrelevant) {
flags |= (1 << 3) | (1 << 4);
}
SAFE_WRITE_EX(io, flags);
{
quint8 padding = 0;
SAFE_WRITE_EX(io, padding);
}
{
// extra fields with their own length tag
KisAslWriterUtils::OffsetStreamPusher<quint32> extraDataSizeTag(io);
if (m_onlyTransparencyMask) {
{
const quint32 layerMaskDataSize = 20; // support simple case only
SAFE_WRITE_EX(io, layerMaskDataSize);
}
KisAslWriterUtils::writeRect(m_onlyTransparencyMaskRect, io);
{
KIS_ASSERT_RECOVER_NOOP(m_onlyTransparencyMask->paintDevice()->pixelSize() == 1);
const quint8 defaultPixel = *m_onlyTransparencyMask->paintDevice()->defaultPixel();
SAFE_WRITE_EX(io, defaultPixel);
}
{
const quint8 maskFlags = 0; // nothing serious
SAFE_WRITE_EX(io, maskFlags);
const quint16 padding = 0; // 2-byte padding
SAFE_WRITE_EX(io, padding);
}
} else {
const quint32 nullLayerMaskDataSize = 0;
SAFE_WRITE_EX(io, nullLayerMaskDataSize);
}
{
// blending ranges are not implemented yet
const quint32 nullBlendingRangesSize = 0;
SAFE_WRITE_EX(io, nullBlendingRangesSize);
}
// layer name: Pascal string, padded to a multiple of 4 bytes.
psdwrite_pascalstring(io, layerName, 4);
PsdAdditionalLayerInfoBlock additionalInfoBlock(m_header);
// write 'luni' data block
additionalInfoBlock.writeLuniBlockEx(io, layerName);
// write 'lsct' data block
if (sectionType != psd_other) {
additionalInfoBlock.writeLsctBlockEx(io, sectionType, isPassThrough, blendModeKey);
}
// write 'lfx2' data block
if (!stylesXmlDoc.isNull()) {
additionalInfoBlock.writeLfx2BlockEx(io, stylesXmlDoc);
}
}
} catch (KisAslWriterUtils::ASLWriteException &e) {
void KisColorSelectorBase::setHidingTime(int time)
{
KIS_ASSERT_RECOVER_NOOP(m_isPopup);
m_hideTimer->setInterval(time);
}