rename the following methods:

tqparent parent
tqmask mask


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1246260 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

28 files changed, 94 insertions, 94 deletions

diff --git a/kexi/core/kexi.h b/kexi/core/kexi.h
index a98f9341..426854e6 100644
--- a/kexi/core/kexi.h
+++ b/kexi/core/kexi.h
@@ -42,7 +42,7 @@ namespace Kexi
 	enum ViewMode { 
 		AllViewModes = 0, //!< Usable primarily in KexiPart::initInstanceActions()
 		NoViewMode = 0, //!< In KexiViewBase::afterSwitchFrom() and KexiViewBase::beforeSwitchTo() 
-		                //!< means that tqparent dialog of the view has not yet view defined.
+		                //!< means that parent dialog of the view has not yet view defined.
 		DataViewMode = 1,
 		DesignViewMode = 2,
 		TextViewMode = 4 //!< Also known as SQL View Mode
diff --git a/kexi/core/kexiactionproxy.cpp b/kexi/core/kexiactionproxy.cpp
index 4b77b9ef..49cbeb3b 100644
--- a/kexi/core/kexiactionproxy.cpp
+++ b/kexi/core/kexiactionproxy.cpp
@@ -97,7 +97,7 @@ KexiActionProxy::~KexiActionProxy()
 	for (;it.current();++it) {
 		it.current()->setActionProxyParent_internal( 0 );
 	}
-	//take me from tqparent
+	//take me from parent
 	if (m_actionProxyParent)
 		m_actionProxyParent->takeActionProxyChild( this );
 
@@ -158,7 +158,7 @@ KAction* KexiActionProxy::plugSharedAction(const char *action_name, const TQStri
 	TQCString altName = a->name();
 	altName += "_alt";
 	KAction *alt_act = new KAction(alternativeText, a->iconSet(), a->shortcut(), 
-		0, 0, a->tqparent(), altName);
+		0, 0, a->parent(), altName);
 	TQObject::connect(alt_act, TQT_SIGNAL(activated()), a, TQT_SLOT(activate()));
 	alt_act->plug(w);
 
@@ -201,7 +201,7 @@ bool KexiActionProxy::activateSharedAction(const char *action_name, bool alsoChe
 					return true;
 			}
 		}
-		return m_actionProxyParent ? m_actionProxyParent->activateSharedAction(action_name, false) : false; //last chance: tqparent
+		return m_actionProxyParent ? m_actionProxyParent->activateSharedAction(action_name, false) : false; //last chance: parent
 	}
 	//activate in this proxy...
 	p->first->activate();
@@ -244,7 +244,7 @@ bool KexiActionProxy::isAvailable(const char* action_name, bool alsoCheckInChild
 					return it.current()->isAvailable(action_name, alsoCheckInChildren);
 			}
 		}
-		return m_actionProxyParent ? m_actionProxyParent->isAvailable(action_name, false) : false; //last chance: tqparent
+		return m_actionProxyParent ? m_actionProxyParent->isAvailable(action_name, false) : false; //last chance: parent
 	}
 	//supported explicitly:
 	return p->second != 0;
@@ -273,9 +273,9 @@ void KexiActionProxy::takeActionProxyChild( KexiActionProxy* child )
 		m_sharedActionChildren.take();
 }
 
-void KexiActionProxy::setActionProxyParent_internal( KexiActionProxy* tqparent )
+void KexiActionProxy::setActionProxyParent_internal( KexiActionProxy* parent )
 {
-	m_actionProxyParent = tqparent;
+	m_actionProxyParent = parent;
 }
 
 #include "kexiactionproxy_p.moc"
diff --git a/kexi/core/kexiactionproxy.h b/kexi/core/kexiactionproxy.h
index e88a89d9..facb09b3 100644
--- a/kexi/core/kexiactionproxy.h
+++ b/kexi/core/kexiactionproxy.h
@@ -153,8 +153,8 @@ class KEXICORE_EXPORT KexiActionProxy
 		 we start to iterate over proxy tqchildren (in unspecified order) to and call 
 		 activateSharedAction() on every child until one of them accept the "event".
 		 
-		 If proxy child is destroyed, it is automatically detached from its tqparent proxy. 
-		 Parent proxy is 0 by default. This pointer is properly cleared when tqparent proxy is destroyed. */
+		 If proxy child is destroyed, it is automatically detached from its parent proxy. 
+		 Parent proxy is 0 by default. This pointer is properly cleared when parent proxy is destroyed. */
 		void addActionProxyChild( KexiActionProxy* child );
 
 		void takeActionProxyChild( KexiActionProxy* child );
@@ -169,14 +169,14 @@ class KEXICORE_EXPORT KexiActionProxy
 
 		KexiActionProxy* m_actionProxyParent;
 
-		TQObject m_signal_parent; //!< it's just to have common tqparent for owned signals
+		TQObject m_signal_parent; //!< it's just to have common parent for owned signals
 
 		//! For internal use by plugSharedActionToExternalGUI()
 		KAction_setEnabled_Helper *m_KAction_setEnabled_helper;
 
 	public:
-		//! For internal use by addActionProxyChild(). \a tqparent can be 0.
-		void setActionProxyParent_internal( KexiActionProxy* tqparent );
+		//! For internal use by addActionProxyChild(). \a parent can be 0.
+		void setActionProxyParent_internal( KexiActionProxy* parent );
 
 		//! @internal
 		KexiActionProxy *m_focusedChild;
