Update various qt function definitions and static methods for tqt3

pull/1/head
Timothy Pearson 13 years ago
parent 35dc3d657c
commit e6cf8874a7

@ -1104,7 +1104,7 @@ EOF
if test $kde_qtsubver -gt 0; then
cat >> conftest.$ac_ext <<EOF
#if QT_VERSION < 210
#if TQT_VERSION < 210
#error 1
#endif
EOF
@ -1201,22 +1201,22 @@ fi
if test -z "$3"; then
if test $kde_qtver = 3; then
if test $kde_qtsubver -gt 0; then
kde_qt_verstring="QT_VERSION >= 0x03@VER@00 && QT_VERSION < 0x040000"
kde_qt_verstring="TQT_VERSION >= 0x03@VER@00 && TQT_VERSION < 0x040000"
qtsubver=`echo "00$kde_qtsubver" | sed -e 's,.*\(..\)$,\1,'`
kde_qt_verstring=`echo $kde_qt_verstring | sed -e "s,@VER@,$qtsubver,"`
else
kde_qt_verstring="QT_VERSION >= 300 && QT_VERSION < 0x040000"
kde_qt_verstring="TQT_VERSION >= 300 && TQT_VERSION < 0x040000"
fi
fi
if test $kde_qtver = 2; then
if test $kde_qtsubver -gt 0; then
kde_qt_verstring="QT_VERSION >= 222"
kde_qt_verstring="TQT_VERSION >= 222"
else
kde_qt_verstring="QT_VERSION >= 200"
kde_qt_verstring="TQT_VERSION >= 200"
fi
fi
if test $kde_qtver = 1; then
kde_qt_verstring="QT_VERSION >= 142 && QT_VERSION < 200"
kde_qt_verstring="TQT_VERSION >= 142 && TQT_VERSION < 200"
fi
else
kde_qt_verstring="$3"

