Each file in this commit has the issue where it is possible for code to

overrun static buffers. This could lead to serious problems. Granted it
is almost impossible to do that. But it isn't totally impossible. So this
commit makes it impossible to overrun.

6 files changed, 51 insertions, 38 deletions

diff --git a/noncore/games/backgammon/moveengine.cpp b/noncore/games/backgammon/moveengine.cpp
index a4145cc..b102258 100644
--- a/noncore/games/backgammon/moveengine.cpp
+++ b/noncore/games/backgammon/moveengine.cpp
@@ -1,291 +1,293 @@
 #include "moveengine.h"
 
 #include <qtimer.h>
 #include <stdlib.h>
 
 MoveEngine::MoveEngine()
         : QObject()
 {
     int offset=7;
     int a=0; //counter variable
     int xfill[]={210,185,170,155,140,125,110,85,70,55,40,25,10,10,25,40,55,70,85,110,125,140,155,170,185,210};
     for(a=0;a<26;a++)
     {
         x_coord[a]=xfill[a];
     }
 
     int yfill[]={10,25,40,55,70,10+offset,25+offset,40+offset,55+offset,25,40,55, 25+offset,40+offset,40};
     int zfill[]={1,1,1,1,1,2,2,2,2,3,3,3,4,4,5};
     for(a=0;a<15;a++)
     {
         yup_coord[a]=yfill[a];
         ylow_coord[a]=185-(yfill[a]);
         z_coord[a]=zfill[a];
     }
     for(a=0;a<5;a++)
     {
         if(a<3)
         {
             x_fin1[a]=65+a*15;
             x_fin2[a]=155-a*15;
         }
         y_fin[a]=225-a*5;
     }
     z_fin=1;
 
     reset();
 }
 
 MoveEngine::~MoveEngine()
 {}
 
 void MoveEngine::position(Pieces& pieces,bool non_qte)
 {
     int player1_counter=0;
     int player2_counter=0;
 
     //non qte styles are smaller !!
     int offset=(non_qte) ? 5 : 0;
 
     for(int a=0;a<28;a++)
     {
         for(int b=0;b<abs(population[a].total);b++)
         {
             if(population[a].total>0) //player 1 pieces
             {
-                pieces.player1[player1_counter].x=x_coord[a]-offset;
+		if (a < 26)
+                    pieces.player1[player1_counter].x=x_coord[a]-offset;
                 if(a>=0 && a<13)
                 {
                     pieces.player1[player1_counter].y=yup_coord[b]-offset;
                     pieces.player1[player1_counter].z=z_coord[b];
                     pieces.player1[player1_counter].side=false;
                     player1_counter++;
                 }
                 else if(a>12 && a<26)
                 {
                     pieces.player1[player1_counter].y=ylow_coord[b]-offset;
                     pieces.player1[player1_counter].z=z_coord[b];
                     pieces.player1[player1_counter].side=false;
                     player1_counter++;
                 }
                 else if(a==26)
                 {
                     if(b<5)
                     {
                         pieces.player1[player1_counter].x=x_fin1[0]-offset;
                         pieces.player1[player1_counter].y=y_fin[b]-offset;
                         pieces.player1[player1_counter].z=z_fin;
                     }
                     else if(b>=5 && b<10)
                     {
                         pieces.player1[player1_counter].x=x_fin1[1]-offset;
                         pieces.player1[player1_counter].y=y_fin[b-5]-offset;
                         pieces.player1[player1_counter].z=z_fin;
                     }
                     else
                     {
                         pieces.player1[player1_counter].x=x_fin1[2]-offset;
                         pieces.player1[player1_counter].y=y_fin[b-10]-offset;
                         pieces.player1[player1_counter].z=z_fin;
                     }
                     pieces.player1[player1_counter].side=true;
                     player1_counter++;
 
                 }
             }
 
             else if(population[a].total<0) //player 2 pieces
             {
-                pieces.player2[player2_counter].x=x_coord[a]-offset;
+		if (a < 26)
+                    pieces.player2[player2_counter].x=x_coord[a]-offset;
                 if(a>=0 && a<13)
                 {
                     pieces.player2[player2_counter].y=yup_coord[b]-offset;
                     pieces.player2[player2_counter].z=z_coord[b];
                     pieces.player2[player2_counter].side=false;
                     player2_counter++;
                 }
                 else if(a>12 && a<26)
                 {
                     pieces.player2[player2_counter].y=ylow_coord[b]-offset;
                     pieces.player2[player2_counter].z=z_coord[b];
                     pieces.player2[player2_counter].side=false;
                     player2_counter++;
                 }
                 else if(a==27)
                 {
                     if(b<5)
                     {
                         pieces.player2[player2_counter].x=x_fin2[0]-offset;
                         pieces.player2[player2_counter].y=y_fin[b]-offset;
                         pieces.player2[player2_counter].z=z_fin;
                     }
                     else if(b>=5 && b<10)
                     {
                         pieces.player2[player2_counter].x=x_fin2[1]-offset;
                         pieces.player2[player2_counter].y=y_fin[b-5]-offset;
                         pieces.player2[player2_counter].z=z_fin;
                     }
                     else
                     {
                         pieces.player2[player2_counter].x=x_fin2[2]-offset;
                         pieces.player2[player2_counter].y=y_fin[b-10]-offset;
                         pieces.player2[player2_counter].z=z_fin;
                     }
                     pieces.player2[player2_counter].side=true;
                     player2_counter++;
 
                 }
             }
         }
     }
 }
 
 void MoveEngine::diceroll(const int& newplayer,const int& face1,const int& face2,const int& face3,const int& face4,bool computer)
 {
     checkstate();
     player=newplayer;
     otherplayer=(player==1) ? 2 : 1;
     dice[0]=face1;
     dice[1]=face2;
     dice[2]=face3;
     dice[3]=face4;
     marker_current=-1;
     if(getPossibleMoves()==0)
     {
         emit nomove();
         return; // player will be changed
     }
     if(!computer)
         return; //human intervention required
 
     QTimer::singleShot(2000,this,SLOT(automove()));
 }
 
 
 void MoveEngine::automove()
 {
     //the maximimum possibility
     int maxpos=0;
     //the position in the moves array
     int from=-1;
     int to=-1;
     //dice1 or dice 2 ??
     int index_dice=0;
     for(int counter=0;counter<26;counter++)
     {
         int a=(player==1) ? counter : 25-counter;
         for(int b=0;b<4;b++)
         {
             if(moves[a].weight[b]>maxpos)
             {
                 maxpos=moves[a].weight[b];
                 from=a;
                 to=moves[a].to[b];
                 index_dice=b+1;
             }
         }
     }
     move(from,to,index_dice);
 }
 
 
 void MoveEngine::boardpressed(const int& x,const int& y,Marker& marker,bool non_qte)
 {
     //get the position of the mouse click
     bool upper=true;
     bool found=false;
 
     int offset=(non_qte) ? 5 : 0;
 
     if(y<=85) // board slots 0 to 12
         marker.y_current=0;
     else if(y>=105) //board slots 13 to 25
     {
         marker.y_current=195-2*offset;
         upper=false;
     }
 
     int index=13; // the clicked board slot
 
     while(index<25 && !found)
     {
         if(x>=x_coord[index] && x<x_coord[index+1])
         {
             marker.x_current=x_coord[index];
             found=true;
             ;
         }
         else
         {
             index++;
         }
     }
     if(!found)
     {
         marker.x_current=x_coord[25];
         index=25;
     }
     if(upper)
     {
         index=25-index;
     }
 
     int a=0;
     int usedice=-1;
     int dice_value=7;
     for(a=0;a<4;a++)
     {
         if(index==marker_next[a] && marker_next[a]!=-1 && dice_value>dice[a])
         {
           usedice=a;
           dice_value=dice[0];
          }        
     }  
     if(usedice!=-1)
     {
         move(marker_current,marker_next[usedice],usedice+1);
         nomarker(marker);
         return;
 
     }
 
 
     if(dice[0]==7 && dice[1]==7 && dice[2]==7 && dice[3]==7) //no dice rolled
     {
         nomarker(marker);
         return;
     }
     else if(fieldColor(index)==player)
     {
         marker.visible_current=true;
         marker_current=index;
     }
     else
     {
         nomarker(marker);
         return;
     }
 
     for(a=0;a<4;a++)
     {
         if(moves[index].weight[a]>0)
         {
             int nextfield=moves[index].to[a];
             marker.x_next[a]=x_coord[nextfield];
             marker_next[a]=nextfield;
             if(nextfield<13) //upper half
                 marker.y_next[a]=0;
             else //lower half
                 marker.y_next[a]=195-2*offset;
             marker.visible_next[a]=true;
         }
         else
         {
             marker.x_next[a]=0;
             marker.y_next[a]=0;
             marker_next[a]=-1;
             marker.visible_next[a]=false;
         }
     }
     return;
 }
