As KPacman didn't use tr() but KDE's i18n() is did a simple

perl -pi~ -e 's/i18n/tr/g' *.cpp

8 files changed, 81 insertions, 81 deletions

diff --git a/noncore/games/kpacman/board.cpp b/noncore/games/kpacman/board.cpp
index 849e75b..f95f699 100644
--- a/noncore/games/kpacman/board.cpp
+++ b/noncore/games/kpacman/board.cpp
@@ -28,69 +28,69 @@ Board::Board(int size) : QArray<int> (size)
 void Board::init(Image image, QString levelName)
 {
     prisonEntry = OUT;
     prisonExit = OUT;
     fruitHome = OUT;
     fruitPosition = OUT;
     pacmanHome = OUT;
     pacmanPosition = OUT;
     for (int m = 0; m < 8; m++) {
         monsterHome[m] = OUT;
         monsterPosition[m] = OUT;
     }
     for (int e = 0; e < 8; e++) {
         energizerPosition[e] = OUT;
     }
     for (int e = 0; e < 8; e++) {
         tunnelPosition[e] = OUT;
     }
 
     fill(0);
     numPoints = 0;
     numEnergizers = 0;
     numMonsters = 0;
     numTunnels = 0;
 
     if (!levelName.isNull() && !levelName.isEmpty())
         if (mapName == levelName)
             image = File;
         else {
             QFile levelFile(levelName);
             if (!levelFile.open(IO_ReadOnly)) {
 
-                QString msg = i18n("The levelmap could not be constructed.\n\n"
+                QString msg = "The levelmap could not be constructed.\n\n"
                                    "The file '@LEVELNAME@' does not exist,\n"
-                                   "or could not be opened for reading.");
+                                   "or could not be opened for reading.";
                 msg.replace(QRegExp("@LEVELNAME@"), levelName);
-                // QMessageBox::information(0, i18n("Initialization Error"), msg);
+                // QMessageBox::information(0, tr("Initialization Error"), msg);
                 printf("%s\n", msg.data());
             } else {
                 map.fill(' ', BoardHeight*BoardWidth);
                 int height = 0; 
 
                 QTextStream levelStream(&levelFile);
                 while (!levelStream.eof() && height < BoardHeight) {
                     QString line = levelStream.readLine();
                 
                     if (line.find(QRegExp("^ *;")) == -1) {     
 
                         line.replace(QRegExp(";.*"), "");       // strip off comments
                         line.replace(QRegExp("\" *$"), "");     // strip off trailing "
                         line.replace(QRegExp("^ *\""), "");     // strip off leading "
 
                         map.replace(height*BoardWidth,
                                     (line.length() > BoardWidth) ? BoardWidth : line.length(),
                                     line.data());
 
                         height++;
                     }
                 }
                 mapName = levelName;
                 levelFile.close();
                 image = File;
             }
         }
 
     switch (image) {
         case Intro : // setup(demo_bits);
                      break;
         case Demo  : setup(demo_bits);
diff --git a/noncore/games/kpacman/keys.cpp b/noncore/games/kpacman/keys.cpp
index c609373..8b17785 100644
--- a/noncore/games/kpacman/keys.cpp
+++ b/noncore/games/kpacman/keys.cpp
@@ -1,141 +1,141 @@
 
 #include "portable.h"
 
 #if defined( KDE2_PORT )
 #include <kapp.h>
 #include <kconfig.h>
 #include <klocale.h>
 #include <kstddirs.h>
 #include <kaccel.h>
 
 #include <keys.h>
 #include <keys.moc>
 #elif defined( QPE_PORT )
 #include <qaccel.h>
 #include <qpe/qpeapplication.h>
 #include "config.h"
 #include "keys.h"
 #endif
 
 #include <qpushbt.h>
 #include <qlabel.h>
 #include <qframe.h>
 #include <qkeycode.h>
 #include <qpixmap.h>
 #include <qstring.h>
 
 Keys::Keys( QWidget *parent, const char *name)
     : QDialog( parent, name, TRUE )
 {
     //KStandardDirs *dirs = KGlobal::dirs();
 
     QPushButton *okButton  = new QPushButton(this);
-    okButton->setText(i18n("Ok"));
+    okButton->setText(tr("Ok"));
     okButton->setFixedSize(okButton->size());
     connect( okButton, SIGNAL(clicked()),this, SLOT(ok()) );
     okButton->move(20,210);
 
     QPushButton *defaultButton  = new QPushButton(this);
-    defaultButton->setText(i18n("Defaults"));
+    defaultButton->setText(tr("Defaults"));
     defaultButton->setFixedSize(defaultButton->size());
     connect( defaultButton, SIGNAL(clicked()),this, SLOT(defaults()) );
     defaultButton->move(140,210);
 
     QPushButton *cancelButton  = new QPushButton(this);
-    cancelButton->setText(i18n("Cancel"));
+    cancelButton->setText(tr("Cancel"));
     cancelButton->setFixedSize(cancelButton->size());
     connect( cancelButton, SIGNAL(clicked()),this, SLOT(reject()) );
     cancelButton->move(260,210);
 
     QFrame *separator = new QFrame(this);
     separator->setFrameStyle( QFrame::HLine | QFrame::Sunken );
     separator->setGeometry( 20, 190, 340, 4 );
 
     for ( int x = 0; x < 4; x++) {
             QLabel *l = new QLabel(this);
             l->setAlignment(AlignCenter);
             labels[x] = l;
     }
 
     labels[0]->setGeometry(120, 20, 140, 20 );
     labels[1]->setGeometry(120,160, 140, 20 );
     labels[2]->setGeometry( 20, 92, 100, 20 );
     labels[3]->setGeometry(265, 92, 100, 20 );
 
     QString pixPath;
 
     QPushButton *up = new QPushButton(this);
     pixPath = FIND_APP_DATA( "pics/up.xpm" );
     up->setPixmap( QPixmap(pixPath));
     up->setFixedSize(up->pixmap()->size());
     connect( up, SIGNAL(clicked()),this, SLOT(butUp()) );
     up->move(180, 50);
 
     QPushButton *down = new QPushButton(this);
     pixPath = FIND_APP_DATA( "pics/down.xpm");
     down->setPixmap( QPixmap(pixPath));
     down->setFixedSize(down->pixmap()->size());
     connect( down, SIGNAL(clicked()),this, SLOT(butDown()) );
     down->move(180, 130);
 
     QPushButton *left = new QPushButton(this);
     pixPath = FIND_APP_DATA( "pics/left.xpm");
     left->setPixmap( QPixmap(pixPath));
     left->setFixedSize(left->pixmap()->size());
     connect( left, SIGNAL(clicked()),this, SLOT(butLeft()) );
     left->move(140, 90);
 
     QPushButton *right = new QPushButton(this);
     pixPath = FIND_APP_DATA( "pics/right.xpm");
     right->setPixmap( QPixmap(pixPath));
     right->setFixedSize(right->pixmap()->size());
     connect( right, SIGNAL(clicked()),this, SLOT(butRight()) );
     right->move(220, 90);
 
 
-    setCaption(i18n("Change Direction Keys"));
+    setCaption(tr("Change Direction Keys"));
     setFixedSize(380, 260);
     lab = 0;
     init();
 }
 
 void Keys::keyPressEvent( QKeyEvent *e )
 {
         uint kCode = e->key() & ~(SHIFT | CTRL | ALT);
         QString string = KAccel::keyToString(kCode);
 
         if (lab != 0) {
             if ( string.isNull() )
-                    lab->setText(i18n("Undefined key"));
+                    lab->setText(tr("Undefined key"));
             else
                 lab->setText(string);
         }
         else if ( lab == 0 && e->key() == Key_Escape)
             reject();
 }
 
 void Keys::butUp()
 {
     getKey(0);
 }
 
 void Keys::butDown()
 {
     getKey(1);
 }
 
 void Keys::butLeft()
 {
     getKey(2);
 }
 
 void Keys::butRight()
 {
     getKey(3);
 }
 
 void Keys::getKey(int i)
 {
     if ( lab != 0)
             focusOut(lab);
 
diff --git a/noncore/games/kpacman/kpacman.cpp b/noncore/games/kpacman/kpacman.cpp
index 4077085..7df6ef0 100644
--- a/noncore/games/kpacman/kpacman.cpp
+++ b/noncore/games/kpacman/kpacman.cpp
@@ -58,133 +58,133 @@ Kpacman::Kpacman(QWidget *parent, const char *name)
     focusInContinue = !cfg->readBoolEntry("FocusInContinue", TRUE);
     hideMouseCursor = !cfg->readBoolEntry("HideMouseCursor", TRUE);
     APP_CONFIG_END( cfg );
 
     toggleFocusOutPause();
     toggleFocusInContinue();
     toggleHideMouseCursor();
 
 #ifndef QWS
     menuBar->show();
     view->show();
     setMenu(menuBar);
     setView(view);
 #else
     setCentralWidget( view );
 #endif
 }
 
 Kpacman::~Kpacman()
 {
     APP_CONFIG_BEGIN( cfg );
     cfg->writeEntry("FocusOutPause", focusOutPause);
     cfg->writeEntry("FocusInContinue", focusInContinue);
     cfg->writeEntry("HideMouseCursor", hideMouseCursor);
     APP_CONFIG_END( cfg );
     delete _menuBar;
 }
 
 void Kpacman::menu()
 {
     gamePopup = new QPopupMenu();
     CHECK_PTR( gamePopup );
-    newID = gamePopup->insertItem(i18n("&New"), this, SLOT(newKpacman()),Key_F2);
-    pauseID = gamePopup->insertItem(i18n("&Pause"),
+    newID = gamePopup->insertItem(tr("&New"), this, SLOT(newKpacman()),Key_F2);
+    pauseID = gamePopup->insertItem(tr("&Pause"),
                                     this, SLOT(pauseKpacman()), Key_F3);
-    hofID = gamePopup->insertItem(i18n("&Hall of fame"),
+    hofID = gamePopup->insertItem(tr("&Hall of fame"),
                                     this, SLOT(toggleHallOfFame()), Key_F4);
     gamePopup->insertSeparator();
-    gamePopup->insertItem(i18n("&Quit"), this, SLOT(quitKpacman()), CTRL+Key_Q);
+    gamePopup->insertItem(tr("&Quit"), this, SLOT(quitKpacman()), CTRL+Key_Q);
     gamePopup->setCheckable(TRUE);
 
     optionsPopup = new QPopupMenu();
     CHECK_PTR(optionsPopup);
 
     modesPopup = new QPopupMenu();
     CHECK_PTR(modesPopup);
 
-    hideMouseCursorID = optionsPopup->insertItem(i18n("&Hide Mousecursor"),
+    hideMouseCursorID = optionsPopup->insertItem(tr("&Hide Mousecursor"),
                                                  this, SLOT(toggleHideMouseCursor()),
                                                  CTRL+Key_H);
     optionsPopup->insertSeparator();
 
     if (lookupSchemes() > 0) {
-        optionsPopup->insertItem(i18n("&Select graphic scheme"),  modesPopup);
+        optionsPopup->insertItem(tr("&Select graphic scheme"),  modesPopup);
         optionsPopup->insertSeparator();
     }
 
-    focusOutPauseID = optionsPopup->insertItem(i18n("&Pause in Background"),
+    focusOutPauseID = optionsPopup->insertItem(tr("&Pause in Background"),
                                                this, SLOT(toggleFocusOutPause()));
-    focusInContinueID = optionsPopup->insertItem(i18n("&Continue in Foreground"),
+    focusInContinueID = optionsPopup->insertItem(tr("&Continue in Foreground"),
                                               this, SLOT(toggleFocusInContinue()));
     optionsPopup->insertSeparator();
 
-    optionsPopup->insertItem(i18n("Change &keys..."), this, SLOT(confKeys()));
+    optionsPopup->insertItem(tr("Change &keys..."), this, SLOT(confKeys()));
 
 #ifndef QWS
-    QString aboutText = i18n("@PACKAGE@ - @VERSION@\n\n"
+    QString aboutText = tr("@PACKAGE@ - @VERSION@\n\n"
                              "Joerg Thoennissen (joe@dsite.de)\n\n"
                              "A pacman game for the KDE Desktop\n\n"
                              "The program based on the source of ksnake\n"
                              "by Michel Filippi (mfilippi@sade.rhein-main.de).\n"
                              "The design was strongly influenced by the pacman\n"
                              "(c) 1980 MIDWAY MFG.CO.\n\n"
                              "I like to thank my girlfriend Elke Krueers for\n"
                              "the last 10 years of her friendship.\n");
     aboutText.replace(QRegExp("@PACKAGE@"), PACKAGE);
     aboutText.replace(QRegExp("@VERSION@"), VERSION);
     QPopupMenu *helpPopup = helpMenu(aboutText, FALSE);
 #endif
 
     //_menuBar = new KMenuBar(this);
     //CHECK_PTR( _menuBar );
-    //_menuBar->insertItem(i18n("&Game"), gamePopup);
-    //_menuBar->insertItem(i18n("&Options"), optionsPopup);
+    //_menuBar->insertItem(tr("&Game"), gamePopup);
+    //_menuBar->insertItem(tr("&Options"), optionsPopup);
     //_menuBar->insertSeparator();
 #ifndef QWS
-    _menuBar->insertItem(i18n("&Help"), helpPopup);
+    _menuBar->insertItem(tr("&Help"), helpPopup);
 #endif
 }
 
 int Kpacman::lookupSchemes()
 {
     APP_CONFIG_BEGIN( cfg );
     int ModeCount = cfg->readNumEntry("ModeCount", -1);
     int Mode = cfg->readNumEntry("Mode", -1);
     int SchemeCount = cfg->readNumEntry("SchemeCount");
     int Scheme = cfg->readNumEntry("Scheme", -1);
 
     if (SchemeCount == 0 || Scheme == -1) {
-        QMessageBox::warning(this, i18n("Configuration Error"),
-                                   i18n("There are no schemes defined,\n"
+        QMessageBox::warning(this, tr("Configuration Error"),
+                                   tr("There are no schemes defined,\n"
                                         "or no scheme is selected."));
         APP_CONFIG_END( cfg );
         return 0;
     }
 
     connect(modesPopup, SIGNAL(activated(int)), this, SLOT(schemeChecked(int)));
     modeID.resize(ModeCount > 0 ? ModeCount : 0);
 
     if (!schemesPopup->isEmpty())
         schemesPopup->clear();
 
     SAVE_CONFIG_GROUP( cfg, oldgroup );
 
     QString ModeGroup;
     QString ModeName;
 
     for (int m = 0; m < ModeCount; m++) {
         ModeGroup.sprintf("Mode %d", m);
         cfg->setGroup(ModeGroup);
 
         ModeName = cfg->readEntry("Description", ModeGroup);
 
         QPopupMenu *p = new QPopupMenu;
         p->setCheckable(TRUE);
         connect(p, SIGNAL(activated(int)), this, SLOT(schemeChecked(int)));
         schemesPopup->append(p);
 
         modeID[m] = modesPopup->insertItem(ModeName, schemesPopup->at(m));
         modesPopup->setItemEnabled(modeID[m], FALSE);
         modesPopup->setItemChecked(modeID[m], m == Mode);
     }
 
diff --git a/noncore/games/kpacman/kpacmanwidget.cpp b/noncore/games/kpacman/kpacmanwidget.cpp
index 330c88e..215dcda 100644
--- a/noncore/games/kpacman/kpacmanwidget.cpp
+++ b/noncore/games/kpacman/kpacmanwidget.cpp
@@ -85,69 +85,69 @@ void KpacmanWidget::confScheme()
         if (scheme != -1 || mode == -1) {
             newgroup.sprintf("Scheme %d", scheme);
             cfg->setGroup(newgroup);
 
             mode = cfg->readNumEntry("Mode", -1);
             RESTORE_CONFIG_GROUP( cfg, oldgroup );
         }
     }
 
     confMisc();
 
     if (mode != -1) {
         newgroup.sprintf("Mode %d", mode);
         cfg->setGroup(newgroup);
 
         confMisc(FALSE);
     }
 
     if (scheme != -1) {
         newgroup.sprintf("Scheme %d", scheme);
         cfg->setGroup(newgroup);
 
         confMisc(FALSE);
     }
 
     if (lastFontName != fontName) {
 
         if (bitfont != 0)
             delete bitfont;
 
         bitfont = new Bitfont(fontName, bitfontFirstChar, bitfontLastChar);
         if (bitfont->width() == 0 || bitfont->height() == 0) {
-            QString msg = i18n("The bitfont could not be contructed.\n\n"
+            QString msg = tr("The bitfont could not be contructed.\n\n"
                                "The file '@FONTNAME@' does not exist,\n"
                                "or is of an unknown format.");
             msg.replace(QRegExp("@FONTNAME@"), fontName);
-            // QMessageBox::critical(this, i18n("Initialization Error"), msg);
+            // QMessageBox::critical(this, tr("Initialization Error"), msg);
             printf("%s\n", msg.data());
         }
     }
 
     RESTORE_CONFIG_GROUP( cfg, oldgroup );
     APP_CONFIG_END( cfg );
 }
 
 void KpacmanWidget::setScheme(int Scheme, int Mode)
 {
     mode = Mode;
     scheme = Scheme;
 
     confScheme();
 
     score->setScheme(Scheme, Mode, bitfont);
     referee->setScheme(Scheme, Mode, bitfont);
     status->setScheme(Scheme, Mode);
 
 #ifndef QWS
     setFixedSize(referee->width(),
                  bitfont->height()*3 + referee->height() + status->height());
 #endif
 
     score->repaint(FALSE);
     referee->repaint(FALSE);
     status->repaint(FALSE);
 }
 
 void KpacmanWidget::resizeEvent( QResizeEvent * )
 {
     referee->setGeometry(0, bitfont->height()*3, referee->width(), referee->height());
diff --git a/noncore/games/kpacman/painter.cpp b/noncore/games/kpacman/painter.cpp
index 16fed55..80aeab0 100644
--- a/noncore/games/kpacman/painter.cpp
+++ b/noncore/games/kpacman/painter.cpp
@@ -45,69 +45,69 @@ Painter::Painter( Board *b, QWidget *parent, int Scheme, int Mode, Bitfont *font
     lastPrisonPixmapName = "";
     lastEnergizerPixmapName = "";
     lastFruitPixmapName = "";
     lastPacmanPixmapName = "";
     lastDyingPixmapName = "";
     lastEyesPixmapName = "";
     lastMonsterPixmapName = "";
     lastFruitScorePixmapName = "";
     lastMonsterScorePixmapName = "";
 
     bitfont = font;
 
     scheme = Scheme;
     mode = Mode;
     level = 0;
 
     confScheme();
 }
 
 QList<QPixmap> *Painter::loadPixmap(QWidget*, QString pixmapName,
                                     QList<QPixmap> *pixmaps)
 {
     if (pixmaps == NULL) {
         pixmaps = new QList<QPixmap>;
         pixmaps->setAutoDelete(TRUE);
     }
 
     if (!pixmaps->isEmpty())
         pixmaps->clear();
 
     QPixmap PIXMAP(pixmapName);
     if (PIXMAP.isNull() || PIXMAP.mask() == NULL) {
-        QString msg = i18n("The pixmap could not be contructed.\n\n"
+        QString msg = "The pixmap could not be contructed.\n\n"
                            "The file '@PIXMAPNAME@' does not exist,\n"
-                           "or is of an unknown format.");
+                           "or is of an unknown format.";
         msg.replace(QRegExp("@PIXMAPNAME@"), pixmapName);
-        // QMessageBox::critical(parent, i18n("Initialization Error"), msg);
+        // QMessageBox::critical(parent, tr("Initialization Error"), msg);
         printf("%s\n", msg.data());
         return 0;
     }
 
     int height = PIXMAP.height();
     int width = (height == 0) ? 0 : PIXMAP.width()/(PIXMAP.width()/height);
 
     QBitmap BITMAP;
     QBitmap MASK;
 
     BITMAP = *PIXMAP.mask();
     MASK.resize(width, height);
 
     for (int x = 0; x < PIXMAP.width()/width; x++) {
         QPixmap *pixmap = new QPixmap(width, height);
         pixmaps->append(pixmap);
         bitBlt(pixmap, 0, 0, &PIXMAP, x*width, 0, width, height, QPixmap::CopyROP, TRUE);
         bitBlt(&MASK, 0, 0, &BITMAP, x*width, 0, width, height, QPixmap::CopyROP, TRUE);
         pixmap->setMask(MASK);
     }
 
     return pixmaps;
 }
 
 QList<QPixmap> *Painter::textPixmap(QStrList &str, QList<QPixmap> *pixmaps,
                                     QColor fg, QColor bg)
 {
     if (pixmaps == NULL) {
         pixmaps = new QList<QPixmap>;
         pixmaps->setAutoDelete(TRUE);
     }
 
diff --git a/noncore/games/kpacman/referee.cpp b/noncore/games/kpacman/referee.cpp
index 567a8ed..9edaabd 100644
--- a/noncore/games/kpacman/referee.cpp
+++ b/noncore/games/kpacman/referee.cpp
@@ -66,136 +66,136 @@ Referee::Referee( QWidget *parent, const char *name, int Scheme, int Mode, Bitfo
     energizerRect = new QList<QRect>;
     energizerRect->setAutoDelete(TRUE);
 
     pacmanRect.setRect(0, 0, 0, 0);
     fruitRect.setRect(0, 0, 0, 0);
 
     QTime midnight( 0, 0, 0 );
     srand( midnight.secsTo(QTime::currentTime()) );
 
     lifes = 0;
     points = 0;
 
     emit setLifes(lifes);
     emit setPoints(points);
 
     intro();
 }
 
 void Referee::paintEvent( QPaintEvent *e)
 {
     if (gameState.testBit(HallOfFame))
         return;
 
     QRect rect = e->rect();
 
     if (!rect.isEmpty()) {
         QPixmap p = pix->levelPix();
         bitBlt(this, rect.x(), rect.y(),
                &p, rect.x(), rect.y(), rect.width(), rect.height());
     }
 
     if ((gameState.testBit(GameOver) || gameState.testBit(Demonstration)) &&
-        rect.intersects(pix->rect(board->position(fruithome), i18n("GAME  OVER"))))
-        pix->draw(board->position(fruithome), Widget, i18n("GAME  OVER"), RED);
+        rect.intersects(pix->rect(board->position(fruithome), tr("GAME  OVER"))))
+        pix->draw(board->position(fruithome), Widget, tr("GAME  OVER"), RED);
 
     for (Energizer *e = energizers->first(); e != 0; e = energizers->next()) {
         if (e && e->state() == on &&
             rect.intersects(pix->rect(e->position(), EnergizerPix)) &&
             !(e->position() == pacman->position() && gameState.testBit(Scoring))) {
             if (e->pix() != -1)
                 pix->draw(e->position(), Widget, EnergizerPix, e->pix());
         }
     }
 
     if (!gameState.testBit(Init)) {
 
         if (!gameState.testBit(Dying) && (fruit->pix() != -1))
             if (fruit->state() != active) {
                 if (rect.intersects(pix->rect(fruit->position(), FruitScorePix, fruit->pix())))
                     pix->draw(fruit->position(), Widget, FruitScorePix, fruit->pix());
             } else {
                 if (rect.intersects(pix->rect(fruit->position(), FruitPix, fruit->pix())))
                     pix->draw(fruit->position(), Widget, FruitPix, fruit->pix());
             }
 
         for (Monster *m = monsters->first(); m != 0; m = monsters->next())
             if (m && m->state() == harmless &&
                 rect.intersects(pix->rect(m->position(), MonsterPix)) &&
                 !(m->position() == pacman->position() && gameState.testBit(Scoring))) {
                 if (m->body() != -1)
                     pix->draw(m->position(), Widget, MonsterPix, m->body());
                 if (m->eyes() != -1)
                     pix->draw(m->position(), Widget, EyesPix, m->eyes());
             }
 
         if (!gameState.testBit(Scoring) && !gameState.testBit(LevelDone) &&
             rect.intersects(pix->rect(pacman->position(), PacmanPix)) && pacman->pix() != -1)
             pix->draw(pacman->position(), Widget, PacmanPix, pacman->pix());
 
         for (Monster *m = monsters->first(); m != 0; m = monsters->next())
             if (m && m->state() != harmless &&
                 rect.intersects(pix->rect(m->position(), MonsterPix)) &&
                 !(m->position() == pacman->position() && gameState.testBit(Scoring))) {
                 if (m->body() != -1)
                     pix->draw(m->position(), Widget, MonsterPix, m->body());
                 if (m->eyes() != -1)
                     pix->draw(m->position(), Widget, EyesPix, m->eyes());
             }
     }
 
     if (gameState.testBit(Scoring) &&
         rect.intersects(pix->rect(pacman->position(), MonsterScorePix, monstersEaten-1)))
         pix->draw(pacman->position(), Widget, MonsterScorePix, monstersEaten-1);
 
     if (gameState.testBit(Init) && gameState.testBit(Dying) &&
         timerCount < pix->maxPixmaps(DyingPix) &&
         rect.intersects(pix->rect(pacman->position(), PacmanPix)))
         pix->draw(pacman->position(), Widget, DyingPix, timerCount);
 
     if (gameState.testBit(LevelDone) &&
         rect.intersects(pix->rect(pacman->position(), PacmanPix)))
         pix->draw(pacman->position(), Widget, PacmanPix, pacman->pix());
 
     if (gameState.testBit(Player) &&
-        rect.intersects(pix->rect(board->position(monsterhome, 0), i18n("PLAYER ONE"))))
-        pix->draw(board->position(monsterhome, 0), Widget, i18n("PLAYER ONE"), CYAN);
+        rect.intersects(pix->rect(board->position(monsterhome, 0), tr("PLAYER ONE"))))
+        pix->draw(board->position(monsterhome, 0), Widget, tr("PLAYER ONE"), CYAN);
 
     if (gameState.testBit(Ready) &&
-        rect.intersects(pix->rect(board->position(fruithome), i18n("READY!"))))
-        pix->draw(board->position(fruithome), Widget, i18n("READY!"), YELLOW);
+        rect.intersects(pix->rect(board->position(fruithome), tr("READY!"))))
+        pix->draw(board->position(fruithome), Widget, tr("READY!"), YELLOW);
 
     if (gameState.testBit(Paused) &&
-        rect.intersects(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, i18n("PAUSED"))))
-        pix->draw((BoardWidth*BoardHeight)/2-BoardWidth, Widget, i18n("PAUSED"), RED, BLACK);
+        rect.intersects(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, tr("PAUSED"))))
+        pix->draw((BoardWidth*BoardHeight)/2-BoardWidth, Widget, tr("PAUSED"), RED, BLACK);
 }
 
 void Referee::timerEvent( QTimerEvent *e )
 {
     if (gameState.testBit(HallOfFame))
         return;
 
     QRect lastRect;
     int lastPix;
     bool moved = FALSE;
     int eated = 0;
 
     if (e->timerId() == energizerTimer) {
         for (int e = 0; e < board->energizers(); e++) {
             lastRect = pix->rect(energizers->at(e)->position(), EnergizerPix);
             lastPix = energizers->at(e)->pix();
             if (energizers->at(e)->move()) {
                 moved = TRUE;
                 *energizerRect->at(e) = pix->rect(energizers->at(e)->position(), EnergizerPix);
                 if (lastPix == energizers->at(e)->pix() &&
                     lastRect == pix->rect(energizers->at(e)->position(), EnergizerPix))
                     energizerRect->at(e)->setRect(0, 0, 0, 0);
                 else
                     *energizerRect->at(e) = pix->rect(*energizerRect->at(e), lastRect);
             }
         }
 
         for (int e = 0; e < board->energizers(); e++)
             if (!energizerRect->at(e)->isNull())
                 repaint(*energizerRect->at(e), FALSE);
 
         return;
@@ -811,157 +811,157 @@ void Referee::eaten()
         for (Monster *m = monsters->first(); m != 0; m = monsters->next())
             if (m && m->direction() == X && !gameState.testBit(Introducing))
                 m->setDirection(N);
         if (monstersEaten != 4 || !gameState.testBit(Introducing))
             QTimer::singleShot( monsterScoreDurMS, this, SLOT(start()));
     }
 }
 
 void Referee::toggleHallOfFame()
 {
     gameState.toggleBit(HallOfFame);
 }
 
 void Referee::hallOfFame()
 {
     if (gameState.testBit(HallOfFame))  // If the HallOfFame is switched on manually, toggle the
         toggleHallOfFame();             // bit twice.
 
     emit setLevel(0);                   // Clear status display for hall of fame
     emit setScore(level, 0);
     emit forcedHallOfFame(TRUE);
 }
 
 void Referee::pause()
 {
     static int pausedTimer = 0;
 
     if (!gameState.testBit(Paused)) {
         pausedTimer = gameTimer;
         stop();
         stopEnergizer();
         gameState.setBit(Paused);
-        repaint(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, i18n("PAUSED")), FALSE);
+        repaint(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, tr("PAUSED")), FALSE);
     } else {
         gameState.clearBit(Paused);
-        repaint(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, i18n("PAUSED")), FALSE);
+        repaint(pix->rect((BoardWidth*BoardHeight)/2-BoardWidth, tr("PAUSED")), FALSE);
         if (pausedTimer) {
             pausedTimer = 0;
             start();
         }
     }
     emit togglePaused();
 }
 
 void Referee::intro()
 {
     stop();
     stopEnergizer();
     bool paused = gameState.testBit(Paused);
 
     gameState.fill(FALSE);
     gameState.setBit(Introducing);
     gameState.setBit(Init);
 
     if (paused)
         gameState.setBit(Paused);
 
     level = 0;
     emit setLevel(level);
 
     board->init(Intro);
     pix->setLevel(level);
 
     initPacman();
     initFruit();
     initMonsters();
     initEnergizers();
 
     repaint();
 
     monstersEaten = 0;
     timerCount = 0;
     introPlay();
 }
 
 void Referee::introMonster(int id)
 {
     Monster *m = new Monster(board, id);
 
     m->setPosition((10+id*6)*BoardWidth+10);
     m->setDirection(E);
     m->setDangerous(dangerousTicks[level], monsterIQ[level]);
     m->setMaxPixmaps(pix->maxPixmaps(MonsterPix), pix->maxPixmaps(EyesPix));
 
     if (m->body() != -1)
         pix->draw(m->position(), RoomPix, MonsterPix, m->body());
     if (m->eyes() != -1)
         pix->draw(m->position(), RoomPix, EyesPix, m->eyes());
 
     repaint(pix->rect(m->position(), MonsterPix), FALSE);
     m->setPosition(OUT);
 }
 
 void Referee::introPaint(int t)
 {
     QString pts;
 
     switch (t) {
-        case  0 : repaint(pix->draw(16, 6, RoomPix, i18n("CHARACTER"), WHITE, QColor(), AlignLeft), FALSE);
-                  repaint(pix->draw(36, 6, RoomPix, i18n("/"), WHITE, QColor(), AlignLeft), FALSE);
-                  repaint(pix->draw(40, 6, RoomPix, i18n("NICKNAME"), WHITE, QColor(), AlignLeft), FALSE);
+        case  0 : repaint(pix->draw(16, 6, RoomPix, tr("CHARACTER"), WHITE, QColor(), AlignLeft), FALSE);
+                  repaint(pix->draw(36, 6, RoomPix, tr("/"), WHITE, QColor(), AlignLeft), FALSE);
+                  repaint(pix->draw(40, 6, RoomPix, tr("NICKNAME"), WHITE, QColor(), AlignLeft), FALSE);
                   break;
         case  1 : introMonster(0);
                   break;
-        case  2 : repaint(pix->draw(16, 10, RoomPix, i18n("-SHADOW"), RED, QColor(), AlignLeft), FALSE);
+        case  2 : repaint(pix->draw(16, 10, RoomPix, tr("-SHADOW"), RED, QColor(), AlignLeft), FALSE);
                   break;
-        case  3 : repaint(pix->draw(38, 10, RoomPix, i18n("\"BLINKY\""), RED, QColor(), AlignLeft), FALSE);
+        case  3 : repaint(pix->draw(38, 10, RoomPix, tr("\"BLINKY\""), RED, QColor(), AlignLeft), FALSE);
                   break;
         case  4 : introMonster(1);
                   break;
-        case  5 : repaint(pix->draw(16, 16, RoomPix, i18n("-SPEEDY"), PINK, QColor(), AlignLeft), FALSE);
+        case  5 : repaint(pix->draw(16, 16, RoomPix, tr("-SPEEDY"), PINK, QColor(), AlignLeft), FALSE);
                   break;
-        case  6 : repaint(pix->draw(38, 16, RoomPix, i18n("\"PINKY\""), PINK, QColor(), AlignLeft), FALSE);
+        case  6 : repaint(pix->draw(38, 16, RoomPix, tr("\"PINKY\""), PINK, QColor(), AlignLeft), FALSE);
                   break;
         case  7 : introMonster(2);
                   break;
-        case  8 : repaint(pix->draw(16, 22, RoomPix, i18n("-BASHFUL"), CYAN, QColor(), AlignLeft), FALSE);
+        case  8 : repaint(pix->draw(16, 22, RoomPix, tr("-BASHFUL"), CYAN, QColor(), AlignLeft), FALSE);
                   break;
-        case  9 : repaint(pix->draw(38, 22, RoomPix, i18n("\"INKY\""), CYAN, QColor(), AlignLeft), FALSE);
+        case  9 : repaint(pix->draw(38, 22, RoomPix, tr("\"INKY\""), CYAN, QColor(), AlignLeft), FALSE);
                   break;
         case 10 : introMonster(3);
                   break;
-        case 11 : repaint(pix->draw(16, 28, RoomPix, i18n("-POKEY"), ORANGE, QColor(), AlignLeft), FALSE);
+        case 11 : repaint(pix->draw(16, 28, RoomPix, tr("-POKEY"), ORANGE, QColor(), AlignLeft), FALSE);
                   break;
-        case 12 : repaint(pix->draw(38, 28, RoomPix, i18n("\"CLYDE\""), ORANGE, QColor(), AlignLeft), FALSE);
+        case 12 : repaint(pix->draw(38, 28, RoomPix, tr("\"CLYDE\""), ORANGE, QColor(), AlignLeft), FALSE);
                   break;
         case 13 : pts.sprintf("%d", pointScore);
                   repaint(pix->draw(28, 44, RoomPix, pts.data(), WHITE, QColor(), AlignRight), FALSE);
                   repaint(pix->draw(31, 44, RoomPix, "\x1C\x1D\x1E", WHITE, QColor(), AlignLeft), FALSE);
                   pts.sprintf("%d", energizerScore);
                   repaint(pix->draw(28, 48, RoomPix, pts.data(), WHITE, QColor(), AlignRight), FALSE);
                   repaint(pix->draw(31, 48, RoomPix, "\x1C\x1D\x1E", WHITE, QColor(), AlignLeft), FALSE);
                   break;
         case 14 : // "@ 1980 MIDWAY MFG.CO."
 #if defined( KDE2_PORT )
                   repaint(pix->draw(30, 58, RoomPix, "© 1998-2002 J.THÖNNISSEN", PINK), FALSE);
 #elif defined( QPE_PORT )
                   repaint(pix->draw(30, 55, RoomPix, "© 1998-2002 J.THÖNNISSEN", PINK), FALSE);
                   repaint(pix->draw(29, 60, RoomPix, "Qtopia port: Catalin CLIMOV", GREEN), FALSE);
 #endif
                   break;
     }
 }
 
 void Referee::introPlay()
 {
     if (!gameState.testBit(Introducing) || gameState.testBit(Ready))
         return;
     if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
         QTimer::singleShot(afterPauseMS, this, SLOT(introPlay()));
         return;
     }
 
     if (!gameState.testBit(Init)) {
         if (monstersEaten == 4) {
             stop();
             QTimer::singleShot(introPostAnimationMS, this, SLOT(demo()));
@@ -1067,96 +1067,96 @@ void Referee::play()
     stop();
     stopEnergizer();
 
     gameState.fill(FALSE);
     gameState.setBit(Init);
     gameState.setBit(Playing);
     gameState.setBit(Player);
     gameState.setBit(Ready);
 
     lifes = 3;
     level = 1;
     points = 0;
 
     extraLifeScoreIndex = 0;
     nextExtraLifeScore = extraLifeScore[extraLifeScoreIndex];
     if (nextExtraLifeScore < 0)
         nextExtraLifeScore *= -1;
 
     board->init(Level, mapName.at(level));
     pix->setLevel(level);
 
     initPacman();
     initFruit();
     initMonsters();
     initEnergizers();
 
     repaint();
     emit toggleNew();
     emit setLifes(lifes);
     emit setLevel(level);
     emit setPoints(points);
 
-    repaint(pix->rect(board->position(monsterhome, 0), i18n("PLAYER ONE")), FALSE);
-    repaint(pix->rect(board->position(fruithome), i18n("READY!")), FALSE);
+    repaint(pix->rect(board->position(monsterhome, 0), tr("PLAYER ONE")), FALSE);
+    repaint(pix->rect(board->position(fruithome), tr("READY!")), FALSE);
 
     timerCount = 0;
     QTimer::singleShot(playerDurMS, this, SLOT(ready()));
 }
 
 void Referee::ready()
 {
     if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
         QTimer::singleShot(afterPauseMS, this, SLOT(ready()));
         return;
     }
 
     if (gameState.testBit(Player)) {
         emit setLifes(--lifes);
         gameState.clearBit(Player);
         gameState.clearBit(Init);
-        repaint(pix->rect(board->position(monsterhome, 0), i18n("PLAYER ONE")), FALSE);
+        repaint(pix->rect(board->position(monsterhome, 0), tr("PLAYER ONE")), FALSE);
         repaintFigures();
         QTimer::singleShot(playerDurMS, this, SLOT(ready()));
         return;
     }
 
     if (gameState.testBit(Ready)) {
         gameState.clearBit(Ready);
-        repaint(pix->rect(board->position(fruithome), i18n("READY!")), FALSE);
+        repaint(pix->rect(board->position(fruithome), tr("READY!")), FALSE);
         start();
     } else {
         gameState.setBit(Ready);
         gameState.clearBit(Init);
-        repaint(pix->rect(board->position(fruithome), i18n("READY!")), FALSE);
+        repaint(pix->rect(board->position(fruithome), tr("READY!")), FALSE);
         QTimer::singleShot(readyDurMS, this, SLOT(ready()));
     }
 }
 
 
 void Referee::levelUp()
 {
     stop();
     stopEnergizer();
 
     gameState.setBit(LevelDone);
     pacman->setPosition(pacman->position());    // set mouthPosition to "0"
     repaint(pix->rect(pacman->position(), PacmanPix));
 
     timerCount = 0;
     QTimer::singleShot(levelUpPreAnimationMS, this, SLOT(levelUpPlay()));
 }
 
 void Referee::levelUpPlay()
 {
     if (gameState.testBit(Ready))
         return;
 
     if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
         QTimer::singleShot(afterPauseMS, this, SLOT(levelUpPlay()));
         return;
     }
 
     switch (timerCount) {
         case 0 : gameState.setBit(Init);
                  setOnEnergizers();
                  repaintFigures();
@@ -1265,65 +1265,65 @@ void Referee::killed()
 
         timerCount = 0;
         killedPlay();
     }
 }
 
 void Referee::killedPlay()
 {
     if (!gameState.testBit(Dying) || gameState.testBit(Ready))
         return;
     if (gameState.testBit(Paused) || gameState.testBit(HallOfFame)) {
         QTimer::singleShot(afterPauseMS, this, SLOT(killedPlay()));
         return;
     }
 
     if (timerCount <= pix->maxPixmaps(DyingPix)) {
         repaint(pix->rect(pacman->position(), PacmanPix), FALSE);
         if (timerCount >= pix->maxPixmaps(DyingPix)-1 || timerCount == 0)
             QTimer::singleShot(dyingPostAnimationMS, this, SLOT(killedPlay()));
         else
             QTimer::singleShot(dyingAnimationMS, this, SLOT(killedPlay()));
         timerCount++;
     } else {
         gameState.clearBit(Dying);
         stopEnergizer();
         if (lifes == 0) {
             gameState.setBit(GameOver);
             gameState.clearBit(Playing);
             for (int e = 0; e < board->energizers(); e++) {
                 energizers->at(e)->setOff();
                 repaint(pix->rect(board->position(energizer, e), EnergizerPix), FALSE);
             }
-            repaint(pix->rect(board->position(fruithome), i18n("GAME  OVER")), FALSE);
+            repaint(pix->rect(board->position(fruithome), tr("GAME  OVER")), FALSE);
             QTimer::singleShot(gameOverDurMS, this, SLOT(hallOfFame()));
         } else {
             gameState.clearBit(Init);
             initPacman();
             initFruit();
             initMonsters();
             initEnergizers();
             emit setLifes(--lifes);
             repaintFigures();
             ready();
         }
     }
 }
 
 void Referee::initPacman()
 {
     pacman->setMaxPixmaps(pix->maxPixmaps(PacmanPix));
     pacman->setDemo(gameState.testBit(Demonstration));
     pacman->setPosition(board->position(pacmanhome));
     pacman->setDirection(W, TRUE);
     pacman->setAlive(pacmanTicks[level]);
 }
 
 void Referee::initFruit(bool fullInitialization)
 {
     if (fullInitialization) {
         fruit->setMaxPixmaps(pix->maxPixmaps(FruitPix));
         if (fruitIndex[level] == 0)
             fruit->setLevel(level, fruitAppearsTicks[level],
                             fruitDurTicks[level], fruitTicks[level]);
         else if (fruitIndex[level] < 0)
             fruit->setLevel(pix->maxPixmaps(FruitPix)+1,
diff --git a/noncore/games/kpacman/score.cpp b/noncore/games/kpacman/score.cpp
index 6e660e8..17dbf0a 100644
--- a/noncore/games/kpacman/score.cpp
+++ b/noncore/games/kpacman/score.cpp
@@ -46,168 +46,168 @@ Score::Score(QWidget *parent, const char *name, int Scheme, int Mode, Bitfont *f
 
     initKeys();
 
     scheme = Scheme;
     mode = Mode;
     confScheme();
 
     bitfont = font;
 
     highscoreFile.setName(locateHighscoreFilePath().filePath());
     read();
 
     for (int p = 0; p < maxPlayer; p++) {
         playerScore[p] = 0;
         playerName[p] = getenv("LOGNAME");
         if (playerName[p].length() < minPlayerNameLength)
             playerName[p].setExpand(minPlayerNameLength-1, ' ');
 
         for (uint i = 0; i < playerName[p].length(); i++)
             if (playerName[p].at(i) < bitfont->firstChar() ||
                 playerName[p].at(i) > bitfont->lastChar())
                 playerName[p].at(i) = playerName[p].at(i).upper();
     }
 }
 
 Score::~Score()
 {
     // write();
 }
 
 void Score::paintEvent( QPaintEvent *e)
 {
-    if (rect(1, 0, i18n("  1UP ")).intersects(e->rect())) {
+    if (rect(1, 0, tr("  1UP ")).intersects(e->rect())) {
         QPixmap pix;
         QColor fg = BLACK;
         if (cursor.on || paused || lastPlayer != 0)
             fg = WHITE;
-        pix = bitfont->text(i18n("  1UP "), fg, BLACK);
+        pix = bitfont->text(tr("  1UP "), fg, BLACK);
         bitBlt(this, x(1), y(0), &pix);
     }
 
-    if (rect(8, 0, i18n(" HIGH SCORE ")).intersects(e->rect())) {
-            QPixmap pix = bitfont->text(i18n(" HIGH SCORE "), WHITE, BLACK);
+    if (rect(8, 0, tr(" HIGH SCORE ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(tr(" HIGH SCORE "), WHITE, BLACK);
         bitBlt(this, x(8), y(0), &pix);
     }
 
-    if (maxPlayer > 1 && rect(21, 0, i18n("  2UP ")).intersects(e->rect())) {
+    if (maxPlayer > 1 && rect(21, 0, tr("  2UP ")).intersects(e->rect())) {
         QPixmap pix;
         QColor fg = BLACK;
         if (cursor.on || paused || lastPlayer != 1)
             fg = WHITE;
-        pix = bitfont->text(i18n("  2UP "), fg, BLACK);
+        pix = bitfont->text(tr("  2UP "), fg, BLACK);
         bitBlt(this, x(21), y(0), &pix);
     }
 
     QString s;
 
     s.sprintf("%6d0", playerScore[0]/10);
     if (rect(0, 1, s).intersects(e->rect())) {
             QPixmap pix = bitfont->text(s, WHITE, BLACK);
             bitBlt(this, x(0), y(1), &pix);
     }
 
     s.sprintf("%8d0", HighScore/10);
     if (rect(8, 1, s).intersects(e->rect())) {
             QPixmap pix = bitfont->text(s, WHITE, BLACK);
             bitBlt(this, x(8), y(1), &pix);
     }
 
     if (lastScore >= 0) {
-        if (rect(1, 4*1.25, i18n("     CONGRATULATIONS      ")).intersects(e->rect())) {
-            QPixmap pix = bitfont->text(i18n("     CONGRATULATIONS      "), YELLOW, BLACK);
+        if (rect(1, 4*1.25, tr("     CONGRATULATIONS      ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(tr("     CONGRATULATIONS      "), YELLOW, BLACK);
             bitBlt(this, x(1), y(4*1.25), &pix);
         }
-        if (rect(1, 6*1.25, i18n("    YOU HAVE ARCHIEVED    ")).intersects(e->rect())) {
-            QPixmap pix = bitfont->text(i18n("    YOU HAVE ARCHIEVED    "), CYAN, BLACK);
+        if (rect(1, 6*1.25, tr("    YOU HAVE ARCHIEVED    ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(tr("    YOU HAVE ARCHIEVED    "), CYAN, BLACK);
             bitBlt(this, x(1), y(6*1.25), &pix);
         }
-        if (rect(1, 7*1.25, i18n("  A SCORE IN THE TOP 10.  ")).intersects(e->rect())) {
-            QPixmap pix = bitfont->text(i18n("  A SCORE IN THE TOP 10.  "), CYAN, BLACK);
+        if (rect(1, 7*1.25, tr("  A SCORE IN THE TOP 10.  ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(tr("  A SCORE IN THE TOP 10.  "), CYAN, BLACK);
             bitBlt(this, x(1), y(7*1.25), &pix);
         }
-        if (rect(1, 8*1.25, i18n("                          ")).intersects(e->rect())) {
-            QPixmap pix = bitfont->text(i18n("                          "), CYAN, BLACK);
+        if (rect(1, 8*1.25, tr("                          ")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(tr("                          "), CYAN, BLACK);
             bitBlt(this, x(1), y(8*1.25), &pix);
         }
     }
 
-    if (rect(1, 9.5*1.25, i18n("RNK   SCORE  NAME   DATE")).intersects(e->rect())) {
-            QPixmap pix = bitfont->text(i18n("RNK   SCORE  NAME   DATE"), WHITE, BLACK);
+    if (rect(1, 9.5*1.25, tr("RNK   SCORE  NAME   DATE")).intersects(e->rect())) {
+            QPixmap pix = bitfont->text(tr("RNK   SCORE  NAME   DATE"), WHITE, BLACK);
         bitBlt(this, x(1), y(9.5*1.25), &pix);
     }
 
     for (int i = 0; i < 10; i++) {
         s.sprintf("%2d%9d  %-3.3s  %-8.8s",
             i+1, hallOfFame[i].points, hallOfFame[i].name.utf8().data(),
             formatDate(hallOfFame[i].moment.date()).data());
         if (rect(1, (11+i)*1.25, s).intersects(e->rect())) {
             QPixmap pix = bitfont->text(s, (i == lastScore) ? YELLOW : WHITE, BLACK);
             bitBlt(this, x(1), y((11+i)*1.25), &pix);
         }
     }
 
     if (cursor.x != -1 && cursor.y != -1 && cursor.on) {
         if (rect(cursor.x, (cursor.y*1.25), cursor.chr).intersects(e->rect())) {
             QPixmap pix = bitfont->text(cursor.chr, BLACK, YELLOW);
             bitBlt(this, x(cursor.x), y(cursor.y*1.25), &pix);
         }
     }
 
     if (paused) {
 
-        QPixmap pix = bitfont->text(i18n("PAUSED"), RED, BLACK);
-        QRect r = bitfont->rect(i18n("PAUSED"));
+        QPixmap pix = bitfont->text(tr("PAUSED"), RED, BLACK);
+        QRect r = bitfont->rect(tr("PAUSED"));
         r.moveCenter(QPoint(this->width()/2, this->height()/2));
 
         bitBlt(this, r.x(), r.y(), &pix);
     }
 }
 
 void Score::timerEvent(QTimerEvent*)
 {
     cursor.on = !cursor.on;
 
     if (paused)
         return;
 
     if (cursor.x != -1 && cursor.y != -1)
         repaint(rect(cursor.x, cursor.y*1.25, cursor.chr), FALSE);
     scrollRepeat = FALSE;
 
     if (lastPlayer == 0)
-        repaint(rect(1, 0, i18n("  1UP ")), FALSE);
+        repaint(rect(1, 0, tr("  1UP ")), FALSE);
 
     if (lastPlayer == 1)
-        repaint(rect(21, 0, i18n("  2UP ")), FALSE);
+        repaint(rect(21, 0, tr("  2UP ")), FALSE);
 }
 
 void Score::keyPressEvent(QKeyEvent *k)
 {
     if (lastScore < 0 || lastPlayer < 0 || lastPlayer >= maxPlayer || paused) {
         k->ignore();
         return;
     }
 
     int x = cursor.x;
     int y = cursor.y;
 
     uint key = k->key();
 
     if (scrollRepeat && (key == UpKey || key == Key_Up || key == DownKey || key == Key_Down)) {
         k->ignore();
         return;
     }
 
     if (key != Key_Return) {
         if (key == RightKey || key == Key_Right)
             if (++cursor.x > 16)
                 cursor.x = 14;
         if (key == LeftKey || key == Key_Left)
             if (--cursor.x < 14)
                 cursor.x = 16;
         if (key == UpKey || key == Key_Up)
             if (cursor.chr.unicode() < bitfont->lastChar())
                 cursor.chr = cursor.chr.unicode()+1;
             else
                 cursor.chr = bitfont->firstChar();
         if (key == DownKey || key == Key_Down)
@@ -452,131 +452,131 @@ void Score::read()
                 s >> hallOfFame[i].points >> hallOfFame[i].levels >> hallOfFame[i].duration >>
                      hallOfFame[i].moment >> name;
                 hallOfFame[i].name = QString::fromLatin1(name);
                 delete(name);
             }
             highscoreFile.close();
         }
     } else {
         for (int i = 0; i < 10; i++) {
             hallOfFame[i].points = 5000;
             hallOfFame[i].levels = 0;
             hallOfFame[i].duration = QTime();
             hallOfFame[i].moment = QDateTime();
             hallOfFame[i].name = "???";
         }
         // write();
     }
 
     for (int i = 0; i < 10; i++)
         for (uint j = 0; j < hallOfFame[i].name.length(); j++)
             if (hallOfFame[i].name.at(j) < bitfont->firstChar() ||
                 hallOfFame[i].name.at(j) > bitfont->lastChar())
                 hallOfFame[i].name.at(j) = hallOfFame[i].name.at(j).upper();
 
     HighScore = hallOfFame[0].points;
 }
 
 void Score::write()
 {
 #ifndef QWS
     if (!highscoreFile.exists() && highscoreFile.name() == systemHighscoreFileInfo.filePath())
         KMessageBox::information(0,
-                                 i18n("You're going to create the highscore-file\n"
+                                 tr("You're going to create the highscore-file\n"
                                  "'%1'\n"
 																 "for your maschine, that should be used systemwide.\n"
 																 "\n"
                                  "To grant access to the other users, set the appropriate rights (a+w)\n"
                                  "on that file or ask your systemadministator for that favor.\n"
                                  "\n"
                                  "To use a different directory or filename for the highscores,"
                                  "specify them in the configfile (kpacmanrc:highscoreFilePath)."
                                  ).arg(systemHighscoreFileInfo.filePath()));
 
     if (highscoreFile.name() == privateHighscoreFileInfo.filePath())
         KMessageBox::information(0,
-                                 i18n("You're using a private highscore-file, that's mostly because of\n"
+                                 tr("You're using a private highscore-file, that's mostly because of\n"
                                  "missing write-access to the systemwide file\n"
                                  "'%1' .\n"
                                  "\n"
                                  "Ask your systemadministrator for granting you access to that file,\n"
                                  "by setting the appropriate rights (a+w) on it.\n"
                                  "\n"
                                  "To use a different directory or filename for the highscores,"
                                  "specify them in the configfile (kpacmanrc:highscoreFilePath)."
                                  ).arg(systemHighscoreFileInfo.filePath()),
                                  QString::null, "PrivateHighscore");
 #endif
     if (highscoreFile.open(IO_WriteOnly)) {
         QDataStream s(&highscoreFile);
         for (int i = 0; i < 10; i++)
             s << hallOfFame[i].points << hallOfFame[i].levels << hallOfFame[i].duration <<
                  hallOfFame[i].moment << hallOfFame[i].name.latin1();
         highscoreFile.close();
     }
 }
 
 void Score::setPause(bool Paused)
 {
     paused = Paused;
 
-    QRect r = bitfont->rect(i18n("PAUSED"));
+    QRect r = bitfont->rect(tr("PAUSED"));
     r.moveCenter(QPoint(this->width()/2, this->height()/2));
     repaint(r, TRUE);
 
     // repaint 1UP or 2UP
     repaint(FALSE);
 }
 
 void Score::end()
 {
     if (paused) {
         QTimer::singleShot(afterPauseMS, this, SLOT(end()));
         return;
     }
 
     // repaint 1UP or 2UP
     lastPlayer = -1;
     repaint(FALSE);
 
     emit forcedHallOfFame(FALSE);
 }
 
 /*
  * Return the date in a formatted QString. The format can be changed using internationalization
  * of the string "YY/MM/DD". Invalid QDate's where returned as "00/00/00".
  */
 QString Score::formatDate(QDate date)
 {
-    QString s = i18n("@YY@/@MM@/@DD@");
+    QString s = tr("@YY@/@MM@/@DD@");
 
     QString dd;
     dd.sprintf("%02d", date.isValid() ? date.year() % 100 : 0);
     s.replace(QRegExp("@YY@"), dd);
     dd.sprintf("%02d", date.isValid() ? date.month() : 0);
     s.replace(QRegExp("@MM@"), dd);
     dd.sprintf("%02d", date.isValid() ? date.day() : 0);
     s.replace(QRegExp("@DD@"), dd);
 
     return s;
 }
 
 QRect Score::rect(int col, float row, QString str, int align)
 {
     QRect r = bitfont->rect(str);
     r.moveBy(x(col), y(row));
 
     int dx = 0;
     int dy = 0;
 
     if (align & AlignLeft || align & AlignRight) {
         dx = (str.length()-1) * (bitfont->width()/2);
         if (align & AlignRight)
             dx *= -1;
     }
 
     if (align & AlignTop || align & AlignBottom) {
         dy = bitfont->height()/2;
         if (align & AlignBottom)
             dy *= -1;
     }
 
diff --git a/noncore/games/kpacman/status.cpp b/noncore/games/kpacman/status.cpp
index 00d1f22..3453d37 100644
--- a/noncore/games/kpacman/status.cpp
+++ b/noncore/games/kpacman/status.cpp
@@ -19,69 +19,69 @@
 #include <qmsgbox.h>
 #include <qfileinfo.h>
 
 Status::Status( QWidget *parent, const char *name, int Scheme, int Mode ) :
     QWidget( parent, name )
 {
     actualLifes = 0;
     actualLevel = 0;
 
     lifesPix = NULL;
     levelPix = NULL;
 
     scheme = Scheme;
     mode = Mode;
     level = 0;
 
     confScheme();
 }
 
 QList<QPixmap> *Status::loadPixmap(QWidget *parent, QString pixmapName,
                                    QList<QPixmap> *pixmaps)
 {
     if (pixmaps == NULL) {
         pixmaps = new QList<QPixmap>;
         pixmaps->setAutoDelete(TRUE);
     }
 
     if (!pixmaps->isEmpty())
         pixmaps->clear();
 
     QPixmap PIXMAP(pixmapName);
     if (PIXMAP.isNull() || PIXMAP.mask() == NULL) {
-        QString msg = i18n("The pixmap could not be contructed.\n\n"
+        QString msg = tr("The pixmap could not be contructed.\n\n"
                            "The file '@PIXMAPNAME@' does not exist,\n"
                            "or is of an unknown format.");
         msg.replace(QRegExp("@PIXMAPNAME@"), pixmapName);
-        QMessageBox::information(parent, i18n("Initialization Error"),
+        QMessageBox::information(parent, tr("Initialization Error"),
                                  (const char *) msg);
         return 0;
     }
 
     int height = PIXMAP.height();
     int width = (height == 0) ? 0 : PIXMAP.width()/(PIXMAP.width()/height);
 
     QBitmap BITMAP;
     QBitmap MASK;
 
     BITMAP = *PIXMAP.mask();
     MASK.resize(width, height);
 
     for (int x = 0; x < PIXMAP.width()/width; x++) {
         QPixmap *pixmap = new QPixmap(width, height);
         pixmaps->append(pixmap);
         bitBlt(pixmap, 0, 0, &PIXMAP, x*width, 0, width, height, CopyROP, TRUE);
         bitBlt(&MASK, 0, 0, &BITMAP, x*width, 0, width, height, CopyROP, TRUE);
         pixmap->setMask(MASK);
     }
 
     return pixmaps;
 }
 
 void Status::paintEvent( QPaintEvent *)
 {
     for (int x = 0; x < actualLifes && !lifesPix->isEmpty(); x++)
         bitBlt(this, lifesPix->at(0)->width()+(lifesPix->at(0)->width()*x), 
                (height()-lifesPix->at(0)->height())/2,
                lifesPix->at(0), 0, 0,
                lifesPix->at(0)->width(), lifesPix->at(0)->height());