CStdString OfflineDocIDResolver::GetDocNum( const CStdString& sDocID ) const
{
int iPosEnd = (x64_int_cast)sDocID.rfind(_T("/"));
int iPosStart = (x64_int_cast)sDocID.rfind(_T("/"), iPosEnd - 1);
return sDocID.Mid(iPosStart + 1, iPosEnd - (iPosStart + 1));
}
CStdString CIManTestUtils::GetDocNumFromDocID(CStdString sDocID)
{
int iSlash = (x64_int_cast)sDocID.rfind(_T('/'));
if(iSlash == -1)
return _T("");
sDocID.resize(iSlash);
iSlash = (x64_int_cast)sDocID.rfind(_T('/'));
if(iSlash == -1)
return _T("");
sDocID.erase(0, iSlash + 1);
return sDocID;
}
CStdString OfflineDataStore::GenerateVersionDocID(const CStdString& sVersion, const CStdString& sDocID)
{
CStdString sTempID = _T("offline://") + sDocID;
CStdString sVersionID;
CStdString::size_type iFind = sTempID.rfind(_T('/'));
if(iFind != CStdString::npos )
{
sVersionID = sTempID.Mid(0, (iFind + 1));
}
sVersionID += sVersion;
return sVersionID;
}
CStdString URIUtils::GetDirectory(const CStdString &strFilePath)
{
// Will from a full filename return the directory the file resides in.
// Keeps the final slash at end and possible |option=foo options.
size_t iPosSlash = strFilePath.find_last_of("/\\");
if (iPosSlash == string::npos)
return ""; // No slash, so no path (ignore any options)
size_t iPosBar = strFilePath.rfind('|');
if (iPosBar == string::npos)
return strFilePath.substr(0, iPosSlash + 1); // Only path
return strFilePath.substr(0, iPosSlash + 1) + strFilePath.substr(iPosBar); // Path + options
}
/// \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();
size_t nPosOpen = strLabel.find('(');
size_t nPosClose = strLabel.rfind(')');
if (nPosOpen != std::string::npos &&
nPosClose != std::string::npos &&
nPosClose > nPosOpen)
{
strLabel.erase(nPosOpen + 1, (nPosClose) - (nPosOpen + 1));
strHistoryString = strLabel;
}
else
strHistoryString = strLabel;
}
else
{
// Other items in virtual directory
strHistoryString = pItem->GetLabel() + pItem->GetPath();
URIUtils::RemoveSlashAtEnd(strHistoryString);
}
}
else
{
// Normal directory items
strHistoryString = pItem->GetPath();
URIUtils::RemoveSlashAtEnd(strHistoryString);
}
}
void URIUtils::RemoveExtension(CStdString& strFileName)
{
if(IsURL(strFileName))
{
CURL url(strFileName);
strFileName = url.GetFileName();
RemoveExtension(strFileName);
url.SetFileName(strFileName);
strFileName = url.Get();
return;
}
size_t iPos = strFileName.rfind('.');
// Extension found
if (iPos != std::string::npos)
{
CStdString strExtension = GetExtension(strFileName);
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(iPos);
}
}
bool CWIN32Util::XBMCShellExecute(const CStdString &strPath, bool bWaitForScriptExit)
{
CStdString strCommand = strPath;
CStdString strExe = strPath;
CStdString strParams;
CStdString strWorkingDir;
StringUtils::Trim(strCommand);
if (strCommand.empty())
{
return false;
}
size_t iIndex = std::string::npos;
char split = ' ';
if (strCommand[0] == '\"')
{
split = '\"';
}
iIndex = strCommand.find(split, 1);
if (iIndex != std::string::npos)
{
strExe = strCommand.substr(0, iIndex + 1);
strParams = strCommand.substr(iIndex + 1);
}
StringUtils::Replace(strExe, "\"", "");
strWorkingDir = strExe;
iIndex = strWorkingDir.rfind('\\');
if(iIndex != std::string::npos)
{
strWorkingDir[iIndex+1] = '\0';
}
CStdStringW WstrExe, WstrParams, WstrWorkingDir;
g_charsetConverter.utf8ToW(strExe, WstrExe);
g_charsetConverter.utf8ToW(strParams, WstrParams);
g_charsetConverter.utf8ToW(strWorkingDir, WstrWorkingDir);
bool ret;
SHELLEXECUTEINFOW ShExecInfo = {0};
ShExecInfo.cbSize = sizeof(SHELLEXECUTEINFOW);
ShExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
ShExecInfo.hwnd = NULL;
ShExecInfo.lpVerb = NULL;
ShExecInfo.lpFile = WstrExe.c_str();
ShExecInfo.lpParameters = WstrParams.c_str();
ShExecInfo.lpDirectory = WstrWorkingDir.c_str();
ShExecInfo.nShow = SW_SHOW;
ShExecInfo.hInstApp = NULL;
g_windowHelper.StopThread();
LockSetForegroundWindow(LSFW_UNLOCK);
ShowWindow(g_hWnd,SW_MINIMIZE);
ret = ShellExecuteExW(&ShExecInfo) == TRUE;
g_windowHelper.SetHANDLE(ShExecInfo.hProcess);
// ShellExecute doesn't return the window of the started process
// we need to gather it from somewhere to allow switch back to XBMC
// when a program is minimized instead of stopped.
//g_windowHelper.SetHWND(ShExecInfo.hwnd);
g_windowHelper.Create();
if(bWaitForScriptExit)
{
// Todo: Pause music and video playback
WaitForSingleObject(ShExecInfo.hProcess,INFINITE);
}
return ret;
}
bool URIUtils::GetParentPath(const CStdString& strPath, CStdString& strParent)
{
strParent = "";
CURL url(strPath);
CStdString strFile = url.GetFileName();
if ( URIUtils::ProtocolHasParentInHostname(url.GetProtocol()) && strFile.empty())
{
strFile = url.GetHostName();
return GetParentPath(strFile, strParent);
}
else if (url.GetProtocol() == "stack")
{
CStackDirectory dir;
CFileItemList items;
dir.GetDirectory(url, items);
items[0]->m_strDVDLabel = GetDirectory(items[0]->GetPath());
if (StringUtils::StartsWithNoCase(items[0]->m_strDVDLabel, "rar://") || StringUtils::StartsWithNoCase(items[0]->m_strDVDLabel, "zip://"))
GetParentPath(items[0]->m_strDVDLabel, strParent);
else
strParent = items[0]->m_strDVDLabel;
for( int i=1;i<items.Size();++i)
{
items[i]->m_strDVDLabel = GetDirectory(items[i]->GetPath());
if (StringUtils::StartsWithNoCase(items[0]->m_strDVDLabel, "rar://") || StringUtils::StartsWithNoCase(items[0]->m_strDVDLabel, "zip://"))
items[i]->SetPath(GetParentPath(items[i]->m_strDVDLabel));
else
items[i]->SetPath(items[i]->m_strDVDLabel);
GetCommonPath(strParent,items[i]->GetPath());
}
return true;
}
else if (url.GetProtocol() == "multipath")
{
// get the parent path of the first item
return GetParentPath(CMultiPathDirectory::GetFirstPath(strPath), strParent);
}
else if (url.GetProtocol() == "plugin")
{
if (!url.GetOptions().empty())
{
url.SetOptions("");
strParent = url.Get();
return true;
}
if (!url.GetFileName().empty())
{
url.SetFileName("");
strParent = url.Get();
return true;
}
if (!url.GetHostName().empty())
{
url.SetHostName("");
strParent = url.Get();
return true;
}
return true; // already at root
}
else if (url.GetProtocol() == "special")
{
if (HasSlashAtEnd(strFile))
strFile.erase(strFile.size() - 1);
if(strFile.rfind('/') == std::string::npos)
return false;
}
else if (strFile.size() == 0)
{
if (url.GetHostName().size() > 0)
{
// we have an share with only server or workgroup name
// set hostname to "" and return true to get back to root
url.SetHostName("");
strParent = url.Get();
return true;
}
return false;
}
if (HasSlashAtEnd(strFile) )
{
strFile.erase(strFile.size() - 1);
}
size_t iPos = strFile.rfind('/');
#ifndef TARGET_POSIX
if (iPos == std::string::npos)
{
iPos = strFile.rfind('\\');
}
#endif
if (iPos == std::string::npos)
{
url.SetFileName("");
strParent = url.Get();
return true;
}
strFile.erase(iPos);
AddSlashAtEnd(strFile);
url.SetFileName(strFile);
strParent = url.Get();
return true;
}
CStdString CPlayListM3U::GetBestBandwidthStream(const CStdString &strFileName, size_t bandwidth)
{
// we may be passed a playlist that does not contain playlists of different
// bitrates (eg: this playlist is really the HLS video). So, default the
// return to the filename so it can be played
char szLine[4096];
CStdString strLine;
CStdString strPlaylist = strFileName;
size_t maxBandwidth = 0;
// if we cannot get the last / we wont be able to determine the sub-playlists
size_t baseEnd = strPlaylist.rfind('/');
if (baseEnd == std::string::npos)
return strPlaylist;
// store the base path (the path without the filename)
CStdString basePath = strPlaylist.substr(0, baseEnd + 1);
// open the file, and if it fails, return
CFile file;
if (!file.Open(strFileName) )
{
file.Close();
return strPlaylist;
}
// convert bandwidth specified in kbps to bps used by the m3u8
bandwidth *= 1000;
while (file.ReadString(szLine, 1024))
{
// read and trim a line
strLine = szLine;
strLine.TrimRight(" \t\r\n");
strLine.TrimLeft(" \t");
// skip the first line
if (strLine == M3U_START_MARKER)
continue;
else if (strLine.Left(strlen(M3U_STREAM_MARKER)) == M3U_STREAM_MARKER)
{
// parse the line so we can pull out the bandwidth
std::map< CStdString, CStdString > params = ParseStreamLine(strLine);
std::map< CStdString, CStdString >::iterator it = params.find(M3U_BANDWIDTH_MARKER);
if (it != params.end())
{
size_t streamBandwidth = atoi(it->second.c_str());
if ((maxBandwidth < streamBandwidth) && (streamBandwidth <= bandwidth))
{
// read the next line
if (!file.ReadString(szLine, 1024))
continue;
strLine = szLine;
strLine.TrimRight(" \t\r\n");
strLine.TrimLeft(" \t");
// this line was empty
if (strLine.empty())
continue;
// store the max bandwidth
maxBandwidth = streamBandwidth;
// if the path is absolute just use it
if (CURL::IsFullPath(strLine))
strPlaylist = strLine;
else
strPlaylist = basePath + strLine;
}
}
}
}
CLog::Log(LOGINFO, "Auto-selecting %s based on configured bandwidth.", strPlaylist.c_str());
return strPlaylist;
}
CStdString OfflineDataStore::RemoveVersionLabel( const CStdString& sDocID ) const
{
size_t iPos = sDocID.rfind(_T("/"));
return sDocID.Mid(0, iPos + 1);
}
CStdString OfflineDocIDResolver::GetVersion( const CStdString& sDocID ) const
{
int iPos = (x64_int_cast)sDocID.rfind(_T("/"));
return sDocID.Mid(iPos + 1);
}