diff --git a/kexi/core/kexicontexthelp.cpp b/kexi/core/kexicontexthelp.cpp
index 48bf6b51..e806aaaf 100644
--- a/kexi/core/kexicontexthelp.cpp
+++ b/kexi/core/kexicontexthelp.cpp
@@ -27,8 +27,8 @@
 #include <kdebug.h>
 #include <kiconloader.h>
 
-KexiContextHelp::KexiContextHelp(KexiMainWindow *view, TQWidget *tqparent)
-	:KoContextHelpWidget(tqparent,"kexi_contexthelp")
+KexiContextHelp::KexiContextHelp(KexiMainWindow *view, TQWidget *parent)
+	:KoContextHelpWidget(parent,"kexi_contexthelp")
 {
 	kdDebug()<<"KexiContextHelp::KexiContextHelp()"<<endl;
 	setCaption(i18n("Context Help"));
diff --git a/kexi/core/kexicontexthelp.h b/kexi/core/kexicontexthelp.h
index c1cd2a0b..d28c8e2a 100644
--- a/kexi/core/kexicontexthelp.h
+++ b/kexi/core/kexicontexthelp.h
@@ -30,7 +30,7 @@ class KEXICORE_EXPORT KexiContextHelp : public KoContextHelpWidget
   TQ_OBJECT
 
 	public:
-		KexiContextHelp(KexiMainWindow *view, TQWidget *tqparent=0);
+		KexiContextHelp(KexiMainWindow *view, TQWidget *parent=0);
 		~KexiContextHelp();
 	private slots:
 		void linkClickedInternal(const TQString &link);
diff --git a/kexi/core/kexidataiteminterface.h b/kexi/core/kexidataiteminterface.h
index ad3a3d25..1c87e0e0 100644
--- a/kexi/core/kexidataiteminterface.h
+++ b/kexi/core/kexidataiteminterface.h
@@ -188,7 +188,7 @@ class KEXICORE_EXPORT KexiDataItemInterface
 		bool cursorAtNewRow();
 
 		/*! Sets a pointer to a Parent Data Item Interface. This pointer is 0 by default, 
-		 but can be set by tqparent widget if this interface is a building block of a larger data widget. 
+		 but can be set by parent widget if this interface is a building block of a larger data widget. 
 		 It is the case for KexiDBFieldEdit widget (see KexiDBFieldEdit::createEditor()). Use with care.
 		 signalValueChanged() method will check this pointer, and if it's not 0, 
 		 m_parentDataItemInterface->signalValueChanged() is called, so a changes can be signalled at higher level. */
@@ -222,8 +222,8 @@ class KEXICORE_EXPORT KexiDataItemInterface
 //		virtual void setValueInternal(const TQVariant& value) = 0;
 
 		/*! Call this in your implementation when value changes, 
-		 so installed listener can react on this change. If there is a tqparent data item defined
-		 (see setParentDataItemInterface()), tqparent's signalValueChanged() method will be called instead. */
+		 so installed listener can react on this change. If there is a parent data item defined
+		 (see setParentDataItemInterface()), parent's signalValueChanged() method will be called instead. */
 		virtual void signalValueChanged();
 
 		/*! Used to perform some actions before signalValueChanged() call. 
diff --git a/kexi/core/kexidialogbase.cpp b/kexi/core/kexidialogbase.cpp
index 01f20d8c..ff642741 100644
--- a/kexi/core/kexidialogbase.cpp
+++ b/kexi/core/kexidialogbase.cpp
@@ -41,9 +41,9 @@
 #include <kapplication.h>
 #include <kiconloader.h>
 
-KexiDialogBase::KexiDialogBase(KexiMainWindow *tqparent, const TQString &caption)
- : KMdiChildView(caption, tqparent, "KexiDialogBase")
- , KexiActionProxy(TQT_TQOBJECT(this), tqparent)
+KexiDialogBase::KexiDialogBase(KexiMainWindow *parent, const TQString &caption)
+ : KMdiChildView(caption, parent, "KexiDialogBase")
+ , KexiActionProxy(TQT_TQOBJECT(this), parent)
  , m_isRegistered(false)
  , m_origCaption(caption)
  , m_schemaData(0)
@@ -54,7 +54,7 @@ KexiDialogBase::KexiDialogBase(KexiMainWindow *tqparent, const TQString &caption
 	m_supportedViewModes = 0; //will be set by KexiPart
 	m_openedViewModes = 0;
 	m_currentViewMode = Kexi::NoViewMode; //no view available yet
-	m_parentWindow = tqparent;
+	m_parentWindow = parent;
 	m_creatingViewsMode = -1;
 
 	TQVBoxLayout *lyr = new TQVBoxLayout(this);
@@ -64,7 +64,7 @@ KexiDialogBase::KexiDialogBase(KexiMainWindow *tqparent, const TQString &caption
 #ifdef KEXI_NO_CTXT_HELP
 	m_contextHelpInfo=new KexiContextHelpInfo();
 #endif
-//	m_instance=tqparent->instance();
+//	m_instance=parent->instance();
 	m_id = -1;
 	m_item = 0;
 
diff --git a/kexi/core/kexidialogbase.h b/kexi/core/kexidialogbase.h
index 6479ae5b..6449004b 100644
--- a/kexi/core/kexidialogbase.h
+++ b/kexi/core/kexidialogbase.h
@@ -49,8 +49,8 @@ namespace KoProperty {
 class KEXICORE_EXPORT KexiDialogTempData : public TQObject
 {
 	public:
-	KexiDialogTempData(TQObject* tqparent)
-	 : TQObject(tqparent, "KexiDialogTempData")
+	KexiDialogTempData(TQObject* parent)
+	 : TQObject(parent, "KexiDialogTempData")
 	 , proposeOpeningInTextViewModeBecauseOfProblems(false)
 	{}
 	/*! Initially false, KexiPart::Part implementation can set this to true
@@ -81,7 +81,7 @@ class KEXICORE_EXPORT KexiDialogBase :
   TQ_OBJECT
 
 	public:
-		KexiDialogBase(KexiMainWindow *tqparent, const TQString &caption = TQString());
+		KexiDialogBase(KexiMainWindow *parent, const TQString &caption = TQString());
 		virtual ~KexiDialogBase();
 
 		bool isRegistered();
diff --git a/kexi/core/kexidragobjects.cpp b/kexi/core/kexidragobjects.cpp
index f69b5a6a..e7373ed7 100644
--- a/kexi/core/kexidragobjects.cpp
+++ b/kexi/core/kexidragobjects.cpp
@@ -27,8 +27,8 @@
 /// implementation of KexiFieldDrag
 
 KexiFieldDrag::KexiFieldDrag(const TQString& sourceMimeType, const TQString& sourceName, 
-	const TQString& field, TQWidget *tqparent, const char *name)
- : TQStoredDrag("kexi/field", tqparent, name)
+	const TQString& field, TQWidget *parent, const char *name)
+ : TQStoredDrag("kexi/field", parent, name)
 {
 	TQByteArray data;
 	TQDataStream stream1(data,IO_WriteOnly);
@@ -37,8 +37,8 @@ KexiFieldDrag::KexiFieldDrag(const TQString& sourceMimeType, const TQString& sou
 }
 
 KexiFieldDrag::KexiFieldDrag(const TQString& sourceMimeType, const TQString& sourceName, 
-	const TQStringList& fields, TQWidget *tqparent, const char *name)
- : TQStoredDrag((fields.count() > 1) ? "kexi/fields" : "kexi/field", tqparent, name)
+	const TQStringList& fields, TQWidget *parent, const char *name)
+ : TQStoredDrag((fields.count() > 1) ? "kexi/fields" : "kexi/field", parent, name)
 {
 	TQByteArray data;
 	TQDataStream stream1(data,IO_WriteOnly);
@@ -112,8 +112,8 @@ KexiFieldDrag::decodeMultiple( TQDropEvent* e, TQString& sourceMimeType,
 /// implementation of KexiDataProviderDrag
 
 KexiDataProviderDrag::KexiDataProviderDrag(const TQString& sourceMimeType, const TQString& sourceName,
-	TQWidget *tqparent, const char *name)
- : TQStoredDrag("kexi/dataprovider", tqparent, name)
+	TQWidget *parent, const char *name)
+ : TQStoredDrag("kexi/dataprovider", parent, name)
 {
 	TQByteArray data;
 	TQDataStream stream1(data,IO_WriteOnly);
diff --git a/kexi/core/kexidragobjects.h b/kexi/core/kexidragobjects.h
index 26e2b24f..4db4534e 100644
--- a/kexi/core/kexidragobjects.h
+++ b/kexi/core/kexidragobjects.h
@@ -33,12 +33,12 @@ class KEXICORE_EXPORT KexiFieldDrag : public TQStoredDrag
 	public:
 		/*! Creates drag object for a single field \a field. */
 		KexiFieldDrag(const TQString& sourceMimeType, const TQString& sourceName, 
-			const TQString& field, TQWidget *tqparent, const char *name);
+			const TQString& field, TQWidget *parent, const char *name);
 
 		/*! Creates drag object for multiple fields \a fields. 
 		 If there's less than two elements in the list, data is set up as for above ctor. */
 		KexiFieldDrag(const TQString& sourceMimeType, const TQString& sourceName, 
-			const TQStringList& field, TQWidget *tqparent=0, const char *name=0);
+			const TQStringList& field, TQWidget *parent=0, const char *name=0);
 
 		~KexiFieldDrag();
 
