brew_lib.txt

自己开发的brew 程序库

 for ( int i=0; i<len; i++ )
 {
  if ( ( numBuf[i] < '0' ) || ( numBuf[i] > '9' ) )
  {
   return 0;
  }
 }
 return ATOI( (char*)numBuf );
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
void CApp::AppendWChar( AECHAR* psz, AECHAR c )
{
 int len = WSTRLEN( psz );
 psz[len] = c;
 psz[len+1] = '\0';
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
uint32 CApp::loadStringFromResource( AECHAR** ppsz, uint16 nResID )
{
 uint32 size = 0;

 if(*ppsz == NULL)
 {
  ISHELL_GetResSize( m_pIShell, CULD_BS_RES_FILE, nResID, RESTYPE_STRING, &size );
  *ppsz = (AECHAR*)MALLOC(size * sizeof(AECHAR));
  if(*ppsz != NULL)
  {
   ISHELL_LoadResString(m_pIShell,CULD_BS_RES_FILE,nResID,*ppsz,size * sizeof(AECHAR));
  }
 }

 return size;
}
/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : STREAM
* RETURN        : 
*******************************************************************************************************************************************/
AECHAR* CApp::ReadUTF( uint8** pdis )
{
 int utflen = ((*pdis)[0] << 8) | (*pdis)[1];
 (*pdis) += 2;

    AECHAR* str = new AECHAR[utflen]; 
 str[0] = '\0';
    uint8* bytearr = new uint8[utflen];
    uint32 c, char2, char3;
 int count = 0;

 MEMMOVE( bytearr, (*pdis), utflen );
 (*pdis) += utflen;

 while (count < utflen) 
 {
      c = bytearr[count];
  switch (c >> 4) 
  {
   case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
    /* 0xxxxxxx*/
    count++;
    //str.append((char)c);
    CApp::AppendWChar( str, (AECHAR)c );
    break;
   case 12: case 13:
    /* 110x xxxx   10xx xxxx*/
    count += 2;
    if (count > utflen)
     goto READ_UTF_END;
    char2 = bytearr[count-1];
    if ((char2 & 0xC0) != 0x80)
     goto READ_UTF_END; 
    //str.append((char)(((c & 0x1F) << 6) | (char2 & 0x3F)));
    CApp::AppendWChar( str, (AECHAR)(((c & 0x1F) << 6) | (char2 & 0x3F)) );
    break;
   case 14:
    /* 1110 xxxx  10xx xxxx  10xx xxxx */
    count += 3;
    if (count > utflen)
     goto READ_UTF_END;
    char2 = bytearr[count-2];
    char3 = bytearr[count-1];
    if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80))
     goto READ_UTF_END;   
    //str.append((char)(((c & 0x0F) << 12) | ((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0)));
    CApp::AppendWChar( str, (AECHAR)(((c & 0x0F) << 12) | ((char2 & 0x3F) << 6)  | ((char3 & 0x3F) << 0)) );
    break;
   default:
    /* 10xx xxxx,  1111 xxxx */
    goto READ_UTF_END;   
  }
 }

READ_UTF_END:
    // The number of chars produced may be less than utflen
 AECHAR* ret = NULL;
 int strLen = WSTRLEN( str );
 if ( strLen <= 0 )
 {
  ret = NULL;
 }
 else
 {
  ret = new AECHAR[strLen];
  WSTRCPY( ret, str );
 }
 if ( str )
 {
  delete[] str;
  str = NULL;
 }
 if ( bytearr )
 {
  delete[] bytearr;
  bytearr = NULL;
 }
 return ret;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
