TDE
/
koffice
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/koffice
0
0
Fork 0
Code Issues Releases Wiki Activity

rename the following methods:

Browse Source 
tqparent parent
tqmask mask


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1246260 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
v3.5.13-sru
tpearson 14 years ago
parent b6edfe41c9
commit 04766b207a
2299 changed files with 10010 additions and 10010 deletions
Show Stats Download Patch File Download Diff File

6
chalk/chalkcolor/colorspaces/kis_alpha_colorspace.cc
Unescape Escape View File

@ -38,9 +38,9 @@ namespace {
const TQ_UINT8 PIXEL_MASK = 0;
}
KisAlphaColorSpace::KisAlphaColorSpace(KisColorSpaceFactoryRegistry * tqparent,
KisAlphaColorSpace::KisAlphaColorSpace(KisColorSpaceFactoryRegistry * parent,
KisProfile *p) :
KisU8BaseColorSpace(KisID("ALPHA", i18n("Alpha tqmask")), TYPE_GRAY_8, icSigGrayData, tqparent, p)
KisU8BaseColorSpace(KisID("ALPHA", i18n("Alpha mask")), TYPE_GRAY_8, icSigGrayData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Alpha"), i18n("A"), 0, KisChannelInfo::ALPHA, KisChannelInfo::UINT8));
m_alphaPos = 0;
@ -125,7 +125,7 @@ bool KisAlphaColorSpace::convertPixelsTo(const TQ_UINT8 *src,
}
//XXX bitblt of ColorSpaceAlpha does not take tqmask into consideration as this is probably not
//XXX bitblt of ColorSpaceAlpha does not take mask into consideration as this is probably not
// used ever
void KisAlphaColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dststride,

6
chalk/chalkcolor/colorspaces/kis_alpha_colorspace.h
Unescape Escape View File

@ -24,12 +24,12 @@
#include "kis_u8_base_colorspace.h"
/**
* The alpha tqmask is a special color strategy that treats all pixels as
* alpha value with a colour common to the tqmask. The default color is white.
* The alpha mask is a special color strategy that treats all pixels as
* alpha value with a colour common to the mask. The default color is white.
*/
class KisAlphaColorSpace : public KisU8BaseColorSpace {
public:
KisAlphaColorSpace(KisColorSpaceFactoryRegistry * tqparent,
KisAlphaColorSpace(KisColorSpaceFactoryRegistry * parent,
KisProfile *p);
virtual ~KisAlphaColorSpace();

64
chalk/chalkcolor/colorspaces/kis_lab_colorspace.cc
Unescape Escape View File

@ -33,10 +33,10 @@
#include "kis_color_conversions.h"
#include "kis_integer_maths.h"
KisLabColorSpace::KisLabColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p)
KisLabColorSpace::KisLabColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p)
: KisU16BaseColorSpace(KisID("LABA", i18n("L*a*b* (16-bit integer/channel)")),
COLORSPACE_SH(PT_Lab)|CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1),
icSigLabData, tqparent, p)
icSigLabData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Lightness"), i18n("L"), CHANNEL_L * sizeof(TQ_UINT16), KisChannelInfo::COLOR, KisChannelInfo::UINT16, sizeof(TQ_UINT16), TQColor(100,100,100)));
@ -267,19 +267,19 @@ void KisLabColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStrid
while (rows > 0) {
const Pixel *src = reinterpret_cast<const Pixel *>(srcRowStart);
Pixel *dst = reinterpret_cast<Pixel *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT16 srcAlpha = src->alpha;
// apply the alphatqmask
if (tqmask != 0) {
if (*tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, *tqmask);
// apply the alphamask
if (mask != 0) {
if (*mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, *mask);
}
tqmask++;
mask++;
}
if (srcAlpha != U16_OPACITY_TRANSPARENT) {
@ -351,20 +351,20 @@ void KisLabColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
TQ_UINT16 srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
d->alpha = UINT16_MULT(srcAlpha, d->alpha);
}
@ -381,7 +381,7 @@ void KisLabColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 U8_opacity,
TQ_INT32 rows,
@ -395,7 +395,7 @@ void KisLabColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
//compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -425,16 +425,16 @@ void KisLabColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
//compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
//compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
//compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, U8_opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, U8_opacity);
break;
case COMPOSITE_COPY_RED:
//compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -469,22 +469,22 @@ void KisLabColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
//compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
//compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
//compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
//compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
//compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
//compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
//compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -493,24 +493,24 @@ void KisLabColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
//compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
//compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
//compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
//compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
abstractCompositeAlphaDarken<TQ_UINT16, U16Mult, Uint8ToU16, U16OpacityTest,
CHANNEL_ALPHA, NUM_COLOR_CHANNELS, NUM_CHANNELS>(
dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride,
dst, dstRowStride, src, srcRowStride, mask, maskRowStride,
rows, cols, opacity, U16Mult(), Uint8ToU16(), U16OpacityTest());
break;
default:

32
chalk/chalkcolor/colorspaces/kis_lab_colorspace.h
Unescape Escape View File

@ -29,7 +29,7 @@
class KisLabColorSpace : public KisU16BaseColorSpace {
public:
KisLabColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisLabColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisLabColorSpace();
public:
@ -87,22 +87,22 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
/*
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
*/
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
private:
struct Pixel {
@ -145,7 +145,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigLabData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisLabColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisLabColorSpace(parent, p); };
virtual TQString defaultProfile() { return "Lab built-in - (lcms internal)"; };
};

78
chalk/chalkcolor/colorspaces/kis_xyz_colorspace.cc
Unescape Escape View File

@ -39,9 +39,9 @@
// XXX: Maybe use TYPE_XYZ_DBL for an extra stimulating performance hit? People shouldn't depend
// on this fallback...
KisXyzColorSpace::KisXyzColorSpace(KisColorSpaceFactoryRegistry * tqparent,
KisXyzColorSpace::KisXyzColorSpace(KisColorSpaceFactoryRegistry * parent,
KisProfile *p) :
KisU16BaseColorSpace(KisID("XYZA", i18n("XYZ/Alpha")), (COLORSPACE_SH(PT_XYZ)|CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)), icSigCmykData, tqparent, p)
KisU16BaseColorSpace(KisID("XYZA", i18n("XYZ/Alpha")), (COLORSPACE_SH(PT_XYZ)|CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)), icSigCmykData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("X"), i18n("X"), 0, KisChannelInfo::COLOR, KisChannelInfo::UINT8));
m_channels.push_back(new KisChannelInfo(i18n("Y"), i18n("Y"), 1, KisChannelInfo::COLOR, KisChannelInfo::UINT8));
@ -125,21 +125,21 @@ void KisXyzColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStrid
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart);
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT16 srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
if (srcAlpha != U16_OPACITY_TRANSPARENT) {
@ -198,7 +198,7 @@ void KisXyzColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStrid
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart); \
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart); \
TQ_INT32 columns = numColumns; \
const TQ_UINT8 *tqmask = maskRowStart; \
const TQ_UINT8 *mask = maskRowStart; \
\
while (columns > 0) { \
\
@ -207,13 +207,13 @@ void KisXyzColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStrid
\
srcAlpha = TQMIN(srcAlpha, dstAlpha); \
\
if (tqmask != 0) { \
TQ_UINT8 U8_tqmask = *tqmask; \
if (mask != 0) { \
TQ_UINT8 U8_mask = *mask; \
\
if (U8_tqmask != OPACITY_OPAQUE) { \
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask)); \
if (U8_mask != OPACITY_OPAQUE) { \
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask)); \
} \
tqmask++; \
mask++; \
} \
\
if (srcAlpha != U16_OPACITY_TRANSPARENT) { \
@ -437,20 +437,20 @@ void KisXyzColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
TQ_UINT16 srcAlpha = s -> alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
d -> alpha = UINT16_MULT(srcAlpha, d -> alpha);
}
@ -467,7 +467,7 @@ void KisXyzColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 U8_opacity,
TQ_INT32 rows,
@ -481,7 +481,7 @@ void KisXyzColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
//compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -510,16 +510,16 @@ void KisXyzColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
//compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, U8_opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, U8_opacity);
break;
case COMPOSITE_COPY_RED:
//compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -554,22 +554,22 @@ void KisXyzColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
//compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
//compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
//compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
//compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
//compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -578,24 +578,24 @@ void KisXyzColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
abstractCompositeAlphaDarken<TQ_UINT16, U16Mult, Uint8ToU16, U16OpacityTest,
PIXEL_ALPHA, xyz::MAX_CHANNEL_XYZ, xyz::MAX_CHANNEL_XYZA>(
dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride,
dst, dstRowStride, src, srcRowStride, mask, maskRowStride,
rows, cols, opacity, U16Mult(), Uint8ToU16(), U16OpacityTest());
break;
default:

22
chalk/chalkcolor/colorspaces/kis_xyz_colorspace.h
Unescape Escape View File