@@ -71,7 +71,7 @@ class KEXICORE_EXPORT KexiDataProviderDrag : public TQStoredDrag
 {
 	public:
 		KexiDataProviderDrag(const TQString& sourceMimeType, const TQString& sourceName, 
-		TQWidget *tqparent=0, const char *name=0);
+		TQWidget *parent=0, const char *name=0);
 		~KexiDataProviderDrag() { };
 
 		static bool canDecode( TQDragMoveEvent* e);
diff --git a/kexi/core/kexiguimsghandler.cpp b/kexi/core/kexiguimsghandler.cpp
index 5b8bb8f5..4121543e 100644
--- a/kexi/core/kexiguimsghandler.cpp
+++ b/kexi/core/kexiguimsghandler.cpp
@@ -26,8 +26,8 @@
 #include <kmessagebox.h>
 #include <kdialogbase.h>
 
-KexiGUIMessageHandler::KexiGUIMessageHandler(TQWidget *tqparent)
-: KexiDB::MessageHandler(tqparent)
+KexiGUIMessageHandler::KexiGUIMessageHandler(TQWidget *parent)
+: KexiDB::MessageHandler(parent)
 {
 }
 
diff --git a/kexi/core/kexiguimsghandler.h b/kexi/core/kexiguimsghandler.h
index bfe1495e..af407ab1 100644
--- a/kexi/core/kexiguimsghandler.h
+++ b/kexi/core/kexiguimsghandler.h
@@ -26,7 +26,7 @@
 class KEXICORE_EXPORT KexiGUIMessageHandler : public KexiDB::MessageHandler
 {
 	public:
-		KexiGUIMessageHandler(TQWidget *tqparent = 0);
+		KexiGUIMessageHandler(TQWidget *parent = 0);
 		virtual ~KexiGUIMessageHandler();
 		virtual void showErrorMessage(const TQString &title, const TQString &details = TQString());
 		virtual void showErrorMessage(KexiDB::Object *obj, const TQString& msg = TQString());
diff --git a/kexi/core/kexiinternalpart.cpp b/kexi/core/kexiinternalpart.cpp
index 7e0386cd..93d73cac 100644
--- a/kexi/core/kexiinternalpart.cpp
+++ b/kexi/core/kexiinternalpart.cpp
@@ -71,8 +71,8 @@ KexiInternalPartManager internalPartManager;
 
 //----------------------------------------------
 
-KexiInternalPart::KexiInternalPart(TQObject *tqparent, const char *name, const TQStringList &)
- : TQObject(tqparent, name)
+KexiInternalPart::KexiInternalPart(TQObject *parent, const char *name, const TQStringList &)
+ : TQObject(parent, name)
  , m_uniqueDialog(true)
  , m_cancelled(false)
 {
@@ -92,12 +92,12 @@ KexiInternalPart::part(KexiDB::MessageHandler *msgHdr, const char* partName)
 //static
 TQWidget* KexiInternalPart::createWidgetInstance(const char* partName, 
 	const char* widgetClass, KexiDB::MessageHandler *msgHdr, KexiMainWindow* mainWin, 
-	TQWidget *tqparent, const char *objName, TQMap<TQString,TQString>* args)
+	TQWidget *parent, const char *objName, TQMap<TQString,TQString>* args)
 {
 	KexiInternalPart *part = internalPartManager.findPart(msgHdr, partName);
 	if (!part)
 		return 0; //fatal!
-	return part->createWidget(widgetClass, mainWin, tqparent, objName ? objName : partName, args);
+	return part->createWidget(widgetClass, mainWin, parent, objName ? objName : partName, args);
 }
 
 KexiDialogBase* KexiInternalPart::findOrCreateKexiDialog(
@@ -178,21 +178,21 @@ bool KexiInternalPart::executeCommand(const char* partName,
 }
 
 TQWidget* KexiInternalPart::createWidget(const char* widgetClass, KexiMainWindow* mainWin, 
-	TQWidget * tqparent, const char * objName, TQMap<TQString,TQString>* args)
+	TQWidget * parent, const char * objName, TQMap<TQString,TQString>* args)
 {
 	Q_UNUSED(widgetClass);
 	Q_UNUSED(mainWin);
-	Q_UNUSED(tqparent);
+	Q_UNUSED(parent);
 	Q_UNUSED(objName);
 	Q_UNUSED(args);
 	return 0;
 }
 
-KexiViewBase* KexiInternalPart::createView(KexiMainWindow* mainWin, TQWidget * tqparent,
+KexiViewBase* KexiInternalPart::createView(KexiMainWindow* mainWin, TQWidget * parent,
  const char * objName)
 {
 	Q_UNUSED(mainWin);
-	Q_UNUSED(tqparent);
+	Q_UNUSED(parent);
 	Q_UNUSED(objName);
 	return 0;
 }
diff --git a/kexi/core/kexiinternalpart.h b/kexi/core/kexiinternalpart.h
index 4abf1d19..596f8dd4 100644
--- a/kexi/core/kexiinternalpart.h
+++ b/kexi/core/kexiinternalpart.h
@@ -52,10 +52,10 @@ class KEXICORE_EXPORT KexiInternalPart : public TQObject
   TQ_OBJECT
 
 	public:
-		KexiInternalPart(TQObject *tqparent, const char *name, const TQStringList &);
+		KexiInternalPart(TQObject *parent, const char *name, const TQStringList &);
 		virtual ~KexiInternalPart();
 	
-		KexiDialogBase *instance(KexiMainWindow *tqparent);
+		KexiDialogBase *instance(KexiMainWindow *parent);
 
 		/*! Creates a new widget instance using part \a partName.
 		 \a widgetClass is a pseudo class used in case when the part offers more 
@@ -64,23 +64,23 @@ class KEXICORE_EXPORT KexiInternalPart : public TQObject
 		 \a args is two-way optional argument: it can contain custom options used 
 		 on widget's creation. Depending on implementation, the created widget can write its 
 		 state (e.g. result or status information) back to this argument.
-		 Created widget will have assigned \a tqparent widget and \a objName name. */
+		 Created widget will have assigned \a parent widget and \a objName name. */
 		static TQWidget* createWidgetInstance(const char* partName, const char* widgetClass, 
 			KexiDB::MessageHandler *msgHdr, KexiMainWindow* mainWin, 
-			TQWidget *tqparent, const char *objName = 0, TQMap<TQString,TQString>* args = 0);
+			TQWidget *parent, const char *objName = 0, TQMap<TQString,TQString>* args = 0);
 
 		/*! For convenience. */
 		static TQWidget* createWidgetInstance(const char* partName,
 			KexiDB::MessageHandler *msgHdr, KexiMainWindow* mainWin, 
-			TQWidget *tqparent, const char *objName = 0, TQMap<TQString,TQString>* args = 0)
-		 { return createWidgetInstance(partName, 0, msgHdr, mainWin, tqparent, objName, args); }
+			TQWidget *parent, const char *objName = 0, TQMap<TQString,TQString>* args = 0)
+		 { return createWidgetInstance(partName, 0, msgHdr, mainWin, parent, objName, args); }
 
 		/*! Creates a new dialog instance. If such instance already exists, 
 		 and is unique (see uniqueDialog()) it is just returned.
 		 The part knows about destroying its dialog instance, (if it is uinque), 
 		 so on another call the dialog will be created again. 
 		 \a msgHdr is a message handler for displaying error messages.
-		 The dialog is assigned to \a mainWin as its tqparent, 
+		 The dialog is assigned to \a mainWin as its parent, 
 		 and \a objName name is set. */
 		static KexiDialogBase* createKexiDialogInstance(const char* partName, 
 			KexiDB::MessageHandler *msgHdr, KexiMainWindow* mainWin, const char *objName = 0);
