skins/AknSkins/sdcsrc/SDCBinOutput.cpp
changeset 50 c6286dcf6040
parent 0 05e9090e2422
child 53 8f0f421d3d0f
child 55 33ddb261ab37
equal deleted inserted replaced
43:1951b3078691 50:c6286dcf6040
    13 *
    13 *
    14 * Description:  Binary output.
    14 * Description:  Binary output.
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 #include <windows.h>
    18 #include <wchar.h>
       
    19 #include <sys/time.h>
       
    20 #include <unistd.h>
       
    21 #include <cstdlib>
       
    22 #include <string>
    19 
    23 
    20 #include "SDCGlobals.h"
    24 #include "SDCGlobals.h"
    21 #include "SDCBinOutput.h"
    25 #include "SDCBinOutput.h"
    22 #include "AknsConstants.hrh"
    26 #include "AknsConstants.hrh"
    23 #include "SDCException.h"
    27 #include "SDCException.h"
       
    28 #include "SDCCompat.h"
    24 
    29 
    25 // Make std namespace available for compatibility
    30 // Make std namespace available for compatibility
    26 namespace std {}
    31 namespace std {}
    27 using namespace std;
    32 using namespace std;
    28 
    33 
    79     iData = aData;
    84     iData = aData;
    80     strcpy( iBaseName, aBaseName );
    85     strcpy( iBaseName, aBaseName );
    81 
    86 
    82     PrepareSkinDescriptor( aStubOnly );
    87     PrepareSkinDescriptor( aStubOnly );
    83 
    88 
    84     if( iOutputPos != iOutputVector.size() ) throw CSDCException( ESDCUnknownError, "Internal binary output size does not match" );
    89     if( iOutputPos != static_cast<int>( iOutputVector.size() ) ) throw CSDCException( ESDCUnknownError, "Internal binary output size does not match" );
    85 
    90 
    86     FILE* file = fopen( aBinFilename, "wb" );
    91     FILE* file = fopen( aBinFilename, "wb" );
    87     if( !file ) throw CSDCException( ESDCFileOpenError, "Can not open target binary file for writing" );
    92     if( !file ) throw CSDCException( ESDCFileOpenError, "Can not open target binary file for writing" );
    88     int i;
    93     unsigned int i;
    89     for( i=0; i<iOutputVector.size(); i++ )
    94     for( i=0; i<iOutputVector.size(); i++ )
    90         {
    95         {
    91         fputc( iOutputVector[i], file );
    96         fputc( iOutputVector[i], file );
    92         }
    97         }
    93     fclose( file );
    98     fclose( file );
   139     WriteInt( 0 );              // ChunksN
   144     WriteInt( 0 );              // ChunksN
   140 
   145 
   141     PrepareInformation();
   146     PrepareInformation();
   142     chunksN++;
   147     chunksN++;
   143 
   148 
   144     int i;
   149     unsigned int i;
   145 
   150 
   146     for( i=0; i<iData->iTargetDeviceVector.size(); i++ )
   151     for( i=0; i<iData->iTargetDeviceVector.size(); i++ )
   147         {
   152         {
   148         TSDCTargetDeviceEntry* entry = iData->iTargetDeviceVector[i];
   153         TSDCTargetDeviceEntry* entry = iData->iTargetDeviceVector[i];
   149         PrepareTargetDevice( entry->iDeviceName );
   154         PrepareTargetDevice( entry->iDeviceName );
   232 
   237 
   233         // Mirrored
   238         // Mirrored
   234         PrepareEncapsulatedNormalClass( 0x00020000 );
   239         PrepareEncapsulatedNormalClass( 0x00020000 );
   235         chunksN++;
   240         chunksN++;
   236 
   241 
   237         for (int count = 0;count < iData->iLanguageVector.size(); count++)
   242         for (unsigned int count = 0;count < iData->iLanguageVector.size(); count++)
   238             {
   243             {
   239             // Language
   244             // Language
   240             PrepareEncapsulatedNormalClass( iData->iLanguageVector[count] );
   245             PrepareEncapsulatedNormalClass( iData->iLanguageVector[count] );
   241             chunksN++;
   246             chunksN++;
   242             }
   247             }
   264     WriteUint16( 1 );           // Version
   269     WriteUint16( 1 );           // Version
   265 
   270 
   266     AppendBytes( 1*2 );
   271     AppendBytes( 1*2 );
   267     WriteUint16( wcslen( aDeviceName ) );
   272     WriteUint16( wcslen( aDeviceName ) );
   268 
   273 
   269     for( int i=0; i<wcslen( aDeviceName ); i++ )
   274     for( unsigned int i=0; i<wcslen( aDeviceName ); i++ )
   270         {
   275         {
   271         AppendBytes( 2 );
   276         AppendBytes( 2 );
   272         WriteUint16( aDeviceName[i] );
   277         WriteUint16( aDeviceName[i] );
   273         }
   278         }
   274 
   279 
   291 
   296 
   292     AppendBytes( 2*2 );
   297     AppendBytes( 2*2 );
   293     WriteInt16( aLanguage );
   298     WriteInt16( aLanguage );
   294     WriteUint16( wcslen( aName ) );
   299     WriteUint16( wcslen( aName ) );
   295 
   300 
   296     for( int i=0; i<wcslen( aName ); i++ )
   301     for( unsigned int i=0; i<wcslen( aName ); i++ )
   297         {
   302         {
   298         AppendBytes( 2 );
   303         AppendBytes( 2 );
   299         WriteUint16( aName[i] );
   304         WriteUint16( aName[i] );
   300         }
   305         }
   301 
   306 
   308     }
   313     }
   309 
   314 
   310 void CSDCBinOutput::PrepareInformation()
   315 void CSDCBinOutput::PrepareInformation()
   311     {
   316     {
   312     TPos startPos( this );
   317     TPos startPos( this );
   313     int i;
   318     unsigned int i;
   314 
   319 
   315     AppendBytes( 1*4 + 2*2 );
   320     AppendBytes( 1*4 + 2*2 );
   316     WriteUint( 0 );             // Length
   321     WriteUint( 0 );             // Length
   317     WriteUint16( 11 );          // Type
   322     WriteUint16( 11 );          // Type
   318     WriteUint16( 2 );           // Version
   323     WriteUint16( 2 );           // Version
   319 
   324 
   320     AppendBytes( 2*4 );
   325     AppendBytes( 2*4 );
   321     SYSTEMTIME sysTime;
   326 
   322     GetSystemTime( &sysTime );
   327 	struct timeval sysTime;
   323     FILETIME fileTime;
   328 	gettimeofday( &sysTime, NULL);
   324     SystemTimeToFileTime( &sysTime, &fileTime );
   329 	// 100-nanosecond
   325     WriteInt( fileTime.dwHighDateTime );
   330 	unsigned long long currentTime;
   326     WriteInt( fileTime.dwLowDateTime );
   331 	// get the 100-nanosecond number at time of UTC
       
   332 	currentTime = ( sysTime.tv_usec + mktime(gmtime(&sysTime.tv_sec)) * SEC_TO_USEC ) * USEC_TO_100NANOSEC;
       
   333 
       
   334 	unsigned int highPart = static_cast<unsigned int>((currentTime >> 32) );
       
   335 	unsigned int lowPart = static_cast<unsigned int>( currentTime );
       
   336 
       
   337     WriteInt( highPart );
       
   338     WriteInt( lowPart );
   327 
   339 
   328     AppendBytes( 2*4 );
   340     AppendBytes( 2*4 );
   329     WriteInt( (gVersionMajor<<16) | gVersionMinor );
   341     WriteInt( (gVersionMajor<<16) | gVersionMinor );
   330     WriteInt( 0 );
   342     WriteInt( 0 );
   331 
   343 
   402 
   414 
   403     AppendBytes( 1*1 + 1*2 );
   415     AppendBytes( 1*1 + 1*2 );
   404     WriteByte( aWpType );
   416     WriteByte( aWpType );
   405     WriteUint16( strlen( buf ) );
   417     WriteUint16( strlen( buf ) );
   406 
   418 
   407     for( int i=0; i<strlen( buf ); i++ )
   419     for( unsigned int i=0; i<strlen( buf ); i++ )
   408         {
   420         {
   409         AppendBytes( 2 );
   421         AppendBytes( 2 );
   410         WriteUint16( (short int)buf[i] );
   422         WriteUint16( (short int)buf[i] );
   411         }
   423         }
   412 
   424 
   432 
   444 
   433     AppendBytes( 1*4 + 1*2 );
   445     AppendBytes( 1*4 + 1*2 );
   434     WriteInt( aId );
   446     WriteInt( aId );
   435     WriteUint16( strlen( aFilename ) );
   447     WriteUint16( strlen( aFilename ) );
   436 
   448 
   437     for( int i=0; i<strlen( aFilename ); i++ )
   449     for( unsigned int i=0; i<strlen( aFilename ); i++ )
   438         {
   450         {
   439         AppendBytes( 2 );
   451         AppendBytes( 2 );
   440         WriteUint16( (short int)aFilename[i] );
   452         WriteUint16( (short int)aFilename[i] );
   441         }
   453         }
   442 
   454 
   533     int chunksN = 0;
   545     int chunksN = 0;
   534     AppendBytes( 1*4 );
   546     AppendBytes( 1*4 );
   535     TPos chunksNPos( this );
   547     TPos chunksNPos( this );
   536     WriteInt( 0 );              // ChunksN
   548     WriteInt( 0 );              // ChunksN
   537 
   549 
   538     int i;
   550     unsigned int i;
   539     for( i=0; i<iData->iBitmapDefVector.size(); i++ )
   551     for( i=0; i<iData->iBitmapDefVector.size(); i++ )
   540         {
   552         {
   541         if( iData->iBitmapDefVector[i]->iRestriction != aRestriction ) continue;
   553         if( iData->iBitmapDefVector[i]->iRestriction != aRestriction ) continue;
   542 
   554 
   543         if( (iData->iBitmapDefVector[i]->iAppIconBitmap==false) || iData->IsScalable() )
   555         if( (iData->iBitmapDefVector[i]->iAppIconBitmap==false) || iData->IsScalable() )
   648     int chunksN = 0;
   660     int chunksN = 0;
   649     AppendBytes( 1*4 );
   661     AppendBytes( 1*4 );
   650     TPos chunksNPos( this );
   662     TPos chunksNPos( this );
   651     WriteInt( 0 );              // ChunksN
   663     WriteInt( 0 );              // ChunksN
   652 
   664 
   653     int i;
   665     unsigned int i;
   654     for( i=0; i<iData->iBitmapDefVector.size(); i++ )
   666     for( i=0; i<iData->iBitmapDefVector.size(); i++ )
   655         {
   667         {
   656         if( iData->iBitmapDefVector[i]->iAppIconBitmap == true )
   668         if( iData->iBitmapDefVector[i]->iAppIconBitmap == true )
   657             {
   669             {
   658             if( iData->iBitmapDefVector[i]->iRestriction )
   670             if( iData->iBitmapDefVector[i]->iRestriction )
   734     AppendBytes( 2*4 + 1*1 );
   746     AppendBytes( 2*4 + 1*1 );
   735     WriteInt( aColorTableDef->iIID.iMajor );
   747     WriteInt( aColorTableDef->iIID.iMajor );
   736     WriteInt( aColorTableDef->iIID.iMinor );
   748     WriteInt( aColorTableDef->iIID.iMinor );
   737     WriteByte( aColorTableDef->iColors.size() );
   749     WriteByte( aColorTableDef->iColors.size() );
   738 
   750 
   739     for( int i=0; i<aColorTableDef->iColors.size(); i++ )
   751     for( unsigned int i=0; i<aColorTableDef->iColors.size(); i++ )
   740         {
   752         {
   741         AppendBytes( 1*2 + 1*4 );
   753         AppendBytes( 1*2 + 1*4 );
   742         WriteInt16( (short int)aColorTableDef->iColors[i].iIndex );
   754         WriteInt16( (short int)aColorTableDef->iColors[i].iIndex );
   743         WriteUint( aColorTableDef->iColors[i].iRgb );
   755         WriteUint( aColorTableDef->iColors[i].iRgb );
   744         }
   756         }
   778     WriteInt16( (short int)aBmpAnimDef->iInterval );
   790     WriteInt16( (short int)aBmpAnimDef->iInterval );
   779     WriteByte( (unsigned char)aBmpAnimDef->iPlayMode );
   791     WriteByte( (unsigned char)aBmpAnimDef->iPlayMode );
   780     WriteByte( (unsigned char)aBmpAnimDef->iFlash );
   792     WriteByte( (unsigned char)aBmpAnimDef->iFlash );
   781     WriteByte( (unsigned char)aBmpAnimDef->iFrames.size() );
   793     WriteByte( (unsigned char)aBmpAnimDef->iFrames.size() );
   782 
   794 
   783     for( int i=0; i<aBmpAnimDef->iFrames.size(); i++ )
   795     for( unsigned int i=0; i<aBmpAnimDef->iFrames.size(); i++ )
   784         {
   796         {
   785         AppendBytes( 2*4 + 3*2 );
   797         AppendBytes( 2*4 + 3*2 );
   786         WriteInt( aBmpAnimDef->iFrames[i].iIID.iMajor );
   798         WriteInt( aBmpAnimDef->iFrames[i].iIID.iMajor );
   787         WriteInt( aBmpAnimDef->iFrames[i].iIID.iMinor );
   799         WriteInt( aBmpAnimDef->iFrames[i].iIID.iMinor );
   788         WriteInt16( (short int)aBmpAnimDef->iFrames[i].iTime );
   800         WriteInt16( (short int)aBmpAnimDef->iFrames[i].iTime );
   812     AppendBytes( 2*4 + 1*2 );
   824     AppendBytes( 2*4 + 1*2 );
   813     WriteInt( aStringDef->iIID.iMajor );
   825     WriteInt( aStringDef->iIID.iMajor );
   814     WriteInt( aStringDef->iIID.iMinor );
   826     WriteInt( aStringDef->iIID.iMinor );
   815     WriteUint16( wcslen( aStringDef->iString ) );
   827     WriteUint16( wcslen( aStringDef->iString ) );
   816 
   828 
   817     for( int i=0; i<wcslen( aStringDef->iString ); i++ )
   829     for( unsigned int i=0; i<wcslen( aStringDef->iString ); i++ )
   818         {
   830         {
   819         AppendBytes( 2 );
   831         AppendBytes( 2 );
   820         WriteUint16( aStringDef->iString[i] );
   832         WriteUint16( aStringDef->iString[i] );
   821         }
   833         }
   822 
   834 
   857     WriteUint( 0 );             // Reserved
   869     WriteUint( 0 );             // Reserved
   858 
   870 
   859     AppendBytes( 1*2 );
   871     AppendBytes( 1*2 );
   860     WriteUint16( aItemDef->iCommands.size() );
   872     WriteUint16( aItemDef->iCommands.size() );
   861 
   873 
   862     for( int i=0; i<aItemDef->iCommands.size(); i++ )
   874     for( unsigned int i=0; i<aItemDef->iCommands.size(); i++ )
   863         {
   875         {
   864         PrepareEffectCommand( aItemDef->iCommands[i] );
   876         PrepareEffectCommand( aItemDef->iCommands[i] );
   865         }
   877         }
   866 
   878 
   867     AppendBytes( 1*1 );
   879     AppendBytes( 1*1 );
   909     AppendBytes( 1*4 );
   921     AppendBytes( 1*4 );
   910     WriteUint( aItemDef->iMinInterval );
   922     WriteUint( aItemDef->iMinInterval );
   911 
   923 
   912     AppendBytes( 1*2 );
   924     AppendBytes( 1*2 );
   913     WriteUint16( aItemDef->iPreprocessCommands.size() );
   925     WriteUint16( aItemDef->iPreprocessCommands.size() );
   914     int i;
   926     unsigned int i;
   915     for( i=0; i<aItemDef->iPreprocessCommands.size(); i++ )
   927     for( i=0; i<aItemDef->iPreprocessCommands.size(); i++ )
   916         {
   928         {
   917         PrepareEffectCommand( aItemDef->iPreprocessCommands[i] );
   929         PrepareEffectCommand( aItemDef->iPreprocessCommands[i] );
   918         }
   930         }
   919 
   931 
   965     AppendBytes( 2*4 + 1*1 );
   977     AppendBytes( 2*4 + 1*1 );
   966     WriteInt( aIID.iMajor );
   978     WriteInt( aIID.iMajor );
   967     WriteInt( aIID.iMinor );
   979     WriteInt( aIID.iMinor );
   968     WriteByte( (unsigned char)aImages.size() );
   980     WriteByte( (unsigned char)aImages.size() );
   969 
   981 
   970     for( int i=0; i<aImages.size(); i++ )
   982     for( unsigned int i=0; i<aImages.size(); i++ )
   971         {
   983         {
   972         AppendBytes( 2*4 );
   984         AppendBytes( 2*4 );
   973         WriteInt( aImages[i].iMajor );
   985         WriteInt( aImages[i].iMajor );
   974         WriteInt( aImages[i].iMinor );
   986         WriteInt( aImages[i].iMinor );
   975         }
   987         }
  1013     startPos.Back( this );
  1025     startPos.Back( this );
  1014     }
  1026     }
  1015 
  1027 
  1016 void CSDCBinOutput::PrepareParamVector( const vector<TSDCEffectParameter>& aParameters )
  1028 void CSDCBinOutput::PrepareParamVector( const vector<TSDCEffectParameter>& aParameters )
  1017     {
  1029     {
  1018     for( int i=0; i<aParameters.size(); i++ )
  1030     for( unsigned int i=0; i<aParameters.size(); i++ )
  1019         {
  1031         {
  1020         int type = aParameters[i].iType;
  1032         int type = aParameters[i].iType;
  1021 
  1033 
  1022         TPos paramPos( this );
  1034         TPos paramPos( this );
  1023 
  1035 
  1046             }
  1058             }
  1047 
  1059 
  1048         AppendBytes( 1*2 );
  1060         AppendBytes( 1*2 );
  1049         WriteUint16( wcslen(aParameters[i].iName) ); // ParamNameLen
  1061         WriteUint16( wcslen(aParameters[i].iName) ); // ParamNameLen
  1050 
  1062 
  1051         for( int b=0; b<wcslen(aParameters[i].iName); b++ )
  1063         for( unsigned int b=0; b<wcslen(aParameters[i].iName); b++ )
  1052             {
  1064             {
  1053             AppendBytes( 1*2 );
  1065             AppendBytes( 1*2 );
  1054             WriteUint16( aParameters[i].iName[b] );
  1066             WriteUint16( aParameters[i].iName[b] );
  1055             }
  1067             }
  1056 
  1068 
  1062         else if( type == 1 ) // String
  1074         else if( type == 1 ) // String
  1063             {
  1075             {
  1064             AppendBytes( 1*2 );
  1076             AppendBytes( 1*2 );
  1065             WriteUint16( wcslen(aParameters[i].iString) );
  1077             WriteUint16( wcslen(aParameters[i].iString) );
  1066 
  1078 
  1067             for( int a=0; a<wcslen(aParameters[i].iString); a++ )
  1079             for( unsigned int a=0; a<wcslen(aParameters[i].iString); a++ )
  1068                 {
  1080                 {
  1069                 AppendBytes( 1*2 );
  1081                 AppendBytes( 1*2 );
  1070                 WriteUint16( aParameters[i].iString[a] );
  1082                 WriteUint16( aParameters[i].iString[a] );
  1071                 }
  1083                 }
  1072             }
  1084             }