Rename KShared

57 files changed, 436 insertions, 436 deletions

diff --git a/kexi/core/kexi.cpp b/kexi/core/kexi.cpp
index f352b51b..95b14e67 100644
--- a/kexi/core/kexi.cpp
+++ b/kexi/core/kexi.cpp
@@ -45,10 +45,10 @@ using namespace Kexi;
 
 //! used for speedup
 //! @internal
-class KexiInternal : public KShared
+class KexiInternal : public TDEShared
 {
 	public:
-		KexiInternal() : KShared()
+		KexiInternal() : TDEShared()
 		 , connset(0)
 		 , smallFont(0)
 		{
diff --git a/kexi/core/kexiactioncategories.h b/kexi/core/kexiactioncategories.h
index 6e672133..5f43aaf6 100644
--- a/kexi/core/kexiactioncategories.h
+++ b/kexi/core/kexiactioncategories.h
@@ -40,7 +40,7 @@ enum ActionCategory
 /*! Note: we do not declare actions used in design/text view modes, 
  because the categories are used in the data view, 
  for now in the 'assign action to a push button' function. */
-class KEXICORE_EXPORT ActionCategories : public KShared
+class KEXICORE_EXPORT ActionCategories : public TDEShared
 {
 	public:
 		ActionCategories();
diff --git a/kexi/formeditor/scripting/formscript.h b/kexi/formeditor/scripting/formscript.h
index 138a12de..de38325c 100644
--- a/kexi/formeditor/scripting/formscript.h
+++ b/kexi/formeditor/scripting/formscript.h
@@ -72,7 +72,7 @@ class FormScript : public TQObject
 	private:
 		ScriptManager  *m_manager;
 		Form  *m_form;
-                KSharedPtr<Kross::Api::ScriptContainer> m_script;
+                TDESharedPtr<Kross::Api::ScriptContainer> m_script;
 		EventList  m_list;
 };
 
diff --git a/kexi/kexidb/preparedstatement.cpp b/kexi/kexidb/preparedstatement.cpp
index ce96f630..f1ab679c 100644
--- a/kexi/kexidb/preparedstatement.cpp
+++ b/kexi/kexidb/preparedstatement.cpp
@@ -27,7 +27,7 @@ using namespace KexiDB;
 
 PreparedStatement::PreparedStatement(StatementType type, ConnectionInternal& conn, 
 	FieldList& fields, const TQStringList& where)
- : KShared()
+ : TDEShared()
  , m_type(type)
  , m_fields(&fields)
  , m_where(where.isEmpty() ? new TQStringList(where) : 0)
diff --git a/kexi/kexidb/preparedstatement.h b/kexi/kexidb/preparedstatement.h
index 463c3c44..fa8e58a6 100644
--- a/kexi/kexidb/preparedstatement.h
+++ b/kexi/kexidb/preparedstatement.h
@@ -70,10 +70,10 @@ class FieldList;
 	Depending on database backend, you can avoid escaping BLOBs. 
 	See KexiFormView::storeData() for example use.
 */
-class KEXI_DB_EXPORT PreparedStatement : public KShared
+class KEXI_DB_EXPORT PreparedStatement : public TDEShared
 {
 	public:
-		typedef KSharedPtr<PreparedStatement> Ptr;
+		typedef TDESharedPtr<PreparedStatement> Ptr;
 
 		//! Defines type of the prepared statement.
 		enum StatementType {
diff --git a/kexi/plugins/macros/kexiactions/datatableaction.cpp b/kexi/plugins/macros/kexiactions/datatableaction.cpp
index 19922122..4e211a53 100644
--- a/kexi/plugins/macros/kexiactions/datatableaction.cpp
+++ b/kexi/plugins/macros/kexiactions/datatableaction.cpp
@@ -46,7 +46,7 @@ namespace KexiMacro {
 			{
 				TQStringList list;
 				list << "import" << "export";
-				this->appendChild( KSharedPtr<KoMacro::Variable>( new KoMacro::Variable(list, "@list") ) );
+				this->appendChild( TDESharedPtr<KoMacro::Variable>( new KoMacro::Variable(list, "@list") ) );
 
 				this->setVariant( list[0] );
 			}
@@ -61,7 +61,7 @@ namespace KexiMacro {
 			{
 				TQStringList list;
 				list << "file" << "clipboard";
-				this->appendChild( KSharedPtr<KoMacro::Variable>( new KoMacro::Variable(list, "@list") ) );
+				this->appendChild( TDESharedPtr<KoMacro::Variable>( new KoMacro::Variable(list, "@list") ) );
 
 				this->setVariant( list[0] );
 			}
@@ -87,10 +87,10 @@ namespace KexiMacro {
 								namelist << info->objectName() + "." + item_it.current()->name();
 					}
 					for(TQStringList::Iterator it = namelist.begin(); it != namelist.end(); ++it)
-						this->appendChild( KSharedPtr<KoMacro::Variable>(new KoMacro::Variable(*it)) );
+						this->appendChild( TDESharedPtr<KoMacro::Variable>(new KoMacro::Variable(*it)) );
 
 					//const TQString name = info->objectName(); //info->groupName();
-					//this->appendChild( KSharedPtr<KoMacro::Variable>(new KoMacro::Variable(name)) );
+					//this->appendChild( TDESharedPtr<KoMacro::Variable>(new KoMacro::Variable(name)) );
 				}
 				const TQString n =
 					namelist.contains(partitem)
@@ -106,20 +106,20 @@ namespace KexiMacro {
 DataTableAction::DataTableAction()
 	: KexiAction("datatable", i18n("Data Table"))
 {
-	setVariable(KSharedPtr<KoMacro::Variable>( new MethodVariable<DataTableAction>(this) ));
-	setVariable(KSharedPtr<KoMacro::Variable>( new TypeVariable<DataTableAction>(this) ));
-	setVariable(KSharedPtr<KoMacro::Variable>( new PartItemVariable<DataTableAction>(this) ));
+	setVariable(TDESharedPtr<KoMacro::Variable>( new MethodVariable<DataTableAction>(this) ));
+	setVariable(TDESharedPtr<KoMacro::Variable>( new TypeVariable<DataTableAction>(this) ));
+	setVariable(TDESharedPtr<KoMacro::Variable>( new PartItemVariable<DataTableAction>(this) ));
 }
 
 DataTableAction::~DataTableAction() 
 {
 }
 
-bool DataTableAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
+bool DataTableAction::notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
 {
 	kdDebug()<<"DataTableAction::notifyUpdated() name="<<name<<" macroitem.action="<<(macroitem->action() ? macroitem->action()->name() : "NOACTION")<<endl;
 	/*
-	KSharedPtr<KoMacro::Variable> variable = macroitem->variable(name, false);
+	TDESharedPtr<KoMacro::Variable> variable = macroitem->variable(name, false);
 	if(! variable) {
 		kdWarning()<<"DataTableAction::notifyUpdated() No such variable="<<name<<" in macroitem."<<endl;
 		return false;
@@ -128,16 +128,16 @@ bool DataTableAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, co
 	if(name == "method") {
 		const int partitem = macroitem->variant(OBJECT, true).toString();
 		macroitem->variable(OBJECT, true)->setChildren(
-			KoMacro::Variable::List() << KSharedPtr<KoMacro::Variable>(new ObjectVariable<ExecuteAction>(this, partitem)) );
+			KoMacro::Variable::List() << TDESharedPtr<KoMacro::Variable>(new ObjectVariable<ExecuteAction>(this, partitem)) );
 	}
 	*/
 	return true;
 }
 
-void DataTableAction::activate(KSharedPtr<KoMacro::Context> context)
+void DataTableAction::activate(TDESharedPtr<KoMacro::Context> context)
 {
 	if(! mainWin()->project()) {
-		kdWarning() << "ExecuteAction::activate(KSharedPtr<KoMacro::Context>) Invalid project" << endl;
+		kdWarning() << "ExecuteAction::activate(TDESharedPtr<KoMacro::Context>) Invalid project" << endl;
 		return;
 	}
 
diff --git a/kexi/plugins/macros/kexiactions/datatableaction.h b/kexi/plugins/macros/kexiactions/datatableaction.h
index e3f71601..a3acf5f8 100644
--- a/kexi/plugins/macros/kexiactions/datatableaction.h
+++ b/kexi/plugins/macros/kexiactions/datatableaction.h
@@ -61,7 +61,7 @@ namespace KexiMacro {
 			* @return true if the update was successfully else false
 			* is returned.
 			*/
-			virtual bool notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
+			virtual bool notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
 
 		public slots:
 
@@ -69,7 +69,7 @@ namespace KexiMacro {
 			* Called if the @a Action should be executed within the
 			* defined @p context .
 			*/
-			virtual void activate(KSharedPtr<KoMacro::Context> context);
+			virtual void activate(TDESharedPtr<KoMacro::Context> context);
 
 	};
 }
diff --git a/kexi/plugins/macros/kexiactions/executeaction.cpp b/kexi/plugins/macros/kexiactions/executeaction.cpp
index 564b03c8..7383b9a8 100644
--- a/kexi/plugins/macros/kexiactions/executeaction.cpp
+++ b/kexi/plugins/macros/kexiactions/executeaction.cpp
@@ -40,20 +40,20 @@ ExecuteAction::ExecuteAction()
 	: KexiAction("execute", i18n("Execute"))
 {
 	int conditions = ObjectVariable<ExecuteAction>::VisibleInNav | ObjectVariable<ExecuteAction>::Executable;
-	KSharedPtr<KoMacro::Variable> objvar = new ObjectVariable<ExecuteAction>(this, conditions);
+	TDESharedPtr<KoMacro::Variable> objvar = new ObjectVariable<ExecuteAction>(this, conditions);
 	setVariable(objvar);
 
-	setVariable(KSharedPtr<KoMacro::Variable>( new ObjectNameVariable<ExecuteAction>(this, objvar->variant().toString()) ));
+	setVariable(TDESharedPtr<KoMacro::Variable>( new ObjectNameVariable<ExecuteAction>(this, objvar->variant().toString()) ));
 }
 
 ExecuteAction::~ExecuteAction() 
 {
 }
 
-bool ExecuteAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
+bool ExecuteAction::notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
 {
 	kdDebug()<<"ExecuteAction::notifyUpdated() name="<<name<<" macroitem.action="<<(macroitem->action() ? macroitem->action()->name() : "NOACTION")<<endl;
-	KSharedPtr<KoMacro::Variable> variable = macroitem->variable(name, false);
+	TDESharedPtr<KoMacro::Variable> variable = macroitem->variable(name, false);
 	if(! variable) {
 		kdWarning()<<"ExecuteAction::notifyUpdated() No such variable="<<name<<" in macroitem."<<endl;
 		return false;
@@ -64,16 +64,16 @@ bool ExecuteAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, cons
 		const TQString objectvalue = macroitem->variant(OBJECT, true).toString(); // e.g. "macro" or "script"
 		const TQString objectname = macroitem->variant(NAME, true).toString(); // e.g. "macro1" or "macro2" if objectvalue above is "macro"
 		macroitem->variable(NAME, true)->setChildren(
-			KoMacro::Variable::List() << KSharedPtr<KoMacro::Variable>(new ObjectNameVariable<ExecuteAction>(this, objectvalue, objectname)) );
+			KoMacro::Variable::List() << TDESharedPtr<KoMacro::Variable>(new ObjectNameVariable<ExecuteAction>(this, objectvalue, objectname)) );
 	}
 
 	return true;
 }
 
-void ExecuteAction::activate(KSharedPtr<KoMacro::Context> context)
+void ExecuteAction::activate(TDESharedPtr<KoMacro::Context> context)
 {
 	if(! mainWin()->project()) {
-		kdWarning() << "ExecuteAction::activate(KSharedPtr<KoMacro::Context>) Invalid project" << endl;
+		kdWarning() << "ExecuteAction::activate(TDESharedPtr<KoMacro::Context>) Invalid project" << endl;
 		return;
 	}
 
diff --git a/kexi/plugins/macros/kexiactions/executeaction.h b/kexi/plugins/macros/kexiactions/executeaction.h
index 04fef2dc..be7c95dc 100644
--- a/kexi/plugins/macros/kexiactions/executeaction.h
+++ b/kexi/plugins/macros/kexiactions/executeaction.h
@@ -63,7 +63,7 @@ namespace KexiMacro {
 			* @return true if the update was successfully else false
 			* is returned.
 			*/
-			virtual bool notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
+			virtual bool notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
 
 		public slots:
 
@@ -71,7 +71,7 @@ namespace KexiMacro {
 			* Called if the @a Action should be executed within the
 			* defined @p context .
 			*/
-			virtual void activate(KSharedPtr<KoMacro::Context> context);
+			virtual void activate(TDESharedPtr<KoMacro::Context> context);
 
 	};
 }
diff --git a/kexi/plugins/macros/kexiactions/messageaction.cpp b/kexi/plugins/macros/kexiactions/messageaction.cpp
index a36d0526..f421abb5 100644
--- a/kexi/plugins/macros/kexiactions/messageaction.cpp
+++ b/kexi/plugins/macros/kexiactions/messageaction.cpp
@@ -39,9 +39,9 @@ MessageAction::~MessageAction()
 {
 }
 
-void MessageAction::activate(KSharedPtr<KoMacro::Context> context)
+void MessageAction::activate(TDESharedPtr<KoMacro::Context> context)
 {
-	kdDebug() << "MessageAction::activate(KSharedPtr<Context>)" << endl;
+	kdDebug() << "MessageAction::activate(TDESharedPtr<Context>)" << endl;
 	const TQString caption = context->variable("caption")->variant().toString();
 	const TQString message = context->variable("message")->variant().toString();
 	KMessageBox::information(mainWin(), message, caption);
diff --git a/kexi/plugins/macros/kexiactions/messageaction.h b/kexi/plugins/macros/kexiactions/messageaction.h
index da7723c3..9af12b89 100644
--- a/kexi/plugins/macros/kexiactions/messageaction.h
+++ b/kexi/plugins/macros/kexiactions/messageaction.h
@@ -59,7 +59,7 @@ namespace KexiMacro {
 			* Called if the @a Action should be executed within the
 			* defined @param context .
 			*/
-			virtual void activate(KSharedPtr<KoMacro::Context> context);
+			virtual void activate(TDESharedPtr<KoMacro::Context> context);
 
 	};
 }
diff --git a/kexi/plugins/macros/kexiactions/navigateaction.cpp b/kexi/plugins/macros/kexiactions/navigateaction.cpp
index 815b8723..336039ae 100644
--- a/kexi/plugins/macros/kexiactions/navigateaction.cpp
+++ b/kexi/plugins/macros/kexiactions/navigateaction.cpp
@@ -47,7 +47,7 @@ namespace KexiMacro {
 			{
 				TQStringList list;
 				list << "first" << "previous" << "next" << "last" << "goto";
-				this->appendChild( KSharedPtr<KoMacro::Variable>( new KoMacro::Variable(list, "@list") ) );
+				this->appendChild( TDESharedPtr<KoMacro::Variable>( new KoMacro::Variable(list, "@list") ) );
 
 				/*TODO should this actions belong to navigate? maybe it would be more wise to have
 				such kind of functionality in an own e.g. "Modify" action to outline, that
@@ -64,25 +64,25 @@ NavigateAction::NavigateAction()
 	: KexiAction("navigate", i18n("Navigate"))
 {
 	KoMacro::Variable* navvar = new NavigateVariable<NavigateAction>(this);
-	setVariable(KSharedPtr<KoMacro::Variable>( navvar ));
+	setVariable(TDESharedPtr<KoMacro::Variable>( navvar ));
 
 	KoMacro::Variable* rowvar = new KexiVariable<NavigateAction>(this, "rownr", i18n("Row"));
 	rowvar->setVariant(0);
-	setVariable(KSharedPtr<KoMacro::Variable>(rowvar));
+	setVariable(TDESharedPtr<KoMacro::Variable>(rowvar));
 
 	KoMacro::Variable* colvar = new KexiVariable<NavigateAction>(this, "colnr", i18n("Column"));
 	colvar->setVariant(0);
-	setVariable(KSharedPtr<KoMacro::Variable>(colvar));
+	setVariable(TDESharedPtr<KoMacro::Variable>(colvar));
 }
 
 NavigateAction::~NavigateAction() 
 {
 }
 
-bool NavigateAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
+bool NavigateAction::notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
 {
 	kdDebug()<<"NavigateAction::notifyUpdated() name="<<name<<" macroitem.action="<<(macroitem->action() ? macroitem->action()->name() : "NOACTION")<<endl;
-	KSharedPtr<KoMacro::Variable> variable = macroitem->variable(name, false);
+	TDESharedPtr<KoMacro::Variable> variable = macroitem->variable(name, false);
 	if(! variable) {
 		kdWarning()<<"NavigateAction::notifyUpdated() No such variable="<<name<<" in macroitem."<<endl;
 		return false;
@@ -94,15 +94,15 @@ bool NavigateAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, con
 		const int colnr = macroitem->variant("colnr", true).toInt(); // e.g. "macro1" or "macro2" if objectvalue above is "macro"
 
 		macroitem->variable("rownr", true)->setChildren(
-			KoMacro::Variable::List() << KSharedPtr<KoMacro::Variable>(new KoMacro::Variable(rownr)) );
+			KoMacro::Variable::List() << TDESharedPtr<KoMacro::Variable>(new KoMacro::Variable(rownr)) );
 		macroitem->variable("colnr", true)->setChildren(
-			KoMacro::Variable::List() << KSharedPtr<KoMacro::Variable>(new KoMacro::Variable(colnr)) );
+			KoMacro::Variable::List() << TDESharedPtr<KoMacro::Variable>(new KoMacro::Variable(colnr)) );
 	}
 
 	return true;
 }
 
-void NavigateAction::activate(KSharedPtr<KoMacro::Context> context)
+void NavigateAction::activate(TDESharedPtr<KoMacro::Context> context)
 {
 	KexiDialogBase* dialog = dynamic_cast<KexiDialogBase*>( mainWin()->activeWindow() );
 	if(! dialog) {
diff --git a/kexi/plugins/macros/kexiactions/navigateaction.h b/kexi/plugins/macros/kexiactions/navigateaction.h
index 449a9459..0dcff98a 100644
--- a/kexi/plugins/macros/kexiactions/navigateaction.h
+++ b/kexi/plugins/macros/kexiactions/navigateaction.h
@@ -63,7 +63,7 @@ namespace KexiMacro {
 			* @return true if the update was successfully else false
 			* is returned.
 			*/
-			virtual bool notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
+			virtual bool notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
 
 		public slots:
 
@@ -71,7 +71,7 @@ namespace KexiMacro {
 			* Called if the @a Action should be executed within the
 			* defined @p context .
 			*/
-			virtual void activate(KSharedPtr<KoMacro::Context> context);
+			virtual void activate(TDESharedPtr<KoMacro::Context> context);
 
 	};
 }
diff --git a/kexi/plugins/macros/kexiactions/objectnamevariable.h b/kexi/plugins/macros/kexiactions/objectnamevariable.h
index 1a0aabf8..03545f69 100644
--- a/kexi/plugins/macros/kexiactions/objectnamevariable.h
+++ b/kexi/plugins/macros/kexiactions/objectnamevariable.h
@@ -61,7 +61,7 @@ namespace KexiMacro {
 					namelist << "";
 
 				for(TQStringList::Iterator it = namelist.begin(); it != namelist.end(); ++it)
-					this->appendChild( KSharedPtr<KoMacro::Variable>(new KoMacro::Variable(*it)) );
+					this->appendChild( TDESharedPtr<KoMacro::Variable>(new KoMacro::Variable(*it)) );
 
 				this->setVariant( (name.isNull() || ! namelist.contains(name)) ? namelist[0] : name );
 
diff --git a/kexi/plugins/macros/kexiactions/objectvariable.h b/kexi/plugins/macros/kexiactions/objectvariable.h
index c27f024b..65def3aa 100644
--- a/kexi/plugins/macros/kexiactions/objectvariable.h
+++ b/kexi/plugins/macros/kexiactions/objectvariable.h
@@ -67,7 +67,7 @@ namespace KexiMacro {
 						continue;
 
 					const TQString name = info->objectName(); //info->groupName();
-					this->appendChild( KSharedPtr<KoMacro::Variable>(new KoMacro::Variable(name)) );
+					this->appendChild( TDESharedPtr<KoMacro::Variable>(new KoMacro::Variable(name)) );
 				}
 
 				if(! objectname.isNull())
diff --git a/kexi/plugins/macros/kexiactions/openaction.cpp b/kexi/plugins/macros/kexiactions/openaction.cpp
index d7c4e7aa..f5206ff5 100644
--- a/kexi/plugins/macros/kexiactions/openaction.cpp
+++ b/kexi/plugins/macros/kexiactions/openaction.cpp
@@ -63,7 +63,7 @@ namespace KexiMacro {
 					if(viewmodes & Kexi::TextViewMode)
 						namelist << TEXTVIEW;
 					for(TQStringList::Iterator it = namelist.begin(); it != namelist.end(); ++it)
-						this->children().append( KSharedPtr<KoMacro::Variable>(new KoMacro::Variable(*it)) );
+						this->children().append( TDESharedPtr<KoMacro::Variable>(new KoMacro::Variable(*it)) );
 				}
 				const TQString n =
 					namelist.contains(viewname)
@@ -81,21 +81,21 @@ OpenAction::OpenAction()
 {
 	const int conditions = ObjectVariable<OpenAction>::VisibleInNav;
 	
-	KSharedPtr<KoMacro::Variable> objvar = new ObjectVariable<OpenAction>(this, conditions);
+	TDESharedPtr<KoMacro::Variable> objvar = new ObjectVariable<OpenAction>(this, conditions);
 	setVariable(objvar);
 
-	setVariable(KSharedPtr<KoMacro::Variable>( new ObjectNameVariable<OpenAction>(this, objvar->variant().toString()) ));
-	setVariable(KSharedPtr<KoMacro::Variable>( new ViewVariable<OpenAction>(this, objvar->variant().toString()) ));
+	setVariable(TDESharedPtr<KoMacro::Variable>( new ObjectNameVariable<OpenAction>(this, objvar->variant().toString()) ));
+	setVariable(TDESharedPtr<KoMacro::Variable>( new ViewVariable<OpenAction>(this, objvar->variant().toString()) ));
 }
 
 OpenAction::~OpenAction()
 {
 }
 
-bool OpenAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
+bool OpenAction::notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
 {
 	kdDebug()<<"OpenAction::notifyUpdated() name="<<name<<" macroitem.action="<<(macroitem->action() ? macroitem->action()->name() : "NOACTION")<<endl;
-	KSharedPtr<KoMacro::Variable> variable = macroitem->variable(name, false);
+	TDESharedPtr<KoMacro::Variable> variable = macroitem->variable(name, false);
 	if(! variable) {
 		kdWarning()<<"OpenAction::notifyUpdated() No such variable="<<name<<" in macroitem."<<endl;
 		return false;
@@ -108,15 +108,15 @@ bool OpenAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const T
 		const TQString viewname = macroitem->variant(VIEW, true).toString(); // "data", "design" or "text"
 
 		macroitem->variable(NAME, true)->setChildren(
-			KoMacro::Variable::List() << KSharedPtr<KoMacro::Variable>(new ObjectNameVariable<OpenAction>(this, objectvalue, objectname)) );
+			KoMacro::Variable::List() << TDESharedPtr<KoMacro::Variable>(new ObjectNameVariable<OpenAction>(this, objectvalue, objectname)) );
 		macroitem->variable(VIEW, true)->setChildren(
-			KoMacro::Variable::List() << KSharedPtr<KoMacro::Variable>(new ViewVariable<OpenAction>(this, objectvalue, viewname)) );
+			KoMacro::Variable::List() << TDESharedPtr<KoMacro::Variable>(new ViewVariable<OpenAction>(this, objectvalue, viewname)) );
 	}
 
 	return true;
 }
 
-void OpenAction::activate(KSharedPtr<KoMacro::Context> context)
+void OpenAction::activate(TDESharedPtr<KoMacro::Context> context)
 {
 	if(! mainWin()->project()) {
 		throw KoMacro::Exception(i18n("No project loaded."));
diff --git a/kexi/plugins/macros/kexiactions/openaction.h b/kexi/plugins/macros/kexiactions/openaction.h
index 092dc371..700b6ef6 100644
--- a/kexi/plugins/macros/kexiactions/openaction.h
+++ b/kexi/plugins/macros/kexiactions/openaction.h
@@ -64,7 +64,7 @@ namespace KexiMacro {
 			* @return true if the update was successfully else false
 			* is returned.
 			*/
-			virtual bool notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
+			virtual bool notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
 
 		public slots:
 
@@ -72,7 +72,7 @@ namespace KexiMacro {
 			* Called if the @a Action should be executed within the
 			* defined @p context .
 			*/
-			virtual void activate(KSharedPtr<KoMacro::Context> context);
+			virtual void activate(TDESharedPtr<KoMacro::Context> context);
 
 	};
 }
diff --git a/kexi/plugins/macros/kexipart/keximacrodesignview.cpp b/kexi/plugins/macros/kexipart/keximacrodesignview.cpp
index 5406e8ca..dd8b9a92 100644
--- a/kexi/plugins/macros/kexipart/keximacrodesignview.cpp
+++ b/kexi/plugins/macros/kexipart/keximacrodesignview.cpp
@@ -137,7 +137,7 @@ KexiMacroDesignView::KexiMacroDesignView(KexiMainWindow *mainwin, TQWidget *pare
 	TQStringList actionnames = KoMacro::Manager::self()->actionNames();
 	TQStringList::ConstIterator it, end( actionnames.constEnd() );
 	for( it = actionnames.constBegin(); it != end; ++it) {
-		KSharedPtr<KoMacro::Action> action = KoMacro::Manager::self()->action(*it);
+		TDESharedPtr<KoMacro::Action> action = KoMacro::Manager::self()->action(*it);
 		items.append( action->text() );
 	}
 
@@ -218,7 +218,7 @@ void KexiMacroDesignView::updateData()
 			d->tabledata->append(tableitem);
 		}
 		// Set the action-column.
-		KSharedPtr<KoMacro::Action> action = (*it)->action();
+		TDESharedPtr<KoMacro::Action> action = (*it)->action();
 		if(action.data()) {
 			int i = actionnames.findIndex( action->name() );
 			if(i >= 0) {
@@ -273,11 +273,11 @@ void KexiMacroDesignView::beforeCellChanged(KexiTableItem* item, int colnum, TQV
 	// If the rowindex doesn't exists yet, we need to append new
 	// items till we are able to access the item we like to use.
 	for(int i = macro()->items().count(); i <= rowindex; i++) {
-		macro()->addItem( KSharedPtr<KoMacro::MacroItem>( new KoMacro::MacroItem() ) );
+		macro()->addItem( TDESharedPtr<KoMacro::MacroItem>( new KoMacro::MacroItem() ) );
 	}
 
 	// Get the matching MacroItem.
-	KSharedPtr<KoMacro::MacroItem> macroitem = macro()->items()[rowindex];
+	TDESharedPtr<KoMacro::MacroItem> macroitem = macro()->items()[rowindex];
 	if(! macroitem.data()) {
 		kdWarning() << "KexiMacroDesignView::beforeCellChanged() Invalid item for rowindex=" << rowindex << endl;
 		return;
@@ -293,7 +293,7 @@ void KexiMacroDesignView::beforeCellChanged(KexiTableItem* item, int colnum, TQV
 				TQStringList actionnames = KoMacro::Manager::self()->actionNames();
 				actionname = actionnames[ selectedindex - 1 ]; // first item is empty
 			}
-			KSharedPtr<KoMacro::Action> action = KoMacro::Manager::self()->action(actionname);
+			TDESharedPtr<KoMacro::Action> action = KoMacro::Manager::self()->action(actionname);
 			macroitem->setAction(action);
 			updateProperties(d->propertyset->currentRow(), d->propertyset->currentPropertySet(), macroitem);
 			propertySetReloaded(true);
@@ -329,7 +329,7 @@ void KexiMacroDesignView::rowInserted(KexiTableItem*, uint row, bool)
 		// need to do anything yet cause the new item will be handled on
 		// beforeCellChanged() anyway.
 		kdDebug() << "KexiMacroDesignView::rowInserted() Inserting new MacroItem" << endl;
-		KSharedPtr<KoMacro::MacroItem> macroitem = KSharedPtr<KoMacro::MacroItem>( new KoMacro::MacroItem() );
+		TDESharedPtr<KoMacro::MacroItem> macroitem = TDESharedPtr<KoMacro::MacroItem>( new KoMacro::MacroItem() );
 		KoMacro::MacroItem::List::Iterator it = macroitems.at(row);
 		macroitems.insert(it, macroitem);
 	}
@@ -347,7 +347,7 @@ void KexiMacroDesignView::rowDeleted()
 	macroitems.remove( macroitems.at(rowindex) );
 }
 
-bool KexiMacroDesignView::updateSet(KoProperty::Set* set, KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& variablename)
+bool KexiMacroDesignView::updateSet(KoProperty::Set* set, TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& variablename)
 {
 	kdDebug() << "KexiMacroDesignView::updateSet() variablename=" << variablename << endl;
 	KoProperty::Property* property = KexiMacroProperty::createProperty(macroitem, variablename);
@@ -357,7 +357,7 @@ bool KexiMacroDesignView::updateSet(KoProperty::Set* set, KSharedPtr<KoMacro::Ma
 	return true;
 }
 
-void KexiMacroDesignView::updateProperties(int row, KoProperty::Set* set, KSharedPtr<KoMacro::MacroItem> macroitem)
+void KexiMacroDesignView::updateProperties(int row, KoProperty::Set* set, TDESharedPtr<KoMacro::MacroItem> macroitem)
 {
 	kdDebug() << "KexiMacroDesignView::updateProperties() row=" << row << endl;
 
@@ -365,7 +365,7 @@ void KexiMacroDesignView::updateProperties(int row, KoProperty::Set* set, KShare
 		return; // ignore invalid rows and avoid infinite recursion.
 	}
 
-	KSharedPtr<KoMacro::Action> action = macroitem->action();
+	TDESharedPtr<KoMacro::Action> action = macroitem->action();
 	if(! action.data()) {
 		// don't display a propertyset if there is no action defined.
 		d->propertyset->remove(row);
@@ -395,7 +395,7 @@ void KexiMacroDesignView::updateProperties(int row, KoProperty::Set* set, KShare
 	TQStringList varnames = action->variableNames();
 	for(TQStringList::Iterator it = varnames.begin(); it != varnames.end(); ++it) {
 		if(updateSet(set, macroitem, *it)) {
-			KSharedPtr<KoMacro::Variable> variable = macroitem->variable(*it, true);
+			TDESharedPtr<KoMacro::Variable> variable = macroitem->variable(*it, true);
 			kdDebug()<<"KexiMacroDesignView::updateProperties() name=" << *it << " variable=" << variable->variant().toString() << endl;
 #if 0
 			macroitem->setVariable(*it, variable);
@@ -428,7 +428,7 @@ void KexiMacroDesignView::propertyChanged(KoProperty::Set& set, KoProperty::Prop
 		setDirty();
 		if(reload) {
 			// The MacroItem which should be changed.
-			KSharedPtr<KoMacro::MacroItem> macroitem = macro()->items()[row];
+			TDESharedPtr<KoMacro::MacroItem> macroitem = macro()->items()[row];
 			// Update the properties.
 			updateProperties(row, &set, macroitem);
 		}
@@ -442,11 +442,11 @@ void KexiMacroDesignView::propertyChanged(KoProperty::Set& set, KoProperty::Prop
 	*/
 
 	/*
-	TQStringList dirtyvarnames = macroitem->setVariable(name, KSharedPtr<KoMacro::Variable>(pv));
+	TQStringList dirtyvarnames = macroitem->setVariable(name, TDESharedPtr<KoMacro::Variable>(pv));
 	bool dirty = false;
 	bool reload = false;
 	for(TQStringList::Iterator it = dirtyvarnames.begin(); it != dirtyvarnames.end(); ++it) {
-		KSharedPtr<KoMacro::Variable> variable = macroitem->variable(*it);
+		TDESharedPtr<KoMacro::Variable> variable = macroitem->variable(*it);
 		if(! variable.data()) {
 			kdDebug() << "KexiMacroDesignView::propertyChanged() name=" << name << " it=" << *it << " skipped cause such a variable is not known." << endl;
 			continue;
diff --git a/kexi/plugins/macros/kexipart/keximacrodesignview.h b/kexi/plugins/macros/kexipart/keximacrodesignview.h
index eaa64f37..c23e31f9 100644
--- a/kexi/plugins/macros/kexipart/keximacrodesignview.h
+++ b/kexi/plugins/macros/kexipart/keximacrodesignview.h
@@ -118,13 +118,13 @@ class KexiMacroDesignView : public KexiMacroView
 		* Update the \a KoProperty::Set set with the passed \a KoMacro::MacroItem
 		* \p item and the variablename \p variablename .
 		*/
-		bool updateSet(KoProperty::Set* set, KSharedPtr<KoMacro::MacroItem> item, const TQString& variablename);
+		bool updateSet(KoProperty::Set* set, TDESharedPtr<KoMacro::MacroItem> item, const TQString& variablename);
 
 		/**
 		* Update the properties of the \a KoProperty::Set \p set at
 		* row-number \p row with the \a KoMacro::MacroItem \p macroitem .
 		*/
-		void updateProperties(int row, KoProperty::Set* set, KSharedPtr<KoMacro::MacroItem> macroitem);
+		void updateProperties(int row, KoProperty::Set* set, TDESharedPtr<KoMacro::MacroItem> macroitem);
 };
 
 #endif
diff --git a/kexi/plugins/macros/kexipart/keximacroerror.cpp b/kexi/plugins/macros/kexipart/keximacroerror.cpp
index 1b23fa50..6c35e8d7 100644
--- a/kexi/plugins/macros/kexipart/keximacroerror.cpp
+++ b/kexi/plugins/macros/kexipart/keximacroerror.cpp
@@ -34,7 +34,7 @@ class KexiMacroError::Private
 {
 	public:
 		KexiMainWindow* const mainwin;
-		KSharedPtr<KoMacro::Context> context;
+		TDESharedPtr<KoMacro::Context> context;
 
 		Private(KexiMainWindow* const m, KoMacro::Context* const c)
 			: mainwin(m)
@@ -43,7 +43,7 @@ class KexiMacroError::Private
 		}
 };
 
-KexiMacroError::KexiMacroError(KexiMainWindow* mainwin, KSharedPtr<KoMacro::Context> context)
+KexiMacroError::KexiMacroError(KexiMainWindow* mainwin, TDESharedPtr<KoMacro::Context> context)
 	: KexiMacroErrorBase(mainwin, "KexiMacroError" , /*WFlags*/ TQt::WDestructiveClose)
 	, d(new Private(mainwin, context))
 {
@@ -62,7 +62,7 @@ KexiMacroError::KexiMacroError(KexiMainWindow* mainwin, KSharedPtr<KoMacro::Cont
 		KListViewItem* listviewitem = new KListViewItem(errorlist);
 		listviewitem->setText(0,TQString("%1").arg(i++));
 		listviewitem->setText(1,i18n("Action"));
-		KSharedPtr<KoMacro::MacroItem> macroitem = *mit;
+		TDESharedPtr<KoMacro::MacroItem> macroitem = *mit;
 
 		if (macroitem != 0 && macroitem->action() != 0)
 		{
@@ -103,7 +103,7 @@ void KexiMacroError::designbtnClicked()
 	}
 
 	// We need to determinate the KexiPart::Item which should be opened.
-	KSharedPtr<KoMacro::Macro> macro = d->context->macro();
+	TDESharedPtr<KoMacro::Macro> macro = d->context->macro();
 	const TQString name = macro->name();
 	KexiPart::Item* item = d->mainwin->project()->itemForMimeType("kexi/macro", name);
 	if(! item) {
diff --git a/kexi/plugins/macros/kexipart/keximacroerror.h b/kexi/plugins/macros/kexipart/keximacroerror.h
index f8fb5756..b3bfcad8 100644
--- a/kexi/plugins/macros/kexipart/keximacroerror.h
+++ b/kexi/plugins/macros/kexipart/keximacroerror.h
@@ -60,7 +60,7 @@ class KexiMacroError : public KexiMacroErrorBase
 		* @param mainwin The parent @a KexiMainWindow instance.
 		* @param context The @a KoMacro::Context where the error happened.
 		*/
-		KexiMacroError(KexiMainWindow* mainwin, KSharedPtr<KoMacro::Context> context);
+		KexiMacroError(KexiMainWindow* mainwin, TDESharedPtr<KoMacro::Context> context);
 		
 		/**
 		* Destructor.
diff --git a/kexi/plugins/macros/kexipart/keximacropart.cpp b/kexi/plugins/macros/kexipart/keximacropart.cpp
index 1459fffc..c189b8ca 100644
--- a/kexi/plugins/macros/kexipart/keximacropart.cpp
+++ b/kexi/plugins/macros/kexipart/keximacropart.cpp
@@ -129,7 +129,7 @@ KexiViewBase* KexiMacroPart::createView(TQWidget* parent, KexiDialogBase* dialog
 	//kdDebug() << "KexiMacroPart::createView() itemname=" << itemname << endl;
 
 	if(! itemname.isNull()) {
-		KSharedPtr<KoMacro::Macro> macro = ::KoMacro::Manager::self()->getMacro(itemname);
+		TDESharedPtr<KoMacro::Macro> macro = ::KoMacro::Manager::self()->getMacro(itemname);
 		if(! macro) {
 			// If we don't have a macro with that name yet, create one.
 			macro = ::KoMacro::Manager::self()->createMacro(itemname);
diff --git a/kexi/plugins/macros/kexipart/keximacroproperty.cpp b/kexi/plugins/macros/kexipart/keximacroproperty.cpp
index 7934ec71..07c8f8e1 100644
--- a/kexi/plugins/macros/kexipart/keximacroproperty.cpp
+++ b/kexi/plugins/macros/kexipart/keximacroproperty.cpp
@@ -47,13 +47,13 @@ class KexiMacroProperty::Private
 		/** The @a KoMacro::MacroItem the custom property uses
 		internal. Together with the name we are able to identify
 		the used variable at runtime. */
-		KSharedPtr<KoMacro::MacroItem> macroitem;
+		TDESharedPtr<KoMacro::MacroItem> macroitem;
 		/** The name the variable @a KoMacro::Variable is known
 		as in the @a KoMacro::MacroItem defined above. */
 		TQString name;
 };
 
-KexiMacroProperty::KexiMacroProperty(KoProperty::Property* parent, KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
+KexiMacroProperty::KexiMacroProperty(KoProperty::Property* parent, TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
 	: KoProperty::CustomProperty(parent)
 	, d( new Private() )
 {
@@ -72,14 +72,14 @@ void KexiMacroProperty::init()
 	Q_ASSERT( d->macroitem != 0 );
 	//kdDebug() << "--------- KexiMacroProperty::set() macroitem=" << d->macroitem->name() << " name=" << d->name << endl;
 
-	KSharedPtr<KoMacro::Action> action = d->macroitem->action();
-	KSharedPtr<KoMacro::Variable> actionvariable = action->variable(d->name);
+	TDESharedPtr<KoMacro::Action> action = d->macroitem->action();
+	TDESharedPtr<KoMacro::Variable> actionvariable = action->variable(d->name);
 	if(! actionvariable.data()) {
 		kdDebug() << "KexiMacroProperty::createProperty() Skipped cause there exists no such action=" << d->name << endl;
 		return;
 	}
 
-	KSharedPtr<KoMacro::Variable> variable = d->macroitem->variable(d->name, true/*checkaction*/);
+	TDESharedPtr<KoMacro::Variable> variable = d->macroitem->variable(d->name, true/*checkaction*/);
 	if(! variable.data()) {
 		kdDebug() << "KexiMacroProperty::createProperty() Skipped cause there exists no such variable=" << d->name << endl;
 		return;
@@ -121,7 +121,7 @@ void KexiMacroProperty::setValue(const TQVariant &value, bool rememberOldValue)
 
 TQVariant KexiMacroProperty::value() const
 {
-	KSharedPtr<KoMacro::Variable> variable = d->macroitem->variable(d->name, true);
+	TDESharedPtr<KoMacro::Variable> variable = d->macroitem->variable(d->name, true);
 	Q_ASSERT( variable.data() != 0 );
 	return variable.data() ? variable->variant() : TQVariant();
 }
@@ -131,7 +131,7 @@ bool KexiMacroProperty::handleValue() const
 	return true; // we handle getting and setting of values and don't need KoProperty::Property for it.
 }
 
-KSharedPtr<KoMacro::MacroItem> KexiMacroProperty::macroItem() const
+TDESharedPtr<KoMacro::MacroItem> KexiMacroProperty::macroItem() const
 {
 	return d->macroitem;
 }
@@ -141,12 +141,12 @@ TQString KexiMacroProperty::name() const
 	return d->name;
 }
 
-KSharedPtr<KoMacro::Variable> KexiMacroProperty::variable() const
+TDESharedPtr<KoMacro::Variable> KexiMacroProperty::variable() const
 {
 	return d->macroitem->variable(d->name, true/*checkaction*/);
 }
 
-KoProperty::Property* KexiMacroProperty::createProperty(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
+KoProperty::Property* KexiMacroProperty::createProperty(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
 {
 	KoProperty::Property* property = new KoProperty::Property();
 	KexiMacroProperty* customproperty = new KexiMacroProperty(property, macroitem, name);
@@ -184,7 +184,7 @@ KoProperty::CustomProperty* KexiMacroPropertyFactory::createCustomProperty(KoPro
 		return 0;
 	}
 
-	KSharedPtr<KoMacro::MacroItem> macroitem = parentcustomproperty->macroItem();
+	TDESharedPtr<KoMacro::MacroItem> macroitem = parentcustomproperty->macroItem();
 	Q_ASSERT( macroitem.data() != 0 );
 	const TQString name = parentcustomproperty->name();
 	Q_ASSERT(! name.isEmpty());
@@ -266,7 +266,7 @@ class EditListBoxItem : public ListBoxItem
 		}
 
 		virtual TQString text() const {
-			KSharedPtr<KoMacro::Variable> variable = m_macroproperty->variable();
+			TDESharedPtr<KoMacro::Variable> variable = m_macroproperty->variable();
 			Q_ASSERT( variable.data() );
 			//kdDebug()<<"EditListBoxItem::text() text="<<variable->toString()<<endl;
 			Q_ASSERT( variable->toString() != TQString() );
@@ -274,9 +274,9 @@ class EditListBoxItem : public ListBoxItem
 		}
 
 		KoProperty::Widget* widget() const { return m_widget; }
-		KSharedPtr<KoMacro::MacroItem> macroItem() const { return m_macroproperty->macroItem(); }
-		KSharedPtr<KoMacro::Variable> variable() const { return m_macroproperty->variable(); }
-		KSharedPtr<KoMacro::Action> action() const { return m_macroproperty->macroItem()->action(); }
+		TDESharedPtr<KoMacro::MacroItem> macroItem() const { return m_macroproperty->macroItem(); }
+		TDESharedPtr<KoMacro::Variable> variable() const { return m_macroproperty->variable(); }
+		TDESharedPtr<KoMacro::Action> action() const { return m_macroproperty->macroItem()->action(); }
 
 	protected:
 		virtual void paint(TQPainter* p) {
@@ -290,9 +290,9 @@ class EditListBoxItem : public ListBoxItem
 
 	private:
 		void init() {
-			KSharedPtr<KoMacro::MacroItem> macroitem = m_macroproperty->macroItem();
+			TDESharedPtr<KoMacro::MacroItem> macroitem = m_macroproperty->macroItem();
 			Q_ASSERT( macroitem.data() );
-			KSharedPtr<KoMacro::Action> action = m_macroproperty->macroItem()->action();
+			TDESharedPtr<KoMacro::Action> action = m_macroproperty->macroItem()->action();
 			if(! action.data()) {
 				kdWarning() << "EditListBoxItem::EditListBoxItem() Skipped cause there exists no action for macroproperty=" << m_macroproperty->name() << endl;
 				return;
@@ -302,7 +302,7 @@ class EditListBoxItem : public ListBoxItem
 				kdWarning() << "EditListBoxItem::EditListBoxItem() No parentproperty defined" << endl;
 				return;
 			}
-			KSharedPtr<KoMacro::Variable> variable = m_macroproperty->variable();
+			TDESharedPtr<KoMacro::Variable> variable = m_macroproperty->variable();
 			if(! variable.data()) {
 				kdWarning() << "EditListBoxItem::EditListBoxItem() No variable defined for property=" << parentproperty->name() << endl;
 				return;
@@ -310,7 +310,7 @@ class EditListBoxItem : public ListBoxItem
 
 			TQVariant variant = variable->variant();
 
-			KSharedPtr<KoMacro::Variable> actionvariable = action->variable(m_macroproperty->name());
+			TDESharedPtr<KoMacro::Variable> actionvariable = action->variable(m_macroproperty->name());
 			if(actionvariable.data()) {
 				TQVariant actionvariant = actionvariable->variant();
 				Q_ASSERT( ! actionvariant.isNull() );
@@ -393,13 +393,13 @@ class ListBox : public TQListBox
 			{
 				KoMacro::Variable::List actionchildren;
 
-				KSharedPtr<KoMacro::Variable> itemvar = m_macroproperty->macroItem()->variable(name,false);
+				TDESharedPtr<KoMacro::Variable> itemvar = m_macroproperty->macroItem()->variable(name,false);
 				//kdDebug() << "KexiMacroProperty::ListBox::update() itemvar="<<(itemvar.data() ? "name:"+itemvar->name()+" value:"+itemvar->toString() : "NULL")<<endl;
 				if(itemvar.data())
 					actionchildren = itemvar->children();
 
-				KSharedPtr<KoMacro::Action> action = m_edititem->action();
-				KSharedPtr<KoMacro::Variable> actionvar = action.data() ? action->variable(name) : KSharedPtr<KoMacro::Variable>();
+				TDESharedPtr<KoMacro::Action> action = m_edititem->action();
+				TDESharedPtr<KoMacro::Variable> actionvar = action.data() ? action->variable(name) : TDESharedPtr<KoMacro::Variable>();
 				//kdDebug() << "KexiMacroProperty::ListBox::update() actionvar="<<(actionvar.data() ? "name:"+actionvar->name()+" value:"+actionvar->toString() : "NULL")<<endl;
 				if(actionvar.data())
 					actionchildren += actionvar->children();
diff --git a/kexi/plugins/macros/kexipart/keximacroproperty.h b/kexi/plugins/macros/kexipart/keximacroproperty.h
index 44ad8bd4..47f7a7e1 100644
--- a/kexi/plugins/macros/kexipart/keximacroproperty.h
+++ b/kexi/plugins/macros/kexipart/keximacroproperty.h
@@ -47,7 +47,7 @@ class KexiMacroProperty
 	public:
 
 		/** Constructor. */
-		explicit KexiMacroProperty(KoProperty::Property* parent, KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
+		explicit KexiMacroProperty(KoProperty::Property* parent, TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
 		/** Destructor. */
 		virtual ~KexiMacroProperty();
 
@@ -73,7 +73,7 @@ class KexiMacroProperty
 
 		/** \return the \a KoMacro::MacroItem this custom property has or
 		NULL if there was no item provided. */
-		KSharedPtr<KoMacro::MacroItem> macroItem() const;
+		TDESharedPtr<KoMacro::MacroItem> macroItem() const;
 
 		/** \return the name the property has in the \a KoMacro::MacroItem
 		above. Is TQString() if there was no item provided. */
@@ -82,11 +82,11 @@ class KexiMacroProperty
 		/** \return the \a KoMacro::Variable which has the name @a name()
 		in the item @a macroItem() . If such a variable doesn't exists NULL
 		is returned. */
-		KSharedPtr<KoMacro::Variable> variable() const;
+		TDESharedPtr<KoMacro::Variable> variable() const;
 
 		/** Factory function to create a new @a KoProperty::Property instance
 		that will use a @a KexiMacroProperty as container. */
-		static KoProperty::Property* createProperty(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
+		static KoProperty::Property* createProperty(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
 
 	signals:
 
diff --git a/kexi/plugins/macros/kexipart/keximacroview.cpp b/kexi/plugins/macros/kexipart/keximacroview.cpp
index 19e789f0..f0e7ea0b 100644
--- a/kexi/plugins/macros/kexipart/keximacroview.cpp
+++ b/kexi/plugins/macros/kexipart/keximacroview.cpp
@@ -47,7 +47,7 @@ class KexiMacroView::Private
 		* The \a KoMacro::Manager instance used to access the
 		* Macro Framework.
 		*/
-		KSharedPtr<KoMacro::Macro> macro;
+		TDESharedPtr<KoMacro::Macro> macro;
 
 		/**
 		* Constructor.
@@ -76,7 +76,7 @@ KexiMacroView::~KexiMacroView()
 	delete d;
 }
 
-KSharedPtr<KoMacro::Macro> KexiMacroView::macro() const
+TDESharedPtr<KoMacro::Macro> KexiMacroView::macro() const
 {
 	return d->macro;
 }
@@ -161,7 +161,7 @@ tristate KexiMacroView::storeData(bool /*dontAsk*/)
 
 void KexiMacroView::execute(TQObject* sender)
 {
-	KSharedPtr<KoMacro::Context> context = d->macro->execute(sender);
+	TDESharedPtr<KoMacro::Context> context = d->macro->execute(sender);
 	if(context->hadException()) {
 		KexiMacroError* error = new KexiMacroError(
 			mainWin(), // The parent KexiMainWindow
diff --git a/kexi/plugins/macros/kexipart/keximacroview.h b/kexi/plugins/macros/kexipart/keximacroview.h
index c11d48e8..ddff961f 100644
--- a/kexi/plugins/macros/kexipart/keximacroview.h
+++ b/kexi/plugins/macros/kexipart/keximacroview.h
@@ -63,7 +63,7 @@ class KexiMacroView : public KexiViewBase
 		/**
 		* \return the Macro instance.
 		*/
-		KSharedPtr<KoMacro::Macro> macro() const;
+		TDESharedPtr<KoMacro::Macro> macro() const;
 
 		/**
 		* Load the data from XML source and fill the internally
diff --git a/kexi/plugins/macros/lib/action.cpp b/kexi/plugins/macros/lib/action.cpp
index fc729b57..3fc1adf6 100644
--- a/kexi/plugins/macros/lib/action.cpp
+++ b/kexi/plugins/macros/lib/action.cpp
@@ -68,7 +68,7 @@ namespace KoMacro {
 
 Action::Action(const TQString& name, const TQString& text)
 	: TQObject()
-	, KShared()
+	, TDEShared()
 	, d( new Private() ) // create the private d-pointer instance.
 {
 	kdDebug() << "Action::Action() name=" << name << endl;
@@ -76,7 +76,7 @@ Action::Action(const TQString& name, const TQString& text)
 	setText(text);
 
 	// Publish this action.
-	KoMacro::Manager::self()->publishAction( KSharedPtr<Action>(this) );
+	KoMacro::Manager::self()->publishAction( TDESharedPtr<Action>(this) );
 }
 
 Action::~Action()
@@ -127,9 +127,9 @@ bool Action::hasVariable(const TQString& name) const
 	return d->varmap.contains(name);
 }
 
-KSharedPtr<Variable> Action::variable(const TQString& name) const
+TDESharedPtr<Variable> Action::variable(const TQString& name) const
 {
-	return d->varmap.contains(name) ? d->varmap[name] : KSharedPtr<Variable>(0);
+	return d->varmap.contains(name) ? d->varmap[name] : TDESharedPtr<Variable>(0);
 }
 
 Variable::Map Action::variables() const
@@ -142,7 +142,7 @@ TQStringList Action::variableNames() const
 	return d->varnames;
 }
 
-void Action::setVariable(KSharedPtr<Variable> variable)
+void Action::setVariable(TDESharedPtr<Variable> variable)
 {
 	const TQString name = variable->name();
 	if(! d->varmap.contains(name)) {
@@ -156,7 +156,7 @@ void Action::setVariable(const TQString& name, const TQString& text, const TQVar
 	Variable* variable = new Variable(variant);
 	variable->setName(name);
 	variable->setText(text);
-	setVariable( KSharedPtr<Variable>(variable) );
+	setVariable( TDESharedPtr<Variable>(variable) );
 }
 
 void Action::removeVariable(const TQString& name)
diff --git a/kexi/plugins/macros/lib/action.h b/kexi/plugins/macros/lib/action.h
index 762e27ae..c779f21a 100644
--- a/kexi/plugins/macros/lib/action.h
+++ b/kexi/plugins/macros/lib/action.h
@@ -37,7 +37,7 @@ namespace KoMacro {
 	 */
 	class KOMACRO_EXPORT Action
 		: public TQObject // TQt functionality like signals and slots
-		, public KShared // shared reference-counting
+		, public TDEShared // shared reference-counting
 	{
 			Q_OBJECT
   
@@ -56,7 +56,7 @@ namespace KoMacro {
 			/**
 			* Shared pointer to implement reference-counting.
 			*/
-			typedef TQMap<TQString, KSharedPtr<Action> > Map;
+			typedef TQMap<TQString, TDESharedPtr<Action> > Map;
 
 			/**
 			* Constructor.
@@ -118,7 +118,7 @@ namespace KoMacro {
 			* name @p name . If there exists no @a Variable with
 			* such a name, NULL is returned.
 			*/
-			KSharedPtr<Variable> variable(const TQString& name) const;
+			TDESharedPtr<Variable> variable(const TQString& name) const;
 
 			/**
 			* @return the map of variables this @a Action provides.
@@ -134,7 +134,7 @@ namespace KoMacro {
 			 * Append the @a Variable @p variable to list of variables
 			 * this @a Action provides.
 			 */
-			void setVariable(KSharedPtr<Variable> variable);
+			void setVariable(TDESharedPtr<Variable> variable);
 
 			/**
 			 * Set the variable.
@@ -162,7 +162,7 @@ namespace KoMacro {
 			* @return true if the update was successfully else false
 			* is returned.
 			*/
-			virtual bool notifyUpdated(const KSharedPtr<MacroItem> &macroitem, const TQString& name) {
+			virtual bool notifyUpdated(const TDESharedPtr<MacroItem> &macroitem, const TQString& name) {
 				Q_UNUSED(macroitem);
 				Q_UNUSED(name);
 				return true; // The default implementation does nothing.
@@ -174,7 +174,7 @@ namespace KoMacro {
 			* Called if the @a Action should be executed within the
 			* defined @p context .
 			*/
-			virtual void activate(KSharedPtr<Context> context) = 0;
+			virtual void activate(TDESharedPtr<Context> context) = 0;
 
 		private:
 			/// @internal d-pointer class.
diff --git a/kexi/plugins/macros/lib/context.cpp b/kexi/plugins/macros/lib/context.cpp
index c0eea250..a09704bd 100644
--- a/kexi/plugins/macros/lib/context.cpp
+++ b/kexi/plugins/macros/lib/context.cpp
@@ -41,25 +41,25 @@ namespace KoMacro {
 			/**
 			* The @a Macro instance that owns this @a Context .
 			*/
-			KSharedPtr<Macro> macro;
+			TDESharedPtr<Macro> macro;
 
 			/**
 			* List of @a Action instances that are children of the
 			* macro.
 			*/
-			TQValueList<KSharedPtr<MacroItem > > items;
+			TQValueList<TDESharedPtr<MacroItem > > items;
 
 			/**
 			* The currently selected @a MacroItem or NULL if there
 			* is now @a MacroItem selected yet.
 			*/
-			KSharedPtr<MacroItem> macroitem;
+			TDESharedPtr<MacroItem> macroitem;
 
 			/**
 			* Map of all @a Variable instance that are defined within
 			* this context.
 			*/
-			TQMap<TQString, KSharedPtr<Variable > > variables;
+			TQMap<TQString, TDESharedPtr<Variable > > variables;
 
 			/**
 			* The @a Exception instance thrown at the last @a activate()
@@ -68,7 +68,7 @@ namespace KoMacro {
 			Exception* exception;
 
 			/// Constructor.
-			explicit Private(KSharedPtr<Macro> m)
+			explicit Private(TDESharedPtr<Macro> m)
 				: macro(m) // remember the macro
 				, items(m->items()) // set d-pointer children to macro children
 				, exception(0) // no exception yet.
@@ -84,7 +84,7 @@ namespace KoMacro {
 
 }
 //Constructor with initialization of our Private.object (d-pointer)
-Context::Context(KSharedPtr<Macro> macro)
+Context::Context(TDESharedPtr<Macro> macro)
 	: TQObject()
 	, d( new Private(macro) ) // create the private d-pointer instance.
 {
@@ -104,7 +104,7 @@ bool Context::hasVariable(const TQString& name) const
 }
 
 //return variable with name or throw an exception if none is found in variables
-KSharedPtr<Variable> Context::variable(const TQString& name) const
+TDESharedPtr<Variable> Context::variable(const TQString& name) const
 {
 	//Use TQMap?s contains to check if a variable with name exists in context	
 	if (d->variables.contains(name)) {
@@ -113,7 +113,7 @@ KSharedPtr<Variable> Context::variable(const TQString& name) const
 	}
 	//if there is a macroitem try to get variable from it 
 	if(d->macroitem.data()) {
-		KSharedPtr<Variable> v = d->macroitem->variable(name, true);
+		TDESharedPtr<Variable> v = d->macroitem->variable(name, true);
 		if(v.data()) {
 			return v;
 		}
@@ -129,7 +129,7 @@ Variable::Map Context::variables() const
 }
 
 //set a variable
-void Context::setVariable(const TQString& name, KSharedPtr<Variable> variable)
+void Context::setVariable(const TQString& name, TDESharedPtr<Variable> variable)
 {
 	//debuging infos
 	kdDebug() << TQString("KoMacro::Context::setVariable name='%1' variable='%2'").arg(name).arg(variable->toString()) << endl;
@@ -138,13 +138,13 @@ void Context::setVariable(const TQString& name, KSharedPtr<Variable> variable)
 }
 
 //return the associated Macro
-KSharedPtr<Macro> Context::macro() const
+TDESharedPtr<Macro> Context::macro() const
 {
 	return d->macro;
 }
 
 //return the currently selected MacroItem
-KSharedPtr<MacroItem> Context::macroItem() const
+TDESharedPtr<MacroItem> Context::macroItem() const
 {
 	return d->macroitem;
 }
@@ -162,18 +162,18 @@ Exception* Context::exception() const
 }
 
 //try to activate all action?s in this context
-void Context::activate(TQValueList<KSharedPtr<MacroItem > >::ConstIterator it)
+void Context::activate(TQValueList<TDESharedPtr<MacroItem > >::ConstIterator it)
 {
 	//debuging infos
 	kdDebug() << "Context::activate()" << endl;
 	//TQ_ASSIGN(d->macro);
 
 	//set end to constEnd
-	TQValueList<KSharedPtr<MacroItem > >::ConstIterator end(d->items.constEnd());
+	TQValueList<TDESharedPtr<MacroItem > >::ConstIterator end(d->items.constEnd());
 	//loop through actions
 	for(;it != end; ++it) {
 		// fetch the MacroItem we are currently pointing to.
-		d->macroitem = KSharedPtr<MacroItem>(*it);
+		d->macroitem = TDESharedPtr<MacroItem>(*it);
 		//skip empty macroitems
 		if(! d->macroitem.data()) {
 			kdDebug() << "Context::activate() Skipping empty MacroItem" << endl;
@@ -181,7 +181,7 @@ void Context::activate(TQValueList<KSharedPtr<MacroItem > >::ConstIterator it)
 		}
 
 		// fetch the Action, the MacroItem points to.
-		KSharedPtr<Action> action = d->macroitem->action();
+		TDESharedPtr<Action> action = d->macroitem->action();
 		//skip macroitems without an action
 		if(! action.data()) {
 			kdDebug() << "Context::activate() Skipping MacroItem with no action" << endl;
@@ -204,7 +204,7 @@ void Context::activate(TQValueList<KSharedPtr<MacroItem > >::ConstIterator it)
 			//and all variables wich belong to the action/macro
 			TQStringList variables = action->variableNames();
 			for(TQStringList::Iterator vit = variables.begin(); vit != variables.end(); ++vit) {
-				KSharedPtr<Variable> v = d->macroitem->variable(*vit, true);
+				TDESharedPtr<Variable> v = d->macroitem->variable(*vit, true);
 				d->exception->addTraceMessage( TQString("%1=%2").arg(*vit).arg(v->toString()) );
 			}
 			return; // abort execution
@@ -213,11 +213,11 @@ void Context::activate(TQValueList<KSharedPtr<MacroItem > >::ConstIterator it)
 
 	// The run is done. So, let's remove the currently selected item to
 	// outline, that we did the job and there stays no dangling item.
-	d->macroitem = KSharedPtr<MacroItem>(0);
+	d->macroitem = TDESharedPtr<MacroItem>(0);
 }
 
 //try to activated an context
-void Context::activate(KSharedPtr<Context> context)
+void Context::activate(TDESharedPtr<Context> context)
 {
 	//setup context
 	delete d->exception; d->exception = 0;
@@ -252,7 +252,7 @@ void Context::activateNext()
 	}
 
 	//find the macroitem from which to continue
-	TQValueList<KSharedPtr<MacroItem > >::ConstIterator it = d->items.find(d->macroitem);
+	TQValueList<TDESharedPtr<MacroItem > >::ConstIterator it = d->items.find(d->macroitem);
 	if (it != d->items.constEnd()) {
 		activate(++it); // try to continue the execution.
 	}
diff --git a/kexi/plugins/macros/lib/context.h b/kexi/plugins/macros/lib/context.h
index 4f9621cc..9bb0f5eb 100644
--- a/kexi/plugins/macros/lib/context.h
+++ b/kexi/plugins/macros/lib/context.h
@@ -40,7 +40,7 @@ namespace KoMacro {
 	*/
 	class KOMACRO_EXPORT Context
 		: public TQObject
-		, public KShared
+		, public TDEShared
 	{
 			Q_OBJECT
   
@@ -51,7 +51,7 @@ namespace KoMacro {
 			* 
 			* @param macro The @a Macro this @a Context belongs to.
 			*/
-			explicit Context(KSharedPtr<Macro> macro);
+			explicit Context(TDESharedPtr<Macro> macro);
 
 			/**
 			* Destructor.
@@ -68,7 +68,7 @@ namespace KoMacro {
 			* @return the @a Variable defined with name @p name or
 			* NULL if there exists no such variable.
 			*/
-			KSharedPtr<Variable> variable(const TQString& name) const;
+			TDESharedPtr<Variable> variable(const TQString& name) const;
 
 			/**
 			* @return a map of all @a Variable instance that are defined
@@ -80,18 +80,18 @@ namespace KoMacro {
 			* Set the variable @p variable defined with name @p name . If
 			* there exists already a variable with that name replace it.
 			*/
-			void setVariable(const TQString& name, KSharedPtr<Variable> variable);
+			void setVariable(const TQString& name, TDESharedPtr<Variable> variable);
 
 			/**
 			* @return the associated macro 
 			*/
-			KSharedPtr<Macro> macro() const;
+			TDESharedPtr<Macro> macro() const;
 
 			/**
 			* @return the currently selected @a MacroItem instance
 			* or NULL if there is no @a MacroItem selected yet.
 			*/
-			KSharedPtr<MacroItem> macroItem() const;
+			TDESharedPtr<MacroItem> macroItem() const;
 
 			/**
 			* @return true if the last @a activate() stopped with an
@@ -114,7 +114,7 @@ namespace KoMacro {
 			* remembers what @a Action should be executed next and
 			* calling this slot just activates those @a Action .
 			*/
-			virtual void activate(TQValueList<KSharedPtr <MacroItem> >::ConstIterator it);
+			virtual void activate(TQValueList<TDESharedPtr <MacroItem> >::ConstIterator it);
 
 		public slots:
 
@@ -123,7 +123,7 @@ namespace KoMacro {
 			* @a Context @p context which will be used as
 			* parent context for this context.
 			*/
-			virtual void activate(KSharedPtr<Context> context);
+			virtual void activate(TDESharedPtr<Context> context);
 
 			/**
 			* This slot continues execution.
diff --git a/kexi/plugins/macros/lib/macro.cpp b/kexi/plugins/macros/lib/macro.cpp
index 808c4043..af29da57 100644
--- a/kexi/plugins/macros/lib/macro.cpp
+++ b/kexi/plugins/macros/lib/macro.cpp
@@ -41,7 +41,7 @@ namespace KoMacro {
 			/**
 			* A list of @a MacroItem instances.
 			*/
-			TQValueList<KSharedPtr<MacroItem > > itemlist;
+			TQValueList<TDESharedPtr<MacroItem > > itemlist;
 
 			/**
 			* The name the @a Macro has.
@@ -55,7 +55,7 @@ namespace KoMacro {
 //constructor, initalize internal (d-pointer) name
 Macro::Macro(const TQString& name)
 	: TQObject()
-	, KShared()
+	, TDEShared()
 	, XMLHandler(this)
 	, d( new Private() ) // create the private d-pointer instance.
 {
@@ -88,13 +88,13 @@ const TQString Macro::toString() const
 }
 
 //get (d-pointer) itemlist
-TQValueList<KSharedPtr<MacroItem > >& Macro::items() const
+TQValueList<TDESharedPtr<MacroItem > >& Macro::items() const
 {
 	return d->itemlist;
 }
 
 //add a macroitem to internal (d-pointer) itemlist
-void Macro::addItem(KSharedPtr<MacroItem> item)
+void Macro::addItem(TDESharedPtr<MacroItem> item)
 {
 	d->itemlist.append(item);
 }
@@ -105,15 +105,15 @@ void Macro::clearItems()
 }
 
 //run our macro
-KSharedPtr<Context> Macro::execute(TQObject* sender)
+TDESharedPtr<Context> Macro::execute(TQObject* sender)
 {
-	kdDebug() << "Macro::execute(KSharedPtr<Context>)" << endl;
+	kdDebug() << "Macro::execute(TDESharedPtr<Context>)" << endl;
 
 	//create context in which macro can/should run
-	KSharedPtr<Context> c = KSharedPtr<Context>( new Context(this) );
+	TDESharedPtr<Context> c = TDESharedPtr<Context>( new Context(this) );
 	if(sender) {
 		// set the sender-variable if we got a sender TQObject.
-		c->setVariable("[sender]", KSharedPtr<Variable>( new Variable(sender) ));
+		c->setVariable("[sender]", TDESharedPtr<Variable>( new Variable(sender) ));
 	}
 	//connect(context, TQT_SIGNAL(activated()), this, TQT_SIGNAL(activated()));
 	
diff --git a/kexi/plugins/macros/lib/macro.h b/kexi/plugins/macros/lib/macro.h
index 80d50deb..cc1fd77e 100644
--- a/kexi/plugins/macros/lib/macro.h
+++ b/kexi/plugins/macros/lib/macro.h
@@ -40,7 +40,7 @@ namespace KoMacro {
 	*/
 	class KOMACRO_EXPORT Macro
 		: public TQObject // TQt functionality like signals and slots
-		, public KShared // shared reference-counting
+		, public TDEShared // shared reference-counting
 		, public XMLHandler // to (un-)serialize from/to XML
 	{
 			Q_OBJECT
@@ -53,7 +53,7 @@ namespace KoMacro {
 			* class should use this typemap rather then the TQMap direct. That
 			* way we are more flexible on future changes.
 			*/
-			typedef TQMap<TQString, KSharedPtr<Macro > > Map;
+			typedef TQMap<TQString, TDESharedPtr<Macro > > Map;
 
 			/**
 			* Constructor.
@@ -87,13 +87,13 @@ namespace KoMacro {
 			* @return a list of @a MacroItem instances which
 			* are children of this @a Macro .
 			*/
-			TQValueList< KSharedPtr<MacroItem> >& items() const;
+			TQValueList< TDESharedPtr<MacroItem> >& items() const;
 
 			/**
 			* Add the @a MacroItem @p item to the list of items
 			* this @a Macro has.
 			*/
-			void addItem(KSharedPtr<MacroItem> item);
+			void addItem(TDESharedPtr<MacroItem> item);
 
 			/**
 			* Removes all @a MacroItem instances this @a Macro has.
@@ -117,7 +117,7 @@ namespace KoMacro {
 			* @param context The @a Context this @a Macro should
 			* be executed in.
 			*/
-			virtual KSharedPtr<Context> execute(TQObject* sender);
+			virtual TDESharedPtr<Context> execute(TQObject* sender);
 
 		private:
 			/// @internal d-pointer class.
diff --git a/kexi/plugins/macros/lib/macroitem.cpp b/kexi/plugins/macros/lib/macroitem.cpp
index cf317fab..33e69c31 100644
--- a/kexi/plugins/macros/lib/macroitem.cpp
+++ b/kexi/plugins/macros/lib/macroitem.cpp
@@ -35,7 +35,7 @@ namespace KoMacro {
 			/**
 			* The @a Action this @a MacroItem has.
 			*/
-			KSharedPtr<Action> action;
+			TDESharedPtr<Action> action;
 			
 			/**
 			* The comment this @a MacroItem has.
@@ -109,7 +109,7 @@ namespace KoMacro {
 }
 
 MacroItem::MacroItem()
-	: KShared()
+	: TDEShared()
 	, d( new Private() )
 {
 }
@@ -129,29 +129,29 @@ void MacroItem::setComment(const TQString& comment)
 	d->comment = comment;
 }
 
-KSharedPtr<Action> MacroItem::action() const
+TDESharedPtr<Action> MacroItem::action() const
 {
 	return d->action;
 }
 
-void MacroItem::setAction(KSharedPtr<Action> action)
+void MacroItem::setAction(TDESharedPtr<Action> action)
 {
 	d->action = action;
 }
 
 TQVariant MacroItem::variant(const TQString& name, bool checkaction) const
 {
-	KSharedPtr<Variable> v = variable(name, checkaction);
+	TDESharedPtr<Variable> v = variable(name, checkaction);
 	return v.data() ? v->variant() : TQVariant();
 }
 
-KSharedPtr<Variable> MacroItem::variable(const TQString& name, bool checkaction) const
+TDESharedPtr<Variable> MacroItem::variable(const TQString& name, bool checkaction) const
 {
 	if(d->variables.contains(name))
 		return d->variables[name];
 	if(checkaction && d->action.data())
 		return d->action->variable(name);
-	return KSharedPtr<Variable>(0);
+	return TDESharedPtr<Variable>(0);
 }
 
 Variable::Map MacroItem::variables() const
@@ -163,7 +163,7 @@ bool MacroItem::setVariant(const TQString& name, const TQVariant& variant)
 {
 	// Let's look if there is an action defined for the variable. If that's
 	// the case, we try to use that action to preserve the type of the variant.
-	KSharedPtr<Variable> actionvariable = d->action ? d->action->variable(name) : KSharedPtr<Variable>(0);
+	TDESharedPtr<Variable> actionvariable = d->action ? d->action->variable(name) : TDESharedPtr<Variable>(0);
 
 	// If we know the expected type, we try to cast the variant to the expected
 	// type else the variant stays untouched (so, it will stay a string).
@@ -172,12 +172,12 @@ bool MacroItem::setVariant(const TQString& name, const TQVariant& variant)
 		: variant; // don't cast anything, just leave the string-type...
 
 	// Now let's try to determinate the variable which should be changed.
-	KSharedPtr<Variable> variable = d->variables[name];
+	TDESharedPtr<Variable> variable = d->variables[name];
 	if(! variable.data()) {
 		// if there exists no such variable yet, create one.
 		kdDebug() << "MacroItem::setVariable() Creating new variable name=" << name << endl;
 
-		variable = KSharedPtr<Variable>( new Variable() );
+		variable = TDESharedPtr<Variable>( new Variable() );
 		variable->setName(name);
 		d->variables.replace(name, variable);
 	}
@@ -201,11 +201,11 @@ bool MacroItem::setVariant(const TQString& name, const TQVariant& variant)
 	return true;
 }
 
-KSharedPtr<Variable> MacroItem::addVariable(const TQString& name, const TQVariant& variant)
+TDESharedPtr<Variable> MacroItem::addVariable(const TQString& name, const TQVariant& variant)
 {
 	Q_ASSERT(! d->variables.contains(name) );
 	// Create a new Variable.
-	KSharedPtr<Variable> variable = KSharedPtr<Variable>( new Variable() );
+	TDESharedPtr<Variable> variable = TDESharedPtr<Variable>( new Variable() );
 	variable->setName(name);
 	
 	// Put it into the Variable-map.
diff --git a/kexi/plugins/macros/lib/macroitem.h b/kexi/plugins/macros/lib/macroitem.h
index 6b996e70..210a9585 100644
--- a/kexi/plugins/macros/lib/macroitem.h
+++ b/kexi/plugins/macros/lib/macroitem.h
@@ -43,7 +43,7 @@ namespace KoMacro {
 	* MacroItem choosen @a Action implementation) and holds the by the
 	* user defined modifications like e.g. the comment on the other hand.
 	*/
-	class KOMACRO_EXPORT MacroItem : public KShared
+	class KOMACRO_EXPORT MacroItem : public TDEShared
 	{
 
 		public:
@@ -51,7 +51,7 @@ namespace KoMacro {
 			/**
 			* A list of \a MacroItem instances.
 			*/
-			typedef TQValueList<KSharedPtr<MacroItem > > List;
+			typedef TQValueList<TDESharedPtr<MacroItem > > List;
 
 			/**
 			* Constructor.
@@ -81,12 +81,12 @@ namespace KoMacro {
 			* no @a Action defined yet else the returned
 			* @a Action will be used to implement the execution.
 			*/
-			KSharedPtr<Action> action() const;
+			TDESharedPtr<Action> action() const;
 
 			/**
 			* Set the @a Action @param action this @a MacroItem points to.
 			*/
-			void setAction(KSharedPtr<Action> action);
+			void setAction(TDESharedPtr<Action> action);
 
 			/**
 			* @return @a Variant from the @a Variable identified with
@@ -110,12 +110,12 @@ namespace KoMacro {
 			* such a @param name in the case this @a MacroItem
 			* doesn't have such a name.
 			*/
-			KSharedPtr<Variable> variable(const TQString& name, bool checkaction = false) const;
+			TDESharedPtr<Variable> variable(const TQString& name, bool checkaction = false) const;
 
 			/**
 			* @return a map of @a Variable instances.
 			*/
-			TQMap<TQString, KSharedPtr<Variable> > variables() const;
+			TQMap<TQString, TDESharedPtr<Variable> > variables() const;
 
 			/**
 			* Set the @a TQVariant @param variant as variable with the variablename
@@ -128,7 +128,7 @@ namespace KoMacro {
 			* Add a new variable with the vaiablename @param name and the given
 			* @a TQVariant @param variant to our @a MacroItem instance.
 			*/
-			KSharedPtr<Variable> addVariable(const TQString& name, const TQVariant& variant);
+			TDESharedPtr<Variable> addVariable(const TQString& name, const TQVariant& variant);
 
 		private:
 			/// @internal d-pointer class.
diff --git a/kexi/plugins/macros/lib/manager.cpp b/kexi/plugins/macros/lib/manager.cpp
index f73ddaa8..5ab431d5 100644
--- a/kexi/plugins/macros/lib/manager.cpp
+++ b/kexi/plugins/macros/lib/manager.cpp
@@ -41,10 +41,10 @@ namespace KoMacro {
 	{
 		public:
 			KXMLGUIClient* const xmlguiclient;
-			TQMap<TQString, KSharedPtr<Macro > > macros;
+			TQMap<TQString, TDESharedPtr<Macro > > macros;
 
 			TQStringList actionnames;
-			TQMap<TQString, KSharedPtr<Action> > actions;
+			TQMap<TQString, TDESharedPtr<Action> > actions;
 
 			TQMap<TQString, TQGuardedPtr<TQObject> > objects;
 
@@ -108,12 +108,12 @@ bool Manager::hasMacro(const TQString& macroname)
 	return d->macros.contains(macroname);
 }
 
-KSharedPtr<Macro> Manager::getMacro(const TQString& macroname)
+TDESharedPtr<Macro> Manager::getMacro(const TQString& macroname)
 {
 	return d->macros[macroname];
 }
 
-void Manager::addMacro(const TQString& macroname, KSharedPtr<Macro> macro)
+void Manager::addMacro(const TQString& macroname, TDESharedPtr<Macro> macro)
 {
 	d->macros.replace(macroname, macro);
 }
@@ -123,13 +123,13 @@ void Manager::removeMacro(const TQString& macroname)
 	d->macros.remove(macroname);
 }
 
-KSharedPtr<Macro> Manager::createMacro(const TQString& macroname)
+TDESharedPtr<Macro> Manager::createMacro(const TQString& macroname)
 {
-	KSharedPtr<Macro> macro = KSharedPtr<Macro>( new Macro(macroname) );
+	TDESharedPtr<Macro> macro = TDESharedPtr<Macro>( new Macro(macroname) );
 	return macro;
 }
 
-KSharedPtr<Action> Manager::action(const TQString& name) const
+TDESharedPtr<Action> Manager::action(const TQString& name) const
 {
 	return d->actions[name];
 }
@@ -144,7 +144,7 @@ TQStringList Manager::actionNames() const
 	return d->actionnames;
 }
 
-void Manager::publishAction(KSharedPtr<Action> action)
+void Manager::publishAction(TDESharedPtr<Action> action)
 {
 	const TQString name = action->name();
 	if(! d->actions.contains(name)) {
diff --git a/kexi/plugins/macros/lib/manager.h b/kexi/plugins/macros/lib/manager.h
index 733ffb75..5e3ce084 100644
--- a/kexi/plugins/macros/lib/manager.h
+++ b/kexi/plugins/macros/lib/manager.h
@@ -122,7 +122,7 @@ namespace KoMacro {
 			* \return the \a Macro defined with \p macroname
 			* or NULL if we don't have such a \a Macro.
 			*/
-			KSharedPtr<Macro> getMacro(const TQString& macroname);
+			TDESharedPtr<Macro> getMacro(const TQString& macroname);
 
 			/**
 			* Add a new \a Macro to the list of known macros. If
@@ -134,7 +134,7 @@ namespace KoMacro {
 			*        accessible as.
 			* \param macro The \a Macro instance.
 			*/
-			void addMacro(const TQString& macroname, KSharedPtr<Macro> macro);
+			void addMacro(const TQString& macroname, TDESharedPtr<Macro> macro);
 
 			/**
 			* Remove the \a Macro defined with \p macroname . If
@@ -150,7 +150,7 @@ namespace KoMacro {
 			* like to attach the returned new \a Macro to this
 			* \a Manager instance.
 			*/
-			KSharedPtr<Macro> createMacro(const TQString& macroname);
+			TDESharedPtr<Macro> createMacro(const TQString& macroname);
 
 #if 0
 			/**
@@ -164,20 +164,20 @@ namespace KoMacro {
 			*
 			* @deprecated Moved to common XMLReader/XMLWriter classes. Use Macro::xmlHandler() !
 			*/
-			KSharedPtr<Action> createAction(const TQDomElement& element);
+			TDESharedPtr<Action> createAction(const TQDomElement& element);
 #endif
 
 			/**
 			* @return the @a Action which was published under the
-			* name @p name or returns an empty @a KSharedPtr<Action> object
+			* name @p name or returns an empty @a TDESharedPtr<Action> object
 			* if there was no such @a Action published.
 			*/
-			KSharedPtr<Action> action(const TQString& name) const;
+			TDESharedPtr<Action> action(const TQString& name) const;
 
 			/**
 			* @return a map of all published actions.
 			*/
-			TQMap<TQString, KSharedPtr<Action> > actions() const;
+			TQMap<TQString, TDESharedPtr<Action> > actions() const;
 
 			/**
 			* @return a list of all published actions.
@@ -188,7 +188,7 @@ namespace KoMacro {
 			* Publish the @a Action @p action . The published @a Action
 			* will be accessible via it's unique name.
 			*/
-			void publishAction(KSharedPtr<Action> action);
+			void publishAction(TDESharedPtr<Action> action);
 
 			/**
 			* Publish the passed TQObject @p object. Those object will
diff --git a/kexi/plugins/macros/lib/metamethod.cpp b/kexi/plugins/macros/lib/metamethod.cpp
index 18839780..6642c706 100644
--- a/kexi/plugins/macros/lib/metamethod.cpp
+++ b/kexi/plugins/macros/lib/metamethod.cpp
@@ -70,7 +70,7 @@ namespace KoMacro {
 			* if this @a MetaMethod doesn't belong to any @a MetaObject
 			* yet.
 			*/
-			KSharedPtr<MetaObject> object;
+			TDESharedPtr<MetaObject> object;
 
 			/**
 			* The @a MetaMethod::Type this method provides access
@@ -81,8 +81,8 @@ namespace KoMacro {
 
 }
 
-MetaMethod::MetaMethod(const TQString& signature, Type type, KSharedPtr<MetaObject> object)
-	: KShared()
+MetaMethod::MetaMethod(const TQString& signature, Type type, TDESharedPtr<MetaObject> object)
+	: TDEShared()
 	, d( new Private() ) // create the private d-pointer instance.
 {
 	d->signature = signature;
@@ -135,7 +135,7 @@ MetaMethod::~MetaMethod()
 	delete d;
 }
 
-KSharedPtr<MetaObject> const MetaMethod::object() const
+TDESharedPtr<MetaObject> const MetaMethod::object() const
 {
 	return d->object;
 }
@@ -180,8 +180,8 @@ TQUObject* MetaMethod::toTQUObject(Variable::List arguments)
 	uo[0] = TQUObject(); // empty placeholder for the returnvalue.
 
 	for(uint i = 0; i < argsize; i++) {
-		KSharedPtr<MetaParameter> metaargument = d->arguments[i];
-		KSharedPtr<Variable> variable = arguments[i + 1];
+		TDESharedPtr<MetaParameter> metaargument = d->arguments[i];
+		TDESharedPtr<Variable> variable = arguments[i + 1];
 
 		if ( !variable ) {
 	 		throw Exception(TQString("Variable is undefined !"));
@@ -254,7 +254,7 @@ TQUObject* MetaMethod::toTQUObject(Variable::List arguments)
 	return uo;
 }
 
-KSharedPtr<Variable> MetaMethod::toVariable(TQUObject* uo)
+TDESharedPtr<Variable> MetaMethod::toVariable(TQUObject* uo)
 {
 	const TQString desc( uo->type->desc() );
 
@@ -303,16 +303,16 @@ Variable::List MetaMethod::toVariableList(TQUObject* uo)
 	return list;
 }
 
-KSharedPtr<Variable> MetaMethod::invoke(Variable::List arguments)
+TDESharedPtr<Variable> MetaMethod::invoke(Variable::List arguments)
 {
-	kdDebug() << "KSharedPtr<Variable> MetaMethod::invoke(Variable::List arguments)" << endl; 
+	kdDebug() << "TDESharedPtr<Variable> MetaMethod::invoke(Variable::List arguments)" << endl; 
 
 	if(! d->object) {
 		throw Exception("MetaObject is undefined.");
 	}
 
 	TQObject* obj = d->object->object();
-	KSharedPtr<Variable> returnvalue;
+	TDESharedPtr<Variable> returnvalue;
 	TQUObject* qu = 0;
 
 	try {
diff --git a/kexi/plugins/macros/lib/metamethod.h b/kexi/plugins/macros/lib/metamethod.h
index daf7dfcb..8be7b556 100644
--- a/kexi/plugins/macros/lib/metamethod.h
+++ b/kexi/plugins/macros/lib/metamethod.h
@@ -43,7 +43,7 @@ namespace KoMacro {
 	* The design tried to limit future porting to TQt4 by providing a
 	* somewhat similar API to the TQt4 TQMeta* stuff.
 	*/
-	class KOMACRO_EXPORT MetaMethod : public KShared
+	class KOMACRO_EXPORT MetaMethod : public TDEShared
 	{
 		public:
 
@@ -69,7 +69,7 @@ namespace KoMacro {
 			* belongs to. Each @a MethodMethod is associated with
 			* exactly one @a MetaObject .
 			*/
-			explicit MetaMethod(const TQString& signature, Type type = Unknown, KSharedPtr<MetaObject> object = 0);
+			explicit MetaMethod(const TQString& signature, Type type = Unknown, TDESharedPtr<MetaObject> object = 0);
 
 			/**
 			* Destructor.
@@ -80,7 +80,7 @@ namespace KoMacro {
 			* @return the @a MetaObject instance this @a MethodMethod
 			* belongs to.
 			*/
-			KSharedPtr<MetaObject> const object() const;
+			TDESharedPtr<MetaObject> const object() const;
 
 			/**
 			* @return the signature this @a MetaMethod has. It could
@@ -112,31 +112,31 @@ namespace KoMacro {
 			* @return the signature arguments as parsed list of
 			* @a MetaParameter instances.
 			*/
-			TQValueList< KSharedPtr<MetaParameter> > arguments() const;
+			TQValueList< TDESharedPtr<MetaParameter> > arguments() const;
 
 			/**
 			* Translate the passed @p arguments list of @a Variable instances
 			* into a TQt3 TQUObject* array.
 			*/
-			TQUObject* toTQUObject(TQValueList< KSharedPtr<Variable> > arguments);
+			TQUObject* toTQUObject(TQValueList< TDESharedPtr<Variable> > arguments);
 
 			/**
 			* Translate the passed @p uo TQUObject reference into an internal used
 			* @a Variable instances.
 			*/
-			KSharedPtr<Variable> toVariable(TQUObject* uo);
+			TDESharedPtr<Variable> toVariable(TQUObject* uo);
 
 			/**
 			* Translate the passed @p uo TQUObject array into an internal used
 			* list of @a Variable instances.
 			*/
-			TQValueList< KSharedPtr<Variable> > toVariableList(TQUObject* uo);
+			TQValueList< TDESharedPtr<Variable> > toVariableList(TQUObject* uo);
 
 			/**
 			* Invoke the @a MetaMethod with the optional arguments
 			* @p arguments and return a variable.
 			*/
-			KSharedPtr<Variable> invoke(TQValueList< KSharedPtr<Variable> > arguments);
+			TDESharedPtr<Variable> invoke(TQValueList< TDESharedPtr<Variable> > arguments);
 
 		private:
 			/// @internal d-pointer class.
diff --git a/kexi/plugins/macros/lib/metaobject.cpp b/kexi/plugins/macros/lib/metaobject.cpp
index ee865c82..deaf4974 100644
--- a/kexi/plugins/macros/lib/metaobject.cpp
+++ b/kexi/plugins/macros/lib/metaobject.cpp
@@ -56,7 +56,7 @@ namespace KoMacro {
 }
 
 MetaObject::MetaObject(TQObject* const object)
-	: KShared()
+	: TDEShared()
 	, d( new Private(object) ) // create the private d-pointer instance.
 {
 }
@@ -106,7 +106,7 @@ int MetaObject::indexOfSlot(const char* slot) const
 	return slotid;
 }
 
-KSharedPtr<MetaMethod> MetaObject::method(int index)
+TDESharedPtr<MetaMethod> MetaObject::method(int index)
 {
 	TQObject* obj = object();
 	MetaMethod::Type type = MetaMethod::Slot;
@@ -131,20 +131,20 @@ KSharedPtr<MetaMethod> MetaObject::method(int index)
 	return new MetaMethod(metadata->name, type, this);
 }
 
-KSharedPtr<MetaMethod> MetaObject::signal(const char* signal)
+TDESharedPtr<MetaMethod> MetaObject::signal(const char* signal)
 {
 	return method( indexOfSignal(signal) );
 }
 
-KSharedPtr<MetaMethod> MetaObject::slot(const char* slot)
+TDESharedPtr<MetaMethod> MetaObject::slot(const char* slot)
 {
 	return method( indexOfSlot(slot) );
 }
 
-KSharedPtr<Variable> MetaObject::invokeMethod(int index, Variable::List arguments)
+TDESharedPtr<Variable> MetaObject::invokeMethod(int index, Variable::List arguments)
 {
 	// kdDebug() << "MetaObject::invokeMethod(int index, Variable::List arguments)" << endl;
-	KSharedPtr<MetaMethod> m = method(index);
+	TDESharedPtr<MetaMethod> m = method(index);
 	// kdDebug() << "MetaObject::invokeMethod(int index, Variable::List arguments) return" << endl;
 	return m->invoke(arguments);
 }
diff --git a/kexi/plugins/macros/lib/metaobject.h b/kexi/plugins/macros/lib/metaobject.h
index a1a52562..e3ae98a1 100644
--- a/kexi/plugins/macros/lib/metaobject.h
+++ b/kexi/plugins/macros/lib/metaobject.h
@@ -38,7 +38,7 @@ namespace KoMacro {
 	* The design tried to limit future porting to TQt4 by providing a
 	* somewhat similar API to the TQt4 TQMeta* stuff.
 	*/
-	class KOMACRO_EXPORT MetaObject : public KShared
+	class KOMACRO_EXPORT MetaObject : public TDEShared
 	{
 		public:
 
@@ -78,19 +78,19 @@ namespace KoMacro {
 			* @return the @a MetaMethod that matches to the
 			* index @p index .
 			*/
-			KSharedPtr<MetaMethod> method(int index);
+			TDESharedPtr<MetaMethod> method(int index);
 
 			/**
 			* @return a @a MetaMethod for the signal @p signal .
 			*/
-			KSharedPtr<MetaMethod> signal(const char* signal);
+			TDESharedPtr<MetaMethod> signal(const char* signal);
 
 			/**
 			* @return a @a MetaMethod for the slot @p slot .
 			*/
-			KSharedPtr<MetaMethod> slot(const char* slot);
+			TDESharedPtr<MetaMethod> slot(const char* slot);
 
-//KSharedPtr<MetaMethod> addSlot(const char* slot);
+//TDESharedPtr<MetaMethod> addSlot(const char* slot);
 //void connectSignal(TQObject* obj, const char* signal);
 
 			/**
@@ -104,7 +104,7 @@ namespace KoMacro {
 			* @return The returnvalue the method provides and that got
 			* returned if the execution is done.
 			*/
-			KSharedPtr<Variable> invokeMethod(int index, TQValueList< KSharedPtr<Variable> > arguments);
+			TDESharedPtr<Variable> invokeMethod(int index, TQValueList< TDESharedPtr<Variable> > arguments);
 
 		private:
 			/// @internal d-pointer class.
diff --git a/kexi/plugins/macros/lib/metaparameter.cpp b/kexi/plugins/macros/lib/metaparameter.cpp
index ed921cfe..68a48fc1 100644
--- a/kexi/plugins/macros/lib/metaparameter.cpp
+++ b/kexi/plugins/macros/lib/metaparameter.cpp
@@ -58,7 +58,7 @@ namespace KoMacro {
 }
 
 MetaParameter::MetaParameter(const TQString& signatureargument)
-	: KShared()
+	: TDEShared()
 	, d( new Private() ) // create the private d-pointer instance.
 {
 	d->type = TypeNone;
@@ -137,7 +137,7 @@ void MetaParameter::setSignatureArgument(const TQString& signatureargument)
 	}
 }
 
-bool MetaParameter::validVariable(KSharedPtr<Variable> variable) const
+bool MetaParameter::validVariable(TDESharedPtr<Variable> variable) const
 {
 	if( type() != variable->type() ) {
 		return false;
diff --git a/kexi/plugins/macros/lib/metaparameter.h b/kexi/plugins/macros/lib/metaparameter.h
index fa9df552..ec927c53 100644
--- a/kexi/plugins/macros/lib/metaparameter.h
+++ b/kexi/plugins/macros/lib/metaparameter.h
@@ -39,7 +39,7 @@ namespace KoMacro {
 	* The design tried to limit future porting to TQt4 by providing a
 	* somewhat similar API to the TQt4 TQMeta* stuff.
 	*/
-	class KOMACRO_EXPORT MetaParameter : public KShared
+	class KOMACRO_EXPORT MetaParameter : public TDEShared
 	{
 
 			/**
@@ -57,7 +57,7 @@ namespace KoMacro {
 			/**
 			* List of @a MetaParameter instances.
 			*/
-			typedef TQValueList<KSharedPtr <MetaParameter > > List;
+			typedef TQValueList<TDESharedPtr <MetaParameter > > List;
 
 			/**
 			* Constructor.
@@ -114,7 +114,7 @@ namespace KoMacro {
 			* valid for this @a MetaParameter . Valid means, that
 			* the variable has a castable type.
 			*/
-			bool validVariable(KSharedPtr<Variable> variable) const;
+			bool validVariable(TDESharedPtr<Variable> variable) const;
 
 		protected:
 
diff --git a/kexi/plugins/macros/lib/variable.cpp b/kexi/plugins/macros/lib/variable.cpp
index 3661ef9a..61e349df 100644
--- a/kexi/plugins/macros/lib/variable.cpp
+++ b/kexi/plugins/macros/lib/variable.cpp
@@ -218,7 +218,7 @@ Variable::List Variable::children() const
 	return d->children;
 }
 
-void Variable::appendChild(KSharedPtr<Variable> variable)
+void Variable::appendChild(TDESharedPtr<Variable> variable)
 {
 	d->children.append(variable);
 }
diff --git a/kexi/plugins/macros/lib/variable.h b/kexi/plugins/macros/lib/variable.h
index 14adf09c..cb7334aa 100644
--- a/kexi/plugins/macros/lib/variable.h
+++ b/kexi/plugins/macros/lib/variable.h
@@ -32,7 +32,7 @@ namespace KoMacro {
 	/**
 	* A variable value used to provide abstract access to variables. The
 	* class handles TQVariant and TQObject and provides access to them.
-	* Variable inherits KShared and implements reference couting. So, it's
+	* Variable inherits TDEShared and implements reference couting. So, it's
 	* not needed to take care of memory-managment.
 	*/
 	class KOMACRO_EXPORT Variable : public MetaParameter
@@ -58,12 +58,12 @@ namespace KoMacro {
 			/**
 			* A list of variables.
 			*/
-			typedef TQValueList<KSharedPtr<Variable > > List;
+			typedef TQValueList<TDESharedPtr<Variable > > List;
 
 			/**
 			* A map of variables.
 			*/
-			typedef TQMap<TQString, KSharedPtr<Variable > > Map;
+			typedef TQMap<TQString, TDESharedPtr<Variable > > Map;
 
 			/**
 			* Default constructor.
@@ -185,7 +185,7 @@ namespace KoMacro {
 			* Append a @a Variable to the list of children this
 			* @a Variable has.
 			*/
-			void appendChild(KSharedPtr<Variable> variable);
+			void appendChild(TDESharedPtr<Variable> variable);
 
 			/**
 			* Clear the list of children this @a Variable has.
diff --git a/kexi/plugins/macros/lib/xmlhandler.cpp b/kexi/plugins/macros/lib/xmlhandler.cpp
index 5b53d51b..65f1a4cf 100644
--- a/kexi/plugins/macros/lib/xmlhandler.cpp
+++ b/kexi/plugins/macros/lib/xmlhandler.cpp
@@ -99,7 +99,7 @@ bool XMLHandler::parseXML(const TQDomElement& element)
 			const TQDomElement itemelem = itemnode.toElement();
 
 			// Create a new MacroItem
-			KSharedPtr<MacroItem> item = new MacroItem();
+			TDESharedPtr<MacroItem> item = new MacroItem();
 
 			// Add the new item to our Macro.
 			d->macro->addItem( item );
@@ -107,7 +107,7 @@ bool XMLHandler::parseXML(const TQDomElement& element)
 			// Each MacroItem may point to an Action instance. We
 			// try to determinate this action now and if it's defined
 			// and available, we set it.
-			KSharedPtr<Action> action = Manager::self()->action( itemelem.attribute("action") );
+			TDESharedPtr<Action> action = Manager::self()->action( itemelem.attribute("action") );
 			if(action.data()) {
 				item->setAction(action);
 			}
@@ -157,14 +157,14 @@ TQDomElement XMLHandler::toXML()
 	//macroelem.setAttribute("name",d->macro->name());
 
 	// The list of MacroItem-children a Macro provides.
-	TQValueList<KSharedPtr<MacroItem > > items = d->macro->items();
+	TQValueList<TDESharedPtr<MacroItem > > items = d->macro->items();
 
 	// Create an iterator...
-	TQValueList<KSharedPtr<MacroItem > >::ConstIterator it(items.constBegin()), end(items.constEnd());
+	TQValueList<TDESharedPtr<MacroItem > >::ConstIterator it(items.constBegin()), end(items.constEnd());
 	// ...and iterate over the list of children the Macro provides.
 	for(;it != end; ++it) {
 		// We are iterating over MacroItem instances.
-		KSharedPtr<MacroItem> item = *it;
+		TDESharedPtr<MacroItem> item = *it;
 
 		// Flag to determinate if we really need to remember this item what
 		// is only the case if comment or action is defined.
@@ -174,7 +174,7 @@ TQDomElement XMLHandler::toXML()
 		TQDomElement itemelem = document.createElement("item");
 
 		// Each MacroItem could point to an Action provided by the Manager.
-		const KSharedPtr<Action> action = item->action();
+		const TDESharedPtr<Action> action = item->action();
 		if( action ) {
 			append = true;
 
@@ -184,10 +184,10 @@ TQDomElement XMLHandler::toXML()
 			// Each MacroItem could have a list of variables. We
 			// iterate through that list and build a element
 			// for each single variable.
-			TQMap<TQString, KSharedPtr<Variable > > varmap = item->variables();
+			TQMap<TQString, TDESharedPtr<Variable > > varmap = item->variables();
 
-			for(TQMap<TQString, KSharedPtr<Variable > >::ConstIterator vit = varmap.constBegin(); vit != varmap.constEnd(); ++vit) {
-				const KSharedPtr<Variable> v = vit.data();
+			for(TQMap<TQString, TDESharedPtr<Variable > >::ConstIterator vit = varmap.constBegin(); vit != varmap.constEnd(); ++vit) {
+				const TDESharedPtr<Variable> v = vit.data();
 				if(! v.data()) {
 					// skip if the variable is NULL.
 					continue;
diff --git a/kexi/plugins/macros/tests/actiontests.cpp b/kexi/plugins/macros/tests/actiontests.cpp
index 26e38b32..912d9ff3 100644
--- a/kexi/plugins/macros/tests/actiontests.cpp
+++ b/kexi/plugins/macros/tests/actiontests.cpp
@@ -73,11 +73,11 @@ namespace KoMacroTest {
 
 		TQDomDocument* doomdocument;
 		
-		KSharedPtr<KoMacro::Macro> macro;
+		TDESharedPtr<KoMacro::Macro> macro;
 
-		TQValueList< KSharedPtr<KoMacro::MacroItem> > items;
+		TQValueList< TDESharedPtr<KoMacro::MacroItem> > items;
 
-		KSharedPtr<KoMacro::Action> actionptr;
+		TDESharedPtr<KoMacro::Action> actionptr;
 
 		Private()
 			: xmlguiclient(0)
@@ -90,7 +90,7 @@ namespace KoMacroTest {
 	};
 }
 
-typedef TQValueList< KSharedPtr<KoMacro::MacroItem> >::size_type sizetype;
+typedef TQValueList< TDESharedPtr<KoMacro::MacroItem> >::size_type sizetype;
 
 
 ActionTests::ActionTests()
@@ -147,7 +147,7 @@ void ActionTests::testMacro()
 	kdDebug()<<"===================== testMacro() ======================" << endl;
 	
 	//fetch Items and ..
-	//TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
+	//TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
 
 	//... check that there is one
 	KOMACROTEST_XASSERT( d->items.count(), sizetype(0) );
@@ -158,7 +158,7 @@ void ActionTests::testAction()
 	kdDebug()<<"===================== testAction() ======================" << endl;
 
 	//get it
-	//KSharedPtr<KoMacro::Action> actionptr = d->items[0]->action();
+	//TDESharedPtr<KoMacro::Action> actionptr = d->items[0]->action();
 	//-> check that it is not null
 	KOMACROTEST_XASSERT(sizetype(d->actionptr.data()), sizetype(0));
 }
@@ -167,7 +167,7 @@ void ActionTests::testText()
 {
 	kdDebug()<<"===================== testText() ======================" << endl;		
 
-	//KSharedPtr<KoMacro::Action> actionptr = items[0]->action();
+	//TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();
 
 	const TQString leetSpeech = "']['3 $']['";
 	
@@ -184,7 +184,7 @@ void ActionTests::testName()
 {
 	kdDebug()<<"===================== testName() ======================" << endl;			
 
-	//KSharedPtr<KoMacro::Action> actionptr = items[0]->action();
+	//TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();
 
 	//check name
 	KOMACROTEST_ASSERT(d->actionptr->name(),TQString("testaction"));
@@ -198,7 +198,7 @@ void ActionTests::testComment()
 {
 	kdDebug()<<"===================== testComment() ======================" << endl;			
 
-	//KSharedPtr<KoMacro::Action> actionptr = items[0]->action();
+	//TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();
 
 	//check comment
 	KOMACROTEST_XASSERT(d->actionptr->comment(),TQString("No Comment!"));
diff --git a/kexi/plugins/macros/tests/commontests.cpp b/kexi/plugins/macros/tests/commontests.cpp
index 41234eca..9d43ac41 100644
--- a/kexi/plugins/macros/tests/commontests.cpp
+++ b/kexi/plugins/macros/tests/commontests.cpp
@@ -94,7 +94,7 @@ namespace KoMacroTest {
 
 }
 
-typedef TQValueList< KSharedPtr<KoMacro::MacroItem> >::size_type sizetype;
+typedef TQValueList< TDESharedPtr<KoMacro::MacroItem> >::size_type sizetype;
 
 CommonTests::CommonTests()
 	: KUnitTest::SlotTester()
@@ -164,7 +164,7 @@ void CommonTests::testAction()
 		
 	TQDomElement const domelement = d->doomdocument->documentElement();
 	
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	
 	//Is our XML parseable ?
 	KOMACROTEST_ASSERT(macro->parseXML(domelement),true);
@@ -172,19 +172,19 @@ void CommonTests::testAction()
 	//??
 	macro->execute(this);
 
-	//create list of KSharedPtr from the childs of the macro
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = macro->items();
+	//create list of TDESharedPtr from the childs of the macro
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = macro->items();
 	
 	
 	//check that there is one
 	KOMACROTEST_ASSERT( items.count(), sizetype(1) );
 	//fetch the first one
-	KSharedPtr<KoMacro::Action> actionptr = items[0]->action();
+	TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();
 	//How do we know that an action exist ?	
 	//-> check that it is not null
 	KOMACROTEST_XASSERT(sizetype(actionptr.data()), sizetype(0));
 	//fetch the "teststring"-variable
-	KSharedPtr<KoMacro::Variable> variableptr = actionptr->variable("teststring");
+	TDESharedPtr<KoMacro::Variable> variableptr = actionptr->variable("teststring");
 	//check that it is not null
 	KOMACROTEST_XASSERT(sizetype(variableptr.data()), sizetype(0));
 	//check that it is " "
@@ -249,7 +249,7 @@ void CommonTests::testAction()
 	
 	//commontests.cpp: In member function 'void KoMacroTest::CommonTests::testAction()':
 	//commontests.cpp:249: error: call of overloaded 'setVariable(const char [8], int)' is ambiguous
-	//../lib/macroitem.h:131: note: candidates are: TQStringList KoMacro::MacroItem::setVariable(const TQString&, KSharedPtr<KoMacro::Variable>)
+	//../lib/macroitem.h:131: note: candidates are: TQStringList KoMacro::MacroItem::setVariable(const TQString&, TDESharedPtr<KoMacro::Variable>)
 	//../lib/macroitem.h:137: note:                 TQStringList KoMacro::MacroItem::setVariable(const TQString&, const TQVariant&)
 
 	macroitem->setVariable("testint",(int) 0);
@@ -285,7 +285,7 @@ void CommonTests::testXmlhandler()
 	kdDebug()<<"===================== testXmlhandler() ======================" << endl;
 
 	// Local Init
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomElement domelement;
 
 	// Save old doomdocument
@@ -428,9 +428,9 @@ void CommonTests::testFunction()
 		"</function>"
 	));
 
-	//create an KomacroFunction  with our data, and put it into a KSharedPtr
-	KSharedPtr<KoMacro::Action> functionptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
-	//cast KSharedPtr to KoMacro-"Function"
+	//create an KomacroFunction  with our data, and put it into a TDESharedPtr
+	TDESharedPtr<KoMacro::Action> functionptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+	//cast TDESharedPtr to KoMacro-"Function"
 	KoMacro::Function* func = dynamic_cast<KoMacro::Function*>( functionptr.data() );
 		//check that function is not null
 	KOMACROTEST_XASSERT((int) func, 0);
@@ -449,12 +449,12 @@ void CommonTests::testFunction()
 	KOMACROTEST_ASSERT( TQString(func->slot()), TQString("myslot(const TQString&,int)") );
 
 	//create KoMacro-MetaObject from receiverObject
-	KSharedPtr<KoMacro::MetaObject> receivermetaobject = func->receiverObject();
+	TDESharedPtr<KoMacro::MetaObject> receivermetaobject = func->receiverObject();
 	//check that receivermetaobject.data is not null
 	KOMACROTEST_XASSERT((int) receivermetaobject.data(), 0);
 	
 	//create KoMacro-MetaMethod from receiverObject
-	KSharedPtr<KoMacro::MetaMethod> receivermetamethod = receivermetaobject->slot( func->slot().latin1() );
+	TDESharedPtr<KoMacro::MetaMethod> receivermetamethod = receivermetaobject->slot( func->slot().latin1() );
 	//check that receivermetamethod.data is not null
 	KOMACROTEST_XASSERT((int) receivermetamethod.data(), 0);
 
@@ -469,7 +469,7 @@ void CommonTests::testFunction()
 		// firstrun we have a TQString, secondrun we have an int
 		switch(i) {
 			case 0: { // returnvalue
-				KOMACROTEST_ASSERT(*it, KSharedPtr<KoMacro::Variable>(NULL));
+				KOMACROTEST_ASSERT(*it, TDESharedPtr<KoMacro::Variable>(NULL));
 			} break;
 			case 1: { // first parameter
 				//check first variable of func is the same as argument1
@@ -491,10 +491,10 @@ void CommonTests::testFunction()
 	KOMACROTEST_ASSERT( funcvariables.count(), uint(3) );
 
 	// check that the first argument (the returnvalue) is empty
-	KOMACROTEST_ASSERT( funcvariables[0], KSharedPtr<KoMacro::Variable>(NULL) );
+	KOMACROTEST_ASSERT( funcvariables[0], TDESharedPtr<KoMacro::Variable>(NULL) );
 	
 	//create a KoMacro-Variable-Ptr from first func argument
-	KSharedPtr<KoMacro::Variable> stringvar = funcvariables[1];
+	TDESharedPtr<KoMacro::Variable> stringvar = funcvariables[1];
 	//check that it is not null
 	KOMACROTEST_XASSERT((int) stringvar.data(),0);
 	//check via TQVariant type that stringvar is from Type Variant
@@ -505,7 +505,7 @@ void CommonTests::testFunction()
 	KOMACROTEST_ASSERT( stringvar->toString(), argument1 );
 
 	//create a KoMacro-Variable-Ptr from second func argument
-	KSharedPtr<KoMacro::Variable> intvar = funcvariables[2];
+	TDESharedPtr<KoMacro::Variable> intvar = funcvariables[2];
 	//check that it is not null	
 	KOMACROTEST_XASSERT((int) intvar.data(), 0);
 	//check via TQVariant type that stringvar is from Type Variant
@@ -516,7 +516,7 @@ void CommonTests::testFunction()
 	KOMACROTEST_ASSERT( intvar->toInt(), argument2 );
 
 	//returnvalue see testobject ....
-	KSharedPtr<KoMacro::Variable> funcreturnvalue = receivermetamethod->invoke( funcvariables );
+	TDESharedPtr<KoMacro::Variable> funcreturnvalue = receivermetamethod->invoke( funcvariables );
 	kdDebug() << "CommonTests::testFunction() RETURNVALUE =====> " << funcreturnvalue->toString() << endl;
 	KOMACROTEST_ASSERT( funcreturnvalue->toInt(), argument2 );
 
@@ -543,8 +543,8 @@ void CommonTests::testIntFunction()
 		"</function>"
 	));
 
-	//create an KomacroFunction  with our data, and put it into a KSharedPtr
-	KSharedPtr<KoMacro::Action> functionptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+	//create an KomacroFunction  with our data, and put it into a TDESharedPtr
+	TDESharedPtr<KoMacro::Action> functionptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
 	//Cast data to function
 	KoMacro::Function* func = dynamic_cast<KoMacro::Function*>( functionptr.data() );
 		//check that it is not null
@@ -573,8 +573,8 @@ void CommonTests::testDoubleFunction()
 		"</function>"
 	));
 
-	//create an KomacroFunction  with our data, and put it into a KSharedPtr
-	KSharedPtr<KoMacro::Action> functionptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+	//create an KomacroFunction  with our data, and put it into a TDESharedPtr
+	TDESharedPtr<KoMacro::Action> functionptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
 	//Cast data to function
 	KoMacro::Function* func = dynamic_cast<KoMacro::Function*>( functionptr.data() );
 		//check that it is not null
@@ -602,8 +602,8 @@ void CommonTests::testTQStringFunction()
 		"</function>"
 	));
 
-	//create an KomacroFunction with our data, and put it into a KSharedPtr
-	KSharedPtr<KoMacro::Action> functionptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+	//create an KomacroFunction with our data, and put it into a TDESharedPtr
+	TDESharedPtr<KoMacro::Action> functionptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
 	//Cast data to function
 	KoMacro::Function* func = dynamic_cast<KoMacro::Function*>( functionptr.data() );
 		//check that it is not null
@@ -621,7 +621,7 @@ void CommonTests::testMacro()
 
 	TQDomElement const domelement = d->doomdocument->documentElement();
 	
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	//Is our XML parseable ?
 	KOMACROTEST_ASSERT(macro->parseXML(domelement),true);
 
@@ -639,7 +639,7 @@ void CommonTests::testMacro()
 // 	));
 // 
 // 	//create Macro
-// // 	KSharedPtr<KoMacro::Action> macroptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+// // 	TDESharedPtr<KoMacro::Action> macroptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
 // 	//cast data to Macro
 // 	KoMacro::Macro* macro = dynamic_cast<KoMacro::Macro*>( macroptr.data() );
 	//check that it is not null
@@ -661,11 +661,11 @@ void CommonTests::testMacro()
 	 */
 	
 	//create list of KsharedPtr from the childs of the macro
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = macro->items();
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = macro->items();
 	//check that there is one
 	KOMACROTEST_ASSERT( items.count(), sizetype(1) );
 	//fetch the first one
-	KSharedPtr<KoMacro::Action> actionptr = items[0]->action();
+	TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();
 	//How do we know that an action exist ?	
 	//-> check that it is not null
 	KOMACROTEST_XASSERT(sizetype(actionptr.data()), sizetype(0));
@@ -677,7 +677,7 @@ void CommonTests::testMacro()
 //	KOMACROTEST_ASSERT( actionptr->comment(), TQString("") );
 /*
 	//fetch the second one
-	KSharedPtr<KoMacro::Action> myfuncptr = children[1];
+	TDESharedPtr<KoMacro::Action> myfuncptr = children[1];
 	//cast it to function
 	
                                                                                     KoMacro::Function* myfunc = dynamic_cast<KoMacro::Function*>( myfuncptr.data() );
@@ -700,12 +700,12 @@ void CommonTests::testMacro()
 	myfunc->activate();
 */	
 	//create another macro
-	KSharedPtr<KoMacro::Macro> yanMacro = KoMacro::Manager::self()->createMacro("testMacro2");
+	TDESharedPtr<KoMacro::Macro> yanMacro = KoMacro::Manager::self()->createMacro("testMacro2");
 	
 	KOMACROTEST_ASSERT(yanMacro->parseXML(domelement),true);
 	//create two more macros
-	//KSharedPtr<KoMacro::Action> yanActionptr2 = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
-	//KSharedPtr<KoMacro::Action> yanActionptr3 = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+	//TDESharedPtr<KoMacro::Action> yanActionptr2 = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+	//TDESharedPtr<KoMacro::Action> yanActionptr3 = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
 	
 	//check that they aren?t null
 	KOMACROTEST_XASSERT(sizetype(yanMacro.data()), sizetype(0));
@@ -713,7 +713,7 @@ void CommonTests::testMacro()
 	//KOMACROTEST_XASSERT((int) yanActionptr3.data(), 0);
 	
 	//create a list of the children from yanMacro
-	//TQValueList< KSharedPtr<KoMacro::Action> > yanChildren = yanMacro->children();
+	//TQValueList< TDESharedPtr<KoMacro::Action> > yanChildren = yanMacro->children();
 	//check that there are two
 	//KOMACROTEST_ASSERT(yanChildren.count(), uint(2));
 /*
@@ -769,7 +769,7 @@ void CommonTests::testDom() {
 		"</function>"
 	));
 	//create functiom
-	KSharedPtr<KoMacro::Action> macroptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+	TDESharedPtr<KoMacro::Action> macroptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
 	//try to execute function and catch exception
 	KOMACROTEST_ASSERTEXCEPTION(KoMacro::Exception&, macroptr->activate());
 
@@ -853,21 +853,21 @@ void CommonTests::testVariables()
 	));
 
 	//create an macro
-	KSharedPtr<KoMacro::Action> macroptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
+	TDESharedPtr<KoMacro::Action> macroptr = ::KoMacro::Manager::self()->createAction( domdocument.documentElement() );
 	//cast data to macro
 	KoMacro::Macro* macro = dynamic_cast<KoMacro::Macro*>( macroptr.data() );
 		//check that it is not null
 	KOMACROTEST_XASSERT((int) macro, 0);
 		
 	//create a list of its children
-	TQValueList< KSharedPtr<KoMacro::Action> > children = macro->children();
+	TQValueList< TDESharedPtr<KoMacro::Action> > children = macro->children();
 	//Check that there are two children. The first child is always the returnvalue.
 	KOMACROTEST_ASSERT( children.count(), uint(2) );
 	//fetch the children
-	KSharedPtr<KoMacro::Action> func1ptr = children[1];
+	TDESharedPtr<KoMacro::Action> func1ptr = children[1];
 
 	//create new context
-	KSharedPtr<KoMacro::Context> context = new KoMacro::Context(macroptr);
+	TDESharedPtr<KoMacro::Context> context = new KoMacro::Context(macroptr);
 
 	{
 		//try to execute function with non-functional variable
@@ -882,7 +882,7 @@ void CommonTests::testVariables()
 		//execute function
 		func1ptr->activate(context);
 		//fetch return value
-		KSharedPtr<KoMacro::Variable> returnvariable = context->variable("$MyReturnVariable");
+		TDESharedPtr<KoMacro::Variable> returnvariable = context->variable("$MyReturnVariable");
 		//check that it is not null
 		KOMACROTEST_XASSERT( (int) returnvariable.data(), 0);
 		//check that it is "Some String"
@@ -895,7 +895,7 @@ void CommonTests::testVariables()
 		//execute function
 		func1ptr->activate(context);
 		//fetch return value
-		KSharedPtr<KoMacro::Variable> returnvariable = context->variable("$MyReturnVariable");
+		TDESharedPtr<KoMacro::Variable> returnvariable = context->variable("$MyReturnVariable");
 		//check that it is not null
 		KOMACROTEST_XASSERT( (int) returnvariable.data(), 0);
 		//check that it is 12345
diff --git a/kexi/plugins/macros/tests/macroitemtests.cpp b/kexi/plugins/macros/tests/macroitemtests.cpp
index 0ac780b0..044808d7 100644
--- a/kexi/plugins/macros/tests/macroitemtests.cpp
+++ b/kexi/plugins/macros/tests/macroitemtests.cpp
@@ -71,7 +71,7 @@ namespace KoMacroTest {
 
 		TQDomDocument* doomdocument;
 		
-		KSharedPtr<KoMacro::Macro> macro;
+		TDESharedPtr<KoMacro::Macro> macro;
 
 		Private()
 			: xmlguiclient(0)
@@ -83,7 +83,7 @@ namespace KoMacroTest {
 	};
 }
 
-typedef TQValueList< KSharedPtr<KoMacro::MacroItem> >::size_type sizetype;
+typedef TQValueList< TDESharedPtr<KoMacro::MacroItem> >::size_type sizetype;
 
 MacroitemTests::MacroitemTests()
 	: KUnitTest::SlotTester()
@@ -136,7 +136,7 @@ void MacroitemTests::testMacro()
 	kdDebug()<<"===================== testMacro() ======================" << endl;
 	
 	//fetch Items and ..
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
 
 	//... check that there is one
 	KOMACROTEST_XASSERT( items.count(), sizetype(0) );
@@ -148,9 +148,9 @@ void MacroitemTests::testMacroItemString()
 
 	kdDebug()<<"===================== testMacroItemString() ======================" << endl;	
 	
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
-	KSharedPtr<KoMacro::Action> actionptr = items[0]->action();
-	KSharedPtr<KoMacro::Variable> variableptr = actionptr->variable(TESTSTRING);
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
+	TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();
+	TDESharedPtr<KoMacro::Variable> variableptr = actionptr->variable(TESTSTRING);
 	
 	//create new macroitem for testing
 	KoMacro::MacroItem* macroitem = new KoMacro::MacroItem();
@@ -185,8 +185,8 @@ void MacroitemTests::testMacroItemInt()
 
 	kdDebug()<<"===================== testMacroItemInt() ======================" << endl;	
 
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
-	KSharedPtr<KoMacro::Action> actionptr = items[0]->action();	
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
+	TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();	
 	
 	//create new macroitem for testing
 	KoMacro::MacroItem* macroitem = new KoMacro::MacroItem();
@@ -195,7 +195,7 @@ void MacroitemTests::testMacroItemInt()
 	items.append(macroitem);
 
 	macroitem->setVariable(TESTINT,INT_MIN);
-	KSharedPtr<KoMacro::Variable> variableptr = macroitem->variable(TESTINT);
+	TDESharedPtr<KoMacro::Variable> variableptr = macroitem->variable(TESTINT);
 	KOMACROTEST_XASSERT(sizetype(variableptr.data()), sizetype(0));
 	KOMACROTEST_ASSERT(sizetype(variableptr->variant().toInt()),sizetype(INT_MIN));
 	
@@ -226,8 +226,8 @@ void MacroitemTests::testMacroItemBool()
 
 	kdDebug()<<"===================== testMacroItemBool() ======================" << endl;	
 
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
-	KSharedPtr<KoMacro::Action> actionptr = items[0]->action();	
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
+	TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();	
 	
 	//create new macroitem for testing
 	KoMacro::MacroItem* macroitem = new KoMacro::MacroItem();
@@ -236,7 +236,7 @@ void MacroitemTests::testMacroItemBool()
 	items.append(macroitem);
 
 	macroitem->setVariable(TESTBOOL,"false");
-	KSharedPtr<KoMacro::Variable> variableptr = macroitem->variable(TESTBOOL);
+	TDESharedPtr<KoMacro::Variable> variableptr = macroitem->variable(TESTBOOL);
 	KOMACROTEST_XASSERT(sizetype(variableptr.data()), sizetype(0));
 	KOMACROTEST_ASSERT(variableptr->variant().toBool(),false);
 }
diff --git a/kexi/plugins/macros/tests/macrotests.cpp b/kexi/plugins/macros/tests/macrotests.cpp
index d5d2c2af..7a5f30d0 100644
--- a/kexi/plugins/macros/tests/macrotests.cpp
+++ b/kexi/plugins/macros/tests/macrotests.cpp
@@ -83,7 +83,7 @@ namespace KoMacroTest {
 	};
 }
 
-typedef TQValueList< KSharedPtr<KoMacro::MacroItem> >::size_type sizetype;
+typedef TQValueList< TDESharedPtr<KoMacro::MacroItem> >::size_type sizetype;
 
 
 MacroTests::MacroTests()
@@ -136,8 +136,8 @@ void MacroTests::testMacro()
 
 	TQDomElement const domelement = d->doomdocument->documentElement();
 	
-	KSharedPtr<KoMacro::Macro> macro1 = KoMacro::Manager::self()->createMacro("testMacro");
-	KSharedPtr<KoMacro::Macro> macro2 = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro1 = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro2 = KoMacro::Manager::self()->createMacro("testMacro");
 	//Is our XML parseable ?
 	KOMACROTEST_ASSERT(macro1->parseXML(domelement),true);
 	KOMACROTEST_ASSERT(macro2->parseXML(domelement),true);
@@ -150,8 +150,8 @@ void MacroTests::testMacro()
 	KOMACROTEST_ASSERT(macro1->name(), macro2->name() );
 
 	//create list of KsharedPtr from the childs of the macro	
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items1 = macro1->items();
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items2 = macro2->items();
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items1 = macro1->items();
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items2 = macro2->items();
 	
 	//check that there is one
 	KOMACROTEST_XASSERT( items1.count(), sizetype(0) );	
@@ -174,7 +174,7 @@ void MacroTests::testMacro()
 	}
 	
 	//fetch the first one
-	KSharedPtr<KoMacro::Action> actionptr = items1[0]->action();
+	TDESharedPtr<KoMacro::Action> actionptr = items1[0]->action();
 	//check that it is not null
 	KOMACROTEST_XASSERT(sizetype(actionptr.data()), sizetype(0));
 	//check that it has the right name
diff --git a/kexi/plugins/macros/tests/testaction.cpp b/kexi/plugins/macros/tests/testaction.cpp
index 845acd5f..4e7bb67b 100644
--- a/kexi/plugins/macros/tests/testaction.cpp
+++ b/kexi/plugins/macros/tests/testaction.cpp
@@ -43,16 +43,16 @@ TestAction::~TestAction()
 {
 }
 
-bool TestAction::notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
+bool TestAction::notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name)
 {
 	Q_UNUSED(macroitem);
 	Q_UNUSED(name);
 	return true;
 }
 
-void TestAction::activate(KSharedPtr<KoMacro::Context> context)
+void TestAction::activate(TDESharedPtr<KoMacro::Context> context)
 {
-	kdDebug() << "TestAction::activate(KSharedPtr<Context>)" << endl;
+	kdDebug() << "TestAction::activate(TDESharedPtr<Context>)" << endl;
 	const TQString teststring = context->variable("teststring")->variant().toString();
 	const int  testint = context->variable("testint")->variant().toInt();
 	const bool testbool = context->variable("testbool")->variant().toBool();
diff --git a/kexi/plugins/macros/tests/testaction.h b/kexi/plugins/macros/tests/testaction.h
index 43ce74bb..bb41e5fb 100644
--- a/kexi/plugins/macros/tests/testaction.h
+++ b/kexi/plugins/macros/tests/testaction.h
@@ -63,7 +63,7 @@ namespace KoMacroTest {
 			* @return true if the update was successfully else false
 			* is returned.
 			*/
-			virtual bool notifyUpdated(KSharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
+			virtual bool notifyUpdated(TDESharedPtr<KoMacro::MacroItem> macroitem, const TQString& name);
 
 		public slots:
 
@@ -71,7 +71,7 @@ namespace KoMacroTest {
 			* Called if the @a Action should be executed within the
 			* defined @p context .
 			*/
-			virtual void activate(KSharedPtr<KoMacro::Context> context);
+			virtual void activate(TDESharedPtr<KoMacro::Context> context);
 
 	};
 }
diff --git a/kexi/plugins/macros/tests/variabletests.cpp b/kexi/plugins/macros/tests/variabletests.cpp
index c9724639..4efe3953 100644
--- a/kexi/plugins/macros/tests/variabletests.cpp
+++ b/kexi/plugins/macros/tests/variabletests.cpp
@@ -73,7 +73,7 @@ namespace KoMacroTest {
 
 		TQDomDocument* doomdocument;
 		
-		KSharedPtr<KoMacro::Macro> macro;
+		TDESharedPtr<KoMacro::Macro> macro;
 
 		Private()
 			: xmlguiclient(0)
@@ -85,7 +85,7 @@ namespace KoMacroTest {
 	};
 }
 
-typedef TQValueList< KSharedPtr<KoMacro::MacroItem> >::size_type sizetype;
+typedef TQValueList< TDESharedPtr<KoMacro::MacroItem> >::size_type sizetype;
 
 /******************************************************************************
 * This is an xtra big TODO: 
@@ -144,7 +144,7 @@ void VariableTests::testMacro()
 	kdDebug()<<"===================== testMacro() ======================" << endl;
 	
 	//fetch Items and ..
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();
 
 	//... check that there is one
 	KOMACROTEST_XASSERT( items.count(), sizetype(0) );
@@ -152,11 +152,11 @@ void VariableTests::testMacro()
 
 void VariableTests::testVariableString() {
 	kdDebug()<<"===================== testVariableString() ======================" << endl;			
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();	
-	KSharedPtr<KoMacro::Action> actionptr = items[0]->action();
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();	
+	TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();
 	
 	//fetch the "teststring"-variable
-	KSharedPtr<KoMacro::Variable> variableptr = actionptr->variable(TESTSTRING);	
+	TDESharedPtr<KoMacro::Variable> variableptr = actionptr->variable(TESTSTRING);	
 	//So there is a variable, does hasVariable() work ?
 	KOMACROTEST_ASSERT(actionptr->hasVariable(TESTSTRING),true);
 	//check count of variables
@@ -185,11 +185,11 @@ void VariableTests::testVariableString() {
 
 void VariableTests::testVariableInt() {
 	kdDebug()<<"===================== testVariableInt() ======================" << endl;			
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();	
-	KSharedPtr<KoMacro::Action> actionptr = items[0]->action();
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();	
+	TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();
 	
 	//fetch the "testint"-variable
-	KSharedPtr<KoMacro::Variable> variableptr = actionptr->variable(TESTINT);	
+	TDESharedPtr<KoMacro::Variable> variableptr = actionptr->variable(TESTINT);	
 	//check that it is not null
 	KOMACROTEST_XASSERT(sizetype(variableptr.data()), sizetype(0));
 	//check that it is 0
@@ -218,11 +218,11 @@ void VariableTests::testVariableInt() {
 
 void VariableTests::testVariableBool() {
 	kdDebug()<<"===================== testVariableBool() ======================" << endl;			
-	TQValueList< KSharedPtr<KoMacro::MacroItem> >& items = d->macro->items();	
-	KSharedPtr<KoMacro::Action> actionptr = items[0]->action();	
+	TQValueList< TDESharedPtr<KoMacro::MacroItem> >& items = d->macro->items();	
+	TDESharedPtr<KoMacro::Action> actionptr = items[0]->action();	
 	
 	//fetch the "testbool"-variable
-	KSharedPtr<KoMacro::Variable> variableptr = actionptr->variable(TESTBOOL);	
+	TDESharedPtr<KoMacro::Variable> variableptr = actionptr->variable(TESTBOOL);	
 	//check that it is not null
 	KOMACROTEST_XASSERT(sizetype(variableptr.data()), sizetype(0));
 	//check that it is " "
diff --git a/kexi/plugins/macros/tests/xmlhandlertests.cpp b/kexi/plugins/macros/tests/xmlhandlertests.cpp
index 9627a00b..971c85db 100644
--- a/kexi/plugins/macros/tests/xmlhandlertests.cpp
+++ b/kexi/plugins/macros/tests/xmlhandlertests.cpp
@@ -61,7 +61,7 @@ namespace KoMacroTest {
 		* handling and communication with from TQObject
 		* inheritated instances.
 		*/
-		KSharedPtr<KoMacro::Action> testaction;
+		TDESharedPtr<KoMacro::Action> testaction;
 
 		Private()
 			: xmlguiclient(0)
@@ -143,7 +143,7 @@ void XMLHandlerTests::testParseAndToXML()
 void XMLHandlerTests::testCorrectDomElement()
 {
 	// Local Init
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	// Part 1: From XML to a Macro.
@@ -184,7 +184,7 @@ void XMLHandlerTests::testCorrectDomElement()
 // 2.Test - XML-document with bad root element.
 void XMLHandlerTests::testBadRoot()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -210,7 +210,7 @@ void XMLHandlerTests::testBadRoot()
 // 3.Test - XML-document with a missing Variable.
 void XMLHandlerTests::testMissingVariable()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -238,7 +238,7 @@ void XMLHandlerTests::testMissingVariable()
 // 4.Test - One more Variable in XML-Document.
 void XMLHandlerTests::testMoreVariables()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -270,7 +270,7 @@ void XMLHandlerTests::testMoreVariables()
 // 5.Test - XML-document with wrong macro-xmlversion.
 void XMLHandlerTests::testWrongVersion()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -297,7 +297,7 @@ void XMLHandlerTests::testWrongVersion()
 // 	or missing end tag.
 void XMLHandlerTests::testWrongXMLStruct()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -321,7 +321,7 @@ void XMLHandlerTests::testWrongXMLStruct()
 // 7.Test-XML-document with maximum field-size.
 void XMLHandlerTests::testMaxNum()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -351,7 +351,7 @@ void XMLHandlerTests::testMaxNum()
 // 8.Test-XML-document with maximum+1 field-size.
 void XMLHandlerTests::testMaxNum2()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -381,7 +381,7 @@ void XMLHandlerTests::testMaxNum2()
 // 9.Test-XML-document with minimum field-size.
 void XMLHandlerTests::testMinNum()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -411,7 +411,7 @@ void XMLHandlerTests::testMinNum()
 // 10.Test-XML-document with minimum+1 field-size.
 void XMLHandlerTests::testMinNum2()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -441,7 +441,7 @@ void XMLHandlerTests::testMinNum2()
 // 11.Test - With a to big number.
 void XMLHandlerTests::testBigNumber()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -471,7 +471,7 @@ void XMLHandlerTests::testBigNumber()
 // 12.Test - With two MacroItems.
 void XMLHandlerTests::testTwoMacroItems()
 {
-	KSharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
+	TDESharedPtr<KoMacro::Macro> macro = KoMacro::Manager::self()->createMacro("testMacro");
 	TQDomDocument doomdocument;
 
 	const TQString xml = TQString("<!DOCTYPE macros>"
@@ -517,15 +517,15 @@ void XMLHandlerTests::testTwoMacroItems()
 * @p isactionset Bool for expectation that the @a Action -names are equal.
 * @p isvariableok TQMap of Bools for comparing each @a Variable .
 */
-void XMLHandlerTests::assertMacroContentEqToXML(const KSharedPtr<KoMacro::Macro> macro,
+void XMLHandlerTests::assertMacroContentEqToXML(const TDESharedPtr<KoMacro::Macro> macro,
 	const TQDomElement& elem,
 	const bool isitemsempty,
 	const bool isactionset,
 	const TQMap<TQString, bool> isvariableok)
 {
 	// Make an Iterator over the MacroItems of the Macro.
-	const TQValueList<KSharedPtr<KoMacro::MacroItem > > macroitems = macro->items();
-	TQValueList<KSharedPtr<KoMacro::MacroItem > >::ConstIterator 
+	const TQValueList<TDESharedPtr<KoMacro::MacroItem > > macroitems = macro->items();
+	TQValueList<TDESharedPtr<KoMacro::MacroItem > >::ConstIterator 
 		mit(macroitems.constBegin()), end(macroitems.constEnd());
 
 	//1.comparison - Is the MacroItem-list empty?
@@ -545,7 +545,7 @@ void XMLHandlerTests::assertMacroContentEqToXML(const KSharedPtr<KoMacro::Macro>
 
 	// Iterate over the MacroItems and item-elements.
 	while(mit != end && ! itemnode.isNull()) {
-		const KSharedPtr<KoMacro::MacroItem> macroitem = *mit;
+		const TDESharedPtr<KoMacro::MacroItem> macroitem = *mit;
 		const TQDomElement itemelem = itemnode.toElement();
 		
 		//2.comparison - Is the Action-name equal?
@@ -563,12 +563,12 @@ void XMLHandlerTests::assertMacroContentEqToXML(const KSharedPtr<KoMacro::Macro>
 		}
 
 		// Go down to MacroItem->Variable and item->variable and compare them.
-		TQMap<TQString, KSharedPtr<KoMacro::Variable > > mvariables = macroitem->variables();
+		TQMap<TQString, TDESharedPtr<KoMacro::Variable > > mvariables = macroitem->variables();
 		TQDomNode varnode = itemelem.firstChild();
 
 		while ( ! varnode.isNull()) {
 			const TQDomElement varelem = varnode.toElement();
-			const KSharedPtr<KoMacro::Variable> varitem = mvariables.find(varelem.attribute("name")).data();
+			const TDESharedPtr<KoMacro::Variable> varitem = mvariables.find(varelem.attribute("name")).data();
 			
 			//3.comparison - Is the content of the Variable
 			// in the MacroItem and and item equal?
@@ -605,10 +605,10 @@ void XMLHandlerTests::assertMacroContentEqToXML(const KSharedPtr<KoMacro::Macro>
 }
 
 // Prints a TQMap of Variables to kdDebug().
-void XMLHandlerTests::printMvariables(const TQMap<TQString, KSharedPtr<KoMacro::Variable > > mvariables, const TQString s)
+void XMLHandlerTests::printMvariables(const TQMap<TQString, TDESharedPtr<KoMacro::Variable > > mvariables, const TQString s)
 {
 	//TQValueList<TQString>::ConstIterator kit (keys.constBegin()), end(keys.constEnd());
-	TQMap<TQString, KSharedPtr<KoMacro::Variable > >::ConstIterator mvit (mvariables.constBegin()), end(mvariables.constEnd());
+	TQMap<TQString, TDESharedPtr<KoMacro::Variable > >::ConstIterator mvit (mvariables.constBegin()), end(mvariables.constEnd());
 	while(mvit != end){
 		const KoMacro::Variable * v = *mvit;
 		kdDebug() << s << ": " << v->name() << endl;
diff --git a/kexi/plugins/macros/tests/xmlhandlertests.h b/kexi/plugins/macros/tests/xmlhandlertests.h
index 521f9ee5..062b24b1 100644
--- a/kexi/plugins/macros/tests/xmlhandlertests.h
+++ b/kexi/plugins/macros/tests/xmlhandlertests.h
@@ -77,14 +77,14 @@ namespace KoMacroTest {
 			* @p isactionset Bool for expectation that the @a Action -names are equal.
 			* @p isvariableok TQMap of Bools for comparing each @a Variable .
 			*/
-			void assertMacroContentEqToXML(const KSharedPtr<KoMacro::Macro> macro,
+			void assertMacroContentEqToXML(const TDESharedPtr<KoMacro::Macro> macro,
 				const TQDomElement& elem,
 				const bool isitemsempty,
 				const bool isactionset,
 				const TQMap<TQString, bool> isvariableok);
 
 			// Prints a TQMap of Variables to kdDebug().
-			void printMvariables(const TQMap<TQString, KSharedPtr<KoMacro::Variable > > mvariables, const TQString s);
+			void printMvariables(const TQMap<TQString, TDESharedPtr<KoMacro::Variable > > mvariables, const TQString s);
 
 			/** 
 			* Sub-methods of testParseXML() and testToXML().
diff --git a/kexi/plugins/macros/tests/xmlhandlertests2.cpp b/kexi/plugins/macros/tests/xmlhandlertests2.cpp
index cc38c077..8e990d11 100644
--- a/kexi/plugins/macros/tests/xmlhandlertests2.cpp
+++ b/kexi/plugins/macros/tests/xmlhandlertests2.cpp
@@ -59,39 +59,39 @@ namespace KoMacroTest {
 		/**
 		* @a Macro instance as a container for the macroitems;
 		*/
-		KSharedPtr<KoMacro::Macro> macro;		// container for manually created items
-		KSharedPtr<KoMacro::Macro> macro2;		// container for parsen items
-		KSharedPtr<KoMacro::Macro> macro3;		// container for parsen items after back-converting by toXML() and again parseXML()
+		TDESharedPtr<KoMacro::Macro> macro;		// container for manually created items
+		TDESharedPtr<KoMacro::Macro> macro2;		// container for parsen items
+		TDESharedPtr<KoMacro::Macro> macro3;		// container for parsen items after back-converting by toXML() and again parseXML()
 
 		/**
 		* An @a TestObject instance used internaly to test
 		* handling and communication with from TQObject
 		* inheritated instances.
 		*/
-		KSharedPtr<KoMacro::Action> testaction;
-		KSharedPtr<KoMacro::Action> action2;	// action of the parsen macro2
-		KSharedPtr<KoMacro::Action> action3;	// action of the parsen macro3
-		KSharedPtr<KoMacro::Action> testaction_2;	// for test12
-		KSharedPtr<KoMacro::Action> action2_2;	// action of the parsen macro2, for test12
-		KSharedPtr<KoMacro::Action> action3_2;	// action of the parsen macro3, for test12
+		TDESharedPtr<KoMacro::Action> testaction;
+		TDESharedPtr<KoMacro::Action> action2;	// action of the parsen macro2
+		TDESharedPtr<KoMacro::Action> action3;	// action of the parsen macro3
+		TDESharedPtr<KoMacro::Action> testaction_2;	// for test12
+		TDESharedPtr<KoMacro::Action> action2_2;	// action of the parsen macro2, for test12
+		TDESharedPtr<KoMacro::Action> action3_2;	// action of the parsen macro3, for test12
 
 		/**
 		* Represents a @a TQValuList of @a MacroItem which are parsen in the 
 		* correspondig @a Macro .
 		*/
-		TQValueList<KSharedPtr<KoMacro::MacroItem > > macroitems2;	// items of macro2
-		TQValueList<KSharedPtr<KoMacro::MacroItem > > macroitems3;	// items of macro3
+		TQValueList<TDESharedPtr<KoMacro::MacroItem > > macroitems2;	// items of macro2
+		TQValueList<TDESharedPtr<KoMacro::MacroItem > > macroitems3;	// items of macro3
 
 		/**
 		* @a MacroItem instances which ist fillen manually from the given XML
 		* and parsen by the @a XMLHandler over the XML.
 		*/
-		KSharedPtr<KoMacro::MacroItem> macroitem;	// created manually from XML
-		KSharedPtr<KoMacro::MacroItem> macroitem2;	// parsen from XML in macro2
-		KSharedPtr<KoMacro::MacroItem> macroitem3;	// parsen from XML in macro3
-		KSharedPtr<KoMacro::MacroItem> macroitem_2;	// created manually from XML, for test12
-		KSharedPtr<KoMacro::MacroItem> macroitem2_2;// parsen from XML in macro2, for test12
-		KSharedPtr<KoMacro::MacroItem> macroitem3_2;// parsen from XML in macro3, for test12
+		TDESharedPtr<KoMacro::MacroItem> macroitem;	// created manually from XML
+		TDESharedPtr<KoMacro::MacroItem> macroitem2;	// parsen from XML in macro2
+		TDESharedPtr<KoMacro::MacroItem> macroitem3;	// parsen from XML in macro3
+		TDESharedPtr<KoMacro::MacroItem> macroitem_2;	// created manually from XML, for test12
+		TDESharedPtr<KoMacro::MacroItem> macroitem2_2;// parsen from XML in macro2, for test12
+		TDESharedPtr<KoMacro::MacroItem> macroitem3_2;// parsen from XML in macro3, for test12
 
 		Private()
 			: xmlguiclient(0)
@@ -207,10 +207,10 @@ void XMLHandlerTests2::testCorrectDomElement()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -300,10 +300,10 @@ void XMLHandlerTests2::testBadRoot()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_XASSERT(d->macro2->parseXML(elem),true);
@@ -339,9 +339,9 @@ void XMLHandlerTests2::testMissingVariable()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
 		
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -425,11 +425,11 @@ void XMLHandlerTests2::testMoreVariables()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
-	KSharedPtr<KoMacro::Variable> varbla = 		d->macroitem->addVariable("testbla","somethingwrong");
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
+	TDESharedPtr<KoMacro::Variable> varbla = 		d->macroitem->addVariable("testbla","somethingwrong");
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -517,10 +517,10 @@ void XMLHandlerTests2::testWrongVersion()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_XASSERT(d->macro2->parseXML(elem),true);
@@ -559,10 +559,10 @@ void XMLHandlerTests2::testWrongXMLStruct()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_XASSERT(d->macro2->parseXML(elem),true);
@@ -599,10 +599,10 @@ void XMLHandlerTests2::testMaxNum()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(INT_MAX));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(DBL_MAX));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(INT_MAX));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(DBL_MAX));
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -687,10 +687,10 @@ void XMLHandlerTests2::testMaxNum2()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(INT_MAX+1));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(DBL_MAX+1));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(INT_MAX+1));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(DBL_MAX+1));
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -775,10 +775,10 @@ void XMLHandlerTests2::testMinNum()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(INT_MIN));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(DBL_MIN));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(INT_MIN));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(DBL_MIN));
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -863,10 +863,10 @@ void XMLHandlerTests2::testMinNum2()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(INT_MIN-1));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(DBL_MIN-1));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(INT_MIN-1));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(DBL_MIN-1));
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -951,10 +951,10 @@ void XMLHandlerTests2::testBigNumber()
 	d->macroitem->setAction(d->testaction);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	//TODO //KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0123456789012345678901234567890123456789));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	//TODO //TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0123456789012345678901234567890123456789));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
 	
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -1050,18 +1050,18 @@ void XMLHandlerTests2::testTwoMacroItems()
 	d->macroitem_2->setAction(d->testaction_2);
 
 	// Push the Variables into the macroitem.
-	KSharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
-	KSharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
-	KSharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
-	KSharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
-	KSharedPtr<KoMacro::Variable> varbla = 		d->macroitem->addVariable("testbla","somethingwrong");
+	TDESharedPtr<KoMacro::Variable> varstring = 	d->macroitem->addVariable("teststring",TQVariant("test_string"));
+	TDESharedPtr<KoMacro::Variable> varint = 		d->macroitem->addVariable("testint",TQVariant(0));
+	TDESharedPtr<KoMacro::Variable> varbool = 	d->macroitem->addVariable("testbool",TQVariant(true));
+	TDESharedPtr<KoMacro::Variable> vardouble = 	d->macroitem->addVariable("testdouble",TQVariant(0.6));
+	TDESharedPtr<KoMacro::Variable> varbla = 		d->macroitem->addVariable("testbla","somethingwrong");
 
 	// Push the Variables into the macroitem4.
-	KSharedPtr<KoMacro::Variable> varstring_2 = d->macroitem_2->addVariable("teststring",TQVariant("testString2"));
-	KSharedPtr<KoMacro::Variable> varint_2 = 	d->macroitem_2->addVariable("testint",TQVariant(4));
-	KSharedPtr<KoMacro::Variable> varbool_2 = 	d->macroitem_2->addVariable("testbool",TQVariant(false));
-	KSharedPtr<KoMacro::Variable> vardouble_2 = d->macroitem_2->addVariable("testdouble",TQVariant(0.7));
-	KSharedPtr<KoMacro::Variable> varbla_2 = 	d->macroitem_2->addVariable("testbla","somethingwrong2");
+	TDESharedPtr<KoMacro::Variable> varstring_2 = d->macroitem_2->addVariable("teststring",TQVariant("testString2"));
+	TDESharedPtr<KoMacro::Variable> varint_2 = 	d->macroitem_2->addVariable("testint",TQVariant(4));
+	TDESharedPtr<KoMacro::Variable> varbool_2 = 	d->macroitem_2->addVariable("testbool",TQVariant(false));
+	TDESharedPtr<KoMacro::Variable> vardouble_2 = d->macroitem_2->addVariable("testdouble",TQVariant(0.7));
+	TDESharedPtr<KoMacro::Variable> varbla_2 = 	d->macroitem_2->addVariable("testbla","somethingwrong2");
 
 	// Is our XML parseable into a 2. Macro by calling parseXML()?
 	KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
@@ -1072,7 +1072,7 @@ void XMLHandlerTests2::testTwoMacroItems()
 	KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)2);
 
 	{
-		TQValueList<KSharedPtr<KoMacro::MacroItem > >::ConstIterator mit2(d->macroitems2.constBegin());
+		TQValueList<TDESharedPtr<KoMacro::MacroItem > >::ConstIterator mit2(d->macroitems2.constBegin());
 		// 2a.comparison - Test if the Action is correct?
 		d->macroitem2 = *mit2;
 		mit2++;
@@ -1111,7 +1111,7 @@ void XMLHandlerTests2::testTwoMacroItems()
 	KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)2);
 
 	{
-	TQValueList<KSharedPtr<KoMacro::MacroItem > >::ConstIterator mit3(d->macroitems3.constBegin());
+	TQValueList<TDESharedPtr<KoMacro::MacroItem > >::ConstIterator mit3(d->macroitems3.constBegin());
 		// 2b.comparison - Test if the Action is correct?
 		d->macroitem3 = *mit3;
 		mit3++;
@@ -1145,14 +1145,14 @@ void XMLHandlerTests2::testTwoMacroItems()
 * End of Sub-methos of testParseAndToXML2().
 ***************************************************************************/
 
-bool XMLHandlerTests2::assertActionsEqual(KSharedPtr<KoMacro::Action> action,
-	KSharedPtr<KoMacro::Action> action2)
+bool XMLHandlerTests2::assertActionsEqual(TDESharedPtr<KoMacro::Action> action,
+	TDESharedPtr<KoMacro::Action> action2)
 {
 	return action->name() == action2->name();
 }
 
-bool XMLHandlerTests2::assertVariablesEqual(KSharedPtr<KoMacro::Variable> var,
-	KSharedPtr<KoMacro::Variable> var2)
+bool XMLHandlerTests2::assertVariablesEqual(TDESharedPtr<KoMacro::Variable> var,
+	TDESharedPtr<KoMacro::Variable> var2)
 {
 	if ( var->variant() != var2->variant() ) kdDebug() << "Variable1: " << var->variant() << " and Variable2: " << var2->variant() << endl;
 	return var->variant() == var2->variant();
diff --git a/kexi/plugins/macros/tests/xmlhandlertests2.h b/kexi/plugins/macros/tests/xmlhandlertests2.h
index 376d7b08..3fd59609 100644
--- a/kexi/plugins/macros/tests/xmlhandlertests2.h
+++ b/kexi/plugins/macros/tests/xmlhandlertests2.h
@@ -70,7 +70,7 @@ namespace KoMacroTest {
 			Private* const d;
 
 			typedef TQMap<TQString,KoMacro::Variable>::size_type sizetypemap;
-			typedef TQValueList<KSharedPtr<KoMacro::MacroItem > >::size_type sizetypelist;
+			typedef TQValueList<TDESharedPtr<KoMacro::MacroItem > >::size_type sizetypelist;
 
 			/** 
 			* Compares a XML-Element with a Macro. Call sub-asserts.
@@ -80,14 +80,14 @@ namespace KoMacroTest {
 			* @p isactionset Bool for expectation that the @a Action -names are equal.
 			* @p isvariableok TQMap of Bools for comparing each @a Variable .
 			*/
-/*			void assertMacroContentEqToXML(const KSharedPtr<KoMacro::Macro> macro,
+/*			void assertMacroContentEqToXML(const TDESharedPtr<KoMacro::Macro> macro,
 				const TQDomElement& elem,
 				const bool isitemsempty,
 				const bool isactionset,
 				const TQMap<TQString, bool> isvariableok);
 
 			// Prints a TQMap of Variables to kdDebug().
-			void printMvariables(const TQMap<TQString, KSharedPtr<KoMacro::Variable > > mvariables, const TQString s);
+			void printMvariables(const TQMap<TQString, TDESharedPtr<KoMacro::Variable > > mvariables, const TQString s);
 */
 			/** 
 			* Sub-methods of testParseXML() and testToXML().
@@ -122,11 +122,11 @@ namespace KoMacroTest {
 			void testTwoMacroItems();
 
 
-			bool assertActionsEqual(KSharedPtr<KoMacro::Action> action,
-				KSharedPtr<KoMacro::Action> action2);
+			bool assertActionsEqual(TDESharedPtr<KoMacro::Action> action,
+				TDESharedPtr<KoMacro::Action> action2);
 
-			bool assertVariablesEqual(KSharedPtr<KoMacro::Variable> var,
-				KSharedPtr<KoMacro::Variable> var2);
+			bool assertVariablesEqual(TDESharedPtr<KoMacro::Variable> var,
+				TDESharedPtr<KoMacro::Variable> var2);
 	};
 }
 
diff --git a/kexi/plugins/scripting/kexidb/kexidbconnection.h b/kexi/plugins/scripting/kexidb/kexidbconnection.h
index 925a6e8e..846f2b2c 100644
--- a/kexi/plugins/scripting/kexidb/kexidbconnection.h
+++ b/kexi/plugins/scripting/kexidb/kexidbconnection.h
@@ -180,8 +180,8 @@ namespace Kross { namespace KexiDB {
             ::KexiDB::Connection* connection() const;
             ::KexiDB::Connection* m_connection;
 
-            KSharedPtr<KexiDBConnectionData> m_connectiondata;
-            KSharedPtr<KexiDBDriver> m_driver;
+            TDESharedPtr<KexiDBConnectionData> m_connectiondata;
+            TDESharedPtr<KexiDBDriver> m_driver;
 
             /// Initialize the class instance.
             void initialize();