1 files changed, 42 insertions, 42 deletions

diff --git a/krita/plugins/viewplugins/imagesize/dlg_layersize.cc b/krita/plugins/viewplugins/imagesize/dlg_layersize.cc
index ba942eca..faf64c00 100644
--- a/krita/plugins/viewplugins/imagesize/dlg_layersize.cc
+++ b/krita/plugins/viewplugins/imagesize/dlg_layersize.cc
@@ -27,11 +27,11 @@
 
 using namespace std;
 
-#include <qradiobutton.h>
-#include <qcheckbox.h>
-#include <qbuttongroup.h>
-#include <qlabel.h>
-#include <qcombobox.h>
+#include <tqradiobutton.h>
+#include <tqcheckbox.h>
+#include <tqbuttongroup.h>
+#include <tqlabel.h>
+#include <tqcombobox.h>
 
 #include <klocale.h>
 #include <knuminput.h>
@@ -46,9 +46,9 @@ using namespace std;
 
 // XXX: I'm really real bad at arithmetic, let alone math. Here
 // be rounding errors. (Boudewijn)
-DlgLayerSize::DlgLayerSize( QWidget *  parent,
+DlgLayerSize::DlgLayerSize( TQWidget *  tqparent,
                 const char * name)
-    : super (parent, name, true, i18n("Scale Layer"), Ok | Cancel, Ok)
+    : super (tqparent, name, true, i18n("Scale Layer"), Ok | Cancel, Ok)
 {
     m_lock = false;
 
@@ -59,13 +59,13 @@ DlgLayerSize::DlgLayerSize( QWidget *  parent,
     m_page->cmbFilterType->setCurrentText("Mitchell");
 
     setMainWidget(m_page);
-    resize(m_page->sizeHint());
+    resize(m_page->tqsizeHint());
 
     unblockAll();
 
 
-    connect(this, SIGNAL(okClicked()),
-        this, SLOT(okClicked()));
+    connect(this, TQT_SIGNAL(okClicked()),
+        this, TQT_SLOT(okClicked()));
 
 }
 
@@ -74,7 +74,7 @@ DlgLayerSize::~DlgLayerSize()
     delete m_page;
 }
 
-void DlgLayerSize::setWidth(Q_UINT32 w)
+void DlgLayerSize::setWidth(TQ_UINT32 w)
 {
     blockAll();
 
@@ -86,7 +86,7 @@ void DlgLayerSize::setWidth(Q_UINT32 w)
     unblockAll();
 }
 
-void DlgLayerSize::setWidthPercent(Q_UINT32 w)
+void DlgLayerSize::setWidthPercent(TQ_UINT32 w)
 {
     blockAll();
 
@@ -97,19 +97,19 @@ void DlgLayerSize::setWidthPercent(Q_UINT32 w)
 }
 
 
-void DlgLayerSize::setMaximumWidth(Q_UINT32 w)
+void DlgLayerSize::setMaximumWidth(TQ_UINT32 w)
 {
     m_page->intWidth->setMaxValue(w);
     m_maxW = w;
 }
 
-Q_INT32 DlgLayerSize::width()
+TQ_INT32 DlgLayerSize::width()
 {
-    //return (Q_INT32)qRound(m_oldW);
-    return (Q_INT32)qRound(m_page->intWidth->value());
+    //return (TQ_INT32)tqRound(m_oldW);
+    return (TQ_INT32)tqRound(m_page->intWidth->value());
 }
 
-void DlgLayerSize::setHeight(Q_UINT32 h)
+void DlgLayerSize::setHeight(TQ_UINT32 h)
 {
     blockAll();
 
@@ -122,7 +122,7 @@ void DlgLayerSize::setHeight(Q_UINT32 h)
 }
 
 
-void DlgLayerSize::setHeightPercent(Q_UINT32 h)
+void DlgLayerSize::setHeightPercent(TQ_UINT32 h)
 {
     blockAll();
 
@@ -132,16 +132,16 @@ void DlgLayerSize::setHeightPercent(Q_UINT32 h)
     unblockAll();
 }
 
-void DlgLayerSize::setMaximumHeight(Q_UINT32 h)
+void DlgLayerSize::setMaximumHeight(TQ_UINT32 h)
 {
     m_page->intHeight->setMaxValue(h);
     m_maxH = h;
 }
 
-Q_INT32 DlgLayerSize::height()
+TQ_INT32 DlgLayerSize::height()
 {
-    //return (Q_INT32)qRound(m_oldH);
-    return (Q_INT32)qRound(m_page->intHeight->value());
+    //return (TQ_INT32)tqRound(m_oldH);
+    return (TQ_INT32)tqRound(m_page->intHeight->value());
 }
 
 KisFilterStrategy *DlgLayerSize::filterType()
@@ -165,14 +165,14 @@ void DlgLayerSize::slotWidthPixelsChanged(int w)
 
     double wPercent = double(w) * 100 / double(m_origW);
 
-    m_page->intWidthPercent->setValue(qRound(wPercent));
+    m_page->intWidthPercent->setValue(tqRound(wPercent));
 
     // Set height in pixels and percent of necessary
     if (m_page->chkConstrain->isChecked()) {
-        m_page->intHeightPercent->setValue(qRound(wPercent));
+        m_page->intHeightPercent->setValue(tqRound(wPercent));
 
-        m_oldH = qRound(m_origH * wPercent / 100);
-        m_page->intHeight->setValue(qRound(m_oldH));
+        m_oldH = tqRound(m_origH * wPercent / 100);
+        m_page->intHeight->setValue(tqRound(m_oldH));
 
     }
     m_oldW = w;
@@ -186,14 +186,14 @@ void DlgLayerSize::slotHeightPixelsChanged(int h)
 
     double hPercent = double(h) * 100 / double(m_origH);
 
-    m_page->intHeightPercent->setValue(qRound(hPercent));
+    m_page->intHeightPercent->setValue(tqRound(hPercent));
 
     // Set width in pixels and percent of necessary
     if (m_page->chkConstrain->isChecked()) {
-        m_page->intWidthPercent->setValue(qRound(hPercent));
+        m_page->intWidthPercent->setValue(tqRound(hPercent));
 
-        m_oldW = qRound(m_origW * hPercent / 100);
-        m_page->intWidth->setValue(qRound(m_oldW));
+        m_oldW = tqRound(m_origW * hPercent / 100);
+        m_page->intWidth->setValue(tqRound(m_oldW));
 
     }
     m_oldH = h;
@@ -205,11 +205,11 @@ void DlgLayerSize::slotWidthPercentChanged(int w)
 {
     blockAll();
 
-    m_page->intWidth->setValue(qRound(w * m_origW / 100));
+    m_page->intWidth->setValue(tqRound(w * m_origW / 100));
 
     if (m_page->chkConstrain->isChecked()) {
         m_page->intHeightPercent->setValue(w);
-        m_page->intHeight->setValue(qRound( w * m_origH / 100));
+        m_page->intHeight->setValue(tqRound( w * m_origH / 100));
     }
 
     unblockAll();
@@ -219,10 +219,10 @@ void DlgLayerSize::slotHeightPercentChanged(int h)
 {
     blockAll();
 
-    m_page->intHeight->setValue(qRound(h * m_origH / 100));
+    m_page->intHeight->setValue(tqRound(h * m_origH / 100));
     if (m_page->chkConstrain->isChecked()) {
         m_page->intWidthPercent->setValue(h);
-        m_page->intWidth->setValue(qRound( h * m_origW / 100));
+        m_page->intWidth->setValue(tqRound( h * m_origW / 100));
     }
 
     unblockAll();
@@ -243,17 +243,17 @@ void DlgLayerSize::blockAll()
 void DlgLayerSize::unblockAll()
 {
     // XXX: more efficient to use blockSignals?
-    connect (m_page->intWidth, SIGNAL(valueChanged(int)),
-         this, SLOT(slotWidthPixelsChanged(int)));
+    connect (m_page->intWidth, TQT_SIGNAL(valueChanged(int)),
+         this, TQT_SLOT(slotWidthPixelsChanged(int)));
 
-    connect (m_page->intHeight, SIGNAL(valueChanged(int)),
-         this, SLOT(slotHeightPixelsChanged(int)));
+    connect (m_page->intHeight, TQT_SIGNAL(valueChanged(int)),
+         this, TQT_SLOT(slotHeightPixelsChanged(int)));
 
-    connect (m_page->intWidthPercent, SIGNAL(valueChanged(int)),
-         this, SLOT(slotWidthPercentChanged(int)));
+    connect (m_page->intWidthPercent, TQT_SIGNAL(valueChanged(int)),
+         this, TQT_SLOT(slotWidthPercentChanged(int)));
 
-    connect (m_page->intHeightPercent, SIGNAL(valueChanged(int)),
-         this, SLOT(slotHeightPercentChanged(int)));
+    connect (m_page->intHeightPercent, TQT_SIGNAL(valueChanged(int)),
+         this, TQT_SLOT(slotHeightPercentChanged(int)));
 
 
 }