diff --git a/noncore/games/kbill/UI.cpp b/noncore/games/kbill/UI.cpp
index 611cebf..a49c3c1 100644
--- a/noncore/games/kbill/UI.cpp
+++ b/noncore/games/kbill/UI.cpp
@@ -1,172 +1,171 @@
 /***************************************************************************
                           UI.cc  -  description
                              -------------------
     begin                : Thu Dec 30 1999
     copyright            : (C) 1999 by Jurrien Loonstra
     email                : j.h.loonstra@st.hanze.nl
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include "objects.h"
 #include "Strings.h"
 #ifdef KDEVER
 #include <kapplication.h>
 #endif
 #include <qmessagebox.h>
 
 #include "inputbox.h"
 
 /**************************/
 /* Timer control routines */
 /**************************/
 
 UI::~UI() {
 	paint.end();
 	delete pix;
 }
 
 void UI::restart_timer() {
 	field->startTimer();
 }
 
 void UI::kill_timer() {
 	field->stopTimer();
 }
 
 /*******************/
 /* Window routines */
 /*******************/
 
 void UI::initialize(int *argc, char **argv) {
 	 #ifdef KDEVER
 	 app = new KApplication(*argc, argv, "kbill");
 	 #endif
 	 app = new QPEApplication(*argc, argv);
 }
 
 void UI::graph_init() {
 	pix = new QPixmap(Game::scrwidth, Game::scrheight);
 	paint.begin(pix, field);
 	paint.setPen(QPen(Qt::black, 3));
 }
 
 void UI::make_mainwin() {
 	main = new KBill();
 	app->showMainWidget(main,true);
 	main->showMaximized();
 	field = main->getField();
 }
 
 void UI::popup_dialog (int dialog) {
 	kill_timer();
 	switch (dialog) {
 	case Game::ENDGAME:
-			QMessageBox::message(("Endgame"), QT_TR_NOOP(endgamestr));
-			break;
+		QMessageBox::message(("Endgame"), QT_TR_NOOP(endgamestr));
+		break;
 	case Game::HIGHSCORE:
-		//	QMessageBox::message(("HighScore"), highscorestr);
-			break;
-	case Game::ENTERNAME: {
+		break;
+	case Game::ENTERNAME:
+		{
 			InputBox b(main, 0, ("Enter Name"), QT_TR_NOOP(enternamestr));
 			bool state = b.exec() == 2;
-		  char str[20], *nl;
-	    strcpy(str, b.getText());
-	    if (!str[0] || state)
+			char str[20], *nl;
+			strncpy(str, b.getText(), 19);
+	    		if (!str[0] || state)
 				strcpy(str, "Anonymous");
-	    else if ((nl = strchr(str, '\n')))
+			else if ((nl = strchr(str, '\n')))
 				*nl = '\0';
-	    if (strlen(str) > 20)
-				str[20] = 0;  /* truncate string if too long */
-//	    scores.recalc(str);
-			}
-	    break;
+			if (strlen(str) > 19)
+				str[19] = '\0';  /* truncate/terminate the string if it is too long */
+		}
+		break;
 	case Game::SCORE:
-			QMessageBox::message(("Score"), scorestr);
-			break;
+		QMessageBox::message(("Score"), scorestr);
+		break;
 	}
 	restart_timer();
 }
 
 /*********************/
 /* Graphics routines */
 /*********************/
 
 void UI::set_cursor(int cursor) {
 	QCursor *cur;
 	switch (cursor) {
 	case Game::BUCKETC:
 		cur = bucket.cursor.cursor;
 		break;
 	case Game::DOWNC:
 		cur = downcursor.cursor;
 		break;
 	case Game::DEFAULTC:
 		cur = defaultcursor.cursor;
 		break;
 	default:
 		cur = OS.cursor[cursor].cursor;
 	}
 	field->setCursor(*cur);
 }
 
 void UI::load_cursors() {
 	defaultcursor.load("hand_up", MCursor::SEP_MASK);
 	field->setCursor(*defaultcursor.cursor);
 	downcursor.load("hand_down", MCursor::SEP_MASK);
 }
 
 void UI::clear() {
 	paint.eraseRect(0, 0, field->width(), field->height());
 }
 
 void UI::refresh() {
 	paint.flush();
 	field->setPixmap(pix);
 	field->repaint(FALSE);
 }
 
 void UI::draw (Picture pict, int x, int y) {
 	paint.drawPixmap(x, y, *pict.pix);
 }
 
 void UI::draw_centered (Picture pict) {
 	draw(pict, (field->width() - pict.width) / 2, (field->height() - pict.height) / 2);
 }
 
 void UI::draw_line(int x1, int y1, int x2, int y2) {
 	paint.drawLine(x1, y1, x2, y2);
 
 }
 
 void UI::draw_str(char *str, int x, int y) {
 	paint.drawText(x, y, str);
 }
 
 
 /******************/
 /* Other routines */
 /******************/
 
 void UI::set_pausebutton (int action) {
 	main->file->setItemEnabled(main->pauseid, action);
 }
 
 
 int UI::MainLoop() {
   return app->exec();
 }
 
 void UI::update_hsbox(char *str) {
 	highscorestr = str;	
 }
 
 void UI::update_scorebox(int level, int score) {
 	scorestr.sprintf ("%s %d:\n%s: %d", QT_TR_NOOP("After Level"), level, QT_TR_NOOP("Your score"), score);
 }
