Пример #1
0
///////////////////////////////////////////////////////////////////////////////
// The query->m_Search is filled out when provided.
//
bool TokenizeQuery( const tstring& queryString, std::vector< tstring >& tokens )
{
    const tregex parseTokens( s_TokenizeQueryString, std::tr1::regex::icase );

    // parse once to tokenize then match again
    tsregex_iterator parseItr( queryString.begin(), queryString.end(), parseTokens );
    tsregex_iterator parseEnd;

    tstring curToken;
    for ( ; parseItr != parseEnd; ++parseItr )
    {
        const std::tr1::match_results<tstring::const_iterator>& tokenizeResults = *parseItr;
        curToken = tokenizeResults[1].matched ? Helium::MatchResultAsString( tokenizeResults, 1 ) : TXT( "" );
        if ( !curToken.empty() )
        {
            tokens.push_back( curToken );
        }
    }

    return !tokens.empty();
}
Пример #2
0
bool CRegisterMenu::UnRegister(tstring strAppName, tstring strExt, tstring strMenu)
{
  if (   strAppName.empty()
    || strExt.empty() 
    || strMenu.empty())
    return false;

  if (!UnRegisterExtKey(strExt, strMenu))
  {
    return false;
  }

  // remove '.'
  strExt.erase(std::remove(strExt.begin(), strExt.end(), _T('.')), strExt.end());

  // Uppercase extension
  CStringUtil::MakeUpper(strExt);
  tstring strAppExt = strAppName + _T(".") + strExt;

  return UnRegisterMenu(strAppExt);	
}
Пример #3
0
 bool is_fixed_width(const tstring & font_name) {
   if (font_name.length() > 31) return false;
 
   HDC dc = GetDC(NULL);
   if (!dc) WIN_EXCEPT("Failed call to GetDC(NULL).");
   
   LOGFONT lf = {};
   lf.lfCharSet = DEFAULT_CHARSET;
   lf.lfPitchAndFamily = 0;
   // already checked length
   TCHAR * ptr = std::copy(font_name.begin(), font_name.end(), lf.lfFaceName); 
   ASSERT(ptr <= (lf.lfFaceName + 32)); (void)ptr;
   
   bool is = false;
   EnumFontFamiliesEx(dc, 
                      &lf, 
                      reinterpret_cast<FONTENUMPROC>(EnumFontFamExProc), 
                      reinterpret_cast<LPARAM>(&is), 
                      0);
   
   ReleaseDC(NULL, dc);
   return is;
 }
Пример #4
0
tstring::size_type
tstring::find(char_type const* s, size_type pos, size_type n) const
{    
	if( size() == 0 ) {
		if( n == 0 )
			return 0;
		else
			return npos;
	}

	TINFRA_ASSERT(pos == npos || pos <= this->size() );

    tstring const other = tstring(s, n, false);
    const_iterator result = std::search(
        begin()+pos,
        end(),
        other.begin(),
        other.end());
    if( result == end() )
        return npos;
    else
        return result - begin(); 
}
Пример #5
0
	std::string ConvertTString(const tstring & value)
	{
		return string(value.begin(), value.end());
	}
