You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1286 lines
34 KiB
1286 lines
34 KiB
/*
|
|
* Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
|
|
* Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
#include <tqrect.h>
|
|
#include <tqwmatrix.h>
|
|
#include <tqimage.h>
|
|
#include <tqdatetime.h>
|
|
#include <tqapplication.h>
|
|
#include <tqvaluelist.h>
|
|
#include <tqtimer.h>
|
|
|
|
#include <kcommand.h>
|
|
#include <tdelocale.h>
|
|
#include <kdebug.h>
|
|
|
|
#include <KoStore.h>
|
|
|
|
#include "kis_global.h"
|
|
#include "kis_types.h"
|
|
#include "kis_painter.h"
|
|
#include "kis_fill_painter.h"
|
|
#include "kis_undo_adapter.h"
|
|
#include "kis_iterator.h"
|
|
#include "kis_iterators_pixel.h"
|
|
#include "kis_iteratorpixeltrait.h"
|
|
#include "kis_random_accessor.h"
|
|
#include "kis_random_sub_accessor.h"
|
|
#include "kis_transaction.h"
|
|
#include "kis_profile.h"
|
|
#include "kis_color.h"
|
|
#include "kis_integer_maths.h"
|
|
#include "kis_colorspace_factory_registry.h"
|
|
#include "kis_selection.h"
|
|
#include "kis_layer.h"
|
|
#include "kis_paint_device_iface.h"
|
|
#include "kis_paint_device.h"
|
|
#include "kis_datamanager.h"
|
|
#include "kis_memento.h"
|
|
#include "kis_selection.h"
|
|
|
|
#include "kis_exif_info.h"
|
|
|
|
namespace {
|
|
|
|
class KisPaintDeviceCommand : public KNamedCommand {
|
|
typedef KNamedCommand super;
|
|
|
|
public:
|
|
KisPaintDeviceCommand(const TQString& name, KisPaintDeviceSP paintDevice);
|
|
virtual ~KisPaintDeviceCommand() {}
|
|
|
|
virtual void execute() = 0;
|
|
virtual void unexecute() = 0;
|
|
|
|
protected:
|
|
void setUndo(bool undo);
|
|
|
|
KisPaintDeviceSP m_paintDevice;
|
|
};
|
|
|
|
KisPaintDeviceCommand::KisPaintDeviceCommand(const TQString& name, KisPaintDeviceSP paintDevice) :
|
|
super(name), m_paintDevice(paintDevice)
|
|
{
|
|
}
|
|
|
|
void KisPaintDeviceCommand::setUndo(bool undo)
|
|
{
|
|
if (m_paintDevice->undoAdapter()) {
|
|
m_paintDevice->undoAdapter()->setUndo(undo);
|
|
}
|
|
}
|
|
|
|
class MoveCommand : public KNamedCommand {
|
|
typedef KNamedCommand super;
|
|
|
|
public:
|
|
MoveCommand(KisPaintDeviceSP device, const TQPoint& oldpos, const TQPoint& newpos);
|
|
virtual ~MoveCommand();
|
|
|
|
virtual void execute();
|
|
virtual void unexecute();
|
|
|
|
private:
|
|
void moveTo(const TQPoint& pos);
|
|
void undoOff();
|
|
void undoOn();
|
|
|
|
private:
|
|
KisPaintDeviceSP m_device;
|
|
TQPoint m_oldPos;
|
|
TQPoint m_newPos;
|
|
};
|
|
|
|
MoveCommand::MoveCommand(KisPaintDeviceSP device, const TQPoint& oldpos, const TQPoint& newpos) :
|
|
super(i18n("Move Layer"))
|
|
{
|
|
m_device = device;
|
|
m_oldPos = oldpos;
|
|
m_newPos = newpos;
|
|
}
|
|
|
|
MoveCommand::~MoveCommand()
|
|
{
|
|
}
|
|
|
|
void MoveCommand::undoOff()
|
|
{
|
|
if (m_device->undoAdapter()) {
|
|
m_device->undoAdapter()->setUndo(false);
|
|
}
|
|
}
|
|
|
|
void MoveCommand::undoOn()
|
|
{
|
|
if (m_device->undoAdapter()) {
|
|
m_device->undoAdapter()->setUndo(true);
|
|
}
|
|
}
|
|
|
|
void MoveCommand::execute()
|
|
{
|
|
undoOff();
|
|
moveTo(m_newPos);
|
|
undoOn();
|
|
}
|
|
|
|
void MoveCommand::unexecute()
|
|
{
|
|
undoOff();
|
|
moveTo(m_oldPos);
|
|
undoOn();
|
|
}
|
|
|
|
void MoveCommand::moveTo(const TQPoint& pos)
|
|
{
|
|
m_device->move(pos.x(), pos.y());
|
|
}
|
|
|
|
class KisConvertLayerTypeCmd : public KNamedCommand {
|
|
typedef KNamedCommand super;
|
|
|
|
public:
|
|
KisConvertLayerTypeCmd(KisUndoAdapter *adapter, KisPaintDeviceSP paintDevice,
|
|
KisDataManagerSP beforeData, KisColorSpace * beforeColorSpace,
|
|
KisDataManagerSP afterData, KisColorSpace * afterColorSpace
|
|
) : super(i18n("Convert Layer Type"))
|
|
{
|
|
m_adapter = adapter;
|
|
m_paintDevice = paintDevice;
|
|
m_beforeData = beforeData;
|
|
m_beforeColorSpace = beforeColorSpace;
|
|
m_afterData = afterData;
|
|
m_afterColorSpace = afterColorSpace;
|
|
}
|
|
|
|
virtual ~KisConvertLayerTypeCmd()
|
|
{
|
|
}
|
|
|
|
public:
|
|
virtual void execute()
|
|
{
|
|
m_adapter->setUndo(false);
|
|
m_paintDevice->setData(m_afterData, m_afterColorSpace);
|
|
m_adapter->setUndo(true);
|
|
}
|
|
|
|
virtual void unexecute()
|
|
{
|
|
m_adapter->setUndo(false);
|
|
m_paintDevice->setData(m_beforeData, m_beforeColorSpace);
|
|
m_adapter->setUndo(true);
|
|
}
|
|
|
|
private:
|
|
KisUndoAdapter *m_adapter;
|
|
|
|
KisPaintDeviceSP m_paintDevice;
|
|
|
|
KisDataManagerSP m_beforeData;
|
|
KisColorSpace * m_beforeColorSpace;
|
|
|
|
KisDataManagerSP m_afterData;
|
|
KisColorSpace * m_afterColorSpace;
|
|
};
|
|
|
|
}
|
|
|
|
KisPaintDevice::KisPaintDevice(KisColorSpace * colorSpace, const char * name) :
|
|
TQObject(0, name), TDEShared(), m_exifInfo(0), m_lock( false )
|
|
{
|
|
if (colorSpace == 0) {
|
|
kdWarning(41001) << "Cannot create paint device without colorstrategy!\n";
|
|
return;
|
|
}
|
|
m_longRunningFilterTimer = 0;
|
|
m_dcop = 0;
|
|
|
|
m_x = 0;
|
|
m_y = 0;
|
|
|
|
m_pixelSize = colorSpace->pixelSize();
|
|
m_nChannels = colorSpace->nChannels();
|
|
|
|
TQ_UINT8* defPixel = new TQ_UINT8 [ m_pixelSize ];
|
|
colorSpace->fromTQColor(TQt::black, OPACITY_TRANSPARENT, defPixel);
|
|
|
|
m_datamanager = new KisDataManager(m_pixelSize, defPixel);
|
|
delete [] defPixel;
|
|
|
|
TQ_CHECK_PTR(m_datamanager);
|
|
m_extentIsValid = true;
|
|
|
|
m_parentLayer = 0;
|
|
|
|
m_colorSpace = colorSpace;
|
|
|
|
m_hasSelection = false;
|
|
m_selectionDeselected = false;
|
|
m_selection = 0;
|
|
|
|
}
|
|
|
|
KisPaintDevice::KisPaintDevice(KisLayer *parent, KisColorSpace * colorSpace, const char * name) :
|
|
TQObject(0, name), TDEShared(), m_exifInfo(0), m_lock( false )
|
|
{
|
|
|
|
m_longRunningFilterTimer = 0;
|
|
m_dcop = 0;
|
|
|
|
m_x = 0;
|
|
m_y = 0;
|
|
|
|
m_hasSelection = false;
|
|
m_selectionDeselected = false;
|
|
m_selection = 0;
|
|
|
|
m_parentLayer = parent;
|
|
|
|
if (colorSpace == 0 && parent != 0 && parent->image() != 0) {
|
|
m_colorSpace = parent->image()->colorSpace();
|
|
}
|
|
else {
|
|
m_colorSpace = colorSpace;
|
|
}
|
|
|
|
Q_ASSERT( m_colorSpace );
|
|
|
|
m_pixelSize = m_colorSpace->pixelSize();
|
|
m_nChannels = m_colorSpace->nChannels();
|
|
|
|
TQ_UINT8* defPixel = new TQ_UINT8[ m_pixelSize ];
|
|
m_colorSpace->fromTQColor(TQt::black, OPACITY_TRANSPARENT, defPixel);
|
|
|
|
m_datamanager = new KisDataManager(m_pixelSize, defPixel);
|
|
delete [] defPixel;
|
|
TQ_CHECK_PTR(m_datamanager);
|
|
m_extentIsValid = true;
|
|
|
|
if ( TQString ( name ) == TQString( "Layer 1" ) ) {
|
|
m_longRunningFilters = m_colorSpace->createBackgroundFilters();
|
|
|
|
if (!m_longRunningFilters.isEmpty()) {
|
|
m_longRunningFilterTimer = new TQTimer(this);
|
|
connect(m_longRunningFilterTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(runBackgroundFilters()));
|
|
m_longRunningFilterTimer->start(2000);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
KisPaintDevice::KisPaintDevice(const KisPaintDevice& rhs) : TQObject(), TDEShared(rhs)
|
|
{
|
|
if (this != &rhs) {
|
|
m_longRunningFilterTimer = 0;
|
|
m_parentLayer = 0;
|
|
m_dcop = rhs.m_dcop;
|
|
if (rhs.m_datamanager) {
|
|
m_datamanager = new KisDataManager(*rhs.m_datamanager);
|
|
TQ_CHECK_PTR(m_datamanager);
|
|
}
|
|
else {
|
|
kdWarning() << "rhs " << rhs.name() << " has no datamanager\n";
|
|
}
|
|
m_extentIsValid = rhs.m_extentIsValid;
|
|
m_x = rhs.m_x;
|
|
m_y = rhs.m_y;
|
|
m_colorSpace = rhs.m_colorSpace;
|
|
m_hasSelection = rhs.m_hasSelection;
|
|
|
|
if ( m_hasSelection )
|
|
m_selection = new KisSelection(*rhs.m_selection);
|
|
else
|
|
m_selection = 0;
|
|
|
|
m_pixelSize = rhs.m_pixelSize;
|
|
m_nChannels = rhs.m_nChannels;
|
|
if(rhs.m_exifInfo)
|
|
{
|
|
m_exifInfo = new KisExifInfo(*rhs.m_exifInfo);
|
|
}
|
|
else {
|
|
m_exifInfo = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
KisPaintDevice::~KisPaintDevice()
|
|
{
|
|
delete m_dcop;
|
|
delete m_longRunningFilterTimer;
|
|
TQValueList<KisFilter*>::iterator it;
|
|
TQValueList<KisFilter*>::iterator end = m_longRunningFilters.end();
|
|
for (it = m_longRunningFilters.begin(); it != end; ++it) {
|
|
KisFilter * f = (*it);
|
|
delete f;
|
|
}
|
|
m_longRunningFilters.clear();
|
|
//delete m_exifInfo;
|
|
}
|
|
|
|
DCOPObject *KisPaintDevice::dcopObject()
|
|
{
|
|
if (!m_dcop) {
|
|
m_dcop = new KisPaintDeviceIface(this);
|
|
TQ_CHECK_PTR(m_dcop);
|
|
}
|
|
return m_dcop;
|
|
}
|
|
|
|
KisLayer *KisPaintDevice::parentLayer() const
|
|
{
|
|
return m_parentLayer;
|
|
}
|
|
|
|
void KisPaintDevice::setParentLayer(KisLayer *parentLayer)
|
|
{
|
|
m_parentLayer = parentLayer;
|
|
}
|
|
|
|
void KisPaintDevice::setDirty(const TQRect & rc)
|
|
{
|
|
if (m_parentLayer) m_parentLayer->setDirty(rc);
|
|
}
|
|
|
|
void KisPaintDevice::setDirty()
|
|
{
|
|
if (m_parentLayer) m_parentLayer->setDirty();
|
|
}
|
|
|
|
KisImage *KisPaintDevice::image() const
|
|
{
|
|
if (m_parentLayer) {
|
|
return m_parentLayer->image();
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
void KisPaintDevice::move(TQ_INT32 x, TQ_INT32 y)
|
|
{
|
|
TQRect dirtyRect = extent();
|
|
|
|
m_x = x;
|
|
m_y = y;
|
|
|
|
dirtyRect |= extent();
|
|
|
|
if(m_selection)
|
|
{
|
|
m_selection->setX(x);
|
|
m_selection->setY(y);
|
|
}
|
|
|
|
setDirty(dirtyRect);
|
|
|
|
emit positionChanged(this);
|
|
}
|
|
|
|
void KisPaintDevice::move(const TQPoint& pt)
|
|
{
|
|
move(pt.x(), pt.y());
|
|
}
|
|
|
|
KNamedCommand * KisPaintDevice::moveCommand(TQ_INT32 x, TQ_INT32 y)
|
|
{
|
|
KNamedCommand * cmd = new MoveCommand(this, TQPoint(m_x, m_y), TQPoint(x, y));
|
|
TQ_CHECK_PTR(cmd);
|
|
cmd->execute();
|
|
return cmd;
|
|
}
|
|
|
|
void KisPaintDevice::extent(TQ_INT32 &x, TQ_INT32 &y, TQ_INT32 &w, TQ_INT32 &h) const
|
|
{
|
|
m_datamanager->extent(x, y, w, h);
|
|
x += m_x;
|
|
y += m_y;
|
|
}
|
|
|
|
TQRect KisPaintDevice::extent() const
|
|
{
|
|
TQ_INT32 x, y, w, h;
|
|
extent(x, y, w, h);
|
|
return TQRect(x, y, w, h);
|
|
}
|
|
|
|
bool KisPaintDevice::extentIsValid() const
|
|
{
|
|
return m_extentIsValid;
|
|
}
|
|
|
|
void KisPaintDevice::setExtentIsValid(bool isValid)
|
|
{
|
|
m_extentIsValid = isValid;
|
|
}
|
|
|
|
void KisPaintDevice::exactBounds(TQ_INT32 &x, TQ_INT32 &y, TQ_INT32 &w, TQ_INT32 &h) const
|
|
{
|
|
TQRect r = exactBounds();
|
|
x = r.x();
|
|
y = r.y();
|
|
w = r.width();
|
|
h = r.height();
|
|
}
|
|
|
|
TQRect KisPaintDevice::exactBoundsOldMethod() const
|
|
{
|
|
TQ_INT32 x, y, w, h, boundX, boundY, boundW, boundH;
|
|
extent(x, y, w, h);
|
|
|
|
extent(boundX, boundY, boundW, boundH);
|
|
|
|
const TQ_UINT8* defaultPixel = m_datamanager->defaultPixel();
|
|
|
|
bool found = false;
|
|
|
|
for (TQ_INT32 y2 = y; y2 < y + h ; ++y2) {
|
|
KisHLineIterator it = const_cast<KisPaintDevice *>(this)->createHLineIterator(x, y2, w, false);
|
|
while (!it.isDone() && found == false) {
|
|
if (memcmp(it.rawData(), defaultPixel, m_pixelSize) != 0) {
|
|
boundY = y2;
|
|
found = true;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
if (found) break;
|
|
}
|
|
|
|
found = false;
|
|
|
|
for (TQ_INT32 y2 = y + h; y2 > y ; --y2) {
|
|
KisHLineIterator it = const_cast<KisPaintDevice *>(this)->createHLineIterator(x, y2, w, false);
|
|
while (!it.isDone() && found == false) {
|
|
if (memcmp(it.rawData(), defaultPixel, m_pixelSize) != 0) {
|
|
boundH = y2 - boundY + 1;
|
|
found = true;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
if (found) break;
|
|
}
|
|
found = false;
|
|
|
|
for (TQ_INT32 x2 = x; x2 < x + w ; ++x2) {
|
|
KisVLineIterator it = const_cast<KisPaintDevice *>(this)->createVLineIterator(x2, y, h, false);
|
|
while (!it.isDone() && found == false) {
|
|
if (memcmp(it.rawData(), defaultPixel, m_pixelSize) != 0) {
|
|
boundX = x2;
|
|
found = true;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
if (found) break;
|
|
}
|
|
|
|
found = false;
|
|
|
|
// Look for right edge )
|
|
for (TQ_INT32 x2 = x + w; x2 > x ; --x2) {
|
|
KisVLineIterator it = const_cast<KisPaintDevice *>(this)->createVLineIterator(x2, y, h, false);
|
|
while (!it.isDone() && found == false) {
|
|
if (memcmp(it.rawData(), defaultPixel, m_pixelSize) != 0) {
|
|
boundW = x2 - boundX + 1; // XXX: I commented this
|
|
// +1 out, but why? It
|
|
// should be correct, since
|
|
// we've found the first
|
|
// pixel that should be
|
|
// included, and it should
|
|
// be added to the width.
|
|
found = true;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
if (found) break;
|
|
}
|
|
|
|
return TQRect(boundX, boundY, boundW, boundH);
|
|
}
|
|
|
|
TQRect KisPaintDevice::exactBoundsImprovedOldMethod() const
|
|
{
|
|
// Solution n°2
|
|
TQ_INT32 x, y, w, h, boundX2, boundY2, boundW2, boundH2;
|
|
extent(x, y, w, h);
|
|
extent(boundX2, boundY2, boundW2, boundH2);
|
|
|
|
const TQ_UINT8* defaultPixel = m_datamanager->defaultPixel();
|
|
bool found = false;
|
|
{
|
|
KisHLineIterator it = const_cast<KisPaintDevice *>(this)->createHLineIterator(x, y, w, false);
|
|
for (TQ_INT32 y2 = y; y2 < y + h ; ++y2) {
|
|
while (!it.isDone() && found == false) {
|
|
if (memcmp(it.rawData(), defaultPixel, m_pixelSize) != 0) {
|
|
boundY2 = y2;
|
|
found = true;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
if (found) break;
|
|
it.nextRow();
|
|
}
|
|
}
|
|
|
|
found = false;
|
|
|
|
for (TQ_INT32 y2 = y + h; y2 > y ; --y2) {
|
|
KisHLineIterator it = const_cast<KisPaintDevice *>(this)->createHLineIterator(x, y2, w, false);
|
|
while (!it.isDone() && found == false) {
|
|
if (memcmp(it.rawData(), defaultPixel, m_pixelSize) != 0) {
|
|
boundH2 = y2 - boundY2 + 1;
|
|
found = true;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
if (found) break;
|
|
}
|
|
found = false;
|
|
|
|
{
|
|
KisVLineIterator it = const_cast<KisPaintDevice *>(this)->createVLineIterator(x, boundY2, boundH2, false);
|
|
for (TQ_INT32 x2 = x; x2 < x + w ; ++x2) {
|
|
while (!it.isDone() && found == false) {
|
|
if (memcmp(it.rawData(), defaultPixel, m_pixelSize) != 0) {
|
|
boundX2 = x2;
|
|
found = true;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
if (found) break;
|
|
it.nextCol();
|
|
}
|
|
}
|
|
|
|
found = false;
|
|
|
|
// Look for right edge )
|
|
{
|
|
for (TQ_INT32 x2 = x + w; x2 > x ; --x2) {
|
|
KisVLineIterator it = const_cast<KisPaintDevice *>(this)->createVLineIterator(/*x + w*/ x2, boundY2, boundH2, false);
|
|
while (!it.isDone() && found == false) {
|
|
if (memcmp(it.rawData(), defaultPixel, m_pixelSize) != 0) {
|
|
boundW2 = x2 - boundX2 + 1; // XXX: I commented this
|
|
// +1 out, but why? It
|
|
// should be correct, since
|
|
// we've found the first
|
|
// pixel that should be
|
|
// included, and it should
|
|
// be added to the width.
|
|
found = true;
|
|
break;
|
|
}
|
|
++it;
|
|
}
|
|
if (found) break;
|
|
}
|
|
}
|
|
return TQRect(boundX2, boundY2, boundW2, boundH2);
|
|
}
|
|
|
|
|
|
TQRect KisPaintDevice::exactBounds() const
|
|
{
|
|
TQRect r2 = exactBoundsImprovedOldMethod();
|
|
return r2;
|
|
}
|
|
|
|
void KisPaintDevice::crop(TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h)
|
|
{
|
|
m_datamanager->setExtent(x - m_x, y - m_y, w, h);
|
|
}
|
|
|
|
|
|
void KisPaintDevice::crop(TQRect r)
|
|
{
|
|
r.moveBy(-m_x, -m_y); m_datamanager->setExtent(r);
|
|
}
|
|
|
|
void KisPaintDevice::clear()
|
|
{
|
|
m_datamanager->clear();
|
|
}
|
|
|
|
void KisPaintDevice::fill(TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h, const TQ_UINT8 *fillPixel)
|
|
{
|
|
m_datamanager->clear(x, y, w, h, fillPixel);
|
|
}
|
|
|
|
void KisPaintDevice::mirrorX()
|
|
{
|
|
TQRect r;
|
|
if (hasSelection()) {
|
|
r = selection()->selectedRect();
|
|
}
|
|
else {
|
|
r = exactBounds();
|
|
}
|
|
|
|
for (TQ_INT32 y = r.top(); y <= r.bottom(); ++y) {
|
|
KisHLineIteratorPixel srcIt = createHLineIterator(r.x(), y, r.width(), false);
|
|
KisHLineIteratorPixel dstIt = createHLineIterator(r.x(), y, r.width(), true);
|
|
|
|
dstIt += r.width() - 1;
|
|
|
|
while (!srcIt.isDone()) {
|
|
if (srcIt.isSelected()) {
|
|
memcpy(dstIt.rawData(), srcIt.oldRawData(), m_pixelSize);
|
|
}
|
|
++srcIt;
|
|
--dstIt;
|
|
|
|
}
|
|
}
|
|
if (m_parentLayer) {
|
|
m_parentLayer->setDirty(r);
|
|
}
|
|
}
|
|
|
|
void KisPaintDevice::mirrorY()
|
|
{
|
|
/* Read a line from bottom to top and and from top to bottom and write their values to each other */
|
|
TQRect r;
|
|
if (hasSelection()) {
|
|
r = selection()->selectedRect();
|
|
}
|
|
else {
|
|
r = exactBounds();
|
|
}
|
|
|
|
|
|
TQ_INT32 y1, y2;
|
|
for (y1 = r.top(), y2 = r.bottom(); y1 <= r.bottom(); ++y1, --y2) {
|
|
KisHLineIteratorPixel itTop = createHLineIterator(r.x(), y1, r.width(), true);
|
|
KisHLineIteratorPixel itBottom = createHLineIterator(r.x(), y2, r.width(), false);
|
|
while (!itTop.isDone() && !itBottom.isDone()) {
|
|
if (itBottom.isSelected()) {
|
|
memcpy(itTop.rawData(), itBottom.oldRawData(), m_pixelSize);
|
|
}
|
|
++itBottom;
|
|
++itTop;
|
|
}
|
|
}
|
|
|
|
if (m_parentLayer) {
|
|
m_parentLayer->setDirty(r);
|
|
}
|
|
}
|
|
|
|
KisMementoSP KisPaintDevice::getMemento()
|
|
{
|
|
return m_datamanager->getMemento();
|
|
}
|
|
|
|
void KisPaintDevice::rollback(KisMementoSP memento) { m_datamanager->rollback(memento); }
|
|
|
|
void KisPaintDevice::rollforward(KisMementoSP memento) { m_datamanager->rollforward(memento); }
|
|
|
|
bool KisPaintDevice::write(KoStore *store)
|
|
{
|
|
bool retval = m_datamanager->write(store);
|
|
emit ioProgress(100);
|
|
|
|
return retval;
|
|
}
|
|
|
|
bool KisPaintDevice::read(KoStore *store)
|
|
{
|
|
bool retval = m_datamanager->read(store);
|
|
emit ioProgress(100);
|
|
|
|
return retval;
|
|
}
|
|
|
|
void KisPaintDevice::convertTo(KisColorSpace * dstColorSpace, TQ_INT32 renderingIntent)
|
|
{
|
|
kdDebug(41004) << "Converting " << name() << " to " << dstColorSpace->id().id() << " from "
|
|
<< m_colorSpace->id().id() << "\n";
|
|
if ( colorSpace() == dstColorSpace )
|
|
{
|
|
return;
|
|
}
|
|
|
|
KisPaintDevice dst(dstColorSpace);
|
|
dst.setX(getX());
|
|
dst.setY(getY());
|
|
|
|
TQ_INT32 x, y, w, h;
|
|
extent(x, y, w, h);
|
|
|
|
for (TQ_INT32 row = y; row < y + h; ++row) {
|
|
|
|
TQ_INT32 column = x;
|
|
TQ_INT32 columnsRemaining = w;
|
|
|
|
while (columnsRemaining > 0) {
|
|
|
|
TQ_INT32 numContiguousDstColumns = dst.numContiguousColumns(column, row, row);
|
|
TQ_INT32 numContiguousSrcColumns = numContiguousColumns(column, row, row);
|
|
|
|
TQ_INT32 columns = TQMIN(numContiguousDstColumns, numContiguousSrcColumns);
|
|
columns = TQMIN(columns, columnsRemaining);
|
|
|
|
//const TQ_UINT8 *srcData = pixel(column, row);
|
|
//TQ_UINT8 *dstData = dst.writablePixel(column, row);
|
|
KisHLineIteratorPixel srcIt = createHLineIterator(column, row, columns, false);
|
|
KisHLineIteratorPixel dstIt = dst.createHLineIterator(column, row, columns, true);
|
|
|
|
const TQ_UINT8 *srcData = srcIt.rawData();
|
|
TQ_UINT8 *dstData = dstIt.rawData();
|
|
|
|
|
|
m_colorSpace->convertPixelsTo(srcData, dstData, dstColorSpace, columns, renderingIntent);
|
|
|
|
column += columns;
|
|
columnsRemaining -= columns;
|
|
}
|
|
}
|
|
|
|
KisDataManagerSP oldData = m_datamanager;
|
|
KisColorSpace *oldColorSpace = m_colorSpace;
|
|
|
|
setData(dst.m_datamanager, dstColorSpace);
|
|
|
|
if (undoAdapter() && undoAdapter()->undo()) {
|
|
undoAdapter()->addCommand(new KisConvertLayerTypeCmd(undoAdapter(), this, oldData, oldColorSpace, m_datamanager, m_colorSpace));
|
|
}
|
|
}
|
|
|
|
void KisPaintDevice::setProfile(KisProfile * profile)
|
|
{
|
|
if (profile == 0) return;
|
|
|
|
KisColorSpace * dstSpace =
|
|
KisMetaRegistry::instance()->csRegistry()->getColorSpace( colorSpace()->id(),
|
|
profile);
|
|
if (dstSpace)
|
|
m_colorSpace = dstSpace;
|
|
|
|
}
|
|
|
|
void KisPaintDevice::setData(KisDataManagerSP data, KisColorSpace * colorSpace)
|
|
{
|
|
m_datamanager = data;
|
|
m_colorSpace = colorSpace;
|
|
m_pixelSize = m_colorSpace->pixelSize();
|
|
m_nChannels = m_colorSpace->nChannels();
|
|
|
|
if (m_parentLayer) {
|
|
m_parentLayer->setDirty(extent());
|
|
m_parentLayer->notifyPropertyChanged();
|
|
}
|
|
}
|
|
|
|
KisUndoAdapter *KisPaintDevice::undoAdapter() const
|
|
{
|
|
if (m_parentLayer && m_parentLayer->image()) {
|
|
return m_parentLayer->image()->undoAdapter();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void KisPaintDevice::convertFromTQImage(const TQImage& image, const TQString &srcProfileName,
|
|
TQ_INT32 offsetX, TQ_INT32 offsetY)
|
|
{
|
|
TQImage img = image;
|
|
|
|
// Chalk is little-endian inside.
|
|
if (img.bitOrder() == TQImage::LittleEndian) {
|
|
img = img.convertBitOrder(TQImage::BigEndian);
|
|
}
|
|
kdDebug() << k_funcinfo << img.bitOrder()<< endl;
|
|
// Chalk likes bgra (convertDepth returns *this is the img is alread 32 bits)
|
|
img = img.convertDepth( 32 );
|
|
#if 0
|
|
// XXX: Apply import profile
|
|
if (colorSpace() == KisMetaRegistry::instance()->csRegistry() ->getColorSpace(KisID("RGBA",""),"")) {
|
|
writeBytes(img.bits(), 0, 0, img.width(), img.height());
|
|
}
|
|
else {
|
|
#endif
|
|
TQ_UINT8 * dstData = new TQ_UINT8[img.width() * img.height() * pixelSize()];
|
|
KisMetaRegistry::instance()->csRegistry()
|
|
->getColorSpace(KisID("RGBA",""),srcProfileName)->
|
|
convertPixelsTo(img.bits(), dstData, colorSpace(), img.width() * img.height());
|
|
writeBytes(dstData, offsetX, offsetY, img.width(), img.height());
|
|
// }
|
|
}
|
|
|
|
TQImage KisPaintDevice::convertToTQImage(KisProfile * dstProfile, float exposure)
|
|
{
|
|
TQ_INT32 x1;
|
|
TQ_INT32 y1;
|
|
TQ_INT32 w;
|
|
TQ_INT32 h;
|
|
|
|
x1 = - getX();
|
|
y1 = - getY();
|
|
|
|
if (image()) {
|
|
w = image()->width();
|
|
h = image()->height();
|
|
}
|
|
else {
|
|
extent(x1, y1, w, h);
|
|
}
|
|
|
|
return convertToTQImage(dstProfile, x1, y1, w, h, exposure);
|
|
}
|
|
|
|
// XXX: is this faster than building the TQImage ourselves? It makes
|
|
TQImage KisPaintDevice::convertToTQImage(KisProfile * dstProfile, TQ_INT32 x1, TQ_INT32 y1, TQ_INT32 w, TQ_INT32 h, float exposure)
|
|
{
|
|
if (w < 0)
|
|
return TQImage();
|
|
|
|
if (h < 0)
|
|
return TQImage();
|
|
|
|
TQ_UINT8 * data = new TQ_UINT8 [w * h * m_pixelSize];
|
|
TQ_CHECK_PTR(data);
|
|
|
|
// XXX: Is this really faster than converting line by line and building the TQImage directly?
|
|
// This copies potentially a lot of data.
|
|
readBytes(data, x1, y1, w, h);
|
|
TQImage image = colorSpace()->convertToTQImage(data, w, h, dstProfile, INTENT_PERCEPTUAL, exposure);
|
|
delete[] data;
|
|
|
|
return image;
|
|
}
|
|
|
|
KisPaintDeviceSP KisPaintDevice::createThumbnailDevice(TQ_INT32 w, TQ_INT32 h)
|
|
{
|
|
KisPaintDeviceSP thumbnail = new KisPaintDevice(colorSpace(), "thumbnail");
|
|
|
|
thumbnail->clear();
|
|
|
|
int srcw, srch;
|
|
if( image() )
|
|
{
|
|
srcw = image()->width();
|
|
srch = image()->height();
|
|
}
|
|
else
|
|
{
|
|
const TQRect e = exactBounds();
|
|
srcw = e.width();
|
|
srch = e.height();
|
|
}
|
|
|
|
if (w > srcw)
|
|
{
|
|
w = srcw;
|
|
h = TQ_INT32(double(srcw) / w * h);
|
|
}
|
|
if (h > srch)
|
|
{
|
|
h = srch;
|
|
w = TQ_INT32(double(srch) / h * w);
|
|
}
|
|
|
|
if (srcw > srch)
|
|
h = TQ_INT32(double(srch) / srcw * w);
|
|
else if (srch > srcw)
|
|
w = TQ_INT32(double(srcw) / srch * h);
|
|
|
|
for (TQ_INT32 y=0; y < h; ++y) {
|
|
TQ_INT32 iY = (y * srch ) / h;
|
|
for (TQ_INT32 x=0; x < w; ++x) {
|
|
TQ_INT32 iX = (x * srcw ) / w;
|
|
thumbnail->setPixel(x, y, colorAt(iX, iY));
|
|
}
|
|
}
|
|
|
|
return thumbnail;
|
|
|
|
}
|
|
|
|
|
|
TQImage KisPaintDevice::createThumbnail(TQ_INT32 w, TQ_INT32 h)
|
|
{
|
|
int srcw, srch;
|
|
if( image() )
|
|
{
|
|
srcw = image()->width();
|
|
srch = image()->height();
|
|
}
|
|
else
|
|
{
|
|
const TQRect e = extent();
|
|
srcw = e.width();
|
|
srch = e.height();
|
|
}
|
|
|
|
if (w > srcw)
|
|
{
|
|
w = srcw;
|
|
h = TQ_INT32(double(srcw) / w * h);
|
|
}
|
|
if (h > srch)
|
|
{
|
|
h = srch;
|
|
w = TQ_INT32(double(srch) / h * w);
|
|
}
|
|
|
|
if (srcw > srch)
|
|
h = TQ_INT32(double(srch) / srcw * w);
|
|
else if (srch > srcw)
|
|
w = TQ_INT32(double(srcw) / srch * h);
|
|
|
|
TQColor c;
|
|
TQ_UINT8 opacity;
|
|
TQImage img(w,h,32);
|
|
|
|
for (TQ_INT32 y=0; y < h; ++y) {
|
|
TQ_INT32 iY = (y * srch ) / h;
|
|
for (TQ_INT32 x=0; x < w; ++x) {
|
|
TQ_INT32 iX = (x * srcw ) / w;
|
|
pixel(iX, iY, &c, &opacity);
|
|
const TQRgb rgb = c.rgb();
|
|
img.setPixel(x, y, tqRgba(tqRed(rgb), tqGreen(rgb), tqBlue(rgb), opacity));
|
|
}
|
|
}
|
|
|
|
return img;
|
|
}
|
|
|
|
KisRectIteratorPixel KisPaintDevice::createRectIterator(TQ_INT32 left, TQ_INT32 top, TQ_INT32 w, TQ_INT32 h, bool writable)
|
|
{
|
|
if(hasSelection())
|
|
return KisRectIteratorPixel(this, m_datamanager, m_selection->m_datamanager, left, top, w, h, m_x, m_y, writable);
|
|
else
|
|
return KisRectIteratorPixel(this, m_datamanager, NULL, left, top, w, h, m_x, m_y, writable);
|
|
}
|
|
|
|
KisHLineIteratorPixel KisPaintDevice::createHLineIterator(TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, bool writable)
|
|
{
|
|
if(hasSelection())
|
|
return KisHLineIteratorPixel(this, m_datamanager, m_selection->m_datamanager, x, y, w, m_x, m_y, writable);
|
|
else
|
|
return KisHLineIteratorPixel(this, m_datamanager, NULL, x, y, w, m_x, m_y, writable);
|
|
}
|
|
|
|
KisVLineIteratorPixel KisPaintDevice::createVLineIterator(TQ_INT32 x, TQ_INT32 y, TQ_INT32 h, bool writable)
|
|
{
|
|
if(hasSelection())
|
|
return KisVLineIteratorPixel(this, m_datamanager, m_selection->m_datamanager, x, y, h, m_x, m_y, writable);
|
|
else
|
|
return KisVLineIteratorPixel(this, m_datamanager, NULL, x, y, h, m_x, m_y, writable);
|
|
|
|
}
|
|
|
|
KisRandomAccessorPixel KisPaintDevice::createRandomAccessor(TQ_INT32 x, TQ_INT32 y, bool writable) {
|
|
if(hasSelection())
|
|
return KisRandomAccessorPixel(m_datamanager, m_selection->m_datamanager, x, y, m_x, m_y, writable);
|
|
else
|
|
return KisRandomAccessorPixel(m_datamanager, NULL, x, y, m_x, m_y, writable);
|
|
}
|
|
|
|
KisRandomSubAccessorPixel KisPaintDevice::createRandomSubAccessor()
|
|
{
|
|
return KisRandomSubAccessorPixel(this);
|
|
}
|
|
|
|
void KisPaintDevice::emitSelectionChanged()
|
|
{
|
|
if (m_parentLayer && m_parentLayer->image()) {
|
|
m_parentLayer->image()->slotSelectionChanged();
|
|
}
|
|
}
|
|
|
|
void KisPaintDevice::emitSelectionChanged(const TQRect& r)
|
|
{
|
|
if (m_parentLayer && m_parentLayer->image()) {
|
|
m_parentLayer->image()->slotSelectionChanged(r);
|
|
}
|
|
}
|
|
|
|
KisSelectionSP KisPaintDevice::selection()
|
|
{
|
|
if ( m_selectionDeselected && m_selection ) {
|
|
m_selectionDeselected = false;
|
|
}
|
|
else if (!m_selection) {
|
|
m_selection = new KisSelection(this);
|
|
TQ_CHECK_PTR(m_selection);
|
|
m_selection->setX(m_x);
|
|
m_selection->setY(m_y);
|
|
}
|
|
m_hasSelection = true;
|
|
|
|
return m_selection;
|
|
}
|
|
|
|
|
|
bool KisPaintDevice::hasSelection()
|
|
{
|
|
return m_hasSelection;
|
|
}
|
|
|
|
bool KisPaintDevice::selectionDeselected()
|
|
{
|
|
return m_selectionDeselected;
|
|
}
|
|
|
|
|
|
void KisPaintDevice::deselect()
|
|
{
|
|
if (m_selection && m_hasSelection) {
|
|
m_hasSelection = false;
|
|
m_selectionDeselected = true;
|
|
}
|
|
}
|
|
|
|
void KisPaintDevice::reselect()
|
|
{
|
|
m_hasSelection = true;
|
|
m_selectionDeselected = false;
|
|
}
|
|
|
|
void KisPaintDevice::addSelection(KisSelectionSP selection) {
|
|
|
|
KisPainter painter(this->selection().data());
|
|
TQRect r = selection->selectedExactRect();
|
|
painter.bitBlt(r.x(), r.y(), COMPOSITE_OVER, selection.data(), r.x(), r.y(), r.width(), r.height());
|
|
painter.end();
|
|
}
|
|
|
|
void KisPaintDevice::subtractSelection(KisSelectionSP selection) {
|
|
KisPainter painter(this->selection().data());
|
|
selection->invert();
|
|
|
|
TQRect r = selection->selectedExactRect();
|
|
painter.bitBlt(r.x(), r.y(), COMPOSITE_ERASE, selection.data(), r.x(), r.y(), r.width(), r.height());
|
|
|
|
selection->invert();
|
|
painter.end();
|
|
}
|
|
|
|
void KisPaintDevice::clearSelection()
|
|
{
|
|
if (!hasSelection()) return;
|
|
|
|
TQRect r = m_selection->selectedExactRect();
|
|
|
|
if (r.isValid()) {
|
|
|
|
for (TQ_INT32 y = 0; y < r.height(); y++) {
|
|
|
|
KisHLineIterator devIt = createHLineIterator(r.x(), r.y() + y, r.width(), true);
|
|
KisHLineIterator selectionIt = m_selection->createHLineIterator(r.x(), r.y() + y, r.width(), false);
|
|
|
|
while (!devIt.isDone()) {
|
|
// XXX: Optimize by using stretches
|
|
|
|
m_colorSpace->applyInverseAlphaU8Mask( devIt.rawData(), selectionIt.rawData(), 1);
|
|
|
|
++devIt;
|
|
++selectionIt;
|
|
}
|
|
}
|
|
|
|
if (m_parentLayer) {
|
|
m_parentLayer->setDirty(r);
|
|
}
|
|
}
|
|
}
|
|
|
|
void KisPaintDevice::applySelectionMask(KisSelectionSP mask)
|
|
{
|
|
TQRect r = mask->selectedRect();
|
|
crop(r);
|
|
|
|
for (TQ_INT32 y = r.top(); y <= r.bottom(); ++y) {
|
|
|
|
KisHLineIterator pixelIt = createHLineIterator(r.x(), y, r.width(), true);
|
|
KisHLineIterator maskIt = mask->createHLineIterator(r.x(), y, r.width(), false);
|
|
|
|
while (!pixelIt.isDone()) {
|
|
// XXX: Optimize by using stretches
|
|
|
|
m_colorSpace->applyAlphaU8Mask( pixelIt.rawData(), maskIt.rawData(), 1);
|
|
|
|
++pixelIt;
|
|
++maskIt;
|
|
}
|
|
}
|
|
}
|
|
|
|
KisSelectionSP KisPaintDevice::setSelection( KisSelectionSP selection)
|
|
{
|
|
if (selection) {
|
|
KisSelectionSP oldSelection = m_selection;
|
|
m_selection = selection;
|
|
m_hasSelection = true;
|
|
return oldSelection;
|
|
}
|
|
else return 0;
|
|
}
|
|
|
|
bool KisPaintDevice::pixel(TQ_INT32 x, TQ_INT32 y, TQColor *c, TQ_UINT8 *opacity)
|
|
{
|
|
KisHLineIteratorPixel iter = createHLineIterator(x, y, 1, false);
|
|
|
|
TQ_UINT8 *pix = iter.rawData();
|
|
|
|
if (!pix) return false;
|
|
|
|
colorSpace()->toTQColor(pix, c, opacity);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool KisPaintDevice::pixel(TQ_INT32 x, TQ_INT32 y, KisColor * kc)
|
|
{
|
|
KisHLineIteratorPixel iter = createHLineIterator(x, y, 1, false);
|
|
|
|
TQ_UINT8 *pix = iter.rawData();
|
|
|
|
if (!pix) return false;
|
|
|
|
kc->setColor(pix, m_colorSpace);
|
|
|
|
return true;
|
|
}
|
|
|
|
KisColor KisPaintDevice::colorAt(TQ_INT32 x, TQ_INT32 y)
|
|
{
|
|
//return KisColor(m_datamanager->pixel(x - m_x, y - m_y), m_colorSpace);
|
|
KisHLineIteratorPixel iter = createHLineIterator(x, y, 1, true);
|
|
return KisColor(iter.rawData(), m_colorSpace);
|
|
}
|
|
|
|
bool KisPaintDevice::setPixel(TQ_INT32 x, TQ_INT32 y, const TQColor& c, TQ_UINT8 opacity)
|
|
{
|
|
KisHLineIteratorPixel iter = createHLineIterator(x, y, 1, true);
|
|
|
|
colorSpace()->fromTQColor(c, opacity, iter.rawData());
|
|
|
|
return true;
|
|
}
|
|
|
|
bool KisPaintDevice::setPixel(TQ_INT32 x, TQ_INT32 y, const KisColor& kc)
|
|
{
|
|
TQ_UINT8 * pix;
|
|
if (kc.colorSpace() != m_colorSpace) {
|
|
KisColor kc2 (kc, m_colorSpace);
|
|
pix = kc2.data();
|
|
}
|
|
else {
|
|
pix = kc.data();
|
|
}
|
|
|
|
KisHLineIteratorPixel iter = createHLineIterator(x, y, 1, true);
|
|
memcpy(iter.rawData(), pix, m_colorSpace->pixelSize());
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
TQ_INT32 KisPaintDevice::numContiguousColumns(TQ_INT32 x, TQ_INT32 minY, TQ_INT32 maxY)
|
|
{
|
|
return m_datamanager->numContiguousColumns(x - m_x, minY - m_y, maxY - m_y);
|
|
}
|
|
|
|
TQ_INT32 KisPaintDevice::numContiguousRows(TQ_INT32 y, TQ_INT32 minX, TQ_INT32 maxX)
|
|
{
|
|
return m_datamanager->numContiguousRows(y - m_y, minX - m_x, maxX - m_x);
|
|
}
|
|
|
|
TQ_INT32 KisPaintDevice::rowStride(TQ_INT32 x, TQ_INT32 y)
|
|
{
|
|
return m_datamanager->rowStride(x - m_x, y - m_y);
|
|
}
|
|
|
|
const TQ_UINT8* KisPaintDevice::pixel(TQ_INT32 x, TQ_INT32 y)
|
|
{
|
|
return m_datamanager->pixel(x - m_x, y - m_y);
|
|
}
|
|
|
|
TQ_UINT8* KisPaintDevice::writablePixel(TQ_INT32 x, TQ_INT32 y)
|
|
{
|
|
return m_datamanager->writablePixel(x - m_x, y - m_y);
|
|
}
|
|
|
|
void KisPaintDevice::setX(TQ_INT32 x)
|
|
{
|
|
m_x = x;
|
|
if(m_selection && m_selection != this)
|
|
m_selection->setX(x);
|
|
}
|
|
|
|
void KisPaintDevice::setY(TQ_INT32 y)
|
|
{
|
|
m_y = y;
|
|
if(m_selection && m_selection != this)
|
|
m_selection->setY(y);
|
|
}
|
|
|
|
|
|
void KisPaintDevice::readBytes(TQ_UINT8 * data, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h)
|
|
{
|
|
m_datamanager->readBytes(data, x - m_x, y - m_y, w, h);
|
|
}
|
|
|
|
void KisPaintDevice::writeBytes(const TQ_UINT8 * data, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h)
|
|
{
|
|
m_datamanager->writeBytes( data, x - m_x, y - m_y, w, h);
|
|
}
|
|
|
|
|
|
KisDataManagerSP KisPaintDevice::dataManager() const
|
|
{
|
|
return m_datamanager;
|
|
}
|
|
|
|
KisExifInfo* KisPaintDevice::exifInfo()
|
|
{
|
|
if(!m_exifInfo)
|
|
m_exifInfo = new KisExifInfo();
|
|
return m_exifInfo;
|
|
}
|
|
|
|
void KisPaintDevice::runBackgroundFilters()
|
|
{
|
|
if ( m_lock ) return;
|
|
|
|
KisTransaction * cmd = new KisTransaction("Running autofilters", this);
|
|
|
|
TQRect rc = extent();
|
|
if (!m_longRunningFilters.isEmpty()) {
|
|
TQValueList<KisFilter*>::iterator it;
|
|
TQValueList<KisFilter*>::iterator end = m_longRunningFilters.end();
|
|
for (it = m_longRunningFilters.begin(); it != end; ++it) {
|
|
(*it)->process(this, this, 0, rc);
|
|
}
|
|
}
|
|
if (cmd && undoAdapter()) undoAdapter()->addCommand(cmd);
|
|
|
|
if (m_parentLayer) m_parentLayer->setDirty(rc);
|
|
}
|
|
|
|
#include "kis_paint_device.moc"
|