rename the following methods:

tqparent parent
tqmask mask


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

55 files changed, 198 insertions, 198 deletions

diff --git a/kcachegrind/kcachegrind/callgraphview.cpp b/kcachegrind/kcachegrind/callgraphview.cpp
index 4135f6b4..5fc8dbb3 100644
--- a/kcachegrind/kcachegrind/callgraphview.cpp
+++ b/kcachegrind/kcachegrind/callgraphview.cpp
@@ -963,8 +963,8 @@ void GraphExporter::buildGraph(TraceFunction* f, int d,
 //
 // PannerView
 //
-PannerView::PannerView(TQWidget * tqparent, const char * name)
-  : TQCanvasView(tqparent, name, WNoAutoErase | WStaticContents)
+PannerView::PannerView(TQWidget * parent, const char * name)
+  : TQCanvasView(parent, name, WNoAutoErase | WStaticContents)
 {
   _movingZoomRect = false;
 
@@ -1368,8 +1368,8 @@ void CallGraphTip::maybeTip( const TQPoint& pos )
 // CallGraphView
 //
 CallGraphView::CallGraphView(TraceItemView* parentView,
-                             TQWidget* tqparent, const char* name)
-  : TQCanvasView(tqparent, name), TraceItemView(parentView)
+                             TQWidget* parent, const char* name)
+  : TQCanvasView(parent, name), TraceItemView(parentView)
 {
     _zoomPosition = DEFAULT_ZOOMPOS;
     _lastAutoPosition = TopLeft;
diff --git a/kcachegrind/kcachegrind/callgraphview.h b/kcachegrind/kcachegrind/callgraphview.h
index f2e567c1..631c6a30 100644
--- a/kcachegrind/kcachegrind/callgraphview.h
+++ b/kcachegrind/kcachegrind/callgraphview.h
@@ -287,7 +287,7 @@ class PannerView: public TQCanvasView
   TQ_OBJECT
 
 public:
-  PannerView(TQWidget * tqparent = 0, const char * name = 0);
+  PannerView(TQWidget * parent = 0, const char * name = 0);
 
   void setZoomRect(TQRect r);
 
@@ -423,7 +423,7 @@ public:
  enum ZoomPosition { TopLeft, TopRight, BottomLeft, BottomRight, Auto };
 
   CallGraphView(TraceItemView* parentView,
-                TQWidget* tqparent=0, const char* name=0);
+                TQWidget* parent=0, const char* name=0);
   ~CallGraphView();
 
   void readViewConfig(KConfig*, TQString prefix, TQString postfix, bool);
diff --git a/kcachegrind/kcachegrind/callitem.cpp b/kcachegrind/kcachegrind/callitem.cpp
index 3667f668..3a3a7266 100644
--- a/kcachegrind/kcachegrind/callitem.cpp
+++ b/kcachegrind/kcachegrind/callitem.cpp
@@ -34,8 +34,8 @@
 // CallItem
 
 
-CallItem::CallItem(CallView* view, TQListView* tqparent, TraceCall* c)
-    : TQListViewItem(tqparent)
+CallItem::CallItem(CallView* view, TQListView* parent, TraceCall* c)
+    : TQListViewItem(parent)
 {
   _call = c;
   _view = view;
diff --git a/kcachegrind/kcachegrind/callmapview.cpp b/kcachegrind/kcachegrind/callmapview.cpp
index 605e572e..3f363f29 100644
--- a/kcachegrind/kcachegrind/callmapview.cpp
+++ b/kcachegrind/kcachegrind/callmapview.cpp
@@ -51,8 +51,8 @@
 
 
 CallMapView::CallMapView(bool showCallers, TraceItemView* parentView,
-                         TQWidget* tqparent, const char* name)
-  : TreeMapWidget(new CallMapBaseItem(), tqparent, name),  TraceItemView(parentView)
+                         TQWidget* parent, const char* name)
+  : TreeMapWidget(new CallMapBaseItem(), parent, name),  TraceItemView(parentView)
 {
   _showCallers = showCallers;
 
@@ -116,7 +116,7 @@ TQString CallMapView::whatsThis() const
              "<em>very</em> time consuming, you may want to limit "
              "the maximum drawn nesting level before. "
              "'Best' determinates the split direction for tqchildren "
-             "from the aspect ratio of the tqparent. "
+             "from the aspect ratio of the parent. "
              "'Always Best' decides on remaining space for each "
              "sibling. "
              "'Ignore Proportions' takes space for function name "
@@ -171,7 +171,7 @@ void CallMapView::context(TreeMapItem* i,const TQPoint & p)
       if ((int)name.length()>Configuration::maxSymbolLength())
         name = name.left(Configuration::maxSymbolLength()) + "...";
       fpopup.insertItem(name, 101+count);
-      item = item->tqparent();
+      item = item->parent();
       count++;
     }
     popup.insertSeparator();
@@ -223,7 +223,7 @@ void CallMapView::context(TreeMapItem* i,const TQPoint & p)
         l2popup.setItemChecked(201+count, true);
         foundStopName = true;
       }
-      item = item->tqparent();
+      item = item->parent();
       count++;
     }
   }
@@ -326,7 +326,7 @@ void CallMapView::context(TreeMapItem* i,const TQPoint & p)
   if (r>100 && r<150) {
     r -= 100;
     while (i && (r>1)) {
-      i=i->tqparent();
+      i=i->parent();
       r--;
     }
     activatedSlot(i);
@@ -336,7 +336,7 @@ void CallMapView::context(TreeMapItem* i,const TQPoint & p)
   if (r>200 && r<250) {
     r -= 200;
     while (i && (r>1)) {
-      i=i->tqparent();
+      i=i->parent();
       r--;
     }
     if (i)
@@ -556,7 +556,7 @@ TQString CallMapView::tipString(TreeMapItem* i) const
     if (!tip.isEmpty()) tip += "\n";
 
     tip += itemTip;
-    i = i->tqparent();
+    i = i->parent();
     count++;
   }
   if (count == Configuration::maxSymbolCount()) tip += "\n...";
diff --git a/kcachegrind/kcachegrind/callmapview.h b/kcachegrind/kcachegrind/callmapview.h
index 67cecb6d..1ee45258 100644
--- a/kcachegrind/kcachegrind/callmapview.h
+++ b/kcachegrind/kcachegrind/callmapview.h
@@ -35,7 +35,7 @@ class CallMapView: public TreeMapWidget, public TraceItemView
 public:
 
   CallMapView(bool showCallers, TraceItemView* parentView,
-              TQWidget* tqparent=0, const char* name=0);
+              TQWidget* parent=0, const char* name=0);
 
   TQWidget* widget() { return this; }
   TQString whatsThis() const;
diff --git a/kcachegrind/kcachegrind/callview.cpp b/kcachegrind/kcachegrind/callview.cpp
index 11da69e4..2eb08f68 100644
--- a/kcachegrind/kcachegrind/callview.cpp
+++ b/kcachegrind/kcachegrind/callview.cpp
@@ -36,8 +36,8 @@
 
 
 CallView::CallView(bool showCallers, TraceItemView* parentView,
-		   TQWidget* tqparent, const char* name)
-  : TQListView(tqparent, name), TraceItemView(parentView)
+		   TQWidget* parent, const char* name)
+  : TQListView(parent, name), TraceItemView(parentView)
 {
     _showCallers = showCallers;
 
diff --git a/kcachegrind/kcachegrind/callview.h b/kcachegrind/kcachegrind/callview.h
index b18e6c3c..be644f97 100644
--- a/kcachegrind/kcachegrind/callview.h
+++ b/kcachegrind/kcachegrind/callview.h
@@ -34,7 +34,7 @@ class CallView: public TQListView, public TraceItemView
 
 public:
   CallView(bool showCallers, TraceItemView* parentView,
-	   TQWidget* tqparent=0, const char* name=0);
+	   TQWidget* parent=0, const char* name=0);
 
   virtual TQWidget* widget() { return this; }
   TQString whatsThis() const;
