1 files changed, 248 insertions, 248 deletions
diff --git a/PerlQt/Qt.pm b/PerlQt/Qt.pm
index 01a08e8..69bcbca 100644
--- a/PerlQt/Qt.pm
+++ b/PerlQt/Qt.pm
@@ -1,4 +1,4 @@
-package Qt::base;
+package TQt::base;
 use strict;
 
 sub this () {}
@@ -8,394 +8,394 @@ sub new {
     my $t = this;
     shift->NEW(@_);
     my $ret = this;
-    Qt::_internal::setThis($t);
+    TQt::_internal::setThis($t);
     return $ret;
 }
 
-package Qt::base::_overload;
+package TQt::base::_overload;
 use strict;
 
 no strict 'refs';
 use overload
     "fallback" => 1,
-    "==" => "Qt::base::_overload::op_equal",
-    "!=" => "Qt::base::_overload::op_not_equal",
-    "+=" => "Qt::base::_overload::op_plus_equal",
-    "-=" => "Qt::base::_overload::op_minus_equal",
-    "*=" => "Qt::base::_overload::op_mul_equal",
-    "/=" => "Qt::base::_overload::op_div_equal",
-    ">>" => "Qt::base::_overload::op_shift_right",
-    "<<" => "Qt::base::_overload::op_shift_left",
-    "<=" => "Qt::base::_overload::op_lesser_equal",
-    ">=" => "Qt::base::_overload::op_greater_equal",
-    "^=" => "Qt::base::_overload::op_xor_equal",
-    "|=" => "Qt::base::_overload::op_or_equal",
-    ">"  => "Qt::base::_overload::op_greater",
-    "<"  => "Qt::base::_overload::op_lesser",
-    "+"  => "Qt::base::_overload::op_plus",
-    "-"  => "Qt::base::_overload::op_minus",
-    "*"  => "Qt::base::_overload::op_mul",
-    "/"  => "Qt::base::_overload::op_div",
-    "^"  => "Qt::base::_overload::op_xor",
-    "|"  => "Qt::base::_overload::op_or",
-    "--" => "Qt::base::_overload::op_decrement",
-    "++" => "Qt::base::_overload::op_increment",
-    "neg"=> "Qt::base::_overload::op_negate";
+    "==" => "TQt::base::_overload::op_equal",
+    "!=" => "TQt::base::_overload::op_not_equal",
+    "+=" => "TQt::base::_overload::op_plus_equal",
+    "-=" => "TQt::base::_overload::op_minus_equal",
+    "*=" => "TQt::base::_overload::op_mul_equal",
+    "/=" => "TQt::base::_overload::op_div_equal",
+    ">>" => "TQt::base::_overload::op_shift_right",
+    "<<" => "TQt::base::_overload::op_shift_left",
+    "<=" => "TQt::base::_overload::op_lesser_equal",
+    ">=" => "TQt::base::_overload::op_greater_equal",
+    "^=" => "TQt::base::_overload::op_xor_equal",
+    "|=" => "TQt::base::_overload::op_or_equal",
+    ">"  => "TQt::base::_overload::op_greater",
+    "<"  => "TQt::base::_overload::op_lesser",
+    "+"  => "TQt::base::_overload::op_plus",
+    "-"  => "TQt::base::_overload::op_minus",
+    "*"  => "TQt::base::_overload::op_mul",
+    "/"  => "TQt::base::_overload::op_div",
+    "^"  => "TQt::base::_overload::op_xor",
+    "|"  => "TQt::base::_overload::op_or",
+    "--" => "TQt::base::_overload::op_decrement",
+    "++" => "TQt::base::_overload::op_increment",
+    "neg"=> "TQt::base::_overload::op_negate";
 
 sub op_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator==';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator==';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator==';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator==';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret
 }
 
 sub op_not_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator!=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator!=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator!=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator!=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret
 }
 
 sub op_plus_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator+=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator+=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return ($_[2] ? $_[1] : $_[0]) unless $err = $@;
     my $ret;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator+=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator+=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret
 }
 
 sub op_minus_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator-=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator-=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return ($_[2] ? $_[1] : $_[0]) unless $err = $@;
     my $ret;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator-=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator-=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@; 
     $ret
 }
 
 sub op_mul_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator*=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator*=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return ($_[2] ? $_[1] : $_[0]) unless $err = $@;
     my $ret;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator*=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator*=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@; 
     $ret
 }
 
 sub op_div_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator/=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator/=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return ($_[2] ? $_[1] : $_[0]) unless $err = $@;
     my $ret;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator/=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator/=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@; 
     $ret
 }
 
 sub op_shift_right {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator>>';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator>>';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator>>';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator>>';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret    
 }
 
 sub op_shift_left {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator<<';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator<<';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator<<';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator<<';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret
 }
 
 sub op_lesser_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator<=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator<=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     return ($_[2] ? $_[1] : $_[0]) unless $err = $@;
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     my $ret;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator<=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator<=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@; 
     $ret
 }
 
 sub op_greater_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator>=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator>=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return ($_[2] ? $_[1] : $_[0]) unless $err = $@;
     my $ret;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator>=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator>=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@; 
     $ret
 }
 
 sub op_xor_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator^=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator^=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return ($_[2] ? $_[1] : $_[0]) unless $err = $@;
     my $ret;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator^=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator^=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@; 
     $ret
 }
 
 sub op_or_equal {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator|=';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator|=';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return ($_[2] ? $_[1] : $_[0]) unless $err = $@;
     my $ret;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator|=';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator|=';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@; 
     $ret
 }
 
 sub op_greater {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator>';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator>';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator>';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator>';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret    
 }
 
 sub op_lesser {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator<';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator<';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator<';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator<';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret    
 }
 
 sub op_plus {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator+';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator+';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator+';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator+';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret    
 }
 
 sub op_minus {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator-';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator-';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator-';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator-';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret    
 }
 
 sub op_mul {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator*';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator*';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator*';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator*';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret     
 }
 
 sub op_div {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator/';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator/';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator/';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator/';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret     
 }
 
 sub op_negate {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator-';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator-';
     my $autoload = ref($_[0])."::AUTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->($_[0]) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator-';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator-';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload($_[0]) };
     die $err.$@ if $@;
     $ret
 }
 
 sub op_xor {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator^';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator^';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator^';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator^';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret    
 }
 
 sub op_or {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator|';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator|';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my ($ret, $err);
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $ret = $autoload->(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $ret unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator|';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator|';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; $ret = &$autoload(($_[2] ? (@_)[1,0] : (@_)[0,1])) };
     die $err.$@ if $@;
     $ret    
 }
 
 sub op_increment {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator++';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator++';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->($_[0]) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $_[0] unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator++';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator++';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; &$autoload($_[0]) };
     die $err.$@ if $@; 
     $_[0]
 }
 
 sub op_decrement {
-    $Qt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator--';
+    $TQt::AutoLoad::AUTOLOAD = ref($_[0]).'::operator--';
     my $autoload = ref($_[0])."::_UTOLOAD";
     my $err;
-    $Qt::_internal::strictArgMatch = 1;
+    $TQt::_internal::strictArgMatch = 1;
     eval { local $SIG{'__DIE__'}; $autoload->($_[0]) };
-    $Qt::_internal::strictArgMatch = 0;
+    $TQt::_internal::strictArgMatch = 0;
     return $_[0] unless $err = $@;
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GlobalSpace::operator--';
-    $autoload = "Qt::GlobalSpace::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GlobalSpace::operator--';
+    $autoload = "TQt::GlobalSpace::_UTOLOAD";
     eval { local $SIG{'__DIE__'}; &$autoload($_[0]) };
     die $err.$@ if $@;
     $_[0]
 }
 