@@ -96,7 +96,7 @@ class KEXICORE_EXPORT KexiInternalPart : public TQObject
 		 state (e.g. result or status information) back to this argument.
 		 The part knows about destroying its dialog instance, (if it is uinque), 
 		 so on another call the dialog will be created again. 
-		 The dialog is assigned to \a mainWin as its tqparent, 
+		 The dialog is assigned to \a mainWin as its parent, 
 		 and \a objName name is set. */
 		static TQDialog* createModalDialogInstance(const char* partName, 
 			const char* dialogClass, KexiDB::MessageHandler *msgHdr, KexiMainWindow* mainWin, 
@@ -132,7 +132,7 @@ class KEXICORE_EXPORT KexiInternalPart : public TQObject
 		/*! Reimplement this if your internal part has to return widgets 
 		 or TQDialog objects. */
 		virtual TQWidget *createWidget(const char* widgetClass, KexiMainWindow* mainWin, 
-			TQWidget * tqparent, const char * objName = 0, TQMap<TQString,TQString>* args = 0);
+			TQWidget * parent, const char * objName = 0, TQMap<TQString,TQString>* args = 0);
 		
 //		//! Reimplement this if your internal part has to return dialogs
 //		virtual KexiDialogBase *createDialog(KexiMainWindow* /*mainWin*/, 
