コード例 #1
0
int CDBCommandBuilderBase::GenerateSqlInsert(const IDBRecord& rec, tstring& buffer)
{
	buffer.append(TEXT("INSERT INTO "));
	WrapperIdentifier(TableSchema_->DBName.c_str(), buffer);

	buffer.append(TEXT(" ("));

	for (int i = 0; i < TableSchema_->Columns.size(); ++i)
	{
		WrapperIdentifier(TableSchema_->Columns[i].DBName.c_str(), buffer);
		buffer.append(TEXT(", "));
	}
	
	*(buffer.end() - 2) = ')';
	buffer.append(TEXT("VALUES ("));

	for (int i = 0; i < TableSchema_->Columns.size(); ++i)
	{
		WrapperValue(rec.GetField(i).c_str(), TableSchema_->Columns[i].DBType, buffer);
		buffer.append(TEXT(", "));
	}

	*(buffer.end() - 2) = ')';

	return 1;
}
コード例 #2
0
tstring format_rate(const IQuotesProvider *pProvider, MCONTACT hContact, const tstring &rsFrmt)
{
	tstring sResult;

	for (tstring::const_iterator i = rsFrmt.begin(); i != rsFrmt.end();) {
		TCHAR chr = *i;
		switch (chr) {
		default:
			sResult += chr;
			++i;
			break;
		
		case _T('\\'):
			++i;
			if (i != rsFrmt.end()) {
				TCHAR t = *i;
				switch (t) {
					case _T('%'):  sResult += _T("%"); break;
					case _T('t'):  sResult += _T("\t"); break;
					case _T('n'):  sResult += _T("\n"); break;
					case _T('\\'): sResult += _T("\\"); break;
					default:       sResult += chr; sResult += t; break;
				}
				++i;
			}
			else sResult += chr;
			break;

		case _T('%'):
			++i;
			if (i != rsFrmt.end()) {
				chr = *i;

				byte nWidth = 0;
				if (::isdigit(chr)) {
					nWidth = chr - 0x30;
					++i;
					if (i == rsFrmt.end()) {
						sResult += chr;
						break;
					}
					else chr = *i;
				}

				CQuotesProviderVisitorFormater visitor(hContact, chr, nWidth);
				pProvider->Accept(visitor);
				const tstring& s = visitor.GetResult();
				sResult += s;
				++i;
			}
			else sResult += chr;
			break;
		}
	}

	return sResult;
}
コード例 #3
0
ファイル: Parser.cpp プロジェクト: jcshaw/namedfolders
tstring nf::Parser::ExtractPrefix(tstring const &CommandString)
{
//можем обойтись без регулярного выражения
	if (CommandString.empty()) return _T("");

	tstring::const_iterator p = std::find(++CommandString.begin(), CommandString.end(), _T(':'));
	if (p == CommandString.end()) return _T("");

	return tstring(CommandString.begin(), p + 1);
}
コード例 #4
0
ファイル: gdemu_system_windows.cpp プロジェクト: Godzil/gdemu
std::wstring SystemWindowsClass::ToWString(const tstring &s)
#endif
{
#ifdef _UNICODE
	string
#else
	wstring
#endif
    result(s.begin(), s.end());
  // copy from one to another
  result.assign(s.begin(), s.end());
	return result;
}
コード例 #5
0
ファイル: ChatCtrl.cpp プロジェクト: Dimetro83/DC_DDD
void ChatCtrl::FormatChatLine(const tstring& sMyNick, tstring& sText, CHARFORMAT2& cf, bool isMyMessage, const tstring& sAuthor, LONG lSelBegin, bool bUseEmo) {
	// Set text format
	tstring sMsgLower(sText.length(), NULL);
	std::transform(sText.begin(), sText.end(), sMsgLower.begin(), _totlower);

	LONG lSelEnd = lSelBegin + sText.size();
	SetSel(lSelBegin, lSelEnd);
	SetSelectionCharFormat(isMyMessage ? WinUtil::m_ChatTextMyOwn : cf);
	
	// highlight all occurences of my nick
	long lMyNickStart = -1, lMyNickEnd = -1;
	size_t lSearchFrom = 0;	
	tstring sNick(sMyNick.length(), NULL);
	std::transform(sMyNick.begin(), sMyNick.end(), sNick.begin(), _totlower);

	bool found = false;
	while((lMyNickStart = sMsgLower.find(sNick, lSearchFrom)) != tstring::npos) {
		lMyNickEnd = lMyNickStart + (long)sNick.size();
		SetSel(lSelBegin + lMyNickStart, lSelBegin + lMyNickEnd);
		SetSelectionCharFormat(WinUtil::m_TextStyleMyNick);
		lSearchFrom = lMyNickEnd;
		found = true;
	}
	
	if(found) {
		if(	!SETTING(CHATNAMEFILE).empty() && !BOOLSETTING(SOUNDS_DISABLED) &&
			!sAuthor.empty() && (stricmp(sAuthor.c_str(), sNick) != 0)) {
				::PlaySound(Text::toT(SETTING(CHATNAMEFILE)).c_str(), NULL, SND_FILENAME | SND_ASYNC);	 	
        }	
	}

	// highlight all occurences of favourite users' nicks
	FavoriteManager::FavoriteMap ul = FavoriteManager::getInstance()->getFavoriteUsers();
	for(FavoriteManager::FavoriteMap::const_iterator i = ul.begin(); i != ul.end(); ++i) {
		const FavoriteUser& pUser = i->second;

		lSearchFrom = 0;
		sNick = Text::toT(pUser.getNick());
		std::transform(sNick.begin(), sNick.end(), sNick.begin(), _totlower);

		while((lMyNickStart = sMsgLower.find(sNick, lSearchFrom)) != tstring::npos) {
			lMyNickEnd = lMyNickStart + (long)sNick.size();
			SetSel(lSelBegin + lMyNickStart, lSelBegin + lMyNickEnd);
			SetSelectionCharFormat(WinUtil::m_TextStyleFavUsers);
			lSearchFrom = lMyNickEnd;
		}
	}

	// Links and smilies
	FormatEmoticonsAndLinks(sText, sMsgLower, lSelBegin, bUseEmo);
}
コード例 #6
0
ファイル: XmlTreeView.cpp プロジェクト: chrisoldwood/XMLEdit
void XmlTreeView::PostProcessSummary(tstring& str)
{
	// Replace empty strings.
	if (str.empty())
	{
		str = TXT("(empty)");
		return;
	}

	bool bWhitespaceOnly = true;

	// Find if only whitespace characters.
	for (tstring::const_iterator it = str.begin(); ((it != str.end()) && bWhitespaceOnly); ++it)
	{
		if (!tisspace(static_cast<utchar>(*it)))
			bWhitespaceOnly = false;
	}

	// Replace "invisible" strings.
	if (bWhitespaceOnly)
	{
		str = TXT("(whitespace)");
		return;
	}

	// Trim string.
	if (str.length() > App.m_nDefMaxItemLen)
	{
		str.erase(App.m_nDefMaxItemLen, str.length()-App.m_nDefMaxItemLen);

		str += TXT("...");
	}
}
コード例 #7
0
ファイル: EditorLoader.cpp プロジェクト: BillyKim/jello-man
void EditorLoader::SaveLevel(const tstring& fileName)
{
	if (fileName != _T(""))
	{
		string s(fileName.begin(), fileName.end());

		m_pLevel->Serialize(s);
	}
}
コード例 #8
0
ファイル: registermenu.cpp プロジェクト: envi/imagepitcher
// HKEY_CLASSES_ROOT
//    FileMarker.AVI - AVI - Windows 기본 비디오 파일
//       shell
// 	       Mark - Daum 팟플레이어의 재생목록(&I)에 추가하기
// 		    command - "C:\Program Files (x86)\DAUM\PotPlayer\PotPlayer.exe" "%1" /ADD
bool CRegisterMenu::Register(const tstring& strAppName, tstring strExt, 
                             tstring strMenu, tstring strMenuDisplay, 
                             tstring strCommand, tstring strDesc)
{
  if (strAppName.empty() || strExt.empty() || strDesc.empty() || 
      strMenu.empty() || strMenuDisplay.empty() || strCommand.empty())
    return false;

  if (!RegisterExtKey(strExt, strMenu, strMenuDisplay, strCommand))
    return false;

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

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

  LPCTSTR strSubKeys[] = { strAppExt.c_str(), 
                           _T("shell"), 
                           strMenu.c_str(), 
                           _T("command") };

  LPCTSTR strValues[] = { strDesc.c_str(),
                          _T(""),
                          strMenuDisplay.c_str(),
                          strCommand.c_str() };

  tstring strSubKey;
  tstring strValue;
  for (int i = 0; i < _countof(strSubKeys); ++i)
  {
    strSubKey += strSubKeys[i];
    strSubKey += _T("\\");
    strValue = strValues[i];

    if (!RegisterMenu(strSubKey, strValue))
      return false;
  }

//	SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_FLUSH, NULL, NULL);

  return true;
}
コード例 #9
0
void
TLvColumn::SetText(const tstring& text)
{
  if (!IsRepresentable<int>(text.size() + 1))
    throw TXOwl(_T("TLvColumn::SetText: The text argument is too large (>INT_MAX)"));

  Buffer.assign(text.begin(), text.end());
  Buffer.push_back(_T('\0'));
  SetTextBuffer(&Buffer[0], static_cast<int>(Buffer.size()));
}
コード例 #10
0
ファイル: settings.cpp プロジェクト: chiptuneXT/OpenMyTank
std::string GetDefaultLanguage()
{
  static std::string language;
  if (language.empty())
  {
    const tstring tLanguage = GetString(IDS_LANGUAGE);
    language.assign(tLanguage.begin(), tLanguage.end());
  }
  return language;
}
コード例 #11
0
ファイル: registermenu.cpp プロジェクト: envi/imagepitcher
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);	
}
コード例 #12
0
void litehtml::css_length::fromString( const tstring& str, const tstring& predefs, int defValue )
{
	// TODO: Make support for calc
	if(str.substr(0, 4) == _t("calc"))
	{
		m_is_predefined = true;
		m_predef		= 0;
		return;
	}

	int predef = value_index(str.c_str(), predefs.c_str(), -1);
	if(predef >= 0)
	{
		m_is_predefined = true;
		m_predef		= predef;
	} else
	{
		m_is_predefined = false;

		tstring num;
		tstring un;
		bool is_unit = false;
		for(tstring::const_iterator chr = str.begin(); chr != str.end(); chr++)
		{
			if(!is_unit)
			{
				if(t_isdigit(*chr) || *chr == _t('.') || *chr == _t('+') || *chr == _t('-'))
				{
					num += *chr;
				} else
				{
					is_unit = true;
				}
			}
			if(is_unit)
			{
				un += *chr;
			}
		}
		if(!num.empty())
		{
			m_value = (float) t_strtod(num.c_str(), 0);
			m_units	= (css_units) value_index(un.c_str(), css_units_strings, css_units_none);
		} else
		{
			// not a number so it is predefined
			m_is_predefined = true;
			m_predef = defValue;
		}
	}
}
コード例 #13
0
ファイル: SystemFrame.cpp プロジェクト: jameskumar/airgit
void SystemFrame::Colorize(const tstring& line, LONG Begin){

	tstring::const_iterator start = line.begin();
	tstring::const_iterator end = line.end();
	boost::match_results<tstring::const_iterator> result;
	int pos=0;

	while(boost::regex_search(start, end, result, reg, boost::match_default)) {
		ctrlPad.SetSel(pos + Begin + result.position(), pos + Begin + result.position() + result.length());
		ctrlPad.SetSelectionCharFormat(WinUtil::m_ChatTextServer);
		start = result[0].second;
		pos=pos+result.position() + result.length();
	}
}
コード例 #14
0
ファイル: ChatCtrl.cpp プロジェクト: Dimetro83/DC_DDD
string ChatCtrl::escapeUnicode(tstring str) {
	TCHAR buf[8];
	memzero(buf, sizeof(buf));

	int dist = 0;
	tstring::iterator i;
	while((i = std::find_if(str.begin() + dist, str.end(), std::bind2nd(std::greater<TCHAR>(), 0x7f))) != str.end()) {
		dist = (i+1) - str.begin(); // Random Acess iterators FTW
		snwprintf(buf, sizeof(buf), _T("%hd"), int(*i));
		str.replace(i, i+1, _T("\\ud\\u") + tstring(buf) + _T("?"));
		memzero(buf, sizeof(buf));
	}
	return Text::fromT(str);
}
コード例 #15
0
void CDBCommandBuilderBase::GenerateConditionStr(const IDBRecord& rec, const CDBRecordComparison& cmp, tstring& buffer)
{
	if(cmp.KeyFields().size() > 0)
	{
		buffer.append(TEXT(" WHERE "));

		for (int i = 0; i < cmp.KeyFields().size(); ++i)
		{					
			int field = cmp.KeyFields()[i];
			GenerateFieldConditionStr((*TableSchema_)[field], rec.GetField(field), buffer);
			buffer.append(TEXT(" AND "));
		}

		*(buffer.end() - 4) = '\0';
	}
}
コード例 #16
0
int CDBCommandBuilderBase::GenerateSqlUpdate(const IDBRecord& ori, const IDBRecord& cur, const CDBRecordComparison& cmp, tstring& buffer)
{
	buffer.append(TEXT("UPDATE "));
	WrapperIdentifier(TableSchema_->DBName.c_str(), buffer);
	buffer.append(TEXT(" SET "));

	for (int i = 0; i < TableSchema_->Columns.size(); ++i)
	{
		GenerateFieldAssignmentStr(TableSchema_->Columns[i], cur.GetField(i), buffer);
		buffer.append(TEXT(", "));
	}

	*(buffer.end() - 2) = ' ';
	GenerateConditionStr(ori, cmp, buffer);

	return 1;
}
コード例 #17
0
        void texture_from_file(ID3D11Device* device, tstring filename, ID3D11ShaderResourceView** srv)
        {
            std::replace(filename.begin(), filename.end(), L'\\', L'/');

            bool is_dds = filename.find(L".dds") != std::string::npos;

            try
            {
                if (!is_dds)
                    stb_to_srv(device, to_string(filename).c_str(), srv);
                else
                    dds_to_srv(device, filename, srv);

                tclog << L"Loading: " << filename << print_log_info(*srv) << std::endl;
            }
            catch (std::exception& e)
            {
                tcout << L"Failed to load: " << filename << std::endl;
                tcout << e.what() << std::endl;
            }
        }
