コード例 #1
0
ファイル: ScraperParser.cpp プロジェクト: AaronDnz/xbmc
void CScraperParser::ReplaceBuffers(CStdString& strDest)
{
  // insert buffers
  int iIndex;
  for (int i=MAX_SCRAPER_BUFFERS-1; i>=0; i--)
  {
    CStdString temp;
    iIndex = 0;
    temp.Format("$$%i",i+1);
    while ((size_t)(iIndex = strDest.find(temp,iIndex)) != CStdString::npos) // COPIED FROM CStdString WITH THE ADDITION OF $ ESCAPING
    {
      strDest.replace(strDest.begin()+iIndex,strDest.begin()+iIndex+temp.GetLength(),m_param[i]);
      iIndex += m_param[i].length();
    }
  }
  // insert settings
  iIndex = 0;
  while ((size_t)(iIndex = strDest.find("$INFO[",iIndex)) != CStdString::npos)
  {
    int iEnd = strDest.Find("]",iIndex);
    CStdString strInfo = strDest.Mid(iIndex+6,iEnd-iIndex-6);
    CStdString strReplace;
    if (m_scraper)
      strReplace = m_scraper->GetSetting(strInfo);
    strDest.replace(strDest.begin()+iIndex,strDest.begin()+iEnd+1,strReplace);
    iIndex += strReplace.length();
  }
  iIndex = 0;
  while ((size_t)(iIndex = strDest.find("\\n",iIndex)) != CStdString::npos)
    strDest.replace(strDest.begin()+iIndex,strDest.begin()+iIndex+2,"\n");
}
コード例 #2
0
CStdString OfflineDocIDResolver::GetLibrary( const CStdString& sDocID ) const
{
    int iPosStart = (x64_int_cast)sDocID.find( _T("//") );
    int iPosEnd = (x64_int_cast)sDocID.find( _T('/'), iPosStart + 2 );

    return sDocID.Mid(iPosStart + 2, iPosEnd - (iPosStart + 2));
}
コード例 #3
0
ファイル: PathReadWriter.cpp プロジェクト: killbug2004/WSProf
void PathReadWriter::GetPathList(const CStdString& sPathList, std::vector<CStdString>& pathList)
{
	pathList.clear();
	pathList.reserve(std::count(sPathList.begin(), sPathList.end(), _T(';')) + 1);

	int nStartPos = 0;
	for (int nEndPos = (int) sPathList.find(_T(';'));
		nEndPos >= 0;
		nEndPos = (int) sPathList.find(_T(';'), nStartPos = nEndPos + 1))
	{
		CStdString sSubPath = sPathList.Mid(nStartPos, nEndPos - nStartPos).Trim();
		if (!sSubPath.IsEmpty())
		{
			::PathRemoveBackslash(sSubPath.GetBuffer(MAX_PATH));
			sSubPath.ReleaseBuffer();
			pathList.push_back(sSubPath);
		}
	}
	CStdString sSubPath = sPathList.Mid(nStartPos).Trim();
	if (!sSubPath.IsEmpty())
	{
		::PathRemoveBackslash(sSubPath.GetBuffer(MAX_PATH));
		sSubPath.ReleaseBuffer();
		pathList.push_back(sSubPath);
	}
}
コード例 #4
0
WordVersions WordVersionChecker::ConvertNameToVersion(const CStdString& sVersionName)
{
	CStdString sMajVersion = sVersionName;

	if (sVersionName.find(_T('.'))!=-1)
	{
		sMajVersion = sVersionName.Left(sVersionName.find(_T('.')));
	}

	int iMajVer = _ttoi(sVersionName.c_str());

	switch (iMajVer)
	{
	case 8:
		return WORD_97;
	case 9:
		return WORD_2K;
	case 10:
		return WORD_XP;
	case 11:
		return WORD_2003;
	case 12:
		return WORD_2007;
	case 14:
		return WORD_2010;
	default:
		return UNKNOWN_WORD_VERSION;
	}

}
コード例 #5
0
ファイル: pathhelper.cpp プロジェクト: killbug2004/WSProf
void PathHelper::RemoveFromPath(CStdString sPath)
{
	CStdString sFullPath = GetProcessPath();

	sFullPath.ToLower();
	sPath.ToLower();

	if ( sPath.Right(1) == _T("\\") )
	{
		sPath = sPath.Left(sPath.length() - 1);
	}

	int nStart = (x64_int_cast)sFullPath.find(sPath);

	while (nStart >= 0)  // there may be multiple copies
	{
		int nEnd = nStart + (x64_int_cast)sPath.length() + 1;

		sFullPath = sFullPath.Left(nStart) + sFullPath.Right(sFullPath.length() - nEnd );

		sFullPath.TrimRight();
		sFullPath.TrimLeft();

		if (sFullPath.Left(1) == _T(";"))
			sFullPath = sFullPath.Mid(1);

		sFullPath.Replace(_T(";;"),_T(";"));

		nStart = (x64_int_cast)sFullPath.find(sPath);
	}

	SetProcessPath(sFullPath);
}
コード例 #6
0
// Splits the string input into pieces delimited by delimiter.
// if 2 delimiters are in a row, it will include the empty string between them.
// added MaxStrings parameter to restrict the number of returned substrings (like perl and python)
int StringUtils::SplitString(const CStdString& input, const CStdString& delimiter, CStdStringArray &results, unsigned int iMaxStrings /* = 0 */)
{
  size_t iPos = std::string::npos;
  size_t newPos = std::string::npos;
  size_t sizeS2 = delimiter.size();
  size_t isize = input.size();

  results.clear();

  vector<unsigned int> positions;

  newPos = input.find(delimiter, 0);

  if (newPos == std::string::npos)
  {
    results.push_back(input);
    return 1;
  }

  while (newPos != std::string::npos)
  {
    positions.push_back(newPos);
    iPos = newPos;
    newPos = input.find(delimiter, iPos + sizeS2);
  }

  // numFound is the number of delimiters which is one less
  // than the number of substrings
  unsigned int numFound = positions.size();
  if (iMaxStrings > 0 && numFound >= iMaxStrings)
    numFound = iMaxStrings - 1;

  for ( unsigned int i = 0; i <= numFound; i++ )
  {
    CStdString s;
    if ( i == 0 )
    {
      if ( i == numFound )
        s = input;
      else
        s = input.substr(i, positions[i]);
    }
    else
    {
      size_t offset = positions[i - 1] + sizeS2;
      if ( offset < isize )
      {
        if ( i == numFound )
          s = input.substr(offset);
        else if ( i > 0 )
          s = input.substr( positions[i - 1] + sizeS2,
                         positions[i] - positions[i - 1] - sizeS2 );
      }
    }
    results.push_back(s);
  }
  // return the number of substrings
  return results.size();
}
コード例 #7
0
// returns the number of occurrences of strFind in strInput.
int StringUtils::FindNumber(const CStdString& strInput, const CStdString &strFind)
{
  size_t pos = strInput.find(strFind, 0);
  int numfound = 0;
  while (pos != std::string::npos)
  {
    numfound++;
    pos = strInput.find(strFind, pos + 1);
  }
  return numfound;
}
コード例 #8
0
void CGUIDialogAudioSubtitleSettings::AddAudioStreams(CSettingGroup *group, const std::string &settingId)
{
  m_audioStreamStereoMode = false;
  if (group == NULL || settingId.empty())
    return;

  m_audioStream = g_application.m_pPlayer->GetAudioStream();
  if (m_audioStream < 0)
    m_audioStream = 0;

  // check if we have a single, stereo stream, and if so, allow us to split into
  // left, right or both
  if (g_application.m_pPlayer->GetAudioStreamCount() == 1)
  {
    CStdString strAudioInfo;
    g_application.m_pPlayer->GetAudioInfo(strAudioInfo);

    /* TODO:STRING_CLEANUP */
    int iNumChannels = 0;
    size_t pos = strAudioInfo.find("chns:");
    if (pos != std::string::npos)
      iNumChannels = static_cast<int>(strtol(strAudioInfo.substr(pos + 5).c_str(), NULL, 0));

    std::string strAudioCodec;
    if (strAudioInfo.size() > 7)
      strAudioCodec = strAudioInfo.substr(7, strAudioInfo.find(") VBR") - 5);

    bool bDTS = strAudioCodec.find("DTS") != std::string::npos;
    bool bAC3 = strAudioCodec.find("AC3") != std::string::npos;

    if (iNumChannels == 2 && !(bDTS || bAC3))
    { // ok, enable these options
/*      if (CMediaSettings::Get().GetCurrentVideoSettings().m_AudioStream == -1)
      { // default to stereo stream
        CMediaSettings::Get().GetCurrentVideoSettings().m_AudioStream = 0;
      }*/
      StaticIntegerSettingOptions options;
      for (int i = 0; i < 3; ++i)
        options.push_back(make_pair(i, 13320 + i));

      m_audioStream = -CMediaSettings::Get().GetCurrentVideoSettings().m_AudioStream - 1;
      m_audioStreamStereoMode = true;
      AddSpinner(group, settingId, 460, 0, m_audioStream, options);
      return;
    }
  }

  AddSpinner(group, settingId, 460, 0, m_audioStream, AudioStreamsOptionFiller);
}
コード例 #9
0
ファイル: MultiPathDirectory.cpp プロジェクト: Anankin/xbmc
CStdString CMultiPathDirectory::GetFirstPath(const CStdString &strPath)
{
  size_t pos = strPath.find("/", 12);
  if (pos != std::string::npos)
    return CURL::Decode(strPath.substr(12, pos - 12));
  return "";
}
コード例 #10
0
ファイル: DemoTestClass.cpp プロジェクト: killbug2004/WSProf
bool TestWindowActivate::GetWordPath(CStdString& csWordPath)
{
	if( !m_csWordPath.IsEmpty() )
		return true;

	TCHAR szValue[MAX_PATH]={0};
	DWORD	cbValue   = MAX_PATH;
	DWORD	wKeyType  = REG_SZ;
	HKEY	hStartKey = NULL;
	bool	bRet      = false;
	CStdString csPossibleResult;

	assertTest( RegOpenKey(		HKEY_CLASSES_ROOT,
							_T("\\Word.Document.8\\shell\\Open\\command"),
							&hStartKey) == ERROR_SUCCESS );
	
	assertTest( RegQueryValueEx(hStartKey, NULL, NULL, 
						    &wKeyType,
							(unsigned char*) szValue,
							&cbValue) == ERROR_SUCCESS);

	csPossibleResult = szValue;
	csPossibleResult.ToLower();

	int iFind =(x64_int_cast) csPossibleResult.find( _T("winword.exe") );
	if( iFind != CStdString::npos )
	{
		m_csWordPath = csPossibleResult;
		bRet = true;
	}

	RegCloseKey(hStartKey);
	return bRet;
}
コード例 #11
0
ファイル: ALSADirectSound.cpp プロジェクト: Kr0nZ/boxee
bool CALSADirectSound::SoundDeviceExists(const CStdString& device)
{
  void **hints, **n;
  char *name;
  CStdString strName;
  bool retval = false;

  if (snd_device_name_hint(-1, "pcm", &hints) == 0)
  {
    for (n = hints; *n; n++)
    {
      if ((name = snd_device_name_get_hint(*n, "NAME")) != NULL)
      {
        strName = name;
        if (strName.find(device) != string::npos)
        {
          retval = true;
          break;
        }
        free(name);
      }
    }
    snd_device_name_free_hint(hints);
  }
  return retval;
}
コード例 #12
0
ファイル: RSSDirectory.cpp プロジェクト: dougall08/xbmc
static void ParseItem(CFileItem* item, SResources& resources, TiXmlElement* root, const CStdString& path)
{
  for (TiXmlElement* child = root->FirstChildElement(); child; child = child->NextSiblingElement())
  {
    CStdString name = child->Value();
    CStdString xmlns;
    size_t pos = name.find(':');
    if(pos != std::string::npos)
    {
      xmlns = name.substr(0, pos);
      name.erase(0, pos+1);
    }

    if      (xmlns == "media")
      ParseItemMRSS   (item, resources, child, name, xmlns, path);
    else if (xmlns == "itunes")
      ParseItemItunes (item, resources, child, name, xmlns, path);
    else if (xmlns == "voddler")
      ParseItemVoddler(item, resources, child, name, xmlns, path);
    else if (xmlns == "boxee")
      ParseItemBoxee  (item, resources, child, name, xmlns, path);
    else if (xmlns == "zn")
      ParseItemZink   (item, resources, child, name, xmlns, path);
    else if (xmlns == "svtplay")
      ParseItemSVT    (item, resources, child, name, xmlns, path);
    else
      ParseItemRSS    (item, resources, child, name, xmlns, path);
  }
}
コード例 #13
0
ファイル: TSReader.cpp プロジェクト: SirTomselon/xbmc
std::string CTsReader::TranslatePath(const char*  pszFileName)
{
  if (m_basePath.length() == 0)
    return pszFileName;

  CStdString sTimeshiftFile = pszFileName;
  size_t found = string::npos;

  if ((m_cardSettings) && (m_cardSettings->size() > 0))
  {
    for (CCards::iterator it = m_cardSettings->begin(); it < m_cardSettings->end(); it++)
    {
      // Determine whether the first part of the timeshift file name is shared with this card
      found = sTimeshiftFile.find(it->TimeshiftingFolder);
      if (found != string::npos)
      {
        // Remove the original base path and replace it with the given path
        sTimeshiftFile = m_basePath + sTimeshiftFile.substr(it->TimeshiftingFolder.length()+1);
        break;
      }
    }
    XBMC->Log(LOG_DEBUG, "CTsReader:TranslatePath %s -> %s", pszFileName, sTimeshiftFile.c_str());
    return sTimeshiftFile;
  }

  return pszFileName;
}
コード例 #14
0
ファイル: VideoReferenceClock.cpp プロジェクト: AWilco/xbmc
bool CVideoReferenceClock::ParseNvSettings(int& RefreshRate)
{
  double fRefreshRate;
  char   Buff[255];
  int    ReturnV;
  struct lconv *Locale = localeconv();
  FILE*  NvSettings;

  const char* VendorPtr = (const char*)glGetString(GL_VENDOR);
  if (!VendorPtr)
  {
    CLog::Log(LOGDEBUG, "CVideoReferenceClock: glGetString(GL_VENDOR) returned NULL, not using nvidia-settings");
    return false;
  }

  CStdString Vendor = VendorPtr;
  Vendor.ToLower();
  if (Vendor.find("nvidia") == std::string::npos)
  {
    CLog::Log(LOGDEBUG, "CVideoReferenceClock: GL_VENDOR:%s, not using nvidia-settings", Vendor.c_str());
    return false;
  }

  NvSettings = popen(NVSETTINGSCMD, "r");
  if (!NvSettings)
  {
    CLog::Log(LOGDEBUG, "CVideoReferenceClock: %s: %s", NVSETTINGSCMD, strerror(errno));
    return false;
  }

  ReturnV = fscanf(NvSettings, "%254[^\n]", Buff);
  pclose(NvSettings);
  if (ReturnV != 1)
  {
    CLog::Log(LOGDEBUG, "CVideoReferenceClock: %s produced no output", NVSETTINGSCMD);
    return false;
  }

  CLog::Log(LOGDEBUG, "CVideoReferenceClock: output of %s: %s", NVSETTINGSCMD, Buff);

  for (int i = 0; i < 255 && Buff[i]; i++)
  {
      //workaround for locale mismatch
    if (Buff[i] == '.' || Buff[i] == ',')
      Buff[i] = *Locale->decimal_point;
  }

  ReturnV = sscanf(Buff, "%lf", &fRefreshRate);
  if (ReturnV != 1 || fRefreshRate <= 0.0)
  {
    CLog::Log(LOGDEBUG, "CVideoReferenceClock: can't make sense of that");
    return false;
  }

  RefreshRate = MathUtils::round_int(fRefreshRate);
  CLog::Log(LOGDEBUG, "CVideoReferenceClock: Detected refreshrate by nvidia-settings: %f hertz, rounding to %i hertz",
            fRefreshRate, RefreshRate);

  return true;
}
コード例 #15
0
ファイル: URIUtils.cpp プロジェクト: 7orlum/xbmc
void URIUtils::RemoveExtension(std::string& strFileName)
{
  if(IsURL(strFileName))
  {
    CURL url(strFileName);
    strFileName = url.GetFileName();
    RemoveExtension(strFileName);
    url.SetFileName(strFileName);
    strFileName = url.Get();
    return;
  }

  size_t period = strFileName.find_last_of("./\\");
  if (period != string::npos && strFileName[period] == '.')
  {
    CStdString strExtension = strFileName.substr(period);
    StringUtils::ToLower(strExtension);
    strExtension += "|";

    CStdString strFileMask;
    strFileMask = g_advancedSettings.m_pictureExtensions;
    strFileMask += "|" + g_advancedSettings.m_musicExtensions;
    strFileMask += "|" + g_advancedSettings.m_videoExtensions;
    strFileMask += "|" + g_advancedSettings.m_subtitlesExtensions;
#if defined(TARGET_DARWIN)
    strFileMask += "|.py|.xml|.milk|.xpr|.xbt|.cdg|.app|.applescript|.workflow";
#else
    strFileMask += "|.py|.xml|.milk|.xpr|.xbt|.cdg";
#endif
    strFileMask += "|";

    if (strFileMask.find(strExtension) != std::string::npos)
      strFileName.erase(period);
  }
}
コード例 #16
0
bool URIUtils::IsOnLAN(const CStdString& strPath)
{
  if(IsMultiPath(strPath))
    return IsOnLAN(CMultiPathDirectory::GetFirstPath(strPath));

  if(IsStack(strPath))
    return IsOnLAN(CStackDirectory::GetFirstStackedFile(strPath));

  if(IsSpecial(strPath))
    return IsOnLAN(CSpecialProtocol::TranslatePath(strPath));

  if(IsDAAP(strPath))
    return true;
  
  if(IsPlugin(strPath))
    return false;

  if(IsTuxBox(strPath))
    return true;

  if(IsUPnP(strPath))
    return true;

  CURL url(strPath);
  if (url.GetProtocol() == "rar" || url.GetProtocol() == "zip")
    return IsOnLAN(url.GetHostName());

  if(!IsRemote(strPath))
    return false;

  CStdString host = url.GetHostName();
  if(host.length() == 0)
    return false;

  // assume a hostname without dot's
  // is local (smb netbios hostnames)
  if(host.find('.') == string::npos)
    return true;

  unsigned long address = ntohl(inet_addr(host.c_str()));
  if(address == INADDR_NONE)
  {
    CStdString ip;
    if(CDNSNameCache::Lookup(host, ip))
      address = ntohl(inet_addr(ip.c_str()));
  }

  if(address != INADDR_NONE)
  {
    // check if we are on the local subnet
    if (!g_application.getNetwork().GetFirstConnectedInterface())
      return false;

    if (g_application.getNetwork().HasInterfaceForIP(address))
      return true;
  }

  return false;
}
コード例 #17
0
ファイル: SmbFile.cpp プロジェクト: CybeSystems/XBMCPortable
bool CSmbFile::IsValidFile(const CStdString& strFileName)
{
  if (strFileName.find('/') == std::string::npos || /* doesn't have sharename */
      StringUtils::EndsWith(strFileName, "/.") || /* not current folder */
      StringUtils::EndsWith(strFileName, "/.."))  /* not parent folder */
      return false;
  return true;
}
コード例 #18
0
CStdString CGUIDialogBoxeeTechInfo::removeNItem(int n, CStdString str)
{
    size_t pos;
    CStdString tempStr;
    for (int i=1; i<n; i++)
    {
        pos = str.find(",");
        tempStr = tempStr.c_str() + str.substr(0, pos+2);
        str = str.substr(pos+2);
        //printf ("CGUIDialogBoxeeTechInfo::removeNItem - str: %s, tempStr: %s\n",str.c_str(), tempStr.c_str());
    }
    pos = str.find(",");
    str = str.substr(pos+2);
    tempStr = tempStr + str;

    return tempStr;
}
コード例 #19
0
ファイル: ZeroconfBrowser.cpp プロジェクト: Anankin/xbmc
CZeroconfBrowser::ZeroconfService CZeroconfBrowser::ZeroconfService::fromPath(const CStdString& fcr_path)
{
  if( fcr_path.empty() )
    throw std::runtime_error("CZeroconfBrowser::ZeroconfService::fromPath input string empty!");

  size_t pos1 = fcr_path.find('@'); //first @
  size_t pos2 = fcr_path.find('@', pos1 + 1); //second

  if(pos1 == std::string::npos || pos2 == std::string::npos)
    throw std::runtime_error("CZeroconfBrowser::ZeroconfService::fromPath invalid input path");

  return ZeroconfService(
    fcr_path.substr(pos2 + 1, fcr_path.length()), //name
    fcr_path.substr(0, pos1), //type
    fcr_path.substr(pos1 + 1, pos2-(pos1+1)) //domain
    );
}
コード例 #20
0
ファイル: exPIMP.cpp プロジェクト: Konnekt/expimp
int __stdcall IMessageProc(sIMessage_base * msgBase) {
    sIMessage_2params * msg = (msgBase->s_size>=sizeof(sIMessage_2params))?static_cast<sIMessage_2params*>(msgBase):0;
    switch (msgBase->id) {
    /* Wiadomoœci na które TRZEBA odpowiedzieæ */
    case IM_PLUG_NET:        return NET_EXPIMP; // Zwracamy wartoœæ NET, która MUSI byæ ró¿na od 0 i UNIKATOWA!
	case IM_PLUG_TYPE:       return IMT_UI|IMT_CONFIG; // Zwracamy jakiego typu jest nasza wtyczka (które wiadomoœci bêdziemy obs³ugiwaæ)
    case IM_PLUG_VERSION:    return 0; // Wersja wtyczki tekstowo major.minor.release.build ...
    case IM_PLUG_SDKVERSION: return KONNEKT_SDK_V;  // Ta linijka jest wymagana!
    case IM_PLUG_SIG:        return (int)"EXPIMP"; // Sygnaturka wtyczki (krótka, kilkuliterowa nazwa)
    case IM_PLUG_CORE_V:     return (int)"W98"; // Wymagana wersja rdzenia
    case IM_PLUG_UI_V:       return 0; // Wymagana wersja UI
    case IM_PLUG_NAME:       return (int)"exPiMP"; // Pe³na nazwa wtyczki
    case IM_PLUG_NETNAME:    return 0; // Nazwa obs³ugiwanej sieci (o ile jak¹œ sieæ obs³uguje)
    case IM_PLUG_INIT:       Plug_Init(msg->p1,msg->p2);return Init();
    case IM_PLUG_DEINIT:     Plug_Deinit(msg->p1,msg->p2);return DeInit();

    case IM_SETCOLS:     return ISetCols();

    case IM_UI_PREPARE:      return IPrepare();
    case IM_START:           return IStart();
    case IM_END:             return IEnd();

    case IM_UIACTION:        return ActionProc((sUIActionNotify_base*)msg->p1);

	case IM_PLUG_ARGS: {
		sIMessage_plugArgs * pa = static_cast<sIMessage_plugArgs*> (msgBase);
		if (pa->argc < 2) return 0;
		const char * import_ = getArgV(pa->argv+1 , pa->argc-1 , "-import" , true);
		if (import_ && *import_) {
			CStdString import = import_;
			if (import.find("expimp:")==0) {
				import = import.substr(import.find(':') + 1);
			}
			DoImport(import);		
		}
		return 0;}

    /* Tutaj obs³ugujemy wszystkie pozosta³e wiadomoœci */

    default:
        if (Ctrl) Ctrl->setError(IMERROR_NORESULT);
        return 0;

 }
 return 0;
}
コード例 #21
0
bool ShouldPrintToTempFile(const CStdString& sOutputFile)
{
	if(sOutputFile.find(L",")!=std::string::npos)
	{
		return true;
	}
	return false;
}
コード例 #22
0
ファイル: GUIInfoTypes.cpp プロジェクト: DasMarx/xbmc
CStdString AddonReplacer(const CStdString &str)
{
  // assumes "addon.id #####"
  size_t length = str.find(" ");
  CStdString id = str.substr(0, length);
  int stringid = atoi(str.substr(length + 1).c_str());
  return CAddonMgr::Get().GetString(id, stringid);
}
コード例 #23
0
bool TestWorkshareActions::TestManifestFileForVista()
{
	HANDLE hFile = ::CreateFile(sMANIFEST.c_str(), GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (hFile == INVALID_HANDLE_VALUE)
		return false;

	LARGE_INTEGER filesize;
	if (::GetFileSizeEx(hFile, &filesize) == 0)
	{
		::CloseHandle(hFile);
		return false;
	}
	DWORD dwFilesize = filesize.LowPart;
	
	DWORD read = 0;
	BYTE* buf = new BYTE[dwFilesize+2];
	if (::ReadFile(hFile, buf, dwFilesize, &read, NULL) == 0)
	{
		delete [] buf;
		::CloseHandle(hFile);
		return false;
	}
		
	buf[dwFilesize] = 0;
	buf[dwFilesize + 1 ] = 0;

	CStdString fileBuf;
	fileBuf = reinterpret_cast<TCHAR*>(buf);
	delete [] buf;
	buf = NULL;

	CStdString str = _T("<!--WISEMETA: name=\"[INSTALLDIRWITHDOUBLEBACKSLASH]");
	if (fileBuf.find(str) != -1)
	{
		::CloseHandle(hFile);
		return false;
	}
	if (fileBuf.find(sINSTALLDIRWITHDOUBLEBACKSLASH) != -1)
	{
		::CloseHandle(hFile);
		return false;
	}

	::CloseHandle(hFile);
	return true;
}
コード例 #24
0
ファイル: GUIWindow.cpp プロジェクト: B0k0/xbmc
void CGUIWindow::AllocResources(bool forceLoad /*= FALSE */)
{
  CSingleLock lock(g_graphicsContext);

#ifdef _DEBUG
  int64_t start;
  start = CurrentHostCounter();
#endif
  // use forceLoad to determine if xml file needs loading
  forceLoad |= NeedXMLReload() || (m_loadType == LOAD_EVERY_TIME);

  // if window is loaded and load is forced we have to free window resources first
  if (m_windowLoaded && forceLoad)
    FreeResources(true);

  if (forceLoad)
  {
    CStdString xmlFile = GetProperty("xmlfile").asString();
    if (xmlFile.size())
    {
      bool bHasPath = xmlFile.find("\\") != std::string::npos || xmlFile.find("/") != std::string::npos;
      Load(xmlFile,bHasPath);
    }
  }

  int64_t slend;
  slend = CurrentHostCounter();

  // and now allocate resources
  CGUIControlGroup::AllocResources();

#ifdef _DEBUG
  int64_t end, freq;
  end = CurrentHostCounter();
  freq = CurrentHostFrequency();
  if (forceLoad)
    CLog::Log(LOGDEBUG,"Alloc resources: %.2fms  (%.2f ms skin load)", 1000.f * (end - start) / freq, 1000.f * (slend - start) / freq);
  else
  {
    CLog::Log(LOGDEBUG,"Window %s was already loaded", GetProperty("xmlfile").c_str());
    CLog::Log(LOGDEBUG,"Alloc resources: %.2fm", 1000.f * (end - start) / freq);
  }
#endif
  m_bAllocated = true;
}
コード例 #25
0
ファイル: CueDocument.cpp プロジェクト: Anankin/xbmc
////////////////////////////////////////////////////////////////////////////////////
// Function: ExtractInfo()
// Extracts the information in quotes from the string line, returning it in quote
////////////////////////////////////////////////////////////////////////////////////
CStdString CCueDocument::ExtractInfo(const CStdString &line)
{
  size_t left = line.find('\"');
  if (left != std::string::npos)
  {
    size_t right = line.find('\"', left + 1);
    if (right != std::string::npos)
    {
      CStdString text = line.substr(left + 1, right - left - 1);
      g_charsetConverter.unknownToUTF8(text);
      return text;
    }
  }
  CStdString text = line;
  StringUtils::Trim(text);
  g_charsetConverter.unknownToUTF8(text);
  return text;
}
コード例 #26
0
ファイル: StringUtils.cpp プロジェクト: 7orlum/xbmc
bool StringUtils::ContainsKeyword(const CStdString &str, const vector<string> &keywords)
{
  for (vector<string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
  {
    if (str.find(*it) != str.npos)
      return true;
  }
  return false;
}
コード例 #27
0
bool StringUtils::ContainsKeyword(const CStdString &str, const CStdStringArray &keywords)
{
  for (CStdStringArray::const_iterator it = keywords.begin(); it != keywords.end(); it++)
  {
    if (str.find(*it) != str.npos)
      return true;
  }
  return false;
}
コード例 #28
0
ファイル: RssReader.cpp プロジェクト: B0k0/xbmc
bool CRssReader::Parse(int iFeed)
{
  TiXmlElement* rootXmlNode = m_xml.RootElement();

  if (!rootXmlNode)
    return false;

  TiXmlElement* rssXmlNode = NULL;

  CStdString strValue = rootXmlNode->Value();
  if (strValue.find("rss") != std::string::npos ||
      strValue.find("rdf") != std::string::npos)
    rssXmlNode = rootXmlNode;
  else
  {
    // Unable to find root <rss> or <rdf> node
    return false;
  }

  TiXmlElement* channelXmlNode = rssXmlNode->FirstChildElement("channel");
  if (channelXmlNode)
  {
    TiXmlElement* titleNode = channelXmlNode->FirstChildElement("title");
    if (titleNode && !titleNode->NoChildren())
    {
      CStdString strChannel = titleNode->FirstChild()->Value();
      CStdStringW strChannelUnicode;
      g_charsetConverter.utf8ToW(strChannel, strChannelUnicode, m_rtlText);
      AddString(strChannelUnicode, RSS_COLOR_CHANNEL, iFeed);

      AddString(":", RSS_COLOR_CHANNEL, iFeed);
      AddString(" ", RSS_COLOR_CHANNEL, iFeed);
    }

    GetNewsItems(channelXmlNode,iFeed);
  }

  GetNewsItems(rssXmlNode,iFeed);

  // avoid trailing ' - '
  if (m_strFeed[iFeed].size() > 3 && m_strFeed[iFeed].substr(m_strFeed[iFeed].size() - 3) == L" - ")
  {
    if (m_rtlText)
    {
      m_strFeed[iFeed].erase(0, 3);
      m_strColors[iFeed].erase(0, 3);
    }
    else
    {
      m_strFeed[iFeed].erase(m_strFeed[iFeed].length() - 3);
      m_strColors[iFeed].erase(m_strColors[iFeed].length() - 3);
    }
  }
  return true;
}
コード例 #29
0
ファイル: AFPFile.cpp プロジェクト: CharlieMarshall/xbmc
bool CAFPFile::IsValidFile(const CStdString& strFileName)
{
  if (strFileName.find('/') == std::string::npos   || // doesn't have sharename
      StringUtils::EndsWith(strFileName, "/.") ||     // not current folder
      StringUtils::EndsWith(strFileName, "/.."))      // not parent folder
  {
    return false;
  }

  return true;
}
コード例 #30
0
ファイル: WIN32Util.cpp プロジェクト: Saddamisalami/xbmc
bool CWIN32Util::HasGLDefaultDrivers()
{
  unsigned int a=0,b=0;

  CStdString strVendor = g_Windowing.GetRenderVendor();
  g_Windowing.GetRenderVersion(a, b);

  if(strVendor.find("Microsoft")!=strVendor.npos && a==1 && b==1)
    return true;
  else
    return false;
}