@ -43,7 +43,7 @@ public:
};
public:
KisXyzColorSpace(KisColorSpaceFactoryRegistry * tqparent,
KisXyzColorSpace(KisColorSpaceFactoryRegistry * parent,
KisProfile *p);
virtual ~KisXyzColorSpace();
@ -87,16 +87,16 @@ public:
KisCompositeOpList userVisiblecompositeOps() const;
protected:
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
private:

4
chalk/chalkcolor/kis_abstract_colorspace.cc
Unescape Escape View File

@ -63,9 +63,9 @@ class KisColorAdjustmentImpl : public KisColorAdjustment
KisAbstractColorSpace::KisAbstractColorSpace(const KisID& id,
DWORD cmType,
icColorSpaceSignature colorSpaceSignature,
KisColorSpaceFactoryRegistry * tqparent,
KisColorSpaceFactoryRegistry * parent,
KisProfile *p)
: m_parent( tqparent )
: m_parent( parent )
, m_profile( p )
, m_id( id )
, m_cmType( cmType )

16
chalk/chalkcolor/kis_abstract_colorspace.h
Unescape Escape View File

@ -53,13 +53,13 @@ public:
* @param id The unique human and machine readable identifiation of this colorspace
* @param cmType the lcms type indentification for this colorspace, may be 0
* @param colorSpaceSignature the icc identification for this colorspace, may be 0
* @param tqparent the registry that owns this instance
* @param parent the registry that owns this instance
* @param profile the profile this colorspace uses for transforms
*/
KisAbstractColorSpace(const KisID & id,
DWORD cmType,
icColorSpaceSignature colorSpaceSignature,
KisColorSpaceFactoryRegistry * tqparent,
KisColorSpaceFactoryRegistry * parent,
KisProfile *profile);
void init();
@ -229,7 +229,7 @@ protected:
const ColorType *src = reinterpret_cast<const ColorType*>(srcRowStart);
ColorType *dst = reinterpret_cast<ColorType*>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
@ -237,12 +237,12 @@ protected:
ColorType srcAlpha = src[AlphaPos];
ColorType dstAlpha = dst[AlphaPos];
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = nativeMult(srcAlpha, uint8ToNative(*tqmask));
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = nativeMult(srcAlpha, uint8ToNative(*mask));
mask++;
}
if (opacity != OPACITY_OPAQUE) {

6
chalk/chalkcolor/kis_colorspace.h
Unescape Escape View File

@ -314,14 +314,14 @@ public:
virtual void multiplyAlpha(TQ_UINT8 * pixels, TQ_UINT8 alpha, TQ_INT32 nPixels) = 0;
/**
* Applies the specified 8-bit alpha tqmask to the pixels. We assume that there are just
* Applies the specified 8-bit alpha mask to the pixels. We assume that there are just
* as many alpha values as pixels but we do not check this; the alpha values
* are assumed to be 8-bits.
*/
virtual void applyAlphaU8Mask(TQ_UINT8 * pixels, TQ_UINT8 * alpha, TQ_INT32 nPixels) = 0;
/**
* Applies the inverted 8-bit alpha tqmask to the pixels. We assume that there are just
* Applies the inverted 8-bit alpha mask to the pixels. We assume that there are just
* as many alpha values as pixels but we do not check this; the alpha values
* are assumed to be 8-bits.
*/
@ -436,7 +436,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() = 0;
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *) = 0;
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *) = 0;
/**
* Returns the default icc profile for use with this colorspace. This may be ""

6
chalk/chalkcolor/kis_colorspace_iface.cc
Unescape Escape View File

@ -24,10 +24,10 @@
#include <dcopclient.h>
KisColorSpaceIface::KisColorSpaceIface( KisColorSpace * tqparent )
: DCOPObject(tqparent->id().id().latin1())
KisColorSpaceIface::KisColorSpaceIface( KisColorSpace * parent )
: DCOPObject(parent->id().id().latin1())
{
m_parent = tqparent;
m_parent = parent;
}
TQByteArray KisColorSpaceIface::invertColor(TQByteArray src, TQ_INT32 nPixels)

2
chalk/chalkcolor/kis_colorspace_iface.h
Unescape Escape View File

@ -30,7 +30,7 @@ class KisColorSpaceIface : public DCOPObject
{
K_DCOP
public:
KisColorSpaceIface( KisColorSpace * tqparent );
KisColorSpaceIface( KisColorSpace * parent );
k_dcop:
TQByteArray invertColor(TQByteArray src, TQ_INT32 nPixels);

4
chalk/chalkcolor/kis_f16half_base_colorspace.h
Unescape Escape View File

@ -63,9 +63,9 @@ class KisF16HalfBaseColorSpace : public KisAbstractColorSpace {
public:
KisF16HalfBaseColorSpace(const KisID & id, DWORD cmType, icColorSpaceSignature colorSpaceSignature,
KisColorSpaceFactoryRegistry * tqparent,
KisColorSpaceFactoryRegistry * parent,
KisProfile *p)
: KisAbstractColorSpace(id, cmType, colorSpaceSignature, tqparent, p)
: KisAbstractColorSpace(id, cmType, colorSpaceSignature, parent, p)
{
m_alphaSize = sizeof(half);
};

4
chalk/chalkcolor/kis_f32_base_colorspace.h
Unescape Escape View File

@ -58,8 +58,8 @@ class KisF32BaseColorSpace : public KisAbstractColorSpace {
public:
KisF32BaseColorSpace(const KisID & id, DWORD cmType, icColorSpaceSignature colorSpaceSignature, KisColorSpaceFactoryRegistry * tqparent, KisProfile *p)
: KisAbstractColorSpace(id, cmType, colorSpaceSignature, tqparent, p)
KisF32BaseColorSpace(const KisID & id, DWORD cmType, icColorSpaceSignature colorSpaceSignature, KisColorSpaceFactoryRegistry * parent, KisProfile *p)
: KisAbstractColorSpace(id, cmType, colorSpaceSignature, parent, p)
{
m_alphaSize = sizeof(float);
};

4
chalk/chalkcolor/kis_u16_base_colorspace.h
Unescape Escape View File

@ -37,10 +37,10 @@ public:
public:
KisU16BaseColorSpace(const KisID & id, DWORD cmType, icColorSpaceSignature colorSpaceSignature,
KisColorSpaceFactoryRegistry * tqparent,
KisColorSpaceFactoryRegistry * parent,
KisProfile *p)
: KisAbstractColorSpace(id, cmType, colorSpaceSignature,
tqparent,
parent,
p)
{
m_alphaSize = sizeof(TQ_UINT16);

4
chalk/chalkcolor/kis_u8_base_colorspace.h
Unescape Escape View File

@ -34,9 +34,9 @@ class KisU8BaseColorSpace : public KisAbstractColorSpace {
public:
KisU8BaseColorSpace(const KisID & id, DWORD cmType, icColorSpaceSignature colorSpaceSignature,
KisColorSpaceFactoryRegistry * tqparent,
KisColorSpaceFactoryRegistry * parent,
KisProfile *p)
: KisAbstractColorSpace(id, cmType, colorSpaceSignature, tqparent, p)
: KisAbstractColorSpace(id, cmType, colorSpaceSignature, parent, p)
{
m_alphaSize = sizeof(TQ_UINT8);
};

8
chalk/colorspaces/cmyk_u16/cmyk_u16_plugin.cc
Unescape Escape View File

@ -34,14 +34,14 @@ typedef KGenericFactory<CMYKU16Plugin> CMYKU16PluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalk_cmyk_u16_plugin, CMYKU16PluginFactory( "chalk" ) )
CMYKU16Plugin::CMYKU16Plugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
CMYKU16Plugin::CMYKU16Plugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(CMYKU16PluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( tqparent );
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( parent );
KisColorSpace * colorSpaceCMYKU16 = new KisCmykU16ColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisCmykU16ColorSpaceFactory();

2
chalk/colorspaces/cmyk_u16/cmyk_u16_plugin.h
Unescape Escape View File

@ -29,7 +29,7 @@ class CMYKU16Plugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
CMYKU16Plugin(TQObject *tqparent, const char *name, const TQStringList &);
CMYKU16Plugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~CMYKU16Plugin();
};

78
chalk/colorspaces/cmyk_u16/kis_cmyk_u16_colorspace.cc
Unescape Escape View File

@ -40,8 +40,8 @@ namespace {
const TQ_INT32 MAX_CHANNEL_CMYKA = 5;
}
KisCmykU16ColorSpace::KisCmykU16ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
KisU16BaseColorSpace(KisID("CMYKA16", i18n("CMYK (16-bit integer/channel)")), TYPE_CMYK5_16, icSigCmykData, tqparent, p)
KisCmykU16ColorSpace::KisCmykU16ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisU16BaseColorSpace(KisID("CMYKA16", i18n("CMYK (16-bit integer/channel)")), TYPE_CMYK5_16, icSigCmykData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Cyan"), i18n("C"), 0 * sizeof(TQ_UINT16), KisChannelInfo::COLOR, KisChannelInfo::UINT16, sizeof(TQ_UINT16), TQt::cyan));
m_channels.push_back(new KisChannelInfo(i18n("Magenta"), i18n("M"), 1 * sizeof(TQ_UINT16), KisChannelInfo::COLOR, KisChannelInfo::UINT16, sizeof(TQ_UINT16), TQt::magenta));
@ -216,21 +216,21 @@ void KisCmykU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart);
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT16 srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
if (srcAlpha != U16_OPACITY_TRANSPARENT) {
@ -290,7 +290,7 @@ void KisCmykU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart); \
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart); \
TQ_INT32 columns = numColumns; \
const TQ_UINT8 *tqmask = maskRowStart; \
const TQ_UINT8 *mask = maskRowStart; \
\
while (columns > 0) { \
\
@ -299,13 +299,13 @@ void KisCmykU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
\
srcAlpha = TQMIN(srcAlpha, dstAlpha); \
\
if (tqmask != 0) { \
TQ_UINT8 U8_tqmask = *tqmask; \
if (mask != 0) { \
TQ_UINT8 U8_mask = *mask; \
\
if (U8_tqmask != OPACITY_OPAQUE) { \
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask)); \
if (U8_mask != OPACITY_OPAQUE) { \
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask)); \
} \
tqmask++; \
mask++; \
} \
\
if (srcAlpha != U16_OPACITY_TRANSPARENT) { \
@ -528,20 +528,20 @@ void KisCmykU16ColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
TQ_UINT16 srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
d->alpha = UINT16_MULT(srcAlpha, d->alpha);
}
@ -559,7 +559,7 @@ void KisCmykU16ColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 U8_opacity,
TQ_INT32 rows,
@ -573,7 +573,7 @@ void KisCmykU16ColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
//compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -602,16 +602,16 @@ void KisCmykU16ColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
//compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, U8_opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, U8_opacity);
break;
case COMPOSITE_COPY_CYAN:
//compositeCopyCyan(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -646,22 +646,22 @@ void KisCmykU16ColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
//compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
//compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
//compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
//compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
//compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -670,24 +670,24 @@ void KisCmykU16ColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
abstractCompositeAlphaDarken<TQ_UINT16, U16Mult, Uint8ToU16, U16OpacityTest,
PIXEL_ALPHA, MAX_CHANNEL_CMYK, MAX_CHANNEL_CMYKA>(
dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride,
dst, dstRowStride, src, srcRowStride, mask, maskRowStride,
rows, cols, opacity, U16Mult(), Uint8ToU16(), U16OpacityTest());
break;
default:

24
chalk/colorspaces/cmyk_u16/kis_cmyk_u16_colorspace.h
Unescape Escape View File

@ -39,7 +39,7 @@ public:
};
public:
KisCmykU16ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisCmykU16ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisCmykU16ColorSpace();
virtual bool willDegrade(ColorSpaceIndependence independence)
@ -78,16 +78,16 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
private:
friend class KisCmykU16ColorSpaceTester;
@ -115,7 +115,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigCmykData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisCmykU16ColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisCmykU16ColorSpace(parent, p); };
virtual TQString defaultProfile() { return "Offset printing, according to ISO/DIS 12647-2:2004, OFCOM, paper type 1 or 2 = coated art, 115 g/m2, screen ruling 60 cm-1, positive-acting plates"; };
};

8
chalk/colorspaces/cmyk_u8/cmyk_plugin.cc
Unescape Escape View File

@ -39,13 +39,13 @@ typedef KGenericFactory<CMYKPlugin> CMYKPluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalkcmykplugin, CMYKPluginFactory( "chalk" ) )
CMYKPlugin::CMYKPlugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
CMYKPlugin::CMYKPlugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(CMYKPluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( tqparent );
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( parent );
KisColorSpace * colorSpaceCMYK = new KisCmykColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisCmykColorSpaceFactory();

2
chalk/colorspaces/cmyk_u8/cmyk_plugin.h
Unescape Escape View File

@ -29,7 +29,7 @@ class CMYKPlugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
CMYKPlugin(TQObject *tqparent, const char *name, const TQStringList &);
CMYKPlugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~CMYKPlugin();

78
chalk/colorspaces/cmyk_u8/kis_cmyk_colorspace.cc
Unescape Escape View File

@ -37,8 +37,8 @@ namespace cmyk {
const TQ_INT32 MAX_CHANNEL_CMYKA = 5;
}
KisCmykColorSpace::KisCmykColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
KisU8BaseColorSpace(KisID("CMYK", i18n("CMYK")), TYPE_CMYK5_8, icSigCmykData, tqparent, p)
KisCmykColorSpace::KisCmykColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisU8BaseColorSpace(KisID("CMYK", i18n("CMYK")), TYPE_CMYK5_8, icSigCmykData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Cyan"), i18n("C"), 0, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQt::cyan));
m_channels.push_back(new KisChannelInfo(i18n("Magenta"), i18n("M"), 1, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQt::magenta));
@ -214,21 +214,21 @@ void KisCmykColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_CMYK_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(srcAlpha, U8_tqmask);
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT8_MULT(srcAlpha, U8_mask);
}
tqmask++;
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -288,7 +288,7 @@ void KisCmykColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
const TQ_UINT8 *src = srcRowStart; \
TQ_UINT8 *dst = dstRowStart; \
TQ_INT32 columns = numColumns; \
const TQ_UINT8 *tqmask = maskRowStart; \
const TQ_UINT8 *mask = maskRowStart; \
\
while (columns > 0) { \
\
@ -297,13 +297,13 @@ void KisCmykColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
\
srcAlpha = TQMIN(srcAlpha, dstAlpha); \
\
if (tqmask != 0) { \
TQ_UINT8 U8_tqmask = *tqmask; \
if (mask != 0) { \
TQ_UINT8 U8_mask = *mask; \
\
if (U8_tqmask != OPACITY_OPAQUE) { \
srcAlpha = UINT8_MULT(srcAlpha, U8_tqmask); \
if (U8_mask != OPACITY_OPAQUE) { \
srcAlpha = UINT8_MULT(srcAlpha, U8_mask); \
} \
tqmask++; \
mask++; \
} \
\
if (srcAlpha != OPACITY_TRANSPARENT) { \
@ -526,20 +526,20 @@ void KisCmykColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
TQ_UINT8 srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, U8_tqmask);
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, U8_mask);
}
tqmask++;
mask++;
}
d->alpha = UINT8_MULT(srcAlpha, d->alpha);
}
@ -556,7 +556,7 @@ void KisCmykColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 opacity,
TQ_INT32 rows,
@ -569,7 +569,7 @@ void KisCmykColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
//compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -598,16 +598,16 @@ void KisCmykColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
//compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY_CYAN:
//compositeCopyCyan(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -642,22 +642,22 @@ void KisCmykColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
//compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
//compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
//compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
//compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
//compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -666,24 +666,24 @@ void KisCmykColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
abstractCompositeAlphaDarken<TQ_UINT8, U8Mult, Uint8ToU8, U8OpacityTest,
PIXEL_CMYK_ALPHA, cmyk::MAX_CHANNEL_CMYK, cmyk::MAX_CHANNEL_CMYKA>(
dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride,
dst, dstRowStride, src, srcRowStride, mask, maskRowStride,
rows, cols, opacity, U8Mult(), Uint8ToU8(), U8OpacityTest());
break;
default:

24
chalk/colorspaces/cmyk_u8/kis_cmyk_colorspace.h
Unescape Escape View File

@ -37,7 +37,7 @@ public:
TQ_UINT16 alpha;
};
public:
KisCmykColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisCmykColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisCmykColorSpace();
@ -80,16 +80,16 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
private:
@ -118,7 +118,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigCmykData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisCmykColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisCmykColorSpace(parent, p); };
virtual TQString defaultProfile() { return "Offset printing, according to ISO/DIS 12647-2:2004, OFCOM, paper type 1 or 2 = coated art, 115 g/m2, screen ruling 60 cm-1, positive-acting plates"; }; // Do not i18n -- this is from a data file
};

8
chalk/colorspaces/gray_u16/gray_u16_plugin.cc
Unescape Escape View File

@ -35,14 +35,14 @@ typedef KGenericFactory<GRAYU16Plugin> GRAYU16PluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalk_gray_u16_plugin, GRAYU16PluginFactory( "chalk" ) )
GRAYU16Plugin::GRAYU16Plugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
GRAYU16Plugin::GRAYU16Plugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(GRAYU16PluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( tqparent );
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( parent );
KisColorSpace * colorSpaceGRAYU16 = new KisGrayU16ColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisGrayU16ColorSpaceFactory();

2
chalk/colorspaces/gray_u16/gray_u16_plugin.h
Unescape Escape View File

@ -29,7 +29,7 @@ class GRAYU16Plugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
GRAYU16Plugin(TQObject *tqparent, const char *name, const TQStringList &);
GRAYU16Plugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~GRAYU16Plugin();
};

78
chalk/colorspaces/gray_u16/kis_gray_u16_colorspace.cc
Unescape Escape View File

@ -39,8 +39,8 @@ namespace {
const TQ_INT32 MAX_CHANNEL_GRAYA = 2;
}
KisGrayU16ColorSpace::KisGrayU16ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
KisU16BaseColorSpace(KisID("GRAYA16", i18n("Grayscale (16-bit integer/channel)")), TYPE_GRAYA_16, icSigGrayData, tqparent, p)
KisGrayU16ColorSpace::KisGrayU16ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisU16BaseColorSpace(KisID("GRAYA16", i18n("Grayscale (16-bit integer/channel)")), TYPE_GRAYA_16, icSigGrayData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Gray"), i18n("G"), PIXEL_GRAY * sizeof(TQ_UINT16), KisChannelInfo::COLOR, KisChannelInfo::UINT16, sizeof(TQ_UINT16)));
m_channels.push_back(new KisChannelInfo(i18n("Alpha"), i18n("A"), PIXEL_ALPHA * sizeof(TQ_UINT16), KisChannelInfo::ALPHA, KisChannelInfo::UINT16, sizeof(TQ_UINT16)));
@ -167,21 +167,21 @@ void KisGrayU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart);
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT16 srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
if (srcAlpha != U16_OPACITY_TRANSPARENT) {
@ -238,7 +238,7 @@ void KisGrayU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart); \
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart); \
TQ_INT32 columns = numColumns; \
const TQ_UINT8 *tqmask = maskRowStart; \
const TQ_UINT8 *mask = maskRowStart; \
\
while (columns > 0) { \
\
@ -247,13 +247,13 @@ void KisGrayU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
\
srcAlpha = TQMIN(srcAlpha, dstAlpha); \
\
if (tqmask != 0) { \
TQ_UINT8 U8_tqmask = *tqmask; \
if (mask != 0) { \
TQ_UINT8 U8_mask = *mask; \
\
if (U8_tqmask != OPACITY_OPAQUE) { \
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask)); \
if (U8_mask != OPACITY_OPAQUE) { \
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask)); \
} \
tqmask++; \
mask++; \
} \
\
if (srcAlpha != U16_OPACITY_TRANSPARENT) { \
@ -473,20 +473,20 @@ void KisGrayU16ColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
TQ_UINT16 srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
d->alpha = UINT16_MULT(srcAlpha, d->alpha);
}
@ -503,7 +503,7 @@ void KisGrayU16ColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 U8_opacity,
TQ_INT32 rows,
@ -517,7 +517,7 @@ void KisGrayU16ColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
//compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -546,16 +546,16 @@ void KisGrayU16ColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
//compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, U8_opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, U8_opacity);
break;
case COMPOSITE_COPY_RED:
//compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -590,22 +590,22 @@ void KisGrayU16ColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
//compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
//compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
//compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
//compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
//compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
//compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -614,24 +614,24 @@ void KisGrayU16ColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
abstractCompositeAlphaDarken<TQ_UINT16, U16Mult, Uint8ToU16, U16OpacityTest,
PIXEL_ALPHA, MAX_CHANNEL_GRAY, MAX_CHANNEL_GRAYA>(
dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride,
dst, dstRowStride, src, srcRowStride, mask, maskRowStride,
rows, cols, opacity, U16Mult(), Uint8ToU16(), U16OpacityTest());
break;
default:

24
chalk/colorspaces/gray_u16/kis_gray_u16_colorspace.h
Unescape Escape View File

@ -46,7 +46,7 @@ public:
public:
KisGrayU16ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisGrayU16ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisGrayU16ColorSpace();
public:
@ -76,16 +76,16 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
private:
friend class KisGrayU16ColorSpaceTester;
@ -110,7 +110,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigGrayData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisGrayU16ColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisGrayU16ColorSpace(parent, p); };
virtual TQString defaultProfile() { return "gray built-in - (lcms internal)"; };
};

8
chalk/colorspaces/gray_u8/gray_plugin.cc
Unescape Escape View File

@ -37,16 +37,16 @@ typedef KGenericFactory<GrayPlugin> GrayPluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalkgrayplugin, GrayPluginFactory( "chalkcore" ) )
GrayPlugin::GrayPlugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
GrayPlugin::GrayPlugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(GrayPluginFactory::instance());
// This is not a gui plugin; only load it when the doc is created.
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( tqparent );
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( parent );
// .22 gamma grayscale or something like that. Taken from the lcms tutorial...
LPGAMMATABLE Gamma = cmsBuildGamma(256, 2.2);

2
chalk/colorspaces/gray_u8/gray_plugin.h
Unescape Escape View File

@ -29,7 +29,7 @@ class GrayPlugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
GrayPlugin(TQObject *tqparent, const char *name, const TQStringList &);
GrayPlugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~GrayPlugin();
};

162
chalk/colorspaces/gray_u8/kis_gray_colorspace.cc
Unescape Escape View File

@ -43,8 +43,8 @@ namespace {
const TQ_INT32 MAX_CHANNEL_GRAYSCALEA = 2;
}
KisGrayColorSpace::KisGrayColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
KisU8BaseColorSpace(KisID("GRAYA", i18n("Grayscale")), TYPE_GRAYA_8, icSigGrayData, tqparent, p)
KisGrayColorSpace::KisGrayColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisU8BaseColorSpace(KisID("GRAYA", i18n("Grayscale")), TYPE_GRAYA_8, icSigGrayData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Gray"), i18n("G"), 0, KisChannelInfo::COLOR, KisChannelInfo::UINT8));
m_channels.push_back(new KisChannelInfo(i18n("Alpha"), i18n("A"), 1, KisChannelInfo::ALPHA, KisChannelInfo::UINT8));
@ -199,7 +199,7 @@ void KisGrayColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 opacity,
TQ_INT32 rows,
@ -208,37 +208,37 @@ void KisGrayColorSpace::bitBlt(TQ_UINT8 *dst,
{
switch (op.op()) {
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_CLEAR: {
TQ_UINT8 *d;
@ -253,7 +253,7 @@ void KisGrayColorSpace::bitBlt(TQ_UINT8 *dst,
}
break;
case COMPOSITE_ALPHA_DARKEN:
compositeAlphaDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeAlphaDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
default:
@ -285,18 +285,18 @@ void KisGrayColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -353,7 +353,7 @@ void KisGrayColorSpace::compositeMultiply(TQ_UINT8 *dstRowStart, TQ_INT32 dstRow
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -362,12 +362,12 @@ void KisGrayColorSpace::compositeMultiply(TQ_UINT8 *dstRowStart, TQ_INT32 dstRow
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -419,7 +419,7 @@ void KisGrayColorSpace::compositeDivide(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -428,12 +428,12 @@ void KisGrayColorSpace::compositeDivide(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -490,7 +490,7 @@ void KisGrayColorSpace::compositeScreen(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -499,12 +499,12 @@ void KisGrayColorSpace::compositeScreen(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -561,7 +561,7 @@ void KisGrayColorSpace::compositeOverlay(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -570,12 +570,12 @@ void KisGrayColorSpace::compositeOverlay(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -632,7 +632,7 @@ void KisGrayColorSpace::compositeDodge(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStr
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -641,12 +641,12 @@ void KisGrayColorSpace::compositeDodge(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStr
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -703,7 +703,7 @@ void KisGrayColorSpace::compositeBurn(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -712,12 +712,12 @@ void KisGrayColorSpace::compositeBurn(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -775,7 +775,7 @@ void KisGrayColorSpace::compositeDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -784,12 +784,12 @@ void KisGrayColorSpace::compositeDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -846,7 +846,7 @@ void KisGrayColorSpace::compositeLighten(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -855,12 +855,12 @@ void KisGrayColorSpace::compositeLighten(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -927,17 +927,17 @@ void KisGrayColorSpace::compositeErase(TQ_UINT8 *dst,
{
const TQ_UINT8 *s = src;
TQ_UINT8 *d = dst;
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (i = cols; i > 0; i--, s+=MAX_CHANNEL_GRAYSCALEA, d+=MAX_CHANNEL_GRAYSCALEA)
{
srcAlpha = s[PIXEL_GRAY_ALPHA];
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, *mask);
mask++;
}
d[PIXEL_GRAY_ALPHA] = UINT8_MULT(srcAlpha, d[PIXEL_GRAY_ALPHA]);
}
@ -958,7 +958,7 @@ void KisGrayColorSpace::compositeAlphaDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dst
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
@ -966,12 +966,12 @@ void KisGrayColorSpace::compositeAlphaDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dst
TQ_UINT8 srcAlpha = src[PIXEL_GRAY_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_GRAY_ALPHA];
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (opacity != OPACITY_OPAQUE) {

26
chalk/colorspaces/gray_u8/kis_gray_colorspace.h
Unescape Escape View File

@ -29,7 +29,7 @@
class KRITACORE_EXPORT KisGrayColorSpace : public KisU8BaseColorSpace {
public:
KisGrayColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisGrayColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisGrayColorSpace();
virtual bool willDegrade(ColorSpaceIndependence /*independence*/)
@ -70,17 +70,17 @@ public:
KisCompositeOpList userVisiblecompositeOps() const;
protected:
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeAlphaDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeAlphaDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
private:
@ -106,7 +106,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigGrayData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisGrayColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisGrayColorSpace(parent, p); };
virtual TQString defaultProfile() { return "gray built-in - (lcms internal)"; };
};

40
chalk/colorspaces/lms_f32/kis_lms_f32_colorspace.cc
Unescape Escape View File

@ -48,8 +48,8 @@ namespace {
#define F32_LCMS_TYPE TYPE_BGRA_16
// disable the lcms handling by setting profile=0
KisLmsF32ColorSpace::KisLmsF32ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile */*p*/) :
KisF32BaseColorSpace(KisID("LMSAF32", i18n("LMS (32-bit float/channel)")), F32_LCMS_TYPE, icSig3colorData, tqparent, 0)
KisLmsF32ColorSpace::KisLmsF32ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile */*p*/) :
KisF32BaseColorSpace(KisID("LMSAF32", i18n("LMS (32-bit float/channel)")), F32_LCMS_TYPE, icSig3colorData, parent, 0)
{
m_channels.push_back(new KisChannelInfo(i18n("Long"), i18n("L"), PIXEL_LONGWAVE * sizeof(float), KisChannelInfo::COLOR, KisChannelInfo::FLOAT32, sizeof(float)));
m_channels.push_back(new KisChannelInfo(i18n("Middle"), i18n("M"), PIXEL_MIDDLEWAVE * sizeof(float), KisChannelInfo::COLOR, KisChannelInfo::FLOAT32, sizeof(float)));
@ -226,21 +226,21 @@ void KisLmsF32ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const float *src = reinterpret_cast<const float *>(srcRowStart);
float *dst = reinterpret_cast<float *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
float srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha *= UINT8_TO_FLOAT(U8_tqmask);
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha *= UINT8_TO_FLOAT(U8_mask);
}
tqmask++;
mask++;
}
if (srcAlpha > F32_OPACITY_TRANSPARENT + EPSILON) {
@ -307,20 +307,20 @@ void KisLmsF32ColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
float srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = FLOAT_BLEND(srcAlpha, F32_OPACITY_OPAQUE, UINT8_TO_FLOAT(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = FLOAT_BLEND(srcAlpha, F32_OPACITY_OPAQUE, UINT8_TO_FLOAT(U8_mask));
}
tqmask++;
mask++;
}
d->alpha = srcAlpha * d->alpha;
}
@ -348,7 +348,7 @@ void KisLmsF32ColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 U8_opacity,
TQ_INT32 rows,
@ -362,13 +362,13 @@ void KisLmsF32ColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
default:
break;