diff --git a/noncore/games/kcheckers/echeckers.cpp b/noncore/games/kcheckers/echeckers.cpp
index 1146059..afe62eb 100644
--- a/noncore/games/kcheckers/echeckers.cpp
+++ b/noncore/games/kcheckers/echeckers.cpp
@@ -1,349 +1,349 @@
 //
 // English Checkers
 
 
 #include "echeckers.h"
 
 
 ///////////////////////////////////////////////////
 //
 //  User Functions
 //
 ///////////////////////////////////////////////////
 
 
 bool ECheckers::go1(int from,int field)
 {
   to=field;
 
   if(checkCapture1())
   {
     bool capture=false;
     switch(board[from])
     {
       case MAN1:
         if(manCapture1(from,UL,capture)) return true;
         if(manCapture1(from,UR,capture)) return true;
         return false;
       case KING1:
         if(kingCapture1(from,UL,capture)) return true;
         if(kingCapture1(from,UR,capture)) return true;
         if(kingCapture1(from,DL,capture)) return true;
         if(kingCapture1(from,DR,capture)) return true;
         return false;
     }
   }
   else
   {
     switch(board[from])
     {
       case MAN1:
         if((to==(from-6))||(to==(from-5)))
         {
           board[from]=FREE;
           if(to<10) board[to]=KING1;
           else board[to]=MAN1;
           return true;
         }
         return false;
       case KING1:
         if((to==(from-6))||(to==(from-5))||
            (to==(from+5))||(to==(from+6)) )
         {
           board[from]=FREE;
           board[to]=KING1;
           return true;
         }
         return false;
     }
   }
   return false;
 }
 
 
 bool ECheckers::checkCapture1()
 {
   for(int i=6;i<48;i++)
   {
     switch(board[i])
     {
       case MAN1:
         if(board[i-6]==MAN2 || board[i-6]==KING2)
           if(board[i-12]==FREE) return true;
         if(board[i-5]==MAN2 || board[i-5]==KING2)
           if(board[i-10]==FREE) return true;
         break;
       case KING1:
         if(board[i-6]==MAN2 || board[i-6]==KING2)
           if(board[i-12]==FREE) return true;
         if(board[i-5]==MAN2 || board[i-5]==KING2)
           if(board[i-10]==FREE) return true;
         if(board[i+5]==MAN2 || board[i+5]==KING2)
-          if(board[i+10]==FREE) return true;
+          if(board[((i+10) < 54) ? i+10 : 53]==FREE) return true;
         if(board[i+6]==MAN2 || board[i+6]==KING2)
-          if(board[i+12]==FREE) return true;
+          if(board[((i+12) < 54) ? i+12 : 53]==FREE) return true;
     }
   }
   return false;
 }
 
 
 // Return TRUE if a course of the user true
 // Return FALSE if a course of the user incorrect
 
 bool ECheckers::manCapture1(int from,int direction,bool &capture)
 {
   int i=from+direction;
   if(board[i]==MAN2 || board[i]==KING2)
   {
     int k=i+direction;
     if(board[k]==FREE)
     {
       bool next=false;
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
 
       if(k<10)
       {
         board[k]=KING1;
         if(kingCapture1(k,direction+11,next)) {board[i]=FREE;return true;}
       }
       else
       {
         board[k]=MAN1;
         if(manCapture1(k,UL,next)) {board[i]=FREE;return true;}
         if(manCapture1(k,UR,next)) {board[i]=FREE;return true;}
       }
 
       if((!next) && k==to) {board[i]=FREE;return true;}
 
       board[k]=FREE;
       board[i]=save;
       board[from]=MAN1;
       capture=true;
     }
   }
   return false;
 }
 
 
 bool ECheckers::kingCapture1(int from,int direction,bool &capture)
 {
   int i=from+direction;
   if(board[i]==MAN2 || board[i]==KING2)
   {
     int k=i+direction;
     if(board[k]==FREE)
     {
       bool next=false;
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       board[k]=KING1;
 
       if(direction==UL || direction==DR)
       {
         if(kingCapture1(k,UR,next)) {board[i]=FREE;return true;}
         if(kingCapture1(k,DL,next)) {board[i]=FREE;return true;}
       }
       else
       {
         if(kingCapture1(k,UL,next)) {board[i]=FREE;return true;}
         if(kingCapture1(k,DR,next)) {board[i]=FREE;return true;}
       }
       if(kingCapture1(k,direction,next)) {board[i]=FREE;return true;}
 
       if((!next) && k==to) {board[i]=FREE;return true;}
 
       board[k]=FREE;
       board[i]=save;
       board[from]=KING1;
       capture=true;
     }
   }
   return false;
 }
 
 
 ////////////////////////////////////////////////////
 //
 // Computer Functions
 //
 ////////////////////////////////////////////////////
 
 
 void ECheckers::kingMove2(int from,int &resMax)
 {
   board[from]=FREE;
 
   int i=from-6;
   if(board[i]==FREE)
   {
     board[i]=KING2;
     turn(resMax);
     board[i]=FREE;
   }
 
   i=from-5;
   if(board[i]==FREE)
   {
     board[i]=KING2;
     turn(resMax);
     board[i]=FREE;
   }
 
   i=from+5;
   if(board[i]==FREE)
   {
     board[i]=KING2;
     turn(resMax);
     board[i]=FREE;
   }
 
   i=from+6;
   if(board[i]==FREE)
   {
     board[i]=KING2;
     turn(resMax);
     board[i]=FREE;
   }
 
   board[from]=KING2;
 }
 
 
 bool ECheckers::checkCapture2()
 {
   for(int i=6;i<48;i++)
   {
     switch(board[i])
     {
       case MAN2:
         if(board[i+5]==MAN1 || board[i+5]==KING1)
-          if(board[i+10]==FREE) return true;
+          if(board[((i+10) < 54) ? i+10 : 53]==FREE) return true;
         if(board[i+6]==MAN1 || board[i+6]==KING1)
-          if(board[i+12]==FREE) return true;
+          if(board[((i+12) < 54) ? i+12 : 53]==FREE) return true;
         break;
       case KING2:
         if(board[i-6]==MAN1 || board[i-6]==KING1)
           if(board[i-12]==FREE) return true;
         if(board[i-5]==MAN1 || board[i-5]==KING1)
           if(board[i-10]==FREE) return true;
         if(board[i+5]==MAN1 || board[i+5]==KING1)
-          if(board[i+10]==FREE) return true;
+          if(board[((i+10) < 54) ? i+10 : 53]==FREE) return true;
         if(board[i+6]==MAN1 || board[i+6]==KING1)
-          if(board[i+12]==FREE) return true;
+          if(board[((i+12) < 54) ? i+12 : 53]==FREE) return true;
     }
   }
   return false;
 }
 
 
 // Return TRUE if it is possible to capture
 // Return FALSE if it is impossible to capture
 
 bool ECheckers::manCapture2(int from,int &resMax)
 {
   bool capture=false;
 
   int i=from+5;
   if(board[i]==MAN1 || board[i]==KING1)
   {
     int k=from+10;
     if(board[k]==FREE)
     {
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       resMax--;
       if(from>32)
       {
         board[k]=KING2;
         if(!kingCapture2(k,UL,resMax)) turn(resMax,true);
       }
       else
       {
         board[k]=MAN2;
         if(!manCapture2(k,resMax)) turn(resMax,true);
       }
       resMax++;
       board[k]=FREE;
       board[i]=save;
       board[from]=MAN2;
       capture=true;
     }
   }
 
   i=from+6;
   if(board[i]==MAN1 || board[i]==KING1)
   {
     int k=from+12;
     if(board[k]==FREE)
     {
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       resMax--;
       if(from>32)
       {
         board[k]=KING2;
         if(!kingCapture2(k,UR,resMax)) turn(resMax,true);
       }
       else
       {
         board[k]=MAN2;
         if(!manCapture2(k,resMax)) turn(resMax,true);
       }
       resMax++;
       board[k]=FREE;
       board[i]=save;
       board[from]=MAN2;
       capture=true;
     }
   }
 
   if(capture) return true;
   return false;
 }
 
 
 bool ECheckers::kingCapture2(int from,int direction,int &resMax)
 {
   int i=from+direction;
   if(board[i]==MAN1 || board[i]==KING1)
   {
     int k=i+direction;
     if(board[k]==FREE)
     {
       bool capture=false;
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       resMax--;
 
       board[k]=KING2;
       if(direction==UL || direction==DR)
       {
         if(kingCapture2(k,UR,resMax)) capture=true;
         if(kingCapture2(k,DL,resMax)) capture=true;
       }
       else
       {
         if(kingCapture2(k,UL,resMax)) capture=true;
         if(kingCapture2(k,DR,resMax)) capture=true;
       }
       if(kingCapture2(k,direction,resMax)) capture=true;
 
       if(!capture) turn(resMax,true);
       board[k]=FREE;
 
       resMax++;
       board[i]=save;
       board[from]=KING2;
       return true;
     }
   }
   return false;
 }
 
