// \brief Override the function to change the default behavior on how // a selected item history should look like void CGUIMediaWindow::GetDirectoryHistoryString(const CFileItem* pItem, CStdString& strHistoryString) { if (pItem->m_bIsShareOrDrive) { // We are in the virual directory // History string of the DVD drive // must be handel separately if (pItem->m_iDriveType == CMediaSource::SOURCE_TYPE_DVD) { // Remove disc label from item label // and use as history string, m_strPath // can change for new discs CStdString strLabel = pItem->GetLabel(); int nPosOpen = strLabel.Find('('); int nPosClose = strLabel.ReverseFind(')'); if (nPosOpen > -1 && nPosClose > -1 && nPosClose > nPosOpen) { strLabel.Delete(nPosOpen + 1, (nPosClose) - (nPosOpen + 1)); strHistoryString = strLabel; } else strHistoryString = strLabel; } else { // Other items in virual directory CStdString strPath = pItem->m_strPath; URIUtils::RemoveSlashAtEnd(strPath); strHistoryString = pItem->GetLabel() + strPath; } } else if (pItem->m_lEndOffset>pItem->m_lStartOffset && pItem->m_lStartOffset != -1) { // Could be a cue item, all items of a cue share the same filename // so add the offsets to build the history string strHistoryString.Format("%ld%ld", pItem->m_lStartOffset, pItem->m_lEndOffset); strHistoryString += pItem->m_strPath; } else { // Normal directory items strHistoryString = pItem->m_strPath; } URIUtils::RemoveSlashAtEnd(strHistoryString); strHistoryString.ToLower(); }
bool CBaseTexture::LoadFromFileInMem(unsigned char* buffer, size_t size, const std::string& mimeType, unsigned int maxWidth, unsigned int maxHeight) { if (!buffer || !size) return false; //ImageLib is sooo sloow for jpegs. Try our own decoder first. If it fails, fall back to ImageLib. if (mimeType == "image/jpeg") { CJpegIO jpegfile; if (jpegfile.Read(buffer, size, maxWidth, maxHeight)) { if (jpegfile.Width() > 0 && jpegfile.Height() > 0) { Allocate(jpegfile.Width(), jpegfile.Height(), XB_FMT_A8R8G8B8); if (jpegfile.Decode(m_pixels, GetPitch(), XB_FMT_A8R8G8B8)) { m_hasAlpha=false; ClampToEdge(); return true; } } } } DllImageLib dll; if (!dll.Load()) return false; ImageInfo image; memset(&image, 0, sizeof(image)); unsigned int width = maxWidth ? std::min(maxWidth, g_Windowing.GetMaxTextureSize()) : g_Windowing.GetMaxTextureSize(); unsigned int height = maxHeight ? std::min(maxHeight, g_Windowing.GetMaxTextureSize()) : g_Windowing.GetMaxTextureSize(); CStdString ext = mimeType; int nPos = ext.Find('/'); if (nPos > -1) ext.Delete(0, nPos + 1); if(!dll.LoadImageFromMemory(buffer, size, ext.c_str(), width, height, &image)) { CLog::Log(LOGERROR, "Texture manager unable to load image from memory"); return false; } LoadFromImage(image); dll.ReleaseImage(&image); return true; }
void CHTMLUtil::getAttributeOfTag(const CStdString& strTagAndValue, const CStdString& strTag, CStdString& strValue) { // strTagAndValue contains: // like <a href=""value"..... strValue = strTagAndValue; int iStart = strTagAndValue.Find(strTag); if (iStart < 0) return ; iStart += (int)strTag.size(); while (strTagAndValue[iStart + 1] == 0x20 || strTagAndValue[iStart + 1] == 0x27 || strTagAndValue[iStart + 1] == 34) iStart++; int iEnd = iStart + 1; while (strTagAndValue[iEnd] != 0x27 && strTagAndValue[iEnd] != 0x20 && strTagAndValue[iEnd] != 34 && strTagAndValue[iEnd] != '>') iEnd++; if (iStart >= 0 && iEnd >= 0) { strValue = strTagAndValue.Mid(iStart, iEnd - iStart); } }
bool CNfsConnection::splitUrlIntoExportAndPath(const CURL& url, CStdString &exportPath, CStdString &relativePath) { bool ret = false; //refresh exportlist if empty or hostname change if(m_exportList.empty() || !url.GetHostName().Equals(m_hostName,false)) { m_exportList = GetExportList(url); } if(!m_exportList.empty()) { relativePath = ""; exportPath = ""; CStdString path = url.GetFileName(); //GetFileName returns path without leading "/" //but we need it because the export paths start with "/" //and path.Find(*it) wouldn't work else if(!path.empty() && path[0] != '/') { path = "/" + path; } std::list<CStdString>::iterator it; for(it=m_exportList.begin();it!=m_exportList.end();it++) { //if path starts with the current export path if( path.Find(*it) == 0 ) { exportPath = *it; //handle special case where root is exported //in that case we don't want to stripp off to //much from the path if( exportPath == "/" ) relativePath = "//" + path.Right((path.length()) - exportPath.length()); else relativePath = "//" + path.Right((path.length()-1) - exportPath.length()); ret = true; break; } } } return ret; }
long CSaveAsObject::CreateFileTypesSafeArray(const CStdString& sFormatString, CSDSafeArray& safeArray, const long& lFormatIndex) { // These MUST be a complete list of possible file formats, otherwise the format index will be off :( std::vector<CStdString> vValidFileFormats; vValidFileFormats.push_back(_T("Workshare DeltaFile")); vValidFileFormats.push_back(_T("Word 97-2003 Document")); vValidFileFormats.push_back(_T("Word Document")); vValidFileFormats.push_back(_T("Text Only")); vValidFileFormats.push_back(_T("Rich Text Format")); vValidFileFormats.push_back(_T("HTML Document")); vValidFileFormats.push_back(_T("Works 6.0 & 7.0")); vValidFileFormats.push_back(_T("Word 97-2003 & 6.0/95 - RTF")); vValidFileFormats.push_back(_T("Adobe Acrobat File")); vValidFileFormats.push_back(_T("Adobe Acrobat PDF/A File")); /*DE9488: For the moment we don't want the Excel and Powerpoint to show in the menu, but at a later *date we will add this to save menus*/ //vValidFileFormats.push_back(_T("Excel Document")); //vValidFileFormats.push_back(_T("Excel 2007 Document")); //vValidFileFormats.push_back(_T("PowerPoint Document")); //vValidFileFormats.push_back(_T("PowerPoint 2007 Document")); std::vector<CStdString> vRequiredFileFormats; std::vector<CStdString>::iterator iter; for(iter = vValidFileFormats.begin(); iter != vValidFileFormats.end(); ++iter ) { if(sFormatString.Find(*iter) != -1) { vRequiredFileFormats.push_back(*iter); } } long lVectorIndex = GetVectorIndexFormatPosition(sFormatString, lFormatIndex, vRequiredFileFormats); int index = 0; if(safeArray.Create(VT_BSTR, (x64_int_cast)vRequiredFileFormats.size())) { for(iter = vRequiredFileFormats.begin(); iter != vRequiredFileFormats.end(); ++iter ) { safeArray.PutElement(index, bstr_t(iter->c_str()).copy()); ++index; } } return lVectorIndex; }
CStdString CStackDirectory::GetFirstStackedFile(const CStdString &strPath) { // the stacked files are always in volume order, so just get up to the first filename // occurence of " , " CStdString file, folder; int pos = strPath.Find(" , "); if (pos > 0) URIUtils::Split(strPath.Left(pos), folder, file); else URIUtils::Split(strPath, folder, file); // single filed stacks - should really not happen // remove "stack://" from the folder folder = folder.Mid(8); file.Replace(",,", ","); return URIUtils::AddFileToFolder(folder, file); }
void CLastFmManager::Parameter(const CStdString& key, const CStdString& data, CStdString& value) { value = ""; vector<CStdString> params; StringUtils::SplitString(data, "\n", params); for (int i = 0; i < (int)params.size(); i++) { CStdString tmp = params[i]; if (int pos = tmp.Find(key) >= 0) { tmp.Delete(pos - 1, key.GetLength() + 1); value = tmp; break; } } CLog::Log(LOGDEBUG, "Parameter %s -> %s", key.c_str(), value.c_str()); }
void IpRanges::Compute() { m_ipRangePrefixes.clear(); m_ipRangeBitWidths.clear(); std::list<CStdString>::iterator it; for(it = m_asciiIpRanges.begin(); it != m_asciiIpRanges.end(); it++) { CStdString cidrPrefixLengthString; unsigned int cidrPrefixLength = 32; // by default, x.x.x.x/32 CStdString cidrIpAddressString; struct in_addr cidrIpAddress; CStdString entry = *it; int slashPosition = entry.Find('/'); if(slashPosition > 0) { cidrIpAddressString = entry.Left(slashPosition); cidrPrefixLengthString = entry.Mid(slashPosition+1); bool notAnInt = false; try { cidrPrefixLength = StringToInt(cidrPrefixLengthString); } catch (...) {notAnInt = true;} if(cidrPrefixLength < 1 || cidrPrefixLength > 32 || notAnInt) { throw (CStdString("IpRanges: invalid CIDR prefix length" + entry)); } } else { cidrIpAddressString = entry; } if(ACE_OS::inet_aton((PCSTR)cidrIpAddressString, &cidrIpAddress)) { unsigned int rangeBitWidth = 32-cidrPrefixLength; unsigned int prefix = ntohl((unsigned int)cidrIpAddress.s_addr) >> (rangeBitWidth); m_ipRangePrefixes.push_back(prefix); m_ipRangeBitWidths.push_back(rangeBitWidth); } else { throw (CStdString("invalid IP range:" + entry));
CPeripheral *CPeripherals::GetByPath(const CStdString &strPath) const { if (!strPath.Left(14).Equals("peripherals://")) return NULL; CStdString strPathCut = strPath.Right(strPath.length() - 14); CStdString strBus = strPathCut.Left(strPathCut.Find('/')); CSingleLock lock(m_critSection); for (unsigned int iBusPtr = 0; iBusPtr < m_busses.size(); iBusPtr++) { if (strBus.Equals(PeripheralTypeTranslator::BusTypeToString(m_busses.at(iBusPtr)->Type()))) return m_busses.at(iBusPtr)->GetByPath(strPath); } return NULL; }
bool CHttpApi::checkForFunctionTypeParas(CStdString &cmd, CStdString ¶s) { int open, close; open = cmd.Find("("); if (open>0) { close=cmd.length(); while (close>open && cmd.Mid(close,1)!=")") close--; if (close>open) { paras = cmd.Mid(open + 1, close - open - 1); cmd = cmd.Left(open); return (close-open)>1; } } return false; }
bool CVirtualPathDirectory::GetTypeAndSource(const CStdString& strPath, CStdString& strType, CStdString& strSource) { // format: virtualpath://type/sourcename CStdString strTemp = strPath; CUtil::RemoveSlashAtEnd(strTemp); CStdString strTest = "virtualpath://"; if (strTemp.Left(strTest.length()).Equals(strTest)) { strTemp = strTemp.Mid(strTest.length()); int iPos = strTemp.Find('/'); if (iPos < 1) return false; strType = strTemp.Mid(0, iPos); strSource = strTemp.Mid(iPos + 1); //CLog::Log(LOGDEBUG,"CVirtualPathDirectory::GetTypeAndSource(%s) = [%s],[%s]", strPath.c_str(), strType.c_str(), strSource.c_str()); return true; } return false; }
bool Addon_music_spotify::GetOneTrack(CFileItemList& items, CStdString& path) { Logger::printOut("get one track"); CURL url(path); CStdString uri = url.GetFileNameWithoutPath(); if (uri.Left(13).Equals("spotify:track")) { if (isReady()) { sp_link *spLink = sp_link_create_from_string(uri.Left(uri.Find('.'))); if (!spLink) return false; sp_track *spTrack = sp_link_as_track(spLink); if (spTrack) { SxTrack* track = TrackStore::getInstance()->getTrack(spTrack); items.Add(Utils::SxTrackToItem(track)); sp_track_release(spTrack); } sp_link_release(spLink); } } return true; }
void CGUIWindowBoxeeBrowseLocal::UpdateEjectButtonState() { #ifndef HAS_EMBEDDED SET_CONTROL_HIDDEN(BUTTON_EJECT); SET_CONTROL_HIDDEN(BUTTON_EJECT_USER); #else CStdString strPath = ((CLocalBrowseWindowState*)m_windowState)->GetCurrentPath(); if (CUtil::HasSlashAtEnd(strPath)) { // remove slash at the end strPath.Delete(strPath.size() - 1); } if(!strPath.Equals("afp://") && !strPath.Equals("afp://all") && strPath.Find("afp://") != -1) { SET_CONTROL_VISIBLE(BUTTON_EJECT_USER); SET_CONTROL_HIDDEN(BUTTON_EJECT); return; } if (strPath != "network://protocols" && strPath != "") { SET_CONTROL_HIDDEN(BUTTON_EJECT); SET_CONTROL_HIDDEN(BUTTON_EJECT_USER); return; } VECSOURCES removableDrives; g_mediaManager.GetRemovableDrives(removableDrives); if (removableDrives.size() == 0) { SET_CONTROL_HIDDEN(BUTTON_EJECT); SET_CONTROL_HIDDEN(BUTTON_EJECT_USER); return; } SET_CONTROL_HIDDEN(BUTTON_EJECT_USER); SET_CONTROL_VISIBLE(BUTTON_EJECT); #endif }
void CAdvancedSettings::GetCustomExtensions(TiXmlElement *pRootElement, CStdString& extensions) { CStdString extraExtensions; CSettings::GetString(pRootElement,"add",extraExtensions,""); if (extraExtensions != "") extensions += "|" + extraExtensions; CSettings::GetString(pRootElement,"remove",extraExtensions,""); if (extraExtensions != "") { CStdStringArray exts; StringUtils::SplitString(extraExtensions,"|",exts); for (unsigned int i=0;i<exts.size();++i) { int iPos = extensions.Find(exts[i]); if (iPos == -1) continue; extensions.erase(iPos,exts[i].size()+1); } } }
bool CAppRegistry::Has(const CStdString& key) { CSingleLock lock(m_lock); CStdString tempKey = key; size_t i = 0; // If we are asked for a variable with {}, take it from the vector, otherwise return the first int pos1 = key.Find("{"); int pos2 = key.Find("}"); if (pos1 >= 0 && pos2 > 0) { i = atoi(key.Mid(pos1+1, pos2 - pos1-1).c_str()); tempKey = key.Mid(0, pos1); } if (m_data.find(tempKey) == m_data.end()) return false; return true; }
static void SetupRarOptions(CFileItem& item, const CStdString& path) { CStdString path2(path); if (item.IsVideoDb() && item.HasVideoInfoTag()) path2 = item.GetVideoInfoTag()->m_strFileNameAndPath; CURL url(path2); CStdString opts = url.GetOptions(); if (opts.Find("flags") > -1) return; if (opts.size()) opts += "&flags=8"; else opts = "?flags=8"; url.SetOptions(opts); if (item.IsVideoDb() && item.HasVideoInfoTag()) item.GetVideoInfoTag()->m_strFileNameAndPath = url.Get(); else item.SetPath(url.Get()); g_directoryCache.ClearDirectory(url.GetWithoutFilename()); }
bool CNfsConnection::splitUrlIntoExportAndPath(const CURL& url, CStdString &exportPath, CStdString &relativePath) { bool ret = false; if(m_exportList.empty()) { m_exportList = GetExportList(url); } if(!m_exportList.empty()) { relativePath = ""; exportPath = ""; CStdString path = url.GetFileName(); //GetFileName returns path without leading "/" //but we need it because the export paths start with "/" //and path.Find(*it) wouldn't work else if(path[0] != '/') { path = "/" + path; } std::list<CStdString>::iterator it; for(it=m_exportList.begin();it!=m_exportList.end();it++) { //if path starts with the current export path if( path.Find(*it) == 0 ) { exportPath = *it; relativePath = "//" + path.Right((path.length()-1) - exportPath.length()); ret = true; break; } } } return ret; }
void CTextSearch::GetAndCutNextTerm(CStdString &strSearchTerm, CStdString &strNextTerm) { CStdString strFindNext(" "); if (StringUtils::EndsWith(strSearchTerm, "\"")) { strSearchTerm.erase(0, 1); strFindNext = "\""; } int iNextPos = strSearchTerm.Find(strFindNext); if (iNextPos != -1) { strNextTerm = strSearchTerm.Left(iNextPos); strSearchTerm.erase(0, iNextPos + 1); } else { strNextTerm = strSearchTerm; strSearchTerm.clear(); } }
void CPVRRecording::Update(const CPVRRecording &tag) { m_strRecordingId = tag.m_strRecordingId; m_iClientId = tag.m_iClientId; m_strTitle = tag.m_strTitle; m_recordingTime = tag.m_recordingTime; m_duration = tag.m_duration; m_iPriority = tag.m_iPriority; m_iLifetime = tag.m_iLifetime; m_strDirectory = tag.m_strDirectory; m_strPlot = tag.m_strPlot; m_strPlotOutline = tag.m_strPlotOutline; m_strStreamURL = tag.m_strStreamURL; m_strChannelName = tag.m_strChannelName; m_genre = tag.m_genre; m_strIconPath = tag.m_strIconPath; m_strThumbnailPath = tag.m_strThumbnailPath; m_strFanartPath = tag.m_strFanartPath; if (g_PVRClients->SupportsRecordingPlayCount(m_iClientId)) m_playCount = tag.m_playCount; CStdString strShow; strShow.Format("%s - ", g_localizeStrings.Get(20364).c_str()); if (m_strPlotOutline.Left(strShow.size()).Equals(strShow)) { CStdString strEpisode = m_strPlotOutline; CStdString strTitle = m_strDirectory; int pos = strTitle.ReverseFind('/'); strTitle.erase(0, pos + 1); strEpisode.erase(0, strShow.size()); m_strTitle.Format("%s - %s", strTitle.c_str(), strEpisode); pos = strEpisode.Find('-'); strEpisode.erase(0, pos + 2); m_strPlotOutline = strEpisode; } UpdatePath(); }
void CGUIBaseContainer::OnJumpSMS(int letter) { static const char letterMap[8][6] = { "ABC2", "DEF3", "GHI4", "JKL5", "MNO6", "PQRS7", "TUV8", "WXYZ9" }; // only 2..9 supported if (letter < 2 || letter > 9 || !m_letterOffsets.size()) return; const CStdString letters = letterMap[letter - 2]; // find where we currently are int offset = CorrectOffset(m_offset, m_cursor); unsigned int currentLetter = 0; while (currentLetter + 1 < m_letterOffsets.size() && m_letterOffsets[currentLetter + 1].first <= offset) currentLetter++; // now switch to the next letter CStdString current = m_letterOffsets[currentLetter].second; int startPos = (letters.Find(current.ToUpper()) + 1) % letters.size(); // now jump to letters[startPos], or another one in the same range if possible int pos = startPos; while (true) { // check if we can jump to this letter for (unsigned int i = 0; i < m_letterOffsets.size(); i++) { if (m_letterOffsets[i].second.ToLower() == letters.Mid(pos, 1).ToLower()) { SelectItem(m_letterOffsets[i].first); return; } } pos = (pos + 1) % letters.size(); if (pos == startPos) return; } }
/// \brief Build a directory history string /// \param pItem Item to build the history string from /// \param strHistoryString History string build as return value void CGUIWindowFileManager::GetDirectoryHistoryString(const CFileItem* pItem, CStdString& strHistoryString) { if (pItem->m_bIsShareOrDrive) { // We are in the virtual directory // History string of the DVD drive // must be handel separately if (pItem->m_iDriveType == CMediaSource::SOURCE_TYPE_DVD) { // Remove disc label from item label // and use as history string, m_strPath // can change for new discs CStdString strLabel = pItem->GetLabel(); int nPosOpen = strLabel.Find('('); int nPosClose = strLabel.ReverseFind(')'); if (nPosOpen > -1 && nPosClose > -1 && nPosClose > nPosOpen) { strLabel.Delete(nPosOpen + 1, (nPosClose) - (nPosOpen + 1)); strHistoryString = strLabel; } else strHistoryString = strLabel; } else { // Other items in virtual directory strHistoryString = pItem->GetLabel() + pItem->m_strPath; CUtil::RemoveSlashAtEnd(strHistoryString); } } else { // Normal directory items strHistoryString = pItem->m_strPath; CUtil::RemoveSlashAtEnd(strHistoryString); } }
const CStdString CPVRRecordings::GetDirectoryFromPath(const CStdString &strPath, const CStdString &strBase) const { CStdString strReturn; CStdString strUsePath = TrimSlashes(strPath); CStdString strUseBase = TrimSlashes(strBase); /* strip the base or return an empty value if it doesn't fit or match */ if (!strUseBase.IsEmpty()) { if (strUsePath.GetLength() <= strUseBase.GetLength() || strUsePath.Left(strUseBase.GetLength()) != strUseBase) return strReturn; strUsePath.erase(0, strUseBase.GetLength()); } /* check for more occurences */ int iDelimiter = strUsePath.Find('/'); if (iDelimiter > 0) strReturn = strUsePath.Left(iDelimiter); else strReturn = strUsePath; return TrimSlashes(strReturn); }
void TestGlobalMethods::TestReplaceFileExtension() { CStdString sFile = _T("NotPDF.doc"); CStdString sExtension = _T("pdf"); CStdString sResult = ReplaceFileExtension(sFile, sExtension.c_str()); int iPosition = sResult.ReverseFind(_T('.')); CStdString sNewExtension = sResult.Right((int)sResult.length() - (iPosition + 1)); assertMessage(0 != iPosition, _T("Failed to locate file extension separator '.'")); assertMessage(0 == (int)sExtension.CompareNoCase(sNewExtension), _T("Failed to match the expected extension 'pdf'")); sFile = _T("IsPDF.pdf"); sExtension = _T("pdf"); sResult = ReplaceFileExtension(sFile, sExtension.c_str()); sNewExtension = sResult.Right((int)sResult.length() - (sResult.Find(_T("."), 0) + 1)); assertMessage(sExtension.length() == sNewExtension.length(), _T("We expected the extension lengths to be equal")); sFile = _T("NoExtension"); sExtension = _T("pdf"); sResult = ReplaceFileExtension(sFile, sExtension.c_str()); iPosition = sResult.ReverseFind(_T('.')); assertMessage(0 != iPosition, _T("Failed to locate file extension separator '.'")); assertMessage(0 == (int)sExtension.CompareNoCase(sResult.Right((int)sResult.length() - (iPosition + 1))), _T("Failed to match the expected extension 'pdf'")); }
const CStdString CPVRRecordings::GetDirectoryFromPath(const CStdString &strPath, const CStdString &strBase) const { CStdString strReturn; CStdString strUsePath = TrimSlashes(strPath); CStdString strUseBase = TrimSlashes(strBase); /* strip the base or return an empty value if it doesn't fit or match */ if (!strUseBase.IsEmpty()) { /* adding "/" to make sure that base matches the complete folder name and not only parts of it */ if (strUsePath.GetLength() <= strUseBase.GetLength() || strUsePath.Left(strUseBase.GetLength() + 1) != strUseBase + "/") return strReturn; strUsePath.erase(0, strUseBase.GetLength()); } /* check for more occurences */ int iDelimiter = strUsePath.Find('/'); if (iDelimiter > 0) strReturn = strUsePath.Left(iDelimiter); else strReturn = strUsePath; return TrimSlashes(strReturn); }
void URIUtils::RemoveExtension(CStdString& strFileName) { if(IsURL(strFileName)) { CURL url(strFileName); strFileName = url.GetFileName(); RemoveExtension(strFileName); url.SetFileName(strFileName); strFileName = url.Get(); return; } int iPos = strFileName.ReverseFind("."); // Extension found if (iPos > 0) { CStdString strExtension; GetExtension(strFileName, strExtension); strExtension.ToLower(); strExtension += "|"; CStdString strFileMask; strFileMask = g_settings.m_pictureExtensions; strFileMask += "|" + g_settings.m_musicExtensions; strFileMask += "|" + g_settings.m_videoExtensions; #if defined(__APPLE__) strFileMask += "|.py|.xml|.milk|.xpr|.xbt|.cdg|.app|.applescript|.workflow"; #else strFileMask += "|.py|.xml|.milk|.xpr|.xbt|.cdg"; #endif strFileMask += "|"; if (strFileMask.Find(strExtension) >= 0) strFileName = strFileName.Left(iPos); } }
void CAppRegistry::Unset(const CStdString& key) { CSingleLock lock(m_lock); CStdString tempKey = key; size_t i = 0; // If we are asked for a variable with {}, take it from the vector, otherwise return the first int pos1 = key.Find("{"); int pos2 = key.Find("}"); if (pos1 >= 0 && pos2 > 0) { i = atoi(key.Mid(pos1+1, pos2 - pos1-1).c_str()); tempKey = key.Mid(0, pos1); } // Check if the key exists if (m_data.find(tempKey) == m_data.end()) return; // Check that the index is not out of bounds RegistryValue& values = m_data[tempKey]; if (i > values.size()-1) return; // Remove the item from the deque values.erase(values.begin() + i); // If the the map item has an empty deque, delete it if (values.size() == 0) { m_data.erase(tempKey); } Save(); }
void CLastFMDirectory::AddEntry(int iString, CStdString strPath, CStdString strIconPath, bool bFolder, CFileItemList &items) { CStdString strLabel = g_localizeStrings.Get(iString); strLabel.Replace("%name%", m_objname); strLabel.Replace("%type%", m_objtype); strLabel.Replace("%request%", m_objrequest); strPath.Replace("%name%", m_encodedobjname); strPath.Replace("%type%", m_objtype); strPath.Replace("%request%", m_objrequest); CFileItemPtr pItem(new CFileItem); pItem->SetLabel(strLabel); pItem->m_strPath = strPath; pItem->m_bIsFolder = bFolder; pItem->SetLabelPreformated(true); //the extra info is used in the mediawindows to determine which items are needed in the contextmenu if (strPath.Find("lastfm://xbmc") >= 0) { pItem->SetCanQueue(false); pItem->SetExtraInfo("lastfmitem"); } items.Add(pItem); }
bool URIUtils::IsDVD(const CStdString& strFile) { CStdString strFileLow = strFile; strFileLow.MakeLower(); if (strFileLow.Find("video_ts.ifo") != -1 && IsOnDVD(strFile)) return true; #if defined(_WIN32) if (strFile.Left(6).Equals("dvd://")) return true; if(strFile.Mid(1) != ":\\" && strFile.Mid(1) != ":") return false; if(GetDriveType(strFile.c_str()) == DRIVE_CDROM) return true; #else if (strFileLow == "iso9660://" || strFileLow == "udf://" || strFileLow == "dvd://1" ) return true; #endif return false; }
bool URIUtils::IsDVD(const CStdString& strFile) { CStdString strFileLow = strFile; strFileLow.MakeLower(); if (strFileLow.Find("video_ts.ifo") != -1 && IsOnDVD(strFile)) return true; #if defined(TARGET_WINDOWS) if (StringUtils::StartsWithNoCase(strFile, "dvd://")) return true; if(strFile.Mid(1) != ":\\" && strFile.Mid(1) != ":") return false; if(GetDriveType(strFile.c_str()) == DRIVE_CDROM) return true; #else if (strFileLow == "iso9660://" || strFileLow == "udf://" || strFileLow == "dvd://1" ) return true; #endif return false; }
void TestInterwoven::TestGetMatterFoldersEmailAdressesFromDocumentID() { CScopedTestDoc doc; DocProviderWorker worker; worker.Init(); worker.VerifySessionForServer("WORKSITE-C2"); CStdString sDocNum = CIManTestUtils::GetDocNumFromDocID(doc.GetDocId()); INRTDatabasePtr pDatabase; worker.m_pSessionsManager->GetSessionForServer(_T("WORKSITE-C2"))->GetDatabaseForName(_T("idocsdb1"), pDatabase); IManDocumentPtr pSearchedDocument = CIManTestUtils::GetDocumentFromDatabase_Helper(worker.GetSessionsMgr()->GetNRTDMS(), pDatabase, sDocNum); assertMessage(pSearchedDocument != NULL, _T("Failed to find document : ") + doc.GetDocId()); IManDocumentFolderPtr pDocFolder = CIManTestUtils::GetFolder_Helper(pDatabase, FOLDER_NAME); IManDocumentsPtr pDocs = pDocFolder->Contents; IManContentPtr pContentPtr = pSearchedDocument; HRESULT hr = pDocs->raw_AddDocumentReference( pSearchedDocument, &pContentPtr); CStdString sEmailString = worker.GetMatterFoldersEmailAddressesFromDocumentID(doc.GetDocId()); assertMessage(sEmailString.Find(_T("*****@*****.**"))!=-1, _T("GetMatterFolderEmailAdressFromDocumentID() failed to return a correct folder email address string")); }