10
chalk/colorspaces/lms_f32/kis_lms_f32_colorspace.h
Unescape Escape View File

@ -34,7 +34,7 @@ class KisColorSpaceFactoryRegistry;
class KRITATOOL_EXPORT KisLmsF32ColorSpace : public KisF32BaseColorSpace {
public:
KisLmsF32ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisLmsF32ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisLmsF32ColorSpace();
virtual bool willDegrade(ColorSpaceIndependence independence)
@ -87,9 +87,9 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeCopy(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeCopy(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
private:
inline TQ_UINT8 computeRed(float l, float m, float s) const
@ -148,7 +148,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icMaxEnumData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisLmsF32ColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisLmsF32ColorSpace(parent, p); };
virtual TQString defaultProfile() { return "sRGB built-in - (lcms internal)"; };
};

8
chalk/colorspaces/lms_f32/lms_f32_plugin.cc
Unescape Escape View File

@ -36,14 +36,14 @@ typedef KGenericFactory<LMSF32Plugin> LMSF32PluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalk_lms_f32_plugin, LMSF32PluginFactory( "chalk" ) )
LMSF32Plugin::LMSF32Plugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
LMSF32Plugin::LMSF32Plugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(LMSF32PluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>(tqparent);
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>(parent);
KisColorSpace * colorSpaceLMSF32 = new KisLmsF32ColorSpace(f, 0);

2
chalk/colorspaces/lms_f32/lms_f32_plugin.h
Unescape Escape View File

@ -31,7 +31,7 @@ class LMSF32Plugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
LMSF32Plugin(TQObject *tqparent, const char *name, const TQStringList &);
LMSF32Plugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~LMSF32Plugin();
};

78
chalk/colorspaces/rgb_f16half/kis_rgb_f16half_colorspace.cc
Unescape Escape View File

@ -50,8 +50,8 @@ namespace {
// FIXME: lcms doesn't support 16-bit float
#define RGBAF16HALF_LCMS_TYPE TYPE_BGRA_16
KisRgbF16HalfColorSpace::KisRgbF16HalfColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
KisF16HalfBaseColorSpace(KisID("RGBAF16HALF", i18n("RGB (16-bit float/channel)")), RGBAF16HALF_LCMS_TYPE, icSigRgbData, tqparent, p)
KisRgbF16HalfColorSpace::KisRgbF16HalfColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisF16HalfBaseColorSpace(KisID("RGBAF16HALF", i18n("RGB (16-bit float/channel)")), RGBAF16HALF_LCMS_TYPE, icSigRgbData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Red"), i18n("R"), PIXEL_RED * sizeof(half), KisChannelInfo::COLOR, KisChannelInfo::FLOAT16, sizeof(half)));
m_channels.push_back(new KisChannelInfo(i18n("Green"), i18n("G"), PIXEL_GREEN * sizeof(half), KisChannelInfo::COLOR, KisChannelInfo::FLOAT16, sizeof(half)));
@ -305,21 +305,21 @@ void KisRgbF16HalfColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstR
const half *src = reinterpret_cast<const half *>(srcRowStart);
half *dst = reinterpret_cast<half *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
half srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha *= UINT8_TO_HALF(U8_tqmask);
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha *= UINT8_TO_HALF(U8_mask);
}
tqmask++;
mask++;
}
if (srcAlpha > F16HALF_OPACITY_TRANSPARENT + EPSILON) {
@ -378,7 +378,7 @@ void KisRgbF16HalfColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstR
const half *src = reinterpret_cast<const half *>(srcRowStart); \
half *dst = reinterpret_cast<half *>(dstRowStart); \
TQ_INT32 columns = numColumns; \
const TQ_UINT8 *tqmask = maskRowStart; \
const TQ_UINT8 *mask = maskRowStart; \
\
while (columns > 0) { \
\
@ -387,13 +387,13 @@ void KisRgbF16HalfColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstR
\
srcAlpha = TQMIN(srcAlpha, dstAlpha); \
\
if (tqmask != 0) { \
TQ_UINT8 U8_tqmask = *tqmask; \
if (mask != 0) { \
TQ_UINT8 U8_mask = *mask; \
\
if (U8_tqmask != OPACITY_OPAQUE) { \
srcAlpha *= UINT8_TO_HALF(U8_tqmask); \
if (U8_mask != OPACITY_OPAQUE) { \
srcAlpha *= UINT8_TO_HALF(U8_mask); \
} \
tqmask++; \
mask++; \
} \
\
if (srcAlpha > F16HALF_OPACITY_TRANSPARENT + EPSILON) { \
@ -761,20 +761,20 @@ void KisRgbF16HalfColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
half srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = HALF_BLEND(srcAlpha, F16HALF_OPACITY_OPAQUE, UINT8_TO_HALF(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = HALF_BLEND(srcAlpha, F16HALF_OPACITY_OPAQUE, UINT8_TO_HALF(U8_mask));
}
tqmask++;
mask++;
}
d->alpha = srcAlpha * d->alpha;
}
@ -791,7 +791,7 @@ void KisRgbF16HalfColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 U8_opacity,
TQ_INT32 rows,
@ -805,7 +805,7 @@ void KisRgbF16HalfColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
//compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -834,16 +834,16 @@ void KisRgbF16HalfColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
//compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, U8_opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, U8_opacity);
break;
case COMPOSITE_COPY_RED:
//compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -878,22 +878,22 @@ void KisRgbF16HalfColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
//compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -902,24 +902,24 @@ void KisRgbF16HalfColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
abstractCompositeAlphaDarken<half, F16HalfMult, Uint8ToF16Half, F16HalfOpacityTest,
PIXEL_ALPHA, MAX_CHANNEL_RGB, MAX_CHANNEL_RGBA>(
dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride,
dst, dstRowStride, src, srcRowStride, mask, maskRowStride,
rows, cols,
U8_opacity, F16HalfMult(), Uint8ToF16Half(), F16HalfOpacityTest());
break;

32
chalk/colorspaces/rgb_f16half/kis_rgb_f16half_colorspace.h
Unescape Escape View File

@ -31,7 +31,7 @@
class KRITATOOL_EXPORT KisRgbF16HalfColorSpace : public KisF16HalfBaseColorSpace {
public:
KisRgbF16HalfColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisRgbF16HalfColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisRgbF16HalfColorSpace();
virtual bool willDegrade(ColorSpaceIndependence independence)
@ -85,20 +85,20 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, half opacity);
private:
friend class KisRgbF16HalfColorSpaceTester;
@ -135,7 +135,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigRgbData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisRgbF16HalfColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisRgbF16HalfColorSpace(parent, p); };
virtual TQString defaultProfile() { return "sRGB built-in - (lcms internal)"; };
};

8
chalk/colorspaces/rgb_f16half/rgb_f16half_plugin.cc
Unescape Escape View File

@ -35,14 +35,14 @@ typedef KGenericFactory<RGBF16HalfPlugin> RGBF16HalfPluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalk_rgb_f16half_plugin, RGBF16HalfPluginFactory( "chalk" ) )
RGBF16HalfPlugin::RGBF16HalfPlugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
RGBF16HalfPlugin::RGBF16HalfPlugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(RGBF16HalfPluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( tqparent );
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( parent );
KisColorSpace * colorSpaceRGBF16Half = new KisRgbF16HalfColorSpace(f, 0);
KisColorSpaceFactory *csf = new KisRgbF16HalfColorSpaceFactory();

2
chalk/colorspaces/rgb_f16half/rgb_f16half_plugin.h
Unescape Escape View File

@ -30,7 +30,7 @@ class RGBF16HalfPlugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
RGBF16HalfPlugin(TQObject *tqparent, const char *name, const TQStringList &);
RGBF16HalfPlugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~RGBF16HalfPlugin();
};

2
chalk/colorspaces/rgb_f16half/tests/kis_rgb_f16half_colorspace_tester.cc
Unescape Escape View File

@ -537,7 +537,7 @@ void KisRgbF16HalfColorSpaceTester::testCompositeOps()
};
cs->compositeOver(reinterpret_cast<TQ_UINT8 *>(dstPixels), DST_ROW_STRIDE, reinterpret_cast<const TQ_UINT8 *>(srcPixels),
SRC_ROW_STRIDE, tqmask, MASK_ROW_STRIDE, NUM_ROWS, NUM_COLUMNS, opacity);
SRC_ROW_STRIDE, mask, MASK_ROW_STRIDE, NUM_ROWS, NUM_COLUMNS, opacity);
*/
delete cs;

78
chalk/colorspaces/rgb_f32/kis_rgb_f32_colorspace.cc
Unescape Escape View File

@ -52,8 +52,8 @@ namespace {
#define F32_LCMS_TYPE TYPE_BGRA_16
// disable the lcms handling by setting profile=0
KisRgbF32ColorSpace::KisRgbF32ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile */*p*/) :
KisF32BaseColorSpace(KisID("RGBAF32", i18n("RGB (32-bit float/channel)")), F32_LCMS_TYPE, icSigRgbData, tqparent, 0)
KisRgbF32ColorSpace::KisRgbF32ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile */*p*/) :
KisF32BaseColorSpace(KisID("RGBAF32", i18n("RGB (32-bit float/channel)")), F32_LCMS_TYPE, icSigRgbData, parent, 0)
{
m_channels.push_back(new KisChannelInfo(i18n("Red"), i18n("R"), PIXEL_RED * sizeof(float), KisChannelInfo::COLOR, KisChannelInfo::FLOAT32, sizeof(float)));
m_channels.push_back(new KisChannelInfo(i18n("Green"), i18n("G"), PIXEL_GREEN * sizeof(float), KisChannelInfo::COLOR, KisChannelInfo::FLOAT32, sizeof(float)));
@ -304,21 +304,21 @@ void KisRgbF32ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const float *src = reinterpret_cast<const float *>(srcRowStart);
float *dst = reinterpret_cast<float *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
float srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha *= UINT8_TO_FLOAT(U8_tqmask);
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha *= UINT8_TO_FLOAT(U8_mask);
}
tqmask++;
mask++;
}
if (srcAlpha > F32_OPACITY_TRANSPARENT + EPSILON) {
@ -377,7 +377,7 @@ void KisRgbF32ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const float *src = reinterpret_cast<const float *>(srcRowStart); \
float *dst = reinterpret_cast<float *>(dstRowStart); \
TQ_INT32 columns = numColumns; \
const TQ_UINT8 *tqmask = maskRowStart; \
const TQ_UINT8 *mask = maskRowStart; \
\
while (columns > 0) { \
\
@ -386,13 +386,13 @@ void KisRgbF32ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
\
srcAlpha = TQMIN(srcAlpha, dstAlpha); \
\
if (tqmask != 0) { \
TQ_UINT8 U8_tqmask = *tqmask; \
if (mask != 0) { \
TQ_UINT8 U8_mask = *mask; \
\
if (U8_tqmask != OPACITY_OPAQUE) { \
srcAlpha *= UINT8_TO_FLOAT(U8_tqmask); \
if (U8_mask != OPACITY_OPAQUE) { \
srcAlpha *= UINT8_TO_FLOAT(U8_mask); \
} \
tqmask++; \
mask++; \
} \
\
if (srcAlpha > F32_OPACITY_TRANSPARENT + EPSILON) { \
@ -760,20 +760,20 @@ void KisRgbF32ColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
float srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = FLOAT_BLEND(srcAlpha, F32_OPACITY_OPAQUE, UINT8_TO_FLOAT(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = FLOAT_BLEND(srcAlpha, F32_OPACITY_OPAQUE, UINT8_TO_FLOAT(U8_mask));
}
tqmask++;
mask++;
}
d->alpha = srcAlpha * d->alpha;
}
@ -790,7 +790,7 @@ void KisRgbF32ColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 U8_opacity,
TQ_INT32 rows,
@ -804,7 +804,7 @@ void KisRgbF32ColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
//compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -833,16 +833,16 @@ void KisRgbF32ColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
//compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, U8_opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, U8_opacity);
break;
case COMPOSITE_COPY_RED:
//compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -877,22 +877,22 @@ void KisRgbF32ColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
//compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -901,24 +901,24 @@ void KisRgbF32ColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
abstractCompositeAlphaDarken<float, F32Mult, Uint8ToF32, F32OpacityTest,
PIXEL_ALPHA, MAX_CHANNEL_RGB, MAX_CHANNEL_RGBA>(
dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride,
dst, dstRowStride, src, srcRowStride, mask, maskRowStride,
rows, cols, U8_opacity, F32Mult(), Uint8ToF32(), F32OpacityTest());
default:
break;

32
chalk/colorspaces/rgb_f32/kis_rgb_f32_colorspace.h
Unescape Escape View File

@ -33,7 +33,7 @@ class KisColorSpaceFactoryRegistry;
class KRITATOOL_EXPORT KisRgbF32ColorSpace : public KisF32BaseColorSpace {
public:
KisRgbF32ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisRgbF32ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisRgbF32ColorSpace();
virtual bool willDegrade(ColorSpaceIndependence independence)
@ -89,20 +89,20 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, float opacity);
private:
friend class KisRgbF32ColorSpaceTester;
@ -156,7 +156,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigRgbData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisRgbF32ColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisRgbF32ColorSpace(parent, p); };
virtual TQString defaultProfile() { return "sRGB built-in - (lcms internal)"; };
};

8
chalk/colorspaces/rgb_f32/rgb_f32_plugin.cc
Unescape Escape View File

@ -35,14 +35,14 @@ typedef KGenericFactory<RGBF32Plugin> RGBF32PluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalk_rgb_f32_plugin, RGBF32PluginFactory( "chalk" ) )
RGBF32Plugin::RGBF32Plugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
RGBF32Plugin::RGBF32Plugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(RGBF32PluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>(tqparent);
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>(parent);
KisColorSpace * colorSpaceRGBF32 = new KisRgbF32ColorSpace(f, 0);

2
chalk/colorspaces/rgb_f32/rgb_f32_plugin.h
Unescape Escape View File

@ -30,7 +30,7 @@ class RGBF32Plugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
RGBF32Plugin(TQObject *tqparent, const char *name, const TQStringList &);
RGBF32Plugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~RGBF32Plugin();
};

2
chalk/colorspaces/rgb_f32/tests/kis_strategy_colorspace_rgb_f32_tester.cc
Unescape Escape View File

@ -533,7 +533,7 @@ void KisRgbF32ColorSpaceTester::testCompositeOps()
};
cs->compositeOver(reinterpret_cast<TQ_UINT8 *>(dstPixels), DST_ROW_STRIDE, reinterpret_cast<const TQ_UINT8 *>(srcPixels),
SRC_ROW_STRIDE, tqmask, MASK_ROW_STRIDE, NUM_ROWS, NUM_COLUMNS, opacity);
SRC_ROW_STRIDE, mask, MASK_ROW_STRIDE, NUM_ROWS, NUM_COLUMNS, opacity);
*/
delete cs;

78
chalk/colorspaces/rgb_u16/kis_rgb_u16_colorspace.cc
Unescape Escape View File

@ -44,8 +44,8 @@ namespace {
//const TQ_UINT16 KisRgbU16ColorSpace::U16_OPACITY_OPAQUE;
//const TQ_UINT16 KisRgbU16ColorSpace::U16_OPACITY_TRANSPARENT;
KisRgbU16ColorSpace::KisRgbU16ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
KisU16BaseColorSpace(KisID("RGBA16", i18n("RGB (16-bit integer/channel)")), TYPE_BGRA_16, icSigRgbData, tqparent, p)
KisRgbU16ColorSpace::KisRgbU16ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisU16BaseColorSpace(KisID("RGBA16", i18n("RGB (16-bit integer/channel)")), TYPE_BGRA_16, icSigRgbData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Red"), i18n("R"), PIXEL_RED * sizeof(TQ_UINT16), KisChannelInfo::COLOR, KisChannelInfo::UINT16, sizeof(TQ_UINT16), TQColor(255,0,0)));
m_channels.push_back(new KisChannelInfo(i18n("Green"), i18n("G"), PIXEL_GREEN * sizeof(TQ_UINT16), KisChannelInfo::COLOR, KisChannelInfo::UINT16, sizeof(TQ_UINT16), TQColor(0,255,0)));
@ -202,21 +202,21 @@ void KisRgbU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart);
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT16 srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
if (srcAlpha != U16_OPACITY_TRANSPARENT) {
@ -275,7 +275,7 @@ void KisRgbU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart); \
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart); \
TQ_INT32 columns = numColumns; \
const TQ_UINT8 *tqmask = maskRowStart; \
const TQ_UINT8 *mask = maskRowStart; \
\
while (columns > 0) { \
\
@ -284,13 +284,13 @@ void KisRgbU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
\
srcAlpha = TQMIN(srcAlpha, dstAlpha); \
\
if (tqmask != 0) { \
TQ_UINT8 U8_tqmask = *tqmask; \
if (mask != 0) { \
TQ_UINT8 U8_mask = *mask; \
\
if (U8_tqmask != OPACITY_OPAQUE) { \
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask)); \
if (U8_mask != OPACITY_OPAQUE) { \
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask)); \
} \
tqmask++; \
mask++; \
} \
\
if (srcAlpha != U16_OPACITY_TRANSPARENT) { \
@ -680,20 +680,20 @@ void KisRgbU16ColorSpace::compositeErase(TQ_UINT8 *dst,
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
TQ_UINT16 srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
d->alpha = UINT16_MULT(srcAlpha, d->alpha);
}
@ -710,7 +710,7 @@ void KisRgbU16ColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 U8_opacity,
TQ_INT32 rows,
@ -724,7 +724,7 @@ void KisRgbU16ColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
//compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -753,16 +753,16 @@ void KisRgbU16ColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
//compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, U8_opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, U8_opacity);
break;
case COMPOSITE_COPY_RED:
//compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -797,22 +797,22 @@ void KisRgbU16ColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
//compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -821,24 +821,24 @@ void KisRgbU16ColorSpace::bitBlt(TQ_UINT8 *dst,
//compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
abstractCompositeAlphaDarken<TQ_UINT16, U16Mult, Uint8ToU16, U16OpacityTest,
PIXEL_ALPHA, MAX_CHANNEL_RGB, MAX_CHANNEL_RGBA>(
dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride,
dst, dstRowStride, src, srcRowStride, mask, maskRowStride,
rows, cols, opacity, U16Mult(), Uint8ToU16(), U16OpacityTest());
break;
default:

32
chalk/colorspaces/rgb_u16/kis_rgb_u16_colorspace.h
Unescape Escape View File

@ -38,7 +38,7 @@ public:
TQ_UINT16 alpha;
};
public:
KisRgbU16ColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisRgbU16ColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisRgbU16ColorSpace();
virtual bool willDegrade(ColorSpaceIndependence independence)
@ -80,20 +80,20 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT16 opacity);
private:
friend class KisRgbU16ColorSpaceTester;
@ -120,7 +120,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigRgbData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisRgbU16ColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisRgbU16ColorSpace(parent, p); };
virtual TQString defaultProfile() { return "sRGB built-in - (lcms internal)"; };
};