Пример #6
0
tstring lowercase(const tstring &str) {
    tstring result = str;
    transform(str.begin(), str.end(), result.begin(), ToLower());
    return result;
}
Пример #7
0
bool dir_reader::matches(const tstring& name, const tstring& spec) {
  tstring::const_iterator name_itr = name.begin();
  tstring::const_iterator name_end = name.end();

  tstring::const_iterator spec_itr = spec.begin();
  tstring::const_iterator spec_end = spec.end();

  tstring::const_iterator last_good_spec = spec_end;
  tstring::const_iterator last_good_name = name_end;

  while (name_itr != name_end && spec_itr != spec_end) {
    switch (*spec_itr) {
      case _T('?'):
        // question mark mathes one char
        name_itr++;
        spec_itr++;
        break;

      case _T('*'):
        // double asterisk is the same as a single asterisk
        while (*spec_itr == _T('*')) {
          spec_itr++;
          // asterisk at the end of the spec matches the end of the name
          if (spec_itr == spec_end)
            return true;
        }

        // remember last good name and spec for prematurely stopped asterisk
        last_good_spec = spec_itr;
        last_good_name = name_itr;

        break;

      default:
        // Jim Park: This should work since tolower is templated with Chartype.
        if (::tolower(*name_itr) != ::tolower(*spec_itr)) {
          if (last_good_spec != spec_end) {
            // matched wrong part of the name, try again
            spec_itr = last_good_spec;
            name_itr = ++last_good_name;
          } else {
            // no match and no asterisk to use
            return false;
          }
        } else {
          // remember last good name for prematurely stopped asterisk
          last_good_name = name_itr;

          spec_itr++;
          name_itr++;

          if (spec_itr == spec_end && name_itr != name_end && last_good_spec != spec_end) {
            // asterisk hasn't matched enough, keep matching
            spec_itr = last_good_spec;
          }
        }
        break;
    }
  }

  // skip any redundant asterisks and periods at the end of the name
  while (spec_itr != spec_end) {
    if (*spec_itr != _T('.') && *spec_itr != _T('*')) {
      break;
    }
    spec_itr++;
  }

  // return true only if managed to match everything
  return name_itr == name_end && spec_itr == spec_end;
}
Пример #8
0
bool CPicture::Load(tstring sFilePathName)
{
	bool bResult = false;
	bIsIcon = false;
	lpIcons = NULL;
	//CFile PictureFile;
	//CFileException e;
	FreePictureData(); // Important - Avoid Leaks...

	// No-op if no file specified
	if (sFilePathName.empty())
		return true;

	// Load & initialize the GDI+ library if available
	HMODULE hGdiPlusLib = AtlLoadSystemLibraryUsingFullPath(_T("gdiplus.dll"));
	if (hGdiPlusLib && GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL) == Ok)
	{
		bHaveGDIPlus = true;
	}
	// Since we loaded the gdiplus.dll only to check if it's available, we
	// can safely free the library here again - GdiplusStartup() loaded it too
	// and reference counting will make sure that it stays loaded until GdiplusShutdown()
	// is called.
	FreeLibrary(hGdiPlusLib);

	// Attempt to load using GDI+ if available
	if (bHaveGDIPlus)
	{
		pBitmap = new Bitmap(sFilePathName.c_str(), FALSE);
		GUID guid;
		pBitmap->GetRawFormat(&guid);

		if (pBitmap->GetLastStatus() != Ok)
		{
			delete pBitmap;
			pBitmap = NULL;
		}

		// gdiplus only loads the first icon found in an icon file
		// so we have to handle icon files ourselves :(

		// Even though gdiplus can load icons, it can't load the new
		// icons from Vista - in Vista, the icon format changed slightly.
		// But the LoadIcon/LoadImage API still can load those icons,
		// at least those dimensions which are also used on pre-Vista
		// systems.
		// For that reason, we don't rely on gdiplus telling us if
		// the image format is "icon" or not, we also check the
		// file extension for ".ico".
		std::transform(sFilePathName.begin(), sFilePathName.end(), sFilePathName.begin(), ::tolower);
		bIsIcon = (guid == ImageFormatIcon) || (wcsstr(sFilePathName.c_str(), L".ico") != NULL) || (wcsstr(sFilePathName.c_str(), L".cur") != NULL);
		bIsTiff = (guid == ImageFormatTIFF) || (_tcsstr(sFilePathName.c_str(), _T(".tiff")) != NULL);
		m_Name = sFilePathName;

		if (bIsIcon)
		{
			// Icon file, get special treatment...
			if (pBitmap)
			{
				// Cleanup first...
				delete (pBitmap);
				pBitmap = NULL;
				bIsIcon = true;
			}

			CAutoFile hFile = CreateFile(sFilePathName.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
			if (hFile)
			{
				BY_HANDLE_FILE_INFORMATION fileinfo;
				if (GetFileInformationByHandle(hFile, &fileinfo))
				{
					lpIcons = new BYTE[fileinfo.nFileSizeLow];
					DWORD readbytes;
					if (ReadFile(hFile, lpIcons, fileinfo.nFileSizeLow, &readbytes, NULL))
					{
						// we have the icon. Now gather the information we need later
						if (readbytes >= sizeof(ICONDIR))
						{
							// we are going to open same file second time so we have to close the file now
							hFile.CloseHandle();

							LPICONDIR lpIconDir = (LPICONDIR)lpIcons;
							if ((lpIconDir->idCount) && ((lpIconDir->idCount * sizeof(ICONDIR)) <= fileinfo.nFileSizeLow))
							{
								try
								{
									bResult = false;
									nCurrentIcon = 0;
									hIcons = new HICON[lpIconDir->idCount];
									// check that the pointers point to data that we just loaded
									if (((BYTE*)lpIconDir->idEntries > (BYTE*)lpIconDir) && 
										(((BYTE*)lpIconDir->idEntries) + (lpIconDir->idCount * sizeof(ICONDIRENTRY)) < ((BYTE*)lpIconDir) + fileinfo.nFileSizeLow))
									{
										m_Width = lpIconDir->idEntries[0].bWidth;
										m_Height = lpIconDir->idEntries[0].bHeight;
										bResult = true;
										for (int i=0; i<lpIconDir->idCount; ++i)
										{
											hIcons[i] = (HICON)LoadImage(NULL, sFilePathName.c_str(), IMAGE_ICON,
																		 lpIconDir->idEntries[i].bWidth,
																		 lpIconDir->idEntries[i].bHeight,
																		 LR_LOADFROMFILE);
											if (hIcons[i] == NULL)
											{
												// if the icon couldn't be loaded, the data is most likely corrupt
												delete [] lpIcons;
												lpIcons = NULL;
												bResult = false;
												break;
											}
										}
									}
								}
								catch (...)
								{
									delete [] lpIcons;
									lpIcons = NULL;
									bResult = false;
								}
							}
							else
							{
								delete [] lpIcons;
								lpIcons = NULL;
								bResult = false;
							}
						}
						else
						{
							delete [] lpIcons;
							lpIcons = NULL;
							bResult = false;
						}
					}
					else
					{
						delete [] lpIcons;
						lpIcons = NULL;
					}
				}
			}
		}
		else if (pBitmap)	// Image loaded successfully with GDI+
		{
			m_Height = pBitmap->GetHeight();
			m_Width = pBitmap->GetWidth();
			bResult = true;
		}

		// If still failed to load the file...
		if (!bResult)
		{
			// Attempt to load the FreeImage library as an optional DLL to support additional formats

			// NOTE: Currently just loading via FreeImage & using GDI+ for drawing.
			// It might be nice to remove this dependency in the future.
			HMODULE hFreeImageLib = LoadLibrary(_T("FreeImage.dll"));

			// FreeImage DLL functions
			typedef const char* (__stdcall *FreeImage_GetVersion_t)(void);
			typedef int			(__stdcall *FreeImage_GetFileType_t)(const TCHAR *filename, int size);
			typedef int			(__stdcall *FreeImage_GetFIFFromFilename_t)(const TCHAR *filename);
			typedef void*		(__stdcall *FreeImage_Load_t)(int format, const TCHAR *filename, int flags);
			typedef void		(__stdcall *FreeImage_Unload_t)(void* dib);
			typedef int			(__stdcall *FreeImage_GetColorType_t)(void* dib);
			typedef unsigned	(__stdcall *FreeImage_GetWidth_t)(void* dib);
			typedef unsigned	(__stdcall *FreeImage_GetHeight_t)(void* dib);
			typedef void		(__stdcall *FreeImage_ConvertToRawBits_t)(BYTE *bits, void *dib, int pitch, unsigned bpp, unsigned red_mask, unsigned green_mask, unsigned blue_mask, BOOL topdown);

			//FreeImage_GetVersion_t FreeImage_GetVersion = NULL;
			FreeImage_GetFileType_t FreeImage_GetFileType = NULL;
			FreeImage_GetFIFFromFilename_t FreeImage_GetFIFFromFilename = NULL;
			FreeImage_Load_t FreeImage_Load = NULL;
			FreeImage_Unload_t FreeImage_Unload = NULL;
			//FreeImage_GetColorType_t FreeImage_GetColorType = NULL;
			FreeImage_GetWidth_t FreeImage_GetWidth = NULL;
			FreeImage_GetHeight_t FreeImage_GetHeight = NULL;
			FreeImage_ConvertToRawBits_t  FreeImage_ConvertToRawBits = NULL;

			if (hFreeImageLib)
			{
				bool exportsValid = true;

				//FreeImage_GetVersion = (FreeImage_GetVersion_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetVersion@0", valid);
				FreeImage_GetWidth = (FreeImage_GetWidth_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetWidth@4", exportsValid);
				FreeImage_GetHeight = (FreeImage_GetHeight_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetHeight@4", exportsValid);
				FreeImage_Unload = (FreeImage_Unload_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_Unload@4", exportsValid);
				FreeImage_ConvertToRawBits = (FreeImage_ConvertToRawBits_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_ConvertToRawBits@32", exportsValid);

#ifdef UNICODE
				FreeImage_GetFileType = (FreeImage_GetFileType_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetFileTypeU@8", exportsValid);
				FreeImage_GetFIFFromFilename = (FreeImage_GetFIFFromFilename_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetFIFFromFilenameU@4", exportsValid);
				FreeImage_Load = (FreeImage_Load_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_LoadU@12", exportsValid);
#else
				FreeImage_GetFileType = (FreeImage_GetFileType_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetFileType@8", exportsValid);
				FreeImage_GetFIFFromFilename = (FreeImage_GetFIFFromFilename_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_GetFIFFromFilename@4", exportsValid);
				FreeImage_Load = (FreeImage_Load_t)s_GetProcAddressEx(hFreeImageLib, "_FreeImage_Load@12", exportsValid);
#endif

				//const char* version = FreeImage_GetVersion();

				// Check the DLL is using compatible exports
				if (exportsValid)
				{
					// Derive file type from file header.
					int fileType = FreeImage_GetFileType(sFilePathName.c_str(), 0);
					if (fileType < 0)
					{
						// No file header available, attempt to parse file name for extension.
						fileType = FreeImage_GetFIFFromFilename(sFilePathName.c_str());
					}

					// If we have a valid file type
					if (fileType >= 0)
					{
						void* dib = FreeImage_Load(fileType, sFilePathName.c_str(), 0);

						if (dib)
						{
							unsigned width = FreeImage_GetWidth(dib);
							unsigned height = FreeImage_GetHeight(dib);

							// Create a GDI+ bitmap to load into...
							pBitmap = new Bitmap(width, height, PixelFormat32bppARGB);

							if (pBitmap && pBitmap->GetLastStatus() == Ok)
							{
								// Write & convert the loaded data into the GDI+ Bitmap
								Rect rect(0, 0, width, height);
								BitmapData bitmapData;
								if (pBitmap->LockBits(&rect, ImageLockModeWrite, PixelFormat32bppARGB, &bitmapData) == Ok)
								{
									FreeImage_ConvertToRawBits((BYTE*)bitmapData.Scan0, dib, bitmapData.Stride, 32, 0xff << RED_SHIFT, 0xff << GREEN_SHIFT, 0xff << BLUE_SHIFT, FALSE);

									pBitmap->UnlockBits(&bitmapData);

									m_Width = width;
									m_Height = height;
									bResult = true;
								}
								else    // Failed to lock the destination Bitmap
								{
									delete pBitmap;
									pBitmap = NULL;
								}
							}
							else    // Bitmap allocation failed
							{
								delete pBitmap;
								pBitmap = NULL;
							}

							FreeImage_Unload(dib);
							dib = NULL;
						}
					}
				}

				FreeLibrary(hFreeImageLib);
				hFreeImageLib = NULL;
			}
		}
	}
Пример #9
0
void Path::MakeNative( tstring& path )
{
    std::replace( path.begin(), path.end(), s_InternalPathSeparator, Helium::PathSeparator );
}
Пример #10
0
std::string TCharToOem(const tstring& tText)
{
  std::string result(tText.begin(), tText.end());
  ::CharToOem(tText.c_str(), &(result[0]));
  return result;
}
Пример #11
0
    StoreCertificate::StoreCertificate(
        Win32CertificateLocation certStoreLocation, 
        Win32CertificateStore certStore,
        const tstring & certName) :
            mStore(0)
    {
        std::wstring wStoreName;
        switch (certStore)
        {
        case Cs_AddressBook:            wStoreName = L"AddressBook";      break;
        case Cs_AuthRoot:               wStoreName = L"AuthRoot";         break;
        case Cs_CertificateAuthority:   wStoreName = L"CA";               break;
        case Cs_Disallowed:             wStoreName = L"Disallowed";       break;
        case Cs_My:                     wStoreName = L"MY";               break;
        case Cs_Root:                   wStoreName = L"Root";             break;
        case Cs_TrustedPeople:          wStoreName = L"TrustedPeople";    break;
        case Cs_TrustedPublisher:       wStoreName = L"TrustedPublisher"; break;
        default:
            RCF_ASSERT(0 && "Invalid certificate store value.");
        }

        DWORD dwFlags = 0;
        switch (certStoreLocation)
        {
        case Cl_CurrentUser:            dwFlags = CERT_SYSTEM_STORE_CURRENT_USER;   break;
        case Cl_LocalMachine:           dwFlags = CERT_SYSTEM_STORE_LOCAL_MACHINE;  break;
        default:
            RCF_ASSERT(0 && "Invalid certificate store location value.");
        }

        mStore = CertOpenStore(
            (LPCSTR) CERT_STORE_PROV_SYSTEM,
            X509_ASN_ENCODING,
            0,
            dwFlags,
            &wStoreName[0]);

        DWORD dwErr = GetLastError();

        RCF_VERIFY(
            mStore, 
            RCF::Exception(
                _RcfError_CryptoApiError("CertOpenStore()"), 
                dwErr, 
                RCF::RcfSubsystem_Os));

        std::wstring wCertName(certName.begin(), certName.end());

        DWORD dwFindType = CERT_FIND_SUBJECT_STR;

        PCCERT_CONTEXT pStoreCert = CertFindCertificateInStore(
            mStore, 
            X509_ASN_ENCODING, 
            0,
            dwFindType,
            wCertName.c_str(),
            NULL);

        dwErr = GetLastError();

        RCF_VERIFY(
            pStoreCert, 
            RCF::Exception(
            _RcfError_CryptoApiError("CertFindCertificateInStore()"), 
            dwErr, 
            RCF::RcfSubsystem_Os));

        mpCert = pStoreCert;
    }
Пример #12
0
bool is_number(const tstring &s)
{
    return !s.empty() && std::find_if(s.begin(),
        s.end(), [](TCHAR c) { return !_istdigit(c); }) == s.end();
}
Пример #13
0
void makeUpper(tstring& str)
{
	transform(str.begin(), str.end(), str.begin(), toupper);
}
Пример #14
0
int32 CBrainMemory::RetrieveText(int64 MeaningID,tstring& Text,bool Nest){

	int64 CurrentRoomValue,RoomType; 
    int64  CurrentID = MeaningID;

	//首先得到意义空间的信息
	if(!GetRoomInfo(MeaningID,CurrentRoomValue,RoomType))return 0;

	if(!Nest){
		//首次外部调用时检查MeaningID代表记忆是否为可读的文字信息,嵌套调用则忽略
		if(UnReadable(CurrentRoomValue))return 0;
	}

	//向上漫游,找到父空间空间的ID和逻辑明文,得记忆的形ID
    CppSQLite3Query Result = LBrainQuery("*",CurrentRoomValue,LB_CHILD_ID,CurrentID);
	if(Result.eof())return 0;
    
	CurrentID = Result.getInt64Field(0);
  	if(CurrentID == ROOT_SPACE)return 0;
	CurrentRoomValue = Result.getInt64Field(1);  //总是其他空间的空间识别ID
	
    
	//如果是字符,则可以确定所取文本应该是token
	int ch = IDToChar(CurrentRoomValue);
    if(isascii(ch)){
		TCHAR buf[100]; //暂存token,一个单词99字符应该足够了
		int p = 0;
		buf[p++] = ch;
        
		//继续向上漫游,应该全部都是字符
		for(;;){
			//根据本空间的ID和逻辑明文,找到父空间空间的ID和逻辑明文,
			CppSQLite3Query Result = LBrainQuery("*",CurrentRoomValue,LB_CHILD_ID,CurrentID);
			if(Result.eof())return 0;
			
			CurrentID = Result.getInt64Field(0);
			//如果得到的空间ID为根空间,则表示找到顶了。
			if(CurrentID == ROOT_SPACE){
				buf[p]='\0';
				_tcsrev(buf);
				
				Text = buf;
				//如果是形容词则加上引号
				if(RoomType == MEMORY_REFERENCE){
					Text.insert(Text.begin(),1,_T('\"'));
					Text+=_T('\"');
				}
				return 1;  //表示得到一个token
			}
			CurrentRoomValue = Result.getInt64Field(1);   
			
			if(p<100) buf[p++]  = IDToChar(CurrentRoomValue);
		}
	}
		
    //不是字符,则需要嵌套处理,然后根据返回值添加标点符号
	int32 n = 0;

	vector<tstring> StrList;
	for(;;){
		
		tstring s;
		n = RetrieveText(CurrentRoomValue,s,false);
		
		StrList.push_back(s);
		
		//继续向上漫游,根据本空间的ID和逻辑明文,找到父空间空间的ID和逻辑明文,
		CppSQLite3Query Result = LBrainQuery("*",CurrentRoomValue,LB_CHILD_ID,CurrentID);
		if(Result.eof())return 0;
		
		CurrentID = Result.getInt64Field(0);
		//如果得到的空间ID为根空间,则表示找到顶了。
		if(CurrentID == ROOT_SPACE)break;
		
		CurrentRoomValue = Result.getInt64Field(1);   		
	}

	TCHAR flag=_T(' ');
	if(n==1){ //子句,token之间应该有空格
			flag  = _T(' ');
	}
	else if(n==2){ //句子,子句之间有逗号
			flag = _T(',');
	}
	else if(n ==3){ //段落,句子之间有句号
			flag = _T('.');
	} 
    else if(n== 4){//文本,段落之间要分行
            flag = _T('\n');			
	}
	assert(n<5);
	

	vector<tstring>::reverse_iterator It = StrList.rbegin();
	while(It != StrList.rend()){
		Text += *It;
		if(Text.size()){ 
			TCHAR& ch =  Text[Text.size()-1];
            if(!ispunct(ch)){
				Text += flag;
			}else if(Text.size()>2) {
				ch = Text[Text.size()-2];
				if (isspace(ch))
				{
					Text.erase(Text.size()-2,1);
				}
			}
		}
		It++;
	}	     
	
	if(RoomType == MEMORY_REFERENCE)
	{
		Text.insert(Text.begin(),1,_T('\"'));
		Text+='\"';
		assert(n==1 || n==0); //引用被看作是一个token,应该只出现在子句里
	    return 1;
	}
	return  ++n;
} 
Пример #15
0
void ChatCtrl::FormatEmoticonsAndLinks(tstring& sMsg, tstring& sMsgLower, LONG lSelBegin, bool bUseEmo) {
	if(!sMsg.size())
		return;
	LONG lSelEnd = lSelBegin + sMsg.size();

	// hightlight all URLs and make them clickable
	for(size_t i = 0; i < (sizeof(protocols) / sizeof(protocols[0])); ++i) {
		size_t linkStart = sMsgLower.find(protocols[i]);
		bool isMagnet = (protocols[i] == _T("magnet:?"));
		while(linkStart != tstring::npos) {
			size_t linkEnd = linkStart + protocols[i].size();
			
			try {
				// TODO: complete regexp for URLs
				std::tr1::wregex reg;
//[+]PPA Исправил регулярное выражение для коррктного поиска урлов в VC++ 2010 (пример урла - magnet:?xt=urn:tree:tiger:V3LVT4CSASPLNHRG6DOORAD2SDSBBANIKEI7XHI&xl=260524251&dn=cstrike_full_v.35_(4156).exe  )
				if(isMagnet) // magnet links have totally indifferent structure than classic URL // -/?%&=~#'\\w\\.\\+\\*\\(\\)
					reg.assign(_T("^(\\w)+=[:\\w]+(&(\\w)+=[\\S]*)*[^\\s<>{}\"']+"), std::tr1::regex_constants::icase);
				else
					reg.assign(_T("^([@\\w-]+(\\.)*)+(:[\\d]+)?(/[\\S]*)*[^\\s<>{}\"']+"), std::tr1::regex_constants::icase);
					
				tstring::const_iterator start = sMsg.begin();
				tstring::const_iterator end = sMsg.end();
				std::tr1::match_results<tstring::const_iterator> result;

				if(std::tr1::regex_search(start + linkEnd, end, result, reg, std::tr1::regex_constants::match_default)) {
					dcassert(!result.empty());
					
					 linkEnd += result.length(0);
					 SetSel(lSelBegin + linkStart, lSelBegin + linkEnd);
					if(isMagnet) {
						tstring cURL = ((tstring)(result[0]));
						tstring::size_type dn = cURL.find(_T("dn="));
						if(dn != tstring::npos) {
							string sFileName = Util::encodeURI(Text::fromT(cURL).substr(dn + 3), true);
							int64_t filesize = Util::toInt64(Text::fromT(cURL.substr(cURL.find(_T("xl=")) + 3, cURL.find(_T("&")) - cURL.find(_T("xl=")))));
							tstring shortLink = Text::toT(sFileName) + _T(" (") + Util::formatBytesW(filesize) + _T(")");

							sMsg.replace(linkStart, linkEnd - linkStart, shortLink.c_str());
							std::transform(&sMsgLower.replace(linkStart, linkEnd - linkStart, shortLink.c_str())[linkStart], &sMsgLower[linkEnd], &sMsgLower[linkStart], _totlower);

							setText(shortLink);
							linkEnd = linkStart + shortLink.size();
							SetSel(lSelBegin + linkStart, lSelBegin + linkEnd);
							magnets[shortLink] = _T("magnet:?") + cURL;
					}
				}
					SetSelectionCharFormat(WinUtil::m_TextStyleURL);
				}
			} catch(...) {
			}
			
			linkStart = sMsgLower.find(protocols[i], linkEnd);			
		}
	}

	// insert emoticons
	if(bUseEmo && emoticonsManager->getUseEmoticons()) {
		const Emoticon::List& emoticonsList = emoticonsManager->getEmoticonsList();
		tstring::size_type lastReplace = 0;
		uint8_t smiles = 0;

		while(true) {
			tstring::size_type curReplace = tstring::npos;
			Emoticon* foundEmoticon = NULL;

			for(Emoticon::Iter emoticon = emoticonsList.begin(); emoticon != emoticonsList.end(); ++emoticon) {
				tstring::size_type idxFound = sMsg.find((*emoticon)->getEmoticonText(), lastReplace);
				if(idxFound < curReplace || curReplace == tstring::npos) {
					curReplace = idxFound;
					foundEmoticon = (*emoticon);
				}
			}

			if(curReplace != tstring::npos && smiles < MAX_EMOTICONS) {
				CHARFORMAT2 cfSel;
				cfSel.cbSize = sizeof(cfSel);

				lSelBegin += (curReplace - lastReplace);
				lSelEnd = lSelBegin + foundEmoticon->getEmoticonText().size();
				SetSel(lSelBegin, lSelEnd);

				GetSelectionCharFormat(cfSel);
				if(!(cfSel.dwEffects & CFE_LINK)) {
					CImageDataObject::InsertBitmap(GetOleInterface(), foundEmoticon->getEmoticonBmp(cfSel.crBackColor));

					++smiles;
					++lSelBegin;
				} else lSelBegin = lSelEnd;
				lastReplace = curReplace + foundEmoticon->getEmoticonText().size();
			} else break;
		}
	}

}
Пример #16
0
bool tryParseDateTime(const tstring& value, CDateTime& datetime, tstring& offset)
{
	if (value.size() != 25)
		return false;

	tstring::const_iterator it = value.begin();
	tstring::const_iterator end = value.end();

	size_t digits = 8 + 6; // Date + Time digits.

	while ( (digits != 0) && (it != end) )
	{
		if (!isdigit(*it))
			return false;

		--digits;
		++it;
	}

	if (*it != '.')
		return false;
	else
		++it;

	digits = 6; // Time fraction digits.

	while ( (digits != 0) && (it != end) )
	{
		if (!isdigit(*it))
			return false;

		--digits;
		++it;
	}

	if ( (*it != '+') && (*it != '-') )
		return false;
	else
		++it;

	digits = 3; // Time-zone offset digits.

	while ( (digits != 0) && (it != end) )
	{
		if (!isdigit(*it))
			return false;

		--digits;
		++it;
	}

	const int year       = Core::parse<int>(value.substr( 0, 4));
	const int month      = Core::parse<int>(value.substr( 4, 2));
	const int day        = Core::parse<int>(value.substr( 6, 2));
	const int hours      = Core::parse<int>(value.substr( 8, 2));
	const int minutes    = Core::parse<int>(value.substr(10, 2));
	const int seconds    = Core::parse<int>(value.substr(12, 2));

	if ((year < CDate::MIN_YEAR) || (year > CDate::MAX_YEAR))
		return false;

	if ((month < CDate::MIN_MONTH) || (month > CDate::MAX_MONTH))
		return false;

	if ((day < CDate::MIN_DAY) || (day > CDate::MAX_DAY))
		return false;

	if ((hours < CTime::MIN_HOURS) || (hours > CTime::MAX_HOURS))
		return false;

	if ((minutes < CTime::MIN_MINS) || (minutes > CTime::MAX_MINS))
		return false;

	if ((seconds < CTime::MIN_SECS) || (seconds > CTime::MAX_SECS))
		return false;

	datetime = CDateTime(day, month, year, hours, minutes, seconds);
	offset   = value.substr(21, 4);

	return true;
}
Пример #17
0
	bool Parse(const IQuotesProvider* pProvider, const tstring& rsFrmt, MCONTACT hContact)
	{
		m_abValueFlags[0] = false;
		m_abValueFlags[1] = false;
		m_nComparison = NonValid;
		bool bValid = true;
		int nCurValue = 0;
		for (tstring::const_iterator i = rsFrmt.begin(); i != rsFrmt.end() && bValid && nCurValue < NumValues;) {
			TCHAR chr = *i;
			switch (chr) {
			default:
				if (false == std::isspace(chr))
					bValid = false;
				else 
					++i;
				break;

			case _T('%'):
				++i;
				if (i != rsFrmt.end()) {
					TCHAR t = *i;
					++i;
					CQuotesProviderVisitorTendency visitor(hContact, t);
					pProvider->Accept(visitor);
					if (false == visitor.IsValid()) {
						bValid = false;
					}
					else {
						double d = visitor.GetResult();
						m_adValues[nCurValue] = d;
						m_abValueFlags[nCurValue] = true;
						++nCurValue;
					}
				}
				else bValid = false;
				break;
			case _T('>'):
				m_nComparison = Greater;
				++i;
				break;
			case _T('<'):
				m_nComparison = Less;
				++i;
				break;
			case _T('='):
				switch (m_nComparison) {
				default:
					bValid = false;
					break;
				case NonValid:
					m_nComparison = Equal;
					break;
				case Greater:
					m_nComparison = GreaterOrEqual;
					break;
				case Less:
					m_nComparison = LessOrEqual;
					break;
				}
				++i;
				break;
			}
		}

		return (bValid && IsValid());
	}
Пример #18
0
void Path::Normalize( tstring& path )
{
    toLower( path );
    std::replace( path.begin(), path.end(), Helium::PathSeparator, s_InternalPathSeparator );
}
string ConvertToString(const tstring& str)
{
	return string(str.begin(), str.end());
}
Пример #20
0
std::string T2C(const tstring& text)
{
  return std::string(text.begin(), text.end());
}