-package Qt::_internal;
+package TQt::_internal;
 
 use strict;
 
@@ -414,41 +414,41 @@ sub init_class {
     no strict 'refs';
     my $c = shift;
     my $class = $c;
-    $class =~ s/^Q(?=[A-Z])/Qt::/;
-    my $classId = Qt::_internal::idClass($c);
+    $class =~ s/^Q(?=[A-Z])/TQt::/;
+    my $classId = TQt::_internal::idClass($c);
     insert_pclassid($class, $classId);
 
     $IdClass[$classId] = $class;
     $CppName{$class} = $c;
-    Qt::_internal::installautoload("$class");
+    TQt::_internal::installautoload("$class");
     {
-	package Qt::AutoLoad;   # this package holds $AUTOLOAD
+	package TQt::AutoLoad;   # this package holds $AUTOLOAD
 	my $closure = \&{ "$class\::_UTOLOAD" };
 	*{ $class . "::AUTOLOAD" } =  sub{ &$closure };
     }
 
-    my @isa = Qt::_internal::getIsa($classId);
+    my @isa = TQt::_internal::getIsa($classId);
     for my $super (@isa) {
-	$super =~ s/^Q(?=[A-Z])/Qt::/;
+	$super =~ s/^Q(?=[A-Z])/TQt::/;
     }
-    # the general base class is Qt::base.
+    # the general base class is TQt::base.
     # implicit new(@_) calls are forwarded there.
-    @isa = ("Qt::base") unless @isa;
+    @isa = ("TQt::base") unless @isa;
     *{ "$class\::ISA" } = \@isa;
 
-    Qt::_internal::installautoload(" $class");
+    TQt::_internal::installautoload(" $class");
     {
-	package Qt::AutoLoad;
+	package TQt::AutoLoad;
 	# do lookup at compile-time
 	my $autosub = \&{ " $class\::_UTOLOAD" };
 	*{ " $class\::AUTOLOAD" } = sub { &$autosub };
     }
 
-    *{ " $class\::ISA" } = ["Qt::base::_overload"];
+    *{ " $class\::ISA" } = ["TQt::base::_overload"];
 
     *{ "$class\::NEW" } = sub {
 	my $class = shift;
-	$Qt::AutoLoad::AUTOLOAD = "$class\::$c";
+	$TQt::AutoLoad::AUTOLOAD = "$class\::$c";
 	my $autoload = " $class\::_UTOLOAD";
         {
             no warnings;
@@ -482,9 +482,9 @@ sub argmatch {
 		$match{$method} = [0,$methix];
 	    }
 	} elsif($argtype eq 's') {
-	    if($typename =~ /^(?:(?:const )?u?char\*|(?:const )?(?:(Q(C?)String)|QByteArray)[*&]?)$/) {
+	    if($typename =~ /^(?:(?:const )?u?char\*|(?:const )?(?:(Q(C?)String)|TQByteArray)[*&]?)$/) {
 		# the below read as: is it a (Q(C)String) ? ->priority 1
-		# is it a (QString)  ? -> priority 2
+		# is it a (TQString)  ? -> priority 2
 		# neither: normal priority
 		# Watch the capturing parens vs. non-capturing (?:)
 		$match{$method}[0] = defined $2 && $2 ? 1 : ( defined $1 ? 2 : 0 );
@@ -493,13 +493,13 @@ sub argmatch {
 	} elsif($argtype eq 'a') {
             # FIXME: shouldn't be hardcoded. Installed handlers should tell what perl type they expect.
             if($typename =~ /^(?:
-                                const\ QCOORD\*|
+                                const\ TQCOORD\*|
                                 (?:const\ )?
                                 (?:
                                   Q(?:String|Widget|Object|FileInfo|CanvasItem)List[\*&]?|
-                                  QValueList<int>[\*&]?|
-                                  QPtrList<Q(?:Tab|ToolBar|DockWindow|NetworkOperation)>|
-                                  QRgb\*|
+                                  TQValueList<int>[\*&]?|
+                                  TQPtrList<Q(?:Tab|ToolBar|DockWindow|NetworkOperation)>|
+                                  TQRgb\*|
                                   char\*\*
                                 )
                               )$/x) {
@@ -553,8 +553,8 @@ sub do_autoload {
 	}
     }
     my @methodids = map { findMethod($class, $_) } @methods;
-#   @methodids = map { findMethod('QGlobalSpace', $_) } @methods 
-#			if (!@methodids and $withObject || $class eq 'Qt');
+#   @methodids = map { findMethod('TQGlobalSpace', $_) } @methods 
+#			if (!@methodids and $withObject || $class eq 'TQt');
 
     if(@methodids > 1) {
 	# ghetto method resolution
@@ -567,11 +567,11 @@ sub do_autoload {
             my $c = ($method eq $class)? 4:2;
             warn "Ambiguous method call for :\n".
                 "\t${class}::${method}(".catArguments(\@_).")".
-             ((debug() && (debug() & $Qt::debug::channel{'verbose'})) ?
+             ((debug() && (debug() & $TQt::debug::channel{'verbose'})) ?
              "\nCandidates are:\n".dumpCandidates(\@methodids).
              "\nTaking first one...\nat " : "").
              (caller($c))[1]." line ".(caller($c))[2].".\n"
-        } if debug() && @methodids > 1 && (debug() & $Qt::debug::channel{'ambiguous'});
+        } if debug() && @methodids > 1 && (debug() & $TQt::debug::channel{'ambiguous'});
 
     }
     elsif( @methodids == 1 and @_ ) {
@@ -585,17 +585,17 @@ sub do_autoload {
                     my $c = ($method eq $class)? 4:2;
                     warn "Lookup for ${class}::${method}(".catArguments(\@_).
                          ")\ndid not yeld any result.\n".
-                         ((debug() && (debug() & $Qt::debug::channel{'verbose'})) ?
+                         ((debug() && (debug() & $TQt::debug::channel{'verbose'})) ?
                          "Might be a call for an enumerated value (enum).\n":"").
                          "Trying ${class}::${method}() with no arguments\nat ".
                          (caller($c))[1]." line ".(caller($c))[2].".\n"
-                } if debug() && @_ > 1 && (debug() & $Qt::debug::channel{'ambiguous'});
+                } if debug() && @_ > 1 && (debug() & $TQt::debug::channel{'ambiguous'});
                 @_ = ()
             } if @methodids;
 	}
 	do{
             my $verbose = "";
-            if(debug() && (debug() & $Qt::debug::channel{'verbose'})) {
+            if(debug() && (debug() & $TQt::debug::channel{'verbose'})) {
                 my $alt = findAllMethods( $classId );
                 getAllParents($classId, \my @sup);
                 for my $s(@sup)
@@ -627,7 +627,7 @@ sub do_autoload {
 sub init {
     no warnings;
     installthis(__PACKAGE__);
-    installthis("Qt::base");
+    installthis("TQt::base");
     $Classes = getClassList();
     for my $c (@$Classes) {
 	init_class($c);
@@ -673,19 +673,19 @@ sub getSubName
     return ( $glob =~ /^.*::(.*)$/ )[0];
 }
 
-sub Qt::Application::NEW {
+sub TQt::Application::NEW {
     my $class = shift;
     my $argv = shift;
     unshift @$argv, $0;
     my $count = scalar @$argv;
-    setThis( bless Qt::Application::QApplication($count, $argv, @_), " $class" );
+    setThis( bless TQt::Application::TQApplication($count, $argv, @_), " $class" );
     mapObject(this);
     setAllocated(this, 1);
     setqapp(this);
     shift @$argv;
 }
 
-sub Qt::Image::NEW {
+sub TQt::Image::NEW {
     no strict 'refs';
     # another ugly hack, whee
     my $class = shift;
@@ -696,8 +696,8 @@ sub Qt::Image::NEW {
     }
 
     # FIXME: this is evil
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::Image::QImage';
-    my $autoload = " Qt::Image::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::Image::TQImage';
+    my $autoload = " TQt::Image::_UTOLOAD";
     dontRecurse();
     setThis( $autoload->(@_) );
     setAllocated(this, 1);
@@ -710,19 +710,19 @@ sub makeMetaData {
 	my @params;
 	my $argcnt = scalar @{ $entry->{arguments} };
 	for my $arg (@{ $entry->{arguments} }) {
-	    push @params, make_QUParameter($arg->{name}, $arg->{type}, 0, 1);
+	    push @params, make_TQUParameter($arg->{name}, $arg->{type}, 0, 1);
 	}
-	my $method = make_QUMethod($entry->{name}, \@params);
-	push @tbl, make_QMetaData($entry->{prototype}, $method);
+	my $method = make_TQUMethod($entry->{name}, \@params);
+	push @tbl, make_TQMetaData($entry->{prototype}, $method);
     }
     my $count = scalar @tbl;
-    my $metadata = make_QMetaData_tbl(\@tbl);
+    my $metadata = make_TQMetaData_tbl(\@tbl);
     return ($metadata, $count);
 }
 
 # This is the key function for signal/slots...
-# All META hash entries have been defined by /lib/Qt/slots.pm and /lib/Qt/signals.pm
-# Thereafter, /lib/Qt/isa.pm build the MetaObject by calling this function
+# All META hash entries have been defined by /lib/TQt/slots.pm and /lib/TQt/signals.pm
+# Thereafter, /lib/TQt/isa.pm build the MetaObject by calling this function
 # Here is the structure of the META hash:
 # META { 'slot' => { $slotname-1 => { name      =>  $slotname-1,
 #                                     arguments => xxx,
@@ -750,7 +750,7 @@ sub getMetaObject {
     inheritSuperSigSlots($class);
     my($slot_tbl, $slot_tbl_count) = makeMetaData($meta->{slots});
     my($signal_tbl, $signal_tbl_count) = makeMetaData($meta->{signals});
-    $meta->{object} = make_metaObject($class, Qt::this()->staticMetaObject,
+    $meta->{object} = make_metaObject($class, TQt::this()->staticMetaObject,
 		$slot_tbl, $slot_tbl_count,
 		$signal_tbl, $signal_tbl_count);
     $meta->{changed} = 0;
@@ -759,11 +759,11 @@ sub getMetaObject {
 
 sub updateSigSlots
 {
-    require Qt::signals;
-    require Qt::slots;
+    require TQt::signals;
+    require TQt::slots;
     for my $i (@sigslots) {
         no strict 'refs';
-        my $mod = "Qt::" . lc($$i[0]) . ( substr($$i[0], 0, 1) eq 'S' ? 's' : '' ) . "::import";
+        my $mod = "TQt::" . lc($$i[0]) . ( substr($$i[0], 0, 1) eq 'S' ? 's' : '' ) . "::import";
         $mod->( $$i[1], getSubName($$i[2]) => $$i[3] );
     }
     @sigslots = ();
@@ -790,12 +790,12 @@ sub inheritSuperSigSlots {
                    push @{$meta->{signals}}, \%ss;
                    $meta->{signal}->{$ssn} = \%ss;
                    $ss{index} = $#{ $meta->{signals} };
-                   Qt::_internal::installsignal("$class\::$ssn");
+                   TQt::_internal::installsignal("$class\::$ssn");
                }
             }
-            Qt::_internal::installqt_invoke($class . '::qt_invoke')
+            TQt::_internal::installqt_invoke($class . '::qt_invoke')
                 if( !defined &{ $class. '::qt_invoke' } && exists $meta->{slots} && @{ $meta->{slots} });
-            Qt::_internal::installqt_invoke($class . '::qt_emit')
+            TQt::_internal::installqt_invoke($class . '::qt_emit')
                 if( !defined &{ $class. '::qt_emit' } && exists $meta->{signals} && @{ $meta->{signals} });
         }
     }
@@ -805,46 +805,46 @@ sub getAllParents
 {
    my $classId = shift;
    my $res = shift;
-   my @classes = Qt::_internal::getIsa( $classId );
+   my @classes = TQt::_internal::getIsa( $classId );
    for my $s( @classes )
    {
-       my $c = Qt::_internal::idClass($s);
+       my $c = TQt::_internal::idClass($s);
        push @{ $res }, $c;
        getAllParents($c, $res)
    }
 }
 
-sub Qt::PointArray::setPoints {
+sub TQt::PointArray::setPoints {
     my $points = $_[0];
     no strict 'refs';
     # what a horrible, horrible way to do this
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::PointArray::setPoints';
-    my $autoload = " Qt::PointArray::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::PointArray::setPoints';
+    my $autoload = " TQt::PointArray::_UTOLOAD";
     dontRecurse();
     $autoload->(scalar(@$points)/2, $points);
 }
 
-sub Qt::GridLayout::addMultiCellLayout {
-    # yet another hack. Turnaround for a bug in Qt < 3.1
-    # (addMultiCellLayout doesn't reparent its QLayout argument)
+sub TQt::GridLayout::addMultiCellLayout {
+    # yet another hack. Turnaround for a bug in TQt < 3.1
+    # (addMultiCellLayout doesn't reparent its TQLayout argument)
     no strict 'refs';
     if(!defined $_[0]->{'has been hidden'})
     {
         push @{ this()->{'hidden children'} }, $_[0];
         $_[0]->{'has been hidden'} = 1;
     }
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::GridLayout::addMultiCellLayout';
-    my $autoload = " Qt::GridLayout::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::GridLayout::addMultiCellLayout';
+    my $autoload = " TQt::GridLayout::_UTOLOAD";
     dontRecurse();
     $autoload->(@_);
 }
 
-package Qt::Object;
+package TQt::Object;
 use strict;
 
 sub  MODIFY_CODE_ATTRIBUTES
 {
-    package Qt::_internal;
+    package TQt::_internal;
     my ($package, $coderef, @attrs ) = @_;
     my @reject;
     foreach my $attr( @attrs )
@@ -866,7 +866,7 @@ sub  MODIFY_CODE_ATTRIBUTES
     return @reject;
 }
 
-package Qt;
+package TQt;
 
 use 5.006;
 use strict;
@@ -877,22 +877,22 @@ require Exporter;
 
 our $VERSION = '3.008';
 
-our @EXPORT = qw(&SIGNAL &SLOT &CAST &emit &min &max);
+our @EXPORT = qw(&TQT_SIGNAL &TQT_SLOT &CAST &emit &min &max);
 
-XSLoader::load 'Qt', $VERSION;
+XSLoader::load 'TQt', $VERSION;
 
 # try to avoid KDE's buggy malloc
 # only works for --enable-fast-malloc,
 # not when --enable-fast-malloc=full
 $ENV{'KDE_MALLOC'} = 0;
 
-Qt::_internal::init();
+TQt::_internal::init();
 
 # In general, I'm not a fan of prototypes.
 # However, I'm also not a fan of parentheses
 
-sub SIGNAL ($) { '2' . $_[0] }
-sub SLOT ($) { '1' . $_[0] }
+sub TQT_SIGNAL ($) { '2' . $_[0] }
+sub TQT_SLOT ($) { '1' . $_[0] }
 sub CAST ($$) { bless $_[0], " $_[1]" }
 sub emit (@) { pop @_ }
 sub min ($$) { $_[0] < $_[1] ? $_[0] : $_[1] }
@@ -900,11 +900,11 @@ sub max ($$) { $_[0] > $_[1] ? $_[0] : $_[1] }
 
 sub import { goto &Exporter::import }
 
-sub Qt::base::ON_DESTROY { 0 };
+sub TQt::base::ON_DESTROY { 0 };
 
-sub Qt::Object::ON_DESTROY
+sub TQt::Object::ON_DESTROY
 {
-    package Qt::_internal;
+    package TQt::_internal;
     my $parent = this()->parent;
     if( $parent )
     {
@@ -915,18 +915,18 @@ sub Qt::Object::ON_DESTROY
     return 0
 }
 
-sub Qt::Application::ON_DESTROY { 0 }
+sub TQt::Application::ON_DESTROY { 0 }
 
-# we need to solve an ambiguity for Q*Items: they aren't QObjects,
+# we need to solve an ambiguity for Q*Items: they aren't TQObjects,
 # and are meant to be created on the heap / destroyed manually.
-# On the one hand, we don't want to delete them if they are still owned by a QObject hierarchy
+# On the one hand, we don't want to delete them if they are still owned by a TQObject hierarchy
 # but on the other hand, what can we do if the user DOES need to destroy them?
 #
 # So the solution adopted here is to use the takeItem() method when it exists
 # to lower the refcount and allow explicit destruction/removal.
 
-sub Qt::ListViewItem::ON_DESTROY {
-    package Qt::_internal;
+sub TQt::ListViewItem::ON_DESTROY {
+    package TQt::_internal;
     my $parent = this()->listView();
     if( $parent )
     {
@@ -939,35 +939,35 @@ sub Qt::ListViewItem::ON_DESTROY {
     return 0
 }
 
-sub Qt::ListViewItem::takeItem
+sub TQt::ListViewItem::takeItem
 {
-    package Qt::_internal;
+    package TQt::_internal;
     delete ${ this()->{"hidden children"} } { sv_to_ptr($_[0]) };
     delete $_[0]->{"has been hidden"};
     setAllocated( $_[0], 1 );
     no strict 'refs';
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::ListViewItem::takeItem';
-    my $autoload = " Qt::ListViewItem::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::ListViewItem::takeItem';
+    my $autoload = " TQt::ListViewItem::_UTOLOAD";
     dontRecurse();
     $autoload->( $_[0] );
 }
 
-sub Qt::ListView::takeItem
+sub TQt::ListView::takeItem
 {
-    package Qt::_internal;
+    package TQt::_internal;
     delete ${ this()->{"hidden children"} } { sv_to_ptr($_[0]) };
     delete $_[0]->{"has been hidden"};
     setAllocated( $_[0], 1 );
     no strict 'refs';
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::ListView::takeItem';
-    my $autoload = " Qt::ListView::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::ListView::takeItem';
+    my $autoload = " TQt::ListView::_UTOLOAD";
     dontRecurse();
     $autoload->( $_[0] );
 }
 
-sub Qt::IconViewItem::ON_DESTROY
+sub TQt::IconViewItem::ON_DESTROY
 {
-    package Qt::_internal;
+    package TQt::_internal;
     my $parent = this()->iconView;
     if( $parent )
     {
@@ -980,23 +980,23 @@ sub Qt::IconViewItem::ON_DESTROY
     return 0
 }
 
-sub Qt::IconView::takeItem
+sub TQt::IconView::takeItem
 {
-    package Qt::_internal;
+    package TQt::_internal;
     delete ${ this()->{"hidden children"} } { sv_to_ptr($_[0]) };
     delete $_[0]->{"has been hidden"};
     setAllocated( $_[0], 1 );
     no strict 'refs';
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::IconView::takeItem';
-    my $autoload = " Qt::IconView::_UTOLOAD";
-    Qt::_internal::dontRecurse();
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::IconView::takeItem';
+    my $autoload = " TQt::IconView::_UTOLOAD";
+    TQt::_internal::dontRecurse();
     $autoload->( $_[0] );
 }
 
 
-sub Qt::ListBoxItem::ON_DESTROY
+sub TQt::ListBoxItem::ON_DESTROY
 {
-    package Qt::_internal;
+    package TQt::_internal;
     my $parent = this()->listBox();
     if( $parent )
     {
@@ -1009,24 +1009,24 @@ sub Qt::ListBoxItem::ON_DESTROY
     return 0
 }
 
-sub Qt::ListBox::takeItem
+sub TQt::ListBox::takeItem
 {
     # Unfortunately, takeItem() won't reset the Item's listBox() pointer to 0.
-    # That's a Qt bug (I reported it and it got fixed as of Qt 3.2b2)
-    package Qt::_internal;
+    # That's a TQt bug (I reported it and it got fixed as of TQt 3.2b2)
+    package TQt::_internal;
     delete ${ this()->{"hidden children"} } { sv_to_ptr($_[0]) };
     delete $_[0]->{"has been hidden"};
     setAllocated( $_[0], 1 );
     no strict 'refs';
-    $Qt::Autoload::AUTOLOAD = 'Qt::ListBox::takeItem';
-    my $autoload = " Qt::ListBox::_UTOLOAD";
+    $TQt::Autoload::AUTOLOAD = 'TQt::ListBox::takeItem';
+    my $autoload = " TQt::ListBox::_UTOLOAD";
     dontRecurse();
     $autoload->( $_[0] );
 }
 
-sub Qt::TableItem::ON_DESTROY
+sub TQt::TableItem::ON_DESTROY
 {
-    package Qt::_internal;
+    package TQt::_internal;
     my $parent = this()->table;
     if( $parent )
     {
@@ -1039,22 +1039,22 @@ sub Qt::TableItem::ON_DESTROY
     return 0
 }
 
-sub Qt::Table::takeItem
+sub TQt::Table::takeItem
 {
-    package Qt::_internal;
+    package TQt::_internal;
     delete ${ this()->{"hidden children"} } { sv_to_ptr($_[0]) };
     delete $_[0]->{"has been hidden"};
     setAllocated( $_[0], 1 );
     no strict 'refs';
-    $Qt::AutoLoad::AUTOLOAD = 'Qt::Table::takeItem';
-    my $autoload = " Qt::Table::_UTOLOAD";
+    $TQt::AutoLoad::AUTOLOAD = 'TQt::Table::takeItem';
+    my $autoload = " TQt::Table::_UTOLOAD";
     dontRecurse();
     $autoload->( $_[0] );
 }
 
-sub Qt::LayoutItem::ON_DESTROY
+sub TQt::LayoutItem::ON_DESTROY
 {
-    package Qt::_internal;
+    package TQt::_internal;
     my $parent = this()->widget() || this()->layout();
     if( $parent )
     {
@@ -1069,9 +1069,9 @@ sub Qt::LayoutItem::ON_DESTROY
     return 1
 }
 
-sub Qt::Layout::ON_DESTROY
+sub TQt::Layout::ON_DESTROY
 {
-    package Qt::_internal;
+    package TQt::_internal;
     my $parent = this()->mainWidget() || this()->parent();
     if( $parent )
     {
@@ -1082,9 +1082,9 @@ sub Qt::Layout::ON_DESTROY
     return 0
 }
 
-sub Qt::StyleSheetItem::ON_DESTROY
+sub TQt::StyleSheetItem::ON_DESTROY
 {
-    package Qt::_internal;
+    package TQt::_internal;
     my $parent = this()->styleSheet();
     if( $parent )
     {
@@ -1097,9 +1097,9 @@ sub Qt::StyleSheetItem::ON_DESTROY
     return 0
 }
 
-sub Qt::SqlCursor::ON_DESTROY
+sub TQt::SqlCursor::ON_DESTROY
 {
-    package Qt::_internal;
+    package TQt::_internal;
     push @PersistentObjects, this();
     this()->{"has been hidden"} = 1;
     setAllocated( this(), 0 );