@@ -140,7 +140,7 @@ class KEXICORE_EXPORT KexiInternalPart : public TQObject
 //		 { return 0; }
 		
 		/*! Reimplement this if your internal part has to return a view object. */
-		virtual KexiViewBase *createView(KexiMainWindow* mainWin, TQWidget * tqparent,
+		virtual KexiViewBase *createView(KexiMainWindow* mainWin, TQWidget * parent,
 			const char *objName = 0);
 
 		/*! Reimplement this if your internal part has to execute a command \a commandName 
diff --git a/kexi/core/kexipart.cpp b/kexi/core/kexipart.cpp
index d95bd069..ba54fea7 100644
--- a/kexi/core/kexipart.cpp
+++ b/kexi/core/kexipart.cpp
@@ -87,8 +87,8 @@ public:
 
 using namespace KexiPart;
 
-Part::Part(TQObject *tqparent, const char *name, const TQStringList &)
-: TQObject(tqparent, name)
+Part::Part(TQObject *parent, const char *name, const TQStringList &)
+: TQObject(parent, name)
 , m_guiClient(0)
 , m_registeredPartID(-1) //no registered ID by default
 , d(new PartPrivate())
@@ -100,8 +100,8 @@ Part::Part(TQObject *tqparent, const char *name, const TQStringList &)
 	m_newObjectsAreDirty = false;
 }
 
-Part::Part(TQObject* tqparent, StaticInfo *info)
-: TQObject(tqparent, "StaticPart")
+Part::Part(TQObject* parent, StaticInfo *info)
+: TQObject(parent, "StaticPart")
 , m_guiClient(0)
 , m_registeredPartID(-1) //no registered ID by default
 , d(new PartPrivate())
diff --git a/kexi/core/kexipart.h b/kexi/core/kexipart.h
index 34136d83..f1168fd4 100644
--- a/kexi/core/kexipart.h
+++ b/kexi/core/kexipart.h
@@ -69,7 +69,7 @@ class KEXICORE_EXPORT Part : public TQObject
 
 	public:
 		/*! Constructor. */
-		Part(TQObject *tqparent, const char *name, const TQStringList &);
+		Part(TQObject *parent, const char *name, const TQStringList &);
 		/*! Destructor. */
 		virtual ~Part();
 
@@ -148,9 +148,9 @@ class KEXICORE_EXPORT Part : public TQObject
 		 Default implemention just returns empty KexiDialogTempData object. */
 		virtual KexiDialogTempData* createTempData(KexiDialogBase* dialog);
 
-		/*! Creates a new view for mode \a viewMode, \a item and \a tqparent. The view will be 
+		/*! Creates a new view for mode \a viewMode, \a item and \a parent. The view will be 
 		 used inside \a dialog. */
-		virtual KexiViewBase* createView(TQWidget *tqparent, KexiDialogBase* dialog, 
+		virtual KexiViewBase* createView(TQWidget *parent, KexiDialogBase* dialog, 
 			KexiPart::Item &item, int viewMode = Kexi::DataViewMode, TQMap<TQString,TQString>* staticObjectArgs = 0) = 0;
 
 		/*! i18n'd instance name usable for displaying in gui as object's name.
@@ -213,7 +213,7 @@ class KEXICORE_EXPORT Part : public TQObject
 
 	protected:
 		//! Used by StaticPart
-		Part(TQObject* tqparent, StaticInfo *info);
+		Part(TQObject* parent, StaticInfo *info);
 
 //		virtual KexiDialogBase* createInstance(KexiMainWindow *win, const KexiPart::Item &item, int viewMode = Kexi::DataViewMode) = 0;
 
diff --git a/kexi/core/kexipartguiclient.h b/kexi/core/kexipartguiclient.h
index ed88a816..3b999fee 100644
--- a/kexi/core/kexipartguiclient.h
+++ b/kexi/core/kexipartguiclient.h
@@ -39,7 +39,7 @@ class GUIClient : public TQObject, public KXMLGUIClient
 	public:
 		virtual ~GUIClient() {};
 
-		inline Part *part() { return static_cast<Part*>(TQObject::tqparent()); }
+		inline Part *part() { return static_cast<Part*>(TQObject::parent()); }
 
 	protected:
 		/*! Creates a new GUI Client. If \a partInstanceClient is true, the part will be 
diff --git a/kexi/core/kexipartmanager.cpp b/kexi/core/kexipartmanager.cpp
index 00575461..f6fcd7d8 100644
--- a/kexi/core/kexipartmanager.cpp
+++ b/kexi/core/kexipartmanager.cpp
@@ -35,8 +35,8 @@
 
 using namespace KexiPart;
 
-Manager::Manager(TQObject *tqparent)
- : TQObject(tqparent)
+Manager::Manager(TQObject *parent)
+ : TQObject(parent)
 {
 	m_lookupDone = false;
 	m_partlist.setAutoDelete(true);
diff --git a/kexi/core/kexipartmanager.h b/kexi/core/kexipartmanager.h
index e771ae00..c7506e66 100644
--- a/kexi/core/kexipartmanager.h
+++ b/kexi/core/kexipartmanager.h
@@ -74,7 +74,7 @@ class KEXICORE_EXPORT Manager : public TQObject, public KexiDB::Object
 		/**
 		 * creates an empty instance
 		 */
-		Manager(TQObject *tqparent = 0);
+		Manager(TQObject *parent = 0);
 		~Manager();
 
 		/**
diff --git a/kexi/core/kexiproject.h b/kexi/core/kexiproject.h
index e6fb283e..3a246505 100644
--- a/kexi/core/kexiproject.h
+++ b/kexi/core/kexiproject.h
@@ -107,7 +107,7 @@ class KEXICORE_EXPORT KexiProject : public TQObject, public KexiDB::Object
 		 value in "kexi__db" table. 
 		 This is often the case for native server-based databases. 
 		 If so, Kexi application can propose importing the database
-		 or linking it to tqparent project (the latter isn't yet implemented).
+		 or linking it to parent project (the latter isn't yet implemented).
 		 For other types of errors the variable is set to true. */
 		tristate open(bool &incompatibleWithKexi);
 
diff --git a/kexi/core/kexisharedactionhost.cpp b/kexi/core/kexisharedactionhost.cpp
index aabba3e2..6a696461 100644
--- a/kexi/core/kexisharedactionhost.cpp
+++ b/kexi/core/kexisharedactionhost.cpp
@@ -230,8 +230,8 @@ KActionPtrList KexiSharedActionHost::sharedActions() const
 	public:
 		KexiAction(const TQString &text, const TQIconSet &pix,
 			const KShortcut &cut, const TQObject *receiver,
-			const char *slot, KActionCollection *tqparent, const char *name)
-		 : KAction(text,pix,cut,receiver,slot,tqparent,name)
+			const char *slot, KActionCollection *parent, const char *name)
+		 : KAction(text,pix,cut,receiver,slot,parent,name)
 		{
 		}
 
diff --git a/kexi/core/kexisharedactionhost.h b/kexi/core/kexisharedactionhost.h
index 235ca9b8..91cc09f4 100644
--- a/kexi/core/kexisharedactionhost.h
+++ b/kexi/core/kexisharedactionhost.h
@@ -71,7 +71,7 @@ class KEXICORE_EXPORT KexiSharedActionHost
 
 		/*! \return window widget that is currently focused (using TQWidget::tqfocusWidget())
 		 and matches acceptsSharedActions(). If focused widget does not match,
-		 it's tqparent, grandtqparent, and so on is checked. If all this fails, 
+		 it's parent, grandparent, and so on is checked. If all this fails, 
 		 or no widget has focus, NULL is returned. 
 		 Also works if currently focused window is detached (as in KMDI).
 		 */
diff --git a/kexi/core/kexistaticpart.cpp b/kexi/core/kexistaticpart.cpp
index 86f3a746..69368a1e 100644
--- a/kexi/core/kexistaticpart.cpp
+++ b/kexi/core/kexistaticpart.cpp
@@ -51,10 +51,10 @@ StaticPart::~StaticPart()
 {
 }
 
-KexiViewBase* StaticPart::createView(TQWidget *tqparent, KexiDialogBase* dialog, 
+KexiViewBase* StaticPart::createView(TQWidget *parent, KexiDialogBase* dialog, 
 	KexiPart::Item &item, int viewMode)
 {
-	Q_UNUSED(tqparent);
+	Q_UNUSED(parent);
 	Q_UNUSED(dialog);
 	Q_UNUSED(item);
 	Q_UNUSED(viewMode);
diff --git a/kexi/core/kexistaticpart.h b/kexi/core/kexistaticpart.h
index 06ba7501..314ec59c 100644
--- a/kexi/core/kexistaticpart.h
+++ b/kexi/core/kexistaticpart.h
@@ -48,14 +48,14 @@ class KEXICORE_EXPORT StaticPart : public Part
 		StaticPart(const TQCString& mimeType, const TQString& itemIcon, const TQString& objectName);
 		virtual ~StaticPart();
 
-		/*! Creates a new view for mode \a viewMode, \a item and \a tqparent. The view will be 
+		/*! Creates a new view for mode \a viewMode, \a item and \a parent. The view will be 
 		 used inside \a dialog. \a args arguments can be passed. */
-		virtual KexiViewBase* createView(TQWidget *tqparent, KexiDialogBase* dialog, 
+		virtual KexiViewBase* createView(TQWidget *parent, KexiDialogBase* dialog, 
 			KexiPart::Item &item, int viewMode, TQMap<TQString,TQString>* args) = 0;
 
 	protected:
 		//! unused by static parts
-		KexiViewBase* createView(TQWidget *tqparent, KexiDialogBase* dialog, 
+		KexiViewBase* createView(TQWidget *parent, KexiDialogBase* dialog, 
 			KexiPart::Item &item, int viewMode = Kexi::DataViewMode);
 };
 
diff --git a/kexi/core/kexiuseraction.cpp b/kexi/core/kexiuseraction.cpp
index a45c5ae9..b0966463 100644
--- a/kexi/core/kexiuseraction.cpp
+++ b/kexi/core/kexiuseraction.cpp
@@ -11,8 +11,8 @@
 #include "keximainwindow.h"
 #include "kexiuseraction.h"
 
-KexiUserAction::KexiUserAction(KexiMainWindow *win, KActionCollection *tqparent, const TQString &name, const TQString &text, const TQString &pixmap)
- : KAction(text, pixmap, KShortcut::null(), this, TQT_SLOT(execute()), tqparent, name.latin1())
+KexiUserAction::KexiUserAction(KexiMainWindow *win, KActionCollection *parent, const TQString &name, const TQString &text, const TQString &pixmap)
+ : KAction(text, pixmap, KShortcut::null(), this, TQT_SLOT(execute()), parent, name.latin1())
 {
 	m_win = win;
 	m_method = 0;
@@ -59,12 +59,12 @@ KexiUserAction::execute()
 }
 
 KexiUserAction *
-KexiUserAction::fromCurrentRecord(KexiMainWindow *context, KActionCollection *tqparent, KexiDB::Cursor *c)
+KexiUserAction::fromCurrentRecord(KexiMainWindow *context, KActionCollection *parent, KexiDB::Cursor *c)
 {
 	if(!c || c->bof() || c->eof())
 		return 0;
 
-	KexiUserAction *a = new KexiUserAction(context, tqparent, c->value(1).toString(), c->value(2).toString(), c->value(3).toString());
+	KexiUserAction *a = new KexiUserAction(context, parent, c->value(1).toString(), c->value(2).toString(), c->value(3).toString());
 	TQString args = c->value(5).toString();
 	bool quote = false;
 
diff --git a/kexi/core/kexiuseraction.h b/kexi/core/kexiuseraction.h
index 71ca1819..b7111bd1 100644
--- a/kexi/core/kexiuseraction.h
+++ b/kexi/core/kexiuseraction.h
@@ -48,7 +48,7 @@ class KEXICORE_EXPORT KexiUserAction : public KAction
 		/*! constructs an action
 		    \note methods are associated using setMethod() 
 		    */
-		KexiUserAction(KexiMainWindow *context, KActionCollection *tqparent, const TQString &name, const TQString &text, const TQString &pixmap);
+		KexiUserAction(KexiMainWindow *context, KActionCollection *parent, const TQString &name, const TQString &text, const TQString &pixmap);
 		~KexiUserAction();
 
 		/*! sets execution information associated with this action this will mostly look like
@@ -64,7 +64,7 @@ class KEXICORE_EXPORT KexiUserAction : public KAction
 
 		/*! creates a KexiUserAction from current record in \a c
 		    mostly needed for creation from kexi__useractions table */
-		static KexiUserAction *fromCurrentRecord(KexiMainWindow *context, KActionCollection *tqparent, KexiDB::Cursor *c);
+		static KexiUserAction *fromCurrentRecord(KexiMainWindow *context, KActionCollection *parent, KexiDB::Cursor *c);
 
 	protected slots:
 		/*! actually executes the associated method
diff --git a/kexi/core/kexiviewbase.cpp b/kexi/core/kexiviewbase.cpp
index be201c9b..e89f4a4e 100644
--- a/kexi/core/kexiviewbase.cpp
+++ b/kexi/core/kexiviewbase.cpp
@@ -30,8 +30,8 @@
 
 #include <kdebug.h>
 
-KexiViewBase::KexiViewBase(KexiMainWindow *mainWin, TQWidget *tqparent, const char *name)
- : TQWidget(tqparent, name)
+KexiViewBase::KexiViewBase(KexiMainWindow *mainWin, TQWidget *parent, const char *name)
+ : TQWidget(parent, name)
  , KexiActionProxy(TQT_TQOBJECT(this), mainWin)
  , m_mainWin(mainWin)
  , m_viewWidget(0)
@@ -218,7 +218,7 @@ bool KexiViewBase::eventFilter( TQObject *o, TQEvent *e )
 //		kexidbg << "KexiViewBase::eventFilter(): " << o->name() << " " << e->type() << endl;
 		if (KexiUtils::hasParent( TQT_TQOBJECT(this), TQT_TQOBJECT(o))) {
 			if (e->type()==TQEvent::FocusOut && tqfocusWidget() && !KexiUtils::hasParent( TQT_TQOBJECT(this), TQT_TQOBJECT(tqfocusWidget()))) {
-				//focus out: when currently focused widget is not a tqparent of this view
+				//focus out: when currently focused widget is not a parent of this view
 				emit focus(false);
 			} else if (e->type()==TQEvent::FocusIn) {
 				emit focus(true);
diff --git a/kexi/core/kexiviewbase.h b/kexi/core/kexiviewbase.h
index 60beadf8..139f0b2d 100644
--- a/kexi/core/kexiviewbase.h
+++ b/kexi/core/kexiviewbase.h
@@ -40,7 +40,7 @@ namespace KexiDB {
  KexiViewBase has 'dirty' flag to indicate that view's data has changed.
  This flag's state is reused by KexiDialogBase object that contain the view.
  KexiViewBase objects can be also nested, using addChildView(): any actions and 'dirty' flag
- are transmited to tqparent view in this case.
+ are transmited to parent view in this case.
 
  KexiViewBase objects are usually allocated within KexiDialogBase objects by implementing
  KexiPart::createView() method. See query or table part code for examples.
@@ -55,13 +55,13 @@ class KEXICORE_EXPORT KexiViewBase : public TQWidget, public KexiActionProxy
   TQ_OBJECT
 
 	public:
-		KexiViewBase(KexiMainWindow *mainWin, TQWidget *tqparent, const char *name = 0);
+		KexiViewBase(KexiMainWindow *mainWin, TQWidget *parent, const char *name = 0);
 		virtual ~KexiViewBase();
 
 		//! \return kexi main window that contain this view
 		inline KexiMainWindow *mainWin() const { return m_mainWin; }
 
-		//! \return tqparent KexiDialogBase that contains this view, or 0 if no dialog contain this view
+		//! \return parent KexiDialogBase that contains this view, or 0 if no dialog contain this view
 		KexiDialogBase* parentDialog() const { return m_dialog; }
 
 		/*! Added for convenience.
@@ -112,9 +112,9 @@ class KEXICORE_EXPORT KexiViewBase : public TQWidget, public KexiActionProxy
 		virtual void propertySetSwitched();
 
 		/*! Sets dirty flag on or off. It the flag changes,
-		 dirty(bool) signal is emitted by tqparent dialog (KexiDialog),
-		 to inform the world about that. If this view has a tqparent view, setDirty()
-		 is called also on tqparent view.
+		 dirty(bool) signal is emitted by parent dialog (KexiDialog),
+		 to inform the world about that. If this view has a parent view, setDirty()
+		 is called also on parent view.
 		 Always use this function to update 'dirty' flag information. */
 		void setDirty(bool set);
 
@@ -233,13 +233,13 @@ class KEXICORE_EXPORT KexiViewBase : public TQWidget, public KexiActionProxy
 
 		virtual void setFocusInternal() { TQWidget::setFocus(); }
 
-		/*! Allows to react on tqparent dialog's detaching (only for KMDI's ChildFrame mode)
+		/*! Allows to react on parent dialog's detaching (only for KMDI's ChildFrame mode)
 		 - it is called by KexiDialogBase::youAreDetached().
 		 Default implementation does nothing.
 		 Implement it if you want to perform some appropriate actions. */
 		virtual void parentDialogDetached() {};
 
-		/*! Allows to react on tqparent dialog's attaching (only for KMDI's ChildFrame mode)
+		/*! Allows to react on parent dialog's attaching (only for KMDI's ChildFrame mode)
 		 - it is called by KexiDialogBase::youAreAttached().
 		 Default implementation does nothing.
 		 Implement it if you want to perform some appropriate actions. */