diff --git a/noncore/games/kcheckers/rcheckers.cpp b/noncore/games/kcheckers/rcheckers.cpp
index a1c7afa..d808780 100644
--- a/noncore/games/kcheckers/rcheckers.cpp
+++ b/noncore/games/kcheckers/rcheckers.cpp
@@ -1,476 +1,488 @@
 //
 // Russian Checkers
 
 
 #include "rcheckers.h"
 
 
 ///////////////////////////////////////////////////
 //
 //  User Functions
 //
 ///////////////////////////////////////////////////
 
 
 bool RCheckers::go1(int from,int field)
 {
   to=field;
 
   if(checkCapture1())
   {
     bool capture=false;
     switch(board[from])
     {
       case MAN1:
         if(manCapture1(from,UL,capture)) return true;
         if(manCapture1(from,UR,capture)) return true;
         if(manCapture1(from,DL,capture)) return true;
         if(manCapture1(from,DR,capture)) return true;
         return false;
       case KING1:
         if(kingCapture1(from,UL,capture)) return true;
         if(kingCapture1(from,UR,capture)) return true;
         if(kingCapture1(from,DL,capture)) return true;
         if(kingCapture1(from,DR,capture)) return true;
         return false;
     }
   }
   else
   {
     switch(board[from])
     {
       case MAN1:
         if((to==(from-6))||(to==(from-5)))
         {
           board[from]=FREE;
           if(to<10) board[to]=KING1;
           else board[to]=MAN1;
           return true;
         }
         return false;
       case KING1:
         for(int i=from-6;;i-=6)
         {
           if(i==to)
           {
             board[from]=FREE;
             board[to]=KING1;
             return true;
           }
           else if(board[i]==FREE) continue;
           else break;
         }
         for(int i=from-5;;i-=5)
         {
           if(i==to)
           {
             board[from]=FREE;
             board[to]=KING1;
             return true;
           }
           else if(board[i]==FREE) continue;
           else break;
         }
         for(int i=from+5;;i+=5)
         {
           if(i==to)
           {
             board[from]=FREE;
             board[to]=KING1;
             return true;
           }
           else if(board[i]==FREE) continue;
           else break;
         }
         for(int i=from+6;;i+=6)
         {
           if(i==to)
           {
             board[from]=FREE;
             board[to]=KING1;
             return true;
           }
           else if(board[i]==FREE) continue;
           else break;
         }
         return false;
     }
   }
   return false;
 }
 
 
 bool RCheckers::checkCapture1()
 {
   for(int i=6;i<48;i++)
   {
     switch(board[i])
     {
       case MAN1:
         if(board[i-6]==MAN2 || board[i-6]==KING2)
           if(board[i-12]==FREE) return true;
         if(board[i-5]==MAN2 || board[i-5]==KING2)
           if(board[i-10]==FREE) return true;
         if(board[i+5]==MAN2 || board[i+5]==KING2)
-          if(board[i+10]==FREE) return true;
+          if(board[((i+10) < 54) ? i+10 : 53]==FREE) return true;
         if(board[i+6]==MAN2 || board[i+6]==KING2)
-          if(board[i+12]==FREE) return true;
+          if(board[((i+12) < 54) ? i+12 : 53]==FREE) return true;
         break;
       case KING1:
         int k;
         for(k=i-6;board[k]==FREE;k-=6);
         if(board[k]==MAN2 || board[k]==KING2)
           if(board[k-6]==FREE) return true;
 
         for(k=i-5;board[k]==FREE;k-=5);
         if(board[k]==MAN2 || board[k]==KING2)
           if(board[k-5]==FREE) return true;
 
-        for(k=i+5;board[k]==FREE;k+=5);
+        for(k=i+5;board[k]==FREE;k+=5) {
+          if (k >= 49)
+            break;
+        }
         if(board[k]==MAN2 || board[k]==KING2)
-          if(board[k+5]==FREE) return true;
+          if(board[((k+5) < 54) ? k+5 : 53]==FREE) return true;
 
-        for(k=i+6;board[k]==FREE;k+=6);
+        for(k=i+6;board[k]==FREE;k+=6) {
+          if (k >=48)
+            break;
+        }
         if(board[k]==MAN2 || board[k]==KING2)
-          if(board[k+6]==FREE) return true;
+          if(board[((k+6) < 54) ? k+6 : 53]==FREE) return true;
     }
   }
   return false;
 }
 
 
 // Return TRUE if a course of the user true
 // Return FALSE if a course of the user incorrect
 
 bool RCheckers::manCapture1(int from,int direction,bool &capture)
 {
   int i=from+direction;
   if(board[i]==MAN2 || board[i]==KING2)
   {
     int k=i+direction;
     if(board[k]==FREE)
     {
       bool next=false;
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
 
       if(k<10)
       {
         board[k]=KING1;
         if(kingCapture1(k,direction+11,next)) {board[i]=FREE;return true;}
       }
       else
       {
         board[k]=MAN1;
         if(direction==UL || direction==DR)
         {
           if(manCapture1(k,UR,next)) {board[i]=FREE;return true;}
           if(manCapture1(k,DL,next)) {board[i]=FREE;return true;}
         }
         else
         {
           if(manCapture1(k,UL,next)) {board[i]=FREE;return true;}
           if(manCapture1(k,DR,next)) {board[i]=FREE;return true;}
         }
         if(manCapture1(k,direction,next)) {board[i]=FREE;return true;}
       }
 
       if((!next) && k==to) {board[i]=FREE;return true;}
 
       board[k]=FREE;
       board[i]=save;
       board[from]=MAN1;
       capture=true;
     }
   }
   return false;
 }
 
 
 bool RCheckers::kingCapture1(int from,int direction,bool &capture)
 {
   int i;
   for(i=from+direction;board[i]==FREE;i+=direction);
 
   if(board[i]==MAN2 || board[i]==KING2)
   {
     int k=i+direction;
     if(board[k]==FREE)
     {
       bool next=false;
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
 
       for(;board[k]==FREE;k+=direction)
       {
         board[k]=KING1;
         if(direction==UL || direction==DR)
         {
           if(kingCapture1(k,UR,next)) {board[i]=FREE;return true;}
           if(kingCapture1(k,DL,next)) {board[i]=FREE;return true;}
         }
         else
         {
           if(kingCapture1(k,UL,next)) {board[i]=FREE;return true;}
           if(kingCapture1(k,DR,next)) {board[i]=FREE;return true;}
         }
         board[k]=FREE;
       }
 
       board[k-=direction]=KING1;
       if(kingCapture1(k,direction,next)) {board[i]=FREE;return true;}
       board[k]=FREE;
 
       if(!next)
         for(;k!=i;k-=direction)
           if(k==to) {board[i]=FREE;board[k]=KING1;return true;}
 
       board[i]=save;
       board[from]=KING1;
       capture=true;
     }
   }
   return false;
 }
 
 
 ////////////////////////////////////////////////////
 //
 // Computer Functions
 //
 ////////////////////////////////////////////////////
 
 
 void RCheckers::kingMove2(int from,int &resMax)
 {
   board[from]=FREE;
   for(int i=from-6;board[i]==FREE;i-=6)
   {
     board[i]=KING2;
     turn(resMax);
     board[i]=FREE;
   }
   for(int i=from-5;board[i]==FREE;i-=5)
   {
     board[i]=KING2;
     turn(resMax);
     board[i]=FREE;
   }
   for(int i=from+5;board[i]==FREE;i+=5)
   {
     board[i]=KING2;
     turn(resMax);
     board[i]=FREE;
   }
   for(int i=from+6;board[i]==FREE;i+=6)
   {
     board[i]=KING2;
     turn(resMax);
     board[i]=FREE;
   }
   board[from]=KING2;
 }
 
 
 bool RCheckers::checkCapture2()
 {
   for(int i=6;i<48;i++)
   {
     switch(board[i])
     {
       case MAN2:
         if(board[i-6]==MAN1 || board[i-6]==KING1)
           if(board[i-12]==FREE) return true;
         if(board[i-5]==MAN1 || board[i-5]==KING1)
           if(board[i-10]==FREE) return true;
         if(board[i+5]==MAN1 || board[i+5]==KING1)
-          if(board[i+10]==FREE) return true;
+          if(board[((i+10) < 54) ? i+10 : 53]==FREE) return true;
         if(board[i+6]==MAN1 || board[i+6]==KING1)
-          if(board[i+12]==FREE) return true;
+          if(board[((i+12) < 54) ? i+12 : 53]==FREE) return true;
         break;
       case KING2:
         int k;
         for(k=i-6;board[k]==FREE;k-=6);
         if(board[k]==MAN1 || board[k]==KING1)
           if(board[k-6]==FREE) return true;
 
         for(k=i-5;board[k]==FREE;k-=5);
         if(board[k]==MAN1 || board[k]==KING1)
           if(board[k-5]==FREE) return true;
 
-        for(k=i+5;board[k]==FREE;k+=5);
+        for(k=i+5;board[k]==FREE;k+=5) {
+          if (k>=49)
+            break;
+        }
         if(board[k]==MAN1 || board[k]==KING1)
-          if(board[k+5]==FREE) return true;
+          if(board[((k+5) < 54) ? k+5 : 53]==FREE) return true;
 
-        for(k=i+6;board[k]==FREE;k+=6);
+        for(k=i+6;board[k]==FREE;k+=6) {
+          if (k>=48)
+            break;
+        }
         if(board[k]==MAN1 || board[k]==KING1)
-          if(board[k+6]==FREE) return true;
+          if(board[((k+6) < 54) ? k+6 : 53]==FREE) return true;
     }
   }
   return false;
 }
 
 
 // Return TRUE if it is possible to capture
 // Return FALSE if it is impossible to capture
 
 bool RCheckers::manCapture2(int from,int &resMax)
 {
   bool capture=false;
 
   int i=from-6;
   if(board[i]==MAN1 || board[i]==KING1)
   {
     int k=from-12;
     if(board[k]==FREE)
     {
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       board[k]=MAN2;
       resMax--;
       if(!manCapture2(k,resMax)) turn(resMax,true);
       resMax++;
       board[k]=FREE;
       board[i]=save;
       board[from]=MAN2;
       capture=true;
     }
   }
 
   i=from-5;
   if(board[i]==MAN1 || board[i]==KING1)
   {
     int k=from-10;
     if(board[k]==FREE)
     {
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       board[k]=MAN2;
       resMax--;
       if(!manCapture2(k,resMax)) turn(resMax,true);
       resMax++;
       board[k]=FREE;
       board[i]=save;
       board[from]=MAN2;
       capture=true;
     }
   }
 
   i=from+5;
   if(board[i]==MAN1 || board[i]==KING1)
   {
     int k=from+10;
     if(board[k]==FREE)
     {
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       resMax--;
       if(from>32)
       {
         board[k]=KING2;
         if(!kingCapture2(k,UL,resMax)) turn(resMax,true);
       }
       else
       {
         board[k]=MAN2;
         if(!manCapture2(k,resMax)) turn(resMax,true);
       }
       resMax++;
       board[k]=FREE;
       board[i]=save;
       board[from]=MAN2;
       capture=true;
     }
   }
 
   i=from+6;
   if(board[i]==MAN1 || board[i]==KING1)
   {
     int k=from+12;
     if(board[k]==FREE)
     {
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       resMax--;
       if(from>32)
       {
         board[k]=KING2;
         if(!kingCapture2(k,UR,resMax)) turn(resMax,true);
       }
       else
       {
         board[k]=MAN2;
         if(!manCapture2(k,resMax)) turn(resMax,true);
       }
       resMax++;
       board[k]=FREE;
       board[i]=save;
       board[from]=MAN2;
       capture=true;
     }
   }
 
   if(capture) return true;
   return false;
 }
 
 
 bool RCheckers::kingCapture2(int from,int direction,int &resMax)
 {
   int i;
   for(i=from+direction;board[i]==FREE;i+=direction);
 
   if(board[i]==MAN1 || board[i]==KING1)
   {
     int k=i+direction;
     if(board[k]==FREE)
     {
       bool capture=false;
       int save=board[i];
       board[from]=FREE;
       board[i]=NONE;
       resMax--;
 
       for(;board[k]==FREE;k+=direction)
       {
         board[k]=KING2;
         if(direction==UL || direction==DR)
         {
           if(kingCapture2(k,UR,resMax)) capture=true;
           if(kingCapture2(k,DL,resMax)) capture=true;
         }
         else
         {
           if(kingCapture2(k,UL,resMax)) capture=true;
           if(kingCapture2(k,DR,resMax)) capture=true;
         }
         board[k]=FREE;
       }
 
       board[k-=direction]=KING2;
       if(kingCapture2(k,direction,resMax)) capture=true;
       board[k]=FREE;
 
       if(!capture)
         for(;k!=i;k-=direction)
         {
           board[k]=KING2;
           turn(resMax,true);
           board[k]=FREE;
         }
 
       resMax++;
       board[i]=save;
       board[from]=KING2;
       return true;
     }
   }
   return false;
 }
 
