Пример #1
0
HRESULT URLParser::ParseVideoURL(std::wstring& wstrURL, std::wstring& wstrVideoURL)
{
    HRESULT hr = E_FAIL;
    std::wstring wstrNormalizedURL;
    URLParser::VIDEO_URL_PARSER eVideoURLParser;
    int iCount = 0;
    if(0 == wstrURL.find(L"http://"))
    {
        iCount += wcslen(L"http://");
    }
    if(iCount == wstrURL.find(L"www."))
    {
        iCount += wcslen(L"www.");
    }
    if(iCount == wstrURL.find(L"youtube"))
    {
        eVideoURLParser = URLParser::YOUTUBE_VIDEO_URL_PARSER;
        hr = GetVideoInfoURL(eVideoURLParser, wstrURL, wstrVideoURL );
    }
    /*
    else if(OTHER_VIDEO_PARSERS)
    {
        // For Future
    }
    */
    return hr;
}
Пример #2
0
HRESULT URLParser::GetVideoInfoURL(URLParser::VIDEO_URL_PARSER eVideoURLParser, std::wstring& wstrURL, std::wstring& wstrVideoURL)
{
    HRESULT hr          = E_FAIL;
    int     iVdoIDStart = -1;
    int     iVdoIDEnd   = -1;
    std::wstring wstrVideoID;
    if(std::wstring::npos != (iVdoIDStart = wstrURL.find(L"v=")))
    {
        iVdoIDStart += wcslen(L"v=");
        iVdoIDEnd = wstrURL.find(L"&", iVdoIDStart);
        if(std::wstring::npos != iVdoIDEnd)
        {
            // pick start to end
            wstrVideoID = wstrURL.substr(iVdoIDStart, (iVdoIDEnd - iVdoIDStart));
        }
        else
        {
            // pick the entire string
            wstrVideoID = wstrURL.substr(iVdoIDStart, (wstrURL.length() - iVdoIDStart));
        }
    }
    if(0 != wstrVideoID.length())
    {
        wstrVideoURL.clear();
        wstrVideoURL.assign(PRE_VIDEO_ID_URL_STRING);
        wstrVideoURL.append(wstrVideoID);
        wstrVideoURL.append(POST_VIDEO_ID_URL_STRING);
        hr = S_OK;
    }
    return hr;
}
Пример #3
0
int FirstInvalidDirSeparatorSizetap(std::wstring& aPath, std::wstring::size_type& aIndex)
	{
	// If path semantics is correct (as needed by sisx library)
	// then the function will return 0
	int ret = 0; 
	int pos = 0;
	#ifdef __LINUX__
	if((pos = aPath.find(L"\\\\", aIndex)) != std::wstring::npos)
	#else
	if((pos = aPath.find(L"//", aIndex)) != std::wstring::npos)
	#endif
		{
		ret = 2;
		}
	#ifdef __LINUX__
	else if((pos = aPath.find(L"\\", aIndex)) != std::wstring::npos)
	#else
	else if((pos = aPath.find(L"/", aIndex)) != std::wstring::npos)
	#endif
		{
		ret = 1;
		}
	aIndex = pos;
	return ret;
	}
