void KisCutCopyActionFactory::run(bool willCut, KisView2 *view)
{
KisImageSP image = view->image();
bool haveShapesSelected = view->selectionManager()->haveShapesSelected();
if (haveShapesSelected) {
#ifdef __GNUC__
#warning "Add saving of XML data for Cut/Copy of shapes"
#endif
image->barrierLock();
if (willCut) {
view->canvasBase()->toolProxy()->cut();
} else {
view->canvasBase()->toolProxy()->copy();
}
image->unlock();
} else {
KisNodeSP node = view->activeNode();
if (!node) return;
image->barrierLock();
ActionHelper::copyFromDevice(view, node->paintDevice());
image->unlock();
KUndo2Command *command = 0;
if (willCut && node->isEditable()) {
struct ClearSelection : public KisTransactionBasedCommand {
ClearSelection(KisNodeSP node, KisSelectionSP sel)
: m_node(node), m_sel(sel) {}
KisNodeSP m_node;
KisSelectionSP m_sel;
KUndo2Command* paint() {
KisTransaction transaction("", m_node->paintDevice());
m_node->paintDevice()->clearSelection(m_sel);
m_node->setDirty(m_sel->selectedRect());
return transaction.endAndTake();
}
};
command = new ClearSelection(node, view->selection());
}
QString actionName = willCut ? i18n("Cut") : i18n("Copy");
KisProcessingApplicator *ap = beginAction(view, actionName);
if (command) {
ap->applyCommand(command,
KisStrokeJobData::SEQUENTIAL,
KisStrokeJobData::NORMAL);
}
KisOperationConfiguration config(id());
config.setProperty("will-cut", willCut);
endAction(ap, config.toXML());
}
}
void KisSimpleUpdateQueueTest::testMixingTypes()
{
QRect imageRect(0,0,1024,1024);
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");
KisPaintLayerSP paintLayer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8);
image->lock();
image->addNode(paintLayer);
image->unlock();
QRect dirtyRect1(0,0,200,200);
QRect dirtyRect2(0,0,200,200);
QRect dirtyRect3(20,20,200,200);
KisTestableSimpleUpdateQueue queue;
KisWalkersList& walkersList = queue.getWalkersList();
queue.addUpdateJob(paintLayer, dirtyRect1, imageRect, 0);
queue.addFullRefreshJob(paintLayer, dirtyRect2, imageRect, 0);
queue.addFullRefreshJob(paintLayer, dirtyRect3, imageRect, 0);
queue.addUpdateNoFilthyJob(paintLayer, dirtyRect1, imageRect, 0);
QCOMPARE(walkersList.size(), 3);
QVERIFY(checkWalker(walkersList[0], QRect(0,0,200,200)));
QVERIFY(checkWalker(walkersList[1], QRect(0,0,220,220)));
QVERIFY(checkWalker(walkersList[2], QRect(0,0,200,200)));
QCOMPARE(walkersList[0]->type(), KisBaseRectsWalker::UPDATE);
QCOMPARE(walkersList[1]->type(), KisBaseRectsWalker::FULL_REFRESH);
QCOMPARE(walkersList[2]->type(), KisBaseRectsWalker::UPDATE_NO_FILTHY);
}
void KisSimpleUpdateQueueTest::testJobProcessing()
{
KisTestableUpdaterContext context(2);
QRect imageRect(0,0,200,200);
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");
KisPaintLayerSP paintLayer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8);
image->lock();
image->addNode(paintLayer);
image->unlock();
QRect dirtyRect1(0,0,50,100);
QRect dirtyRect2(0,0,100,100);
QRect dirtyRect3(50,0,50,100);
QRect dirtyRect4(150,150,50,50);
QRect dirtyRect5(dirtyRect4); // theoretically, should be merged with 4
QVector<KisUpdateJobItem*> jobs;
KisWalkersList walkersList;
/**
* Process the queue and look what has been added into
* the updater context
*/
KisTestableSimpleUpdateQueue queue;
queue.addUpdateJob(paintLayer, dirtyRect1, imageRect, 0);
queue.addUpdateJob(paintLayer, dirtyRect2, imageRect, 0);
queue.addUpdateJob(paintLayer, dirtyRect3, imageRect, 0);
queue.addUpdateJob(paintLayer, dirtyRect4, imageRect, 0);
{
TestUtil::LodOverride l(1, image);
queue.addUpdateJob(paintLayer, dirtyRect5, imageRect, 1);
}
queue.processQueue(context);
jobs = context.getJobs();
QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect2));
QVERIFY(checkWalker(jobs[1]->walker(), dirtyRect4));
QCOMPARE(jobs.size(), 2);
QCOMPARE(context.currentLevelOfDetail(), 0);
walkersList = queue.getWalkersList();
QCOMPARE(walkersList.size(), 1);
QVERIFY(checkWalker(walkersList[0], dirtyRect5, 1));
}
void KisSimpleUpdateQueueTest::testChecksum()
{
QRect imageRect(0,0,512,512);
QRect dirtyRect(100,100,100,100);
const KoColorSpace * colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), colorSpace, "test");
KisLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
KisAdjustmentLayerSP adjustmentLayer = new KisAdjustmentLayer(image, "adj", 0, 0);
image->lock();
image->addNode(paintLayer1, image->rootLayer());
image->addNode(adjustmentLayer, image->rootLayer());
image->unlock();
KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
Q_ASSERT(filter);
KisFilterConfiguration *configuration = filter->defaultConfiguration(0);
KisTestableSimpleUpdateQueue queue;
KisWalkersList& walkersList = queue.getWalkersList();
{
TestUtil::LodOverride l(1, image);
queue.addUpdateJob(adjustmentLayer, dirtyRect, imageRect, 1);
QCOMPARE(walkersList[0]->checksumValid(), true);
QCOMPARE(walkersList[0]->levelOfDetail(), 1);
}
adjustmentLayer->setFilter(configuration);
{
TestUtil::LodOverride l(1, image);
QCOMPARE(walkersList[0]->checksumValid(), false);
}
QVector<KisUpdateJobItem*> jobs;
KisTestableUpdaterContext context(2);
{
TestUtil::LodOverride l(1, image);
queue.processQueue(context);
}
jobs = context.getJobs();
{
TestUtil::LodOverride l(1, image);
QCOMPARE(jobs[0]->walker()->checksumValid(), true);
}
}
bool pickWrapped(KisPaintDeviceSP dev, QPoint pos, KoColor *color, KisImageSP image)
{
if (!image->tryBarrierLock()) return false;
if (image->wrapAroundModePermitted()) {
pos = KisWrappedRect::ptToWrappedPt(pos, image->bounds());
}
bool result = pick(dev, pos, color);
image->unlock();
return result;
}
void KisSimpleUpdateQueueTest::testSplit(bool useFullRefresh)
{
QRect imageRect(0,0,1024,1024);
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");
KisPaintLayerSP paintLayer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8);
image->lock();
image->addNode(paintLayer);
image->unlock();
QRect dirtyRect1(0,0,1000,1000);
KisTestableSimpleUpdateQueue queue;
KisWalkersList& walkersList = queue.getWalkersList();
if(!useFullRefresh) {
queue.addUpdateJob(paintLayer, dirtyRect1, imageRect, 0);
}
else {
queue.addFullRefreshJob(paintLayer, dirtyRect1, imageRect, 0);
}
QCOMPARE(walkersList.size(), 4);
QVERIFY(checkWalker(walkersList[0], QRect(0,0,512,512)));
QVERIFY(checkWalker(walkersList[1], QRect(512,0,488,512)));
QVERIFY(checkWalker(walkersList[2], QRect(0,512,512,488)));
QVERIFY(checkWalker(walkersList[3], QRect(512,512,488,488)));
queue.optimize();
//must change nothing
QCOMPARE(walkersList.size(), 4);
QVERIFY(checkWalker(walkersList[0], QRect(0,0,512,512)));
QVERIFY(checkWalker(walkersList[1], QRect(512,0,488,512)));
QVERIFY(checkWalker(walkersList[2], QRect(0,512,512,488)));
QVERIFY(checkWalker(walkersList[3], QRect(512,512,488,488)));
}
KisImageSP utils::createImage(KisUndoStore *undoStore, const QSize &imageSize) {
QRect imageRect(0,0,imageSize.width(),imageSize.height());
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(undoStore, imageRect.width(), imageRect.height(), cs, "stroke test");
KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
KisPaintLayerSP paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8);
KisPaintLayerSP paintLayer3 = new KisPaintLayer(image, "paint3", OPACITY_OPAQUE_U8);
KisPaintLayerSP paintLayer4 = new KisPaintLayer(image, "paint4", OPACITY_OPAQUE_U8);
KisPaintLayerSP paintLayer5 = new KisPaintLayer(image, "paint5", OPACITY_OPAQUE_U8);
image->lock();
image->addNode(paintLayer1);
image->addNode(paintLayer2);
image->addNode(paintLayer3);
image->addNode(paintLayer4);
image->addNode(paintLayer5);
image->unlock();
return image;
}
void KisImageTest::testConvertImageColorSpace()
{
const KoColorSpace *cs8 = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 1000, 1000, cs8, "stest");
KisPaintDeviceSP device1 = new KisPaintDevice(cs8);
KisLayerSP paint1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
Q_ASSERT(filter);
KisFilterConfiguration *configuration = filter->defaultConfiguration(0);
Q_ASSERT(configuration);
KisLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration, 0);
image->addNode(paint1, image->root());
image->addNode(blur1, image->root());
image->refreshGraph();
const KoColorSpace *cs16 = KoColorSpaceRegistry::instance()->rgb16();
image->lock();
image->convertImageColorSpace(cs16,
KoColorConversionTransformation::InternalRenderingIntent,
KoColorConversionTransformation::InternalConversionFlags);
image->unlock();
QVERIFY(*cs16 == *image->colorSpace());
QVERIFY(*cs16 == *image->root()->colorSpace());
QVERIFY(*cs16 == *paint1->colorSpace());
QVERIFY(*cs16 == *blur1->colorSpace());
QVERIFY(!image->root()->compositeOp());
QVERIFY(*cs16 == *paint1->compositeOp()->colorSpace());
QVERIFY(*cs16 == *blur1->compositeOp()->colorSpace());
image->refreshGraph();
}
void KisSimpleUpdateQueueTest::testJobProcessing()
{
KisTestableUpdaterContext context(2);
QRect imageRect(0,0,200,200);
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, imageRect.width(), imageRect.height(), cs, "merge test");
KisPaintLayerSP paintLayer = new KisPaintLayer(image, "test", OPACITY_OPAQUE_U8);
image->lock();
image->addNode(paintLayer);
image->unlock();
QRect dirtyRect1(0,0,50,100);
QRect dirtyRect2(0,0,100,100);
QRect dirtyRect3(50,0,50,100);
QRect dirtyRect4(150,150,50,50);
QVector<KisUpdateJobItem*> jobs;
KisWalkersList walkersList;
/**
* Process the queue and look what has been added into
* the updater context
*/
KisTestableSimpleUpdateQueue queue;
queue.addJob(paintLayer, dirtyRect1, imageRect);
queue.addJob(paintLayer, dirtyRect2, imageRect);
queue.addJob(paintLayer, dirtyRect3, imageRect);
queue.addJob(paintLayer, dirtyRect4, imageRect);
queue.processQueue(context);
jobs = context.getJobs();
QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect2));
QVERIFY(checkWalker(jobs[1]->walker(), dirtyRect4));
QCOMPARE(jobs.size(), 2);
walkersList = queue.getWalkersList();
QCOMPARE(walkersList.size(), 0);
/**
* Test blocking the process
*/
context.clear();
queue.blockProcessing(context);
queue.addJob(paintLayer, dirtyRect1, imageRect);
queue.addJob(paintLayer, dirtyRect2, imageRect);
queue.addJob(paintLayer, dirtyRect3, imageRect);
queue.addJob(paintLayer, dirtyRect4, imageRect);
jobs = context.getJobs();
QCOMPARE(jobs[0]->walker(), KisBaseRectsWalkerSP(0));
QCOMPARE(jobs[1]->walker(), KisBaseRectsWalkerSP(0));
queue.startProcessing(context);
jobs = context.getJobs();
QVERIFY(checkWalker(jobs[0]->walker(), dirtyRect2));
QVERIFY(checkWalker(jobs[1]->walker(), dirtyRect4));
}
KoFilter::ConversionStatus KisOpenEXRImport::convert(const QByteArray& from, const QByteArray& to)
{
if (from != "image/x-exr" || to != "application/x-krita") {
return KoFilter::NotImplemented;
}
dbgFile << "\n\n\nKrita importing from OpenEXR";
KisDoc2 * doc = dynamic_cast<KisDoc2*>(m_chain -> outputDocument());
if (!doc) {
return KoFilter::CreationError;
}
doc -> prepareForImport();
QString filename = m_chain -> inputFile();
if (filename.isEmpty()) {
return KoFilter::FileNotFound;
}
RgbaInputFile file(QFile::encodeName(filename));
Box2i dataWindow = file.dataWindow();
Box2i displayWindow = file.displayWindow();
dbgFile << "Data window:" << QRect(dataWindow.min.x, dataWindow.min.y, dataWindow.max.x - dataWindow.min.x + 1, dataWindow.max.y - dataWindow.min.y + 1);
dbgFile << "Display window:" << QRect(displayWindow.min.x, displayWindow.min.y, displayWindow.max.x - displayWindow.min.x + 1, displayWindow.max.y - displayWindow.min.y + 1);
int imageWidth = displayWindow.max.x - displayWindow.min.x + 1;
int imageHeight = displayWindow.max.y - displayWindow.min.y + 1;
QString imageName = "Imported from OpenEXR";
int dataWidth = dataWindow.max.x - dataWindow.min.x + 1;
int dataHeight = dataWindow.max.y - dataWindow.min.y + 1;
const KoColorSpace *cs = static_cast<const KoColorSpace *>((KoColorSpaceRegistry::instance()->colorSpace(KoID("RgbAF16", ""), "")));
if (cs == 0) {
return KoFilter::InternalError;
}
doc -> undoAdapter() -> setUndo(false);
KisImageSP image = new KisImage(doc->undoAdapter(), imageWidth, imageHeight, cs, imageName);
if (!image) {
return KoFilter::CreationError;
}
image->lock();
KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE, cs);
layer->setCompositeOp(COMPOSITE_OVER);
if (!layer) {
return KoFilter::CreationError;
}
Q3MemArray<Rgba> pixels(dataWidth);
for (int y = 0; y < dataHeight; ++y) {
file.setFrameBuffer(pixels.data() - dataWindow.min.x - (dataWindow.min.y + y) * dataWidth, 1, dataWidth);
file.readPixels(dataWindow.min.y + y);
KisHLineIterator it = layer->paintDevice()->createHLineIterator(dataWindow.min.x, dataWindow.min.y + y, dataWidth);
Rgba *rgba = pixels.data();
while (!it.isDone()) {
// XXX: For now unmultiply the alpha, though compositing will be faster if we
// keep it premultiplied.
half unmultipliedRed = rgba -> r;
half unmultipliedGreen = rgba -> g;
half unmultipliedBlue = rgba -> b;
if (rgba -> a >= HALF_EPSILON) {
unmultipliedRed /= rgba -> a;
unmultipliedGreen /= rgba -> a;
unmultipliedBlue /= rgba -> a;
}
setPixel(it.rawData(), unmultipliedRed, unmultipliedGreen, unmultipliedBlue, rgba -> a);
++it;
++rgba;
}
}
image->addNode(layer.data(), image->rootLayer().data());
layer->setDirty();
doc -> setCurrentImage(image);
doc -> undoAdapter() -> setUndo(true);
doc -> setModified(false);
image->unlock();
return KoFilter::OK;
}