int CApp::WriteUTF( uint8** pdos, AECHAR* psz )
{
 int i;
 int strlen = WSTRLEN(psz);
 int utflen = 0;
 int c, count = 0;
 
 for ( i = 0; i < strlen; i++) 
 {
     c = psz[i];
     if ((c >= 0x0001) && (c <= 0x007F)) 
  {
   utflen++;
     } 
  else if (c > 0x07FF) 
  {
   utflen += 3;
     } 
  else 
  {
   utflen += 2;
     }
 }

 if (utflen > 65535)
     return 0;

 (*pdos)[0] = (uint8)(((uint32)utflen) >> 8);
 (*pdos)[1] = (uint8)utflen;
 (*pdos) += 2;
 for ( i = 0; i < strlen; i++) 
 {
     c = psz[i];
     if ((c >= 0x0001) && (c <= 0x007F)) 
  {
   (*pdos)[0] = (byte) c;
   (*pdos) += 1;
     } 
  else if (c > 0x07FF) 
  {
   (*pdos)[0] = (uint8) (0xE0 | ((c >> 12) & 0x0F));
   (*pdos)[1] = (uint8) (0x80 | ((c >>  6) & 0x3F));
   (*pdos)[2] = (uint8) (0x80 | ((c >>  0) & 0x3F));
   (*pdos) += 3;
     } 
  else 
  {
   (*pdos)[0] = (uint8) (0xC0 | ((c >>  6) & 0x1F));
   (*pdos)[1] = (uint8) (0x80 | ((c >>  0) & 0x3F));
   (*pdos) += 2;
     }
 }
 return utflen + 2;
}

 /*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
int CApp::ReadInt( uint8** pdis )
{
 int ret = ((*pdis)[0] << 24) | ((*pdis)[1] << 16) | ((*pdis)[2] << 8) | (*pdis)[3];
 (*pdis) += 4;
 return ret;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
void CApp::WriteInt( uint8** pdos, int n )
{
 (*pdos)[0] = (uint8)(((uint32)n) >> 24);
 (*pdos)[1] = (uint8)(((uint32)n) >> 16);
 (*pdos)[2] = (uint8)(((uint32)n) >> 8);
 (*pdos)[3] = (uint8)n;
 (*pdos) += 4;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
short CApp::ReadShort( uint8** pdis )
{
 short ret = ((*pdis)[0] << 8) | (*pdis)[1];
 (*pdis) += 2;
 return ret;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
void CApp::WriteShort ( uint8** pdos, short n )
{
 (*pdos)[0] = (uint8)(((uint16)n) >> 8);
 (*pdos)[1] = (uint8)n;
 (*pdos) += 2;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
byte CApp::ReadByte( uint8** pdis )
{
 byte ret = (*pdis)[0];
 (*pdis) += 1;
 return ret;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
void CApp::WriteByte( uint8** pdos, byte n )
{
 (*pdos)[0] = (uint8)n;
 (*pdos) += 1;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
void CApp::Read( uint8** pdis, uint8* pDst, int ofs, int len )
{
 MEMMOVE( pDst+ofs, *pdis, len );
 (*pdis) += len;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
void CApp::Write( uint8** pdos, uint8* pSrc, int ofs, int len )
{
 MEMMOVE( *pdos, pSrc+ofs, len );
 (*pdos) += len;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : Random
* RETURN        : 
*******************************************************************************************************************************************/
int CApp::GetRand2( int max )
{
 int r;
 GETRAND( (byte*)&r, 4 );
 r &= 0x7fffffff;
 r %= max;

 return r;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
int CApp::GetRandInt()
{
 int r;
 GETRAND( (byte*)&r, 4 );
 return r;
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : 
* RETURN        : 
*******************************************************************************************************************************************/
int CApp::GetRand2( int min, int max )
{
 if( min < max ) {
  int r;
  GETRAND( (byte*)&r, 4 );
  r &= 0x7fffffff;
        return ( r % ( max - min ) + min  );
    } else {
        return min;
    }
}

/*******************************************************************************************************************************************
* FUNCTION      : 
* DESCRIPTION   : IMAGE
* RETURN        : 
*******************************************************************************************************************************************/
IBitmap* CApp::getBitmap( IImage* pIImg )
{
 IBitmap* ret = NULL;
 IBitmap* pDes = NULL;
 AEEImageInfo imginfo;