コード例 #18
0
ファイル: VaultSearchQuery.cpp プロジェクト: euler0/Helium
///////////////////////////////////////////////////////////////////////////////
// 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();
}
コード例 #19
0
ファイル: registrytool.cpp プロジェクト: louk78/GetSystemInfo
BOOL CRegistryTool::StringToRootKey(tstring strKey,HKEY *hKey)
{
	BOOL bSucceed = FALSE;

	transform(strKey.begin(),strKey.end(),strKey.begin(),_totupper);
	if(strKey.compare(_T("HKEY_CLASSES_ROOT"))==0)
	{
		*hKey = HKEY_CLASSES_ROOT;
		bSucceed = TRUE;
	}
	else if(strKey.compare(_T("HKEY_CURRENT_CONFIG"))==0)
	{
		*hKey = HKEY_CURRENT_CONFIG;
		bSucceed = TRUE;
	}
	else if(strKey.compare(_T("HKEY_CURRENT_USER"))==0)
	{
		*hKey = HKEY_CURRENT_USER;
		bSucceed = TRUE;
	}
	else if(strKey.compare(_T("HKEY_LOCAL_MACHINE"))==0)
	{
		*hKey = HKEY_LOCAL_MACHINE;
		bSucceed = TRUE;
	}
	else if(strKey.compare(_T("HKEY_PERFORMANCE_DATA")) ==0)
	{
		*hKey = HKEY_PERFORMANCE_DATA;
		bSucceed = TRUE;
	}
	else if(strKey.compare(_T("HKEY_USERS")) == 0)
	{
		*hKey = HKEY_USERS;
		bSucceed = TRUE;
	}

	return bSucceed;
}
コード例 #20
0
ファイル: font_util.cpp プロジェクト: HowardJeng/conrep
 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;
 }
