yb_base.cpp

简单实用, 功能强大的 C++ Builder 串口控件! 本控件是免费的, 不需要注册, 有关授权及许可协议详见 license.txt 文件。 1.支持二进制数据和文本数据的收发 2.支

/***************************************************************************\
*           yb_base.cpp -- Victor Base Classes, version 1.2.2.4             *
*---------------------------------------------------------------------------*
*                   文件、目录 (文件夹) 和日期、时间的处理                  *
*                     多语言支持 (ANSI, GB2312/GBK, BIG5)                   *
*                           Build Oct.28,2004                               *
*---------------------------------------------------------------------------*
*                   Copyright (C) 1997-2003, Victor Chen.                   *
*                     Homepage: http://www.cppfans.com/                     *
*                        email: [e-mail]                          *
\***************************************************************************/
#pragma hdrstop
//---------------------------------------------------------------------------
#ifndef NO_WIN32_LEAN_AND_MEAN
# define NO_WIN32_LEAN_AND_MEAN
#endif
//---------------------------------------------------------------------------
#include <winsock2.h>
#include "yb_base.h"
#include <shlobj.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
namespace TVictorFuncs {
//---------------------------------------------------------------------------
TStringLocale _SysLocale; //System & Default Locale, must defined before AppLang
TAppLang AppLang;         //Default Language, FontName, Charset, FontSize
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
TStringLocale::TStringLocale()
{
  InitLCID();
}
//----------------------------------------------------------------------------
TStringLocale::TStringLocale(LCID lcId)
{
  InitLCID(lcId);
}
//----------------------------------------------------------------------------
TStringLocale::TStringLocale(const TStringLocale &slc)
{
  InitLCID(slc._lcId);
  _bCaseInsensitive = slc._bCaseInsensitive; //排序是否忽略大小寫 //Case Insensitive
  _StringSortType   = slc._StringSortType;   //排序規則           //String sort sype
}
//----------------------------------------------------------------------------
void TStringLocale::InitLCID(void)
{
  LCID lcId=GetThreadLocale();
  if(!lcId){lcId=lcidEnu;}
  InitLCID(lcId);
}
//----------------------------------------------------------------------------
void TStringLocale::InitLCID(LCID lcId)
{
  _bCaseInsensitive = false;        //排序是否忽略大小寫 //Case Insensitive
  _StringSortType   = vcstPhysical; //排序規則           //String sort sype

  _lcId = lcId;
  _PriLangID = PRIMARYLANGID(_lcId);
  _SubLangID = SUBLANGID(_lcId);

  GetCodePageInfo();
  GetLcidEastern();
}
//----------------------------------------------------------------------------
void TStringLocale::GetCodePageInfo(void)
{
  _CodePage = CP_ACP;

  const BufSize=16;
  char CpBuf[BufSize];
  if(GetLocaleInfo(_lcId, LOCALE_IDEFAULTANSICODEPAGE, CpBuf, BufSize))
    _CodePage = atoi(CpBuf);
  if(!GetCPInfo(_CodePage, &_CpInfo))
    memset(&_CpInfo,0,sizeof(CPINFO));
}
//----------------------------------------------------------------------------
bool TStringLocale::IsLcidWestern(void) //西方語言
{
  return((_PriLangID==LANG_ENGLISH   )|| //英語
         (_PriLangID==LANG_DANISH    )|| //丹麥
         (_PriLangID==LANG_DUTCH     )|| //荷蘭
         (_PriLangID==LANG_FINNISH   )|| //芬蘭
         (_PriLangID==LANG_FRENCH    )|| //法語
         (_PriLangID==LANG_GERMAN    )|| //德語
         (_PriLangID==LANG_ITALIAN   )|| //意大利
         (_PriLangID==LANG_NORWEGIAN )|| //挪威
         (_PriLangID==LANG_PORTUGUESE)|| //葡萄牙
         (_PriLangID==LANG_SPANISH   )|| //西班牙
         (_PriLangID==LANG_SWEDISH   )); //瑞典
}
//----------------------------------------------------------------------------
void TStringLocale::GetLcidEastern(void)
{
  _FarEast    = false;
  _MiddleEast = false;

  if(!IsLcidWestern()) //LCID not in Western list
   {
     _FarEast = _CpInfo.LeadByte[0] || _CpInfo.LeadByte[1];
     if(!_FarEast) //test if is Middle East
      {
        //make a string for right-to-left directional language test
        const nTest = 127;
        char Buf[nTest+1];
        for(int i=0; i<nTest; i++)
          Buf[i] = i|0x80;
        Buf[nTest] = 0;

        //CT_CTYPE2: Retrieve bidirectional layout information
        unsigned short SType[nTest+1];
        if(GetStringTypeEx(_lcId, CT_CTYPE2, Buf, -1, SType))
         {
           for(int i=0; i<nTest; i++)
            {
              if(SType[i]==C2_RIGHTTOLEFT)
               {
                 _MiddleEast=true;
                 break;
               }
            }
         }
      }
   }
}
//----------------------------------------------------------------------------
bool TStringLocale::IsLeadByte(unsigned char c)
{
  for(int i=0; (i<MAX_LEADBYTES) && (_CpInfo.LeadByte[i]||_CpInfo.LeadByte[i+1]); i+=2)
   if((c>=_CpInfo.LeadByte[i]) && (c<=_CpInfo.LeadByte[i+1]))
    return true;
  return false;
}
//----------------------------------------------------------------------------
TStringLocale::TDbcsByteType TStringLocale::ByteType(const char *s, int idx)
{
  int i=0;
  TDbcsByteType t=btSingleByte;
  for(char *p=const_cast<char*>(s); *p; p++)
   {
     if(t==btLeadByte)
       t=btTrailByte;
     else if(IsLeadByte(*p))
       t=btLeadByte;
     else
       t=btSingleByte;
     if(i++==idx)return(t);
   }
  return btSingleByte;
}
//----------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------
TVictorString::TVictorString()
{
  _sbuf=NULL;
  _nBufSize=0;
  _Locale=&_SysLocale;
  Clear();
}
//----------------------------------------------------------------------------
TVictorString::TVictorString(const char *s)
{
  _sbuf=NULL;
  _nBufSize=0;
  _Locale=&_SysLocale;
  Assign(s);
}
//----------------------------------------------------------------------------
TVictorString::TVictorString(const wchar_t *ws)
{
  _sbuf=NULL;
  _nBufSize=0;
  _Locale=&_SysLocale;
  Assign(ws);
}
//----------------------------------------------------------------------------
TVictorString::TVictorString(const TVictorString &s)
{
  _sbuf=NULL;
  _nBufSize=0;
  _Locale=&_SysLocale;
  Assign(s);
}
//----------------------------------------------------------------------------
TVictorString::TVictorString(const TVictorWideString &ws)
{
  _sbuf=NULL;
  _nBufSize=0;
  _Locale=&_SysLocale;
  Assign(ws);
}
//----------------------------------------------------------------------------
TVictorString::TVictorString(const AnsiString &s)
{
  _sbuf=NULL;
  _nBufSize=0;
  _Locale=&_SysLocale;
  Assign(s.c_str());
}
//----------------------------------------------------------------------------
TVictorString::TVictorString(const WideString &ws)
{
  _sbuf=NULL;
  _nBufSize=0;
  _Locale=&_SysLocale;
  Assign(ws.c_bstr());
}
//----------------------------------------------------------------------------
TVictorString::~TVictorString()
{
  if(_sbuf)
   {
     delete[] _sbuf;
     _sbuf = NULL;
     _nBufSize=0;
   }
  SetLocale(NULL);
}
//----------------------------------------------------------------------------
void TVictorString::Clear(void)
{
  AllocBuf(1);
  _sbuf[0]=0;
}
//----------------------------------------------------------------------------
void TVictorString::AllocBuf(const int nSize)
{
  int ns=nSize>1?nSize:1;
  if(ns!=_nBufSize)
   {
     if(_sbuf)
      {
        delete[] _sbuf;
      }
     _sbuf = new char[ns];
     _nBufSize = ns;
   }
}
//----------------------------------------------------------------------------
void TVictorString::SetLocale(TStringLocale *lc)
{
  if((lc) && (lc!=&_SysLocale))
   {
     if(_Locale==&_SysLocale)
       _Locale = new TStringLocale(*lc);
     else
       _Locale->SetLangID(lc->GetLangID());
   }
  else
   {
     if(_Locale!=&_SysLocale)
      {
        delete _Locale;
        _Locale=&_SysLocale;
      }
   }
}
//----------------------------------------------------------------------------
void TVictorString::Assign(const char *s)
{
  if(s)
   {
     AllocBuf(strlen(s)+1);
     strcpy(_sbuf,s);
   }
  else
   {
     Clear();
   }
}
//----------------------------------------------------------------------------
void TVictorString::Assign(const wchar_t *ws)
{
  int BufSize = WideCharToMultiByte(_Locale->GetCodePage(),0,ws,-1,NULL,0,NULL,NULL);
  if(BufSize>0)
   {
     AllocBuf(BufSize);
     WideCharToMultiByte(_Locale->GetCodePage(),0,ws,-1,_sbuf,BufSize,NULL,NULL);
   }
  else
   {
     Clear();
   }
}
//----------------------------------------------------------------------------
void TVictorString::Assign(const TVictorString &s)
{
  SetLocale(s.Locale);
  Assign(s._sbuf);
}
//----------------------------------------------------------------------------
void TVictorString::Assign(const TVictorWideString &ws)
{
  SetLocale(ws.Locale);
  Assign(ws.c_bstr());
}
//----------------------------------------------------------------------------
TVictorString::operator AnsiString() const
{
  return AnsiString(_sbuf);
}
//----------------------------------------------------------------------------
TVictorString::operator WideString() const
{
  TVictorWideString ws(_sbuf);
  return WideString(ws.c_bstr());
}
//----------------------------------------------------------------------------
TVictorString &TVictorString::operator += (const TVictorString &s)
{
  *this = *this + s;
  return *this;
}
//----------------------------------------------------------------------------
TVictorString TVictorString::operator + (const TVictorString &s) const
{
  TVictorString v;
  v.SetLocale(Locale);
  v.AllocBuf(Length()+s.Length()+1);
  strcpy(v._sbuf,_sbuf);
  strcat(v._sbuf,s._sbuf);
  return v;
}
//----------------------------------------------------------------------------
TVictorString operator + (const char *s1, const TVictorString &s2)
{
  TVictorString v;
  v.SetLocale(s2.Locale);
  v.AllocBuf(strlen(s1)+s2.Length()+1);
  strcpy(v._sbuf,s1);
  strcat(v._sbuf,s2._sbuf);
  return v;
}
//----------------------------------------------------------------------------
int TVictorString::printf(const char *format,...)
{
  int rc;
  va_list paramList;
  va_start(paramList, format);
  rc = vprintf(format, paramList);
  va_end(paramList);
  return rc;
}
//----------------------------------------------------------------------------
TVictorString &TVictorString::sprintf(const char *format,...)
{
  va_list paramList;
  va_start(paramList, format);
  vprintf(format, paramList);
  va_end(paramList);
  return *this;
}
//----------------------------------------------------------------------------
int TVictorString::vprintf(const char* format, va_list paramList)
{
  int nSize = vsnprintf(NULL, 0, format, paramList)+1;
  AllocBuf(nSize);
  return vsnprintf(_sbuf, nSize, format, paramList);
}
//----------------------------------------------------------------------------
int TVictorString::Pos(const TVictorString &s) const
{
  int Ln = Length();
  int Sn = s.Length();

  for(int i=0; i<=Ln-Sn; i++)
   if(strncmp(_sbuf+i, s._sbuf, Sn)==0)
    return i;
  return -1;
}
//----------------------------------------------------------------------------
int TVictorString::AnsiPos(const TVictorString &s) const
{
  int Ln = Length();
  int Sn = s.Length();
  TStringLocale::TDbcsByteType t=TStringLocale::btSingleByte;

  for(int i=0; i<=Ln-Sn; i++)
   {
     if(t==TStringLocale::btLeadByte)
       t=TStringLocale::btTrailByte;
     else if(_Locale->IsLeadByte(_sbuf[i]))
       t=TStringLocale::btLeadByte;
     else
       t=TStringLocale::btSingleByte;

     if(t!=TStringLocale::btTrailByte)
      if(strncmp(_sbuf+i, s._sbuf, Sn)==0)
       return i;
   }
  return -1;
}
//----------------------------------------------------------------------------
TVictorString TVictorString::UpperCase(void) const
{
  TVictorString s(*this);
  CharUpperBuff(s._sbuf,s.Length());
  return s;
}
//----------------------------------------------------------------------------
TVictorString TVictorString::LowerCase(void) const
{
  TVictorString s(*this);
  CharLowerBuff(s._sbuf,s.Length());
  return s;
}
//----------------------------------------------------------------------------
TVictorString TVictorString::Replace(const TVictorString &from, const TVictorString &to, bool bIgnoreCase) const
{
  TVictorString s(*this),v;
  int fn=from.Length();
  if(fn>0)
   {
     if(bIgnoreCase)
      {
        TVictorString sFromUc=from.UpperCase();
        while(!s.IsEmpty())
         {
           int p = s.UpperCase().AnsiPos(sFromUc);
           if(p>=0)
            {