Пример #4
0
void ReplaceWString(std::wstring & str, const std::wstring & find, const std::wstring & replace)
{
    for(auto i = str.find(find); i != std::wstring::npos ;i = str.find(find))
    {
        str.replace(i, find.size(), replace);
    }
}
int FacadeDocumentProviderImpl::CalculateFormatIndex(const std::wstring& formatString, std::wstring extension)
{
	if (extension[0] == L'.')
		extension = extension.substr(1);

	std::wstring filter = L"*." + CStdStringW(extension).ToLower();

	unsigned int iPos = (unsigned int) -1;
	int iIndex = 1;
	while (true)
	{
		iPos = (x64_int_cast)formatString.find(L"|", iPos+1);
		if (iPos == formatString.npos)
			return 1;

		int startPos = iPos;
		iPos = (x64_int_cast)formatString.find(L"|", iPos+1);
		if (iPos == formatString.npos)
			return 1;

		int endPos = iPos;
		std::wstring thisFormat = formatString.substr(startPos+1, endPos-startPos-1);

		if (thisFormat.find(filter) != thisFormat.npos)
			return iIndex;

		iIndex++;

		iPos++;
	}
	return 1;
}
Пример #6
0
/*
** Replaces %1, %2, ... with the corresponding measure value.
**
*/
bool Meter::ReplaceMeasures(std::wstring& str, AUTOSCALE autoScale, double scale, int decimals, bool percentual)
{
	bool replaced = false;

	if (str.find(L'%') != std::wstring::npos)
	{
		WCHAR buffer[64];

		for (size_t i = m_Measures.size(); i > 0; --i)
		{
			size_t len = _snwprintf_s(buffer, _TRUNCATE, L"%%%i", (int)i);
			size_t start = 0, pos;

			const WCHAR* measureValue = m_Measures[i - 1]->GetStringOrFormattedValue(
				autoScale, scale, decimals, percentual);
			const size_t measureValueLen = wcslen(measureValue);

			do
			{
				pos = str.find(buffer, start, len);
				if (pos != std::wstring::npos)
				{
					str.replace(pos, len, measureValue, measureValueLen);
					start = pos + measureValueLen;
					replaced = true;
				}
			}
			while (pos != std::wstring::npos);
		}
	}

	return replaced;
}
Пример #7
0
/*
** Replaces %1, %2 etc with the corresponding measure value
*/
bool CMeter::ReplaceMeasures(const std::vector<std::wstring>& stringValues, std::wstring& str)
{
	bool replaced = false;

	if (str.find(L'%') != std::wstring::npos)
	{
		WCHAR buffer[64];

		// Create the actual text (i.e. replace %1, %2, .. with the measure texts)
		for (size_t i = stringValues.size(); i > 0; --i)
		{
			size_t len = _snwprintf_s(buffer, _TRUNCATE, L"%%%i", (int)i);
			size_t start = 0, pos;
			do
			{
				pos = str.find(buffer, start, len);
				if (pos != std::wstring::npos)
				{
					str.replace(pos, len, stringValues[i - 1]);
					start = pos + stringValues[i - 1].length();
					replaced = true;
				}
			}
			while (pos != std::wstring::npos);
		}
	}

	return replaced;
}
Пример #8
0
static std::wstring rawinput_device_improve_name(const std::wstring &name)
{
	// The RAW name received is formatted as:
	//   \??\type-id#hardware-id#instance-id#{DeviceClasses-id}
	// XP starts with "\??\"
	// Vista64 starts with "\\?\"

	// ensure the name is something we can handle
	if (name.find(L"\\\\?\\") != 0 && name.find(L"\\??\\") != 0)
		return name;

	std::wstring regpath = compute_device_regpath(name);

	bool hid = false;
	auto improved = improve_name_from_base_path(regpath, &hid);
	if (!improved.empty())
		return improved;

	if (hid)
	{
		improved = improve_name_from_usb_path(regpath);
		if (!improved.empty())
			return improved;
	}

	// Fall back to the original name
	return name;
}
std::wstring Database::getParameterFromTag(std::wstring temp)
{
    size_t pos;
    const size_t nExist = std::wstring::npos;

    pos = temp.find('"');

    if ( pos != nExist)
    {
       temp.erase(0 , pos+1);
       pos = temp.find(L'"');

       if ( pos != nExist)
       {
            temp.erase(pos);
            return temp;
       }

       else
       {
           std::wcout << L"Fehler 1, getParameterFromTag()" << std::endl;
       }
    }

    else
    {
       std::wcout << L"Fehler 2, getParameterFromTag()" << std::endl;
    }

    return L"";
}
Пример #10
0
BOOL CImageUtility::IsLegalPath(std::wstring& wstrPathName)
{
	TSAUTO();

	size_t stPos1 = wstrPathName.find_first_of(L':');
	size_t stPos2 = wstrPathName.find_first_of(L'\\');

	BOOL bIsLegal = TRUE;
	if (1 != stPos1 || 2 != stPos2 || 3 > wstrPathName.length() || wstrPathName.find(_T("//")) != std::wstring::npos || wstrPathName.find(_T("\\\\")) != std::wstring::npos
		|| wstrPathName.find(_T("/\\")) != std::wstring::npos || wstrPathName.find(_T("\\/")) != std::wstring::npos)
	{
		bIsLegal = FALSE;
	}
	if (wstrPathName.size() > 150)
	{
		bIsLegal = FALSE;
	}
	if (TRUE == bIsLegal)
	{
		TCHAR* szUnLegalChars = L"/:*?\"<>|";
		std::wstring wstrPathNameWithoutHead = wstrPathName.substr(2);
		for (int i = 0; i < 8; ++i)
		{
			if (wstrPathNameWithoutHead.npos != wstrPathNameWithoutHead.find_first_of(szUnLegalChars[i]))
			{
				bIsLegal = FALSE;
				break;
			}
		}
	}

	return bIsLegal;
}
Пример #11
0
std::wstring getTemplateFilter(const std::wstring & templateContent)
{
    size_t idx_template = templateContent.find(L"$TEMPLATE_FILEFILTER:");
    std::wstring line;
    if(idx_template != std::wstring::npos)
    {
        idx_template += wcslen(L"$TEMPLATE_FILEFILTER:");
        size_t EOL = templateContent.find(L"\n", idx_template);
        if(EOL == std::wstring::npos)
            EOL = templateContent.size() - idx_template - 1;
        if(templateContent.at(EOL - 1) == L'\r')
            EOL--;
        if(EOL < idx_template)
            EOL = idx_template;
        line = templateContent.substr(idx_template, EOL - idx_template);
    }
    else
    {
        line = LoadWideString(IDS_FILTER);
    }
    for(size_t i = 0; i < line.size(); i++)
        if(line[i] == L'|')
            line[i] = L'\0';
    line.push_back(L'\0');
    return line;
}
Пример #12
0
bool CheckEquLabel(std::wstring& str)
{
	size_t s = str.find(L" equ ");
	if (s == std::string::npos) s = str.find(L":equ ");
	if (s != std::string::npos)
	{
		std::wstring name = str.substr(0,s);
		if (name.back() == ':') name.pop_back();

		if (Global.symbolTable.isValidSymbolName(name) == false)
		{
			Logger::printError(Logger::Error,L"Invalid equation name %s",name);
			return true;
		}

		if (Global.symbolTable.symbolExists(name,Global.FileInfo.FileNum,Global.Section))
		{
			Logger::printError(Logger::Error,L"Equation name %s already defined",name);
			return true;
		}
		
		std::wstring replacement = str.substr(s+5);
		Global.symbolTable.addEquation(name,Global.FileInfo.FileNum,Global.Section,replacement);
		return true;
	}

	return false;
}
Пример #13
0
// ---------------------------------------------------------------------------
// Name:        vspPackageWrapper::outputMessage
// Description: Send a text message to the output pane of visual studio
// Arguments:   gtString messageString
// Return Val:  void
// Author:      Gilad Yarnitzky
// Date:        17/2/2011
// ---------------------------------------------------------------------------
void vspPackageWrapper::outputMessage(const std::wstring& messageString, bool outputOnlyToLog)
{
    // Add to log:
    VSCORE(vscPrintDebugMsgToDebugLog)(messageString.c_str());

    if (!outputOnlyToLog)
    {
        IVsOutputWindowPane* spOutputWindowPane = getDebugPane();
        VSP_ASSERT(spOutputWindowPane != NULL);

        if (spOutputWindowPane != NULL)
        {
            HRESULT rc = spOutputWindowPane->Activate();
            bool isOk = (rc == S_OK);

            if (isOk)
            {
                std::wstring messageForOutputPane = messageString;
                // handle a case where the string begins with \n\n\n\n- we don't want to have many "CodeXL-" with no messege
                std::size_t found1 = messageString.find(VS_STR_NewLine);

                if (found1 == 0)
                {
                    for (;;)
                    {
                        std::size_t found2 = messageString.find(VS_STR_NewLine, found1 + 2);

                        if ((found2 != std::string::npos) && (found1 + 2) == found2)
                        {
                            found1 = found2;
                            continue;
                        }
                        else
                        {
                            break;
                        }
                    }

                    messageForOutputPane.insert(found1 + 1, VS_STR_CodeXLPrefix);
                }
                else
                {
                    messageForOutputPane.insert(0, VS_STR_CodeXLPrefix);
                }

                messageForOutputPane += VS_STR_NewLine;

                // Add the message to the debug pane:
                BSTR oleMessageString = SysAllocString(messageForOutputPane.c_str());
                spOutputWindowPane->OutputString(oleMessageString);
                SysFreeString(oleMessageString);

                // Reduce the reference count
                spOutputWindowPane->Release();
            }
        }
    }
}
Пример #14
0
std::wstring parseEngWordForEn(const std::wstring& innerW,const std::wstring& start,const std::wstring& end,int maxLine = 1 )
{
	int pos = 0;
	int endpos = 0;
/*
	for(int i = 0 ; i < maxLine ; i ++ )
	{
		endpos = innerW.find(L"。",endpos);
		if (endpos == std::wstring::npos)
		{
			endpos = innerW.size();
			break;
		}
		endpos ++; //skip 。
	}
*/
	endpos = innerW.size();

	int hit = innerW.find(start,pos);
	if (hit == std::wstring::npos || hit > endpos)
	{
		return L"";
	}
	hit += start.size();
	
	int hyphenpos = innerW.find(L"|",hit);
	int closepos = innerW.find(end,hit);
	if (hyphenpos == std::wstring::npos)
	{
		if (closepos == std::wstring::npos)
		{
			return L"";
		}
	}
	else
	{
		if (closepos == std::wstring::npos)
		{
			closepos = hyphenpos;
		}
		else
		{
			if (closepos > hyphenpos)
			{
				closepos = hyphenpos;
			}
		}
	}

	if (closepos > endpos)
	{
		return L"";
	}
	
	std::wstring a = innerW.substr(hit , closepos - hit);
	a = cleaningYomi(a);
	return a;
}
Пример #15
0
int CommandLineArguments::GetSwitchDelimiterLength(std::wstring arg) {
  if (arg.find(L"--") == 0) {
    return 2;
  } else if (arg.find(L"-") == 0 || arg.find(L"/") == 0) {
    return 1;
  }

  return 0;
}
Пример #16
0
std::wstring Dialog::preInsert(Coord &, const std::wstring &value)
{
  if ((answers_ & Yes) != 0 && value.find(L'y') != std::wstring::npos)
    result(Yes);
  if ((answers_ & No) != 0 && value.find(L'n') != std::wstring::npos)
    result(No);
  if ((answers_ & Cancel) != 0 && value.find(L'c') != std::wstring::npos)
    result(Cancel);
  return L"";
}
std::wstring ReplaceCharWithString(std::wstring source, const wchar_t replaceChar, std::wstring replaceString) 
{ 
	size_t posn = source.find(&replaceChar);
	while (posn != std::wstring::npos)
	{
		source.replace(posn, 1, replaceString);
		posn = source.find(&replaceChar, posn + replaceString.length());
	}
    return source; 
}
 void ReplicaManagerWrapper::AddIncarnationIdIfNecessary(std::wstring & replica)
 {
     if (replica.find(L'@') == std::wstring::npos)
     {
         auto dex = replica.find(L':');
         wstring r;
         StringWriter w(r);
         w << replica.substr(0, dex) << Constants::ReplicaIncarnationDelimiter << Common::Guid::NewGuid().ToString() << ':' << replica.substr(dex+1);
         replica = r;
     }
 }