8
chalk/colorspaces/rgb_u16/rgb_u16_plugin.cc
Unescape Escape View File

@ -34,14 +34,14 @@ typedef KGenericFactory<RGBU16Plugin> RGBU16PluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalk_rgb_u16_plugin, RGBU16PluginFactory( "chalk" ) )
RGBU16Plugin::RGBU16Plugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
RGBU16Plugin::RGBU16Plugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(RGBU16PluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry *>( tqparent );
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry *>( parent );
KisColorSpace * colorSpaceRGBU16 = new KisRgbU16ColorSpace(f, 0);
KisColorSpaceFactory * csFactory = new KisRgbU16ColorSpaceFactory();

2
chalk/colorspaces/rgb_u16/rgb_u16_plugin.h
Unescape Escape View File

@ -29,7 +29,7 @@ class RGBU16Plugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
RGBU16Plugin(TQObject *tqparent, const char *name, const TQStringList &);
RGBU16Plugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~RGBU16Plugin();
};

2
chalk/colorspaces/rgb_u16/tests/kis_strategy_colorspace_rgb_u16_tester.cc
Unescape Escape View File

@ -516,7 +516,7 @@ void KisRgbU16ColorSpaceTester::testCompositeOps()
};
cs->compositeOver(reinterpret_cast<TQ_UINT8 *>(dstPixels), DST_ROW_STRIDE, reinterpret_cast<const TQ_UINT8 *>(srcPixels),
SRC_ROW_STRIDE, tqmask, MASK_ROW_STRIDE, NUM_ROWS, NUM_COLUMNS, opacity);
SRC_ROW_STRIDE, mask, MASK_ROW_STRIDE, NUM_ROWS, NUM_COLUMNS, opacity);
*/
delete cs;

218
chalk/colorspaces/rgb_u8/kis_rgb_colorspace.cc
Unescape Escape View File