コード例 #21
0
ファイル: tstring.cpp プロジェクト: icasimpan/tinfra
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(); 
}
コード例 #22
0
ファイル: tstring.cpp プロジェクト: icasimpan/tinfra
tstring::size_type
tstring_find_last(tstring const& subject, Predicate p, size_t pos)
{
	const size_t npos = tstring::npos;

	if( subject.size() == 0 ) 
		return npos;

	if( pos != npos && pos > subject.size() )
		pos = subject.size()-1;

	TINFRA_ASSERT(pos == npos || pos < subject.size() );

	const  tstring::const_iterator begin = subject.begin();
	tstring::const_iterator i = 
			(pos == npos) ? subject.end()-1
		                  : subject.begin() + pos;

	do {
        if( p(*i)  ) // predicate true, then found
            return i - begin;
	} while( i-- != begin );
	return npos;
}
コード例 #23
0
ファイル: Picture.cpp プロジェクト: 15375514460/TortoiseGit
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;
			}
		}
	}
コード例 #24
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());
	}
コード例 #25
0
ファイル: ChatCtrl.cpp プロジェクト: Dimetro83/DC_DDD
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;
		}
	}

}
コード例 #26
0
ファイル: XMLConverter.cpp プロジェクト: GlenDC/Lemmings3D
	std::string ConvertTString(const tstring & value)
	{
		return string(value.begin(), value.end());
	}
コード例 #27
0
ファイル: util.cpp プロジェクト: 151706061/nsis-chinese
tstring lowercase(const tstring &str) {
    tstring result = str;
    transform(str.begin(), str.end(), result.begin(), ToLower());
    return result;
}
コード例 #28
0
ファイル: dirreader.cpp プロジェクト: kichik/nsis
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;
}
コード例 #29
0
string ConvertToString(const tstring& str)
{
	return string(str.begin(), str.end());
}
コード例 #30
0
ファイル: Path.cpp プロジェクト: andyburke/Replicant
void Path::MakeNative( tstring& path )
{
    std::replace( path.begin(), path.end(), s_InternalPathSeparator, Helium::PathSeparator );
}