KisColorSelectorComboBoxPrivate(QWidget* parent) :
QWidget(parent, Qt::Popup),
spacing(20),
selectorSize(100),
highlightArea(-1,-1,0,0)
{
setMouseTracking(true);
QGridLayout* layout = new QGridLayout(this);
layout->setSpacing(spacing);
//dbgKrita<<"Created list";
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Triangle, KisColorSelectorConfiguration::Ring, KisColorSelectorConfiguration::SL , KisColorSelectorConfiguration::H), this), 0,0);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Ring, KisColorSelectorConfiguration::SV , KisColorSelectorConfiguration::H), this), 0,1);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Ring, KisColorSelectorConfiguration::SV2, KisColorSelectorConfiguration::H), this), 0,2);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::VH, KisColorSelectorConfiguration::hsvS), this), 0,3);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::hsvSH, KisColorSelectorConfiguration::V), this), 0,4);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::SV2, KisColorSelectorConfiguration::H), this), 1,0);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::SV, KisColorSelectorConfiguration::H), this), 1,1);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::VH, KisColorSelectorConfiguration::hsvS), this), 1,2);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::hsvSH, KisColorSelectorConfiguration::V), this), 1,3);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Ring, KisColorSelectorConfiguration::SL , KisColorSelectorConfiguration::H), this), 0,1);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::LH, KisColorSelectorConfiguration::hslS), this), 0,2);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::hslSH, KisColorSelectorConfiguration::L), this), 0,3);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::SL, KisColorSelectorConfiguration::H), this), 1,0);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::LH, KisColorSelectorConfiguration::hslS), this), 1,1);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::hslSH, KisColorSelectorConfiguration::L), this), 1,2);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Ring, KisColorSelectorConfiguration::SI , KisColorSelectorConfiguration::H), this), 0,1);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::IH, KisColorSelectorConfiguration::hsiS), this), 0,2);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::hsiSH, KisColorSelectorConfiguration::I), this), 0,3);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::SI, KisColorSelectorConfiguration::H), this), 1,0);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::IH, KisColorSelectorConfiguration::hsiS), this), 1,1);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::hsiSH, KisColorSelectorConfiguration::I), this), 1,2);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Ring, KisColorSelectorConfiguration::SY , KisColorSelectorConfiguration::H), this), 0,1);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::YH, KisColorSelectorConfiguration::hsyS), this), 0,2);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Wheel, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::hsySH, KisColorSelectorConfiguration::Y), this), 0,3);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::SY, KisColorSelectorConfiguration::H), this), 1,0);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::YH, KisColorSelectorConfiguration::hsyS), this), 1,1);
layout->addWidget(new KisColorSelector(KisColorSelectorConfiguration(KisColorSelectorConfiguration::Square, KisColorSelectorConfiguration::Slider, KisColorSelectorConfiguration::hsySH, KisColorSelectorConfiguration::Y), this), 1,2);
setList(0);
for(int i=0; i<this->layout()->count(); i++) {
KisColorSelector* item = dynamic_cast<KisColorSelector*>(this->layout()->itemAt(i)->widget());
Q_ASSERT(item);
if(item!=0) {
item->setMaximumSize(selectorSize, selectorSize);
item->setMinimumSize(selectorSize, selectorSize);
item->setMouseTracking(true);
item->setEnabled(false);
item->setColor(KoColor(QColor(255,0,0), item->colorSpace()));
item->setDisplayBlip(false);
}
}
}
KoCanvasResourceManager* utils::createResourceManager(KisImageWSP image,
KisNodeSP node,
const QString &presetFileName)
{
KoCanvasResourceManager *manager = new KoCanvasResourceManager();
QVariant i;
i.setValue(KoColor(Qt::black, image->colorSpace()));
manager->setResource(KoCanvasResourceManager::ForegroundColor, i);
i.setValue(KoColor(Qt::white, image->colorSpace()));
manager->setResource(KoCanvasResourceManager::BackgroundColor, i);
i.setValue(static_cast<void*>(0));
manager->setResource(KisCanvasResourceProvider::CurrentPattern, i);
manager->setResource(KisCanvasResourceProvider::CurrentGradient, i);
manager->setResource(KisCanvasResourceProvider::CurrentGeneratorConfiguration, i);
if(!node) {
node = image->root();
while(node && !dynamic_cast<KisPaintLayer*>(node.data())) {
node = node->firstChild();
}
Q_ASSERT(node && dynamic_cast<KisPaintLayer*>(node.data()));
}
i.setValue(node);
manager->setResource(KisCanvasResourceProvider::CurrentKritaNode, i);
KisPaintOpPresetSP preset;
if (!presetFileName.isEmpty()) {
QString fullFileName = TestUtil::fetchDataFileLazy(presetFileName);
preset = new KisPaintOpPreset(fullFileName);
bool presetValid = preset->load();
Q_ASSERT(presetValid); Q_UNUSED(presetValid);
i.setValue(preset);
manager->setResource(KisCanvasResourceProvider::CurrentPaintOpPreset, i);
}
i.setValue(COMPOSITE_OVER);
manager->setResource(KisCanvasResourceProvider::CurrentCompositeOp, i);
i.setValue(false);
manager->setResource(KisCanvasResourceProvider::MirrorHorizontal, i);
i.setValue(false);
manager->setResource(KisCanvasResourceProvider::MirrorVertical, i);
i.setValue(1.0);
manager->setResource(KisCanvasResourceProvider::Opacity, i);
i.setValue(1.0);
manager->setResource(KisCanvasResourceProvider::HdrExposure, i);
i.setValue(QPoint());
manager->setResource(KisCanvasResourceProvider::MirrorAxesCenter, i);
return manager;
}
void KisTransformMaskTest::testWeirdFullUpdates()
{
//TestUtil::ExternalImageChecker chk("mask_with_offset", "transform_mask_updates");
QRect imageRect(0,0,512,512);
QRect fillRect(10, 10, 236, 236);
TestUtil::MaskParent p(imageRect);
p.layer->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));
KisPaintLayerSP player1 = new KisPaintLayer(p.image, "pl1", OPACITY_OPAQUE_U8, p.image->colorSpace());
player1->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));
p.image->addNode(player1, p.image->root());
KisTransformMaskSP mask1 = new KisTransformMask();
mask1->setName("mask1");
QTransform transform1 =
QTransform::fromTranslate(256, 0);
mask1->setTransformParams(KisTransformMaskParamsInterfaceSP(
new KisDumbTransformMaskParams(transform1)));
p.image->addNode(mask1, player1);
KisPaintLayerSP player2 = new KisPaintLayer(p.image, "pl2", OPACITY_OPAQUE_U8, p.image->colorSpace());
player2->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));
p.image->addNode(player2, p.image->root());
KisTransformMaskSP mask2 = new KisTransformMask();
mask2->setName("mask2");
QTransform transform2 =
QTransform::fromTranslate(0, 256);
mask2->setTransformParams(KisTransformMaskParamsInterfaceSP(
new KisDumbTransformMaskParams(transform2)));
p.image->addNode(mask2, player2);
KisPaintLayerSP player3 = new KisPaintLayer(p.image, "pl3", OPACITY_OPAQUE_U8, p.image->colorSpace());
player3->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));
p.image->addNode(player3, p.image->root());
KisTransformMaskSP mask3 = new KisTransformMask();
mask3->setName("mask3");
QTransform transform3 =
QTransform::fromTranslate(256, 256);
mask3->setTransformParams(KisTransformMaskParamsInterfaceSP(
new KisDumbTransformMaskParams(transform3)));
p.image->addNode(mask3, player3);
//p.image->initialRefreshGraph();
p.image->refreshGraphAsync(0, QRect(0,0,256,256), QRect());
p.image->waitForDone();
QVERIFY(player1->projection()->extent().isEmpty());
QVERIFY(player1->projection()->exactBounds().isEmpty());
QVERIFY(player2->projection()->extent().isEmpty());
QVERIFY(player2->projection()->exactBounds().isEmpty());
QVERIFY(player3->projection()->extent().isEmpty());
QVERIFY(player3->projection()->exactBounds().isEmpty());
QCOMPARE(p.image->projection()->exactBounds(), QRect(QRect(10,10,236,236)));
p.image->refreshGraphAsync(0, QRect(0,256,256,256), QRect());
p.image->waitForDone();
QVERIFY(player1->projection()->extent().isEmpty());
QVERIFY(player1->projection()->exactBounds().isEmpty());
QVERIFY(!player2->projection()->extent().isEmpty());
QVERIFY(!player2->projection()->exactBounds().isEmpty());
QVERIFY(player3->projection()->extent().isEmpty());
QVERIFY(player3->projection()->exactBounds().isEmpty());
QCOMPARE(p.image->projection()->exactBounds(), QRect(QRect(10,10,236,492)));
p.image->refreshGraphAsync(0, QRect(256,0,256,256), QRect());
p.image->waitForDone();
QVERIFY(!player1->projection()->extent().isEmpty());
QVERIFY(!player1->projection()->exactBounds().isEmpty());
QVERIFY(!player2->projection()->extent().isEmpty());
QVERIFY(!player2->projection()->exactBounds().isEmpty());
QVERIFY(player3->projection()->extent().isEmpty());
QVERIFY(player3->projection()->exactBounds().isEmpty());
QCOMPARE(p.image->projection()->exactBounds(), QRect(QRect(10,10,492,492)));
QVERIFY((p.image->projection()->region() & QRect(256,256,256,256)).isEmpty());
p.image->refreshGraphAsync(0, QRect(256,256,256,256), QRect());
p.image->waitForDone();
QVERIFY(!player1->projection()->extent().isEmpty());
QVERIFY(!player1->projection()->exactBounds().isEmpty());
QVERIFY(!player2->projection()->extent().isEmpty());
QVERIFY(!player2->projection()->exactBounds().isEmpty());
QVERIFY(!player3->projection()->extent().isEmpty());
QVERIFY(!player3->projection()->exactBounds().isEmpty());
QCOMPARE(p.image->projection()->exactBounds(), QRect(QRect(10,10,492,492)));
QVERIFY(!(p.image->projection()->region() & QRect(256,256,256,256)).isEmpty());
p.image->waitForDone();
KIS_DUMP_DEVICE_2(p.image->projection(), imageRect, "image_proj", "dd");
}
void KisAslLayerStyleSerializerTest::testWritingGradients()
{
KoStopGradient stopGradient("");
{
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
QList<KoGradientStop> stops;
stops << KoGradientStop(0.0, KoColor(Qt::black, cs));
stops << KoGradientStop(0.3, KoColor(Qt::red, cs));
stops << KoGradientStop(0.6, KoColor(Qt::green, cs));
stops << KoGradientStop(1.0, KoColor(Qt::white, cs));
stopGradient.setStops(stops);
}
KisPSDLayerStyleSP style(new KisPSDLayerStyle());
style->outerGlow()->setEffectEnabled(true);
style->outerGlow()->setFillType(psd_fill_gradient);
style->outerGlow()->setGradient(toQShared(new KoStopGradient(stopGradient)));
style->innerGlow()->setEffectEnabled(true);
style->innerGlow()->setFillType(psd_fill_gradient);
style->innerGlow()->setGradient(toQShared(new KoStopGradient(stopGradient)));
style->gradientOverlay()->setEffectEnabled(true);
style->gradientOverlay()->setGradient(toQShared(new KoStopGradient(stopGradient)));
style->stroke()->setEffectEnabled(true);
style->stroke()->setFillType(psd_fill_gradient);
style->stroke()->setGradient(toQShared(new KoStopGradient(stopGradient)));
{
KisAslLayerStyleSerializer s;
s.setStyles(QVector<KisPSDLayerStyleSP>() << style);
QFile dstFile("test_written_stop_gradient.asl");
dstFile.open(QIODevice::WriteOnly);
s.saveToDevice(&dstFile);
dstFile.close();
}
QString xmlDoc;
{
QFile resultFile("test_written_stop_gradient.asl");
resultFile.open(QIODevice::ReadOnly);
KisAslReader reader;
QDomDocument doc = reader.readFile(&resultFile);
xmlDoc = doc.toString();
}
{
// the reference document has stripped "Idnt" field which is random
QRegExp rx("<node key=\"Idnt\" type=\"Text\" value=\".+\"/>");
rx.setMinimal(true);
int pos = 0;
while ((pos = rx.indexIn(xmlDoc, pos)) != -1) {
xmlDoc.remove(pos, rx.matchedLength());
}
{
//QFile xmlFile("reference_gradients.asl.xml");
//xmlFile.open(QIODevice::WriteOnly);
//xmlFile.write(xmlDoc.toLatin1());
//xmlFile.close();
}
QString refFileName(TestUtil::fetchDataFileLazy("reference_gradients.asl.xml"));
QFile refFile(refFileName);
refFile.open(QIODevice::ReadOnly);
QString refDoc = QString(refFile.readAll());
QCOMPARE(xmlDoc, refDoc);
}
}
bool doPartialTests(const QString &prefix, KisImageSP image, KisLayerSP paintLayer,
KisLayerSP visibilityToggleLayer, KisTransformMaskSP mask)
{
TestUtil::ExternalImageChecker chk(prefix, "transform_mask_updates");
bool result = true;
QRect refRect = image->bounds();
int testIndex = 1;
QString testName;
for (int y = 0; y < refRect.height(); y += 512) {
for (int x = 0; x < refRect.width(); x += 512) {
QRect rc(x, y, 512, 512);
if (rc.right() > refRect.right()) {
rc.setRight(refRect.right());
if (rc.isEmpty()) continue;
}
if (rc.bottom() > refRect.bottom()) {
rc.setBottom(refRect.bottom());
if (rc.isEmpty()) continue;
}
paintLayer->setDirty(rc);
image->waitForDone();
testName = QString("tm_%1_partial_%2_%3").arg(testIndex++).arg(x).arg(y);
result &= chk.checkImage(image, testName);
}
}
// initial update of the mask to clear the unused portions of the projection
// (it updates only when we call set dirty on the mask itself, which happens
// in Krita right after the addition of the mask onto a layer)
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_initial_mask_visible_on").arg(testIndex++);
result &= chk.checkImage(image, testName);
// start layer visibility testing
paintLayer->setVisible(false);
paintLayer->setDirty();
image->waitForDone();
testName = QString("tm_%1_layer_visible_off").arg(testIndex++);
result &= chk.checkImage(image, testName);
paintLayer->setVisible(true);
paintLayer->setDirty();
image->waitForDone();
testName = QString("tm_%1_layer_visible_on").arg(testIndex++);
result &= chk.checkImage(image, testName);
if (paintLayer != visibilityToggleLayer) {
visibilityToggleLayer->setVisible(false);
visibilityToggleLayer->setDirty();
image->waitForDone();
testName = QString("tm_%1_extra_layer_visible_off").arg(testIndex++);
result &= chk.checkImage(image, testName);
visibilityToggleLayer->setVisible(true);
visibilityToggleLayer->setDirty();
image->waitForDone();
testName = QString("tm_%1_extra_layer_visible_on").arg(testIndex++);
result &= chk.checkImage(image, testName);
}
// toggle mask visibility
mask->setVisible(false);
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_mask_visible_off").arg(testIndex++);
result &= chk.checkImage(image, testName);
mask->setVisible(true);
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_mask_visible_on").arg(testIndex++);
result &= chk.checkImage(image, testName);
// entire bounds update
// no clearing, just don't hang up
paintLayer->setDirty(refRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_bounds").arg(testIndex++);
result &= chk.checkImage(image, testName);
// no clearing, just don't hang up
mask->setDirty(refRect);
image->waitForDone();
testName = QString("tm_%1_mask_dirty_bounds").arg(testIndex++);
result &= chk.checkImage(image, testName);
if (paintLayer != visibilityToggleLayer) {
// no clearing, just don't hang up
visibilityToggleLayer->setDirty(refRect);
image->waitForDone();
testName = QString("tm_%1_extra_layer_dirty_bounds").arg(testIndex++);
result &= chk.checkImage(image, testName);
}
QRect fillRect;
// partial updates outside
fillRect = QRect(-100, 0.5 * refRect.height(), 50, 100);
paintLayer->paintDevice()->fill(fillRect, KoColor(Qt::red, image->colorSpace()));
paintLayer->setDirty(fillRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_outside_%2_%3").arg(testIndex++).arg(fillRect.x()).arg(fillRect.y());
result &= chk.checkImage(image, testName);
fillRect = QRect(0.5 * refRect.width(), -100, 100, 50);
paintLayer->paintDevice()->fill(fillRect, KoColor(Qt::red, image->colorSpace()));
paintLayer->setDirty(fillRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_outside_%2_%3").arg(testIndex++).arg(fillRect.x()).arg(fillRect.y());
result &= chk.checkImage(image, testName);
fillRect = QRect(refRect.width() + 50, 0.2 * refRect.height(), 50, 100);
paintLayer->paintDevice()->fill(fillRect, KoColor(Qt::red, image->colorSpace()));
paintLayer->setDirty(fillRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_outside_%2_%3").arg(testIndex++).arg(fillRect.x()).arg(fillRect.y());
result &= chk.checkImage(image, testName);
// partial update inside
fillRect = QRect(0.5 * refRect.width() - 50, 0.5 * refRect.height() - 50, 100, 100);
paintLayer->paintDevice()->fill(fillRect, KoColor(Qt::red, image->colorSpace()));
paintLayer->setDirty(fillRect);
image->waitForDone();
testName = QString("tm_%1_layer_dirty_inside_%2_%3").arg(testIndex++).arg(fillRect.x()).arg(fillRect.y());
result &= chk.checkImage(image, testName);
// clear explicitly
image->projection()->clear();
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_mask_dirty_bounds").arg(testIndex++);
result &= chk.checkImage(image, testName);
KisDumbTransformMaskParams *params =
dynamic_cast<KisDumbTransformMaskParams*>(mask->transformParams().data());
QTransform t = params->testingGetTransform();
t *= QTransform::fromTranslate(400, 300);
params->testingSetTransform(t);
mask->setTransformParams(mask->transformParams());
mask->setDirty();
image->waitForDone();
testName = QString("tm_%1_mask_dirty_after_offset").arg(testIndex++);
result &= chk.checkImage(image, testName);
return result;
}
void KisTransformMaskTest::testMultipleMasks()
{
TestUtil::ExternalImageChecker chk("multiple_masks", "transform_mask_updates");
QRect refRect(0,0,512,512);
QRect fillRect(400,400,100,100);
TestUtil::MaskParent p(refRect);
p.layer->paintDevice()->fill(fillRect, KoColor(Qt::red, p.layer->colorSpace()));
KisPaintLayerSP player = new KisPaintLayer(p.image, "bg", OPACITY_OPAQUE_U8, p.image->colorSpace());
p.image->addNode(player, p.image->root(), KisNodeSP());
//KisCloneLayerSP clone = new KisCloneLayer(p.layer, p.image, "clone", OPACITY_OPAQUE_U8);
//p.image->addNode(clone, p.image->root());
KisTransformMaskSP mask1 = new KisTransformMask();
p.image->addNode(mask1, p.layer);
KisTransformMaskSP mask2 = new KisTransformMask();
p.image->addNode(mask2, p.layer);
mask1->setName("mask1");
mask2->setName("mask2");
p.layer->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "00_initial_layer_update");
QTransform transform;
transform = QTransform::fromTranslate(-150, 0);
mask1->setTransformParams(KisTransformMaskParamsInterfaceSP(
new KisDumbTransformMaskParams(transform)));
p.layer->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "01_mask1_moved_layer_update");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "01X_mask1_moved_layer_update");
transform = QTransform::fromTranslate(0, -150);
mask2->setTransformParams(KisTransformMaskParamsInterfaceSP(
new KisDumbTransformMaskParams(transform)));
p.layer->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "02_mask2_moved_layer_update");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "02X_mask2_moved_layer_update");
#ifdef CHECK_MASK1_TOGGLE
{
mask1->setVisible(false);
mask1->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "03_mask1_tg_off_refRect");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "03X_mask1_tg_off_refRect");
mask1->setVisible(true);
mask1->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "04_mask1_tg_on_refRect");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "04X_mask1_tg_on_refRect");
mask1->setVisible(false);
mask1->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "05_mask1_tg_off_default_rect");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "05X_mask1_tg_off_default_rect");
mask1->setVisible(true);
mask1->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "06_mask1_tg_on_default_rect");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "06X_mask1_tg_on_default_rect");
}
#endif /* CHECK_MASK1_TOGGLE */
#ifdef CHECK_MASK2_TOGGLE
{
mask2->setVisible(false);
mask2->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "07_mask2_tg_off_refRect");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "07X_mask2_tg_off_refRect");
mask2->setVisible(true);
mask2->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "08_mask2_tg_on_refRect");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "08X_mask2_tg_on_refRect");
mask2->setVisible(false);
mask2->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "09_mask2_tg_off_default_rect");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "09X_mask2_tg_off_default_rect");
mask2->setVisible(true);
mask2->setDirty(refRect);
p.image->waitForDone();
chk.checkImage(p.image, "10_mask2_tg_on_default_rect");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "10X_mask2_tg_on_default_rect");
}
#endif /* CHECK_MASK2_TOGGLE */
#ifdef CHECK_HIDE_ALL
{
mask1->setVisible(false);
mask1->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "11.1_hide_both_update_default_mask1");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "11.1X_hide_both_update_default_mask1");
mask2->setVisible(false);
mask2->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "11.2_hide_both_update_default_mask2");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "11.2X_hide_both_update_default_mask2");
mask1->setVisible(true);
mask1->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "12_sh_mask1_on");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "12X_sh_mask1_on");
mask1->setVisible(false);
mask1->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "13_sh_mask1_off");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "13X_sh_mask1_off");
mask2->setVisible(true);
mask2->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "14_sh_mask2_on");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "14X_sh_mask2_on");
mask2->setVisible(false);
mask2->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "15_sh_mask2_off");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "15X_sh_mask2_off");
}
#endif /* CHECK_HIDE_ALL */
#ifdef CHECK_HIDE_ALL_AFTER_MOVE
{
transform = QTransform::fromTranslate(50, -150);
mask2->setTransformParams(KisTransformMaskParamsInterfaceSP(
new KisDumbTransformMaskParams(transform)));
mask2->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "20_moved_mask2");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "20X_moved_mask2");
}
{
mask1->setVisible(false);
mask1->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "21.1_hide_both_update_default_mask1");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "21.1X_hide_both_update_default_mask1");
mask2->setVisible(false);
mask2->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "21.2_hide_both_update_default_mask2");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "21.2X_hide_both_update_default_mask2");
mask1->setVisible(true);
mask1->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "22_sh_mask1_on");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "22X_sh_mask1_on");
mask1->setVisible(false);
mask1->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "23_sh_mask1_off");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "23X_sh_mask1_off");
mask2->setVisible(true);
mask2->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "24_sh_mask2_on");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "24X_sh_mask2_on");
mask2->setVisible(false);
mask2->setDirty();
p.image->waitForDone();
chk.checkImage(p.image, "25_sh_mask2_off");
QTest::qWait(4000);
p.image->waitForDone();
chk.checkImage(p.image, "25X_sh_mask2_off");
}
#endif /* CHECK_HIDE_ALL_AFTER_MOVE */
QVERIFY(chk.testPassed());
}
void KisSmudgeRadiusOption::apply(KisPainter& painter, const KisPaintInformation& info, qreal scale, qreal posx, qreal posy,KisPaintDeviceSP dev) const
{
double sliderValue = computeValue(info);
int smudgeRadius = ((sliderValue * scale)*0.5)/100.0;//scale is diameter?
KoColor color = painter.paintColor();
if (smudgeRadius == 1) {
dev->pixel(posx, posy, &color);
painter.setPaintColor(color);
} else {
const KoColorSpace* cs = dev->colorSpace();
int pixelSize = cs->pixelSize();
quint8* data = new quint8[pixelSize];
static quint8** pixels = new quint8*[2];
qint16* weights = new qint16[2];
pixels[1] = new quint8[pixelSize];
pixels[0] = new quint8[pixelSize];
int loop_increment = 1;
if(smudgeRadius >= 8)
{
loop_increment = (2*smudgeRadius)/16;
}
int i = 0;
int k = 0;
int j = 0;
KisRandomConstAccessorSP accessor = dev->createRandomConstAccessorNG(0, 0);
KisCrossDeviceColorPickerInt colorPicker(painter.device(), color);
colorPicker.pickColor(posx, posy, color.data());
for (int y = 0; y <= smudgeRadius; y = y + loop_increment) {
for (int x = 0; x <= smudgeRadius; x = x + loop_increment) {
for(j = 0;j < 2;j++)
{
if(j == 1)
{
y = y*(-1);
}
for(k = 0;k < 2;k++)
{
if(k == 1)
{
x = x*(-1);
}
accessor->moveTo(posx + x, posy + y);
memcpy(pixels[1], accessor->rawDataConst(), pixelSize);
if(i == 0)
{
memcpy(pixels[0],accessor->rawDataConst(),pixelSize);
}
if (x == 0 && y == 0) {
// Because the sum of the weights must be 255,
// we cheat a bit, and weigh the center pixel differently in order
// to sum to 255 in total
// It's -(counts -1), because we'll add the center one implicitly
// through that calculation
weights[1] = (255 - ((i + 1) * (255 /(i+2) )) );
} else {
weights[1] = 255 /(i+2);
}
i++;
if (i>smudgeRadius){i=0;}
weights[0] = 255 - weights[1];
const quint8** cpixels = const_cast<const quint8**>(pixels);
cs->mixColorsOp()->mixColors(cpixels, weights,2, data);
memcpy(pixels[0],data,pixelSize);
}
x = x*(-1);
}
y = y*(-1);
}
}
KoColor color = KoColor(pixels[0],cs);
painter.setPaintColor(color);
for (int l = 0; l < 2; l++){
delete[] pixels[l];
}
// delete[] pixels;
delete[] data;
}
}
bool KoColorSet::init()
{
enumPaletteType format = FORMAT_UNKNOWN;
QString s = QString::fromUtf8(m_data.data(), m_data.count());
if (s.isEmpty() || s.isNull() || s.length() < 50) {
kWarning(30009) << "Illegal Gimp palette file: " << filename();
return false;
}
if (s.startsWith("RIFF") || s.startsWith("PAL data")) {
format = FORMAT_PAL;
} else if (s.startsWith("GIMP Palette")) {
// XXX: No checks for wrong input yet!
quint32 index = 0;
QStringList lines = s.split('\n', QString::SkipEmptyParts);
if (lines.size() < 3) {
return false;
}
QString entry, channel, columns;
QStringList c;
qint32 r, g, b;
QColor color;
KoColorSetEntry e;
format = FORMAT_GPL;
// Read name
if (!lines[1].startsWith("Name: ") || !lines[0].startsWith("GIMP")) {
kWarning(30009) << "Illegal Gimp palette file: " << filename();
return false;
}
setName(i18n(lines[1].mid(strlen("Name: ")).trimmed().toAscii()));
index = 2;
// Read columns
if (lines[index].startsWith("Columns: ")) {
columns = lines[index].mid(strlen("Columns: ")).trimmed();
m_columns = columns.toInt();
index = 3;
}
for (qint32 i = index; i < lines.size(); i++) {
if (lines[i].startsWith('#')) {
m_comment += lines[i].mid(1).trimmed() + ' ';
} else if (!lines[i].isEmpty()) {
QStringList a = lines[i].replace(QChar('\t'), " ").split(' ', QString::SkipEmptyParts);
if (a.count() < 3) {
break;
}
r = a[0].toInt();
a.pop_front();
g = a[0].toInt();
a.pop_front();
b = a[0].toInt();
a.pop_front();
if (r < 0 || r > 255 ||
g < 0 || g > 255 ||
b < 0 || b > 255) {
break;
}
e.color = KoColor(KoColorSpaceRegistry::instance()->rgb8());
e.color.fromQColor(QColor(r, g, b));
QString name = a.join(" ");
e.name = name.isEmpty() ? i18n("Untitled") : name;
add(e);
}
}
setValid(true);
return true;
} else if (s.length() == 768) {
kWarning(30009) << "Photoshop format palette file. Not implemented yet";
format = FORMAT_ACT;
}
return false;
}
KoColor MixerCanvas::currentColorAt(QPoint pos)
{
Q_UNUSED(pos);
return KoColor();
}
bool KoColorSet::init()
{
m_colors.clear(); // just in case this is a reload (eg by KoEditColorSetDialog),
QString s = QString::fromUtf8(m_data.data(), m_data.count());
if (s.isEmpty() || s.isNull() || s.length() < 50) {
kWarning(30009) << "Illegal Gimp palette file: " << filename();
return false;
}
if (s.startsWith("RIFF") || s.startsWith("PAL data")) {
} else if (s.startsWith("GIMP Palette")) {
// XXX: No checks for wrong input yet!
quint32 index = 0;
QStringList lines = s.split('\n', QString::SkipEmptyParts);
if (lines.size() < 3) {
return false;
}
QString entry, channel, columns;
QStringList c;
qint32 r, g, b;
QColor color;
KoColorSetEntry e;
// Read name
if (!lines[1].startsWith("Name: ") || !lines[0].startsWith("GIMP")) {
kWarning(30009) << "Illegal Gimp palette file: " << filename();
return false;
}
setName(i18n(lines[1].mid(strlen("Name: ")).trimmed().toLatin1()));
index = 2;
// Read columns
if (lines[index].startsWith("Columns: ")) {
columns = lines[index].mid(strlen("Columns: ")).trimmed();
m_columns = columns.toInt();
index = 3;
}
for (qint32 i = index; i < lines.size(); i++) {
if (lines[i].startsWith('#')) {
m_comment += lines[i].mid(1).trimmed() + ' ';
} else if (!lines[i].isEmpty()) {
QStringList a = lines[i].replace('\t', ' ').split(' ', QString::SkipEmptyParts);
if (a.count() < 3) {
break;
}
r = a[0].toInt();
a.pop_front();
g = a[0].toInt();
a.pop_front();
b = a[0].toInt();
a.pop_front();
r = qBound(0, r, 255);
g = qBound(0, g, 255);
b = qBound(0, b, 255);
e.color = KoColor(KoColorSpaceRegistry::instance()->rgb8());
e.color.fromQColor(QColor(r, g, b));
QString name = a.join(" ");
e.name = name.isEmpty() ? i18n("Untitled") : name;
add(e);
}
}
setValid(true);
return true;
} else if (s.length() == 768) {
kWarning(30009) << "Photoshop format palette file. Not implemented yet";
}
return false;
}
void KisAsyncMergerTest::testFullRefreshWithClones()
{
const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(0, 128, 128, colorSpace, "clones test");
KisPaintDeviceSP device1 = new KisPaintDevice(colorSpace);
device1->fill(image->bounds(), KoColor( Qt::white, colorSpace));
KisFilterSP filter = KisFilterRegistry::instance()->value("invert");
Q_ASSERT(filter);
KisFilterConfiguration *configuration = filter->defaultConfiguration(0);
Q_ASSERT(configuration);
KisLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8, device1);
KisFilterMaskSP invertMask1 = new KisFilterMask();
invertMask1->initSelection(0, paintLayer1);
invertMask1->setFilter(configuration);
KisLayerSP cloneLayer1 = new KisCloneLayer(paintLayer1, image, "clone_of_1", OPACITY_OPAQUE_U8);
/**
* The clone layer must have a projection to allow us
* to read what it got from its source. Just shift it.
*/
cloneLayer1->setX(10);
cloneLayer1->setY(10);
image->addNode(cloneLayer1, image->rootLayer());
image->addNode(paintLayer1, image->rootLayer());
image->addNode(invertMask1, paintLayer1);
QRect cropRect(image->bounds());
KisFullRefreshWalker walker(cropRect);
KisAsyncMerger merger;
walker.collectRects(image->rootLayer(), image->bounds());
merger.startMerge(walker);
// Wait for additional jobs generated by the clone are finished
image->waitForDone();
QRect filledRect(10, 10,
image->width() - cloneLayer1->x(),
image->height() - cloneLayer1->y());
const int pixelSize = device1->pixelSize();
const int numPixels = filledRect.width() * filledRect.height();
QByteArray bytes(numPixels * pixelSize, 13);
cloneLayer1->projection()->readBytes((quint8*)bytes.data(), filledRect);
KoColor desiredPixel(Qt::black, colorSpace);
quint8 *srcPtr = (quint8*)bytes.data();
quint8 *dstPtr = desiredPixel.data();
for(int i = 0; i < numPixels; i++) {
if(memcmp(srcPtr, dstPtr, pixelSize)) {
qDebug() << "expected:" << dstPtr[0] << dstPtr[1] << dstPtr[2] << dstPtr[3];
qDebug() << "result: " << srcPtr[0] << srcPtr[1] << srcPtr[2] << srcPtr[3];
QFAIL("Failed to compare pixels");
}
srcPtr += pixelSize;
}
}
#include "KoColorDisplayRendererInterface.h"
#include "kis_spinbox_color_selector.h"
#include "kis_dlg_internal_color_selector.h"
#include "ui_wdgdlginternalcolorselector.h"
#include "kis_config.h"
#include "kis_config_notifier.h"
#include "kis_color_input.h"
struct KisDlgInternalColorSelector::Private
{
bool allowUpdates = true;
KoColor currentColor;
KoColor previousColor;
KoColor sRGB = KoColor(KoColorSpaceRegistry::instance()->rgb8());
const KoColorSpace *currentColorSpace;
bool lockUsedCS = false;
bool chooseAlpha = false;
KisSignalCompressor *compressColorChanges;
const KoColorDisplayRendererInterface *displayRenderer;
KisHexColorInput *hexColorInput;
};
KisDlgInternalColorSelector::KisDlgInternalColorSelector(QWidget *parent, KoColor color, Config config, const QString &caption, const KoColorDisplayRendererInterface *displayRenderer)
: QDialog(parent)
,m_d(new Private)
{
setModal(config.modal);
this->setFocusPolicy(Qt::ClickFocus);
m_ui = new Ui_WdgDlgInternalColorSelector();
FlattenTestImage()
: refRect(0,0,512,512)
, p(refRect)
{
image = p.image;
layer1 = p.layer;
layer5 = new KisPaintLayer(p.image, "paint5", 0.4 * OPACITY_OPAQUE_U8);
layer5->disableAlphaChannel(true);
layer2 = new KisPaintLayer(p.image, "paint2", OPACITY_OPAQUE_U8);
tmask = new KisTransparencyMask();
// check channel flags
// make addition composite op
group1 = new KisGroupLayer(p.image, "group1", OPACITY_OPAQUE_U8);
layer3 = new KisPaintLayer(p.image, "paint3", OPACITY_OPAQUE_U8);
layer4 = new KisPaintLayer(p.image, "paint4", OPACITY_OPAQUE_U8);
layer6 = new KisPaintLayer(p.image, "paint6", OPACITY_OPAQUE_U8);
layer7 = new KisPaintLayer(p.image, "paint7", OPACITY_OPAQUE_U8);
layer8 = new KisPaintLayer(p.image, "paint8", OPACITY_OPAQUE_U8);
layer7->setCompositeOp(COMPOSITE_ADD);
layer8->setCompositeOp(COMPOSITE_ADD);
QRect rect1(100, 100, 100, 100);
QRect rect2(150, 150, 150, 150);
QRect tmaskRect(200,200,100,100);
QRect rect3(400, 100, 100, 100);
QRect rect4(500, 100, 100, 100);
QRect rect5(50, 50, 100, 100);
QRect rect6(50, 250, 100, 100);
QRect rect7(50, 350, 50, 50);
QRect rect8(50, 400, 50, 50);
layer1->paintDevice()->fill(rect1, KoColor(Qt::red, p.image->colorSpace()));
layer2->paintDevice()->fill(rect2, KoColor(Qt::green, p.image->colorSpace()));
tmask->testingInitSelection(tmaskRect);
layer3->paintDevice()->fill(rect3, KoColor(Qt::blue, p.image->colorSpace()));
layer4->paintDevice()->fill(rect4, KoColor(Qt::yellow, p.image->colorSpace()));
layer5->paintDevice()->fill(rect5, KoColor(Qt::green, p.image->colorSpace()));
layer6->paintDevice()->fill(rect6, KoColor(Qt::cyan, p.image->colorSpace()));
layer7->paintDevice()->fill(rect7, KoColor(Qt::red, p.image->colorSpace()));
layer8->paintDevice()->fill(rect8, KoColor(Qt::green, p.image->colorSpace()));
KisPSDLayerStyleSP style(new KisPSDLayerStyle());
style->dropShadow()->setEffectEnabled(true);
style->dropShadow()->setDistance(10.0);
style->dropShadow()->setSpread(80.0);
style->dropShadow()->setSize(10);
style->dropShadow()->setNoise(0);
style->dropShadow()->setKnocksOut(false);
style->dropShadow()->setOpacity(80.0);
layer2->setLayerStyle(style);
layer2->setCompositeOp(COMPOSITE_ADD);
group1->setCompositeOp(COMPOSITE_ADD);
p.image->addNode(layer5);
p.image->addNode(layer2);
p.image->addNode(tmask, layer2);
p.image->addNode(group1);
p.image->addNode(layer3, group1);
p.image->addNode(layer4, group1);
p.image->addNode(layer6);
p.image->addNode(layer7);
p.image->addNode(layer8);
p.image->initialRefreshGraph();
// dbgKrita << ppVar(layer1->exactBounds());
// dbgKrita << ppVar(layer5->exactBounds());
// dbgKrita << ppVar(layer2->exactBounds());
// dbgKrita << ppVar(group1->exactBounds());
// dbgKrita << ppVar(layer3->exactBounds());
// dbgKrita << ppVar(layer4->exactBounds());
TestUtil::ExternalImageChecker chk("flatten", "imagetest");
QVERIFY(chk.checkDevice(p.image->projection(), p.image, "00_initial"));
}
KoColor KoDumbColorDisplayRenderer::fromHsv(int h, int s, int v, int a) const
{
QColor qcolor(QColor::fromHsv(h, s, v, a));
return KoColor(qcolor, KoColorSpaceRegistry::instance()->rgb8());
}
void KisPixelSelection::select(const QRect & r, quint8 selectedness)
{
KisFillPainter painter(KisPaintDeviceSP(this));
const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
painter.fillRect(r, KoColor(Qt::white, cs), selectedness);
}