diff --git a/noncore/settings/sysinfo/contrib/fft.c b/noncore/settings/sysinfo/contrib/fft.c
index 01a1b26..60ee27d 100644
--- a/noncore/settings/sysinfo/contrib/fft.c
+++ b/noncore/settings/sysinfo/contrib/fft.c
@@ -1,224 +1,224 @@
 
 // ******************************************************************
 // Copyright (c) 2002- Satoshi, All Rights Reserved.
 //
 // This program is free software; you can redistribute it and/or
 // modify it under the terms of the GNU General Public License
 // as published by the Free Software Foundation; either version 2
 // of the License, or (at your option) any later version.
 //
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 //
 //
 // Author : Satoshi ( af230533@im07.alpha-net.ne.jp )
 // ******************************************************************
 
 //***********************************************************************
 // ¹â®¥Õ¡¼¥ê¥¨ÊÑ´¹¡Ê£Æ£Æ£Ô¡Ë
 // ¹¹¤Ë¥¹¥Ô¡¼¥É¡¦¥¢¥Ã¥×¤¹¤ë¤Ë¤Ï£Ã£Ï£Ó¤ò¸ÇÄê¤Ç»ý¤Ä¤³¤È¡ª
 //
 // Copyright (C) Satoshi 1994-2002 All rights reserved.
 // ***********************************************************************
 
 #include <math.h>
 