@ -89,7 +89,7 @@ void KisAbstractColorSpace::init()
{
// Default pixel buffer for TQColor conversion
m_qcolordata = new TQ_UINT8[3];
Q_CHECK_PTR(m_qcolordata);
TQ_CHECK_PTR(m_qcolordata);
if (m_profile == 0) return;

@ -33,7 +33,7 @@ DCOPObject * KisColorSpace::dcopObject()
{
if (!m_dcop) {
m_dcop = new KisColorSpaceIface(this);
Q_CHECK_PTR(m_dcop);
TQ_CHECK_PTR(m_dcop);
}
return m_dcop;
}

@ -43,7 +43,7 @@ KisColorSpaceFactoryRegistry::KisColorSpaceFactoryRegistry(TQStringList profileF
KisProfile * profile = 0;
for ( TQStringList::Iterator it = profileFilenames.begin(); it != profileFilenames.end(); ++it ) {
profile = new KisProfile(*it);
Q_CHECK_PTR(profile);
TQ_CHECK_PTR(profile);
profile->load();
if (profile->valid()) {

@ -45,7 +45,7 @@ CMYKU16Plugin::CMYKU16Plugin(TQObject *parent, const char *name, const TQStringL
KisColorSpace * colorSpaceCMYKU16 = new KisCmykU16ColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisCmykU16ColorSpaceFactory();
Q_CHECK_PTR(colorSpaceCMYKU16);
TQ_CHECK_PTR(colorSpaceCMYKU16);
f->add(csf);
KisHistogramProducerFactoryRegistry::instance()->add(
new KisBasicHistogramProducerFactory<KisBasicU16HistogramProducer>

@ -49,7 +49,7 @@ CMYKPlugin::CMYKPlugin(TQObject *parent, const char *name, const TQStringList &)
KisColorSpace * colorSpaceCMYK = new KisCmykColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisCmykColorSpaceFactory();
Q_CHECK_PTR(colorSpaceCMYK);
TQ_CHECK_PTR(colorSpaceCMYK);
f->add(csf);
KisHistogramProducerFactoryRegistry::instance()->add(

@ -46,7 +46,7 @@ GRAYU16Plugin::GRAYU16Plugin(TQObject *parent, const char *name, const TQStringL
KisColorSpace * colorSpaceGRAYU16 = new KisGrayU16ColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisGrayU16ColorSpaceFactory();
Q_CHECK_PTR(colorSpaceGRAYU16);
TQ_CHECK_PTR(colorSpaceGRAYU16);
f->add(csf);
KisHistogramProducerFactoryRegistry::instance()->add(

@ -59,7 +59,7 @@ GrayPlugin::GrayPlugin(TQObject *parent, const char *name, const TQStringList &)
KisColorSpace * colorSpaceGrayA = new KisGrayColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisGrayColorSpaceFactory();
Q_CHECK_PTR(colorSpaceGrayA);
TQ_CHECK_PTR(colorSpaceGrayA);
f->add(csf);

@ -46,7 +46,7 @@ RGBF16HalfPlugin::RGBF16HalfPlugin(TQObject *parent, const char *name, const TQS
KisColorSpace * colorSpaceRGBF16Half = new KisRgbF16HalfColorSpace(f, 0);
KisColorSpaceFactory *csf = new KisRgbF16HalfColorSpaceFactory();
Q_CHECK_PTR(colorSpaceRGBF16Half);
TQ_CHECK_PTR(colorSpaceRGBF16Half);
f->add(csf);
KisHistogramProducerFactoryRegistry::instance()->add(
new KisBasicHistogramProducerFactory<KisBasicF16HalfHistogramProducer>

@ -240,7 +240,7 @@ TQ_UINT16 KisWetColorSpace::scaleToU16(const TQ_UINT8 * /*srcPixel*/, TQ_INT32 /
void KisWetColorSpace::toTQColor(const TQ_UINT8 *src, TQColor *c, KisProfile * /*profile*/)
{
TQ_UINT8 * rgb = new TQ_UINT8[3];
Q_CHECK_PTR(rgb);
TQ_CHECK_PTR(rgb);
memset(rgb, 255, 3);
@ -401,7 +401,7 @@ void KisWetColorSpace::wet_init_render_tab()
int a, b;
wet_render_tab = new TQ_UINT32[4096];
Q_CHECK_PTR(wet_render_tab);
TQ_CHECK_PTR(wet_render_tab);
for (i = 0; i < 4096; i++)
{

@ -63,7 +63,7 @@ KisPaintOp * KisWetOpFactory::createOp(const KisPaintOpSettings *settings, KisPa
Q_ASSERT(settings == 0 || wetopSettings != 0);
KisPaintOp * op = new KisWetOp(wetopSettings, painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}

@ -78,7 +78,7 @@ WetPlugin::WetPlugin(TQObject *parent, const char *name, const TQStringList &)
KisColorSpace* colorSpaceWet = new KisWetColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisWetColorSpaceFactory();
Q_CHECK_PTR(colorSpaceWet);
TQ_CHECK_PTR(colorSpaceWet);
// colorspace
f->add(csf);
@ -110,7 +110,7 @@ WetPlugin::WetPlugin(TQObject *parent, const char *name, const TQStringList &)
// Create the wet palette
KisWetPaletteWidget * w = new KisWetPaletteWidget(m_view);
Q_CHECK_PTR(w);
TQ_CHECK_PTR(w);
w->setCaption(i18n("Watercolors"));

@ -92,22 +92,22 @@ void WetPhysicsFilter::flow(KisPaintDeviceSP src, KisPaintDeviceSP /*dst*/, cons
int rs = width; // rowstride
double * flow_t = new double[width * height];
Q_CHECK_PTR(flow_t);
TQ_CHECK_PTR(flow_t);
double * flow_b = new double[width * height];
Q_CHECK_PTR(flow_b);
TQ_CHECK_PTR(flow_b);
double * flow_l = new double[width * height];
Q_CHECK_PTR(flow_l);
TQ_CHECK_PTR(flow_l);
double * flow_r = new double[width * height];
Q_CHECK_PTR(flow_r);
TQ_CHECK_PTR(flow_r);
double * fluid = new double[width * height];
Q_CHECK_PTR(fluid);
TQ_CHECK_PTR(fluid);
double * outflow = new double[width * height];
Q_CHECK_PTR(outflow);
TQ_CHECK_PTR(outflow);
// Height of the paper surface. Do we also increase height because of paint deposits?
int my_height;

@ -32,7 +32,7 @@
KisPaintOp * KisWSBrushOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
{
KisPaintOp * op = new KisWSBrushOp(painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}

@ -94,7 +94,7 @@ void single_step(KisColorSpace * cs, KisPaintDeviceSP src, KisPaintDeviceSP dst
src -> colorSpace() -> toTQColor(pix, &c, &opacity);
TQ_UINT8 *pix = new TQ_UINT8[sizeof( cell )];
Q_CHECK_PTR(pix);
TQ_CHECK_PTR(pix);
cs -> fromTQColor(c, opacity, pix);
}

@ -46,7 +46,7 @@ WetStickyPlugin::WetStickyPlugin(TQObject *parent, const char *name, const TQStr
if ( parent->inherits("KisFactory") )
{
KisColorSpace * colorSpaceWS = new KisWetStickyColorSpace();
Q_CHECK_PTR(colorSpaceWS);
TQ_CHECK_PTR(colorSpaceWS);
KisColorSpaceRegistry::instance() -> add(colorSpaceWS);
KisFilterRegistry::instance()->add(new KisWSEngineFilter());
}

@ -44,7 +44,7 @@ YCbCrU16Plugin::YCbCrU16Plugin(TQObject *parent, const char *name, const TQStrin
KisColorSpace * colorSpaceYCbCrU16 = new KisYCbCrU16ColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisYCbCrU16ColorSpaceFactory();
Q_CHECK_PTR(colorSpaceYCbCrU16);
TQ_CHECK_PTR(colorSpaceYCbCrU16);
f->add(csf);
KisHistogramProducerFactoryRegistry::instance()->add(
new KisBasicHistogramProducerFactory<KisBasicU16HistogramProducer>

@ -46,7 +46,7 @@ YCbCrU8Plugin::YCbCrU8Plugin(TQObject *parent, const char *name, const TQStringL
KisColorSpace * colorSpaceYCbCrU8 = new KisYCbCrU8ColorSpace(f, 0);
KisColorSpaceFactory * csf = new KisYCbCrU8ColorSpaceFactory();
Q_CHECK_PTR(colorSpaceYCbCrU8);
TQ_CHECK_PTR(colorSpaceYCbCrU8);
f->add(csf);
KisHistogramProducerFactoryRegistry::instance()->add(
new KisBasicHistogramProducerFactory<KisBasicU16HistogramProducer>

@ -117,7 +117,7 @@ KisAlphaMaskSP KisAlphaMask::interpolate(KisAlphaMaskSP mask1, KisAlphaMaskSP ma
int width = mask1->width();
int height = mask1->height();
KisAlphaMaskSP outputMask = new KisAlphaMask(width, height);
Q_CHECK_PTR(outputMask);
TQ_CHECK_PTR(outputMask);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {

@ -455,7 +455,7 @@ KisPaintDeviceSP KisBrush::image(KisColorSpace * /*colorSpace*/, const KisPaintI
KisPaintDevice *layer = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getRGB8(), "brush");
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
for (int y = 0; y < outputHeight; y++) {
KisHLineIterator iter = layer->createHLineIterator( 0, y, outputWidth, true);
@ -563,7 +563,7 @@ void KisBrush::createScaledBrushes() const
}
KisAlphaMaskSP scaledMask = new KisAlphaMask(scaledImage, hasColor());
Q_CHECK_PTR(scaledMask);
TQ_CHECK_PTR(scaledMask);
double xScale = static_cast<double>(width) / m_img.width();
double yScale = static_cast<double>(height) / m_img.height();
@ -627,7 +627,7 @@ KisAlphaMaskSP KisBrush::scaleMask(const ScaledBrush *srcBrush, double scale, do
int dstHeight = static_cast<int>(ceil(scale * height())) + 1;
KisAlphaMaskSP dstMask = new KisAlphaMask(dstWidth, dstHeight);
Q_CHECK_PTR(dstMask);
TQ_CHECK_PTR(dstMask);
KisAlphaMaskSP srcMask = srcBrush->mask();
@ -978,7 +978,7 @@ KisAlphaMaskSP KisBrush::scaleSinglePixelMask(double scale, TQ_UINT8 maskValue,
int dstWidth = 2;
int dstHeight = 2;
KisAlphaMaskSP outputMask = new KisAlphaMask(dstWidth, dstHeight);
Q_CHECK_PTR(outputMask);
TQ_CHECK_PTR(outputMask);
double a = subPixelX;
double b = subPixelY;

@ -147,7 +147,7 @@ void KisFillPainter::fillColor(int startX, int startY) {
// Now create a layer and fill it
KisPaintDeviceSP filled = new KisPaintDevice(m_device->colorSpace(), "filled");
Q_CHECK_PTR(filled);
TQ_CHECK_PTR(filled);
KisFillPainter painter(filled.data());
painter.fillRect(0, 0, m_width, m_height, m_paintColor);
painter.end();
@ -160,7 +160,7 @@ void KisFillPainter::fillPattern(int startX, int startY) {
// Now create a layer and fill it
KisPaintDeviceSP filled = new KisPaintDevice(m_device->colorSpace(), "filled");
Q_CHECK_PTR(filled);
TQ_CHECK_PTR(filled);
KisFillPainter painter(filled.data());
painter.fillRect(0, 0, m_width, m_height, m_pattern);
painter.end();

@ -177,7 +177,7 @@ KisFilterStrategyRegistry* KisFilterStrategyRegistry::instance()
if(KisFilterStrategyRegistry::m_singleton == 0)
{
KisFilterStrategyRegistry::m_singleton = new KisFilterStrategyRegistry();
Q_CHECK_PTR(KisFilterStrategyRegistry::m_singleton);
TQ_CHECK_PTR(KisFilterStrategyRegistry::m_singleton);
m_singleton->add(new KisHermiteFilterStrategy);
m_singleton->add(new KisBoxFilterStrategy);
m_singleton->add(new KisTriangleFilterStrategy);

@ -103,7 +103,7 @@ bool KisGradient::init()
Color rightColor(rightRgb.color(), colstopNext->opacity);
KisGradientSegment *segment = new KisGradientSegment(colstop->interpolation, colstop->colorType, colstop->offset, midp, colstopNext->offset, leftColor, rightColor);
Q_CHECK_PTR(segment);
TQ_CHECK_PTR(segment);
if ( !segment->isValid() ) {
delete segment;
@ -418,7 +418,7 @@ KisGradientSegment::RGBColorInterpolationStrategy *KisGradientSegment::RGBColorI
{
if (m_instance == 0) {
m_instance = new RGBColorInterpolationStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -442,7 +442,7 @@ KisGradientSegment::HSVCWColorInterpolationStrategy *KisGradientSegment::HSVCWCo
{
if (m_instance == 0) {
m_instance = new HSVCWColorInterpolationStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -477,7 +477,7 @@ KisGradientSegment::HSVCCWColorInterpolationStrategy *KisGradientSegment::HSVCCW
{
if (m_instance == 0) {
m_instance = new HSVCCWColorInterpolationStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -512,7 +512,7 @@ KisGradientSegment::LinearInterpolationStrategy *KisGradientSegment::LinearInter
{
if (m_instance == 0) {
m_instance = new LinearInterpolationStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -559,7 +559,7 @@ KisGradientSegment::CurvedInterpolationStrategy *KisGradientSegment::CurvedInter
{
if (m_instance == 0) {
m_instance = new CurvedInterpolationStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -585,7 +585,7 @@ KisGradientSegment::SineInterpolationStrategy *KisGradientSegment::SineInterpola
{
if (m_instance == 0) {
m_instance = new SineInterpolationStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -603,7 +603,7 @@ KisGradientSegment::SphereIncreasingInterpolationStrategy *KisGradientSegment::S
{
if (m_instance == 0) {
m_instance = new SphereIncreasingInterpolationStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -621,7 +621,7 @@ KisGradientSegment::SphereDecreasingInterpolationStrategy *KisGradientSegment::S
{
if (m_instance == 0) {
m_instance = new SphereDecreasingInterpolationStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;

@ -366,7 +366,7 @@ namespace {
{
if (m_instance == 0) {
m_instance = new GradientRepeatNoneStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -407,7 +407,7 @@ namespace {
{
if (m_instance == 0) {
m_instance = new GradientRepeatForwardsStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -446,7 +446,7 @@ namespace {
{
if (m_instance == 0) {
m_instance = new GradientRepeatAlternateStrategy();
Q_CHECK_PTR(m_instance);
TQ_CHECK_PTR(m_instance);
}
return m_instance;
@ -518,7 +518,7 @@ bool KisGradientPainter::paintGradient(const KisPoint& gradientVectorStart,
shapeStrategy = new ConicalSymetricGradientStrategy(gradientVectorStart, gradientVectorEnd);
break;
}
Q_CHECK_PTR(shapeStrategy);
TQ_CHECK_PTR(shapeStrategy);
GradientRepeatStrategy *repeatStrategy = 0;

@ -542,7 +542,7 @@ KisImage::KisImage(const KisImage& rhs) : TQObject(), KShared(rhs)
m_adapter = rhs.m_adapter;
m_bkg = new KisBackground();
Q_CHECK_PTR(m_bkg);
TQ_CHECK_PTR(m_bkg);
m_rootLayer = static_cast<KisGroupLayer*>(rhs.m_rootLayer->clone().data());
connect(m_rootLayer, TQT_SIGNAL(sigDirty(TQRect)), this, TQT_SIGNAL(sigImageUpdated(TQRect)));
@ -550,7 +550,7 @@ KisImage::KisImage(const KisImage& rhs) : TQObject(), KShared(rhs)
m_annotations = rhs.m_annotations; // XXX the annotations would probably need to be deep-copied
m_nserver = new KisNameServer(i18n("Layer %1"), rhs.m_nserver->currentSeed() + 1);
Q_CHECK_PTR(m_nserver);
TQ_CHECK_PTR(m_nserver);
//m_guides = rhs.m_guides;
@ -575,7 +575,7 @@ DCOPObject * KisImage::dcopObject()
{
if (!m_dcop) {
m_dcop = new KisImageIface(this);
Q_CHECK_PTR(m_dcop);
TQ_CHECK_PTR(m_dcop);
}
return m_dcop;
}
@ -1041,7 +1041,7 @@ KisLayerSP KisImage::newLayer(const TQString& name, TQ_UINT8 opacity, const KisC
layer = new KisPaintLayer(this, name, opacity, colorstrategy);
else
layer = new KisPaintLayer(this, name, opacity);
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
if (compositeOp.isValid())
layer->setCompositeOp(compositeOp);
@ -1310,7 +1310,7 @@ void KisImage::flatten()
disconnect(oldRootLayer, TQT_SIGNAL(sigDirty(TQRect)), this, TQT_SIGNAL(sigImageUpdated(TQRect)));
KisPaintLayer *dst = new KisPaintLayer(this, nextLayerName(), OPACITY_OPAQUE, colorSpace());
Q_CHECK_PTR(dst);
TQ_CHECK_PTR(dst);
TQRect rc = mergedImage()->extent();
@ -1345,7 +1345,7 @@ void KisImage::flatten()
void KisImage::mergeLayer(KisLayerSP layer)
{
KisPaintLayer *player = new KisPaintLayer(this, layer->name(), OPACITY_OPAQUE, colorSpace());
Q_CHECK_PTR(player);
TQ_CHECK_PTR(player);
TQRect rc = layer->extent() | layer->nextSibling()->extent();

@ -237,7 +237,7 @@ bool KisImagePipeBrush::init()
KisBrush * brush = new KisBrush(name() + "_" + numOfBrushes,
m_data,
i);
Q_CHECK_PTR(brush);
TQ_CHECK_PTR(brush);
m_brushes.append(brush);

@ -29,7 +29,7 @@ KisHLineIteratorPixel::KisHLineIteratorPixel( KisPaintDevice *ndevice, KisDataMa
{
if(sel_dm) {
KisHLineIterator * i = new KisHLineIterator(sel_dm, x - offsetx, y - offsety, w, false);
Q_CHECK_PTR(i);
TQ_CHECK_PTR(i);
KisIteratorPixelTrait <KisHLineIterator>::setSelectionIterator(i);
}
}
@ -41,7 +41,7 @@ KisVLineIteratorPixel::KisVLineIteratorPixel( KisPaintDevice *ndevice, KisDataMa
{
if(sel_dm) {
KisVLineIterator * i = new KisVLineIterator(sel_dm, x - offsetx, y - offsety, h, false);
Q_CHECK_PTR(i);
TQ_CHECK_PTR(i);
KisIteratorPixelTrait <KisVLineIterator>::setSelectionIterator(i);
}
}
@ -53,7 +53,7 @@ KisRectIteratorPixel::KisRectIteratorPixel( KisPaintDevice *ndevice, KisDataMana
{
if(sel_dm) {
KisRectIterator * i = new KisRectIterator(sel_dm, x - offsetx, y - offsety, w, h, false);
Q_CHECK_PTR(i);
TQ_CHECK_PTR(i);
KisIteratorPixelTrait <KisRectIterator>::setSelectionIterator(i);
}
}

@ -223,7 +223,7 @@ KisPaintDevice::KisPaintDevice(KisColorSpace * colorSpace, const char * name) :
m_datamanager = new KisDataManager(m_pixelSize, defPixel);
delete [] defPixel;
Q_CHECK_PTR(m_datamanager);
TQ_CHECK_PTR(m_datamanager);
m_extentIsValid = true;
m_parentLayer = 0;
@ -269,7 +269,7 @@ KisPaintDevice::KisPaintDevice(KisLayer *parent, KisColorSpace * colorSpace, con
m_datamanager = new KisDataManager(m_pixelSize, defPixel);
delete [] defPixel;
Q_CHECK_PTR(m_datamanager);
TQ_CHECK_PTR(m_datamanager);
m_extentIsValid = true;
if ( TQString ( name ) == TQString( "Layer 1" ) ) {
@ -292,7 +292,7 @@ KisPaintDevice::KisPaintDevice(const KisPaintDevice& rhs) : TQObject(), KShared(
m_dcop = rhs.m_dcop;
if (rhs.m_datamanager) {
m_datamanager = new KisDataManager(*rhs.m_datamanager);
Q_CHECK_PTR(m_datamanager);
TQ_CHECK_PTR(m_datamanager);
}
else {
kdWarning() << "rhs " << rhs.name() << " has no datamanager\n";
@ -338,7 +338,7 @@ DCOPObject *KisPaintDevice::dcopObject()
{
if (!m_dcop) {
m_dcop = new KisPaintDeviceIface(this);
Q_CHECK_PTR(m_dcop);
TQ_CHECK_PTR(m_dcop);
}
return m_dcop;
}
@ -401,7 +401,7 @@ void KisPaintDevice::move(const TQPoint& pt)
KNamedCommand * KisPaintDevice::moveCommand(TQ_INT32 x, TQ_INT32 y)
{
KNamedCommand * cmd = new MoveCommand(this, TQPoint(m_x, m_y), TQPoint(x, y));
Q_CHECK_PTR(cmd);
TQ_CHECK_PTR(cmd);
cmd->execute();
return cmd;
}
@ -859,7 +859,7 @@ TQImage KisPaintDevice::convertToTQImage(KisProfile * dstProfile, TQ_INT32 x1,
return TQImage();
TQ_UINT8 * data = new TQ_UINT8 [w * h * m_pixelSize];
Q_CHECK_PTR(data);
TQ_CHECK_PTR(data);
// XXX: Is this really faster than converting line by line and building the TQImage directly?
// This copies potentially a lot of data.
@ -1024,7 +1024,7 @@ KisSelectionSP KisPaintDevice::selection()
}
else if (!m_selection) {
m_selection = new KisSelection(this);
Q_CHECK_PTR(m_selection);
TQ_CHECK_PTR(m_selection);
m_selection->setX(m_x);
m_selection->setY(m_y);
}

@ -126,7 +126,7 @@ void KisPainter::beginTransaction(const TQString& customName)
if (m_transaction)
delete m_transaction;
m_transaction = new KisTransaction(customName, m_device);
Q_CHECK_PTR(m_transaction);
TQ_CHECK_PTR(m_transaction);
}
void KisPainter::beginTransaction( KisTransaction* command)
@ -782,9 +782,9 @@ void KisPainter::fillPolygon(const vKisPoint& points, FillStyle fillStyle)
}
ind = new int[n];
Q_CHECK_PTR(ind);
TQ_CHECK_PTR(ind);
active = new Edge[n];
Q_CHECK_PTR(active);
TQ_CHECK_PTR(active);
/* create y-sorted array of indices ind[k] into vertex list */
for (k=0; k<n; k++)
@ -815,7 +815,7 @@ void KisPainter::fillPolygon(const vKisPoint& points, FillStyle fillStyle)
// create a mask for the actual polygon coverage.
KisPaintDeviceSP polygon = new KisPaintDevice(m_device->colorSpace(), "polygon");
Q_CHECK_PTR(polygon);
TQ_CHECK_PTR(polygon);
KisFillPainter fillPainter(polygon);
TQRect boundingRectangle(x0, y0, x1 - x0 + 1, y1 - y0 + 1);

@ -57,7 +57,7 @@ KisPaintDeviceSP KisPaintOp::computeDab(KisAlphaMaskSP mask, KisColorSpace *cs)
if(!m_dab || m_dab->colorSpace() != cs)
m_dab = new KisPaintDevice(cs, "dab");
Q_CHECK_PTR(m_dab);
TQ_CHECK_PTR(m_dab);
KisColor kc = m_painter->paintColor();

@ -78,7 +78,7 @@ KisPaintOpRegistry* KisPaintOpRegistry::instance()
if(KisPaintOpRegistry::m_singleton == 0)
{
KisPaintOpRegistry::m_singleton = new KisPaintOpRegistry();
Q_CHECK_PTR(KisPaintOpRegistry::m_singleton);
TQ_CHECK_PTR(KisPaintOpRegistry::m_singleton);
}
return KisPaintOpRegistry::m_singleton;
}

@ -284,7 +284,7 @@ KisPaintDeviceSP KisPattern::image(KisColorSpace * colorSpace) {
// If not, create one
KisPaintDeviceSP layer = new KisPaintDevice(colorSpace, "pattern");
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
layer->convertFromTQImage(m_img,"");

@ -42,15 +42,15 @@ void KisScaleWorker::run()
TQ_INT32 targetH = TQABS( tqRound( m_sy * height ) );
TQ_UINT8* newData = new TQ_UINT8[targetW * targetH * m_pixelSize ];
Q_CHECK_PTR(newData);
TQ_CHECK_PTR(newData);
double* weight = new double[ m_pixelSize ]; /* filter calculation variables */
TQ_UINT8* pel = new TQ_UINT8[ m_pixelSize ];
Q_CHECK_PTR(pel);
TQ_CHECK_PTR(pel);
TQ_UINT8 *pel2 = new TQ_UINT8[ m_pixelSize ];
Q_CHECK_PTR(pel2);
TQ_CHECK_PTR(pel2);
bool* bPelDelta = new bool[ m_pixelSize ];
ContribList *contribX;
@ -61,7 +61,7 @@ void KisScaleWorker::run()
// create intermediate row to hold vertical dst row zoom
TQ_UINT8 * tmp = new TQ_UINT8[ width * m_pixelSize ];
Q_CHECK_PTR(tmp);
TQ_CHECK_PTR(tmp);
//create array of pointers to intermediate rows
TQ_UINT8 **tmpRows = new TQ_UINT8*[ height ];
@ -74,7 +74,7 @@ void KisScaleWorker::run()
for(int i = 0; i < (int)(fwidth / m_sy * 2 + 1); i++)
{
tmpRowsMem[i] = new TQ_UINT8[ width * m_pixelSize ];
Q_CHECK_PTR(tmpRowsMem[i]);
TQ_CHECK_PTR(tmpRowsMem[i]);
}
}
else
@ -83,7 +83,7 @@ void KisScaleWorker::run()
for(int i = 0; i < (int)(fwidth * 2 + 1); i++)
{
tmpRowsMem[i] = new TQ_UINT8[ width * m_pixelSize ];
Q_CHECK_PTR(tmpRowsMem[i]);
TQ_CHECK_PTR(tmpRowsMem[i]);
}
}

@ -120,7 +120,7 @@ void KisStrategyMove::endDrag(const TQPoint& pos, bool undo)
if (undo && img->undo()) {
KCommand *cmd = dev->moveCommand(m_layerStart, m_layerPosition);
Q_CHECK_PTR(cmd);
TQ_CHECK_PTR(cmd);
KisUndoAdapter *adapter = img->undoAdapter();
if (adapter) {

@ -69,7 +69,7 @@ public:
KisTransaction * t = 0;
if (m_img->undo()) {
t = new KisTransaction(i18n("Rotate Layer"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
KisTransformWorker tw(dev, m_sx, m_sy, 0.0, 0.0, m_angle, m_tx, m_ty, m_progress, m_filter, true);
@ -108,7 +108,7 @@ public:
if (m_img->undo()) {
t = new KisTransaction(i18n("Rotate Layer"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
KisTransformWorker tw(dev, m_sx, m_sy, 0.0, 0.0, m_angle, m_tx, m_ty, m_progress, m_filter, true);

@ -354,10 +354,10 @@ template <class T> void KisTransformWorker::transformPass(KisPaintDevice *src, K
TQ_INT32 extraLen = (support+256)>>8 + 1;
TQ_UINT8 *tmpLine = new TQ_UINT8[(srcLen +2*extraLen)* pixelSize];
Q_CHECK_PTR(tmpLine);
TQ_CHECK_PTR(tmpLine);
TQ_UINT8 *tmpSel = new TQ_UINT8[srcLen+2*extraLen];
Q_CHECK_PTR(tmpSel);
TQ_CHECK_PTR(tmpSel);
//allocate space for colors
const TQ_UINT8 **colors = new const TQ_UINT8 *[2*support+1];

@ -23,10 +23,10 @@
KisMemento::KisMemento(TQ_UINT32 pixelSize) : KShared()
{
m_hashTable = new KisTile * [1024];
Q_CHECK_PTR(m_hashTable);
TQ_CHECK_PTR(m_hashTable);
m_redoHashTable = new KisTile * [1024];
Q_CHECK_PTR(m_redoHashTable);
TQ_CHECK_PTR(m_redoHashTable);
for(int i = 0; i < 1024; i++)
{

@ -84,7 +84,7 @@ private:
void addTile(TQ_INT32 col, TQ_INT32 row)
{
DeletedTile *d = new DeletedTile(col, row, m_firstDeletedTile);
Q_CHECK_PTR(d);
TQ_CHECK_PTR(d);
m_firstDeletedTile = d;
}

@ -102,7 +102,7 @@ void KisTile::allocate()
if (m_data == 0) {
assert (!readers());
m_data = KisTileManager::instance()->requestTileData(m_pixelSize);
Q_CHECK_PTR(m_data);
TQ_CHECK_PTR(m_data);
}
}

@ -41,14 +41,14 @@ KisTiledDataManager::KisTiledDataManager(TQ_UINT32 pixelSize, const TQ_UINT8 *de
m_pixelSize = pixelSize;
m_defPixel = new TQ_UINT8[m_pixelSize];
Q_CHECK_PTR(m_defPixel);
TQ_CHECK_PTR(m_defPixel);
memcpy(m_defPixel, defPixel, m_pixelSize);
m_defaultTile = new KisTile(pixelSize,0,0, m_defPixel);
Q_CHECK_PTR(m_defaultTile);
TQ_CHECK_PTR(m_defaultTile);
m_hashTable = new KisTile * [1024];
Q_CHECK_PTR(m_hashTable);
TQ_CHECK_PTR(m_hashTable);
for(int i = 0; i < 1024; i++)
m_hashTable [i] = 0;
@ -66,14 +66,14 @@ KisTiledDataManager::KisTiledDataManager(const KisTiledDataManager & dm)
m_pixelSize = dm.m_pixelSize;
m_defPixel = new TQ_UINT8[m_pixelSize];
Q_CHECK_PTR(m_defPixel);
TQ_CHECK_PTR(m_defPixel);
memcpy(m_defPixel, dm.m_defPixel, m_pixelSize);
m_defaultTile = new KisTile(*dm.m_defaultTile, dm.m_defaultTile->getCol(), dm.m_defaultTile->getRow());
Q_CHECK_PTR(m_defaultTile);
TQ_CHECK_PTR(m_defaultTile);
m_hashTable = new KisTile * [1024];
Q_CHECK_PTR(m_hashTable);
TQ_CHECK_PTR(m_hashTable);
m_numTiles = 0;
m_currentMemento = 0;
@ -92,7 +92,7 @@ KisTiledDataManager::KisTiledDataManager(const KisTiledDataManager & dm)
while(tile)
{
KisTile *newtile = new KisTile(*tile, tile->getCol(), tile->getRow());
Q_CHECK_PTR(newtile);
TQ_CHECK_PTR(newtile);
newtile->setNext(m_hashTable[i]);
m_hashTable[i] = newtile;
@ -193,7 +193,7 @@ bool KisTiledDataManager::read(KoStore *store)
TQ_UINT32 tileHash = calcTileHash(col, row);
KisTile *tile = new KisTile(m_pixelSize, col, row, m_defPixel);
Q_CHECK_PTR(tile);
TQ_CHECK_PTR(tile);
updateExtent(col,row);
@ -528,7 +528,7 @@ TQ_UINT32 KisTiledDataManager::calcTileHash(TQ_INT32 col, TQ_INT32 row)
KisMementoSP KisTiledDataManager::getMemento()
{
m_currentMemento = new KisMemento(m_pixelSize);
Q_CHECK_PTR(m_currentMemento);
TQ_CHECK_PTR(m_currentMemento);
memcpy(m_currentMemento->m_defPixel, m_defPixel, m_pixelSize);
@ -606,7 +606,7 @@ void KisTiledDataManager::rollback(KisMementoSP memento)
// Put a copy of the memento tile into our hashtable
curTile = new KisTile(*tile);
Q_CHECK_PTR(curTile);
TQ_CHECK_PTR(curTile);
m_numTiles++;
curTile->setNext(m_hashTable[i]);
@ -671,7 +671,7 @@ void KisTiledDataManager::rollforward(KisMementoSP memento)
// Put a copy of the memento tile into our hashtable
curTile = new KisTile(*tile);
Q_CHECK_PTR(curTile);
TQ_CHECK_PTR(curTile);
curTile->setNext(m_hashTable[i]);
m_hashTable[i] = curTile;
@ -744,7 +744,7 @@ void KisTiledDataManager::ensureTileMementoed(TQ_INT32 col, TQ_INT32 row, TQ_UIN
return; // it has allready been stored
tile = new KisTile(*refTile);
Q_CHECK_PTR(tile);
TQ_CHECK_PTR(tile);
tile->setNext(m_currentMemento->m_hashTable[tileHash]);
m_currentMemento->m_hashTable[tileHash] = tile;
@ -784,7 +784,7 @@ KisTile *KisTiledDataManager::getTile(TQ_INT32 col, TQ_INT32 row, bool writeAcce
{
// Create a new tile
tile = new KisTile(*m_defaultTile, col, row);
Q_CHECK_PTR(tile);
TQ_CHECK_PTR(tile);
tile->setNext(m_hashTable[tileHash]);
m_hashTable[tileHash] = tile;

@ -116,7 +116,7 @@ KisTileManager* KisTileManager::instance()
{
if(KisTileManager::m_singleton == 0) {
staticDeleter.setObject(KisTileManager::m_singleton, new KisTileManager());
Q_CHECK_PTR(KisTileManager::m_singleton);
TQ_CHECK_PTR(KisTileManager::m_singleton);
}
return KisTileManager::m_singleton;
}

@ -461,7 +461,7 @@ KisBumpmapConfigWidget::KisBumpmapConfigWidget(KisFilter *, KisPaintDeviceSP dev
{
m_page = new WdgBumpmap(this);
TQHBoxLayout * l = new TQHBoxLayout(this);
Q_CHECK_PTR(l);
TQ_CHECK_PTR(l);
l->add(m_page);

@ -691,7 +691,7 @@ KisFilterConfiguration* KisCImgFilter::configuration(TQWidget* nwidget)
if( widget == 0 )
{
KisCImgFilterConfiguration * cfg = new KisCImgFilterConfiguration();
Q_CHECK_PTR(cfg);
TQ_CHECK_PTR(cfg);
return cfg;
} else {

@ -33,10 +33,10 @@ KisCImgconfigWidget::KisCImgconfigWidget(KisFilter* nfilter, TQWidget * parent,
: KisFilterConfigWidget(parent, name, f)
{
m_page = new WdgCImg(this);
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
TQHBoxLayout * l = new TQHBoxLayout(this);
Q_CHECK_PTR(l);
TQ_CHECK_PTR(l);
l->add(m_page);
nfilter->setAutoUpdate(false);
@ -58,7 +58,7 @@ KisCImgconfigWidget::KisCImgconfigWidget(KisFilter* nfilter, TQWidget * parent,
KisCImgFilterConfiguration * KisCImgconfigWidget::config()
{
KisCImgFilterConfiguration * cfg = new KisCImgFilterConfiguration();
Q_CHECK_PTR(cfg);
TQ_CHECK_PTR(cfg);
cfg->power1 = m_page->numDetail->value();
cfg->power2 = m_page->numGradient->value();

@ -259,7 +259,7 @@ KisBrightnessContrastConfigWidget::KisBrightnessContrastConfigWidget(TQWidget *
int height;
m_page = new WdgBrightnessContrast(this);
TQHBoxLayout * l = new TQHBoxLayout(this);
Q_CHECK_PTR(l);
TQ_CHECK_PTR(l);
//Hide these buttons and labels as they are not implemented in 1.5
m_page->pb_more_contrast->hide();

@ -307,7 +307,7 @@ KisPerChannelConfigWidget::KisPerChannelConfigWidget(TQWidget * parent, KisPaint
int height;
m_page = new WdgPerChannel(this);
TQHBoxLayout * l = new TQHBoxLayout(this);
Q_CHECK_PTR(l);
TQ_CHECK_PTR(l);
m_dev = dev;
m_curves = new TQSortedList<TQPair<double,double> >[m_dev->colorSpace()->nColorChannels()];

@ -33,7 +33,7 @@
KisFilterConfigWidget * KisCustomConvolutionFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP)
{
KisCustomConvolutionFilterConfigurationWidget* ccfcw = new KisCustomConvolutionFilterConfigurationWidget(this,parent, "custom convolution config widget");
Q_CHECK_PTR(ccfcw);
TQ_CHECK_PTR(ccfcw);
return ccfcw;
}

@ -38,19 +38,19 @@ KisCustomConvolutionFilterConfigurationWidget::KisCustomConvolutionFilterConfigu
: KisFilterConfigWidget ( parent, name )
{
TQGridLayout *widgetLayout = new TQGridLayout(this, 2, 1);
Q_CHECK_PTR(widgetLayout);
TQ_CHECK_PTR(widgetLayout);
// TQPushButton *bnRefresh = new TQPushButton(i18n("Refresh Preview"), this, "bnrefresh");
// Q_CHECK_PTR(bnRefresh);
// TQ_CHECK_PTR(bnRefresh);
// TQSpacerItem *spacer = new TQSpacerItem(100, 30, TQSizePolicy::Expanding, TQSizePolicy::Minimum);
// Q_CHECK_PTR(spacer);
// TQ_CHECK_PTR(spacer);
// widgetLayout->addWidget(bnRefresh, 0, 0);
// widgetLayout->addItem(spacer, 0, 1);
m_ccfcws = new KisCustomConvolutionFilterConfigurationBaseWidget((TQWidget*)this);
Q_CHECK_PTR(m_ccfcws);
TQ_CHECK_PTR(m_ccfcws);
widgetLayout->addMultiCellWidget(m_ccfcws, 1, 1, 0, 1);

@ -163,7 +163,7 @@ KisFilterConfigWidget * KisEmbossFilter::createConfigurationWidget(TQWidget* par
vKisIntegerWidgetParam param;
param.push_back( KisIntegerWidgetParam( 10, 300, 30, i18n("Depth"), "depth" ) );
KisFilterConfigWidget * w = new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
Q_CHECK_PTR(w);
TQ_CHECK_PTR(w);
return w;
}

@ -222,7 +222,7 @@ KisLevelConfigWidget::KisLevelConfigWidget(TQWidget * parent, KisPaintDeviceSP d
m_page->outwhitespin->setValue(255);
TQHBoxLayout * l = new TQHBoxLayout(this);
Q_CHECK_PTR(l);
TQ_CHECK_PTR(l);
l->addWidget(m_page, 0, TQt::AlignTop);
connect( m_page->blackspin, TQT_SIGNAL(valueChanged(int)), TQT_SIGNAL(sigPleaseUpdatePreview()));

@ -117,13 +117,13 @@ void KisSobelFilter::sobel(const TQRect & rc, KisPaintDeviceSP src, KisPaintDevi
/* allocate row buffers */
TQ_UINT8* prevRow = new TQ_UINT8[ (width + 2) * pixelSize];
Q_CHECK_PTR(prevRow);
TQ_CHECK_PTR(prevRow);
TQ_UINT8* curRow = new TQ_UINT8[ (width + 2) * pixelSize];
Q_CHECK_PTR(curRow);
TQ_CHECK_PTR(curRow);
TQ_UINT8* nextRow = new TQ_UINT8[ (width + 2) * pixelSize];
Q_CHECK_PTR(nextRow);
TQ_CHECK_PTR(nextRow);
TQ_UINT8* dest = new TQ_UINT8[ width * pixelSize];
Q_CHECK_PTR(dest);
TQ_CHECK_PTR(dest);
TQ_UINT8* pr = prevRow + pixelSize;
TQ_UINT8* cr = curRow + pixelSize;

@ -38,7 +38,7 @@
KisPaintOp * KisAirbrushOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
{
KisPaintOp * op = new KisAirbrushOp(painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}

@ -51,7 +51,7 @@ KisPaintOp * KisBrushOpFactory::createOp(const KisPaintOpSettings *settings, Kis
Q_ASSERT(settings == 0 || brushopSettings != 0);
KisPaintOp * op = new KisBrushOp(brushopSettings, painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}

@ -37,7 +37,7 @@
KisPaintOp * KisConvolveOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
{
KisPaintOp * op = new KisConvolveOp(painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}

@ -43,7 +43,7 @@
KisPaintOp * KisDuplicateOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
{
KisPaintOp * op = new KisDuplicateOp(painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}
@ -149,7 +149,7 @@ void KisDuplicateOp::paintAt(const KisPoint &pos, const KisPaintInformation& inf
m_srcdev = new KisPaintDevice(device->colorSpace(), "duplicate source dev");
m_target = new KisPaintDevice(device->colorSpace(), "duplicate target dev");
}
Q_CHECK_PTR(m_srcdev);
TQ_CHECK_PTR(m_srcdev);
// Perspective correction ?
KisPainter copyPainter(m_srcdev);

@ -39,7 +39,7 @@
KisPaintOp * KisEraseOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
{
KisPaintOp * op = new KisEraseOp(painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}
@ -97,7 +97,7 @@ void KisEraseOp::paintAt(const KisPoint &pos, const KisPaintInformation& info)
KisAlphaMaskSP mask = brush->mask(info, xFraction, yFraction);
KisPaintDeviceSP dab = new KisPaintDevice(device->colorSpace(), "erase op dab");
Q_CHECK_PTR(dab);
TQ_CHECK_PTR(dab);
TQ_INT32 maskWidth = mask->width();
TQ_INT32 maskHeight = mask->height();

@ -43,7 +43,7 @@
KisPaintOp * KisPenOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
{
KisPaintOp * op = new KisPenOp(painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}

@ -52,7 +52,7 @@ KisPaintOp * KisSmudgeOpFactory::createOp(const KisPaintOpSettings *settings, Ki
Q_ASSERT(settings == 0 || brushopSettings != 0);
KisPaintOp * op = new KisSmudgeOp(brushopSettings, painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}

@ -53,7 +53,7 @@ KisToolBrush::KisToolBrush()
setCursor(KisCursor::load("tool_freehand_cursor.png", 5, 5));
m_rate = 100; // Conveniently hardcoded for now
m_timer = new TQTimer(this);
Q_CHECK_PTR(m_timer);
TQ_CHECK_PTR(m_timer);
connect(m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timeoutPaint()));
@ -155,7 +155,7 @@ TQWidget* KisToolBrush::createOptionWidget(TQWidget* parent)
connect(m_chkDirect, TQT_SIGNAL(stateChanged(int)), this, TQT_SLOT(slotSetPaintingMode(int)));
m_optionLayout = new TQGridLayout(widget, 3, 2, 0, 6);
Q_CHECK_PTR(m_optionLayout);
TQ_CHECK_PTR(m_optionLayout);
super::addOptionWidgetLayout(m_optionLayout);
m_optionLayout->addWidget(m_chkDirect, 0, 0);

@ -75,7 +75,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolBrush();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -76,7 +76,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolColorPicker();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -79,7 +79,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolDuplicate();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -79,7 +79,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolEllipse();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -94,7 +94,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisToolFill * t = new KisToolFill();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -229,7 +229,7 @@ void KisToolGradient::paintLine(KisCanvasPainter& gc)
TQWidget* KisToolGradient::createOptionWidget(TQWidget* parent)
{
TQWidget *widget = super::createOptionWidget(parent);
Q_CHECK_PTR(widget);
TQ_CHECK_PTR(widget);
m_lbShape = new TQLabel(i18n("Shape:"), widget);
m_lbRepeat = new TQLabel(i18n("Repeat:"), widget);

@ -111,7 +111,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolGradient();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -142,7 +142,7 @@ void KisToolLine::buttonRelease(KisButtonReleaseEvent *e)
{
delete m_painter;
m_painter = new KisPainter( device );
Q_CHECK_PTR(m_painter);
TQ_CHECK_PTR(m_painter);
if (m_currentImage->undo()) m_painter->beginTransaction(i18n("Line"));

@ -86,7 +86,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolLine();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -76,7 +76,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolMove();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -68,7 +68,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolPan();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -84,7 +84,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolRectangle();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -70,7 +70,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolText();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -87,7 +87,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolZoom();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -188,7 +188,7 @@ void KisToolMoveSelection::buttonRelease(KisButtonReleaseEvent *e)
if (img->undo()) {
KCommand *cmd = new KisSelectionOffsetCommand( dev, m_layerStart, m_layerPosition);
Q_CHECK_PTR(cmd);
TQ_CHECK_PTR(cmd);
KisUndoAdapter *adapter = img->undoAdapter();
if (adapter) {
adapter->addCommand(cmd);

@ -62,7 +62,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolMoveSelection();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -92,7 +92,7 @@ void KisToolSelectBrush::initPaint(KisEvent* /*e*/)
m_target = selection;
m_painter = new KisPainter(selection.data());
Q_CHECK_PTR(m_painter);
TQ_CHECK_PTR(m_painter);
m_painter->setPaintColor(KisColor(TQt::black, selection->colorSpace()));
m_painter->setBrush(m_subject->currentBrush());
m_painter->setOpacity(OPACITY_OPAQUE);//m_subject->fgColor().colorSpace()->intensity8(m_subject->fgColor().data()));
@ -136,7 +136,7 @@ void KisToolSelectBrush::setup(KActionCollection *collection)
"tool_brush_selection", "Ctrl+Shift+B", this,
TQT_SLOT(activate()), collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Paint a selection"));
m_action->setExclusiveGroup("tools");
m_ownAction = true;
@ -149,7 +149,7 @@ TQWidget* KisToolSelectBrush::createOptionWidget(TQWidget* parent)
// Commented out due to the fact that this doesn't actually work if you change the action
#if 0
m_optWidget = new KisSelectionOptions(parent, m_subject);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(i18n("Selection Brush"));
TQVBoxLayout * l = dynamic_cast<TQVBoxLayout*>(m_optWidget->layout());

@ -71,7 +71,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolSelectBrush();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -149,7 +149,7 @@ void KisToolSelectContiguous::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Select a contiguous area"));
m_action->setExclusiveGroup("tools");
m_ownAction = true;
@ -186,7 +186,7 @@ void KisToolSelectContiguous::slotSetAction(int action)
TQWidget* KisToolSelectContiguous::createOptionWidget(TQWidget* parent)
{
m_optWidget = new KisSelectionOptions(parent, m_subject);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(i18n("Contiguous Area Selection"));
TQVBoxLayout * l = dynamic_cast<TQVBoxLayout*>(m_optWidget->layout());
@ -195,13 +195,13 @@ TQWidget* KisToolSelectContiguous::createOptionWidget(TQWidget* parent)
connect (m_optWidget, TQT_SIGNAL(actionChanged(int)), this, TQT_SLOT(slotSetAction(int)));
TQHBoxLayout * hbox = new TQHBoxLayout(l);
Q_CHECK_PTR(hbox);
TQ_CHECK_PTR(hbox);
TQLabel * lbl = new TQLabel(i18n("Fuzziness: "), m_optWidget);
hbox->addWidget(lbl);
KIntNumInput * input = new KIntNumInput(m_optWidget, "fuzziness");
Q_CHECK_PTR(input);
TQ_CHECK_PTR(input);
input->setRange(0, 200, 10, true);
input->setValue(20);

@ -83,7 +83,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolSelectContiguous();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -290,7 +290,7 @@ void KisToolSelectElliptical::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Select an elliptical area"));
m_action->setExclusiveGroup("tools");
m_ownAction = true;
@ -300,7 +300,7 @@ void KisToolSelectElliptical::setup(KActionCollection *collection)
TQWidget* KisToolSelectElliptical::createOptionWidget(TQWidget* parent)
{
m_optWidget = new KisSelectionOptions(parent, m_subject);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(i18n("Elliptical Selection"));
connect (m_optWidget, TQT_SIGNAL(actionChanged(int)), this, TQT_SLOT(slotSetAction(int)));

@ -84,7 +84,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolSelectElliptical();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -91,7 +91,7 @@ void KisToolSelectEraser::initPaint(KisEvent */*e*/)
m_target = selection;
m_painter = new KisPainter(selection.data());
Q_CHECK_PTR(m_painter);
TQ_CHECK_PTR(m_painter);
m_painter->beginTransaction(i18n("Selection Eraser"));
m_painter->setPaintColor(KisColor(TQt::white, selection->colorSpace()));
m_painter->setBrush(m_subject->currentBrush());
@ -123,7 +123,7 @@ void KisToolSelectEraser::setup(KActionCollection *collection)
"tool_eraser_selection", "Ctrl+Shift+E", this,
TQT_SLOT(activate()), collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Erase parts of a selection"));
m_action->setExclusiveGroup("tools");
m_ownAction = true;
@ -136,7 +136,7 @@ TQWidget* KisToolSelectEraser::createOptionWidget(TQWidget* parent)
// Commented out due to the fact that this doesn't actually work if you change the action
#if 0
m_optWidget = new KisSelectionOptions(parent, m_subject);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(i18n("Selection Eraser"));
TQVBoxLayout * l = dynamic_cast<TQVBoxLayout*>(m_optWidget->layout());

@ -69,7 +69,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolSelectEraser();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -259,7 +259,7 @@ void KisToolSelectOutline::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setExclusiveGroup("tools");
m_action->setToolTip(i18n("Select an outline"));
m_ownAction = true;
@ -270,7 +270,7 @@ void KisToolSelectOutline::setup(KActionCollection *collection)
TQWidget* KisToolSelectOutline::createOptionWidget(TQWidget* parent)
{
m_optWidget = new KisSelectionOptions(parent, m_subject);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(i18n("Outline Selection"));
connect (m_optWidget, TQT_SIGNAL(actionChanged(int)), this, TQT_SLOT(slotSetAction(int)));

@ -89,7 +89,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolSelectOutline();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -278,7 +278,7 @@ void KisToolSelectPolygonal::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setExclusiveGroup("tools");
m_action->setToolTip(i18n("Select a polygonal area"));
m_ownAction = true;
@ -289,7 +289,7 @@ void KisToolSelectPolygonal::setup(KActionCollection *collection)
TQWidget* KisToolSelectPolygonal::createOptionWidget(TQWidget* parent)
{
m_optWidget = new KisSelectionOptions(parent, m_subject);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(i18n("Polygonal Selection"));
connect (m_optWidget, TQT_SIGNAL(actionChanged(int)), this, TQT_SLOT(slotSetAction(int)));

@ -94,7 +94,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolSelectPolygonal();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -291,7 +291,7 @@ void KisToolSelectRectangular::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setExclusiveGroup("tools");
m_action->setToolTip(i18n("Select a rectangular area"));
m_ownAction = true;
@ -301,7 +301,7 @@ void KisToolSelectRectangular::setup(KActionCollection *collection)
TQWidget* KisToolSelectRectangular::createOptionWidget(TQWidget* parent)
{
m_optWidget = new KisSelectionOptions(parent, m_subject);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(i18n("Rectangular Selection"));
connect (m_optWidget, TQT_SIGNAL(actionChanged(int)), this, TQT_SLOT(slotSetAction(int)));

@ -83,7 +83,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolSelectRectangular();
t->setup(ac);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
return t;
}
virtual KisID id() { return KisID("rectangularselect", i18n("Rectangular Select Tool")); }

@ -701,7 +701,7 @@ void KisToolCrop::setOptionWidgetRatio(double ratio)
TQWidget* KisToolCrop::createOptionWidget(TQWidget* parent)
{
m_optWidget = new WdgToolCrop(parent);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
connect(m_optWidget->bnCrop, TQT_SIGNAL(clicked()), this, TQT_SLOT(crop()));
@ -731,7 +731,7 @@ void KisToolCrop::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Crop an area"));
m_action->setExclusiveGroup("tools");

@ -136,7 +136,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolCrop();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -104,7 +104,7 @@ void KisToolBezierPaint::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Draw cubic beziers. Keep Alt, Control or Shift pressed for options. Return or double-click to finish."));
m_action->setExclusiveGroup("tools");

@ -53,7 +53,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolBezierPaint();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -93,7 +93,7 @@ void KisToolBezierSelect::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Select areas of the image with bezier paths."));
m_action->setExclusiveGroup("tools");

@ -53,7 +53,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolBezierSelect();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -571,7 +571,7 @@ void KisToolCurve::slotSetAction(int action) {
TQWidget* KisToolCurve::createSelectionOptionWidget(TQWidget* parent)
{
m_optWidget = new KisSelectionOptions(parent, m_subject);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(m_UIName);
connect (m_optWidget, TQT_SIGNAL(actionChanged(int)), this, TQT_SLOT(slotSetAction(int)));

@ -97,7 +97,7 @@ void KisToolExample::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("This is a test tool for the Curve Framework."));
m_action->setExclusiveGroup("tools");

@ -56,7 +56,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolExample();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -766,7 +766,7 @@ TQWidget* KisToolMagnetic::createOptionWidget(TQWidget* parent)
TQGridLayout *box = new TQGridLayout(l, 2, 2, 3);
box->setColStretch(0, 1);
box->setColStretch(1, 1);
Q_CHECK_PTR(box);
TQ_CHECK_PTR(box);
m_mode = new TQLabel(i18n("Automatic mode"), m_optWidget);
m_lbDistance = new TQLabel(i18n("Distance: "), m_optWidget);
@ -798,7 +798,7 @@ void KisToolMagnetic::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Magnetic Selection: move around an edge to select it. Hit Ctrl to enter/quit manual mode, and double click to finish."));
m_action->setExclusiveGroup("tools");

@ -122,7 +122,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolMagnetic();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -93,7 +93,7 @@ void KisFilterOp::paintAt(const KisPoint &pos, const KisPaintInformation& info)
// Create a temporary paint device
KisPaintDeviceSP tmpDev = new KisPaintDevice(colorSpace, "filterop tmpdev");
Q_CHECK_PTR(tmpDev);
TQ_CHECK_PTR(tmpDev);
// Copy the layer data onto the new paint device

@ -69,7 +69,7 @@ void KisToolFilter::setup(KActionCollection *collection)
"tool_filter", 0, this,
TQT_SLOT(activate()), collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Paint with filters"));
m_action->setExclusiveGroup("tools");
m_ownAction = true;
@ -101,10 +101,10 @@ TQWidget* KisToolFilter::createOptionWidget(TQWidget* parent)
TQWidget *widget = super::createOptionWidget(parent);
m_cbFilter = new KisCmbIDList(widget);
Q_CHECK_PTR(m_cbFilter);
TQ_CHECK_PTR(m_cbFilter);
TQLabel* lbFilter = new TQLabel(i18n("Filter:"), widget);
Q_CHECK_PTR(lbFilter);
TQ_CHECK_PTR(lbFilter);
// Check which filters support painting
KisIDList l = KisFilterRegistry::instance()->listKeys();
@ -121,7 +121,7 @@ TQWidget* KisToolFilter::createOptionWidget(TQWidget* parent)
addOptionWidgetOption(m_cbFilter, lbFilter);
m_optionLayout = new TQGridLayout(widget, 1, 1, 0, 6);
Q_CHECK_PTR(m_optionLayout);
TQ_CHECK_PTR(m_optionLayout);
super::addOptionWidgetLayout(m_optionLayout);
connect(m_cbFilter, TQT_SIGNAL(activated ( const KisID& )), this, TQT_SLOT( changeFilter( const KisID& ) ) );

@ -70,7 +70,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolFilter();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -477,7 +477,7 @@ void KisToolPerspectiveGrid::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setExclusiveGroup("tools");
m_action->setToolTip(i18n("Edit the perspective grid"));
m_ownAction = true;

@ -99,7 +99,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolPerspectiveGrid();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -685,7 +685,7 @@ TQWidget* KisToolPerspectiveTransform::createOptionWidget(TQWidget* /*parent*/)
{
#if 0
m_optWidget = new WdgToolPerspectiveTransform(parent);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->cmbFilter->clear();
m_optWidget->cmbFilter->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
@ -732,7 +732,7 @@ void KisToolPerspectiveTransform::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Perspective transform a layer or a selection"));
m_action->setExclusiveGroup("tools");
m_ownAction = true;

@ -119,7 +119,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolPerspectiveTransform();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac); return t;
}
virtual KisID id() { return KisID("perspective transform", i18n("Perspective transform Tool")); }

@ -230,7 +230,7 @@ void KisToolPolygon::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Draw a polygon. Shift-mouseclick ends the polygon."));
m_action->setExclusiveGroup("tools");

@ -91,7 +91,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolPolygon();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -245,7 +245,7 @@ void KisToolPolyline::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Draw a polyline. Shift-mouseclick ends the polyline."));
m_action->setExclusiveGroup("tools");

@ -98,7 +98,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolPolyline();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -203,7 +203,7 @@ void KisToolSelectSimilar::setup(KActionCollection *collection)
if (m_action == 0) {
m_action = new KRadioAction(i18n("&Similar Selection"), "tool_similar_selection", "Ctrl+E", this, TQT_SLOT(activate()), collection, name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Select similar colors"));
m_action->setExclusiveGroup("tools");
m_ownAction = true;
@ -229,29 +229,29 @@ void KisToolSelectSimilar::slotSetAction(int action)
TQWidget* KisToolSelectSimilar::createOptionWidget(TQWidget* parent)
{
m_optWidget = new TQWidget(parent);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->setCaption(i18n("Similar Selection"));
TQVBoxLayout * l = new TQVBoxLayout(m_optWidget, 0, 6);
Q_CHECK_PTR(l);
TQ_CHECK_PTR(l);
m_selectionOptionsWidget = new KisSelectionOptions(m_optWidget, m_subject);
Q_CHECK_PTR(m_selectionOptionsWidget);
TQ_CHECK_PTR(m_selectionOptionsWidget);
l->addWidget(m_selectionOptionsWidget);
connect (m_selectionOptionsWidget, TQT_SIGNAL(actionChanged(int)), this, TQT_SLOT(slotSetAction(int)));
TQHBoxLayout * hbox = new TQHBoxLayout(l);
Q_CHECK_PTR(hbox);
TQ_CHECK_PTR(hbox);
TQLabel * lbl = new TQLabel(i18n("Fuzziness: "), m_optWidget);
Q_CHECK_PTR(lbl);
TQ_CHECK_PTR(lbl);
hbox->addWidget(lbl);
KIntNumInput * input = new KIntNumInput(m_optWidget, "fuzziness");
Q_CHECK_PTR(input);
TQ_CHECK_PTR(input);
input->setRange(0, 200, 10, true);
input->setValue(20);

@ -90,7 +90,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolSelectSimilar();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -187,7 +187,7 @@ void KisToolStar::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Draw a star"));
m_action->setExclusiveGroup("tools");
@ -230,7 +230,7 @@ TQWidget* KisToolStar::createOptionWidget(TQWidget* parent)
TQWidget *widget = super::createOptionWidget(parent);
m_optWidget = new WdgToolStar(widget);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->ratioSpinBox->setValue(m_innerOuterRatio);

@ -90,7 +90,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolStar();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -860,7 +860,7 @@ TQWidget* KisToolTransform::createOptionWidget(TQWidget* parent)
{
m_optWidget = new WdgToolTransform(parent);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->cmbFilter->clear();
m_optWidget->cmbFilter->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
@ -906,7 +906,7 @@ void KisToolTransform::setup(KActionCollection *collection)
TQT_SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Transform a layer or a selection"));
m_action->setExclusiveGroup("tools");
m_ownAction = true;

@ -143,7 +143,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolTransform();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac); return t;
}
virtual KisID id() { return KisID("transform", i18n("Transform Tool")); }

@ -51,7 +51,7 @@ ToolTransform::ToolTransform(TQObject *parent, const char *name, const TQStringL
{
KisToolRegistry * r = dynamic_cast<KisToolRegistry*>(parent);
KisToolTransformFactory * f = new KisToolTransformFactory();
Q_CHECK_PTR(f);
TQ_CHECK_PTR(f);
r->add(f);
}

@ -73,7 +73,7 @@ void ColorRange::slotActivated()
if (!layer) return;
DlgColorRange * dlgColorRange = new DlgColorRange(m_view, layer, m_view, "ColorRange");
Q_CHECK_PTR(dlgColorRange);
TQ_CHECK_PTR(dlgColorRange);
dlgColorRange->exec();
}

@ -183,7 +183,7 @@ DlgColorRange::DlgColorRange( KisView * view, KisPaintDeviceSP dev, TQWidget *
m_subject = view->canvasSubject();
m_page = new WdgColorRange(this, "color_range");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setCaption(i18n("Color Range"));
setMainWidget(m_page);

@ -99,7 +99,7 @@ void ColorSpaceConversion::slotImgColorSpaceConversion()
}
DlgColorSpaceConversion * dlgColorSpaceConversion = new DlgColorSpaceConversion(m_view, "ColorSpaceConversion");
Q_CHECK_PTR(dlgColorSpaceConversion);
TQ_CHECK_PTR(dlgColorSpaceConversion);
dlgColorSpaceConversion->setCaption(i18n("Convert All Layers From ") + image->colorSpace()->id().name());
@ -136,7 +136,7 @@ void ColorSpaceConversion::slotLayerColorSpaceConversion()
}
DlgColorSpaceConversion * dlgColorSpaceConversion = new DlgColorSpaceConversion(m_view, "ColorSpaceConversion");
Q_CHECK_PTR(dlgColorSpaceConversion);
TQ_CHECK_PTR(dlgColorSpaceConversion);
dlgColorSpaceConversion->setCaption(i18n("Convert Current Layer From") + dev->colorSpace()->id().name());

@ -44,7 +44,7 @@ DlgColorSpaceConversion::DlgColorSpaceConversion( TQWidget * parent,
: super (parent, name, true, i18n("Image Size"), Ok | Cancel, Ok)
{
m_page = new WdgConvertColorSpace(this, "colorspace_conversion");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -44,7 +44,7 @@ DlgDropshadow::DlgDropshadow( const TQString & /*imageCS*/,
: super (parent, name, true, i18n("Drop Shadow"), Ok | Cancel, Ok)
{
m_page = new WdgDropshadow(this, "dropshadow");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -67,7 +67,7 @@ void KisDropshadowPlugin::slotDropshadow()
DlgDropshadow * dlgDropshadow = new DlgDropshadow(dev->colorSpace()->id().name(),
image->colorSpace()->id().name(),
m_view, "Dropshadow");
Q_CHECK_PTR(dlgDropshadow);
TQ_CHECK_PTR(dlgDropshadow);
dlgDropshadow->setCaption(i18n("Drop Shadow"));

@ -43,7 +43,7 @@ DlgHistogram::DlgHistogram( TQWidget * parent, const char * name)
: super (parent, name, true, i18n("Histogram"), Ok | Cancel, Ok)
{
m_page = new KisHistogramWidget(this, "histogram");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setCaption(i18n("Histogram"));
setMainWidget(m_page);

@ -89,7 +89,7 @@ void Histogram::slotLayersChanged() {
void Histogram::slotActivated()
{
DlgHistogram * dlgHistogram = new DlgHistogram(m_view, "Histogram");
Q_CHECK_PTR(dlgHistogram);
TQ_CHECK_PTR(dlgHistogram);
KisPaintDeviceSP dev = m_view->canvasSubject()->currentImg()->activeDevice();
if (dev)

@ -52,7 +52,7 @@ DlgImageSize::DlgImageSize( TQWidget * parent,
m_lock = false;
m_page = new WdgImageSize(this, "image_size");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
m_page->cmbFilterType->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
m_page->cmbFilterType->setCurrentText("Mitchell");

@ -53,7 +53,7 @@ DlgLayerSize::DlgLayerSize( TQWidget * parent,
m_lock = false;
m_page = new WdgLayerSize(this, "layer_size");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
m_page->cmbFilterType->setIDList(KisFilterStrategyRegistry::instance()->listKeys());
m_page->cmbFilterType->setCurrentText("Mitchell");

@ -73,7 +73,7 @@ ImageSize::ImageSize(TQObject *parent, const char *name, const TQStringList &)
m_view = (KisView*) parent;
// Selection manager takes ownership?
KAction * a = new KAction(i18n("&Scale Selection..."), 0, 0, this, TQT_SLOT(slotSelectionScale()), actionCollection(), "selectionscale");
Q_CHECK_PTR(a);
TQ_CHECK_PTR(a);
m_view ->canvasSubject()-> selectionManager()->addSelectionAction(a);
}
}
@ -90,7 +90,7 @@ void ImageSize::slotImageSize()
if (!image) return;
DlgImageSize * dlgImageSize = new DlgImageSize(m_view, "ImageSize");
Q_CHECK_PTR(dlgImageSize);
TQ_CHECK_PTR(dlgImageSize);
dlgImageSize->setCaption(i18n("Image Size"));
@ -123,7 +123,7 @@ void ImageSize::slotLayerSize()
if (!image) return;
DlgLayerSize * dlgLayerSize = new DlgLayerSize(m_view, "LayerSize");
Q_CHECK_PTR(dlgLayerSize);
TQ_CHECK_PTR(dlgLayerSize);
dlgLayerSize->setCaption(i18n("Layer Size"));
@ -160,7 +160,7 @@ void ImageSize::slotSelectionScale()
DlgLayerSize * dlgLayerSize = new DlgLayerSize(m_view, "SelectionScale");
Q_CHECK_PTR(dlgLayerSize);
TQ_CHECK_PTR(dlgLayerSize);
dlgLayerSize->setCaption(i18n("Scale Selection"));

@ -42,7 +42,7 @@ using namespace std;
DlgBorderSelection::DlgBorderSelection( TQWidget * parent, const char * name) : super (parent, name, true, i18n("Border Selection"), Ok | Cancel, Ok)
{
m_page = new WdgBorderSelection(this, "border_selection");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -42,7 +42,7 @@ using namespace std;
DlgGrowSelection::DlgGrowSelection( TQWidget * parent, const char * name) : super (parent, name, true, i18n("Grow Selection"), Ok | Cancel, Ok)
{
m_page = new WdgGrowSelection(this, "grow_selection");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -42,7 +42,7 @@ using namespace std;
DlgShrinkSelection::DlgShrinkSelection( TQWidget * parent, const char * name) : super (parent, name, true, i18n("Shrink Selection"), Ok | Cancel, Ok)
{
m_page = new WdgShrinkSelection(this, "shrink_selection");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -70,9 +70,9 @@ ModifySelection::ModifySelection(TQObject *parent, const char *name, const TQStr
KAction* b = new KAction(i18n("Shrink Selection..."), 0, 0, this, TQT_SLOT(slotShrinkSelection()), actionCollection(), "shrinkselection");
KAction* c = new KAction(i18n("Border Selection..."), 0, 0, this, TQT_SLOT(slotBorderSelection()), actionCollection(), "borderselection");
Q_CHECK_PTR(a);
Q_CHECK_PTR(b);
Q_CHECK_PTR(c);
TQ_CHECK_PTR(a);
TQ_CHECK_PTR(b);
TQ_CHECK_PTR(c);
m_view ->canvasSubject()-> selectionManager()->addSelectionAction(a);
m_view ->canvasSubject()-> selectionManager()->addSelectionAction(b);
@ -92,7 +92,7 @@ void ModifySelection::slotGrowSelection()
if (!image) return;
DlgGrowSelection * dlgGrowSelection = new DlgGrowSelection(m_view, "GrowSelection");
Q_CHECK_PTR(dlgGrowSelection);
TQ_CHECK_PTR(dlgGrowSelection);
dlgGrowSelection->setCaption(i18n("Grow Selection"));
@ -115,7 +115,7 @@ void ModifySelection::slotShrinkSelection()
if (!image) return;
DlgShrinkSelection * dlgShrinkSelection = new DlgShrinkSelection(m_view, "ShrinkSelection");
Q_CHECK_PTR(dlgShrinkSelection);
TQ_CHECK_PTR(dlgShrinkSelection);
dlgShrinkSelection->setCaption(i18n("Shrink Selection"));
@ -139,7 +139,7 @@ void ModifySelection::slotBorderSelection()
if (!image) return;
DlgBorderSelection * dlgBorderSelection = new DlgBorderSelection(m_view, "BorderSelection");
Q_CHECK_PTR(dlgBorderSelection);
TQ_CHECK_PTR(dlgBorderSelection);
dlgBorderSelection->setCaption(i18n("Border Selection"));

@ -46,7 +46,7 @@ DlgPerfTest::DlgPerfTest( TQWidget * parent,
m_lock = false;
m_page = new WdgPerfTest(this, "perf_test");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -104,7 +104,7 @@ void PerfTest::slotPerfTest()
if (!image) return;
DlgPerfTest * dlgPerfTest = new DlgPerfTest(m_view, "PerfTest");
Q_CHECK_PTR(dlgPerfTest);
TQ_CHECK_PTR(dlgPerfTest);
dlgPerfTest->setCaption(i18n("Performance Test"));
@ -217,11 +217,11 @@ void PerfTest::slotPerfTest()
kdDebug() << s << "\n";
}
KDialogBase * d = new KDialogBase(m_view, "", true, "", KDialogBase::Ok);
Q_CHECK_PTR(d);
TQ_CHECK_PTR(d);
d->setCaption("Performance test results");
TQTextEdit * e = new TQTextEdit(d);
Q_CHECK_PTR(e);
TQ_CHECK_PTR(e);
d->setMainWidget(e);
e->setText(report);
e->setMinimumWidth(600);
@ -279,7 +279,7 @@ TQString PerfTest::doBlit(const KisCompositeOp& op,
// Small
KisPaintDeviceSP small = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getColorSpace(cspace,""), "small blit");
Q_CHECK_PTR(small);
TQ_CHECK_PTR(small);
KisFillPainter pf(small.data()) ;
pf.fillRect(0, 0, 32, 32, KisColor(TQt::black, KisMetaRegistry::instance()->csRegistry()->getRGB8()));
@ -302,7 +302,7 @@ TQString PerfTest::doBlit(const KisCompositeOp& op,
// ------------------------------------------------------------------------------
// Medium
KisPaintDeviceSP medium = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getColorSpace(cspace,""), "medium blit");
Q_CHECK_PTR(medium);
TQ_CHECK_PTR(medium);
pf.begin(medium.data()) ;
pf.fillRect(0, 0, 64 * 3, 64 * 3, KisColor(TQt::black, KisMetaRegistry::instance()->csRegistry()->getRGB8()));
@ -325,7 +325,7 @@ TQString PerfTest::doBlit(const KisCompositeOp& op,
// ------------------------------------------------------------------------------
// Big
KisPaintDeviceSP big = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getColorSpace(cspace,""), "big blit");
Q_CHECK_PTR(big);
TQ_CHECK_PTR(big);
pf.begin(big.data()) ;
pf.fillRect(0, 0, 800, 800, KisColor(TQt::black, KisMetaRegistry::instance()->csRegistry()->getRGB8()));
@ -349,7 +349,7 @@ TQString PerfTest::doBlit(const KisCompositeOp& op,
// Outside
KisPaintDeviceSP outside = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getColorSpace(cspace,""), "outside blit");
Q_CHECK_PTR(outside);
TQ_CHECK_PTR(outside);
pf.begin(outside.data()) ;
pf.fillRect(0, 0, 500, 500, KisColor(TQt::black, KisMetaRegistry::instance()->csRegistry()->getRGB8()));
pf.end();
@ -371,7 +371,7 @@ TQString PerfTest::doBlit(const KisCompositeOp& op,
// Small with varied source opacity
KisPaintDeviceSP small_with_alpha = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()->getColorSpace(cspace,""), "small blit with alpha");
Q_CHECK_PTR(small_with_alpha);
TQ_CHECK_PTR(small_with_alpha);
pf.begin(small_with_alpha.data()) ;
pf.fillRect(0, 0, 32, 32, KisColor(TQt::black, KisMetaRegistry::instance()->csRegistry()->getRGB8()), OPACITY_TRANSPARENT);
@ -499,7 +499,7 @@ TQString PerfTest::fillTest(TQ_UINT32 testCount)
// p.paintEllipse(500, 1000, 100, 0, 0);
p.setPaintColor(KisColor(TQt::black, KisMetaRegistry::instance()->csRegistry()->getRGB8()));
KisResourceServerBase* r = KisResourceServerRegistry::instance()->get("PatternServer");
Q_CHECK_PTR(r);
TQ_CHECK_PTR(r);
p.setPattern((KisPattern*)r->resources().first());
p.setFillThreshold(15);
p.setCompositeOp(COMPOSITE_OVER);
@ -704,7 +704,7 @@ TQString PerfTest::readBytesTest(TQ_UINT32 testCount)
for (TQ_UINT32 i = 0; i < testCount; ++i) {
TQ_UINT8 * newData = new TQ_UINT8[1000 * 1000 * l->pixelSize()];
Q_CHECK_PTR(newData);
TQ_CHECK_PTR(newData);
l->readBytes(newData, 0, 0, 1000, 1000);
delete[] newData;
}
@ -721,7 +721,7 @@ TQString PerfTest::readBytesTest(TQ_UINT32 testCount)
for (TQ_UINT32 i = 0; i < testCount; ++i) {
TQ_UINT8 * newData = new TQ_UINT8[1000 * 1000 * l->pixelSize()];
Q_CHECK_PTR(newData);
TQ_CHECK_PTR(newData);
l->readBytes(newData, 0, 0, 1000, 1000);
delete[] newData;
}
@ -746,7 +746,7 @@ TQString PerfTest::writeBytesTest(TQ_UINT32 testCount)
TQ_UINT8 * data = new TQ_UINT8[1000 * 1000 * l->pixelSize()];
Q_CHECK_PTR(data);
TQ_CHECK_PTR(data);
l->readBytes(data, 0, 0, 1000, 1000);
TQTime t;

@ -46,7 +46,7 @@ DlgRotateImage::DlgRotateImage( TQWidget * parent,
m_lock = false;
m_page = new WdgRotateImage(this, "rotate_image");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -84,7 +84,7 @@ void RotateImage::slotRotateImage()
if (!image) return;
DlgRotateImage * dlgRotateImage = new DlgRotateImage(m_view, "RotateImage");
Q_CHECK_PTR(dlgRotateImage);
TQ_CHECK_PTR(dlgRotateImage);
dlgRotateImage->setCaption(i18n("Rotate Image"));
@ -119,7 +119,7 @@ void RotateImage::slotRotateLayer()
if (!image) return;
DlgRotateImage * dlgRotateImage = new DlgRotateImage(m_view, "RotateLayer");
Q_CHECK_PTR(dlgRotateImage);
TQ_CHECK_PTR(dlgRotateImage);
dlgRotateImage->setCaption(i18n("Rotate Layer"));

@ -62,7 +62,7 @@ KSnapshot::KSnapshot(TQWidget *parent, const char *name)
: super(parent, name, false, TQString(), Ok|Cancel)
{
grabber = new TQWidget( 0, 0, WStyle_Customize | WX11BypassWM );
Q_CHECK_PTR(grabber);
TQ_CHECK_PTR(grabber);
grabber->move( -1000, -1000 );
grabber->installEventFilter( this );
@ -74,7 +74,7 @@ KSnapshot::KSnapshot(TQWidget *parent, const char *name)
TQVBox *vbox = makeVBoxMainWidget();
mainWidget = new KSnapshotWidget( vbox, "mainWidget" );
Q_CHECK_PTR(mainWidget);
TQ_CHECK_PTR(mainWidget);
mainWidget->btnSave->hide();
mainWidget->btnPrint->hide();
@ -100,7 +100,7 @@ KSnapshot::KSnapshot(TQWidget *parent, const char *name)
connect( &grabTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( grabTimerDone() ) );
KAccel* accel = new KAccel(this);
Q_CHECK_PTR(accel);
TQ_CHECK_PTR(accel);
accel->insert(KStdAccel::Print, TQT_TQOBJECT(this), TQT_SLOT(slotPrint()));
accel->insert(KStdAccel::New, TQT_TQOBJECT(this), TQT_SLOT(slotGrab()));
@ -169,7 +169,7 @@ void KSnapshot::slotCopy()
void KSnapshot::slotDragSnapshot()
{
TQDragObject *drobj = new TQImageDrag(snapshot.convertToImage(), this);
Q_CHECK_PTR(drobj);
TQ_CHECK_PTR(drobj);
drobj->setPixmap(mainWidget->preview());
drobj->dragCopy();
}
@ -180,7 +180,7 @@ void KSnapshot::slotGrab()
if ( mainWidget->mode() == Region )
{
rgnGrab = new RegionGrabber();
Q_CHECK_PTR(rgnGrab);
TQ_CHECK_PTR(rgnGrab);
connect( rgnGrab, TQT_SIGNAL( regionGrabbed( const TQPixmap & ) ),
TQT_SLOT( slotRegionGrabbed( const TQPixmap & ) ) );
}

@ -27,7 +27,7 @@ int main(int argc, char **argv)
// Create top level window
KSnapshot *toplevel= new KSnapshot();
Q_CHECK_PTR(toplevel);
TQ_CHECK_PTR(toplevel);
app.dcopClient()->setDefaultObject( toplevel->objId() );
toplevel->setCaption( app.makeStdCaption("") );
toplevel->setIcon(SmallIcon("tool_screenshot"));

@ -74,7 +74,7 @@ RegionGrabber::RegionGrabber()
sizeTip = new SizeTip( ( TQWidget * )0L );
tipTimer = new TQTimer( this );
Q_CHECK_PTR(tipTimer);
TQ_CHECK_PTR(tipTimer);
connect( tipTimer, TQT_SIGNAL( timeout() ), TQT_SLOT( updateSizeTip() ) );
TQTimer::singleShot( 200, this, TQT_SLOT( initGrabber() ) );

@ -50,7 +50,7 @@ Screenshot::Screenshot(TQObject *parent, const char *name, const TQStringList &)
KImageIO::registerFormats();
snapshot = new KSnapshot();
Q_CHECK_PTR(snapshot);
TQ_CHECK_PTR(snapshot);
connect( snapshot, TQT_SIGNAL( screenGrabbed() ), TQT_SLOT( slotScreenGrabbed() ) );
(void) new KAction(i18n("&Screenshot..."), SmallIcon("tool_screenshot"), 0, this, TQT_SLOT(slotScreenshot()), actionCollection(), "screenshot");

@ -148,7 +148,7 @@ Kross::Api::Object::Ptr PaintLayer::beginPainting(Kross::Api::List::Ptr args)
delete m_cmd;
}
m_cmd = new KisTransaction(name, paintLayer()->paintDevice());
Q_CHECK_PTR(m_cmd);
TQ_CHECK_PTR(m_cmd);
return 0;
}

@ -41,7 +41,7 @@ DlgSeparate::DlgSeparate( const TQString & imageCS,
m_layerCS(layerCS)
{
m_page = new WdgSeparations(this, "separate_image");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -68,7 +68,7 @@ void KisSeparateChannelsPlugin::slotSeparate()
DlgSeparate * dlgSeparate = new DlgSeparate(dev->colorSpace()->id().name(),
image->colorSpace()->id().name(), m_view, "Separate");
Q_CHECK_PTR(dlgSeparate);
TQ_CHECK_PTR(dlgSeparate);
dlgSeparate->setCaption(i18n("Separate Image"));

@ -47,7 +47,7 @@ DlgShearImage::DlgShearImage( TQWidget * parent,
m_page = new WdgShearImage(this, "shear_image");
m_page->layout()->setMargin(0);
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setMainWidget(m_page);
resize(m_page->sizeHint());

@ -78,7 +78,7 @@ void ShearImage::slotShearImage()
if (!image) return;
DlgShearImage * dlgShearImage = new DlgShearImage(m_view, "ShearImage");
Q_CHECK_PTR(dlgShearImage);
TQ_CHECK_PTR(dlgShearImage);
dlgShearImage->setCaption(i18n("Shear Image"));
@ -97,7 +97,7 @@ void ShearImage::slotShearLayer()
if (!image) return;
DlgShearImage * dlgShearImage = new DlgShearImage(m_view, "ShearLayer");
Q_CHECK_PTR(dlgShearImage);
TQ_CHECK_PTR(dlgShearImage);
dlgShearImage->setCaption(i18n("Shear Layer"));

@ -30,7 +30,7 @@ DlgSubstrate::DlgSubstrate( TQWidget * parent,
{
m_previewPix = TQPixmap();
m_page = new WdgSubstrate(this, "substrate");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setCaption(i18n("Substrate"));
setMainWidget(m_page);
resize(m_page -> size());

@ -66,7 +66,7 @@ SubstratePlugin::~SubstratePlugin()
void SubstratePlugin::slotSubstrateActivated()
{
DlgSubstrate * dlgSubstrate = new DlgSubstrate(m_view, "Substrate");
Q_CHECK_PTR(dlgSubstrate);
TQ_CHECK_PTR(dlgSubstrate);
if (dlgSubstrate -> exec() == TQDialog::Accepted) {
// Retrieve changes made by dialog
// Apply changes to layer (selection)

@ -30,7 +30,7 @@ DlgVariations::DlgVariations( TQWidget * parent,
{
m_previewPix = TQPixmap();
m_page = new WdgVariations(this, "variations");
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
setCaption(i18n("Variations"));
setMainWidget(m_page);
resize(m_page -> size());

@ -70,7 +70,7 @@ Variations::~Variations()
void Variations::slotVariationsActivated()
{
DlgVariations * dlgVariations = new DlgVariations(m_view, "Variations");
Q_CHECK_PTR(dlgVariations);
TQ_CHECK_PTR(dlgVariations);
// Render layer to a TQIMage -- keep in mind possibility of selection
// Scale TQImage

@ -50,7 +50,7 @@ KisAutobrush::KisAutobrush(TQWidget *parent, const char* name, const TQString& c
connect(spinBoxVertical,TQT_SIGNAL(valueChanged(int)),this,TQT_SLOT(spinBoxVerticalChanged(int)));
m_brsh = new TQImage(1,1,32);
Q_CHECK_PTR(m_brsh);
TQ_CHECK_PTR(m_brsh);
paramChanged();
@ -79,11 +79,11 @@ void KisAutobrush::paramChanged()
if(comboBoxShape->currentItem() == 0) // use index compare instead of comparing a translatable string
{
kas = new KisAutobrushCircleShape(spinBoxWidth->value(), spinBoxHeigth->value(), fh, fv);
Q_CHECK_PTR(kas);
TQ_CHECK_PTR(kas);
} else {
kas = new KisAutobrushRectShape(spinBoxWidth->value(), spinBoxHeigth->value(), fh, fv);
Q_CHECK_PTR(kas);
TQ_CHECK_PTR(kas);
}
kas->createBrush(m_brsh);
@ -109,7 +109,7 @@ void KisAutobrush::paramChanged()
p.convertFromImage(pi);
brushPreview->setPixmap(p);
KisAutobrushResource * resource = new KisAutobrushResource(*m_brsh);
Q_CHECK_PTR(resource);
TQ_CHECK_PTR(resource);
emit(activatedResource(resource));
delete kas;

@ -1105,7 +1105,7 @@ void KisCanvas::createCanvasWidget(bool useOpenGL)
m_useOpenGL = useOpenGL;
Q_CHECK_PTR(m_canvasWidget);
TQ_CHECK_PTR(m_canvasWidget);
TQWidget *widget = dynamic_cast<TQWidget *>(m_canvasWidget);
widget->setBackgroundMode(TQWidget::NoBackground);

@ -65,7 +65,7 @@ KisClipboard* KisClipboard::instance()
if(KisClipboard::m_singleton == 0)
{
KisClipboard::m_singleton = new KisClipboard();
Q_CHECK_PTR(KisClipboard::m_singleton);
TQ_CHECK_PTR(KisClipboard::m_singleton);
}
return KisClipboard::m_singleton;
}
@ -200,7 +200,7 @@ KisPaintDeviceSP KisClipboard::clip()
cs = KisMetaRegistry::instance()->csRegistry() ->getColorSpace(KisID("RGBA",""), profileName);
m_clip = new KisPaintDevice(cs, "from paste");
Q_CHECK_PTR(m_clip);
TQ_CHECK_PTR(m_clip);
m_clip->convertFromTQImage(qimg, profileName);
}

@ -105,7 +105,7 @@ void KisCustomBrush::slotAddPredefined() {
void KisCustomBrush::slotUseBrush() {
KisBrush* copy = m_brush->clone();
Q_CHECK_PTR(copy);
TQ_CHECK_PTR(copy);
emit(activatedResource(copy));
}

@ -100,7 +100,7 @@ void KisCustomPattern::slotUsePattern() {
return;
KisPattern* copy = m_pattern->clone();
Q_CHECK_PTR(copy);
TQ_CHECK_PTR(copy);
emit(activatedResource(copy));
}

@ -177,7 +177,7 @@ DCOPObject *KisDoc::dcopObject()
{
if (!m_dcop) {
m_dcop = new KisDocIface(this);
Q_CHECK_PTR(m_dcop);
TQ_CHECK_PTR(m_dcop);
}
return m_dcop;
}
@ -258,14 +258,14 @@ bool KisDoc::init()
}
m_cmdHistory = new KoCommandHistory(actionCollection(), true);
Q_CHECK_PTR(m_cmdHistory);
TQ_CHECK_PTR(m_cmdHistory);
connect(m_cmdHistory, TQT_SIGNAL(documentRestored()), this, TQT_SLOT(slotDocumentRestored()));
connect(m_cmdHistory, TQT_SIGNAL(commandExecuted(KCommand *)), this, TQT_SLOT(slotCommandExecuted(KCommand *)));
setUndo(true);
m_nserver = new KisNameServer(i18n("Image %1"), 1);
Q_CHECK_PTR(m_nserver);
TQ_CHECK_PTR(m_nserver);
if (!KisMetaRegistry::instance()->csRegistry()->exists(KisID("RGBA",""))) {
KMessageBox::sorry(0, i18n("No colorspace modules loaded: cannot run Chalk"));
@ -446,7 +446,7 @@ KisImageSP KisDoc::loadImage(const TQDomElement& element)
img = new KisImage(this, width, height, cs, name);
img->blockSignals(true); // Don't send out signals while we're building the image
Q_CHECK_PTR(img);
TQ_CHECK_PTR(img);
connect( img, TQT_SIGNAL( sigImageModified() ), this, TQT_SLOT( slotImageUpdated() ));
img->setDescription(description);
img->setResolution(xres, yres);
@ -580,7 +580,7 @@ KisLayerSP KisDoc::loadPaintLayer(const TQDomElement& element, KisImageSP img,
cs = KisMetaRegistry::instance()->csRegistry()->getColorSpace(colorspacename,"");
layer = new KisPaintLayer(img, name, opacity, cs);
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
layer->setCompositeOp(compositeOp);
layer->setVisible(visible);
@ -622,7 +622,7 @@ KisGroupLayerSP KisDoc::loadGroupLayer(const TQDomElement& element, KisImageSP i
KisGroupLayerSP layer;
layer = new KisGroupLayer(img, name, opacity);
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
layer->setCompositeOp(compositeOp);
layer->setVisible(visible);
@ -659,7 +659,7 @@ KisAdjustmentLayerSP KisDoc::loadAdjustmentLayer(const TQDomElement& element, Ki
// We'll load the configuration and the selection later.
layer = new KisAdjustmentLayer(img, name, kfc, 0);
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
layer->setCompositeOp(compositeOp);
layer->setVisible(visible);
@ -693,7 +693,7 @@ KisPartLayerSP KisDoc::loadPartLayer(const TQDomElement& element, KisImageSP img
insertChild(child);
KisPartLayerSP layer = new KisPartLayerImpl(img, child);
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
layer->setCompositeOp(compositeOp);
layer->setVisible(visible);
@ -858,11 +858,11 @@ KisImageSP KisDoc::newImage(const TQString& name, TQ_INT32 width, TQ_INT32 heigh
setUndo(false);
KisImageSP img = new KisImage(this, width, height, colorstrategy, name);
Q_CHECK_PTR(img);
TQ_CHECK_PTR(img);
connect( img, TQT_SIGNAL( sigImageModified() ), this, TQT_SLOT( slotImageUpdated() ));
KisPaintLayer *layer = new KisPaintLayer(img, img->nextLayerName(), OPACITY_OPAQUE,colorstrategy);
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
KisColorSpace * cs = KisMetaRegistry::instance()->csRegistry()->getRGB8();
KisFillPainter painter;
@ -897,14 +897,14 @@ bool KisDoc::newImage(const TQString& name, TQ_INT32 width, TQ_INT32 height, Kis
setUndo(false);
img = new KisImage(this, width, height, cs, name);
Q_CHECK_PTR(img);
TQ_CHECK_PTR(img);
connect( img, TQT_SIGNAL( sigImageModified() ), this, TQT_SLOT( slotImageUpdated() ));
img->setResolution(imgResolution, imgResolution);
img->setDescription(imgDescription);
img->setProfile(cs->getProfile());
layer = new KisPaintLayer(img, img->nextLayerName(), OPACITY_OPAQUE, cs);
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
KisFillPainter painter;
painter.begin(layer->paintDevice());
@ -934,7 +934,7 @@ bool KisDoc::newImage(const TQString& name, TQ_INT32 width, TQ_INT32 height, Kis
KoView* KisDoc::createViewInstance(TQWidget* parent, const char *name)
{
KisView * v = new KisView(this, this, parent, name);
Q_CHECK_PTR(v);
TQ_CHECK_PTR(v);
return v;
}
@ -975,7 +975,7 @@ void KisDoc::beginMacro(const TQString& macroName)
if (m_macroNestDepth == 0) {
Q_ASSERT(m_currentMacro == 0);
m_currentMacro = new KMacroCommand(macroName);
Q_CHECK_PTR(m_currentMacro);
TQ_CHECK_PTR(m_currentMacro);
}
m_macroNestDepth++;

@ -86,7 +86,7 @@ KParts::Part* KisFactory::createPartObject( TQWidget *parentWidget,
KisDoc *doc = new KisDoc( parentWidget,
widgetName, parent, name, !bWantKoDocument );
Q_CHECK_PTR(doc);
TQ_CHECK_PTR(doc);
if ( !bWantKoDocument )
doc->setReadWrite( false );
@ -107,7 +107,7 @@ KInstance* KisFactory::instance()
if ( !s_instance )
{
s_instance = new KInstance(s_aboutData);
Q_CHECK_PTR(s_instance);
TQ_CHECK_PTR(s_instance);
s_instance->dirs()->addResourceType("chalk_template", KStandardDirs::kde_default("data") + "chalk/templates");

@ -342,7 +342,7 @@ void KisFilterManager::slotApplyFilter(int i)
// Create the config dialog
m_lastDialog = new KisPreviewDialog(m_view, m_lastFilter->id().name().ascii(), true, m_lastFilter->id().name());
Q_CHECK_PTR(m_lastDialog);
TQ_CHECK_PTR(m_lastDialog);
m_lastWidget = m_lastFilter->createConfigurationWidget( (TQWidget*)m_lastDialog->container(), dev );
bool accepted = true;

@ -100,7 +100,7 @@ void KisPaletteView::setPalette(KisPalette* palette)
if (rows < 1) rows = 1;
m_cells = new KColorCells(viewport(), rows, mCols);
Q_CHECK_PTR(m_cells);
TQ_CHECK_PTR(m_cells);
m_cells->setShading(false);
m_cells->setAcceptDrags(false);

@ -104,7 +104,7 @@ void KisResourceMediator::rServerAddedResource(KisResource *resource)
if (resource && resource->valid()) {
KisIconItem *item = new KisIconItem(resource);
Q_CHECK_PTR(item);
TQ_CHECK_PTR(item);
m_items[resource] = item;

@ -71,7 +71,7 @@ void KisResourceServerBase::loadResources(TQStringList filenames)
if(resource->load() && resource->valid())
{
m_resources.append(resource);
Q_CHECK_PTR(resource);
TQ_CHECK_PTR(resource);
emit resourceAdded(resource);
}
else {

@ -98,7 +98,7 @@ void KisRuler::recalculateSize()
}
m_pixmapBuffer = new TQPixmap(w, h);
Q_CHECK_PTR(m_pixmapBuffer);
TQ_CHECK_PTR(m_pixmapBuffer);
drawRuler();
updatePointer(m_currentPosition, m_currentPosition);

@ -354,7 +354,7 @@ void KisSelectionManager::cut()
if (img->undo()) {
t = new KisSelectedTransaction(i18n("Cut"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
dev->clearSelection();
@ -381,7 +381,7 @@ void KisSelectionManager::copy()
TQRect r = selection->selectedExactRect();
KisPaintDeviceSP clip = new KisPaintDevice(dev->colorSpace(), "clip");
Q_CHECK_PTR(clip);
TQ_CHECK_PTR(clip);
KisColorSpace * cs = clip->colorSpace();
@ -424,7 +424,7 @@ KisLayerSP KisSelectionManager::paste()
if (clip) {
TQApplication::setOverrideCursor(KisCursor::waitCursor());
KisPaintLayer *layer = new KisPaintLayer(img, img->nextLayerName() + i18n("(pasted)"), OPACITY_OPAQUE);
Q_CHECK_PTR(layer);
TQ_CHECK_PTR(layer);
TQRect r = clip->exactBounds();
KisPainter gc;
@ -506,7 +506,7 @@ void KisSelectionManager::selectAll()
KisSelectedTransaction * t = 0;
if (img->undo()) t = new KisSelectedTransaction(i18n("Select All"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
// Make adjustment layers behave better
KisAdjustmentLayer* adj = dynamic_cast<KisAdjustmentLayer*>(img->activeLayer().data());
@ -533,7 +533,7 @@ void KisSelectionManager::deselect()
if (!dev) return;
KisSelectedTransaction * t = 0;
if (img->undo()) t = new KisSelectedTransaction(i18n("Deselect"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
// Make adjustment layers behave almost the same (except no reselect)
KisAdjustmentLayer* adj = dynamic_cast<KisAdjustmentLayer*>(img->activeLayer().data());
@ -636,7 +636,7 @@ void KisSelectionManager::reselect()
KisSelectedTransaction * t = 0;
if (img->undo()) t = new KisSelectedTransaction(i18n("Reselect"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
dev->reselect(); // sets hasSelection=true
dev->setDirty();
@ -662,7 +662,7 @@ void KisSelectionManager::invert()
if (img->undo())
{
t = new KisSelectedTransaction(i18n("Invert"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
s->invert();
@ -716,7 +716,7 @@ void KisSelectionManager::feather()
KisSelectionSP selection = dev->selection();
KisSelectedTransaction * t = 0;
if (img->undo()) t = new KisSelectedTransaction(i18n("Feather..."), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
// XXX: we should let gaussian blur & others influence alpha channels as well
@ -805,7 +805,7 @@ void KisSelectionManager::grow (TQ_INT32 xradius, TQ_INT32 yradius)
if (img->undo()) {
t = new KisSelectedTransaction(i18n("Grow"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
max = new TQ_UINT8* [layerSize.width() + 2 * xradius];

@ -37,7 +37,7 @@ KisSelectionOptions::KisSelectionOptions(TQWidget *parent, KisCanvasSubject * su
m_subject(subject)
{
m_page = new WdgSelectionOptions(this);
Q_CHECK_PTR(m_page);
TQ_CHECK_PTR(m_page);
TQVBoxLayout * l = new TQVBoxLayout(this);
l->addWidget(m_page);

@ -73,7 +73,7 @@ public:
virtual KisTool * createTool(KActionCollection * ac) {
KisTool * t = new KisToolDummy();
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t->setup(ac);
return t;
}

@ -204,7 +204,7 @@ void KisToolFreehand::initPaint(KisEvent *)
}
if(m_target->hasSelection()) m_target->selection()->startCachingExactRect();
m_painter = new KisPainter( m_target );
Q_CHECK_PTR(m_painter);
TQ_CHECK_PTR(m_painter);
m_source = device;
if (currentImage()->undo()) m_painter->beginTransaction(m_transactionText);
}

@ -42,7 +42,7 @@ TQWidget* KisToolShape::createOptionWidget(TQWidget* parent)
TQWidget *widget = super::createOptionWidget(parent);
m_shapeOptionsWidget = new WdgGeometryOptions(0);
Q_CHECK_PTR(m_shapeOptionsWidget);
TQ_CHECK_PTR(m_shapeOptionsWidget);
m_optionLayout = new TQGridLayout(widget, 2, 1);
// super::addOptionWidgetLayout(m_optionLayout);

@ -416,7 +416,7 @@ KoPaletteManager * KisView::paletteManager()
{
if (!m_paletteManager) {
m_paletteManager = new KoPaletteManager(this, actionCollection(), "Chalk palette manager");
Q_CHECK_PTR(m_paletteManager);
TQ_CHECK_PTR(m_paletteManager);
}
return m_paletteManager;
}
@ -449,7 +449,7 @@ DCOPObject* KisView::dcopObject()
{
if (!m_dcop) {
m_dcop = new KisViewIface(this);
Q_CHECK_PTR(m_dcop);
TQ_CHECK_PTR(m_dcop);
}
return m_dcop;
}
@ -459,10 +459,10 @@ void KisView::setupScrollBars()
m_scrollX = 0;
m_scrollY = 0;
m_vScroll = new TQScrollBar(Qt::Vertical, this);
Q_CHECK_PTR(m_vScroll);
TQ_CHECK_PTR(m_vScroll);
m_hScroll = new TQScrollBar(Qt::Horizontal, this);
Q_CHECK_PTR(m_hScroll);
TQ_CHECK_PTR(m_hScroll);
m_vScroll->setGeometry(width() - 16, 20, 16, height() - 36);
m_hScroll->setGeometry(20, height() - 16, width() - 36, 16);
@ -475,10 +475,10 @@ void KisView::setupScrollBars()
void KisView::setupRulers()
{
m_hRuler = new KisRuler(Qt::Horizontal, this);
Q_CHECK_PTR(m_hRuler);
TQ_CHECK_PTR(m_hRuler);
m_vRuler = new KisRuler(Qt::Vertical, this);
Q_CHECK_PTR(m_vRuler);
TQ_CHECK_PTR(m_vRuler);
m_hRuler->setGeometry(20, 0, width() - 20, 20);
m_vRuler->setGeometry(0, 20, 20, height() - 20);
@ -1792,7 +1792,7 @@ void KisView::mirrorLayerX()
KisTransaction * t = 0;
if (undoAdapter() && undoAdapter()->undo()) {
t = new KisTransaction(i18n("Mirror Layer X"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
dev->mirrorX();
@ -1813,7 +1813,7 @@ void KisView::mirrorLayerY()
KisTransaction * t = 0;
if (undoAdapter() && undoAdapter()->undo()) {
t = new KisTransaction(i18n("Mirror Layer Y"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
dev->mirrorY();
@ -1835,7 +1835,7 @@ void KisView::scaleLayer(double sx, double sy, KisFilterStrategy *filterStrategy
KisSelectedTransaction * t = 0;
if (undoAdapter() && undoAdapter()->undo()) {
t = new KisSelectedTransaction(i18n("Scale Layer"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
KisTransformWorker worker(dev, sx, sy, 0, 0, 0.0, 0, 0, m_progress, filterStrategy);
@ -1858,7 +1858,7 @@ void KisView::rotateLayer(double radians)
KisSelectedTransaction * t = 0;
if (undoAdapter() && undoAdapter()->undo()) {
t = new KisSelectedTransaction(i18n("Rotate Layer"), dev);
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
}
KisFilterStrategy *filter = KisFilterStrategyRegistry::instance()->get(KisID("Triangle"));

@ -137,7 +137,7 @@ EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED = QT_VERSION=320 \
PREDEFINED = TQT_VERSION=320 \
__cplusplus \
Q_WS_X11
EXPAND_AS_DEFINED =

@ -1075,7 +1075,7 @@ void KisToolStar::setup(KActionCollection *collection)
SLOT(activate()),
collection,
name());
Q_CHECK_PTR(m_action);
TQ_CHECK_PTR(m_action);
m_action->setToolTip(i18n("Draw a star"));
m_action->setExclusiveGroup("tools");
@ -1136,7 +1136,7 @@ QWidget* KisToolStar::createOptionWidget(QWidget* parent)
QWidget *widget = KisToolShape::createOptionWidget(parent);
m_optWidget = new WdgToolStar(widget);
Q_CHECK_PTR(m_optWidget);
TQ_CHECK_PTR(m_optWidget);
m_optWidget->ratioSpinBox->setValue(m_innerOuterRatio);
@ -1279,7 +1279,7 @@ cursor.
splitCoordinate(pt.y(), &amp;y, &amp;yFraction);
KisPaintDeviceSP dab = new KisPaintDevice(colorSpace, "smeary dab");
Q_CHECK_PTR(dab);
TQ_CHECK_PTR(dab);
</programlisting>
<para>
@ -1348,7 +1348,7 @@ that weve dirtied a small rectangle of the paint device.
KisPaintOp * KisSmearyOpFactory::createOp(const KisPaintOpSettings */*settings*/, KisPainter * painter)
{
KisPaintOp * op = new KisSmearyOp(painter);
Q_CHECK_PTR(op);
TQ_CHECK_PTR(op);
return op;
}
</programlisting>

@ -178,7 +178,7 @@ namespace {
memcpy(rawdata.data(), profiledata, length);
KisAnnotation* annotation = new KisAnnotation(TQString("IPTC"), "", rawdata);
Q_CHECK_PTR(annotation);
TQ_CHECK_PTR(annotation);
image -> addAnnotation(annotation);
}
@ -191,7 +191,7 @@ namespace {
memcpy(rawdata.data(), src->generic_profile[i].info, src->generic_profile[i].length);
KisAnnotation* annotation = new KisAnnotation(TQString(src->generic_profile[i].name), "", rawdata);
Q_CHECK_PTR(annotation);
TQ_CHECK_PTR(annotation);
image -> addAnnotation(annotation);
}
@ -206,7 +206,7 @@ namespace {
memcpy(rawdata.data(), imgAttr -> value, len);
KisAnnotation* annotation = new KisAnnotation( TQString("chalk_attribute:%1").arg(TQString(imgAttr -> key)), "", rawdata );
Q_CHECK_PTR(annotation);
TQ_CHECK_PTR(annotation);
image -> addAnnotation(annotation);
@ -237,7 +237,7 @@ namespace {
memcpy(rawdata.data(), profile->datum, profile->length);
annotation = new KisAnnotation(TQString(name), "", rawdata);
Q_CHECK_PTR(annotation);
TQ_CHECK_PTR(annotation);
image -> addAnnotation(annotation);
}
@ -262,7 +262,7 @@ namespace {
annotation = new KisAnnotation(
TQString("chalk_attribute:%1").arg(TQString(attr -> key)), "", rawdata);
Q_CHECK_PTR(annotation);
TQ_CHECK_PTR(annotation);
image -> addAnnotation(annotation);
#if MagickLibVersion < 0x620
@ -470,7 +470,7 @@ KisImageBuilder_Result KisImageMagickConverter::decode(const KURL& uri, bool isB
if( ! m_img) {
m_img = new KisImage(m_doc->undoAdapter(), image -> columns, image -> rows, cs, "built image");
Q_CHECK_PTR(m_img);
TQ_CHECK_PTR(m_img);
m_img->blockSignals(true); // Don't send out signals while we're building the image
// XXX I'm assuming seperate layers won't have other profile things like EXIF

@ -153,7 +153,7 @@ KisImageBuilder_Result KisJPEGConverter::decode(const KURL& uri)
if (hProfile != (cmsHPROFILE) NULL) {
profile = new KisProfile( profile_rawdata);
Q_CHECK_PTR(profile);
TQ_CHECK_PTR(profile);
kdDebug(41008) << "profile name: " << profile->productName() << " profile description: " << profile->productDescription() << " information sur le produit: " << profile->productInfo() << endl;
if(!profile->isSuitableForOutput())
{
@ -193,7 +193,7 @@ KisImageBuilder_Result KisJPEGConverter::decode(const KURL& uri)
// Creating the KisImageSP
if( ! m_img) {
m_img = new KisImage(m_doc->undoAdapter(), cinfo.image_width, cinfo.image_height, cs, "built image");
Q_CHECK_PTR(m_img);
TQ_CHECK_PTR(m_img);
if(profile && !profile->isSuitableForOutput())
{
m_img -> addAnnotation( new KisAnnotation( profile->productName(), "", profile_rawdata) );

@ -122,7 +122,7 @@ KoFilter::ConversionStatus KisJPEGExport::convert(const TQCString& from, const T
url.setPath(filename);
KisImageSP img = output->currentImage();
Q_CHECK_PTR(img);
TQ_CHECK_PTR(img);
KisJPEGConverter kpc(output, output->undoAdapter());

@ -182,7 +182,7 @@ namespace {
memcpy(rawdata.data(), profile->datum, profile->length);
annotation = new KisAnnotation(TQString(name), "", rawdata);
Q_CHECK_PTR(annotation);
TQ_CHECK_PTR(annotation);
image -> addAnnotation(annotation);
}
@ -207,7 +207,7 @@ namespace {
annotation = new KisAnnotation(
TQString("chalk_attribute:%1").arg(TQString(attr -> key)), "", rawdata);
Q_CHECK_PTR(annotation);
TQ_CHECK_PTR(annotation);
image -> addAnnotation(annotation);
#if MagickLibVersion < 0x620
@ -412,7 +412,7 @@ KisImageBuilder_Result KisImageMagickConverter::decode(const KURL& uri, bool isB
if( ! m_img) {
m_img = new KisImage(m_doc->undoAdapter(), image -> columns, image -> rows, cs, "built image");
Q_CHECK_PTR(m_img);
TQ_CHECK_PTR(m_img);
m_img->blockSignals(true); // Don't send out signals while we're building the image
// XXX I'm assuming seperate layers won't have other profile things like EXIF

@ -79,7 +79,7 @@ KoFilter::ConversionStatus KisOpenEXRExport::convert(const TQCString& from, cons
}
KisImageSP img = new KisImage(*doc -> currentImage());
Q_CHECK_PTR(img);
TQ_CHECK_PTR(img);
// Don't store this information in the document's undo adapter
bool undo = doc -> undoAdapter() -> undo();

@ -238,7 +238,7 @@ KisImageBuilder_Result KisPNGConverter::decode(const KURL& uri)
profile_rawdata.resize(proflen);
memcpy(profile_rawdata.data(), profile_data, proflen);
profile = new KisProfile(profile_rawdata);
Q_CHECK_PTR(profile);
TQ_CHECK_PTR(profile);
if (profile) {
kdDebug(41008) << "profile name: " << profile->productName() << " profile description: " << profile->productDescription() << " information sur le produit: " << profile->productInfo() << endl;
if(!profile->isSuitableForOutput())
@ -332,7 +332,7 @@ KisImageBuilder_Result KisPNGConverter::decode(const KURL& uri)
if( ! m_img) {
m_img = new KisImage(m_doc->undoAdapter(), width, height, cs, "built image");
m_img->blockSignals(true); // Don't send out signals while we're building the image
Q_CHECK_PTR(m_img);
TQ_CHECK_PTR(m_img);
if(profile && !profile->isSuitableForOutput())
{
m_img -> addAnnotation( profile->annotation() );

@ -333,7 +333,7 @@ KisImageBuilder_Result KisTIFFConverter::readTIFFDirectory( TIFF* image)
// Creating the KisImageSP
if( ! m_img ) {
m_img = new KisImage(m_doc->undoAdapter(), width, height, cs, "built image");
Q_CHECK_PTR(m_img);
TQ_CHECK_PTR(m_img);
m_img->blockSignals(true); // Don't send out signals while we're building the image
if(profile)
{

@ -44,7 +44,7 @@ public:
virtual VTool * createTool( KActionCollection * ac, KarbonView* view )
{
VTool * t = new T( view );
Q_CHECK_PTR(t);
TQ_CHECK_PTR(t);
t -> setup(ac);
return t;
}

@ -98,7 +98,7 @@ void VRuler::recalculateSize()
}
m_pixmapBuffer = new TQPixmap(w, h);
Q_CHECK_PTR(m_pixmapBuffer);
TQ_CHECK_PTR(m_pixmapBuffer);
drawRuler();
updatePointer(m_currentPosition, m_currentPosition);

@ -177,7 +177,7 @@ EXPAND_ONLY_PREDEF = YES
SEARCH_INCLUDES = YES
INCLUDE_PATH = ../../kexidb
INCLUDE_FILE_PATTERNS =
PREDEFINED = QT_VERSION=311
PREDEFINED = TQT_VERSION=311
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------

@ -2307,7 +2307,7 @@ void KPrCanvas::setupMenus()
{
// create right button presentation menu
m_presMenu = new KPopupMenu();
Q_CHECK_PTR( m_presMenu );
TQ_CHECK_PTR( m_presMenu );
m_presMenu->setCheckable( true );
m_presMenu->insertTitle( i18n( "Slide Show" ) );
m_presMenu->insertItem( i18n( "&Continue" ), this, TQT_SLOT( setSwitchingMode() ) );

@ -3657,7 +3657,7 @@ void KPrView::setupPopupMenus()
{
// create right button line begin
rb_lbegin = new TQPopupMenu();
Q_CHECK_PTR( rb_lbegin );
TQ_CHECK_PTR( rb_lbegin );
rb_lbegin->insertItem( KPBarIcon("line_normal_begin" ), TQT_TQOBJECT(this), TQT_SLOT( extraLineBeginNormal() ) );
rb_lbegin->insertSeparator();
rb_lbegin->insertItem( KPBarIcon("line_arrow_begin" ), TQT_TQOBJECT(this), TQT_SLOT( extraLineBeginArrow() ) );
@ -3678,7 +3678,7 @@ void KPrView::setupPopupMenus()
// create right button line end
rb_lend = new TQPopupMenu();
Q_CHECK_PTR( rb_lend );
TQ_CHECK_PTR( rb_lend );
rb_lend->insertItem( KPBarIcon("line_normal_end" ), TQT_TQOBJECT(this), TQT_SLOT( extraLineEndNormal() ) );
rb_lend->insertSeparator();
rb_lend->insertItem( KPBarIcon("line_arrow_end" ), TQT_TQOBJECT(this), TQT_SLOT( extraLineEndArrow() ) );
@ -3699,7 +3699,7 @@ void KPrView::setupPopupMenus()
// create arrange-objects popup
m_arrangeObjectsPopup = new TQPopupMenu();
Q_CHECK_PTR(m_arrangeObjectsPopup);
TQ_CHECK_PTR(m_arrangeObjectsPopup);
m_arrangeObjectsPopup->insertItem(KPBarIcon("lower"), TQT_TQOBJECT(this), TQT_SLOT(extraLower()));
m_arrangeObjectsPopup->insertSeparator();
m_arrangeObjectsPopup->insertItem(KPBarIcon("send_backward"), TQT_TQOBJECT(this), TQT_SLOT(extraSendBackward()));

@ -928,7 +928,7 @@ INCLUDE_FILE_PATTERNS =
# or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed.
PREDEFINED = QT_VERSION=320 \
PREDEFINED = TQT_VERSION=320 \
__cplusplus \
Q_WS_X11

@ -87,18 +87,18 @@ TQtCalculator :: TQtCalculator( Calculator *_corba, TQWidget *parent, const char
connect(calc_display,TQT_SIGNAL(clicked()),this,TQT_SLOT(display_selected()));
statusINVLabel = new TQLabel( this, "INV" );
Q_CHECK_PTR( statusINVLabel );
TQ_CHECK_PTR( statusINVLabel );
statusINVLabel->setFrameStyle( TQFrame::Panel | TQFrame::Sunken );
statusINVLabel->setAlignment( AlignCenter );
statusINVLabel->setText("NORM");
statusHYPLabel = new TQLabel( this, "HYP" );
Q_CHECK_PTR( statusHYPLabel );
TQ_CHECK_PTR( statusHYPLabel );
statusHYPLabel->setFrameStyle( TQFrame::Panel | TQFrame::Sunken );
statusHYPLabel->setAlignment( AlignCenter );
statusERRORLabel = new TQLabel( this, "ERROR" );
Q_CHECK_PTR( statusERRORLabel );
TQ_CHECK_PTR( statusERRORLabel );
statusERRORLabel->setFrameStyle( TQFrame::Panel | TQFrame::Sunken );
statusERRORLabel->setAlignment( AlignLeft|AlignVCenter );

@ -1006,7 +1006,7 @@ double KoRuler::makeIntern( double _v )
void KoRuler::setupMenu()
{
d->rb_menu = new TQPopupMenu();
Q_CHECK_PTR( d->rb_menu );
TQ_CHECK_PTR( d->rb_menu );
for ( uint i = 0 ; i <= KoUnit::U_LASTUNIT ; ++i )
{
KoUnit::Unit unit = static_cast<KoUnit::Unit>( i );

@ -154,7 +154,7 @@ void KoTabChooser::drawContents( TQPainter *painter )
void KoTabChooser::setupMenu()
{
rb_menu = new TQPopupMenu();
Q_CHECK_PTR( rb_menu );
TQ_CHECK_PTR( rb_menu );
mLeft = rb_menu->insertItem( i18n( "Tabulator &Left" ), this, TQT_SLOT( rbLeft() ) );
mCenter = rb_menu->insertItem( i18n( "Tabulator &Center" ), this, TQT_SLOT( rbCenter() ) );
mRight = rb_menu->insertItem( i18n( "Tabulator &Right" ), this, TQT_SLOT( rbRight() ) );

@ -34,7 +34,7 @@
KoGrayWidget::KoGrayWidget(TQWidget *parent, const char *name) : super(parent, name)
{
m_ColorButton = new KDualColorButton(this);
Q_CHECK_PTR(m_ColorButton);
TQ_CHECK_PTR(m_ColorButton);
m_ColorButton -> setFixedSize(m_ColorButton->sizeHint());
TQGridLayout *mGrid = new TQGridLayout(this, 3, 5, 5, 2);

Loading…
Cancel
Save