Пример #19
0
bool SleepConsole::FindListSubCommand(std::wstring& input)
{
	bool result = false;
	wstring diskListCommand(L"disks");
	wstring currentOperations(L"current operations");
	wstring pendingOperations(L"pending operations");
	if(input.find(diskListCommand) != wstring::npos){
		result = true;
		for(vector<DISKINFORMATION>::const_iterator iter = disks.begin(); iter != disks.end(); ++iter){
			wstring diskName(L"Disk ");
			int diskNum = iter->DiskNumber;
			wchar_t buff[2] = {0};
			_itow(diskNum, buff, 10);
			diskName += buff;
			wcout << diskName << endl;
			for(std::vector<VOLUMEPROPERTIES>::const_iterator itVol = iter->VOLUMES.begin(); itVol != iter->VOLUMES.end(); ++itVol){
				wcout << L"\t" << itVol->MountPoint << endl;
			}
		}
	}
	else if(input.find(currentOperations) != wstring::npos){
		consoleOperation = QUERY;
		if (GenerateCommandToSend()){
			if (ApplyCommand())
					result = true;
		}
	}
	else if(input.find(pendingOperations) != wstring::npos){
		wchar_t* buffer = new wchar_t[80];
		ZeroMemory(buffer, 80);
		result = true;
		if (sleephddQueue->empty()){
			cout << "No pending operations!\n";
			delete buffer;
			buffer = NULL;
			return result;
		}
		for(std::list<std::pair<std::wstring, Operations> >::iterator iter = sleephddQueue->begin(); iter != sleephddQueue->end(); iter++){
			if(iter->second == ACTIVE)
				swprintf(buffer,L"Partition %s - Active\n", iter->first.c_str());
			else
				swprintf(buffer,L"Partition %s - Locked\n", iter->first.c_str());
			wcout << buffer;
			ZeroMemory(buffer, 80);
		}
		delete buffer;
		buffer = NULL;
	}
	else{
		cout << "Not supported command!\n";
	}

	return result;
}
Пример #20
0
void Mouse::ReplaceMouseVariables(std::wstring& result) const
{
	// Check for new-style variables: [$MOUSEX]
	m_Skin->GetParser().ParseVariables(result, ConfigParser::VariableType::Mouse, m_Meter);

	// Check for old-style variables: $MOUSEX$
	size_t start = 0, end;
	bool loop = true;

	do
	{
		start = result.find(L'$', start);
		if (start != std::wstring::npos)
		{
			size_t si = start + 1;
			end = result.find(L'$', si);
			if (end != std::wstring::npos)
			{
				size_t ei = end - 1;
				if (si != ei && result[si] == L'*' && result[ei] == L'*')
				{
					result.erase(ei, 1);
					result.erase(si, 1);
					start = ei;
				}
				else
				{
					std::wstring strVariable = result.substr(si, end - si);
					std::wstring value = m_Skin->GetParser().GetMouseVariable(strVariable, m_Meter);
					if (!value.empty())
					{
						// Variable found, replace it with the value
						result.replace(start, end - start + 1, value);
						start += value.length();
					}
					else
					{
						start = end;
					}
				}
			}
			else
			{
				loop = false;
			}
		}
		else
		{
			loop = false;
		}
	}
	while (loop);
}
Пример #21
0
/**
 * Split a string into elements as a newly created arrayBuffer
 * @param inBuf The CharArray to split along
 * @param splitChar The char to use as splitter
 * @param &argLen [OUT] The length of the Array
 * @param escape [IN] Set to true to try to escape ":s ie. //token1 "token2 with space" token3//
 * @return The arrayBuffer
 */