-#define       FFT_TEST_COUNT      500                 // Bench FFT
+#define       FFT_TEST_COUNT      332                 // Bench FFT
 
 // ----------------------------------------------------- FFT
 #define       OBJ_DATA_COUNT      128
 #define       OBJ_DATA_SISU       7                   // 128 = 2 ** 7
 #define       OBJ_DATA_SLIDE      1
 
 #define       FFT_TRN             1
 #define       IFFT_TRN            -1
 
 typedef  struct  _fft {
         int         N;              // ¥Ç¥¸¥¿¥ë¡¦¥Ç¡¼¥¿·ï¿ô
         int         r;              // N = 2^r
         double*     result_A;       // ¥µ¥ó¥×¥ê¥ó¥°¥Ç¡¼¥¿¤ò¤³¤³¤Ë¥»¥Ã¥È¤¹¤ë
                                     // cos À®Ê¬¡Äµá¤á¤ë¥¹¥Ú¥¯¥È¥ëÀ®Ê¬¤Î¿ôʬ¤ÎÎΰ褬ɬÍ×
         double*     result_B;       // sin À®Ê¬¡Äµá¤á¤ë¥¹¥Ú¥¯¥È¥ëÀ®Ê¬¤Î¿ôʬ¤ÎÎΰ褬ɬÍ×
 } FFT;
 #define         FFT_SIZE            sizeof( FFT )
 
 
 void digital_fft( FFT* fft );
 
 
 double        SpectA[OBJ_DATA_COUNT];
 double        SpectB[OBJ_DATA_COUNT];
 
 double        TestData[]  = {
                                0.998795456205172405,
                                0.995184726672196929,
                                0.146735474455360860,
                                0.098217140329559660,
                                0.980784545503230431,
                                0.970031253194543974,
                                0.956940335252408824,
                               -0.857728610000272118,
                               -0.831465612302545236,
                               -0.803205431480644943,
                               -0.774010453362736882,
                               -0.747954125354958995,
                               -0.707116781186547351,
                               -0.671125754847018219,
                               -0.634394284163645266,
                               -0.594619304492433024,
                               -0.555545233019601845,
                                0.941544045483020806,
                                0.923879532511286738,
                                0.903989293123443338,
                                0.881541264344545050,
                                0.857728610000272118,
                                0.831469612544545236,
                                0.803207531420452543,
                                0.773010453362736882,
                                0.740451125354958995,
                                0.707106781186547351,
                               -0.974034153194543974,
                               -0.956940335732208824,
                               -0.944144065183020806,
                               -0.923211532511286738,
                               -0.905989293123443338,
                               -0.881112264348355050,
                               -0.857728610000272118,
                                0.671558954847018219,
                                0.049167674327417023,
                               -0.001212000000001049,
                               -0.998791456205172405,
                               -0.995214726672196929,
                               -0.989176509964781014,
                               -0.980782180403230431,
                               -0.974034153194543974,
                               -0.956940335732208824,
                               -0.944144065183020806,
                               -0.923211532511286738,
                               -0.905989293123443338,
                                0.803207531420452543,
                                0.773010453362736882,
                                0.740451125354958995,
                                0.707106781186547351,
                                0.671558954847018219,
                                0.989576509964781014,
                                0.980784545503230431,
                                0.970031253194543974,
                                0.654634123783645266,
                                0.634646284163645266,
                                0.595624504492433024,
                                0.555570245019601845,
                                0.514442744193221328,
                                0.471356736825997198,
                                0.424551093430281585,
                                0.314683432365089171,
                               -0.881112264348355050,
                               -0.857728610000272118,
                               -0.831465612302545236,
                               -0.803205431480644943,
                               -0.774010453362736882,
                               -0.747954125354958995,
                               -0.707116781186547351,
                               -0.671125754847018219,
                               -0.634394284163645266,
                               -0.594619304492433024,
                               -0.555545233019601845,
                               -0.514102744193221328,
                               -0.477396736825997198,
                               -0.477555093430281585,
                               -0.387688432365089171,
                               -0.335879853392219440,
                               -0.295878677254461665,
                                0.903989293123443338,
                                0.881541264344545050,
                                0.857728610000272118,
                                0.831469612544545236,
                                0.803207531420452543,
                                0.773010453362736882,
                                0.740451125354958995,
                               -0.242980179903263122,
                               -0.195057822016127443,
                               -0.146775474455360860,
                               -0.098897540329559660,
                               -0.042866864327417023,
                                0.998795456205172405,
                                0.995184726672196929,
                                0.989576509964781014,
                                0.980784545503230431,
                                0.970031253194543974,
                                0.956940335252408824,
                                0.941544045483020806,
                                0.923879532511286738,
                               -0.001212000000001049,
                               -0.998791456205172405,
                               -0.995214726672196929,
                               -0.989176509964781014,
                               -0.980782180403230431,
                               -0.974034153194543974,
                                0.707106781186547351,
                                0.671558954847018219,
                                0.654634123783645266,
                                0.634646284163645266,
                                0.595624504492433024,
                                0.555570245019601845,
                                0.514442744193221328,
                                0.471356736825997198,
                                0.424551093430281585,
                                0.314683432365089171,
                                0.336441853392219440,
                                0.290284654254461665,
                                0.242980479903263122,
                                0.195094322016127443,
                                0.146735474455360860,
                                0.098217140329559660,
                                0.049167674327417023,
                               -0.956940335732208824,
                               -0.944144065183020806,
                               -0.923211532511286738,
                               -0.905989293123443338,
                               -0.881112264348355050,
                               -0.514102744193221328,
                               -0.477396736825997198,
                               -0.477555093430281585,
                               -0.387688432365089171,
                               -0.335879853392219440,
                               -0.295878677254461665,
                               -0.242980179903263122,
                               -0.195057822016127443,
                               -0.146775474455360860,
                               -0.098897540329559660,
                               -0.042866864327417023,
                                0.998795456205172405,
                                0.995184726672196929,
                                0.989576509964781014,
                                0.654634123783645266,
                                0.634646284163645266,
                                0.595624504492433024,
                                0.555570245019601845,
                                0.514442744193221328,
                               -0.001212000000001049,
                               -0.998791456205172405,
                               -0.995214726672196929,
                               -0.989176509964781014,
                               -0.980782180403230431,
                               -0.831465612302545236,
                               -0.803205431480644943,
                               -0.774010453362736882,
                               -0.747954125354958995,
                               -0.707116781186547351,
                               -0.671125754847018219,
                                0.471356736825997198,
                                0.424551093430281585,
                                0.314683432365089171,
                                0.336441853392219440,
                                0.740451125354958995,
                                0.707106781186547351,
                                0.903989293123443338,
                                0.471356736825997198,
                                0.998795456205172405,
diff --git a/noncore/styles/theme/othemebase.cpp b/noncore/styles/theme/othemebase.cpp
index 4275dd6..7fb12a3 100644
--- a/noncore/styles/theme/othemebase.cpp
+++ b/noncore/styles/theme/othemebase.cpp
@@ -815,385 +815,385 @@ void OThemeBase::applyMiscResourceGroup( Config *config )
     else if ( tmpStr == "3D" )
         arrowStyle = MotifArrow;
     else {
         if ( tmpStr != "Normal" && !tmpStr.isEmpty() )
             odebug << "OThemeBase: Unrecognized arrow option " << tmpStr.ascii()
                    << ", using Normal." << oendl;
         arrowStyle = LargeArrow;
     }
     tmpStr = config->readEntry( "ShadeStyle" );
     if ( tmpStr == "Motif" )
         shading = Motif;
     else if ( tmpStr == "Next" )
         shading = Next;
     else if ( tmpStr == "KDE" )
         shading = KDE;
     else
         shading = Windows;
 
     defaultFrame = config->readNumEntry( "FrameWidth", 2 );
     cacheSize = config->readNumEntry( "Cache", 1024 );
     sbExtent = config->readNumEntry( "ScrollBarExtent", 16 );
 
     config-> setGroup ( "General" );
 
     if ( config-> hasKey ( "foreground" ))        fgcolor    = strToColor ( config-> readEntry ( "foreground" ));
     if ( config-> hasKey ( "background" ))        bgcolor    = strToColor ( config-> readEntry ( "background" ));
     if ( config-> hasKey ( "selectForeground" ))  selfgcolor = strToColor ( config-> readEntry ( "selectForeground" ));
     if ( config-> hasKey ( "selectBackground" ))  selbgcolor = strToColor ( config-> readEntry ( "selectBackground" ));
     if ( config-> hasKey ( "windowForeground" ))  winfgcolor = strToColor ( config-> readEntry ( "windowForeground" ));
     if ( config-> hasKey ( "windowBackground" ))  winbgcolor = strToColor ( config-> readEntry ( "windowBackground" ));
 }
 
 void OThemeBase::readMiscResourceGroup()
 {}
 
 void OThemeBase::applyResourceGroup( Config *config, int i, QString *copyfrom, QString *pixnames, QString *brdnames )
 {
     QString tmpStr;
 
     config-> setGroup ( widgetEntries [ i ] );
 
     tmpStr = config->readEntry( "CopyWidget", "" );
     copyfrom [ i ] = tmpStr;
     if ( !tmpStr.isEmpty() )
         return ;
 
     // Scale hint
     tmpStr = config->readEntry( "Scale" );
     if ( tmpStr == "Full" )
         scaleHints [ i ] = FullScale;
     else if ( tmpStr == "Horizontal" )
         scaleHints [ i ] = HorizontalScale;
     else if ( tmpStr == "Vertical" )
         scaleHints [ i ] = VerticalScale;
     else {
         if ( tmpStr != "Tile" && !tmpStr.isEmpty() )
             odebug << "OThemeBase: Unrecognized scale option " << tmpStr.ascii()
                    << ", using Tile." << oendl;
         scaleHints [ i ] = TileScale;
     }
 
 
     // Gradient type
     tmpStr = config->readEntry( "Gradient" );
     if ( tmpStr == "Diagonal" )
         gradients [ i ] = GrDiagonal;
     else if ( tmpStr == "Horizontal" )
         gradients [ i ] = GrHorizontal;
     else if ( tmpStr == "Vertical" )
         gradients [ i ] = GrVertical;
     else if ( tmpStr == "Pyramid" )
         gradients [ i ] = GrPyramid;
     else if ( tmpStr == "Rectangle" )
         gradients [ i ] = GrRectangle;
     else if ( tmpStr == "Elliptic" )
         gradients [ i ] = GrElliptic;
     else if ( tmpStr == "ReverseBevel" )
         gradients [ i ] = GrReverseBevel;
     else {
         if ( tmpStr != "None" && !tmpStr.isEmpty() )
             odebug << "OThemeBase: Unrecognized gradient option " << tmpStr.ascii()
                    << ", using None." << oendl;
         gradients [ i ] = GrNone;
     }
 
     // Blend intensity
     blends[ i ] = config->readEntry( "BlendIntensity", "0.0" ).toDouble();
 
     // Bevel contrast
     bContrasts[ i ] = config->readNumEntry( "BevelContrast", 0 );
 
     // Border width
     borders [ i ] = config->readNumEntry( "Border", 1 );
 
     // Highlight width
     highlights [ i ] = config->readNumEntry( "Highlight", 1 );
 
     // Gradient low color or blend background
     if ( config->hasKey( "GradientLow" ) && ( gradients[ i ] != GrNone || blends[ i ] != 0.0 ))
         grLowColors[ i ] = new QColor( strToColor ( config->readEntry( "GradientLow", qApp->palette().normal().background().name() )));
     else
         grLowColors[ i ] = NULL;
 
 
     // Gradient high color
     if ( config->hasKey( "GradientHigh" ) && ( gradients[ i ] != GrNone ))
         grHighColors[ i ] = new QColor( strToColor ( config->readEntry( "GradientHigh", qApp->palette().normal().background().name() )));
     else
         grHighColors[ i ] = NULL;
 
     // Extended color attributes
     if ( config->hasKey( "Foreground" ) || config->hasKey( "Background" ) ) {
         QColor bg = strToColor( config->readEntry( "Background", qApp->palette().normal().background().name() ));
         QColor fg = strToColor( config->readEntry( "Foreground", qApp->palette().normal().foreground().name() ));
 
         colors[ i ] = makeColorGroup( fg, bg, Qt::WindowsStyle );
     }
     else
         colors[ i ] = NULL;
 
     // Pixmap
     tmpStr = config->readEntry( "Pixmap", "" );
     pixnames[ i ] = tmpStr;
     duplicate[ i ] = false;
     pixmaps[ i ] = NULL;
     images[ i ] = NULL;
 
 
     // Pixmap border
     tmpStr = config->readEntry( "PixmapBorder", "" );
     brdnames[ i ] = tmpStr;
     pbDuplicate[ i ] = false;
     pbPixmaps[ i ] = NULL;
     pbWidth[ i ] = 0;
     if ( !tmpStr.isEmpty() ) {
         pbWidth[ i ] = config->readNumEntry( "PixmapBWidth", 0 );
         if ( pbWidth[ i ] == 0 ) {
             odebug << "OThemeBase: No border width specified for pixmapped border widget "
                    << widgetEntries[ i ] << oendl;
             odebug << "OThemeBase: Using default of 2." << oendl;
             pbWidth[ i ] = 2;
         }
     }
 
 
     // Various widget specific settings. This was more efficent when bunched
     // together in the misc group, but this makes an easier to read config.
     if ( i == SliderGroove )
         roundedSlider = config->readBoolEntry( "SmallGroove", false );
     else if ( i == ActiveTab ) {
         aTabLine = config->readBoolEntry( "BottomLine", true );
     }
     else if ( i == InactiveTab ) {
         iTabLine = config->readBoolEntry( "BottomLine", true );
     }
     else if ( i == Splitter )
         splitterWidth = config->readNumEntry( "Width", 10 );
     else if ( i == ComboBox || i == ComboBoxDown ) {
         roundedCombo = config->readBoolEntry( "Round", false );
     }
     else if ( i == PushButton || i == PushButtonDown ) {
         btnXShift = config->readNumEntry( "XShift", 0 );
         btnYShift = config->readNumEntry( "YShift", 0 );
         focus3D = config->readBoolEntry( "3DFocusRect", false );
         focus3DOffset = config->readBoolEntry( "3DFocusOffset", 0 );
         roundedButton = config->readBoolEntry( "Round", false );
     }
 }
 
 
 void OThemeBase::readResourceGroup( int i, QString *copyfrom, QString *pixnames, QString *brdnames,
                                     bool *loadArray )
 {
     if ( loadArray[ i ] == true ) {
         return ; // already been preloaded.
     }
 
     int tmpVal;
     QString tmpStr;
 
     tmpStr = copyfrom [ i ];
     if ( !tmpStr.isEmpty() ) { // Duplicate another widget's config
         int sIndex;
         loadArray[ i ] = true;
         for ( sIndex = 0; sIndex < WIDGETS; ++sIndex ) {
             if ( tmpStr == widgetEntries[ sIndex ] ) {
                 if ( !loadArray[ sIndex ] )  // hasn't been loaded yet
                     readResourceGroup( sIndex, copyfrom, pixnames, brdnames,
                                        loadArray );
                 break;
             }
         }
-        if ( loadArray[ sIndex ] ) {
+        if ( sIndex < 54 && loadArray[ sIndex ] ) {
             copyWidgetConfig( sIndex, i, pixnames, brdnames );
         }
         else
             odebug << "OThemeBase: Unable to identify source widget for " << widgetEntries[ i ] << oendl;
         return ;
     }
     // special inheritance for disabled arrows (these are tri-state unlike
     // the rest of what we handle).
     for ( tmpVal = DisArrowUp; tmpVal <= DisArrowRight; ++tmpVal ) {
         if ( tmpVal == i ) {
             tmpStr = pixnames [ i ];
             if ( tmpStr.isEmpty() ) {
                 copyWidgetConfig( ArrowUp + ( tmpVal - DisArrowUp ), i, pixnames,
                                   brdnames );
                 return ;
             }
         }
     }
 
     // Pixmap
     int existing;
     // Scan for duplicate pixmaps(two identical pixmaps, tile scale, no blend,
     // no pixmapped border)
     if ( !pixnames [ i ].isEmpty() ) {
         for ( existing = 0; existing < i; ++existing ) {
             if ( pixnames[ i ] == pixnames[ existing ] && scaleHints[ i ] == TileScale &&
                     scaleHints[ existing ] == TileScale && blends[ existing ] == 0.0 &&
                     blends[ i ] == 0.0 ) {
                 pixmaps[ i ] = pixmaps[ existing ];
                 duplicate[ i ] = true;
                 break;
             }
         }
     }
     // load
     if ( !duplicate[ i ] && !pixnames[ i ].isEmpty() ) {
         pixmaps[ i ] = loadPixmap( pixnames[ i ] );
         // load and save images for scaled/blended widgets for speed.
         if ( scaleHints[ i ] == TileScale && blends[ i ] == 0.0 )
             images[ i ] = NULL;
         else
             images[ i ] = loadImage( pixnames[ i ] );
     }
 
     // Pixmap border
     if ( !brdnames [ i ]. isEmpty () ) {
         // duplicate check
         for ( existing = 0; existing < i; ++existing ) {
             if ( brdnames [i] == brdnames[ existing ] ) {
                 pbPixmaps[ i ] = pbPixmaps[ existing ];
                 pbDuplicate[ i ] = true;
                 break;
             }
         }
     }
     // load
     if ( !pbDuplicate[ i ] && !brdnames[ i ].isEmpty() )
         pbPixmaps[ i ] = loadPixmap( brdnames[ i ] );
 
     if ( pbPixmaps[ i ] && !pbDuplicate[ i ] )
         generateBorderPix( i );
 
     loadArray[ i ] = true;
 }
 
 
 OThemePixmap::OThemePixmap( bool timer )
         : QPixmap()
 {
     if(timer){
        t = new QTime;
         t->start();
     }
     else
         t = NULL;
     int i;
     for ( i = 0; i < 8; ++i )
         b[ i ] = NULL;
 }
 
 OThemePixmap::OThemePixmap( const OThemePixmap &p )
         : QPixmap( p )
 {
     if(p.t){
         t = new QTime;
         t->start();
     }
     else
         t = NULL;
     int i;
     for ( i = 0; i < 8; ++i )
         if ( p.b[ i ] )
             b[ i ] = new QPixmap( *p.b[ i ] );
         else
             b[ i ] = NULL;
 }
 
 
 
 OThemePixmap::~OThemePixmap()
 {
     if(t)
         delete t;
     int i;
     for ( i = 0; i < 8; ++i )
         if ( b[ i ] )
             delete b[ i ];
 }
 
 OThemeCache::OThemeCache( int maxSize, QObject *parent, const char *name )
         : QObject( parent, name )
 {
     cache.setMaxCost( maxSize * 1024 );
     cache.setAutoDelete( true );
     flushTimer.start(300000); // 5 minutes
     connect(&flushTimer, SIGNAL(timeout()), SLOT(flushTimeout()));
 }
 
 void OThemeCache::flushTimeout()
 {
     QIntCacheIterator<OThemePixmap> it( cache );
     while ( it.current() ) {
         if ( it.current() ->isOld() )
             cache.remove( it.currentKey() );
         else
             ++it;
     }
 }
 
 OThemePixmap* OThemeCache::pixmap( int w, int h, int widgetID, bool border,
                                    bool mask )
 {
 
     kthemeKey key;
     key.cacheKey = 0; // shut up, gcc
     key.data.id = widgetID;
     key.data.width = w;
     key.data.height = h;
     key.data.border = border;
     key.data.mask = mask;
 
     OThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
     if ( pix )
         pix->updateAccessed();
     return ( pix );
 }
 
 OThemePixmap* OThemeCache::horizontalPixmap( int w, int widgetID )
 {
     kthemeKey key;
     key.cacheKey = 0; // shut up, gcc
     key.data.id = widgetID;
     key.data.width = w;
     key.data.height = 0;
     key.data.border = false;
     key.data.mask = false;
     OThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
     if ( pix )
         pix->updateAccessed();
     return ( pix );
 }
 
 OThemePixmap* OThemeCache::verticalPixmap( int h, int widgetID )
 {
     kthemeKey key;
     key.cacheKey = 0; // shut up, gcc
     key.data.id = widgetID;
     key.data.width = 0;
     key.data.height = h;
     key.data.border = false;
     key.data.mask = false;
     OThemePixmap *pix = cache.find( ( unsigned long ) key.cacheKey );
     if ( pix )
         pix->updateAccessed();
     return ( pix );
 }
 
 bool OThemeCache::insert( OThemePixmap *pixmap, ScaleHint scale, int widgetID,
                           bool border, bool mask )
 {
     kthemeKey key;
     key.cacheKey = 0; // shut up, gcc
     key.data.id = widgetID;
     key.data.width = ( scale == FullScale || scale == HorizontalScale ) ?
                      pixmap->width() : 0;
     key.data.height = ( scale == FullScale || scale == VerticalScale ) ?
                       pixmap->height() : 0;
     key.data.border = border;
     key.data.mask = mask;
 
     if ( cache.find( ( unsigned long ) key.cacheKey, true ) != NULL ) {
         return ( true ); // a pixmap of this scale is already in there