void KisPasteNewActionFactory::run(KisView2 *view)
{
Q_UNUSED(view);
KisPaintDeviceSP clip = KisClipboard::instance()->clip(QPoint());
if (!clip) return;
QRect rect = clip->exactBounds();
if (rect.isEmpty()) return;
const QByteArray mimetype = KoServiceProvider::readNativeFormatMimeType();
KoDocumentEntry entry = KoDocumentEntry::queryByMimeType(mimetype);
QString error;
KisPart2* part = dynamic_cast<KisPart2*>(entry.createKoPart(&error));
if (!part) return;
KisDoc2 *doc = new KisDoc2(part);
if (!doc) return;
part->setDocument(doc);
KisImageSP image = new KisImage(doc->createUndoStore(),
rect.width(),
rect.height(),
clip->colorSpace(),
i18n("Pasted"));
KisPaintLayerSP layer =
new KisPaintLayer(image.data(), clip->objectName(),
OPACITY_OPAQUE_U8, clip->colorSpace());
KisPainter p(layer->paintDevice());
p.setCompositeOp(COMPOSITE_COPY);
p.bitBlt(0, 0, clip, rect.x(), rect.y(), rect.width(), rect.height());
p.end();
image->addNode(layer.data(), image->rootLayer());
doc->setCurrentImage(image);
KoMainWindow *win = new KoMainWindow(part->componentData());
win->show();
win->setRootDocument(doc);
}
KisLayerSP KisCloneLayer::reincarnateAsPaintLayer() const
{
KisPaintDeviceSP newOriginal = new KisPaintDevice(*original());
KisPaintLayerSP newLayer = new KisPaintLayer(image(), name(), opacity(), newOriginal);
newLayer->setX(newLayer->x() + x());
newLayer->setY(newLayer->y() + y());
newLayer->setCompositeOp(compositeOpId());
newLayer->mergeNodeProperties(nodeProperties());
return newLayer;
}
KisImportExportFilter::ConversionStatus KisBMPImport::convert(const QByteArray& from, const QByteArray& to)
{
dbgFile << "BMP import! From:" << from << ", To:" << to << 0;
if (to != "application/x-krita")
return KisImportExportFilter::BadMimeType;
KisDocument * doc = outputDocument();
if (!doc)
return KisImportExportFilter::NoDocumentCreated;
QString filename = inputFile();
doc->prepareForImport();
if (!filename.isEmpty()) {
QFileInfo fi(filename);
if (!fi.exists()) {
return KisImportExportFilter::FileNotFound;
}
QImage img(filename);
const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(doc->createUndoStore(), img.width(), img.height(), colorSpace, "imported from bmp");
KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), 255);
layer->paintDevice()->convertFromQImage(img, 0, 0, 0);
image->addNode(layer.data(), image->rootLayer().data());
doc->setCurrentImage(image);
return KisImportExportFilter::OK;
}
return KisImportExportFilter::StorageCreationError;
}
KisImageSP createImage(KisUndoStore *undoStore,
KisPaintLayerSP &paintLayer1,
KisPaintLayerSP &paintLayer2)
{
const KoColorSpace *cs = KoColorSpaceRegistry::instance()->rgb8();
KisImageSP image = new KisImage(undoStore, 300, 300, cs, "test");
QRect fillRect1(50,50,100,100);
QRect fillRect2(75,75,50,50);
paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
paintLayer2 = new KisPaintLayer(image, "paint2", OPACITY_OPAQUE_U8);
paintLayer1->paintDevice()->fill(fillRect1, KoColor(Qt::white, cs));
paintLayer2->paintDevice()->fill(fillRect2, KoColor(Qt::red, cs));
image->addNode(paintLayer1, image->rootLayer());
image->addNode(paintLayer2, image->rootLayer());
image->initialRefreshGraph();
return image;
}
void KisTransparencyMaskTest::testMoveMaskItself()
{
KisImageSP image;
KisPaintLayerSP layer;
KisPaintDeviceSP dev;
KisTransparencyMaskSP mask;
initImage(image, layer, dev, mask);
mask->initSelection(layer);
mask->selection()->pixelSelection()->invert();
mask->select(QRect(50, 50, 100, 100));
KisFullRefreshWalker walker(image->bounds());
KisAsyncMerger merger;
walker.collectRects(layer, image->bounds());
merger.startMerge(walker);
// image->projection()->convertToQImage(0, 0,0,300,300).save("proj_before.png");
QRect initialRect(0,0,200,100);
QCOMPARE(layer->exactBounds(), initialRect);
QCOMPARE(image->projection()->exactBounds(), QRect(50,50,100,50));
//layer->setX(100);
//layer->setY(100);
dbgKrita << "Sel. rect before:" << mask->selection()->selectedExactRect();
mask->setX(50);
mask->setY(25);
dbgKrita << "Sel. rect after:" << mask->selection()->selectedExactRect();
QCOMPARE(mask->selection()->selectedExactRect(), QRect(100, 75, 100, 100));
QCOMPARE(layer->paintDevice()->exactBounds(), initialRect);
QCOMPARE(layer->projection()->exactBounds(), QRect(50, 50, 100, 50));
dbgKrita << "";
QRect updateRect(0,0,300,300);
walker.collectRects(mask, updateRect);
merger.startMerge(walker);
// image->projection()->convertToQImage(0, 0,0,300,300).save("proj_after.png");
QCOMPARE(layer->paintDevice()->exactBounds(), initialRect);
QCOMPARE(layer->projection()->exactBounds(), QRect(100, 75, 100, 25));
}
KisImageBuilder_Result PSDLoader::decode(const KUrl& uri)
{
// open the file
QFile f(uri.toLocalFile());
if (!f.exists()) {
return KisImageBuilder_RESULT_NOT_EXIST;
}
if (!f.open(QIODevice::ReadOnly)) {
return KisImageBuilder_RESULT_FAILURE;
}
dbgFile << "pos:" << f.pos();
PSDHeader header;
if (!header.read(&f)) {
dbgFile << "failed reading header: " << header.error;
return KisImageBuilder_RESULT_FAILURE;
}
dbgFile << header;
dbgFile << "Read header. pos:" << f.pos();
PSDColorModeBlock colorModeBlock(header.colormode);
if (!colorModeBlock.read(&f)) {
dbgFile << "failed reading colormode block: " << colorModeBlock.error;
return KisImageBuilder_RESULT_FAILURE;
}
dbgFile << "Read color mode block. pos:" << f.pos();
PSDResourceSection resourceSection;
if (!resourceSection.read(&f)) {
dbgFile << "failed reading resource section: " << resourceSection.error;
return KisImageBuilder_RESULT_FAILURE;
}
dbgFile << "Read resource section. pos:" << f.pos();
PSDLayerSection layerSection(header);
if (!layerSection.read(&f)) {
dbgFile << "failed reading layer section: " << layerSection.error;
return KisImageBuilder_RESULT_FAILURE;
}
// XXX: add all the image resource blocks as annotations to the image
dbgFile << "Read layer section. " << layerSection.nLayers << "layers. pos:" << f.pos();
// Get the right colorspace
QPair<QString, QString> colorSpaceId = psd_colormode_to_colormodelid(header.colormode,
header.channelDepth);
if (colorSpaceId.first.isNull()) return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
// Get the icc profile!
const KoColorProfile* profile = 0;
if (resourceSection.resources.contains(PSDResourceSection::ICC_PROFILE)) {
ICC_PROFILE_1039 *iccProfileData = dynamic_cast<ICC_PROFILE_1039*>(resourceSection.resources[PSDResourceSection::ICC_PROFILE]->resource);
if (iccProfileData ) {
profile = KoColorSpaceRegistry::instance()->createColorProfile(colorSpaceId.first,
colorSpaceId.second,
iccProfileData->icc);
dbgFile << "Loaded ICC profile" << profile->name();
}
}
// Create the colorspace
const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceId.first, colorSpaceId.second, profile);
if (!cs) {
return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
}
// Creating the KisImageWSP
m_image = new KisImage(m_doc->createUndoStore(), header.width, header.height, cs, "built image");
Q_CHECK_PTR(m_image);
m_image->lock();
// set the correct resolution
if (resourceSection.resources.contains(PSDResourceSection::RESN_INFO)) {
RESN_INFO_1005 *resInfo = dynamic_cast<RESN_INFO_1005*>(resourceSection.resources[PSDResourceSection::RESN_INFO]->resource);
if (resInfo) {
m_image->setResolution(POINT_TO_INCH(resInfo->hRes), POINT_TO_INCH(resInfo->vRes));
// let's skip the unit for now; we can only set that on the KoDocument, and krita doesn't use it.
}
}
// Preserve the duotone colormode block for saving back to psd
if (header.colormode == DuoTone) {
KisAnnotationSP annotation = new KisAnnotation("DuotoneColormodeBlock",
i18n("Duotone Colormode Block"),
colorModeBlock.data);
m_image->addAnnotation(annotation);
}
// read the projection into our single layer
if (layerSection.nLayers == 0) {
dbgFile << "Position" << f.pos() << "Going to read the projection into the first layer, which Photoshop calls 'Background'";
KisPaintLayerSP layer = new KisPaintLayer(m_image, i18n("Background"), OPACITY_OPAQUE_U8);
KisTransaction("", layer -> paintDevice());
PSDImageData imageData(&header);
imageData.read(&f, layer->paintDevice());
//readLayerData(&f, layer->paintDevice(), f.pos(), QRect(0, 0, header.width, header.height));
m_image->addNode(layer, m_image->rootLayer());
}
else {
// read the channels for the various layers
for(int i = 0; i < layerSection.nLayers; ++i) {
// XXX: work out the group layer structure in Photoshop, as well as the adjustment layers
PSDLayerRecord* layerRecord = layerSection.layers.at(i);
dbgFile << "Going to read channels for layer" << i << layerRecord->layerName;
KisPaintLayerSP layer = new KisPaintLayer(m_image, layerRecord->layerName, layerRecord->opacity);
layer->setCompositeOp(psd_blendmode_to_composite_op(layerRecord->blendModeKey));
if (!layerRecord->readPixelData(&f, layer->paintDevice())) {
dbgFile << "failed reading channels for layer: " << layerRecord->layerName << layerRecord->error;
return KisImageBuilder_RESULT_FAILURE;
}
m_image->addNode(layer, m_image->rootLayer());
layer->setVisible(layerRecord->visible);
}
}
m_image->unlock();
return KisImageBuilder_RESULT_OK;
}
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;
}