array_buffer::arrayBuffer array_buffer::split2arrayBuffer(const std::wstring inBuf, wchar_t splitChar, unsigned int &argLen, bool escape) {
	if (inBuf.empty())
		return createEmptyArrayBuffer(argLen);

	std::wstring::size_type p1 = 0;
	std::wstring::size_type p2 = 0;
	std::list<std::wstring> token_list;
	while (p1 != std::wstring::npos && p2 != std::wstring::npos) {
		if (escape && inBuf[p1] == '\"') {
			p2 = inBuf.find('\"', p1+1);
			if (p2 != std::wstring::npos)
				p2 = inBuf.find(splitChar, p2);
		} else {
			p2 = inBuf.find(splitChar, p1);
		}
		if (p2 == std::wstring::npos)
			p2 = inBuf.size();
		if (p1 == p2 && p1 != inBuf.size()) {
			p1++;
			continue;
		}
		// p1 = start of "this token"
		// p2 = end of "this token" (next split char)

		if (p2<=p1)
			throw ArrayBufferException("Invalid position");
		std::wstring token = inBuf.substr(p1,p2-p1);
		if (escape && token[0] == '\"')
			token = token.substr(1);
		if (escape && token[token.size()-1] == '\"')
			token = token.substr(0, token.size()-1);


		token_list.push_back(token);
		if (p2 < inBuf.size())
			p2++;
		if (p2 == inBuf.size())
			p2 = std::wstring::npos;
		p1 = p2;
	}
	arrayBuffer arrayBuffer = new arrayBufferItem[token_list.size()];
	argLen=0;
	for (std::list<std::wstring>::const_iterator cit=token_list.begin();cit!=token_list.end();++cit) {
		size_t len = (*cit).size();
		wchar_t* token = new wchar_t[len+1];
		wcsncpy(token, (*cit).c_str(), len);
		arrayBuffer[argLen++] = token;
	}
	token_list.clear();
	return arrayBuffer;
}
Пример #22
0
//-----------------------------------------------------------------------------
void mglParser::PutArg(std::wstring &str, bool def)
{
	size_t pos = str.find('$',def?10:0);
	while(pos<str.length())
	{
		wchar_t ch = str[pos+1];
		if(ch>='0' && ch<='9')	str.replace(pos,2,par[ch-'0']);
		else if(ch>='a' && ch<='z')	str.replace(pos,2,par[ch-'a'+10]);
		else if(ch=='$')	str.replace(pos,2,L"\uffff");
		else str.replace(pos,1,L"\uffff");
		pos = str.find('$',def?10:0);
	}
	while((pos = str.find(L'\uffff'))<str.length())	str[pos]='$';
}
void CtriPOSOpenSSLHMACSampleDlg::ParseUri(std::wstring uri, std::string &scheme, std::string &host, std::string &port, std::string &path, std::string &query)
{
    size_t findIndex = uri.find(L"://", 0);

    if (findIndex != std::string::npos)
    {
        scheme.assign(ToMultiByte(uri.substr(0, findIndex).c_str()));

        findIndex += 3;

        uri.erase(0, findIndex);
    }

    findIndex = uri.find(L"/", 0);

    if (findIndex != std::string::npos)
    {
        host.assign(ToMultiByte(uri.substr(0, findIndex).c_str()));

        uri.erase(0, findIndex);

        if (!host.empty())
        {
            findIndex = host.find(":", 0);

            if (findIndex != std::string::npos)
            {
                port = host.substr(findIndex + 1);

                host.erase(findIndex);
            }
        }
    }

    findIndex = uri.find(L"?", 0);

    if (findIndex == std::string::npos)
    {
        path.assign(ToMultiByte(uri.c_str()));
    }
    else
    {
        path.assign(ToMultiByte(uri.substr(0, findIndex).c_str()));

        findIndex++;

        query.assign(ToMultiByte(uri.substr(findIndex).c_str()));
    }
}
Пример #24
0
size_t StringUtil::split(std::vector<std::wstring>& vec, std::wstring str, wchar_t delim) {
	vec.clear();

	std::wstring::size_type pos = str.find(delim);

	while(pos != std::wstring::npos) {
		vec.push_back(str.substr(0, pos));
		str = str.substr(pos + 1);
		pos = str.find(delim);
	}

	vec.push_back(str);

	return vec.size();
}
Пример #25
0
size_t StringUtil::split(std::list<std::wstring>& list, std::wstring str, wchar_t delim) {
	list.clear();

	std::wstring::size_type pos = str.find(delim);

	while(pos != std::wstring::npos) {
		list.push_back(str.substr(0, pos));
		str = str.substr(pos + 1);
		pos = str.find(delim);
	}

	list.push_back(str);

	return list.size();
}
Пример #26
0
void CLocalPath::AddSegment(std::wstring const& segment)
{
	std::wstring& path = m_path.get();

	assert(!path.empty());
	assert(segment.find(L"/") == std::wstring::npos);
#ifdef FZ_WINDOWS
	assert(segment.find(L"\\") == std::wstring::npos);
#endif

	if (!segment.empty()) {
		path += segment;
		path += path_separator;
	}
}
Пример #27
0
std::wstring string_replace_all( std::wstring src, std::wstring const& target, std::wstring const& repl){

    if (target.length() == 0) {
        // searching for a match to the empty string will result in
        //  an infinite loop
        //  it might make sense to throw an exception for this case
        return src;
    }

    if (src.length() == 0) {
        return src;  // nothing to match against
    }

    size_t idx = 0;

    for (;;) {
        idx = src.find( target, idx);
        if (idx == std::wstring::npos)  break;

        src.replace( idx, target.length(), repl);
        idx += repl.length();
    }

    return src;
}
Пример #28
0
std::wstring UeiArgsParser::convertVerbose(const std::wstring& aVerbose)
{
    std::wostringstream arg;
    arg << SUPPORTED_JVM_ARGS[INDEX_VERBOSE];

    if (aVerbose.find(OPTION_SEPARATOR) != std::wstring::npos)
    {
        arg << OPTION_SEPARATOR;
        if (hasOption(aVerbose, ALL))
        {
            arg << JVM_SUPPORTED_VERBOSE_OPTIONS;
        }
        else
        {
            if (hasOption(aVerbose, GC))
            {
                arg << GC << COMMA;
            }
            if (hasOption(aVerbose, CLASS))
            {
                arg << CLASS << COMMA;
            }
        }
    }

    std::wstring result = arg.str();
    std::wostringstream whitespaces;
    whitespaces << OPTION_SEPARATOR << COMMA;
    trimTrailingSpaces(result, whitespaces.str());

    LOG2(EDebugApi, EInfo,"convertVerbose(%S): %S", aVerbose.c_str(), result.c_str());
    return result;
}
Пример #29
0
int TtfDisplay::getStringWidth(const std::wstring &str, HDC currDC, const std::wstring& filterStr, size_t filterLetterWidth) const
{
	//Save
	if (currDC!=NULL)
		lastKnownGoodHDC = currDC;

	//Measure this item by its string.
	SIZE textSize;
	HFONT oldFont = NULL;
	if (font!=NULL)
		oldFont = (HFONT)SelectObject(lastKnownGoodHDC, font);
	GetTextExtentPoint32(lastKnownGoodHDC, str.c_str(), str.length(), &textSize);

	//Restore the DC
	if (oldFont!=NULL)
		SelectObject(lastKnownGoodHDC, oldFont);

	//Calculate the total number of ZWS letters
	size_t countZWS = 0;
	if (!filterStr.empty()) {
		for (size_t i=0; i<str.length(); i++) {
			if (filterStr.find(str[i])!=wstring::npos)
				countZWS++;
		}
	}

	//Done
	return textSize.cx + countZWS*filterLetterWidth;
}
Пример #30
0
void DSNAttributes::Add(const std::wstring& namevaluepair)
{
    CHECK_BOOL(namevaluepair.find(L"=") != namevaluepair.npos,
        L"Missing = in \"" << namevaluepair << L"\"");

    _attributes.push_back(namevaluepair);
}