fixed an ugly timezone bug

1 files changed, 25 insertions, 25 deletions

diff --git a/microkde/kdecore/klocale.cpp b/microkde/kdecore/klocale.cpp
index 21e6937..d3b04dc 100644
--- a/microkde/kdecore/klocale.cpp
+++ b/microkde/kdecore/klocale.cpp
@@ -1,350 +1,350 @@
 #include <qregexp.h>
 #include <qapplication.h>
 
 #include "kdebug.h"
 #include "kcalendarsystemgregorian.h"
 
 #include "klocale.h"
 
 #include <qstringlist.h>
 QStringList missingTrans;
 
 QDict<QString> *mLocaleDict = 0;
 void setLocaleDict( QDict<QString> * dict )
 {
     mLocaleDict = dict;
 
 }
 void addMissing(const char *text) 
 {
     return;
     QString mis ( text );
     if ( !missingTrans.contains( mis  ) )
         missingTrans.append(mis);
 
 }
 
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qtextcodec.h>
 void dumpMissing()
 {
     return;
     QString fileName = "/tmp/usertrans.txt";
     QFile file( fileName );
     if (!file.open( IO_WriteOnly ) ) {
         return ;
     } 
     QTextStream ts( &file );
     ts.setCodec( QTextCodec::codecForName("utf8") );
 
     int i;
     for ( i = 0; i< missingTrans.count(); ++i ) {
 
         QString text = missingTrans[i].replace( QRegExp("\n"),"\\n" );
         ts << "{ \""<<text<< "\",\""<< text <<"\" },\n";
 
     }
     file.close();
 }
 
 QString i18n(const char *text)
 {
     if ( ! mLocaleDict ) {
         addMissing( text );
         return QString( text );
     }
     else {
         QString* ret  =  mLocaleDict->find(QString(text)) ;
         if ( ret == 0 ) {
             addMissing( text );
             return QString( text );
         }
         else {
             if ( (*ret).isEmpty() ) {
                 addMissing( text );
                 return QString( text );
             }
             else
                 return (*ret);
         }
     }
 
 }
 
 QString i18n(const char *,const char *text)
 {
   return i18n( text );
 }
 
 QString i18n(const char *text1, const char *textn, int num)
 {
   if ( num == 1 ) return i18n( text1 );
   else {
     QString text = i18n( textn );
     int pos = text.find( "%n" );
     if ( pos >= 0 ) text.replace( pos, 2, QString::number( num ) );
     return text;
   }
 }
 
 inline void put_it_in( QChar *buffer, uint& index, const QString &s )
 {
   for ( uint l = 0; l < s.length(); l++ )
     buffer[index++] = s.at( l );
 }
 
 inline void put_it_in( QChar *buffer, uint& index, int number )
 {
   buffer[index++] = number / 10 + '0';
   buffer[index++] = number % 10 + '0';
 }
 
 static int readInt(const QString &str, uint &pos)
 {
   if (!str.at(pos).isDigit()) return -1;
   int result = 0;
   for (; str.length() > pos && str.at(pos).isDigit(); pos++)
     {
       result *= 10;
       result += str.at(pos).digitValue();
     }
 
   return result;
 }
 
 KLocale::KLocale() : mCalendarSystem( 0 )
 {
 
     m_decimalSymbol = ".";
     m_positiveSign = "";
     m_negativeSign = "-";
     m_thousandsSeparator = ",";
 
 
 
 
     mWeekStartsMonday = true;
     mHourF24Format = true;
     mIntDateFormat = Default;
     mIntTimeFormat = Default;
     mLanguage = 0;  
     mDateFormat = "%a %Y %b %d";
     mDateFormatShort = "%Y-%m-%d"; 
-    mTimeZoneList << i18n ("-11:00 US/Samoa")
-            << i18n ("-10:00 US/Hawaii")
-            << i18n ("-09:00 US/Alaska")
-            << i18n ("-08:00 US/Pacific")
-            << i18n ("-07:00 US/Mountain")
-            << i18n ("-06:00 US/Central")
-            << i18n ("-05:00 US/Eastern")
-            << i18n ("-04:00 Brazil/West")
-            << i18n ("-03:00 Brazil/East")
-            << i18n ("-02:00 Brazil/DeNoronha")
-            << i18n ("-01:00 Atlantic/Azores")
-            << i18n (" 00:00 Europe/London(UTC)")
-            << i18n ("+01:00 Europe/Oslo(CET)")
-            << i18n ("+02:00 Europe/Helsinki")
-            << i18n ("+03:00 Europe/Moscow")
-            << i18n ("+04:00 Indian/Mauritius")
-            << i18n ("+05:00 Indian/Maldives")
-            << i18n ("+06:00 Indian/Chagos")
-            << i18n ("+07:00 Asia/Bangkok")
-            << i18n ("+08:00 Asia/Hongkong")
-            << i18n ("+09:00 Asia/Tokyo")
-            << i18n ("+10:00 Asia/Vladivostok")
-            << i18n ("+11:00 Asia/Magadan")
-            << i18n ("+12:00 Asia/Kamchatka")
-            //  << i18n (" xx:xx User defined offset")
+    mTimeZoneList <<  ("-11:00 US/Samoa")
+            <<  ("-10:00 US/Hawaii")
+            <<  ("-09:00 US/Alaska")
+            <<  ("-08:00 US/Pacific")
+            <<  ("-07:00 US/Mountain")
+            <<  ("-06:00 US/Central")
+            <<  ("-05:00 US/Eastern")
+            <<  ("-04:00 Brazil/West")
+            <<  ("-03:00 Brazil/East")
+            <<  ("-02:00 Brazil/DeNoronha")
+            <<  ("-01:00 Atlantic/Azores")
+            <<  (" 00:00 Europe/London(UTC)")
+            <<  ("+01:00 Europe/Oslo(CET)")
+            <<  ("+02:00 Europe/Helsinki")
+            <<  ("+03:00 Europe/Moscow")
+            <<  ("+04:00 Indian/Mauritius")
+            <<  ("+05:00 Indian/Maldives")
+            <<  ("+06:00 Indian/Chagos")
+            <<  ("+07:00 Asia/Bangkok")
+            <<  ("+08:00 Asia/Hongkong")
+            <<  ("+09:00 Asia/Tokyo")
+            <<  ("+10:00 Asia/Vladivostok")
+            <<  ("+11:00 Asia/Magadan")
+            <<  ("+12:00 Asia/Kamchatka")
+            //  <<  (" xx:xx User defined offset")
             << i18n (" Local Time");
     mSouthDaylight = false;
     mTimeZoneOffset = 0;
     daylightEnabled = false;
 }
 
 void KLocale::setDateFormat( QString s )
 {
     mDateFormat = s;
 }
 
 void KLocale::setDateFormatShort( QString s )
 {
     mDateFormatShort = s;
 }
 
 void KLocale::setHore24Format ( bool b )
 {
     mHourF24Format = b;
 }
 void KLocale::setWeekStartMonday( bool b )
 {
     mWeekStartsMonday = b;
 }
 
 KLocale::IntDateFormat KLocale::getIntDateFormat( )
 {
     return mIntDateFormat;
 
 }
 void KLocale::setIntDateFormat( KLocale::IntDateFormat i )
 {
     mIntDateFormat = i;
 }
 KLocale::IntDateFormat KLocale::getIntTimeFormat( )
 {
     return mIntTimeFormat;
 
 }
 void KLocale::setIntTimeFormat( KLocale::IntDateFormat i )
 {
     mIntTimeFormat = i;
 }
 
 void KLocale::setLanguage( int i )
 {
     mLanguage = i;
 }
 int  KLocale::language( )
 {
     return mLanguage;
 }
 QString KLocale::translate( const char *index ) const
 {
   return i18n( index );
 }
 
 QString KLocale::translate( const char *, const char *fallback) const
 {
   return i18n( fallback );
 }
 
 QString KLocale::formatTime(const QTime &pTime, bool includeSecs, IntDateFormat intIntDateFormat) const
 {
     const QString rst = timeFormat(intIntDateFormat);
 
     // only "pm/am" here can grow, the rest shrinks, but
     // I'm rather safe than sorry
     QChar *buffer = new QChar[rst.length() * 3 / 2 + 30];
 
     uint index = 0;
     bool escape = false;
     int number = 0;
 
     for ( uint format_index = 0; format_index < rst.length(); format_index++ )
         {
             if ( !escape )
                 {
                     if ( rst.at( format_index ).unicode() == '%' )
                         escape = true;
                     else
                         buffer[index++] = rst.at( format_index );
                 }
             else
                 {
                     switch ( rst.at( format_index ).unicode() )
                         {
                         case '%':
                             buffer[index++] = '%';
                             break;
                         case 'H':
                             put_it_in( buffer, index, pTime.hour() );
                             break;
                         case 'I':
                             put_it_in( buffer, index, ( pTime.hour() + 11) % 12 + 1 );
                             break;
                         case 'M':
                             put_it_in( buffer, index, pTime.minute() );
                             break;
                         case 'S':
                             if (includeSecs)
                                 put_it_in( buffer, index, pTime.second() );
                             else
                                 {
                                     // we remove the seperator sign before the seconds and
                                     // assume that works everywhere
                                     --index;
                                     break;
                                 }
                             break;
                         case 'k':
                             number = pTime.hour();
                         case 'l':
                             // to share the code
                             if ( rst.at( format_index ).unicode() == 'l' )
                                 number = (pTime.hour() + 11) % 12 + 1;
                             if ( number / 10 )
                                 buffer[index++] = number / 10 + '0';
                             buffer[index++] = number % 10 + '0';
                             break;
                         case 'p':
                             {
                                 QString s;
                                 if ( pTime.hour() >= 12 )
                                     put_it_in( buffer, index, i18n("pm") );
                                 else
                                     put_it_in( buffer, index, i18n("am") );
                                 break;
                             }
                         default:
                             buffer[index++] = rst.at( format_index );
                             break;
                         }
                     escape = false;
                 }
         }
     QString ret( buffer, index );
     delete [] buffer;
     return ret;
 }    
 
 QString KLocale::formatDate(const QDate &pDate, bool shortFormat, IntDateFormat intIntDateFormat) const
 {
   const QString rst = shortFormat?dateFormatShort(intIntDateFormat):dateFormat(intIntDateFormat);
 
   // I'm rather safe than sorry
   QChar *buffer = new QChar[rst.length() * 3 / 2 + 50];
 
   unsigned int index = 0;
   bool escape = false;
   int number = 0;
 
   for ( uint format_index = 0; format_index < rst.length(); ++format_index )
     {
       if ( !escape )
 	{
 	  if ( rst.at( format_index ).unicode() == '%' )
 	    escape = true;
 	  else
 	    buffer[index++] = rst.at( format_index );
 	}
       else
 	{
 	  switch ( rst.at( format_index ).unicode() )
 	    {
 	    case '%':
 	      buffer[index++] = '%';
 	      break;
 	    case 'Y':
 	      put_it_in( buffer, index, pDate.year() / 100 );
 	    case 'y':
 	      put_it_in( buffer, index, pDate.year() % 100 );
 	      break;
 	    case 'n':
 	      number = pDate.month();
 	    case 'e':
 	      // to share the code
 	      if ( rst.at( format_index ).unicode() == 'e' )
 		number = pDate.day();
 	      if ( number / 10 )
 		buffer[index++] = number / 10 + '0';
 	      buffer[index++] = number % 10 + '0';
 	      break;
 	    case 'm':
 	      put_it_in( buffer, index, pDate.month() );
 	      break;
 	    case 'b':
 	      put_it_in( buffer, index, monthName(pDate.month(), true) );
 	      break;
 	    case 'B':
 	      put_it_in( buffer, index, monthName(pDate.month(), false) );
 	      break;