@ -44,8 +44,8 @@ namespace {
const TQ_INT32 MAX_CHANNEL_RGBA = 4;
}
KisRgbColorSpace::KisRgbColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
KisU8BaseColorSpace(KisID("RGBA", i18n("RGB (8-bit integer/channel)")), TYPE_BGRA_8, icSigRgbData, tqparent, p)
KisRgbColorSpace::KisRgbColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisU8BaseColorSpace(KisID("RGBA", i18n("RGB (8-bit integer/channel)")), TYPE_BGRA_8, icSigRgbData, parent, p)
{
m_channels.push_back(new KisChannelInfo(i18n("Red"), i18n("R"), 2, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQColor(255,0,0)));
m_channels.push_back(new KisChannelInfo(i18n("Green"), i18n("G"), 1, KisChannelInfo::COLOR, KisChannelInfo::UINT8, 1, TQColor(0,255,0)));
@ -272,19 +272,19 @@ void KisRgbColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStrid
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -346,7 +346,7 @@ void KisRgbColorSpace::compositeAlphaDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstR
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
@ -354,12 +354,12 @@ void KisRgbColorSpace::compositeAlphaDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstR
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
TQ_UINT8 dstAlpha = dst[PIXEL_ALPHA];
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (opacity != OPACITY_OPAQUE) {
@ -392,7 +392,7 @@ void KisRgbColorSpace::compositeMultiply(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -401,12 +401,12 @@ void KisRgbColorSpace::compositeMultiply(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
@ -473,7 +473,7 @@ void KisRgbColorSpace::compositeDivide(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStr
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -482,12 +482,12 @@ void KisRgbColorSpace::compositeDivide(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStr
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -544,7 +544,7 @@ void KisRgbColorSpace::compositeScreen(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStr
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -553,12 +553,12 @@ void KisRgbColorSpace::compositeScreen(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStr
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -615,7 +615,7 @@ void KisRgbColorSpace::compositeOverlay(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -624,12 +624,12 @@ void KisRgbColorSpace::compositeOverlay(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
@ -687,7 +687,7 @@ void KisRgbColorSpace::compositeDodge(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -696,12 +696,12 @@ void KisRgbColorSpace::compositeDodge(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
@ -759,7 +759,7 @@ void KisRgbColorSpace::compositeBurn(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStrid
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -768,12 +768,12 @@ void KisRgbColorSpace::compositeBurn(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStrid
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -831,7 +831,7 @@ void KisRgbColorSpace::compositeDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStr
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -840,12 +840,12 @@ void KisRgbColorSpace::compositeDarken(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStr
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -902,7 +902,7 @@ void KisRgbColorSpace::compositeLighten(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -911,12 +911,12 @@ void KisRgbColorSpace::compositeLighten(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowSt
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -973,7 +973,7 @@ void KisRgbColorSpace::compositeHue(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -982,12 +982,12 @@ void KisRgbColorSpace::compositeHue(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -1056,7 +1056,7 @@ void KisRgbColorSpace::compositeSaturation(TQ_UINT8 *dstRowStart, TQ_INT32 dstRo
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -1065,12 +1065,12 @@ void KisRgbColorSpace::compositeSaturation(TQ_UINT8 *dstRowStart, TQ_INT32 dstRo
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -1139,7 +1139,7 @@ void KisRgbColorSpace::compositeValue(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -1148,12 +1148,12 @@ void KisRgbColorSpace::compositeValue(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -1222,7 +1222,7 @@ void KisRgbColorSpace::compositeColor(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
TQ_INT32 columns = numColumns;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
while (columns > 0) {
@ -1231,12 +1231,12 @@ void KisRgbColorSpace::compositeColor(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStri
srcAlpha = TQMIN(srcAlpha, dstAlpha);
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -1315,17 +1315,17 @@ void KisRgbColorSpace::compositeErase(TQ_UINT8 *dst,
{
const TQ_UINT8 *s = src;
TQ_UINT8 *d = dst;
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (i = cols; i > 0; i--, s+=MAX_CHANNEL_RGBA, d+=MAX_CHANNEL_RGBA)
{
srcAlpha = s[PIXEL_ALPHA];
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_BLEND(srcAlpha, OPACITY_OPAQUE, *mask);
mask++;
}
d[PIXEL_ALPHA] = UINT8_MULT(srcAlpha, d[PIXEL_ALPHA]);
}
@ -1341,7 +1341,7 @@ void KisRgbColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 opacity,
TQ_INT32 rows,
@ -1354,10 +1354,10 @@ void KisRgbColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ALPHA_DARKEN:
compositeAlphaDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeAlphaDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_IN:
compositeIn(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -1387,16 +1387,16 @@ void KisRgbColorSpace::bitBlt(TQ_UINT8 *dst,
compositeDiff(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_MULT:
compositeMultiply(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeMultiply(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DIVIDE:
compositeDivide(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDivide(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BUMPMAP:
compositeBumpmap(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY_RED:
compositeCopyRed(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -1431,22 +1431,22 @@ void KisRgbColorSpace::bitBlt(TQ_UINT8 *dst,
// No composition.
break;
case COMPOSITE_DARKEN:
compositeDarken(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDarken(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_LIGHTEN:
compositeLighten(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeLighten(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_HUE:
compositeHue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeHue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_SATURATION:
compositeSaturation(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeSaturation(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_VALUE:
compositeValue(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeValue(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLOR:
compositeColor(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeColor(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COLORIZE:
compositeColorize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
@ -1455,19 +1455,19 @@ void KisRgbColorSpace::bitBlt(TQ_UINT8 *dst,
compositeLuminize(pixelSize(), dst, dstRowStride, src, srcRowStride, rows, cols, opacity);
break;
case COMPOSITE_SCREEN:
compositeScreen(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeScreen(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_OVERLAY:
compositeOverlay(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOverlay(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_ERASE:
compositeErase(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeErase(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_DODGE:
compositeDodge(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeDodge(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_BURN:
compositeBurn(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeBurn(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
default:
break;

34
chalk/colorspaces/rgb_u8/kis_rgb_colorspace.h
Unescape Escape View File

@ -31,7 +31,7 @@ const TQ_UINT8 PIXEL_ALPHA = 3;
class KRITATOOL_EXPORT KisRgbColorSpace : public KisU8BaseColorSpace {
public:
KisRgbColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisRgbColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisRgbColorSpace();
virtual bool willDegrade(ColorSpaceIndependence)
@ -75,21 +75,21 @@ protected:
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeAlphaDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeAlphaDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeMultiply(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDivide(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeScreen(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOverlay(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDodge(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeBurn(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeDarken(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeLighten(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeHue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeSaturation(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeValue(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeColor(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
};
class KisRgbColorSpaceFactory : public KisColorSpaceFactory
@ -108,7 +108,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icSigRgbData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile * p) { return new KisRgbColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile * p) { return new KisRgbColorSpace(parent, p); };
virtual TQString defaultProfile() { return "sRGB built-in - (lcms internal)"; };
};

8
chalk/colorspaces/rgb_u8/rgb_plugin.cc
Unescape Escape View File

@ -43,14 +43,14 @@ typedef KGenericFactory<RGBPlugin> RGBPluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalkrgbplugin, RGBPluginFactory( "chalk" ) )
RGBPlugin::RGBPlugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
RGBPlugin::RGBPlugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(RGBPluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>(tqparent);
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>(parent);
KisProfile *defProfile = new KisProfile(cmsCreate_sRGBProfile());
f->addProfile(defProfile);

2
chalk/colorspaces/rgb_u8/rgb_plugin.h
Unescape Escape View File

@ -29,7 +29,7 @@ class RGBPlugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
RGBPlugin(TQObject *tqparent, const char *name, const TQStringList &);
RGBPlugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~RGBPlugin();
};

4
chalk/colorspaces/wet/kis_wet_colorspace.cc
Unescape Escape View File

@ -109,8 +109,8 @@ int getH(int r, int g, int b)
return h;
}
KisWetColorSpace::KisWetColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) :
KisAbstractColorSpace(KisID("WET", i18n("Watercolors")), 0, icMaxEnumData, tqparent, p)
KisWetColorSpace::KisWetColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) :
KisAbstractColorSpace(KisID("WET", i18n("Watercolors")), 0, icMaxEnumData, parent, p)
{
wet_init_render_tab();

4
chalk/colorspaces/wet/kis_wet_colorspace.h
Unescape Escape View File

@ -92,7 +92,7 @@ void wetPixFromDouble(WetPix * dst, WetPixDbl *src);
class KisWetColorSpace : public KisAbstractColorSpace {
public:
KisWetColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p);
KisWetColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p);
virtual ~KisWetColorSpace();
@ -211,7 +211,7 @@ public:
virtual icColorSpaceSignature colorSpaceSignature() { return icMaxEnumData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisWetColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisWetColorSpace(parent, p); };
virtual TQString defaultProfile() { return ""; };
};

2
chalk/colorspaces/wet/kis_wet_palette_widget.cc
Unescape Escape View File

@ -46,7 +46,7 @@
#include "kis_wet_colorspace.h"
#include "kis_wet_palette_widget.h"
KisWetPaletteWidget::KisWetPaletteWidget(TQWidget *tqparent, const char *name) : super(tqparent, name)
KisWetPaletteWidget::KisWetPaletteWidget(TQWidget *parent, const char *name) : super(parent, name)
{
m_subject = 0;

2
chalk/colorspaces/wet/kis_wet_palette_widget.h
Unescape Escape View File

@ -45,7 +45,7 @@ class KRITAUI_EXPORT KisWetPaletteWidget
typedef TQWidget super;
public:
KisWetPaletteWidget(TQWidget *tqparent = 0L, const char *name = 0);
KisWetPaletteWidget(TQWidget *parent = 0L, const char *name = 0);
virtual ~KisWetPaletteWidget() {}
protected slots:

14
chalk/colorspaces/wet/kis_wetop.cc
Unescape Escape View File

@ -36,10 +36,10 @@
#include "kis_wetop.h"
#include "kis_wet_colorspace.h"
KisWetOpSettings::KisWetOpSettings(TQWidget *tqparent)
: super(tqparent)
KisWetOpSettings::KisWetOpSettings(TQWidget *parent)
: super(parent)
{
m_options = new WetPaintOptions(tqparent, "wet option widget");
m_options = new WetPaintOptions(parent, "wet option widget");
}
bool KisWetOpSettings::varySize() const
@ -67,13 +67,13 @@ KisPaintOp * KisWetOpFactory::createOp(const KisPaintOpSettings *settings, KisPa
return op;
}
KisPaintOpSettings* KisWetOpFactory::settings(TQWidget * tqparent, const KisInputDevice& inputDevice)
KisPaintOpSettings* KisWetOpFactory::settings(TQWidget * parent, const KisInputDevice& inputDevice)
{
if (inputDevice == KisInputDevice::mouse()) {
// No options for mouse, only tablet devices
return 0;
} else {
return new KisWetOpSettings(tqparent);
return new KisWetOpSettings(parent);
}
}
@ -120,8 +120,8 @@ void KisWetOp::paintAt(const KisPoint &pos, const KisPaintInformation& info)
dab = brush->image(KisMetaRegistry::instance()->csRegistry()->getAlpha8(), inf);
}
else {
KisAlphaMaskSP tqmask = brush->tqmask(inf);
dab = computeDab(tqmask, KisMetaRegistry::instance()->csRegistry()->getAlpha8());
KisAlphaMaskSP mask = brush->mask(inf);
dab = computeDab(mask, KisMetaRegistry::instance()->csRegistry()->getAlpha8());
}
KisColorSpace * cs = device->colorSpace();

4
chalk/colorspaces/wet/kis_wetop.h
Unescape Escape View File

@ -36,13 +36,13 @@ public:
virtual KisPaintOp * createOp(const KisPaintOpSettings *settings, KisPainter * painter);
virtual KisID id() { return KisID("wetbrush", i18n("Watercolor Brush")); }
virtual bool userVisible(KisColorSpace* cs) { return cs->id() == KisID("WET", ""); }
virtual KisPaintOpSettings *settings(TQWidget * tqparent, const KisInputDevice& inputDevice);
virtual KisPaintOpSettings *settings(TQWidget * parent, const KisInputDevice& inputDevice);
};
class KisWetOpSettings : public KisPaintOpSettings {
typedef KisPaintOpSettings super;
public:
KisWetOpSettings(TQWidget *tqparent);
KisWetOpSettings(TQWidget *parent);
bool varySize() const;
bool varyWetness() const;

12
chalk/colorspaces/wet/wet_plugin.cc
Unescape Escape View File

@ -66,14 +66,14 @@ typedef KGenericFactory<WetPlugin> WetPluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalkwetplugin, WetPluginFactory( "chalkcore" ) )
WetPlugin::WetPlugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
WetPlugin::WetPlugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(WetPluginFactory::instance());
// This is not a gui plugin; only load it when the doc is created.
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") ) {
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>(tqparent);
if ( parent->inherits("KisColorSpaceFactoryRegistry") ) {
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>(parent);
KisColorSpace* colorSpaceWet = new KisWetColorSpace(f, 0);
@ -97,12 +97,12 @@ WetPlugin::WetPlugin(TQObject *tqparent, const char *name, const TQStringList &)
// Texture Action:
f->addPaintDeviceAction(colorSpaceWet, new WetPaintDevAction);
}
else if (tqparent->inherits("KisView"))
else if (parent->inherits("KisView"))
{
setInstance(WetPluginFactory::instance());
setXMLFile(locate("data","chalkplugins/wetplugin.rc"), true);
m_view = dynamic_cast<KisView*>(tqparent);
m_view = dynamic_cast<KisView*>(parent);
// Wetness visualisation
WetnessVisualisationFilter * wf = new WetnessVisualisationFilter(m_view);
wf->setAction(new KToggleAction(i18n("Wetness Visualisation"), 0, 0, wf,

2
chalk/colorspaces/wet/wet_plugin.h
Unescape Escape View File

@ -34,7 +34,7 @@ class WetPlugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
WetPlugin(TQObject *tqparent, const char *name, const TQStringList &);
WetPlugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~WetPlugin();
private:

4
chalk/colorspaces/wet/wetphysicsfilter.cc
Unescape Escape View File

@ -43,7 +43,7 @@
* [11:16] <CyrilleB> boud: which one then ?
* [11:16] <pippin> the error is distributed to the neighbour pixels (to the right, down and down to the left in pixels which have not yet been processed
* [11:16] <pippin> )
* [11:16] <boud> CyrilleB: it's only aptqparent when you let something dry for some time, it looks like meandering snakes (like the old game "snake")
* [11:16] <boud> CyrilleB: it's only apparent when you let something dry for some time, it looks like meandering snakes (like the old game "snake")
* [11:16] <CyrilleB> pippin: somehow yes
* [11:16] <boud> pippin: that is possible
* [11:17] <pippin> boud: this leads to "bleeding" of data to the right and down,..
@ -55,7 +55,7 @@
* [11:27] <boud> Well, I don't have time to investigate right now, but it sounds very plausible.
* [11:27] <CyrilleB> pippin: :)
* [11:28] <boud> of course, the code _is_ available :-)
* [11:28] <pippin> if there is some form of diffusion matrix that is directional around the current pixel,. having that tqmask rotate depending on the modulus of the current iteration # should cancel such an effect out
* [11:28] <pippin> if there is some form of diffusion matrix that is directional around the current pixel,. having that mask rotate depending on the modulus of the current iteration # should cancel such an effect out
*/
WetPhysicsFilter::WetPhysicsFilter()
: KisFilter(id(), "artistic", i18n("Dry the Paint"))

14
chalk/colorspaces/wetsticky/brushop/kis_wsbrushop.cc
Unescape Escape View File

@ -52,13 +52,13 @@ void KisWSBrushOp::paintAt(const KisPoint &pos,
{
// Painting should be implemented according to the following algorithm:
// retrieve brush
// if brush == tqmask
// retrieve tqmask
// if brush == mask
// retrieve mask
// else if brush == image
// retrieve image
// subsample (tqmask | image) for position -- pos should be double!
// apply filters to tqmask (colour | gradient | pattern | etc.
// composite filtered tqmask into temporary layer
// subsample (mask | image) for position -- pos should be double!
// apply filters to mask (colour | gradient | pattern | etc.
// composite filtered mask into temporary layer
// composite temporary layer into target layer
// @see: doc/brush.txt
@ -91,8 +91,8 @@ void KisWSBrushOp::paintAt(const KisPoint &pos,
dab = brush -> image(device -> colorSpace(), pressure, xFraction, yFraction);
}
else {
KisAlphaMaskSP tqmask = brush -> tqmask(pressure, xFraction, yFraction);
dab = computeDab(tqmask);
KisAlphaMaskSP mask = brush -> mask(pressure, xFraction, yFraction);
dab = computeDab(mask);
}
m_painter -> setPressure(pressure);

6
chalk/colorspaces/wetsticky/brushop/wsbrushpaintop_plugin.cc
Unescape Escape View File

@ -36,13 +36,13 @@ typedef KGenericFactory<WSBrushPaintOpPlugin> WSBrushPaintOpPluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalkwsbrushpaintop, WSBrushPaintOpPluginFactory( "chalkcore" ) )
WSBrushPaintOpPlugin::WSBrushPaintOpPlugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
WSBrushPaintOpPlugin::WSBrushPaintOpPlugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(WSBrushPaintOpPluginFactory::instance());
// This is not a gui plugin; only load it when the doc is created.
if ( tqparent->inherits("KisFactory") )
if ( parent->inherits("KisFactory") )
{
KisPaintOpRegistry::instance() -> add ( new KisWSBrushOpFactory );
}

2
chalk/colorspaces/wetsticky/brushop/wsbrushpaintop_plugin.h
Unescape Escape View File

@ -33,7 +33,7 @@ class WSBrushPaintOpPlugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
WSBrushPaintOpPlugin(TQObject *tqparent, const char *name, const TQStringList &);
WSBrushPaintOpPlugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~WSBrushPaintOpPlugin();
private:

20
chalk/colorspaces/wetsticky/kis_wet_sticky_colorspace.cc
Unescape Escape View File

@ -356,7 +356,7 @@ void KisWetStickyColorSpace::bitBlt(TQ_UINT8 *dst,
TQ_INT32 dstRowStride,
const TQ_UINT8 *src,
TQ_INT32 srcRowStride,
const TQ_UINT8 *tqmask,
const TQ_UINT8 *mask,
TQ_INT32 maskRowStride,
TQ_UINT8 opacity,
TQ_INT32 rows,
@ -368,11 +368,11 @@ void KisWetStickyColorSpace::bitBlt(TQ_UINT8 *dst,
// Undefined == no composition
break;
case COMPOSITE_OVER:
compositeOver(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeOver(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
case COMPOSITE_COPY:
default:
compositeCopy(dst, dstRowStride, src, srcRowStride, tqmask, maskRowStride, rows, cols, opacity);
compositeCopy(dst, dstRowStride, src, srcRowStride, mask, maskRowStride, rows, cols, opacity);
break;
}
@ -389,7 +389,7 @@ void KisWetStickyColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRo
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
@ -410,12 +410,12 @@ void KisWetStickyColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRo
TQ_UINT8 srcAlpha = srcCell->alpha;
// apply the alphatqmask
if(tqmask != 0)
// apply the alphamask
if(mask != 0)
{
if(*tqmask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *tqmask);
tqmask++;
if(*mask != OPACITY_OPAQUE)
srcAlpha = UINT8_MULT(srcAlpha, *mask);
mask++;
}
if (srcAlpha != OPACITY_TRANSPARENT) {
@ -467,7 +467,7 @@ void KisWetStickyColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRo
}
void KisWetStickyColorSpace::compositeCopy(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity)
void KisWetStickyColorSpace::compositeCopy(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity)
{
TQ_INT32 linesize = sizeof(CELL) * columns;
TQ_UINT8 *d;

6
chalk/colorspaces/wetsticky/kis_wet_sticky_colorspace.h
Unescape Escape View File

@ -139,9 +139,9 @@ protected:
private:
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeClear(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeCopy(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeClear(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeCopy(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
};

4
chalk/colorspaces/wetsticky/kis_ws_engine_filter.cc
Unescape Escape View File

@ -153,9 +153,9 @@ void KisWSEngineFilter::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisF
}
KisFilterConfigWidget * KisWSEngineFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev)
KisFilterConfigWidget * KisWSEngineFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev)
{
// KisWSEngineFilterConfigurationWidget* kefcw = new KisWSEngineFilterConfigurationWidget(this,tqparent, "");
// KisWSEngineFilterConfigurationWidget* kefcw = new KisWSEngineFilterConfigurationWidget(this,parent, "");
// kdDebug(DBG_AREA_FILTERS) << kefcw << endl;
// return kefcw ;
return 0;

2
chalk/colorspaces/wetsticky/kis_ws_engine_filter.h
Unescape Escape View File

@ -59,7 +59,7 @@ public:
virtual bool supportsIncrementalPainting() { return false; }
public:
virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
virtual KisFilterConfiguration* configuration(TQWidget*, KisPaintDeviceSP dev);

6
chalk/colorspaces/wetsticky/wet_sticky_plugin.cc
Unescape Escape View File

@ -37,13 +37,13 @@ typedef KGenericFactory<WetStickyPlugin> WetStickyPluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalkwsplugin, WetStickyPluginFactory( "chalkcore" ) )
WetStickyPlugin::WetStickyPlugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
WetStickyPlugin::WetStickyPlugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(WetStickyPluginFactory::instance());
// This is not a gui plugin; only load it when the doc is created.
if ( tqparent->inherits("KisFactory") )
if ( parent->inherits("KisFactory") )
{
KisColorSpace * colorSpaceWS = new KisWetStickyColorSpace();
Q_CHECK_PTR(colorSpaceWS);

2
chalk/colorspaces/wetsticky/wet_sticky_plugin.h
Unescape Escape View File

@ -34,7 +34,7 @@ class WetStickyPlugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
WetStickyPlugin(TQObject *tqparent, const char *name, const TQStringList &);
WetStickyPlugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~WetStickyPlugin();
};

6
chalk/colorspaces/wetsticky/ws/anim.c
Unescape Escape View File

@ -53,7 +53,7 @@ static Pixmap colour_pm[FRAME_LIMIT];
static GC gc;
static GC tmp_gc;
static long tqmask;
static long mask;
static XGCValues values;
Display *display;
@ -117,14 +117,14 @@ char *argv[];
XSynchronize(display, True);
tqmask = GCBackground| GCForeground| GCFunction;
mask = GCBackground| GCForeground| GCFunction;
values.function = GXcopy;
values.background = 0;
values.foreground = 1;
gc = XtGetGC(colour_canvas, tqmask, &values);
gc = XtGetGC(colour_canvas, mask, &values);

12
chalk/colorspaces/wetsticky/ws/cmap.c
Unescape Escape View File

@ -59,7 +59,7 @@ static Pixmap dryness_pm;
static GC gc;
static GC tmp_gc;
static long tqmask;
static long mask;
static XGCValues values;
static Colormap cmap;
@ -216,7 +216,7 @@ Drawable win;
/* Fill a window with a solid, white rectangle */
{
XGCValues values;
long tqmask;
long mask;
values.background = colours[0].pixel;
values.foreground = colours[255].pixel;;
@ -224,9 +224,9 @@ long tqmask;
values.function = GXclear;
tqmask = GCBackground| GCForeground| GCFillStyle | GCFunction;
mask = GCBackground| GCForeground| GCFillStyle | GCFunction;
tmp_gc = XtGetGC(top_level, tqmask, &values);
tmp_gc = XtGetGC(top_level, mask, &values);
XFillRectangle(XtDisplay(top_level), win, tmp_gc, 0, 0, 300, 300);
@ -371,14 +371,14 @@ int height;
XInstallColormap(display, cmap);
tqmask = GCBackground| GCForeground| GCFunction;
mask = GCBackground| GCForeground| GCFunction;
values.function = GXcopy;
values.background = colours[0].pixel;
values.foreground = colours[255].pixel;
gc = XtGetGC(colour_canvas, tqmask, &values);
gc = XtGetGC(colour_canvas, mask, &values);
colour_pm = XCreatePixmap(XtDisplay(top_level),
XtWindow(colour_shell), width, height,

12
chalk/colorspaces/wetsticky/ws/x_interface.c
Unescape Escape View File

@ -68,7 +68,7 @@ static Pixmap dryness_pm;
static GC gc;
static GC tmp_gc;
static long tqmask;
static long mask;
static XGCValues values;
static Colormap cmap;
@ -272,7 +272,7 @@ Drawable win;
/* Fill a window with a solid, white rectangle */
{
XGCValues values;
long tqmask;
long mask;
values.background = colours[0].pixel;
values.foreground = colours[255].pixel;;
@ -280,9 +280,9 @@ long tqmask;
values.function = GXclear;
tqmask = GCBackground| GCForeground| GCFillStyle | GCFunction;
mask = GCBackground| GCForeground| GCFillStyle | GCFunction;
tmp_gc = XtGetGC(top_level, tqmask, &values);
tmp_gc = XtGetGC(top_level, mask, &values);
XFillRectangle(XtDisplay(top_level), win, tmp_gc, 0, 0, 300, 300);
@ -423,14 +423,14 @@ int height;
XInstallColormap(display, cmap);
tqmask = GCBackground| GCForeground| GCFunction;
mask = GCBackground| GCForeground| GCFunction;
values.function = GXcopy;
values.background = colours[0].pixel;
values.foreground = colours[255].pixel;
gc = XtGetGC(colour_canvas, tqmask, &values);
gc = XtGetGC(colour_canvas, mask, &values);
colour_pm = XCreatePixmap(XtDisplay(top_level),
XtWindow(colour_shell), width, height,

32
chalk/colorspaces/ycbcr_u16/kis_ycbcr_u16_colorspace.cc
Unescape Escape View File

@ -26,8 +26,8 @@
const TQ_INT32 MAX_CHANNEL_YCbCr = 3;
const TQ_INT32 MAX_CHANNEL_YCbCrA = 4;
KisYCbCrU16ColorSpace::KisYCbCrU16ColorSpace(KisColorSpaceFactoryRegistry* tqparent, KisProfile* /*p*/)
: KisU16BaseColorSpace(KisID("YCbCrAU16", i18n("YCbCr (16-bit integer/channel)")), TYPE_YCbCr_16, icSigYCbCrData, tqparent, 0)
KisYCbCrU16ColorSpace::KisYCbCrU16ColorSpace(KisColorSpaceFactoryRegistry* parent, KisProfile* /*p*/)
: KisU16BaseColorSpace(KisID("YCbCrAU16", i18n("YCbCr (16-bit integer/channel)")), TYPE_YCbCr_16, icSigYCbCrData, parent, 0)
{
m_channels.push_back(new KisChannelInfo(i18n("Y"), "Y", PIXEL_Y * sizeof(TQ_UINT16), KisChannelInfo::COLOR, KisChannelInfo::UINT16, sizeof(TQ_UINT16)));
m_channels.push_back(new KisChannelInfo(i18n("Cb"), "Cb", PIXEL_Cb * sizeof(TQ_UINT16), KisChannelInfo::COLOR, KisChannelInfo::UINT16, sizeof(TQ_UINT16)));
@ -230,21 +230,21 @@ void KisYCbCrU16ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRow
const TQ_UINT16 *src = reinterpret_cast<const TQ_UINT16 *>(srcRowStart);
TQ_UINT16 *dst = reinterpret_cast<TQ_UINT16 *>(dstRowStart);
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT16 srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_MULT(srcAlpha, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
if (srcAlpha != U16_OPACITY_TRANSPARENT) {
@ -303,20 +303,20 @@ void KisYCbCrU16ColorSpace::compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowSize, c
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
TQ_UINT16 srcAlpha = s->alpha;
// apply the alphatqmask
if (tqmask != 0) {
TQ_UINT8 U8_tqmask = *tqmask;
// apply the alphamask
if (mask != 0) {
TQ_UINT8 U8_mask = *mask;
if (U8_tqmask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_tqmask));
if (U8_mask != OPACITY_OPAQUE) {
srcAlpha = UINT16_BLEND(srcAlpha, U16_OPACITY_OPAQUE, UINT8_TO_UINT16(U8_mask));
}
tqmask++;
mask++;
}
d->alpha = UINT16_MULT(srcAlpha, d->alpha);
}

8
chalk/colorspaces/ycbcr_u16/kis_ycbcr_u16_colorspace.h
Unescape Escape View File

@ -31,7 +31,7 @@
class KisYCbCrU16ColorSpace : public KisU16BaseColorSpace
{
public:
KisYCbCrU16ColorSpace(KisColorSpaceFactoryRegistry* tqparent, KisProfile* p);
KisYCbCrU16ColorSpace(KisColorSpaceFactoryRegistry* parent, KisProfile* p);
~KisYCbCrU16ColorSpace();
virtual bool willDegrade(ColorSpaceIndependence )
{
@ -75,8 +75,8 @@ class KisYCbCrU16ColorSpace : public KisU16BaseColorSpace
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
private:
#define CLAMP_TO_16BITCHANNEL(a) CLAMP(a, 0, TQ_UINT16_MAX)
@ -135,7 +135,7 @@ class KisYCbCrU16ColorSpaceFactory : public KisColorSpaceFactory
virtual icColorSpaceSignature colorSpaceSignature() { return icSigYCbCrData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisYCbCrU16ColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisYCbCrU16ColorSpace(parent, p); };
virtual TQString defaultProfile() { return ""; };
};

8
chalk/colorspaces/ycbcr_u16/ycbcr_u16_plugin.cc
Unescape Escape View File

@ -33,14 +33,14 @@ typedef KGenericFactory<YCbCrU16Plugin> YCbCrU16PluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalk_ycbcr_u16_plugin, YCbCrU16PluginFactory( "chalk" ) )
YCbCrU16Plugin::YCbCrU16Plugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
YCbCrU16Plugin::YCbCrU16Plugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(YCbCrU16PluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( tqparent );
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( parent );
KisColorSpace * colorSpaceYCbCrU16 = new KisYCbCrU16ColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisYCbCrU16ColorSpaceFactory();

2
chalk/colorspaces/ycbcr_u16/ycbcr_u16_plugin.h
Unescape Escape View File

@ -29,7 +29,7 @@ class YCbCrU16Plugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
YCbCrU16Plugin(TQObject *tqparent, const char *name, const TQStringList &);
YCbCrU16Plugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~YCbCrU16Plugin();
};

30
chalk/colorspaces/ycbcr_u8/kis_ycbcr_u8_colorspace.cc
Unescape Escape View File

@ -26,8 +26,8 @@
const TQ_INT32 MAX_CHANNEL_YCbCr = 3;
const TQ_INT32 MAX_CHANNEL_YCbCrA = 4;
KisYCbCrU8ColorSpace::KisYCbCrU8ColorSpace(KisColorSpaceFactoryRegistry* tqparent, KisProfile* /*p*/)
: KisU8BaseColorSpace(KisID("YCbCrAU8", i18n("YCbCr (8-bit integer/channel)")), TYPE_YCbCr_8, icSigYCbCrData, tqparent, 0)
KisYCbCrU8ColorSpace::KisYCbCrU8ColorSpace(KisColorSpaceFactoryRegistry* parent, KisProfile* /*p*/)
: KisU8BaseColorSpace(KisID("YCbCrAU8", i18n("YCbCr (8-bit integer/channel)")), TYPE_YCbCr_8, icSigYCbCrData, parent, 0)
{
m_channels.push_back(new KisChannelInfo(i18n("Y"), "Y", PIXEL_Y * sizeof(TQ_UINT8), KisChannelInfo::COLOR, KisChannelInfo::UINT8, sizeof(TQ_UINT8)));
m_channels.push_back(new KisChannelInfo(i18n("Cb"), "Cb", PIXEL_Cb * sizeof(TQ_UINT8), KisChannelInfo::COLOR, KisChannelInfo::UINT8, sizeof(TQ_UINT8)));
@ -230,19 +230,19 @@ void KisYCbCrU8ColorSpace::compositeOver(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowS
const TQ_UINT8 *src = srcRowStart;
TQ_UINT8 *dst = dstRowStart;
const TQ_UINT8 *tqmask = maskRowStart;
const TQ_UINT8 *mask = maskRowStart;
TQ_INT32 columns = numColumns;
while (columns > 0) {
TQ_UINT8 srcAlpha = src[PIXEL_ALPHA];
// apply the alphatqmask
if (tqmask != 0) {
if (*tqmask != OPACITY_OPAQUE) {
srcAlpha *= *tqmask;
// apply the alphamask
if (mask != 0) {
if (*mask != OPACITY_OPAQUE) {
srcAlpha *= *mask;
}
tqmask++;
mask++;
}
if (srcAlpha > OPACITY_TRANSPARENT) {
@ -301,18 +301,18 @@ void KisYCbCrU8ColorSpace::compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowSize, co
{
const Pixel *s = reinterpret_cast<const Pixel *>(src);
Pixel *d = reinterpret_cast<Pixel *>(dst);
const TQ_UINT8 *tqmask = srcAlphaMask;
const TQ_UINT8 *mask = srcAlphaMask;
for (TQ_INT32 i = cols; i > 0; i--, s++, d++)
{
TQ_UINT8 srcAlpha = s -> alpha;
// apply the alphatqmask
if (tqmask != 0) {
if (*tqmask != OPACITY_OPAQUE) {
srcAlpha = *tqmask;
// apply the alphamask
if (mask != 0) {
if (*mask != OPACITY_OPAQUE) {
srcAlpha = *mask;
}
tqmask++;
mask++;
}
d -> alpha = srcAlpha * d -> alpha;
}
@ -325,7 +325,7 @@ void KisYCbCrU8ColorSpace::compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowSize, co
}
}
void KisYCbCrU8ColorSpace::compositeCopy(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 */*tqmask*/, TQ_INT32 /*maskRowStride*/, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 /*opacity*/)
void KisYCbCrU8ColorSpace::compositeCopy(TQ_UINT8 *dstRowStart, TQ_INT32 dstRowStride, const TQ_UINT8 *srcRowStart, TQ_INT32 srcRowStride, const TQ_UINT8 */*mask*/, TQ_INT32 /*maskRowStride*/, TQ_INT32 rows, TQ_INT32 numColumns, TQ_UINT8 /*opacity*/)
{
while (rows > 0) {
memcpy(dstRowStart, srcRowStart, numColumns * sizeof(Pixel));

10
chalk/colorspaces/ycbcr_u8/kis_ycbcr_u8_colorspace.h
Unescape Escape View File

@ -31,7 +31,7 @@
class KisYCbCrU8ColorSpace : public KisU8BaseColorSpace
{
public:
KisYCbCrU8ColorSpace(KisColorSpaceFactoryRegistry* tqparent, KisProfile* p);
KisYCbCrU8ColorSpace(KisColorSpaceFactoryRegistry* parent, KisProfile* p);
~KisYCbCrU8ColorSpace();
virtual bool willDegrade(ColorSpaceIndependence )
{
@ -75,9 +75,9 @@ class KisYCbCrU8ColorSpace : public KisU8BaseColorSpace
TQ_INT32 cols,
const KisCompositeOp& op);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeCopy(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *tqmask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeOver(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeErase(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
void compositeCopy(TQ_UINT8 *dst, TQ_INT32 dstRowStride, const TQ_UINT8 *src, TQ_INT32 srcRowStride, const TQ_UINT8 *mask, TQ_INT32 maskRowStride, TQ_INT32 rows, TQ_INT32 columns, TQ_UINT8 opacity);
private:
#define CLAMP_TO_8BITCHANNEL(a) CLAMP(a, 0, TQ_UINT8_MAX)
@ -136,7 +136,7 @@ class KisYCbCrU8ColorSpaceFactory : public KisColorSpaceFactory
virtual icColorSpaceSignature colorSpaceSignature() { return icSigYCbCrData; };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * tqparent, KisProfile *p) { return new KisYCbCrU8ColorSpace(tqparent, p); };
virtual KisColorSpace *createColorSpace(KisColorSpaceFactoryRegistry * parent, KisProfile *p) { return new KisYCbCrU8ColorSpace(parent, p); };
virtual TQString defaultProfile() { return ""; };
};

8
chalk/colorspaces/ycbcr_u8/ycbcr_u8_plugin.cc
Unescape Escape View File

@ -35,14 +35,14 @@ typedef KGenericFactory<YCbCrU8Plugin> YCbCrU8PluginFactory;
K_EXPORT_COMPONENT_FACTORY( chalk_ycbcr_u8_plugin, YCbCrU8PluginFactory( "chalk" ) )
YCbCrU8Plugin::YCbCrU8Plugin(TQObject *tqparent, const char *name, const TQStringList &)
: KParts::Plugin(tqparent, name)
YCbCrU8Plugin::YCbCrU8Plugin(TQObject *parent, const char *name, const TQStringList &)
: KParts::Plugin(parent, name)
{
setInstance(YCbCrU8PluginFactory::instance());
if ( tqparent->inherits("KisColorSpaceFactoryRegistry") )
if ( parent->inherits("KisColorSpaceFactoryRegistry") )
{
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( tqparent );
KisColorSpaceFactoryRegistry * f = dynamic_cast<KisColorSpaceFactoryRegistry*>( parent );
KisColorSpace * colorSpaceYCbCrU8 = new KisYCbCrU8ColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisYCbCrU8ColorSpaceFactory();

2
chalk/colorspaces/ycbcr_u8/ycbcr_u8_plugin.h
Unescape Escape View File

@ -29,7 +29,7 @@ class YCbCrU8Plugin : public KParts::Plugin
Q_OBJECT
TQ_OBJECT
public:
YCbCrU8Plugin(TQObject *tqparent, const char *name, const TQStringList &);
YCbCrU8Plugin(TQObject *parent, const char *name, const TQStringList &);
virtual ~YCbCrU8Plugin();
};

6
chalk/core/createdcop.py
Unescape Escape View File

@ -34,7 +34,7 @@ class %(classname)sIface : virtual public DCOPObject
{
K_DCOP
public:
%(classname)sIface( %(classname)s * tqparent );
%(classname)sIface( %(classname)s * parent );
k_dcop:
private:
@ -73,10 +73,10 @@ dcopiface_template = """/*
#include <dcopclient.h>
%(classname)sIface::%(classname)sIface( %(classname)s * tqparent )
%(classname)sIface::%(classname)sIface( %(classname)s * parent )
: DCOPObject()
{
m_parent = tqparent;
m_parent = parent;
}
"""

10
chalk/core/kis_alpha_mask.cc
Unescape Escape View File

@ -109,19 +109,19 @@ void KisAlphaMask::computeAlpha(const TQImage& img)
}
}
KisAlphaMaskSP KisAlphaMask::interpolate(KisAlphaMaskSP tqmask1, KisAlphaMaskSP tqmask2, double t)
KisAlphaMaskSP KisAlphaMask::interpolate(KisAlphaMaskSP mask1, KisAlphaMaskSP mask2, double t)
{
Q_ASSERT((tqmask1->width() == tqmask2->width()) && (tqmask1->height() == tqmask2->height()));
Q_ASSERT((mask1->width() == mask2->width()) && (mask1->height() == mask2->height()));
Q_ASSERT(t > -DBL_EPSILON && t < 1 + DBL_EPSILON);
int width = tqmask1->width();
int height = tqmask1->height();
int width = mask1->width();
int height = mask1->height();
KisAlphaMaskSP outputMask = new KisAlphaMask(width, height);
Q_CHECK_PTR(outputMask);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
TQ_UINT8 d = static_cast<TQ_UINT8>((1 - t) * tqmask1->alphaAt(x, y) + t * tqmask2->alphaAt(x, y));
TQ_UINT8 d = static_cast<TQ_UINT8>((1 - t) * mask1->alphaAt(x, y) + t * mask2->alphaAt(x, y));
outputMask->setAlphaAt(x, y, d);
}
}

18
chalk/core/kis_alpha_mask.h
Unescape Escape View File

@ -28,15 +28,15 @@
/**
* KisAlphaMask is intended to create alpha values from a TQImage for use
* in brush creation. It is not a generic alpha tqmask that can be used with
* in brush creation. It is not a generic alpha mask that can be used with
* KisPaintDevices: use a KisSelection for that.
*/
class KisAlphaMask : public KShared {
public:
/**
Create an alpha tqmask based on the specified TQImage. If the image is
not a grayscale, the tqmask value is calculated from the effective grey
Create an alpha mask based on the specified TQImage. If the image is
not a grayscale, the mask value is calculated from the effective grey
level and alpha value.
*/
KisAlphaMask(const TQImage& img);
@ -48,7 +48,7 @@ class KisAlphaMask : public KShared {
KisAlphaMask(const TQImage& img, bool hasColor);
/**
Create a transparent tqmask.
Create a transparent mask.
*/
KisAlphaMask(TQ_INT32 width, TQ_INT32 height);
@ -60,7 +60,7 @@ class KisAlphaMask : public KShared {
TQ_INT32 height() const;
/**
@return the number of lines in the tqmask.
@return the number of lines in the mask.
*/
TQ_INT32 width() const;
@ -68,14 +68,14 @@ class KisAlphaMask : public KShared {
@return the alpha value at the specified position.
Returns TQ_UINT8 OPACITY_TRANSPARENT if the value is
outside the bounds of the tqmask.
outside the bounds of the mask.
XXX: this is, of course, not the best way of masking.
Better would be to let KisAlphaMask fill a chunk of memory
with the alpha values at the right position, something like
void applyMask(TQ_UINT8 *pixeldata, TQ_INT32 pixelWidth,
TQ_INT32 alphaPos). That would be fastest, or we could
provide an iterator over the tqmask, that would be nice, too.
provide an iterator over the mask, that would be nice, too.
*/
inline TQ_UINT8 alphaAt(TQ_INT32 x, TQ_INT32 y) const
{
@ -89,9 +89,9 @@ class KisAlphaMask : public KShared {
void setAlphaAt(TQ_INT32 x, TQ_INT32 y, TQ_UINT8 alpha);
// Create a new tqmask by interpolating between tqmask1 and tqmask2 as t
// Create a new mask by interpolating between mask1 and mask2 as t
// goes from 0 to 1.
static KisAlphaMaskSP interpolate(KisAlphaMaskSP tqmask1, KisAlphaMaskSP tqmask2, double t);
static KisAlphaMaskSP interpolate(KisAlphaMaskSP mask1, KisAlphaMaskSP mask2, double t);
private:
void computeAlpha(const TQImage& img);

16
chalk/core/kis_brush.cc
Unescape Escape View File

@ -375,7 +375,7 @@ TQImage KisBrush::img()
return image;
}
KisAlphaMaskSP KisBrush::tqmask(const KisPaintInformation& info, double subPixelX, double subPixelY) const
KisAlphaMaskSP KisBrush::mask(const KisPaintInformation& info, double subPixelX, double subPixelY) const
{
if (m_scaledBrushes.isEmpty()) {
createScaledBrushes();
@ -405,9 +405,9 @@ KisAlphaMaskSP KisBrush::tqmask(const KisPaintInformation& info, double subPixel
// Exact match.
outputMask = scaleMask(aboveBrush, scale, subPixelX, subPixelY);
} else {
// We are smaller than the smallest tqmask, which is always 1x1.
// We are smaller than the smallest mask, which is always 1x1.
double s = scale / aboveBrush->scale();
outputMask = scaleSinglePixelMask(s, aboveBrush->tqmask()->alphaAt(0, 0), subPixelX, subPixelY);
outputMask = scaleSinglePixelMask(s, aboveBrush->mask()->alphaAt(0, 0), subPixelX, subPixelY);
}
}
@ -629,7 +629,7 @@ KisAlphaMaskSP KisBrush::scaleMask(const ScaledBrush *srcBrush, double scale, do
KisAlphaMaskSP dstMask = new KisAlphaMask(dstWidth, dstHeight);
Q_CHECK_PTR(dstMask);
KisAlphaMaskSP srcMask = srcBrush->tqmask();
KisAlphaMaskSP srcMask = srcBrush->mask();
// Compute scales to map the scaled brush onto the required scale.
double xScale = srcBrush->xScale() / scale;
@ -1167,7 +1167,7 @@ TQImage KisBrush::interpolate(const TQImage& image1, const TQImage& image2, doub
KisBrush::ScaledBrush::ScaledBrush()
{
m_tqmask = 0;
m_mask = 0;
m_image = TQImage();
m_scale = 1;
m_xScale = 1;
@ -1176,7 +1176,7 @@ KisBrush::ScaledBrush::ScaledBrush()
KisBrush::ScaledBrush::ScaledBrush(KisAlphaMaskSP scaledMask, const TQImage& scaledImage, double scale, double xScale, double yScale)
{
m_tqmask = scaledMask;
m_mask = scaledMask;
m_image = scaledImage;
m_scale = scale;
m_xScale = xScale;
@ -1262,7 +1262,7 @@ void KisBrush::generateBoundary() {
if (brushType() == IMAGE || brushType() == PIPE_IMAGE) {
dev = image(KisMetaRegistry::instance()->csRegistry() ->getColorSpace(KisID("RGBA",""),""), KisPaintInformation());
} else {
KisAlphaMaskSP atqmask = tqmask(KisPaintInformation());
KisAlphaMaskSP amask = mask(KisPaintInformation());
KisColorSpace* cs = KisMetaRegistry::instance()->csRegistry()->getColorSpace(KisID("RGBA",""),"");
dev = new KisPaintDevice(cs, "tmp for generateBoundary");
for (int y = 0; y < h; y++) {
@ -1270,7 +1270,7 @@ void KisBrush::generateBoundary() {
int x = 0;
while(!it.isDone()) {
cs->setAlpha(it.rawData(), atqmask->alphaAt(x++, y), 1);
cs->setAlpha(it.rawData(), amask->alphaAt(x++, y), 1);
++it;
}
}

10
chalk/core/kis_brush.h
Unescape Escape View File

@ -77,10 +77,10 @@ public:
virtual bool saveToDevice(TQIODevice* dev) const;
/**
@return a tqmask computed from the grey-level values of the
@return a mask computed from the grey-level values of the
pixels in the brush.
*/
virtual KisAlphaMaskSP tqmask(const KisPaintInformation& info,
virtual KisAlphaMaskSP mask(const KisPaintInformation& info,
double subPixelX = 0, double subPixelY = 0) const;
// XXX: return non-tiled simple buffer
virtual KisPaintDeviceSP image(KisColorSpace * colorSpace, const KisPaintInformation& info,
@ -94,7 +94,7 @@ public:
double xSpacing(double pressure = PRESSURE_DEFAULT) const;
double ySpacing(double pressure = PRESSURE_DEFAULT) const;
// Dimensions in pixels of the tqmask/image at a given pressure.
// Dimensions in pixels of the mask/image at a given pressure.
TQ_INT32 maskWidth(const KisPaintInformation& info) const;
TQ_INT32 maskHeight(const KisPaintInformation& info) const;
@ -135,11 +135,11 @@ private:
double scale() const { return m_scale; }
double xScale() const { return m_xScale; }
double yScale() const { return m_yScale; }
KisAlphaMaskSP tqmask() const { return m_tqmask; }
KisAlphaMaskSP mask() const { return m_mask; }
TQImage image() const { return m_image; }
private:
KisAlphaMaskSP m_tqmask;
KisAlphaMaskSP m_mask;
TQImage m_image;
double m_scale;
double m_xScale;

4
chalk/core/kis_fill_painter.cc
Unescape Escape View File

@ -203,10 +203,10 @@ void KisFillPainter::genericFillEnd(KisPaintDeviceSP filled) {
}
struct FillSegment {
FillSegment(int x, int y/*, FillSegment* tqparent*/) : x(x), y(y)/*, tqparent(tqparent)*/ {}
FillSegment(int x, int y/*, FillSegment* parent*/) : x(x), y(y)/*, parent(parent)*/ {}
int x;
int y;
// FillSegment* tqparent;
// FillSegment* parent;
};
typedef enum { None = 0, Added = 1, Checked = 2 } tqStatus;

2
chalk/core/kis_fill_painter.h
Unescape Escape View File

@ -102,7 +102,7 @@ public:
void fillPattern(int startX, int startY);
/**
* Returns a selection tqmask for the floodfill starting at the specified position.
* Returns a selection mask for the floodfill starting at the specified position.
**/
KisSelectionSP createFloodSelection(int startX, int startY);

4
chalk/core/kis_filter.h
Unescape Escape View File

@ -158,12 +158,12 @@ public:
/**
* Create the configuration widget for this filter.
*
* @param tqparent the TQt owner widget of this widget
* @param parent the TQt owner widget of this widget
* @param dev the paintdevice this filter will act on
    * @return NULL if the filter does not use user-settable configuration settings.
    *         else return a pointer to the new configuration widget
*/
virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget * tqparent, KisPaintDeviceSP dev);
virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget * parent, KisPaintDeviceSP dev);
virtual void cancel() { m_cancelRequested = true; }

4
chalk/core/kis_filter_config_widget.cc
Unescape Escape View File

@ -19,8 +19,8 @@
#include "kis_filter_config_widget.h"
KisFilterConfigWidget::KisFilterConfigWidget(TQWidget * tqparent, const char * name, WFlags f)
: TQWidget(tqparent, name, f)
KisFilterConfigWidget::KisFilterConfigWidget(TQWidget * parent, const char * name, WFlags f)
: TQWidget(parent, name, f)
{
}

2
chalk/core/kis_filter_config_widget.h
Unescape Escape View File

@ -33,7 +33,7 @@ class KisFilterConfigWidget : public TQWidget {
public:
KisFilterConfigWidget(TQWidget * tqparent, const char * name = 0, WFlags f = 0 );
KisFilterConfigWidget(TQWidget * parent, const char * name = 0, WFlags f = 0 );
virtual ~KisFilterConfigWidget();
virtual void setConfiguration(KisFilterConfiguration * config) = 0;

20
chalk/core/kis_group_layer.cc
Unescape Escape View File

@ -90,9 +90,9 @@ bool KisGroupLayer::paintLayerInducesProjectionOptimization(KisPaintLayer* l) {
KisPaintDeviceSP KisGroupLayer::projection(const TQRect & rect)
{
// We don't have a tqparent, and we've got only one child: abuse the child's
// We don't have a parent, and we've got only one child: abuse the child's
// paint device as the projection if the child is visible and 100% opaque
if (tqparent() == 0 && childCount() == 1) {
if (parent() == 0 && childCount() == 1) {
KisPaintLayerSP l = dynamic_cast<KisPaintLayer*>(firstChild().data());
if (paintLayerInducesProjectionOptimization(l)) {
l->setClean(rect);
@ -146,14 +146,14 @@ KisLayerSP KisGroupLayer::at(int index) const
int KisGroupLayer::index(KisLayerSP layer) const
{
if (layer->tqparent().data() == this)
if (layer->parent().data() == this)
return layer->index();
return -1;
}
void KisGroupLayer::setIndex(KisLayerSP layer, int index)
{
if (layer->tqparent().data() != this)
if (layer->parent().data() != this)
return;
//TODO optimize
removeLayer(layer);
@ -163,7 +163,7 @@ void KisGroupLayer::setIndex(KisLayerSP layer, int index)
bool KisGroupLayer::addLayer(KisLayerSP newLayer, int x)
{
if (x < 0 || kClamp(uint(x), uint(0), childCount()) != uint(x) ||
newLayer->tqparent() || m_layers.contains(newLayer))
newLayer->parent() || m_layers.contains(newLayer))
{
kdWarning() << "invalid input to KisGroupLayer::addLayer(KisLayerSP newLayer, int x)!" << endl;
return false;
@ -185,7 +185,7 @@ bool KisGroupLayer::addLayer(KisLayerSP newLayer, int x)
bool KisGroupLayer::addLayer(KisLayerSP newLayer, KisLayerSP aboveThis)
{
if (aboveThis && aboveThis->tqparent().data() != this)
if (aboveThis && aboveThis->parent().data() != this)
{
kdWarning() << "invalid input to KisGroupLayer::addLayer(KisLayerSP newLayer, KisLayerSP aboveThis)!" << endl;
return false;
@ -219,7 +219,7 @@ bool KisGroupLayer::removeLayer(int x)
bool KisGroupLayer::removeLayer(KisLayerSP layer)
{
if (layer->tqparent().data() != this)
if (layer->parent().data() != this)
{
kdWarning() << "invalid input to KisGroupLayer::removeLayer()!" << endl;
return false;
@ -317,7 +317,7 @@ void KisGroupLayer::updateProjection(const TQRect & rc)
// If this is the rootlayer, don't do anything with adj. layers that are below the
// first paintlayer
bool gotPaintLayer = (tqparent() != 0);
bool gotPaintLayer = (parent() != 0);
// Look through all the child layers, searching for the first dirty layer
// if it's found, and if we have found an adj. layer before the the dirty layer,
@ -404,8 +404,8 @@ void KisGroupLayer::updateProjection(const TQRect & rc)
const KisCompositeOp cop = child->compositeOp();
const bool block = child->signalsBlocked();
child->blockSignals(true);
// Composite op copy doesn't take a tqmask/selection into account, so we need
// to make a difference between a paintlayer with a tqmask, and one without
// Composite op copy doesn't take a mask/selection into account, so we need
// to make a difference between a paintlayer with a mask, and one without
KisPaintLayer* l = dynamic_cast<KisPaintLayer*>(child.data());
if (l && l->hasMask())
child->m_compositeOp = COMPOSITE_OVER;

4
chalk/core/kis_group_layer.h
Unescape Escape View File

@ -48,14 +48,14 @@ public:
public:
/**
* Set the entire layer extent dirty; this percolates up to tqparent layers all the
* Set the entire layer extent dirty; this percolates up to parent layers all the
* way to the root layer.
*/
virtual void setDirty(bool propagate = true);
/**
* Add the given rect to the set of dirty rects for this layer;
* this percolates up to tqparent layers all the way to the root
* this percolates up to parent layers all the way to the root
* layer.
*/
virtual void setDirty(const TQRect & rect, bool propagate = true);

50
chalk/core/kis_image.cc
Unescape Escape View File

@ -258,12 +258,12 @@ namespace {
typedef KisImageCommand super;
public:
KisLayerPositionCommand(const TQString& name, KisImageSP image, KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis) : super(name, image)
KisLayerPositionCommand(const TQString& name, KisImageSP image, KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis) : super(name, image)
{
m_layer = layer;
m_oldParent = layer->tqparent();
m_oldParent = layer->parent();
m_oldAboveThis = layer->nextSibling();
m_newParent = tqparent;
m_newParent = parent;
m_newAboveThis = aboveThis;
}
@ -300,7 +300,7 @@ namespace {
{
m_img = img;
m_layer = layer;
m_parent = layer->tqparent();
m_parent = layer->parent();
m_aboveThis = layer->nextSibling();
}
@ -385,7 +385,7 @@ namespace {
m_layer = layer;
m_prevParent = wasParent;
m_prevAbove = wasAbove;
m_newParent = layer->tqparent();
m_newParent = layer->parent();
m_newAbove = layer->nextSibling();
}
@ -1048,7 +1048,7 @@ KisLayerSP KisImage::newLayer(const TQString& name, TQ_UINT8 opacity, const KisC
layer->setVisible(true);
if (m_activeLayer != 0) {
addLayer(layer, m_activeLayer->tqparent().data(), m_activeLayer->nextSibling());
addLayer(layer, m_activeLayer->parent().data(), m_activeLayer->nextSibling());
}
else {
addLayer(layer, m_rootLayer, 0);
@ -1116,17 +1116,17 @@ KisLayerSP KisImage::findLayer(int id) const
}
bool KisImage::addLayer(KisLayerSP layer, KisGroupLayerSP tqparent)
bool KisImage::addLayer(KisLayerSP layer, KisGroupLayerSP parent)
{
return addLayer(layer, tqparent, tqparent->firstChild());
return addLayer(layer, parent, parent->firstChild());
}
bool KisImage::addLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis)
bool KisImage::addLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis)
{
if (!tqparent)
if (!parent)
return false;
const bool success = tqparent->addLayer(layer, aboveThis);
const bool success = parent->addLayer(layer, aboveThis);
if (success)
{
KisPaintLayerSP player = dynamic_cast<KisPaintLayer*>(layer.data());
@ -1163,7 +1163,7 @@ bool KisImage::removeLayer(KisLayerSP layer)
if (!layer || layer->image() != this)
return false;
if (KisGroupLayerSP tqparent = layer->tqparent()) {
if (KisGroupLayerSP parent = layer->parent()) {
// Adjustment layers should mark the layers underneath them, whose rendering
// they have cached, diryt on removal. Otherwise, the group won't be re-rendered.
KisAdjustmentLayer * al = dynamic_cast<KisAdjustmentLayer*>(layer.data());
@ -1196,21 +1196,21 @@ bool KisImage::removeLayer(KisLayerSP layer)
const bool wasActive = layer == activeLayer();
// sigLayerRemoved can set it to 0, we don't want that in the else of wasActive!
KisLayerSP actLayer = activeLayer();
const bool success = tqparent->removeLayer(layer);
const bool success = parent->removeLayer(layer);
if (success) {
layer->setImage(0);
if (!layer->temporary() && undo()) {
m_adapter->addCommand(new LayerRmCmd(m_adapter, this, layer, tqparent, wasAbove));
m_adapter->addCommand(new LayerRmCmd(m_adapter, this, layer, parent, wasAbove));
}
if (!layer->temporary()) {
emit sigLayerRemoved(layer, tqparent, wasAbove);
emit sigLayerRemoved(layer, parent, wasAbove);
if (wasActive) {
if (wasBelow)
activate(wasBelow);
else if (wasAbove)
activate(wasAbove);
else if (tqparent != rootLayer())
activate(tqparent.data());
else if (parent != rootLayer())
activate(parent.data());
else
activate(rootLayer()->firstChild());
} else {
@ -1228,7 +1228,7 @@ bool KisImage::raiseLayer(KisLayerSP layer)
{
if (!layer)
return false;
return moveLayer(layer, layer->tqparent().data(), layer->prevSibling());
return moveLayer(layer, layer->parent().data(), layer->prevSibling());
}
bool KisImage::lowerLayer(KisLayerSP layer)
@ -1236,7 +1236,7 @@ bool KisImage::lowerLayer(KisLayerSP layer)
if (!layer)
return false;
if (KisLayerSP next = layer->nextSibling())
return moveLayer(layer, layer->tqparent().data(), next->nextSibling());
return moveLayer(layer, layer->parent().data(), next->nextSibling());
return false;
}
@ -1254,15 +1254,15 @@ bool KisImage::toBottom(KisLayerSP layer)
return moveLayer(layer, rootLayer(), 0);
}
bool KisImage::moveLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis)
bool KisImage::moveLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis)
{
if (!tqparent)
if (!parent)
return false;
KisGroupLayerSP wasParent = layer->tqparent();
KisGroupLayerSP wasParent = layer->parent();
KisLayerSP wasAbove = layer->nextSibling();
if (wasParent.data() == tqparent.data() && wasAbove.data() == aboveThis.data())
if (wasParent.data() == parent.data() && wasAbove.data() == aboveThis.data())
return false;
lock();
@ -1272,7 +1272,7 @@ bool KisImage::moveLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP
return false;
}
const bool success = tqparent->addLayer(layer, aboveThis);
const bool success = parent->addLayer(layer, aboveThis);
layer->setDirty();
@ -1357,7 +1357,7 @@ void KisImage::mergeLayer(KisLayerSP layer)
layer->accept(visitor);
removeLayer(layer->nextSibling());
addLayer(player, layer->tqparent(), layer);
addLayer(player, layer->parent(), layer);
removeLayer(layer);
undoAdapter()->endMacro();

22
chalk/core/kis_image.h
Unescape Escape View File

@ -248,23 +248,23 @@ public:
KisLayerSP findLayer(int id) const;
/// Move layer to specified position
bool moveLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis);
bool moveLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis);
/**
* Add an already existing layer to the image. The layer is put on top
* of the layers in the specified layergroup
* @param layer the layer to be added
* @param tqparent the tqparent layer
* @param parent the parent layer
*/
bool addLayer(KisLayerSP layer, KisGroupLayerSP tqparent);
bool addLayer(KisLayerSP layer, KisGroupLayerSP parent);
/**
* Add already existing layer to image.
*
* @param layer the layer to be added
* @param tqparent the tqparent layer
* @param parent the parent layer
* @param aboveThis in the list with child layers of the specified
* tqparent, add this layer above the specified sibling.
* parent, add this layer above the specified sibling.
* if 0, the layer is put in the lowermost position in
* its group.
* @param notify If true, the image is immediately recomposited, if false,
@ -272,7 +272,7 @@ public:
*
* returns false if adding the layer didn't work, true if the layer got added
*/
bool addLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis);
bool addLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis);
/// Remove layer
bool removeLayer(KisLayerSP layer);
@ -355,21 +355,21 @@ signals:
/// Emitted after a different layer is made active.
void sigLayerActivated(KisLayerSP layer);
/// Emitted after a layer is added: you can find out where by asking it for its tqparent(), et al.
/// Emitted after a layer is added: you can find out where by asking it for its parent(), et al.
void sigLayerAdded(KisLayerSP layer);
/** Emitted after a layer is removed.
It's no longer in the image, but still exists, so @p layer is valid.
@param layer the removed layer
@param tqparent the tqparent of the layer, before it was removed
@param parent the parent of the layer, before it was removed
@param wasAboveThis the layer it was above, before it was removed.
*/
void sigLayerRemoved(KisLayerSP layer, KisGroupLayerSP wasParent, KisLayerSP wasAboveThis);
/** Emitted after a layer is moved to a different position under its tqparent layer, or its tqparent changes.
/** Emitted after a layer is moved to a different position under its parent layer, or its parent changes.
@param previousParent the tqparent of the layer, before it was moved
@param previousParent the parent of the layer, before it was moved
@param wasAboveThis the layer it was above, before it was moved.
*/
void sigLayerMoved(KisLayerSP layer, KisGroupLayerSP previousParent, KisLayerSP wasAboveThis);
@ -409,7 +409,7 @@ signals:
void sigColorSpaceChanged(KisColorSpace* cs);
/// Emitted when any layer's tqmask info got updated (or when the current layer changes)
/// Emitted when any layer's mask info got updated (or when the current layer changes)
void sigMaskInfoChanged();
public slots:
void slotSelectionChanged();

4
chalk/core/kis_imagepipe_brush.cc
Unescape Escape View File

@ -318,11 +318,11 @@ TQImage KisImagePipeBrush::img()
}
}
KisAlphaMaskSP KisImagePipeBrush::tqmask(const KisPaintInformation& info, double subPixelX, double subPixelY) const
KisAlphaMaskSP KisImagePipeBrush::mask(const KisPaintInformation& info, double subPixelX, double subPixelY) const
{
if (m_brushes.isEmpty()) return 0;
selectNextBrush(info);
return m_brushes.at(m_currentBrush)->tqmask(info, subPixelX, subPixelY);
return m_brushes.at(m_currentBrush)->mask(info, subPixelX, subPixelY);
}
KisPaintDeviceSP KisImagePipeBrush::image(KisColorSpace * colorSpace, const KisPaintInformation& info, double subPixelX, double subPixelY) const

4
chalk/core/kis_imagepipe_brush.h
Unescape Escape View File

@ -125,9 +125,9 @@ public:
virtual TQImage img();
/**
@return the next tqmask in the pipe.
@return the next mask in the pipe.
*/
virtual KisAlphaMaskSP tqmask(const KisPaintInformation& info,
virtual KisAlphaMaskSP mask(const KisPaintInformation& info,
double subPixelX = 0, double subPixelY = 0) const;
virtual KisPaintDeviceSP image(KisColorSpace * colorSpace, const KisPaintInformation& info,
double subPixelX = 0, double subPixelY = 0) const;

2
chalk/core/kis_iteratorpixeltrait.h
Unescape Escape View File

@ -103,7 +103,7 @@ public:
};
/**
* Returns the selectiontqmask from the current point; this is guaranteed
* Returns the selectionmask from the current point; this is guaranteed
* to have the same number of consecutive pixels that the iterator has
* at a given point. It return a 0 if there is no selection.
*/

12
chalk/core/kis_iterators_pixel.h
Unescape Escape View File

@ -66,10 +66,10 @@ public:
TQ_INT32 nConseqHPixels() const {
if (m_selectionIterator) {
TQ_INT32 tqparent = KisHLineIteratorPixel::nConseqHPixels();
TQ_INT32 parent = KisHLineIteratorPixel::nConseqHPixels();
TQ_INT32 selection = m_selectionIterator->nConseqHPixels();
if (tqparent < selection)
return tqparent;
if (parent < selection)
return parent;
return selection;
}
return KisHLineIteratorPixel::nConseqHPixels();
@ -137,10 +137,10 @@ public:
TQ_INT32 nConseqPixels() const {
if (m_selectionIterator) {
TQ_INT32 tqparent = KisRectIterator::nConseqPixels();
TQ_INT32 parent = KisRectIterator::nConseqPixels();
TQ_INT32 selection = m_selectionIterator->nConseqPixels();
if (tqparent < selection)
return tqparent;
if (parent < selection)
return parent;
return selection;
}
return KisRectIterator::nConseqPixels();

18
chalk/core/kis_layer.cc
Unescape Escape View File

@ -341,7 +341,7 @@ void KisLayer::setDirty(bool propagate)
if (rc.isValid()) m_dirtyRect = rc;
// If we're dirty, our tqparent is dirty, if we've got a tqparent
// If we're dirty, our parent is dirty, if we've got a parent
if (propagate && m_parent && rc.isValid()) m_parent->setDirty(m_dirtyRect);
if (m_image && rc.isValid()) {
@ -351,7 +351,7 @@ void KisLayer::setDirty(bool propagate)
void KisLayer::setDirty(const TQRect & rc, bool propagate)
{
// If we're dirty, our tqparent is dirty, if we've got a tqparent
// If we're dirty, our parent is dirty, if we've got a parent
if (rc.isValid())
m_dirtyRect |= rc;
@ -364,23 +364,23 @@ void KisLayer::setDirty(const TQRect & rc, bool propagate)
}
}
KisGroupLayerSP KisLayer::tqparent() const
KisGroupLayerSP KisLayer::parent() const
{
return m_parent;
}
KisLayerSP KisLayer::prevSibling() const
{
if (!tqparent())
if (!parent())
return 0;
return tqparent()->at(index() - 1);
return parent()->at(index() - 1);
}
KisLayerSP KisLayer::nextSibling() const
{
if (!tqparent())
if (!parent())
return 0;
return tqparent()->at(index() + 1);
return parent()->at(index() + 1);
}
int KisLayer::index() const
@ -390,9 +390,9 @@ int KisLayer::index() const
void KisLayer::setIndex(int i)
{
if (!tqparent())
if (!parent())
return;
tqparent()->setIndex(this, i);
parent()->setIndex(this, i);
}
KisLayerSP KisLayer::findLayer(const TQString& n) const

26
chalk/core/kis_layer.h
Unescape Escape View File

@ -69,14 +69,14 @@ public:
/**
* Set the entire layer extent dirty; this percolates up to tqparent layers all the
* Set the entire layer extent dirty; this percolates up to parent layers all the
* way to the root layer.
*/
virtual void setDirty(bool propagate = true);
/**
* Add the given rect to the set of dirty rects for this layer;
* this percolates up to tqparent layers all the way to the root
* this percolates up to parent layers all the way to the root
* layer.
*/
virtual void setDirty(const TQRect & rect, bool propagate = true);
@ -87,41 +87,41 @@ public:
/// Returns the ID of the layer, which is guaranteed to be unique among all KisLayers.
int id() const { return m_id; }
/* Returns the index of the layer in its tqparent's list of child layers. Indices
/* Returns the index of the layer in its parent's list of child layers. Indices
* increase from 0, which is the topmost layer in the list, to the bottommost.
*/
virtual int index() const;
/// Moves this layer to the specified index within its tqparent's list of child layers.
/// Moves this layer to the specified index within its parent's list of child layers.
virtual void setIndex(int index);
/**
* Returns the tqparent layer of a layer. This is 0 only for a root layer; otherwise
* Returns the parent layer of a layer. This is 0 only for a root layer; otherwise
* this will be an actual GroupLayer */
virtual KisGroupLayerSP tqparent() const;
virtual KisGroupLayerSP parent() const;
/**
* Returns the previous sibling of this layer in the tqparent's list. This is the layer
* *above* this layer. 0 is returned if there is no tqparent, or if this child has no more
* Returns the previous sibling of this layer in the parent's list. This is the layer
* *above* this layer. 0 is returned if there is no parent, or if this child has no more
* previous siblings (== firstChild())
*/
virtual KisLayerSP prevSibling() const;
/**
* Returns the next sibling of this layer in the tqparent's list. This is the layer *below*
* this layer. 0 is returned if there is no tqparent, or if this child has no more next
* Returns the next sibling of this layer in the parent's list. This is the layer *below*
* this layer. 0 is returned if there is no parent, or if this child has no more next
* siblings (== lastChild())
*/
virtual KisLayerSP nextSibling() const;
/**
* Returns the sibling above this layer in its tqparent's list. 0 is returned if there is no tqparent,
* Returns the sibling above this layer in its parent's list. 0 is returned if there is no parent,
* or if this layer is the topmost layer in its group. This is the same as calling prevSibling().
*/
KisLayerSP siblingAbove() const { return prevSibling(); }
/**
* Returns the sibling below this layer in its tqparent's list. 0 is returned if there is no tqparent,
* Returns the sibling below this layer in its parent's list. 0 is returned if there is no parent,
* or if this layer is the bottommost layer in its group. This is the same as calling nextSibling().
*/
KisLayerSP siblingBelow() const { return nextSibling(); }
@ -197,7 +197,7 @@ public:
KisUndoAdapter *undoAdapter() const;
/// paints a tqmask where the selection on this layer resides
/// paints a mask where the selection on this layer resides
virtual void paintSelection(TQImage &img, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h);
virtual void paintSelection(TQImage &img, const TQRect& scaledImageRect, const TQSize& scaledImageSize, const TQSize& imageSize);

26
chalk/core/kis_merge_visitor.h
Unescape Escape View File

@ -114,11 +114,11 @@ public:
gc.bitBlt(dx, dy, layer->compositeOp(), source, layer->opacity(), sx, sy, w, h);
} else {
if (layer->renderMask()) {
// To display the tqmask, we don't do things with composite op and opacity
// To display the mask, we don't do things with composite op and opacity
// This is like the gimp does it, I guess that's ok?
// Note that here we'll use m_rc, because even if the extent of the device is
// empty, we want a full tqmask to be drawn! (we don't change rc, since
// empty, we want a full mask to be drawn! (we don't change rc, since
// it'd mess with setClean). This is because KisPainter::bitBlt &'s with
// the source device's extent. This is ok in normal circumstances, but
// we changed the default tile. Fixing this properly would mean fixing it there.
@ -129,36 +129,36 @@ public:
dx = sx;
dy = sy;
// The problem is that the extent of the layer tqmask might not be extended
// The problem is that the extent of the layer mask might not be extended
// enough. Check if that is the case
KisPaintDeviceSP tqmask = layer->getMask();
TQRect mextent = tqmask->extent();
KisPaintDeviceSP mask = layer->getMask();
TQRect mextent = mask->extent();
if ((mextent & m_rc) != m_rc) {
// Iterate over all pixels in the m_rc area. With just accessing the
// tiles in read-write mode, we ensure that the tiles get created if they
// do not exist. If they do, they'll remain untouched since we don't
// actually write data to it.
// XXX Admission: this is actually kind of a hack :-(
KisRectIteratorPixel it = tqmask->createRectIterator(sx, sy, w, h, true);
KisRectIteratorPixel it = mask->createRectIterator(sx, sy, w, h, true);
while (!it.isDone())
++it;
}
if (tempTarget) {
KisPaintDeviceSP temp = new KisPaintDevice(source->colorSpace());
tqmask = paintIndirect(tqmask, temp, layer, sx, sy, dx, dy, w, h);
mask = paintIndirect(mask, temp, layer, sx, sy, dx, dy, w, h);
}
gc.bitBlt(dx, dy, COMPOSITE_OVER, tqmask, OPACITY_OPAQUE, sx, sy, w, h);
gc.bitBlt(dx, dy, COMPOSITE_OVER, mask, OPACITY_OPAQUE, sx, sy, w, h);
} else {
KisSelectionSP tqmask = layer->getMaskAsSelection();
// The indirect painting happens on the tqmask
KisSelectionSP mask = layer->getMaskAsSelection();
// The indirect painting happens on the mask
if (tempTarget && layer->editMask()) {
KisPaintDeviceSP maskSrc = layer->getMask();
KisPaintDeviceSP temp = new KisPaintDevice(maskSrc->colorSpace());
temp = paintIndirect(maskSrc, temp, layer, sx, sy, dx, dy, w, h);
// Blegh
KisRectIteratorPixel srcIt = temp->createRectIterator(sx, sy, w, h, false);
KisRectIteratorPixel dstIt = tqmask->createRectIterator(sx, sy, w, h, true);
KisRectIteratorPixel dstIt = mask->createRectIterator(sx, sy, w, h, true);
while(!dstIt.isDone()) {
// Same as in convertMaskToSelection
@ -167,7 +167,7 @@ public:
++dstIt;
}
} else if (tempTarget) {
// We have a tqmask, and paint indirect, but not on the tqmask
// We have a mask, and paint indirect, but not on the mask
KisPaintDeviceSP temp = new KisPaintDevice(source->colorSpace());
source = paintIndirect(source, temp, layer, sx, sy, dx, dy, w, h);
}
@ -175,7 +175,7 @@ public:
gc.bltSelection(dx, dy,
layer->compositeOp(),
source,
tqmask,
mask,
layer->opacity(), sx, sy, w, h);
}
}

14
chalk/core/kis_paint_device.cc
Unescape Escape View File

@ -236,7 +236,7 @@ KisPaintDevice::KisPaintDevice(KisColorSpace * colorSpace, const char * name) :
}
KisPaintDevice::KisPaintDevice(KisLayer *tqparent, KisColorSpace * colorSpace, const char * name) :
KisPaintDevice::KisPaintDevice(KisLayer *parent, KisColorSpace * colorSpace, const char * name) :
TQObject(0, name), KShared(), m_exifInfo(0), m_lock( false )
{
@ -250,10 +250,10 @@ KisPaintDevice::KisPaintDevice(KisLayer *tqparent, KisColorSpace * colorSpace, c
m_selectionDeselected = false;
m_selection = 0;
m_parentLayer = tqparent;
m_parentLayer = parent;
if (colorSpace == 0 && tqparent != 0 && tqparent->image() != 0) {
m_colorSpace = tqparent->image()->colorSpace();
if (colorSpace == 0 && parent != 0 && parent->image() != 0) {
m_colorSpace = parent->image()->colorSpace();
}
else {
m_colorSpace = colorSpace;
@ -1107,15 +1107,15 @@ void KisPaintDevice::clearSelection()
}
}
void KisPaintDevice::applySelectionMask(KisSelectionSP tqmask)
void KisPaintDevice::applySelectionMask(KisSelectionSP mask)
{
TQRect r = tqmask->selectedRect();
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 = tqmask->createHLineIterator(r.x(), y, r.width(), false);
KisHLineIterator maskIt = mask->createHLineIterator(r.x(), y, r.width(), false);
while (!pixelIt.isDone()) {
// XXX: Optimize by using stretches

12
chalk/core/kis_paint_device.h
Unescape Escape View File

@ -274,7 +274,7 @@ public:
virtual TQImage convertToTQImage(KisProfile * dstProfile, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h, float exposure = 0.0f);
/**
* Create an RGBA TQImage from a rectangle in the paint device. The rectangle is defined by the tqparent image's bounds.
* Create an RGBA TQImage from a rectangle in the paint device. The rectangle is defined by the parent image's bounds.
*
* @param dstProfile RGB profile to use in conversion. May be 0, in which
* case it's up to the colour strategy to choose a profile (most
@ -403,12 +403,12 @@ public:
void setParentLayer(KisLayer *parentLayer);
/**
* Add the specified rect top the tqparent layer (if present)
* Add the specified rect top the parent layer (if present)
*/
virtual void setDirty(const TQRect & rc);
/**
* Set the tqparent layer completely dirty, if this paint device has one.
* Set the parent layer completely dirty, if this paint device has one.
*/
virtual void setDirty();
@ -479,10 +479,10 @@ public:
void clearSelection();
/**
* Apply a tqmask to the image data, i.e. multiply each pixel's opacity by its
* selectedness in the tqmask.
* Apply a mask to the image data, i.e. multiply each pixel's opacity by its
* selectedness in the mask.
*/
void applySelectionMask(KisSelectionSP tqmask);
void applySelectionMask(KisSelectionSP mask);
/**
* Sets the selection of this paint device to the new selection,

4
chalk/core/kis_paint_device_iface.cc
Unescape Escape View File

@ -27,10 +27,10 @@
#include "kis_paint_device.h"
KisPaintDeviceIface::KisPaintDeviceIface( KisPaintDevice * tqparent )
KisPaintDeviceIface::KisPaintDeviceIface( KisPaintDevice * parent )
: DCOPObject("paintdevice")
{
m_parent = tqparent;
m_parent = parent;
}
TQ_INT32 KisPaintDeviceIface::pixelSize() const

2
chalk/core/kis_paint_device_iface.h
Unescape Escape View File

@ -31,7 +31,7 @@ class KisPaintDeviceIface : virtual public DCOPObject
{
K_DCOP
public:
KisPaintDeviceIface( KisPaintDevice * tqparent );
KisPaintDeviceIface( KisPaintDevice * parent );
k_dcop:
/**

84
chalk/core/kis_paint_layer.cc
Unescape Escape View File

@ -39,7 +39,7 @@ KisPaintLayer::KisPaintLayer(KisImage *img, const TQString& name, TQ_UINT8 opaci
Q_ASSERT(img);
Q_ASSERT(dev);
m_paintdev = dev;
m_tqmask = 0;
m_mask = 0;
m_maskAsSelection = 0;
m_paintdev->setParentLayer(this);
m_renderMask = false;
@ -52,7 +52,7 @@ KisPaintLayer::KisPaintLayer(KisImage *img, const TQString& name, TQ_UINT8 opaci
{
Q_ASSERT(img);
m_paintdev = new KisPaintDevice(this, img->colorSpace(), name.latin1());
m_tqmask = 0;
m_mask = 0;
m_maskAsSelection = 0;
m_renderMask = false;
m_editMask = true;
@ -64,7 +64,7 @@ KisPaintLayer::KisPaintLayer(KisImage *img, const TQString& name, TQ_UINT8 opaci
Q_ASSERT(img);
Q_ASSERT(colorSpace);
m_paintdev = new KisPaintDevice(this, colorSpace, name.latin1());
m_tqmask = 0;
m_mask = 0;
m_maskAsSelection = 0;
m_renderMask = false;
m_editMask = true;
@ -76,8 +76,8 @@ KisPaintLayer::KisPaintLayer(const KisPaintLayer& rhs) :
m_paintdev = new KisPaintDevice( *rhs.m_paintdev.data() );
m_paintdev->setParentLayer(this);
if (rhs.hasMask()) {
m_tqmask = new KisPaintDevice(*rhs.m_tqmask.data());
m_tqmask->setParentLayer(this);
m_mask = new KisPaintDevice(*rhs.m_mask.data());
m_mask->setParentLayer(this);
}
m_renderMask = rhs.m_renderMask;
m_editMask = rhs.m_editMask;
@ -93,8 +93,8 @@ KisPaintLayer::~KisPaintLayer()
if (m_paintdev != 0) {
m_paintdev->setParentLayer(0);
}
if (m_tqmask != 0) {
m_tqmask->setParentLayer(0);
if (m_mask != 0) {
m_mask->setParentLayer(0);
}
}
@ -102,8 +102,8 @@ void KisPaintLayer::paintSelection(TQImage &img, TQ_INT32 x, TQ_INT32 y, TQ_INT3
{
if (m_paintdev && m_paintdev->hasSelection()) {
m_paintdev->selection()->paintSelection(img, x, y, w, h);
} else if (m_tqmask && m_editMask && m_tqmask->hasSelection()) {
m_tqmask->selection()->paintSelection(img, x, y, w, h);
} else if (m_mask && m_editMask && m_mask->hasSelection()) {
m_mask->selection()->paintSelection(img, x, y, w, h);
}
}
@ -111,8 +111,8 @@ void KisPaintLayer::paintSelection(TQImage &img, const TQRect& scaledImageRect,
{
if (m_paintdev && m_paintdev->hasSelection()) {
m_paintdev->selection()->paintSelection(img, scaledImageRect, scaledImageSize, imageSize);
} else if (m_tqmask && m_editMask && m_tqmask->hasSelection()) {
m_tqmask->selection()->paintSelection(img, scaledImageRect, scaledImageSize, imageSize);
} else if (m_mask && m_editMask && m_mask->hasSelection()) {
m_mask->selection()->paintSelection(img, scaledImageRect, scaledImageSize, imageSize);
}
}
@ -191,15 +191,15 @@ void KisPaintLayer::removeMask() {
if (!hasMask())
return;
m_tqmask->setParentLayer(0);
m_tqmask = 0;
m_mask->setParentLayer(0);
m_mask = 0;
m_maskAsSelection = 0;
setDirty();
emit sigMaskInfoChanged();
}
// ### XXX Do we apply the tqmask outside the image boundaries too? I'd say no, but I'm not sure
// ### XXX Do we apply the mask outside the image boundaries too? I'd say no, but I'm not sure
void KisPaintLayer::applyMask() {
if (!hasMask())
return;
@ -221,18 +221,18 @@ void KisPaintLayer::applyMask() {
KisPaintDeviceSP KisPaintLayer::createMask() {
if (hasMask())
return m_tqmask;
return m_mask;
kdDebug() << k_funcinfo << endl;
// Grey8 nicely fits our needs of being intuitively comparable to other apps'
// tqmask layer interfaces. It does have an alpha component though, which is a bit
// mask layer interfaces. It does have an alpha component though, which is a bit
// less appropriate in this context.
m_tqmask = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()
m_mask = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()
->getColorSpace(KisID("GRAYA"), 0));
genericMaskCreationHelper();
return m_tqmask;
return m_mask;
}
// FIXME If from is a paint device is not grey8!!
@ -241,22 +241,22 @@ void KisPaintLayer::createMaskFromPaintDevice(KisPaintDeviceSP from) {
return; // Or overwrite? XXX
kdDebug() << k_funcinfo << endl;
m_tqmask = from; // KisPaintDevice(*from); XXX
m_mask = from; // KisPaintDevice(*from); XXX
genericMaskCreationHelper();
}
void KisPaintLayer::createMaskFromSelection(KisSelectionSP from) {
kdDebug() << k_funcinfo << endl;
m_tqmask = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()
m_mask = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()
->getColorSpace(KisID("GRAYA"), 0));
m_tqmask->setParentLayer(this);
m_mask->setParentLayer(this);
m_maskAsSelection = new KisSelection(); // Anonymous selection is good enough
// Default pixel is opaque white == don't tqmask?
// Default pixel is opaque white == don't mask?
TQ_UINT8 const defPixel[] = { 255, 255 };
m_tqmask->dataManager()->setDefaultPixel(defPixel);
m_mask->dataManager()->setDefaultPixel(defPixel);
if (from) {
TQRect r(extent());
@ -265,7 +265,7 @@ void KisPaintLayer::createMaskFromSelection(KisSelectionSP from) {
int h = r.height();
for (int y = r.y(); y < h; y++) {
KisHLineIteratorPixel srcIt = from->createHLineIterator(r.x(), y, w, false);
KisHLineIteratorPixel dstIt = m_tqmask->createHLineIterator(r.x(), y, w, true);
KisHLineIteratorPixel dstIt = m_mask->createHLineIterator(r.x(), y, w, true);
while(!dstIt.isDone()) {
// XXX same remark as in convertMaskToSelection
@ -286,7 +286,7 @@ void KisPaintLayer::createMaskFromSelection(KisSelectionSP from) {
KisPaintDeviceSP KisPaintLayer::getMask() {
createMask();
kdDebug() << k_funcinfo << endl;
return m_tqmask;
return m_mask;
}
KisSelectionSP KisPaintLayer::getMaskAsSelection() {
@ -310,7 +310,7 @@ void KisPaintLayer::setRenderMask(bool b) {
}
void KisPaintLayer::convertMaskToSelection(const TQRect& r) {
KisRectIteratorPixel srcIt = m_tqmask->createRectIterator(r.x(), r.y(),
KisRectIteratorPixel srcIt = m_mask->createRectIterator(r.x(), r.y(),
r.width(), r.height(), false);
KisRectIteratorPixel dstIt = m_maskAsSelection->createRectIterator(r.x(), r.y(),
r.width(), r.height(), true);
@ -326,13 +326,13 @@ void KisPaintLayer::convertMaskToSelection(const TQRect& r) {
}
void KisPaintLayer::genericMaskCreationHelper() {
m_tqmask->setParentLayer(this);
m_mask->setParentLayer(this);
m_maskAsSelection = new KisSelection(); // Anonymous selection is good enough
// Default pixel is opaque white == don't tqmask?
// Default pixel is opaque white == don't mask?
TQ_UINT8 const defPixel[] = { 255, 255 };
m_tqmask->dataManager()->setDefaultPixel(defPixel);
m_mask->dataManager()->setDefaultPixel(defPixel);
setDirty();
emit sigMaskInfoChanged();
@ -355,16 +355,16 @@ namespace {
class KisCreateMaskCommand : public KNamedCommand {
typedef KNamedCommand super;
KisPaintLayerSP m_layer;
KisPaintDeviceSP m_tqmask;
KisPaintDeviceSP m_mask;
public:
KisCreateMaskCommand(const TQString& name, KisPaintLayer* layer)
: super(name), m_layer(layer) {}
virtual void execute() {
kdDebug() << k_funcinfo << endl;
if (!m_tqmask)
m_tqmask = m_layer->createMask();
if (!m_mask)
m_mask = m_layer->createMask();
else
m_layer->createMaskFromPaintDevice(m_tqmask);
m_layer->createMaskFromPaintDevice(m_mask);
}
virtual void unexecute() {
m_layer->removeMask();
@ -411,12 +411,12 @@ namespace {
class KisMaskToSelectionCommand : public KNamedCommand {
typedef KNamedCommand super;
KisPaintLayerSP m_layer;
KisPaintDeviceSP m_tqmask;
KisPaintDeviceSP m_mask;
KisSelectionSP m_selection;
public:
KisMaskToSelectionCommand(const TQString& name, KisPaintLayer* layer)
: super(name), m_layer(layer) {
m_tqmask = m_layer->getMask();
m_mask = m_layer->getMask();
if (m_layer->paintDevice()->hasSelection())
m_selection = m_layer->paintDevice()->selection();
else
@ -431,18 +431,18 @@ namespace {
m_layer->paintDevice()->setSelection(m_selection);
else
m_layer->paintDevice()->deselect();
m_layer->createMaskFromPaintDevice(m_tqmask);
m_layer->createMaskFromPaintDevice(m_mask);
}
};
class KisRemoveMaskCommand : public KNamedCommand {
typedef KNamedCommand super;
KisPaintLayerSP m_layer;
KisPaintDeviceSP m_tqmask;
KisPaintDeviceSP m_mask;
public:
KisRemoveMaskCommand(const TQString& name, KisPaintLayer* layer)
: super(name), m_layer(layer) {
m_tqmask = m_layer->getMask();
m_mask = m_layer->getMask();
}
virtual void execute() {
kdDebug() << k_funcinfo << endl;
@ -451,19 +451,19 @@ namespace {
virtual void unexecute() {
// I hope that if the undo stack unwinds, it will end up here in the right
// state again; taking a deep-copy sounds like wasteful to me
m_layer->createMaskFromPaintDevice(m_tqmask);
m_layer->createMaskFromPaintDevice(m_mask);
}
};
class KisApplyMaskCommand : public KNamedCommand {
typedef KNamedCommand super;
KisPaintLayerSP m_layer;
KisPaintDeviceSP m_tqmask;
KisPaintDeviceSP m_mask;
KisPaintDeviceSP m_original;
public:
KisApplyMaskCommand(const TQString& name, KisPaintLayer* layer)
: super(name), m_layer(layer) {
m_tqmask = m_layer->getMask();
m_mask = m_layer->getMask();
m_original = new KisPaintDevice(*m_layer->paintDevice());
}
virtual void execute() {
@ -479,7 +479,7 @@ namespace {
gc.bitBlt(x, y, COMPOSITE_COPY, m_original, OPACITY_OPAQUE, x, y, w, h);
gc.end();
m_layer->createMaskFromPaintDevice(m_tqmask);
m_layer->createMaskFromPaintDevice(m_mask);
}
};
}

36
chalk/core/kis_paint_layer.h
Unescape Escape View File

@ -73,55 +73,55 @@ public:
inline KisPaintDeviceSP paintDevice() const { return m_paintdev; }
/// Returns the paintDevice that accompanies this layer (or tqmask, see editMask)
/// Returns the paintDevice that accompanies this layer (or mask, see editMask)
inline KisPaintDeviceSP paintDeviceOrMask() const {
if (hasMask() && editMask())
return m_tqmask;
return m_mask;
return m_paintdev;
}
// Mask Layer
/// Does this layer have a layer tqmask?
bool hasMask() const { return m_tqmask != 0; }
/// Does this layer have a layer mask?
bool hasMask() const { return m_mask != 0; }
// XXX TODO: Make these undo-able!
/// Create a tqmask if it does not yet exist, and return it
/// Create a mask if it does not yet exist, and return it
KisPaintDeviceSP createMask();
/// Convert the from argument to the tqmask
/// Convert the from argument to the mask
void createMaskFromPaintDevice(KisPaintDeviceSP from);
/**
* Convert the from selection to a paint device (should convert the getMaskAsSelection
* result back to the tqmask). Overwrites the current tqmask, if any. Also removes the selection
* result back to the mask). Overwrites the current mask, if any. Also removes the selection
*/
void createMaskFromSelection(KisSelectionSP from);
/// Remove the layer tqmask
/// Remove the layer mask
void removeMask();
/// Apply the layer tqmask to the paint device, this removes the tqmask afterwards
/// Apply the layer mask to the paint device, this removes the mask afterwards
void applyMask();
/// Returns the layer tqmask's device. Creates one if there is currently none
/// Returns the layer mask's device. Creates one if there is currently none
KisPaintDeviceSP getMask();
/// Returns the layer tqmask's device, converted to a selection. Creates one if there is currently none
/// Returns the layer mask's device, converted to a selection. Creates one if there is currently none
KisSelectionSP getMaskAsSelection();
/// Undoable version of createMask
KNamedCommand* createMaskCommand();
/// Undoable version of createMaskFromSelection
KNamedCommand* maskFromSelectionCommand();
/// Undoable, removes the current tqmask, but converts it to the current selection
/// Undoable, removes the current mask, but converts it to the current selection
KNamedCommand* maskToSelectionCommand();
/// Undoable version of removeMask
KNamedCommand* removeMaskCommand();
/// Undoable version of applyMask
KNamedCommand* applyMaskCommand();
/// Returns true if the masked part of the tqmask will be rendered instead of being transparent
/// Returns true if the masked part of the mask will be rendered instead of being transparent
bool renderMask() const { return m_renderMask; }
/// Set the renderMask property
void setRenderMask(bool b);
/**
* When this returns true, the KisPaintDevice returned in paintDevice will actually
* be the layer tqmask (if there is one). This is so that tools can draw on the tqmask
* be the layer mask (if there is one). This is so that tools can draw on the mask
* without needing to know its existance.
*/
bool editMask() const { return m_editMask; }
@ -136,17 +136,17 @@ public:
// KisLayerSupportsIndirectPainting