diff --git a/kcachegrind/kcachegrind/configdlg.cpp b/kcachegrind/kcachegrind/configdlg.cpp
index 4fa94f3a..7e56c686 100644
--- a/kcachegrind/kcachegrind/configdlg.cpp
+++ b/kcachegrind/kcachegrind/configdlg.cpp
@@ -38,8 +38,8 @@
 
 
 ConfigDlg::ConfigDlg(Configuration* c, TraceData* data,
-                     TQWidget* tqparent, const char* name)
-  :ConfigDlgBase(tqparent, name)
+                     TQWidget* parent, const char* name)
+  :ConfigDlgBase(parent, name)
 {
   _config = c;
   _data = data;
@@ -340,7 +340,7 @@ void ConfigDlg::dirsItemChanged(TQListViewItem* i)
 void ConfigDlg::dirsDeletePressed()
 {
   if (!_dirItem || (_dirItem->depth() == 0)) return;
-  TQListViewItem* p = _dirItem->tqparent();
+  TQListViewItem* p = _dirItem->parent();
   if (!p) return;
 
   Configuration* c = Configuration::config();
diff --git a/kcachegrind/kcachegrind/configdlg.h b/kcachegrind/kcachegrind/configdlg.h
index 58c9b80d..5ef6bab0 100644
--- a/kcachegrind/kcachegrind/configdlg.h
+++ b/kcachegrind/kcachegrind/configdlg.h
@@ -35,7 +35,7 @@ class ConfigDlg : public ConfigDlgBase
 
 public:
   ConfigDlg(Configuration*, TraceData*,
-            TQWidget* tqparent = 0, const char* name = 0);
+            TQWidget* parent = 0, const char* name = 0);
   ~ConfigDlg();
 
   static bool configure(Configuration*, TraceData*, TQWidget*);
diff --git a/kcachegrind/kcachegrind/costlistitem.cpp b/kcachegrind/kcachegrind/costlistitem.cpp
index 91caea4b..3129838a 100644
--- a/kcachegrind/kcachegrind/costlistitem.cpp
+++ b/kcachegrind/kcachegrind/costlistitem.cpp
@@ -33,9 +33,9 @@
 // CostListItem
 
 
-CostListItem::CostListItem(TQListView* tqparent, TraceCostItem* costItem,
+CostListItem::CostListItem(TQListView* parent, TraceCostItem* costItem,
                            TraceCostType* ct, int size)
-  :TQListViewItem(tqparent)
+  :TQListViewItem(parent)
 {
   _groupSize = size;
   _skipped = 0;
@@ -49,9 +49,9 @@ CostListItem::CostListItem(TQListView* tqparent, TraceCostItem* costItem,
   }
 }
 
-CostListItem::CostListItem(TQListView* tqparent, int skipped,
+CostListItem::CostListItem(TQListView* parent, int skipped,
 			   TraceCostItem* costItem, TraceCostType* ct)
-  :TQListViewItem(tqparent)
+  :TQListViewItem(parent)
 {
   _skipped = skipped;
   _costItem = costItem;
diff --git a/kcachegrind/kcachegrind/costlistitem.h b/kcachegrind/kcachegrind/costlistitem.h
index 369a0c74..99f654e1 100644
--- a/kcachegrind/kcachegrind/costlistitem.h
+++ b/kcachegrind/kcachegrind/costlistitem.h
@@ -25,10 +25,10 @@
 class CostListItem: public TQListViewItem
 {
 public:
-  CostListItem(TQListView* tqparent, TraceCostItem* cost,
+  CostListItem(TQListView* parent, TraceCostItem* cost,
                TraceCostType* ct, int size = -1);
   // entry with multiple skipped items
-  CostListItem(TQListView* tqparent, int skipped, TraceCostItem* cost,
+  CostListItem(TQListView* parent, int skipped, TraceCostItem* cost,
                TraceCostType* ct);
 
   int compare(TQListViewItem * i, int col, bool ascending ) const;
diff --git a/kcachegrind/kcachegrind/costtypeitem.cpp b/kcachegrind/kcachegrind/costtypeitem.cpp
index cf71a3a9..df5bf35a 100644
--- a/kcachegrind/kcachegrind/costtypeitem.cpp
+++ b/kcachegrind/kcachegrind/costtypeitem.cpp
@@ -31,9 +31,9 @@
 // CostTypeItem
 
 
-CostTypeItem::CostTypeItem(TQListView* tqparent, TraceCostItem* costItem,
+CostTypeItem::CostTypeItem(TQListView* parent, TraceCostItem* costItem,
                            TraceCostType* ct, TraceCost::CostType gt)
-  :TQListViewItem(tqparent)
+  :TQListViewItem(parent)
 {
   _costItem = costItem;
   _costType = ct;
diff --git a/kcachegrind/kcachegrind/costtypeitem.h b/kcachegrind/kcachegrind/costtypeitem.h
index 6bf60fa8..d34973db 100644
--- a/kcachegrind/kcachegrind/costtypeitem.h
+++ b/kcachegrind/kcachegrind/costtypeitem.h
@@ -30,7 +30,7 @@
 class CostTypeItem: public TQListViewItem
 {
 public:
-  CostTypeItem(TQListView* tqparent, TraceCostItem* costItem,
+  CostTypeItem(TQListView* parent, TraceCostItem* costItem,
                TraceCostType* ct, TraceCost::CostType gt);
 
   int compare(TQListViewItem * i, int col, bool ascending ) const;
diff --git a/kcachegrind/kcachegrind/costtypeview.cpp b/kcachegrind/kcachegrind/costtypeview.cpp
index ff69bf47..d4087eba 100644
--- a/kcachegrind/kcachegrind/costtypeview.cpp
+++ b/kcachegrind/kcachegrind/costtypeview.cpp
@@ -36,8 +36,8 @@
 
 
 CostTypeView::CostTypeView(TraceItemView* parentView,
-			   TQWidget* tqparent, const char* name)
-  : TQListView(tqparent, name), TraceItemView(parentView)
+			   TQWidget* parent, const char* name)
+  : TQListView(parent, name), TraceItemView(parentView)
 {
     addColumn( i18n( "Event Type" ) );
     addColumn( i18n( "Incl." ) );
diff --git a/kcachegrind/kcachegrind/costtypeview.h b/kcachegrind/kcachegrind/costtypeview.h
index 8940b3c7..ee9963e3 100644
--- a/kcachegrind/kcachegrind/costtypeview.h
+++ b/kcachegrind/kcachegrind/costtypeview.h
@@ -34,7 +34,7 @@ class CostTypeView: public TQListView, public TraceItemView
 
 public:
   CostTypeView(TraceItemView* parentView,
-	       TQWidget* tqparent=0, const char* name=0);
+	       TQWidget* parent=0, const char* name=0);
 
   virtual TQWidget* widget() { return this; }
   TQString whatsThis() const;
diff --git a/kcachegrind/kcachegrind/coverageitem.cpp b/kcachegrind/kcachegrind/coverageitem.cpp
index ab872f71..569359a8 100644
--- a/kcachegrind/kcachegrind/coverageitem.cpp
+++ b/kcachegrind/kcachegrind/coverageitem.cpp
@@ -32,11 +32,11 @@
 // CallerCoverageItem
 
 
-CallerCoverageItem::CallerCoverageItem(TQListView* tqparent, Coverage* c,
+CallerCoverageItem::CallerCoverageItem(TQListView* parent, Coverage* c,
                                        TraceFunction* base,
                                        TraceCostType* ct,
                                        TraceCost::CostType gt)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _skipped = 0;
   _coverage = c;
@@ -50,11 +50,11 @@ CallerCoverageItem::CallerCoverageItem(TQListView* tqparent, Coverage* c,
   setGroupType(gt);
 }
 
-CallerCoverageItem::CallerCoverageItem(TQListView* tqparent, int skipped, Coverage* c,
+CallerCoverageItem::CallerCoverageItem(TQListView* parent, int skipped, Coverage* c,
                                        TraceFunction* base,
                                        TraceCostType* ct,
                                        TraceCost::CostType gt)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _skipped = skipped;
   _coverage = c;
@@ -172,11 +172,11 @@ int CallerCoverageItem::compare(TQListViewItem * i,
 // CalleeCoverageItem
 
 
-CalleeCoverageItem::CalleeCoverageItem(TQListView* tqparent, Coverage* c,
+CalleeCoverageItem::CalleeCoverageItem(TQListView* parent, Coverage* c,
                                        TraceFunction* base,
                                        TraceCostType* ct,
                                        TraceCost::CostType gt)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _skipped = 0;
   _coverage = c;
@@ -190,11 +190,11 @@ CalleeCoverageItem::CalleeCoverageItem(TQListView* tqparent, Coverage* c,
   setGroupType(gt);
 }
 
-CalleeCoverageItem::CalleeCoverageItem(TQListView* tqparent, int skipped, Coverage* c,
+CalleeCoverageItem::CalleeCoverageItem(TQListView* parent, int skipped, Coverage* c,
                                        TraceFunction* base,
                                        TraceCostType* ct,
                                        TraceCost::CostType gt)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _skipped = skipped;
   _coverage = c;
diff --git a/kcachegrind/kcachegrind/coverageitem.h b/kcachegrind/kcachegrind/coverageitem.h
index 04da4305..ba442aa6 100644
--- a/kcachegrind/kcachegrind/coverageitem.h
+++ b/kcachegrind/kcachegrind/coverageitem.h
@@ -31,9 +31,9 @@ class Coverage;
 class CallerCoverageItem: public TQListViewItem
 {
 public:
-  CallerCoverageItem(TQListView* tqparent, Coverage* c, TraceFunction* base,
+  CallerCoverageItem(TQListView* parent, Coverage* c, TraceFunction* base,
                      TraceCostType* ct, TraceCost::CostType gt);
-  CallerCoverageItem(TQListView* tqparent, int skipped, Coverage* c, TraceFunction* base,
+  CallerCoverageItem(TQListView* parent, int skipped, Coverage* c, TraceFunction* base,
                      TraceCostType* ct, TraceCost::CostType gt);
 
   int compare(TQListViewItem * i, int col, bool ascending ) const;
@@ -57,9 +57,9 @@ private:
 class CalleeCoverageItem: public TQListViewItem
 {
 public:
-  CalleeCoverageItem(TQListView* tqparent, Coverage* c, TraceFunction* base,
+  CalleeCoverageItem(TQListView* parent, Coverage* c, TraceFunction* base,
                      TraceCostType* ct, TraceCost::CostType gt);
-  CalleeCoverageItem(TQListView* tqparent, int skipped, Coverage* c, TraceFunction* base,
+  CalleeCoverageItem(TQListView* parent, int skipped, Coverage* c, TraceFunction* base,
                      TraceCostType* ct, TraceCost::CostType gt);
 
   int compare(TQListViewItem * i, int col, bool ascending ) const;
diff --git a/kcachegrind/kcachegrind/coverageview.cpp b/kcachegrind/kcachegrind/coverageview.cpp
index ba6ce77f..6243d8af 100644
--- a/kcachegrind/kcachegrind/coverageview.cpp
+++ b/kcachegrind/kcachegrind/coverageview.cpp
@@ -37,8 +37,8 @@
 
 
 CoverageView::CoverageView(bool showCallers, TraceItemView* parentView,
-			   TQWidget* tqparent, const char* name)
-  : TQListView(tqparent, name), TraceItemView(parentView)
+			   TQWidget* parent, const char* name)
+  : TQListView(parent, name), TraceItemView(parentView)
 {
     _showCallers = showCallers;
 
diff --git a/kcachegrind/kcachegrind/coverageview.h b/kcachegrind/kcachegrind/coverageview.h
index 0be96e85..09c5de03 100644
--- a/kcachegrind/kcachegrind/coverageview.h
+++ b/kcachegrind/kcachegrind/coverageview.h
@@ -35,7 +35,7 @@ class CoverageView: public TQListView, public TraceItemView
 
 public:
   CoverageView(bool showCallers, TraceItemView* parentView,
-	       TQWidget* tqparent=0, const char* name=0);
+	       TQWidget* parent=0, const char* name=0);
 
   virtual TQWidget* widget() { return this; }
   TQString whatsThis() const;
diff --git a/kcachegrind/kcachegrind/dumpselection.cpp b/kcachegrind/kcachegrind/dumpselection.cpp
index 15027325..4d812ef9 100644
--- a/kcachegrind/kcachegrind/dumpselection.cpp
+++ b/kcachegrind/kcachegrind/dumpselection.cpp
@@ -20,8 +20,8 @@
 
 
 DumpSelection::DumpSelection( TopLevel* top,
-                              TQWidget* tqparent, const char* name)
-    : DumpSelectionBase(tqparent, name), TraceItemView(0, top)
+                              TQWidget* parent, const char* name)
+    : DumpSelectionBase(parent, name), TraceItemView(0, top)
 {
 }
 
diff --git a/kcachegrind/kcachegrind/dumpselection.h b/kcachegrind/kcachegrind/dumpselection.h
index b6bcddce..49ca532d 100644
--- a/kcachegrind/kcachegrind/dumpselection.h
+++ b/kcachegrind/kcachegrind/dumpselection.h
@@ -21,7 +21,7 @@ class DumpSelection : public DumpSelectionBase, public TraceItemView
   TQ_OBJECT
 
 public:
-  DumpSelection( TopLevel*, TQWidget* tqparent = 0, const char* name = 0);
+  DumpSelection( TopLevel*, TQWidget* parent = 0, const char* name = 0);
   virtual ~DumpSelection();
 
   TQWidget* widget() { return this; }
diff --git a/kcachegrind/kcachegrind/functionitem.cpp b/kcachegrind/kcachegrind/functionitem.cpp
index 5b70fd2e..9df7e651 100644
--- a/kcachegrind/kcachegrind/functionitem.cpp
+++ b/kcachegrind/kcachegrind/functionitem.cpp
@@ -37,9 +37,9 @@
 
 // FunctionItem
 
-FunctionItem::FunctionItem(TQListView* tqparent, TraceFunction* f,
+FunctionItem::FunctionItem(TQListView* parent, TraceFunction* f,
                            TraceCostType* ct, TraceCost::CostType gt)
-  :TQListViewItem(tqparent)
+  :TQListViewItem(parent)
 {
 #if 0
     _costPixValid = false;
@@ -56,9 +56,9 @@ FunctionItem::FunctionItem(TQListView* tqparent, TraceFunction* f,
     setText(4, f->prettyLocation());
 }
 
-FunctionItem::FunctionItem(TQListView* tqparent, int skipped,
+FunctionItem::FunctionItem(TQListView* parent, int skipped,
 			   TraceFunction* f, TraceCostType* ct)
-  :TQListViewItem(tqparent)
+  :TQListViewItem(parent)
 {
 #if 0
     _costPixValid = false;
diff --git a/kcachegrind/kcachegrind/functionitem.h b/kcachegrind/kcachegrind/functionitem.h
index fcf24123..d8f98f49 100644
--- a/kcachegrind/kcachegrind/functionitem.h
+++ b/kcachegrind/kcachegrind/functionitem.h
@@ -29,10 +29,10 @@
 class FunctionItem: public TQListViewItem
 {
 public:    
-  FunctionItem(TQListView* tqparent, TraceFunction* function,
+  FunctionItem(TQListView* parent, TraceFunction* function,
 	       TraceCostType* ct, TraceCost::CostType gt);
   // constructor for a "Skipped ... " entry
-  FunctionItem(TQListView* tqparent, int skipped,
+  FunctionItem(TQListView* parent, int skipped,
 	       TraceFunction* function, TraceCostType* ct);
 
   int compare(TQListViewItem * i, int col, bool ascending ) const;
diff --git a/kcachegrind/kcachegrind/functionselection.cpp b/kcachegrind/kcachegrind/functionselection.cpp
index 0ea7e72c..437a17bf 100644
--- a/kcachegrind/kcachegrind/functionselection.cpp
+++ b/kcachegrind/kcachegrind/functionselection.cpp
@@ -41,8 +41,8 @@
 #include "toplevel.h"
 
 FunctionSelection::FunctionSelection( TopLevel* top,
-				      TQWidget* tqparent, const char* name)
-    : FunctionSelectionBase(tqparent, name), TraceItemView(0, top)
+				      TQWidget* parent, const char* name)
+    : FunctionSelectionBase(parent, name), TraceItemView(0, top)
 {
   _group = 0;
   _inSetGroup = false;
diff --git a/kcachegrind/kcachegrind/functionselection.h b/kcachegrind/kcachegrind/functionselection.h
index 2aacbeba..c5f78107 100644
--- a/kcachegrind/kcachegrind/functionselection.h
+++ b/kcachegrind/kcachegrind/functionselection.h
@@ -41,7 +41,7 @@ class FunctionSelection : public FunctionSelectionBase, public TraceItemView
   TQ_OBJECT
 
 public:
-  FunctionSelection( TopLevel*, TQWidget* tqparent = 0, const char* name = 0);
+  FunctionSelection( TopLevel*, TQWidget* parent = 0, const char* name = 0);
   ~FunctionSelection();
 
   TraceCostItem* group(TQString);
diff --git a/kcachegrind/kcachegrind/instritem.cpp b/kcachegrind/kcachegrind/instritem.cpp
index 3aa7d22d..81341672 100644
--- a/kcachegrind/kcachegrind/instritem.cpp
+++ b/kcachegrind/kcachegrind/instritem.cpp
@@ -37,9 +37,9 @@
 // InstrItem
 
 // for messages
-InstrItem::InstrItem(InstrView* iv, TQListView* tqparent,
+InstrItem::InstrItem(InstrView* iv, TQListView* parent,
 		     Addr addr, const TQString& msg)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _view = iv;
   _addr = addr;
@@ -56,11 +56,11 @@ InstrItem::InstrItem(InstrView* iv, TQListView* tqparent,
 }
 
 // for code lines
-InstrItem::InstrItem(InstrView* iv, TQListView* tqparent,
+InstrItem::InstrItem(InstrView* iv, TQListView* parent,
 		     Addr addr, bool inside,
 		     const TQString& code, const TQString& cmd,
 		     const TQString& args, TraceInstr* instr)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _view = iv;
   _addr = addr;
@@ -86,9 +86,9 @@ InstrItem::InstrItem(InstrView* iv, TQListView* tqparent,
 }
 
 // for call lines
-InstrItem::InstrItem(InstrView* iv, TQListViewItem* tqparent, Addr addr,
+InstrItem::InstrItem(InstrView* iv, TQListViewItem* parent, Addr addr,
 		     TraceInstr* instr, TraceInstrCall* instrCall)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _view = iv;
   _addr = addr;
@@ -118,9 +118,9 @@ InstrItem::InstrItem(InstrView* iv, TQListViewItem* tqparent, Addr addr,
 }
 
 // for jump lines
-InstrItem::InstrItem(InstrView* iv, TQListViewItem* tqparent, Addr addr,
+InstrItem::InstrItem(InstrView* iv, TQListViewItem* parent, Addr addr,
 		     TraceInstr* instr, TraceInstrJump* instrJump)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _view = iv;
   _addr = addr;
diff --git a/kcachegrind/kcachegrind/instritem.h b/kcachegrind/kcachegrind/instritem.h
index ab5467d9..e521ebe0 100644
--- a/kcachegrind/kcachegrind/instritem.h
+++ b/kcachegrind/kcachegrind/instritem.h
@@ -33,21 +33,21 @@ class InstrItem: public TQListViewItem
 
 public:
   // for messages
-  InstrItem(InstrView* iv, TQListView* tqparent,
+  InstrItem(InstrView* iv, TQListView* parent,
 	    Addr addr, const TQString&);
 
   // for instruction lines
-  InstrItem(InstrView* iv, TQListView* tqparent,
+  InstrItem(InstrView* iv, TQListView* parent,
 	    Addr addr, bool inside,
 	    const TQString&, const TQString&, const TQString&,
 	    TraceInstr* instr);
 
   // for call instr
-  InstrItem(InstrView* iv, TQListViewItem* tqparent, Addr addr,
+  InstrItem(InstrView* iv, TQListViewItem* parent, Addr addr,
 	    TraceInstr* instr, TraceInstrCall* instrCall);
 
   // for jump lines
-  InstrItem(InstrView* iv, TQListViewItem* tqparent, Addr addr,
+  InstrItem(InstrView* iv, TQListViewItem* parent, Addr addr,
 	    TraceInstr* instr, TraceInstrJump* instrJump);
 
   Addr addr() const { return _addr; }
diff --git a/kcachegrind/kcachegrind/instrview.cpp b/kcachegrind/kcachegrind/instrview.cpp
index d578b4f8..39bd9b0b 100644
--- a/kcachegrind/kcachegrind/instrview.cpp
+++ b/kcachegrind/kcachegrind/instrview.cpp
@@ -111,8 +111,8 @@ static bool parseLine(char* buf, Addr& addr,
 
 
 InstrView::InstrView(TraceItemView* parentView,
-                     TQWidget* tqparent, const char* name)
-  : TQListView(tqparent, name), TraceItemView(parentView)
+                     TQWidget* parent, const char* name)
+  : TQListView(parent, name), TraceItemView(parentView)
 {
   _showHexCode = DEFAULT_SHOWHEXCODE;
   _lastHexCodeWidth = 50;
diff --git a/kcachegrind/kcachegrind/instrview.h b/kcachegrind/kcachegrind/instrview.h
index 86d011cc..79d3d763 100644
--- a/kcachegrind/kcachegrind/instrview.h
+++ b/kcachegrind/kcachegrind/instrview.h
@@ -37,7 +37,7 @@ class InstrView : public TQListView, public TraceItemView
 
 public:
   InstrView(TraceItemView* parentView,
-            TQWidget* tqparent = 0, const char* name = 0);
+            TQWidget* parent = 0, const char* name = 0);
 
   virtual TQWidget* widget() { return this; }
   TQString whatsThis() const;
diff --git a/kcachegrind/kcachegrind/multiview.cpp b/kcachegrind/kcachegrind/multiview.cpp
index d3ad670c..18148927 100644
--- a/kcachegrind/kcachegrind/multiview.cpp
+++ b/kcachegrind/kcachegrind/multiview.cpp
@@ -34,8 +34,8 @@
 // MultiView
 //
 
-MultiView::MultiView(TopLevel* top, TQWidget* tqparent, const char* name)
-    : TQSplitter(tqparent, name), TraceItemView(0, top)
+MultiView::MultiView(TopLevel* top, TQWidget* parent, const char* name)
+    : TQSplitter(parent, name), TraceItemView(0, top)
 {
   // default
   setOrientation(Qt::Horizontal);
diff --git a/kcachegrind/kcachegrind/multiview.h b/kcachegrind/kcachegrind/multiview.h
index 393638ba..9d771013 100644
--- a/kcachegrind/kcachegrind/multiview.h
+++ b/kcachegrind/kcachegrind/multiview.h
@@ -37,7 +37,7 @@ class MultiView : public TQSplitter, public TraceItemView
   TQ_OBJECT
 
 public:
-  MultiView(TopLevel* top, TQWidget* tqparent = 0, const char* name = 0);
+  MultiView(TopLevel* top, TQWidget* parent = 0, const char* name = 0);
 
   TQWidget* widget() { return this; }
   TabView* activeTabView() const { return _active; }
diff --git a/kcachegrind/kcachegrind/partgraph.cpp b/kcachegrind/kcachegrind/partgraph.cpp
index 44d54984..47bda4c9 100644
--- a/kcachegrind/kcachegrind/partgraph.cpp
+++ b/kcachegrind/kcachegrind/partgraph.cpp
@@ -29,8 +29,8 @@
 
 // PartAreaWidget
 
-PartAreaWidget::PartAreaWidget(TQWidget* tqparent, const char* name)
-    : TreeMapWidget(new BasePartItem(), tqparent, name)
+PartAreaWidget::PartAreaWidget(TQWidget* parent, const char* name)
+    : TreeMapWidget(new BasePartItem(), parent, name)
 {
   _data = 0;
   _function = 0;
@@ -156,12 +156,12 @@ TQString PartAreaWidget::tipString(TreeMapItem* i) const
       itemTip += "\n";
 
     tip = itemTip + tip;
-    i = i->tqparent();
+    i = i->parent();
     count++;
   }
 
   // skip to part
-  while (i && i->rtti()==3) i = i->tqparent();
+  while (i && i->rtti()==3) i = i->parent();
 
   if (i && i->rtti()==2) {
     itemTip = i18n("Profile Part %1").tqarg(i->text(0));
diff --git a/kcachegrind/kcachegrind/partgraph.h b/kcachegrind/kcachegrind/partgraph.h
index 1477382e..f8ad4ccd 100644
--- a/kcachegrind/kcachegrind/partgraph.h
+++ b/kcachegrind/kcachegrind/partgraph.h
@@ -35,7 +35,7 @@ public:
   // Visualisation inside of trace parts
   enum VisualisationMode { NoVisualisation, Partitioning, Inclusive };
 
-  PartAreaWidget(TQWidget* tqparent=0, const char* name=0);
+  PartAreaWidget(TQWidget* parent=0, const char* name=0);
 
   void setData(TraceData* d);
   void setCostType(TraceCostType* ct);
diff --git a/kcachegrind/kcachegrind/partlistitem.cpp b/kcachegrind/kcachegrind/partlistitem.cpp
index f23db9a4..debea16a 100644
--- a/kcachegrind/kcachegrind/partlistitem.cpp
+++ b/kcachegrind/kcachegrind/partlistitem.cpp
@@ -33,10 +33,10 @@
 
 // PartListItem
 
-PartListItem::PartListItem(TQListView* tqparent, TraceCostItem* costItem,
+PartListItem::PartListItem(TQListView* parent, TraceCostItem* costItem,
                            TraceCostType* ct, TraceCost::CostType gt,
 			   TracePart* part)
-  :TQListViewItem(tqparent)
+  :TQListViewItem(parent)
 {
   _partCostItem = costItem->findDepFromPart(part);
   _part = part;
diff --git a/kcachegrind/kcachegrind/partlistitem.h b/kcachegrind/kcachegrind/partlistitem.h
index c395b239..0ab99a9c 100644
--- a/kcachegrind/kcachegrind/partlistitem.h
+++ b/kcachegrind/kcachegrind/partlistitem.h
@@ -32,7 +32,7 @@
 class PartListItem: public TQListViewItem
 {
 public:
-  PartListItem(TQListView* tqparent, TraceCostItem* costItem,
+  PartListItem(TQListView* parent, TraceCostItem* costItem,
                TraceCostType* ct, TraceCost::CostType gt, TracePart* part);
 
   int compare(TQListViewItem * i, int col, bool ascending ) const;
diff --git a/kcachegrind/kcachegrind/partselection.cpp b/kcachegrind/kcachegrind/partselection.cpp
index b4eb29be..c501702d 100644
--- a/kcachegrind/kcachegrind/partselection.cpp
+++ b/kcachegrind/kcachegrind/partselection.cpp
@@ -36,8 +36,8 @@
 #include "partselection.h"
 #include "partgraph.h"
 
-PartSelection::PartSelection( TQWidget* tqparent, const char* name)
-  : PartSelectionBase(tqparent, name)
+PartSelection::PartSelection( TQWidget* parent, const char* name)
+  : PartSelectionBase(parent, name)
 {
   _data = 0;
   _costType = 0;
@@ -310,7 +310,7 @@ void PartSelection::contextMenuRequested(TreeMapItem* i,
 
       str = i18n("Select") + " '" + ni->text(0) + "'";
       popup.insertItem(str, id);
-      ni = ni->tqparent();
+      ni = ni->parent();
       id++;
     }
   }
@@ -365,7 +365,7 @@ void PartSelection::contextMenuRequested(TreeMapItem* i,
   if (r>=100) {
     TreeMapItem* ci = i;
     while (ci && r>100) {
-      ci = ci->tqparent();
+      ci = ci->parent();
       r--;
     }
     doubleClicked(ci);
@@ -545,7 +545,7 @@ void PartSelection::fillInfo()
   TQString info = _data->activePartRange();
 
   TreeMapItem* i = partAreaWidget->current();
-  while (i && i->rtti()!=2) i = i->tqparent();
+  while (i && i->rtti()!=2) i = i->parent();
   if (i) {
     TracePart* part = ((PartItem*)i)->part();
 
diff --git a/kcachegrind/kcachegrind/partselection.h b/kcachegrind/kcachegrind/partselection.h
index dfdeff17..b8a195f8 100644
--- a/kcachegrind/kcachegrind/partselection.h
+++ b/kcachegrind/kcachegrind/partselection.h
@@ -41,7 +41,7 @@ class PartSelection: public PartSelectionBase
   TQ_OBJECT
 
 public:
-  PartSelection( TQWidget* tqparent = 0, const char* name = 0);
+  PartSelection( TQWidget* parent = 0, const char* name = 0);
   ~PartSelection();
 
   TraceData* data() { return _data; }
diff --git a/kcachegrind/kcachegrind/partview.cpp b/kcachegrind/kcachegrind/partview.cpp
index 039b708c..853e9928 100644
--- a/kcachegrind/kcachegrind/partview.cpp
+++ b/kcachegrind/kcachegrind/partview.cpp
@@ -38,8 +38,8 @@
 
 
 PartView::PartView(TraceItemView* parentView,
-		   TQWidget* tqparent, const char* name)
-  : TQListView(tqparent, name), TraceItemView(parentView)
+		   TQWidget* parent, const char* name)
+  : TQListView(parent, name), TraceItemView(parentView)
 {
     _inSelectionUpdate = false;
 
diff --git a/kcachegrind/kcachegrind/partview.h b/kcachegrind/kcachegrind/partview.h
index 06de9bf7..92761cc1 100644
--- a/kcachegrind/kcachegrind/partview.h
+++ b/kcachegrind/kcachegrind/partview.h
@@ -34,7 +34,7 @@ class PartView: public TQListView, public TraceItemView
 
 public:
   PartView(TraceItemView* parentView,
-	   TQWidget* tqparent=0, const char* name=0);
+	   TQWidget* parent=0, const char* name=0);
 
   virtual TQWidget* widget() { return this; }
   TQString whatsThis() const;
diff --git a/kcachegrind/kcachegrind/sourceitem.cpp b/kcachegrind/kcachegrind/sourceitem.cpp
index db1ee04b..9556c038 100644
--- a/kcachegrind/kcachegrind/sourceitem.cpp
+++ b/kcachegrind/kcachegrind/sourceitem.cpp
@@ -37,11 +37,11 @@
 // SourceItem
 
 // for source lines
-SourceItem::SourceItem(SourceView* sv, TQListView* tqparent,
+SourceItem::SourceItem(SourceView* sv, TQListView* parent,
 		       int fileno, unsigned int lineno,
                        bool inside, const TQString& src,
                        TraceLine* line)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _view = sv;
   _lineno = lineno;
@@ -64,10 +64,10 @@ SourceItem::SourceItem(SourceView* sv, TQListView* tqparent,
 }
 
 // for call lines
-SourceItem::SourceItem(SourceView* sv, TQListViewItem* tqparent,
+SourceItem::SourceItem(SourceView* sv, TQListViewItem* parent,
 		       int fileno, unsigned int lineno,
                        TraceLine* line, TraceLineCall* lineCall)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _view = sv;
   _lineno = lineno;
@@ -98,10 +98,10 @@ SourceItem::SourceItem(SourceView* sv, TQListViewItem* tqparent,
 }
 
 // for jump lines
-SourceItem::SourceItem(SourceView* sv, TQListViewItem* tqparent,
+SourceItem::SourceItem(SourceView* sv, TQListViewItem* parent,
 		       int fileno, unsigned int lineno,
                        TraceLine* line, TraceLineJump* lineJump)
-    : TQListViewItem(tqparent)
+    : TQListViewItem(parent)
 {
   _view = sv;
   _lineno = lineno;
diff --git a/kcachegrind/kcachegrind/sourceitem.h b/kcachegrind/kcachegrind/sourceitem.h
index 532811e0..30589835 100644
--- a/kcachegrind/kcachegrind/sourceitem.h
+++ b/kcachegrind/kcachegrind/sourceitem.h
@@ -32,18 +32,18 @@ class SourceItem: public TQListViewItem
 {
 public:
   // for source lines
-  SourceItem(SourceView* sv, TQListView* tqparent, 
+  SourceItem(SourceView* sv, TQListView* parent, 
 	     int fileno, unsigned int lineno,
 	     bool inside, const TQString& src,
              TraceLine* line = 0);
 
   // for call lines
-  SourceItem(SourceView* sv, TQListViewItem* tqparent, 
+  SourceItem(SourceView* sv, TQListViewItem* parent, 
 	     int fileno, unsigned int lineno,
              TraceLine* line, TraceLineCall* lineCall);
 
   // for jump lines
-  SourceItem(SourceView* sv, TQListViewItem* tqparent, 
+  SourceItem(SourceView* sv, TQListViewItem* parent, 
 	     int fileno, unsigned int lineno,
              TraceLine* line, TraceLineJump* lineJump);
 
diff --git a/kcachegrind/kcachegrind/sourceview.cpp b/kcachegrind/kcachegrind/sourceview.cpp
index be171d90..64b3e995 100644
--- a/kcachegrind/kcachegrind/sourceview.cpp
+++ b/kcachegrind/kcachegrind/sourceview.cpp
@@ -38,8 +38,8 @@
 
 
 SourceView::SourceView(TraceItemView* parentView,
-                       TQWidget* tqparent, const char* name)
-  : TQListView(tqparent, name), TraceItemView(parentView)
+                       TQWidget* parent, const char* name)
+  : TQListView(parent, name), TraceItemView(parentView)
 {
   _inSelectionUpdate = false;
 
diff --git a/kcachegrind/kcachegrind/sourceview.h b/kcachegrind/kcachegrind/sourceview.h
index 2e2c0386..b72fc7ad 100644
--- a/kcachegrind/kcachegrind/sourceview.h
+++ b/kcachegrind/kcachegrind/sourceview.h
@@ -37,7 +37,7 @@ class SourceView : public TQListView, public TraceItemView
 
 public:
   SourceView(TraceItemView* parentView,
-            TQWidget* tqparent = 0, const char* name = 0);
+            TQWidget* parent = 0, const char* name = 0);
 
   TQWidget* widget() { return this; }
   TQString whatsThis() const;
diff --git a/kcachegrind/kcachegrind/stackitem.cpp b/kcachegrind/kcachegrind/stackitem.cpp
index 3b41740a..af0499ba 100644
--- a/kcachegrind/kcachegrind/stackitem.cpp
+++ b/kcachegrind/kcachegrind/stackitem.cpp
@@ -31,8 +31,8 @@
 // StackItem
 
 StackItem::StackItem(StackSelection* ss, 
-		     TQListView* tqparent, TraceFunction* f)
-  :TQListViewItem(tqparent)
+		     TQListView* parent, TraceFunction* f)
+  :TQListViewItem(parent)
 {
   _view = ss;
   _function = f;
@@ -46,8 +46,8 @@ StackItem::StackItem(StackSelection* ss,
 }
 
 StackItem::StackItem(StackSelection* ss,
-		     TQListView* tqparent, TraceCall* call)
-  :TQListViewItem(tqparent)
+		     TQListView* parent, TraceCall* call)
+  :TQListViewItem(parent)
 {
   _view = ss;
   _call = call;
diff --git a/kcachegrind/kcachegrind/stackitem.h b/kcachegrind/kcachegrind/stackitem.h
index 31e24b75..250e9f66 100644
--- a/kcachegrind/kcachegrind/stackitem.h
+++ b/kcachegrind/kcachegrind/stackitem.h
@@ -36,8 +36,8 @@ class StackItem: public TQListViewItem
 {
 public:
   // for top
-  StackItem(StackSelection* ss, TQListView* tqparent, TraceFunction* f);
-  StackItem(StackSelection* ss, TQListView* tqparent, TraceCall* c);
+  StackItem(StackSelection* ss, TQListView* parent, TraceFunction* f);
+  StackItem(StackSelection* ss, TQListView* parent, TraceCall* c);
 
   TraceFunction* function() { return _function; }
   TraceCall* call() { return _call; }
diff --git a/kcachegrind/kcachegrind/stackselection.cpp b/kcachegrind/kcachegrind/stackselection.cpp
index fcba2ab9..59094754 100644
--- a/kcachegrind/kcachegrind/stackselection.cpp
+++ b/kcachegrind/kcachegrind/stackselection.cpp
@@ -35,8 +35,8 @@
 #include "stackselection.h"
 #include "stackitem.h"
 
-StackSelection::StackSelection( TQWidget* tqparent, const char* name)
-  : StackSelectionBase(tqparent, name)
+StackSelection::StackSelection( TQWidget* parent, const char* name)
+  : StackSelectionBase(parent, name)
 {
   _data = 0;
   _browser = new StackBrowser();
diff --git a/kcachegrind/kcachegrind/stackselection.h b/kcachegrind/kcachegrind/stackselection.h
index 6b71c2b8..2bb3a750 100644
--- a/kcachegrind/kcachegrind/stackselection.h
+++ b/kcachegrind/kcachegrind/stackselection.h
@@ -39,7 +39,7 @@ class StackSelection : public StackSelectionBase
   TQ_OBJECT
 
 public:
-  StackSelection( TQWidget* tqparent = 0, const char* name = 0);
+  StackSelection( TQWidget* parent = 0, const char* name = 0);
   ~StackSelection();
 
   TraceData* data() const { return _data; }
diff --git a/kcachegrind/kcachegrind/tabview.cpp b/kcachegrind/kcachegrind/tabview.cpp
index bb5e340c..52f728b5 100644
--- a/kcachegrind/kcachegrind/tabview.cpp
+++ b/kcachegrind/kcachegrind/tabview.cpp
@@ -43,10 +43,10 @@
 
 // TabBar
 
-TabBar::TabBar(TabView* v, TQTabWidget* tqparent, const char *name)
-    : TQTabBar(tqparent, name)
+TabBar::TabBar(TabView* v, TQTabWidget* parent, const char *name)
+    : TQTabBar(parent, name)
 {
-    _tabWidget = tqparent;
+    _tabWidget = parent;
     _tabView = v;
 }
 
@@ -114,8 +114,8 @@ void TabBar::mousePressEvent(TQMouseEvent *e)
 // Splitter
 //
 
-Splitter::Splitter(Qt::Orientation o, TQWidget* tqparent, const char* name)
-  : TQSplitter(o, tqparent, name)
+Splitter::Splitter(Qt::Orientation o, TQWidget* parent, const char* name)
+  : TQSplitter(o, parent, name)
 {}
 
 void Splitter::moveEvent(TQMoveEvent* e)
@@ -145,9 +145,9 @@ void Splitter::checkVisiblity()
 // TabWidget
 //
 
-TabWidget::TabWidget(TabView* v, TQWidget* tqparent,
+TabWidget::TabWidget(TabView* v, TQWidget* parent,
                      const char* name, WFlags f)
-    : TQTabWidget(tqparent, name, f)
+    : TQTabWidget(parent, name, f)
 {
     _hasVisibleRect = false;
     setTabBar(new TabBar(v, this));
@@ -229,8 +229,8 @@ void TabWidget::moveEvent(TQMoveEvent* e)
  */
 
 TabView::TabView(TraceItemView* parentView,
-                 TQWidget* tqparent, const char* name)
-  : TQWidget(tqparent, name), TraceItemView(parentView)
+                 TQWidget* parent, const char* name)
+  : TQWidget(parent, name), TraceItemView(parentView)
 {
     setFocusPolicy(TQ_StrongFocus);
 
@@ -704,7 +704,7 @@ void TabView::selected(TraceItemView*, TraceItem* s)
     select(s);
     updateView();
 
-    // still forward to tqparent
+    // still forward to parent
     if (_parentView) _parentView->selected(this, s);
 }
 
diff --git a/kcachegrind/kcachegrind/tabview.h b/kcachegrind/kcachegrind/tabview.h
index caea8126..221e6e08 100644
--- a/kcachegrind/kcachegrind/tabview.h
+++ b/kcachegrind/kcachegrind/tabview.h
@@ -43,7 +43,7 @@ class TabBar : public TQTabBar
   TQ_OBJECT
 
  public:
-  TabBar(TabView*, TQTabWidget* tqparent, const char *name = 0);
+  TabBar(TabView*, TQTabWidget* parent, const char *name = 0);
  protected:
   void mousePressEvent(TQMouseEvent *e);
 
@@ -65,7 +65,7 @@ class Splitter: public TQSplitter
   TQ_OBJECT
 
 public:
-  Splitter(Qt::Orientation o, TQWidget* tqparent = 0, const char* name = 0);
+  Splitter(Qt::Orientation o, TQWidget* parent = 0, const char* name = 0);
   void checkVisiblity();
 
 protected:
@@ -86,7 +86,7 @@ class TabWidget: public TQTabWidget
 
 public:
 
-  TabWidget(TabView*, TQWidget* tqparent = 0,
+  TabWidget(TabView*, TQWidget* parent = 0,
             const char* name = 0, WFlags f = 0);
 
   bool hasVisibleRect() { return _hasVisibleRect; }
@@ -115,7 +115,7 @@ class TabView : public TQWidget, public TraceItemView
 public:
 
   TabView(TraceItemView* parentView,
-          TQWidget* tqparent = 0, const char* name = 0);
+          TQWidget* parent = 0, const char* name = 0);
 
   virtual TQWidget* widget() { return this; }
   TQString whatsThis() const ;
diff --git a/kcachegrind/kcachegrind/toplevel.cpp b/kcachegrind/kcachegrind/toplevel.cpp
index e625e42d..db1dace7 100644
--- a/kcachegrind/kcachegrind/toplevel.cpp
+++ b/kcachegrind/kcachegrind/toplevel.cpp
@@ -631,15 +631,15 @@ void TopLevel::createMiscActions()
 				  actionCollection(),
 				  "view_expanded");
 
-  hint = i18n("Show percentage costs relative to tqparent");
+  hint = i18n("Show percentage costs relative to parent");
   _taExpanded->setToolTip( hint );
   _taExpanded->setWhatsThis( hint );
 
-  hint = i18n("<b>Show percentage costs relative to tqparent</b>"
+  hint = i18n("<b>Show percentage costs relative to parent</b>"
               "<p>If this is switched off, percentage costs are always shown "
 	      "relative to the total cost of the profile part(s) that are "
 	      "currently browsed. By turning on this option, percentage cost "
-	      "of shown cost items will be relative to the tqparent cost item."
+	      "of shown cost items will be relative to the parent cost item."
 	      "<ul><table>"
 	      "<tr><td><b>Cost Type</td><td><b>Parent Cost</td></tr>"
 	      "<tr><td>Function Cumulative</td><td>Total</td></tr>"
diff --git a/kcachegrind/kcachegrind/tracedata.cpp b/kcachegrind/kcachegrind/tracedata.cpp
index c277cde5..526c1cb0 100644
--- a/kcachegrind/kcachegrind/tracedata.cpp
+++ b/kcachegrind/kcachegrind/tracedata.cpp
@@ -4843,10 +4843,10 @@ void TraceData::update()
 }
 
 TraceCost* TraceData::search(TraceItem::CostType t, TQString name,
-			     TraceCostType* ct, TraceCost* tqparent)
+			     TraceCostType* ct, TraceCost* parent)
 {
     TraceCost* result = 0;
-    TraceItem::CostType pt = tqparent ? tqparent->type() : NoCostType;
+    TraceItem::CostType pt = parent ? parent->type() : NoCostType;
     SubCost sc, scTop = 0;
 
     switch(t) {
@@ -4860,9 +4860,9 @@ TraceCost* TraceData::search(TraceItem::CostType t, TQString name,
 
 		if (f->name() != name) continue;
 
-		if ((pt == Class) && (tqparent != f->cls())) continue;
-		if ((pt == File) && (tqparent != f->file())) continue;
-		if ((pt == Object) && (tqparent != f->object())) continue;
+		if ((pt == Class) && (parent != f->cls())) continue;
+		if ((pt == File) && (parent != f->file())) continue;
+		if ((pt == Object) && (parent != f->object())) continue;
 
 		if (ct) {
 		    sc = f->inclusive()->subCost(ct);
@@ -4931,7 +4931,7 @@ TraceCost* TraceData::search(TraceItem::CostType t, TQString name,
 
     case Instr:
 	if (pt == Function) {
-	    TraceInstrMap* instrMap = ((TraceFunction*)tqparent)->instrMap();
+	    TraceInstrMap* instrMap = ((TraceFunction*)parent)->instrMap();
 	    if (!instrMap) break;
 
 	    TraceInstr *instr;
@@ -4949,9 +4949,9 @@ TraceCost* TraceData::search(TraceItem::CostType t, TQString name,
 	{
 	    TraceFunctionSourceList sList;
 	    if (pt == Function)
-		sList = ((TraceFunction*)tqparent)->sourceFiles();
+		sList = ((TraceFunction*)parent)->sourceFiles();
 	    else if (pt == FunctionSource)
-		sList.append((TraceFunctionSource*) tqparent);
+		sList.append((TraceFunctionSource*) parent);
 	    else break;
 
 	    TraceLineMap* lineMap;
diff --git a/kcachegrind/kcachegrind/tracedata.h b/kcachegrind/kcachegrind/tracedata.h
index edc4c8f8..cb97e623 100644
--- a/kcachegrind/kcachegrind/tracedata.h
+++ b/kcachegrind/kcachegrind/tracedata.h
@@ -1879,13 +1879,13 @@ class TraceData: public TraceCost
   /**
    * Search for item with given name and highest subcost of given cost type.
    *
-   * For some items, they will only be found if the tqparent cost is given:
-   *  Instr, Line, Call  => need tqparent of type Function
-   * For Function, a tqparent of type Obj/File/Class can be given, but
+   * For some items, they will only be found if the parent cost is given:
+   *  Instr, Line, Call  => need parent of type Function
+   * For Function, a parent of type Obj/File/Class can be given, but
    * isn't needed.
    */
   TraceCost* search(TraceItem::CostType, TQString,
-		    TraceCostType* ct = 0, TraceCost* tqparent = 0);
+		    TraceCostType* ct = 0, TraceCost* parent = 0);
 
   // for pretty function names without signature if unique...
   TraceFunctionMap::Iterator functionIterator(TraceFunction*);
diff --git a/kcachegrind/kcachegrind/traceitemview.h b/kcachegrind/kcachegrind/traceitemview.h
index 1d0c0394..f83aa896 100644
--- a/kcachegrind/kcachegrind/traceitemview.h
+++ b/kcachegrind/kcachegrind/traceitemview.h
@@ -66,7 +66,7 @@ public:
 
   enum Direction { None, Back, Forward, Up };
 
-  // a TraceItemView can have a position in a tqparent container
+  // a TraceItemView can have a position in a parent container
   enum Position { Hidden, Top, Right, Left, Bottom };
 
   TraceItemView(TraceItemView* parentView, TopLevel* top = 0);
@@ -94,7 +94,7 @@ public:
   // Overwrite in container views to also set new data for all members.
   virtual void setData(TraceData* d);
 
-  // change from tqparent, call updateView() to update lazily (only if visible)
+  // change from parent, call updateView() to update lazily (only if visible)
   void setCostType(TraceCostType* t) { _newCostType = t; }
   void setCostType2(TraceCostType* t) { _newCostType2 = t; }
   void set(TraceItem::CostType g) { _newGroupType = g; }
@@ -113,7 +113,7 @@ public:
 
   /**
    * Notification from child views.
-   * Default implementation notifies tqparent
+   * Default implementation notifies parent
    */
   virtual void selected(TraceItemView* sender, TraceItem*);
   virtual void selected(TraceItemView* sender, const TracePartList&);
diff --git a/kcachegrind/kcachegrind/treemap.cpp b/kcachegrind/kcachegrind/treemap.cpp
index 66c73ad4..c1f7f12b 100644
--- a/kcachegrind/kcachegrind/treemap.cpp
+++ b/kcachegrind/kcachegrind/treemap.cpp
@@ -720,11 +720,11 @@ int TreeMapItemList::compareItems ( Item item1, Item item2 )
   bool ascending;
   int result;
 
-  TreeMapItem* tqparent = ((TreeMapItem*)item1)->tqparent();
+  TreeMapItem* parent = ((TreeMapItem*)item1)->parent();
   // shouldn't happen
-  if (!tqparent) return 0;
+  if (!parent) return 0;
 
-  int textNo = tqparent->sorting(&ascending);
+  int textNo = parent->sorting(&ascending);
 
   if (textNo < 0) {
     double diff = ((TreeMapItem*)item1)->value() -
@@ -741,22 +741,22 @@ int TreeMapItemList::compareItems ( Item item1, Item item2 )
 
 TreeMapItem* TreeMapItemList::commonParent()
 {
-  TreeMapItem* tqparent, *item;
-  tqparent = first();
-  if (tqparent)
+  TreeMapItem* parent, *item;
+  parent = first();
+  if (parent)
     while( (item = next()) != 0)
-      tqparent = tqparent->commonParent(item);
+      parent = parent->commonParent(item);
 
-  return tqparent;
+  return parent;
 }
 
 
 // TreeMapItem
 
-TreeMapItem::TreeMapItem(TreeMapItem* tqparent, double value)
+TreeMapItem::TreeMapItem(TreeMapItem* parent, double value)
 {
   _value = value;
-  _parent = tqparent;
+  _parent = parent;
 
   _sum = 0;
   _tqchildren = 0;
@@ -767,7 +767,7 @@ TreeMapItem::TreeMapItem(TreeMapItem* tqparent, double value)
   _freeRects = 0;
 
   if (_parent) {
-    // take sorting from tqparent
+    // take sorting from parent
     _sortTextNo = _parent->sorting(&_sortAscending);
     _parent->addItem(this);
   }
@@ -778,12 +778,12 @@ TreeMapItem::TreeMapItem(TreeMapItem* tqparent, double value)
 }
 
 
-TreeMapItem::TreeMapItem(TreeMapItem* tqparent, double value,
+TreeMapItem::TreeMapItem(TreeMapItem* parent, double value,
                          TQString text1, TQString text2,
                          TQString text3, TQString text4)
 {
   _value = value;
-  _parent = tqparent;
+  _parent = parent;
 
   // this resizes the text vector only if needed
   if (!text4.isEmpty()) setText(3, text4);
@@ -832,7 +832,7 @@ bool TreeMapItem::isChildOf(TreeMapItem* item)
 TreeMapItem* TreeMapItem::commonParent(TreeMapItem* item)
 {
   while (item && !isChildOf(item)) {
-    item = item->tqparent();
+    item = item->parent();
   }
   return item;
 }
@@ -1106,8 +1106,8 @@ void TreeMapTip::maybeTip( const TQPoint& pos )
 // TreeMapWidget
 
 TreeMapWidget::TreeMapWidget(TreeMapItem* base,
-			     TQWidget* tqparent, const char* name)
-    : TQWidget(tqparent, name)
+			     TQWidget* parent, const char* name)
+    : TQWidget(parent, name)
 {
     _base = base;
     _base->setWidget(this);
@@ -1472,9 +1472,9 @@ void TreeMapWidget::deletingItem(TreeMapItem* i)
 
   // don't redraw a deleted item
   if (_needsRefresh == i) {
-    // we can savely redraw the tqparent, as deleting order is
-    // from child to tqparent; i.e. i->tqparent() is existing. 
-    _needsRefresh = i->tqparent();
+    // we can savely redraw the parent, as deleting order is
+    // from child to parent; i.e. i->parent() is existing. 
+    _needsRefresh = i->parent();
   }
 }
 
@@ -1494,7 +1494,7 @@ TQString TreeMapWidget::tipString(TreeMapItem* i) const
 
       tip += itemTip;
     }
-    i = i->tqparent();
+    i = i->parent();
   }
   return tip;
 }
@@ -1556,7 +1556,7 @@ TreeMapItem* TreeMapWidget::possibleSelection(TreeMapItem* i) const
     if (_maxSelectDepth>=0) {
       int depth = i->depth();
       while(i && depth > _maxSelectDepth) {
-        i = i->tqparent();
+        i = i->parent();
         depth--;
       }
     }
@@ -1570,7 +1570,7 @@ TreeMapItem* TreeMapWidget::visibleItem(TreeMapItem* i) const
     /* Must have a visible area */
     while(i && ((i->tqitemRect().width() <1) ||
                 (i->tqitemRect().height() <1))) {
-      TreeMapItem* p = i->tqparent();
+      TreeMapItem* p = i->parent();
       if (!p) break;
       int idx = p->tqchildren()->findRef(i);
       idx--;
@@ -1670,13 +1670,13 @@ TreeMapItem* TreeMapWidget::setTmpSelected(TreeMapItem* item, bool selected)
 }
 
 
-bool TreeMapWidget::clearSelection(TreeMapItem* tqparent)
+bool TreeMapWidget::clearSelection(TreeMapItem* parent)
 {
   TreeMapItemList old = _selection;
 
   TreeMapItem* i=_selection.first();
   while (i) {
-    if (i->isChildOf(tqparent)) {
+    if (i->isChildOf(parent)) {
       _selection.remove();
       i = _selection.current();
     }
@@ -1764,11 +1764,11 @@ TreeMapItem* TreeMapWidget::setTmpRangeSelection(TreeMapItem* i1,
   TreeMapItem* commonParent = i1;
   while (commonParent && !i2->isChildOf(commonParent)) {
     i1 = commonParent;
-    commonParent = commonParent->tqparent();
+    commonParent = commonParent->parent();
   }
   if (!commonParent) return changed;
-  while (i2 && i2->tqparent() != commonParent)
-    i2 = i2->tqparent();
+  while (i2 && i2->parent() != commonParent)
+    i2 = i2->parent();
   if (!i2) return changed;
 
   TreeMapItemList* list = commonParent->tqchildren();
@@ -1961,7 +1961,7 @@ void TreeMapWidget::mouseDoubleClickEvent( TQMouseEvent* e )
 /* returns -1 if nothing visible found */
 int nextVisible(TreeMapItem* i)
 {
-  TreeMapItem* p = i->tqparent();
+  TreeMapItem* p = i->parent();
   if (!p || p->tqitemRect().isEmpty()) return -1;
 
   int idx = p->tqchildren()->findRef(i);
@@ -1979,7 +1979,7 @@ int nextVisible(TreeMapItem* i)
 /* returns -1 if nothing visible found */
 int prevVisible(TreeMapItem* i)
 {
-  TreeMapItem* p = i->tqparent();
+  TreeMapItem* p = i->parent();
   if (!p || p->tqitemRect().isEmpty()) return -1;
 
   int idx = p->tqchildren()->findRef(i);
@@ -2050,7 +2050,7 @@ void TreeMapWidget::keyPressEvent( TQKeyEvent* e )
   }
 
   TreeMapItem* old = _current,  *newItem;
-  TreeMapItem* p = _current->tqparent();
+  TreeMapItem* p = _current->parent();
 
   bool goBack;
   if (_current->sorting(&goBack) == -1) {
@@ -2210,7 +2210,7 @@ void TreeMapWidget::drawItem(TQPainter* p,
   TreeMapItem* i;
 
   if (_markNo>0) {
-      for(i = item;i;i=i->tqparent())
+      for(i = item;i;i=i->parent())
 	  if (i->isMarked(_markNo)) break;
 
       isSelected = (i!=0);
@@ -2935,7 +2935,7 @@ void TreeMapWidget::selectionActivated(int id)
   TreeMapItem* i = _menuItem;
   id -= _selectionID;
   while (id>0 && i) {
-    i=i->tqparent();
+    i=i->parent();
     id--;
   }
   if (i)
@@ -2957,7 +2957,7 @@ void TreeMapWidget::addSelectionItems(TQPopupMenu* popup,
     TQString name = i->text(0);
     if (name.isEmpty()) break;
     popup->insertItem(i->text(0), id++);
-    i = i->tqparent();
+    i = i->parent();
   }
 }
 
@@ -2968,7 +2968,7 @@ void TreeMapWidget::fieldStopActivated(int id)
     TreeMapItem* i = _menuItem;
     id -= _fieldStopID+1;
     while (id>0 && i) {
-      i=i->tqparent();
+      i=i->parent();
       id--;
     }
     if (i)
@@ -3000,7 +3000,7 @@ void TreeMapWidget::addFieldStopItems(TQPopupMenu* popup,
         popup->setItemChecked(id, true);
         foundFieldStop = true;
       }
-      i = i->tqparent();
+      i = i->parent();
     }
   }
 
diff --git a/kcachegrind/kcachegrind/treemap.h b/kcachegrind/kcachegrind/treemap.h
index de60f40f..1604a51c 100644
--- a/kcachegrind/kcachegrind/treemap.h
+++ b/kcachegrind/kcachegrind/treemap.h
@@ -244,8 +244,8 @@ public:
                    HAlternate, VAlternate,
                    Horizontal, Vertical };
 
-  TreeMapItem(TreeMapItem* tqparent = 0, double value = 1.0 );
-  TreeMapItem(TreeMapItem* tqparent, double value,
+  TreeMapItem(TreeMapItem* parent = 0, double value = 1.0 );
+  TreeMapItem(TreeMapItem* parent, double value,
               TQString text1, TQString text2 = TQString(),
               TQString text3 = TQString(), TQString text4 = TQString());
   virtual ~TreeMapItem();
@@ -268,9 +268,9 @@ public:
   bool initialized();
 
   /**
-   * Adds an item to a tqparent.
+   * Adds an item to a parent.
    * When no sorting is used, the item is appended (drawn at bottom).
-   * This is only needed if the tqparent was not already specified in the
+   * This is only needed if the parent was not already specified in the
    * construction of the item.
    */
   void addItem(TreeMapItem*);
@@ -289,7 +289,7 @@ public:
   /**
    * Parent Item
    */
-  TreeMapItem* tqparent() const { return _parent; }
+  TreeMapItem* parent() const { return _parent; }
 
   /**
    * Temporary rectangle used for drawing this item the last time.
@@ -409,7 +409,7 @@ public:
   enum SelectionMode { Single, Multi, Extended, NoSelection };
 
   /* The widget becomes owner of the base item */
-  TreeMapWidget(TreeMapItem* base, TQWidget* tqparent=0, const char* name=0);
+  TreeMapWidget(TreeMapItem* base, TQWidget* parent=0, const char* name=0);
   ~TreeMapWidget();
 
   /**
@@ -436,7 +436,7 @@ public:
 
   /**
    * Returns the item possible for selection. this returns the
-   * given item itself or a tqparent thereof,
+   * given item itself or a parent thereof,
    * depending on setting of maxSelectDepth().
    */
   TreeMapItem* possibleSelection(TreeMapItem*) const;
@@ -461,17 +461,17 @@ public:
 
   /**
    * Clear selection of all selected items which are tqchildren of
-   * tqparent. When tqparent == 0, clears whole selection
+   * parent. When parent == 0, clears whole selection
    * Returns true if selection changed.
    */
-  bool clearSelection(TreeMapItem* tqparent = 0);
+  bool clearSelection(TreeMapItem* parent = 0);
 
   /**
    * Selects or unselects items in a range.
    * This is needed internally for Shift-Click in Extented mode.
    * Range means for a hierarchical widget:
    * - select/unselect i1 and i2 according selected
-   * - search common tqparent of i1 and i2, and select/unselect the
+   * - search common parent of i1 and i2, and select/unselect the
    *   range of direct tqchildren between but excluding the child
    *   leading to i1 and the child leading to i2.
    */
@@ -535,12 +535,12 @@ public:
    * If a tqchildren value() is almost the parents sum(),
    * it can happen that the border to be drawn for visibilty of
    * nesting relations takes to much space, and the
-   * tqparent/child size relation can not be mapped to a correct
+   * parent/child size relation can not be mapped to a correct
    * area size relation.
    *
    * Either
    * (1) Ignore the incorrect drawing, or
-   * (2) Skip drawing of the tqparent level alltogether.
+   * (2) Skip drawing of the parent level alltogether.
    */
   void setSkipIncorrectBorder(bool enable = true);
   bool skipIncorrectBorder() const { return _skipIncorrectBorder; }