// Allow user to select a Fanart
void CGUIDialogVideoInfo::OnGetFanart()
{
CFileItemList items;
CFileItem item(*m_movieItem->GetVideoInfoTag());
if (item.HasArt("fanart"))
{
CFileItemPtr itemCurrent(new CFileItem("fanart://Current",false));
itemCurrent->SetArt("thumb", item.GetArt("fanart"));
itemCurrent->SetLabel(g_localizeStrings.Get(20440));
items.Add(itemCurrent);
}
// ensure the fanart is unpacked
m_movieItem->GetVideoInfoTag()->m_fanart.Unpack();
// Grab the thumbnails from the web
for (unsigned int i = 0; i < m_movieItem->GetVideoInfoTag()->m_fanart.GetNumFanarts(); i++)
{
CStdString strItemPath;
strItemPath.Format("fanart://Remote%i",i);
CFileItemPtr item(new CFileItem(strItemPath, false));
CStdString thumb = m_movieItem->GetVideoInfoTag()->m_fanart.GetPreviewURL(i);
item->SetArt("thumb", CTextureCache::GetWrappedThumbURL(thumb));
item->SetIconImage("DefaultPicture.png");
item->SetLabel(g_localizeStrings.Get(20441));
// TODO: Do we need to clear the cached image?
// CTextureCache::Get().ClearCachedImage(thumb);
items.Add(item);
}
CStdString strLocal = item.GetLocalFanart();
if (!strLocal.IsEmpty())
{
CFileItemPtr itemLocal(new CFileItem("fanart://Local",false));
itemLocal->SetArt("thumb", strLocal);
itemLocal->SetLabel(g_localizeStrings.Get(20438));
// TODO: Do we need to clear the cached image?
CTextureCache::Get().ClearCachedImage(strLocal);
items.Add(itemLocal);
}
else
{
CFileItemPtr itemNone(new CFileItem("fanart://None", false));
itemNone->SetIconImage("DefaultVideo.png");
itemNone->SetLabel(g_localizeStrings.Get(20439));
items.Add(itemNone);
}
CStdString result;
VECSOURCES sources(g_settings.m_videoSources);
g_mediaManager.GetLocalDrives(sources);
bool flip=false;
if (!CGUIDialogFileBrowser::ShowAndGetImage(items, sources, g_localizeStrings.Get(20437), result, &flip, 20445) || result.Equals("fanart://Current"))
return; // user cancelled
if (result.Equals("fanart://Local"))
result = strLocal;
if (result.Left(15) == "fanart://Remote")
{
int iFanart = atoi(result.Mid(15).c_str());
// set new primary fanart, and update our database accordingly
m_movieItem->GetVideoInfoTag()->m_fanart.SetPrimaryFanart(iFanart);
CVideoDatabase db;
if (db.Open())
{
db.UpdateFanart(*m_movieItem, (VIDEODB_CONTENT_TYPE)m_movieItem->GetVideoContentType());
db.Close();
}
result = m_movieItem->GetVideoInfoTag()->m_fanart.GetImageURL();
}
else if (result.Equals("fanart://None") || !CFile::Exists(result))
result.clear();
// set the fanart image
if (flip && !result.IsEmpty())
result = CTextureCache::GetWrappedImageURL(result, "", "flipped");
CVideoDatabase db;
if (db.Open())
{
db.SetArtForItem(m_movieItem->GetVideoInfoTag()->m_iDbId, m_movieItem->GetVideoInfoTag()->m_type, "fanart", result);
db.Close();
}
CUtil::DeleteVideoDatabaseDirectoryCache(); // to get them new thumbs to show
m_movieItem->SetArt("fanart", result);
m_hasUpdatedThumb = true;
// Update our screen
Update();
}
bool CRarManager::CacheRarredFile(CStdString& strPathInCache, const CStdString& strRarPath, const CStdString& strPathInRar, BYTE bOptions, const CStdString& strDir, const int64_t iSize)
{
#ifdef HAS_FILESYSTEM_RAR
CSingleLock lock(m_CritSection);
//If file is listed in the cache, then use listed copy or cleanup before overwriting.
bool bOverwrite = (bOptions & EXFILE_OVERWRITE) != 0;
map<CStdString, pair<ArchiveList_struct*,vector<CFileInfo> > >::iterator j = m_ExFiles.find( strRarPath );
CFileInfo* pFile=NULL;
if( j != m_ExFiles.end() )
{
pFile = GetFileInRar(strRarPath,strPathInRar);
if (pFile)
{
if (pFile->m_bIsCanceled())
return false;
if( CFile::Exists( pFile->m_strCachedPath) )
{
if( !bOverwrite )
{
strPathInCache = pFile->m_strCachedPath;
pFile->m_iUsed++;
return true;
}
CFile::Delete(pFile->m_strCachedPath);
pFile->m_iUsed++;
}
}
}
int iRes = 0;
if (iSize > EXTRACTION_WARN_SIZE)
{
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (pDialog)
{
pDialog->SetHeading(120);
pDialog->SetLine(0, 645);
pDialog->SetLine(1, URIUtils::GetFileName(strPathInRar));
pDialog->SetLine(2, "");
pDialog->DoModal();
if (!pDialog->IsConfirmed())
iRes = 2; // pretend to be canceled
}
}
if (CheckFreeSpace(strDir) < iSize && iRes != 2)
{
ClearCache();
if (CheckFreeSpace(strDir) < iSize)
{
CFileItemList items;
CDirectory::GetDirectory(g_advancedSettings.m_cachePath,items);
items.Sort(SortBySize, SortOrderDescending);
while (items.Size() && CheckFreeSpace(strDir) < iSize)
{
if (!items[0]->m_bIsFolder)
if (!CFile::Delete(items[0]->GetPath()))
break;
items.Remove(0);
}
if (!items.Size())
return false;
}
}
CStdString strPath = strPathInRar;
#ifndef TARGET_POSIX
StringUtils::Replace(strPath, '/', '\\');
#endif
//g_charsetConverter.unknownToUTF8(strPath);
CStdString strCachedPath = URIUtils::AddFileToFolder(strDir + "rarfolder%04d",
URIUtils::GetFileName(strPathInRar));
strCachedPath = CUtil::GetNextPathname(strCachedPath, 9999);
if (strCachedPath.empty())
{
CLog::Log(LOGWARNING, "Could not cache file %s", (strRarPath + strPathInRar).c_str());
return false;
}
strCachedPath = CUtil::MakeLegalPath(strCachedPath);
int64_t iOffset = -1;
if (iRes != 2)
{
if (pFile)
{
if (pFile->m_iOffset != -1)
iOffset = pFile->m_iOffset;
}
if (iOffset == -1 && j != m_ExFiles.end()) // grab from list
{
for( ArchiveList_struct* pIterator = j->second.first; pIterator ; pIterator ? pIterator = pIterator->next : NULL)
{
CStdString strName;
/* convert to utf8 */
if( pIterator->item.NameW && wcslen(pIterator->item.NameW) > 0)
g_charsetConverter.wToUTF8(pIterator->item.NameW, strName);
else
g_charsetConverter.unknownToUTF8(pIterator->item.Name, strName);
if (strName.Equals(strPath))
{
iOffset = pIterator->item.iOffset;
break;
}
}
}
bool bShowProgress=false;
if (iSize > 1024*1024 || iSize == -2) // 1MB
bShowProgress=true;
CStdString strDir2 = URIUtils::GetDirectory(strCachedPath);
URIUtils::RemoveSlashAtEnd(strDir2);
if (!CDirectory::Exists(strDir2))
CDirectory::Create(strDir2);
iRes = urarlib_get(const_cast<char*>(strRarPath.c_str()), const_cast<char*>(strDir2.c_str()),
const_cast<char*>(strPath.c_str()),NULL,&iOffset,bShowProgress);
}
if (iRes == 0)
{
CLog::Log(LOGERROR,"failed to extract file: %s",strPathInRar.c_str());
return false;
}
if(!pFile)
{
CFileInfo fileInfo;
fileInfo.m_strPathInRar = strPathInRar;
if (j == m_ExFiles.end())
{
ArchiveList_struct* pArchiveList;
if(ListArchive(strRarPath,pArchiveList))
{
m_ExFiles.insert(make_pair(strRarPath,make_pair(pArchiveList,vector<CFileInfo>())));
j = m_ExFiles.find(strRarPath);
}
else
return false;
}
j->second.second.push_back(fileInfo);
pFile = &(j->second.second[j->second.second.size()-1]);
pFile->m_iUsed = 1;
}
pFile->m_strCachedPath = strCachedPath;
pFile->m_bAutoDel = (bOptions & EXFILE_AUTODELETE) != 0;
pFile->m_iOffset = iOffset;
strPathInCache = pFile->m_strCachedPath;
if (iRes == 2) //canceled
{
pFile->watch.StartZero();
CFile::Delete(pFile->m_strCachedPath);
return false;
}
#endif
return true;
}
uint32_t CButtonTranslator::TranslateRemoteString(const char *szButton)
{
if (!szButton)
return 0;
uint32_t buttonCode = 0;
CStdString strButton = szButton;
strButton.ToLower();
if (strButton.Equals("left")) buttonCode = XINPUT_IR_REMOTE_LEFT;
else if (strButton.Equals("right")) buttonCode = XINPUT_IR_REMOTE_RIGHT;
else if (strButton.Equals("up")) buttonCode = XINPUT_IR_REMOTE_UP;
else if (strButton.Equals("down")) buttonCode = XINPUT_IR_REMOTE_DOWN;
else if (strButton.Equals("select")) buttonCode = XINPUT_IR_REMOTE_SELECT;
else if (strButton.Equals("back")) buttonCode = XINPUT_IR_REMOTE_BACK;
else if (strButton.Equals("menu")) buttonCode = XINPUT_IR_REMOTE_MENU;
else if (strButton.Equals("info")) buttonCode = XINPUT_IR_REMOTE_INFO;
else if (strButton.Equals("display")) buttonCode = XINPUT_IR_REMOTE_DISPLAY;
else if (strButton.Equals("title")) buttonCode = XINPUT_IR_REMOTE_TITLE;
else if (strButton.Equals("play")) buttonCode = XINPUT_IR_REMOTE_PLAY;
else if (strButton.Equals("pause")) buttonCode = XINPUT_IR_REMOTE_PAUSE;
else if (strButton.Equals("reverse")) buttonCode = XINPUT_IR_REMOTE_REVERSE;
else if (strButton.Equals("forward")) buttonCode = XINPUT_IR_REMOTE_FORWARD;
else if (strButton.Equals("skipplus")) buttonCode = XINPUT_IR_REMOTE_SKIP_PLUS;
else if (strButton.Equals("skipminus")) buttonCode = XINPUT_IR_REMOTE_SKIP_MINUS;
else if (strButton.Equals("stop")) buttonCode = XINPUT_IR_REMOTE_STOP;
else if (strButton.Equals("zero")) buttonCode = XINPUT_IR_REMOTE_0;
else if (strButton.Equals("one")) buttonCode = XINPUT_IR_REMOTE_1;
else if (strButton.Equals("two")) buttonCode = XINPUT_IR_REMOTE_2;
else if (strButton.Equals("three")) buttonCode = XINPUT_IR_REMOTE_3;
else if (strButton.Equals("four")) buttonCode = XINPUT_IR_REMOTE_4;
else if (strButton.Equals("five")) buttonCode = XINPUT_IR_REMOTE_5;
else if (strButton.Equals("six")) buttonCode = XINPUT_IR_REMOTE_6;
else if (strButton.Equals("seven")) buttonCode = XINPUT_IR_REMOTE_7;
else if (strButton.Equals("eight")) buttonCode = XINPUT_IR_REMOTE_8;
else if (strButton.Equals("nine")) buttonCode = XINPUT_IR_REMOTE_9;
// additional keys from the media center extender for xbox remote
else if (strButton.Equals("power")) buttonCode = XINPUT_IR_REMOTE_POWER;
else if (strButton.Equals("mytv")) buttonCode = XINPUT_IR_REMOTE_MY_TV;
else if (strButton.Equals("mymusic")) buttonCode = XINPUT_IR_REMOTE_MY_MUSIC;
else if (strButton.Equals("mypictures")) buttonCode = XINPUT_IR_REMOTE_MY_PICTURES;
else if (strButton.Equals("myvideo")) buttonCode = XINPUT_IR_REMOTE_MY_VIDEOS;
else if (strButton.Equals("record")) buttonCode = XINPUT_IR_REMOTE_RECORD;
else if (strButton.Equals("start")) buttonCode = XINPUT_IR_REMOTE_START;
else if (strButton.Equals("volumeplus")) buttonCode = XINPUT_IR_REMOTE_VOLUME_PLUS;
else if (strButton.Equals("volumeminus")) buttonCode = XINPUT_IR_REMOTE_VOLUME_MINUS;
else if (strButton.Equals("channelplus")) buttonCode = XINPUT_IR_REMOTE_CHANNEL_PLUS;
else if (strButton.Equals("channelminus")) buttonCode = XINPUT_IR_REMOTE_CHANNEL_MINUS;
else if (strButton.Equals("pageplus")) buttonCode = XINPUT_IR_REMOTE_CHANNEL_PLUS;
else if (strButton.Equals("pageminus")) buttonCode = XINPUT_IR_REMOTE_CHANNEL_MINUS;
else if (strButton.Equals("mute")) buttonCode = XINPUT_IR_REMOTE_MUTE;
else if (strButton.Equals("recordedtv")) buttonCode = XINPUT_IR_REMOTE_RECORDED_TV;
else if (strButton.Equals("guide")) buttonCode = XINPUT_IR_REMOTE_TITLE; // same as title
else if (strButton.Equals("livetv")) buttonCode = XINPUT_IR_REMOTE_LIVE_TV;
else if (strButton.Equals("star")) buttonCode = XINPUT_IR_REMOTE_STAR;
else if (strButton.Equals("hash")) buttonCode = XINPUT_IR_REMOTE_HASH;
else if (strButton.Equals("clear")) buttonCode = XINPUT_IR_REMOTE_CLEAR;
else if (strButton.Equals("enter")) buttonCode = XINPUT_IR_REMOTE_ENTER;
else if (strButton.Equals("xbox")) buttonCode = XINPUT_IR_REMOTE_DISPLAY; // same as display
else if (strButton.Equals("teletext")) buttonCode = XINPUT_IR_REMOTE_TELETEXT;
else if (strButton.Equals("red")) buttonCode = XINPUT_IR_REMOTE_RED;
else if (strButton.Equals("green")) buttonCode = XINPUT_IR_REMOTE_GREEN;
else if (strButton.Equals("yellow")) buttonCode = XINPUT_IR_REMOTE_YELLOW;
else if (strButton.Equals("blue")) buttonCode = XINPUT_IR_REMOTE_BLUE;
else if (strButton.Equals("subtitle")) buttonCode = XINPUT_IR_REMOTE_SUBTITLE;
else if (strButton.Equals("language")) buttonCode = XINPUT_IR_REMOTE_LANGUAGE;
else CLog::Log(LOGERROR, "Remote Translator: Can't find button %s", strButton.c_str());
return buttonCode;
}
bool CShoutcastDirectory::GetDirectory(const CStdString& strPath, CFileItemList &items)
{
CStdString strRoot = strPath;
if (CUtil::HasSlashAtEnd(strRoot))
strRoot.Delete(strRoot.size() - 1);
/* for old users wich doesn't have the full url */
if( strRoot.Equals("shout://www.shoutcast.com") )
strRoot = "shout://www.shoutcast.com/sbin/newxml.phtml";
if (g_directoryCache.GetDirectory(strRoot, items))
return true;
CGUIDialogProgress* dlgProgress = (CGUIDialogProgress*)m_gWindowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
if (dlgProgress)
{
dlgProgress->ShowProgressBar(false);
dlgProgress->SetHeading(260);
dlgProgress->SetLine(0, 14003);
dlgProgress->SetLine(1, "");
dlgProgress->SetLine(2, "");
dlgProgress->StartModal();
}
CURL url(strRoot);
CStdString protocol = url.GetProtocol();
url.SetProtocol("http");
CFileCurl http;
//CURL doesn't seem to understand that data is encoded.. odd
// opening as text for now
//http.SetContentEncoding("deflate");
if( !http.Open(url, false) )
{
CLog::Log(LOGERROR, "%s - Unable to get shoutcast dir", __FUNCTION__);
if (dlgProgress) dlgProgress->Close();
return false;
}
/* restore protocol */
url.SetProtocol(protocol);
CStdString content = http.GetContent();
if( !(content.Equals("text/html") || content.Equals("text/xml")
|| content.Equals("text/html;charset=utf-8") || content.Equals("text/xml;charset=utf-8") ))
{
CLog::Log(LOGERROR, "%s - Invalid content type %s", __FUNCTION__, content.c_str());
if (dlgProgress) dlgProgress->Close();
return false;
}
int size_read = 0;
int size_total = (int)http.GetLength();
int data_size = 0;
CStdString data;
data.reserve(size_total);
/* read response from server into string buffer */
char buffer[16384];
while( (size_read = http.Read(buffer, sizeof(buffer)-1)) > 0 )
{
buffer[size_read] = 0;
data += buffer;
data_size += size_read;
dlgProgress->Progress();
if (dlgProgress->IsCanceled())
{
dlgProgress->Close();
return false;
}
}
/* parse returned xml */
TiXmlDocument doc;
doc.Parse(data.c_str());
TiXmlElement *root = doc.RootElement();
if(root == NULL)
{
CLog::Log(LOGERROR, "%s - Unable to parse xml", __FUNCTION__);
CLog::Log(LOGDEBUG, "%s - Sample follows...\n%s", __FUNCTION__, data.c_str());
dlgProgress->Close();
return false;
}
/* clear data to keep memusage down, not needed anymore */
data.Empty();
bool result = false;
if( strcmp(root->Value(), "genrelist") == 0 )
result = ParseGenres(root, items, url);
else if( strcmp(root->Value(), "stationlist") == 0 )
result = ParseStations(root, items, url);
else
{
CLog::Log(LOGERROR, "%s - Invalid root xml element for shoutcast",__FUNCTION__);
CLog::Log(LOGDEBUG, "%s - Sample follows...\n%s", __FUNCTION__, data.c_str());
}
CFileItemList vecCacheItems;
g_directoryCache.ClearDirectory(strRoot);
for( int i = 0; i <items.Size(); i++ )
{
CFileItem* pItem=items[i];
if (!pItem->IsParentFolder())
vecCacheItems.Add(new CFileItem( *pItem ));
}
g_directoryCache.SetDirectory(strRoot, vecCacheItems);
if (dlgProgress) dlgProgress->Close();
return result;
}
// Allow user to select a Fanart
void CGUIDialogMusicInfo::OnGetFanart()
{
CFileItemList items;
CStdString cachedThumb(CThumbnailCache::GetThumb(m_artist.strArtist,g_settings.GetMusicFanartFolder()));
if (CFile::Exists(cachedThumb))
{
CFileItemPtr itemCurrent(new CFileItem("fanart://Current",false));
itemCurrent->SetThumbnailImage(cachedThumb);
itemCurrent->SetLabel(g_localizeStrings.Get(20440));
items.Add(itemCurrent);
}
// Grab the thumbnails from the web
for (unsigned int i = 0; i < m_artist.fanart.GetNumFanarts(); i++)
{
CStdString strItemPath;
strItemPath.Format("fanart://Remote%i",i);
CFileItemPtr item(new CFileItem(strItemPath, false));
CStdString thumb = m_artist.fanart.GetPreviewURL(i);
item->SetThumbnailImage(CTextureCache::GetWrappedThumbURL(thumb));
item->SetIconImage("DefaultPicture.png");
item->SetLabel(g_localizeStrings.Get(20441));
// TODO: Do we need to clear the cached image?
// CTextureCache::Get().ClearCachedImage(thumb);
items.Add(item);
}
// Grab a local thumb
CMusicDatabase database;
database.Open();
CStdString strArtistPath;
database.GetArtistPath(m_artist.idArtist,strArtistPath);
CFileItem item(strArtistPath,true);
CStdString strLocal = item.GetLocalFanart();
if (!strLocal.IsEmpty())
{
CFileItemPtr itemLocal(new CFileItem("fanart://Local",false));
itemLocal->SetThumbnailImage(strLocal);
itemLocal->SetLabel(g_localizeStrings.Get(20438));
// TODO: Do we need to clear the cached image?
CTextureCache::Get().ClearCachedImage(strLocal);
items.Add(itemLocal);
}
else
{
CFileItemPtr itemNone(new CFileItem("fanart://None", false));
itemNone->SetIconImage("DefaultArtist.png");
itemNone->SetLabel(g_localizeStrings.Get(20439));
items.Add(itemNone);
}
CStdString result;
VECSOURCES sources(g_settings.m_musicSources);
g_mediaManager.GetLocalDrives(sources);
bool flip=false;
if (!CGUIDialogFileBrowser::ShowAndGetImage(items, sources, g_localizeStrings.Get(20437), result, &flip, 20445))
return; // user cancelled
// delete the thumbnail if that's what the user wants, else overwrite with the
// new thumbnail
if (result.Equals("fanart://Current"))
return;
if (result.Equals("fanart://Local"))
result = strLocal;
CTextureCache::Get().ClearCachedImage(cachedThumb, true);
if (!result.Equals("fanart://None"))
{ // local file
if (result.Left(15) == "fanart://Remote")
{
int iFanart = atoi(result.Mid(15).c_str());
m_artist.fanart.SetPrimaryFanart(iFanart);
// download the fullres fanart image
CStdString tempFile = "special://temp/fanart_download.jpg";
CAsyncFileCopy downloader;
if (!downloader.Copy(m_artist.fanart.GetImageURL(), tempFile, g_localizeStrings.Get(13413)))
return;
result = tempFile;
}
if (flip)
CPicture::ConvertFile(result, cachedThumb,0,1920,-1,100,true);
else
CPicture::CacheFanart(result, cachedThumb);
m_albumItem->SetProperty("fanart_image",cachedThumb);
m_hasUpdatedThumb = true;
}
// tell our GUI to completely reload all controls (as some of them
// are likely to have had this image in use so will need refreshing)
CGUIMessage msg(GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_REFRESH_THUMBS);
g_windowManager.SendMessage(msg);
// Update our screen
Update();
}
bool CLangInfo::Load(const std::string& strFileName, bool onlyCheckLanguage /*= false*/)
{
SetDefaults();
CXBMCTinyXML xmlDoc;
if (!xmlDoc.LoadFile(strFileName))
{
CLog::Log(onlyCheckLanguage ? LOGDEBUG : LOGERROR, "unable to load %s: %s at line %d", strFileName.c_str(), xmlDoc.ErrorDesc(), xmlDoc.ErrorRow());
return false;
}
TiXmlElement* pRootElement = xmlDoc.RootElement();
if (pRootElement->ValueStr() != "language")
{
CLog::Log(onlyCheckLanguage ? LOGDEBUG : LOGERROR, "%s Doesn't contain <language>", strFileName.c_str());
return false;
}
if (pRootElement->Attribute("locale"))
m_defaultRegion.m_strLangLocaleName = pRootElement->Attribute("locale");
#ifdef TARGET_WINDOWS
// Windows need 3 chars isolang code
if (m_defaultRegion.m_strLangLocaleName.length() == 2)
{
if (! g_LangCodeExpander.ConvertTwoToThreeCharCode(m_defaultRegion.m_strLangLocaleName, m_defaultRegion.m_strLangLocaleName, true))
m_defaultRegion.m_strLangLocaleName = "";
}
if (!g_LangCodeExpander.ConvertWindowsToGeneralCharCode(m_defaultRegion.m_strLangLocaleName, m_languageCodeGeneral))
m_languageCodeGeneral = "";
#else
if (m_defaultRegion.m_strLangLocaleName.length() != 3)
{
if (!g_LangCodeExpander.ConvertToThreeCharCode(m_languageCodeGeneral, m_defaultRegion.m_strLangLocaleName, !onlyCheckLanguage))
m_languageCodeGeneral = "";
}
else
m_languageCodeGeneral = m_defaultRegion.m_strLangLocaleName;
#endif
CStdString tmp;
if (g_LangCodeExpander.ConvertToTwoCharCode(tmp, m_defaultRegion.m_strLangLocaleName))
m_defaultRegion.m_strLangLocaleCodeTwoChar = tmp;
const TiXmlNode *pCharSets = pRootElement->FirstChild("charsets");
if (pCharSets && !pCharSets->NoChildren())
{
const TiXmlNode *pGui = pCharSets->FirstChild("gui");
if (pGui && !pGui->NoChildren())
{
CStdString strForceUnicodeFont = ((TiXmlElement*) pGui)->Attribute("unicodefont");
if (strForceUnicodeFont.Equals("true"))
m_defaultRegion.m_forceUnicodeFont=true;
m_defaultRegion.m_strGuiCharSet=pGui->FirstChild()->Value();
}
const TiXmlNode *pSubtitle = pCharSets->FirstChild("subtitle");
if (pSubtitle && !pSubtitle->NoChildren())
m_defaultRegion.m_strSubtitleCharSet=pSubtitle->FirstChild()->Value();
}
const TiXmlNode *pDVD = pRootElement->FirstChild("dvd");
if (pDVD && !pDVD->NoChildren())
{
const TiXmlNode *pMenu = pDVD->FirstChild("menu");
if (pMenu && !pMenu->NoChildren())
m_defaultRegion.m_strDVDMenuLanguage=pMenu->FirstChild()->Value();
const TiXmlNode *pAudio = pDVD->FirstChild("audio");
if (pAudio && !pAudio->NoChildren())
m_defaultRegion.m_strDVDAudioLanguage=pAudio->FirstChild()->Value();
const TiXmlNode *pSubtitle = pDVD->FirstChild("subtitle");
if (pSubtitle && !pSubtitle->NoChildren())
m_defaultRegion.m_strDVDSubtitleLanguage=pSubtitle->FirstChild()->Value();
}
const TiXmlNode *pRegions = pRootElement->FirstChild("regions");
if (pRegions && !pRegions->NoChildren())
{
const TiXmlElement *pRegion=pRegions->FirstChildElement("region");
while (pRegion)
{
CRegion region(m_defaultRegion);
region.m_strName=pRegion->Attribute("name");
if (region.m_strName.empty())
region.m_strName="N/A";
if (pRegion->Attribute("locale"))
region.m_strRegionLocaleName = pRegion->Attribute("locale");
#ifdef TARGET_WINDOWS
// Windows need 3 chars regions code
if (region.m_strRegionLocaleName.length() == 2)
{
if (! g_LangCodeExpander.ConvertLinuxToWindowsRegionCodes(region.m_strRegionLocaleName, region.m_strRegionLocaleName))
region.m_strRegionLocaleName = "";
}
#endif
const TiXmlNode *pDateLong=pRegion->FirstChild("datelong");
if (pDateLong && !pDateLong->NoChildren())
region.m_strDateFormatLong=pDateLong->FirstChild()->Value();
const TiXmlNode *pDateShort=pRegion->FirstChild("dateshort");
if (pDateShort && !pDateShort->NoChildren())
region.m_strDateFormatShort=pDateShort->FirstChild()->Value();
const TiXmlElement *pTime=pRegion->FirstChildElement("time");
if (pTime && !pTime->NoChildren())
{
region.m_strTimeFormat=pTime->FirstChild()->Value();
region.m_strMeridiemSymbols[MERIDIEM_SYMBOL_AM]=pTime->Attribute("symbolAM");
region.m_strMeridiemSymbols[MERIDIEM_SYMBOL_PM]=pTime->Attribute("symbolPM");
}
const TiXmlNode *pTempUnit=pRegion->FirstChild("tempunit");
if (pTempUnit && !pTempUnit->NoChildren())
region.SetTempUnit(pTempUnit->FirstChild()->Value());
const TiXmlNode *pSpeedUnit=pRegion->FirstChild("speedunit");
if (pSpeedUnit && !pSpeedUnit->NoChildren())
region.SetSpeedUnit(pSpeedUnit->FirstChild()->Value());
const TiXmlNode *pTimeZone=pRegion->FirstChild("timezone");
if (pTimeZone && !pTimeZone->NoChildren())
region.SetTimeZone(pTimeZone->FirstChild()->Value());
m_regions.insert(PAIR_REGIONS(region.m_strName, region));
pRegion=pRegion->NextSiblingElement("region");
}
if (!onlyCheckLanguage)
{
const CStdString& strName = CSettings::Get().GetString("locale.country");
SetCurrentRegion(strName);
}
}
g_charsetConverter.reinitCharsetsFromSettings();
if (!onlyCheckLanguage)
LoadTokens(pRootElement->FirstChild("sorttokens"), g_advancedSettings.m_vecTokens);
return true;
}
void CGUIDialogSubtitles::OnDownloadComplete(const CFileItemList *items, const std::string &language)
{
if (items->IsEmpty())
{
CFileItemPtr service = GetService();
if (service)
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, service->GetLabel(), g_localizeStrings.Get(24113));
UpdateStatus(SEARCH_COMPLETE);
return;
}
SUBTITLE_STORAGEMODE storageMode = (SUBTITLE_STORAGEMODE) CSettings::Get().GetInt("subtitles.storagemode");
// Get (unstacked) path
CStdString strCurrentFile = g_application.CurrentUnstackedItem().GetPath();
CStdString strDownloadPath = "special://temp";
CStdString strDestPath;
std::vector<std::string> vecFiles;
CStdString strCurrentFilePath;
if (StringUtils::StartsWith(strCurrentFilePath, "http://"))
{
strCurrentFile = "TempSubtitle";
vecFiles.push_back(strCurrentFile);
}
else
{
CStdString subPath = CSpecialProtocol::TranslatePath("special://subtitles");
if (!subPath.empty())
strDownloadPath = subPath;
/* Get item's folder for sub storage, special case for RAR/ZIP items
TODO: We need some way to avoid special casing this all over the place
for rar/zip (perhaps modify GetDirectory?)
*/
if (URIUtils::IsInRAR(strCurrentFile) || URIUtils::IsInZIP(strCurrentFile))
strCurrentFilePath = URIUtils::GetDirectory(CURL(strCurrentFile).GetHostName());
else
strCurrentFilePath = URIUtils::GetDirectory(strCurrentFile);
// Handle stacks
if (g_application.CurrentFileItem().IsStack() && items->Size() > 1)
{
CStackDirectory::GetPaths(g_application.CurrentFileItem().GetPath(), vecFiles);
// Make sure (stack) size is the same as the size of the items handed to us, else fallback to single item
if (items->Size() != (int) vecFiles.size())
{
vecFiles.clear();
vecFiles.push_back(strCurrentFile);
}
}
else
{
vecFiles.push_back(strCurrentFile);
}
if (storageMode == SUBTITLE_STORAGEMODE_MOVIEPATH &&
CUtil::SupportsWriteFileOperations(strCurrentFilePath))
{
strDestPath = strCurrentFilePath;
}
}
// Use fallback?
if (strDestPath.empty())
strDestPath = strDownloadPath;
// Extract the language and appropriate extension
CStdString strSubLang;
g_LangCodeExpander.ConvertToTwoCharCode(strSubLang, language);
// Iterate over all items to transfer
for (unsigned int i = 0; i < vecFiles.size() && i < (unsigned int) items->Size(); i++)
{
CStdString strUrl = items->Get(i)->GetPath();
CStdString strFileName = URIUtils::GetFileName(vecFiles[i]);
URIUtils::RemoveExtension(strFileName);
// construct subtitle path
CStdString strSubExt = URIUtils::GetExtension(strUrl);
CStdString strSubName = StringUtils::Format("%s.%s%s", strFileName.c_str(), strSubLang.c_str(), strSubExt.c_str());
// Handle URL encoding:
CStdString strDownloadFile = URIUtils::ChangeBasePath(strCurrentFilePath, strSubName, strDownloadPath);
CStdString strDestFile = strDownloadFile;
if (!CFile::Copy(strUrl, strDownloadFile))
{
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, strSubName, g_localizeStrings.Get(24113));
CLog::Log(LOGERROR, "%s - Saving of subtitle %s to %s failed", __FUNCTION__, strUrl.c_str(), strDownloadFile.c_str());
}
else
{
if (strDestPath != strDownloadPath)
{
// Handle URL encoding:
CStdString strTryDestFile = URIUtils::ChangeBasePath(strCurrentFilePath, strSubName, strDestPath);
/* Copy the file from temp to our final destination, if that fails fallback to download path
* (ie. special://subtitles or use special://temp). Note that after the first item strDownloadPath equals strDestpath
* so that all remaining items (including the .idx below) are copied directly to their final destination and thus all
* items end up in the same folder
*/
CLog::Log(LOGDEBUG, "%s - Saving subtitle %s to %s", __FUNCTION__, strDownloadFile.c_str(), strTryDestFile.c_str());
if (CFile::Copy(strDownloadFile, strTryDestFile))
{
CFile::Delete(strDownloadFile);
strDestFile = strTryDestFile;
strDownloadPath = strDestPath; // Update download path so all the other items get directly downloaded to our final destination
}
else
{
CLog::Log(LOGWARNING, "%s - Saving of subtitle %s to %s failed. Falling back to %s", __FUNCTION__, strDownloadFile.c_str(), strTryDestFile.c_str(), strDownloadPath.c_str());
strDestPath = strDownloadPath; // Copy failed, use fallback for the rest of the items
}
}
else
{
CLog::Log(LOGDEBUG, "%s - Saved subtitle %s to %s", __FUNCTION__, strUrl.c_str(), strDownloadFile.c_str());
}
// for ".sub" subtitles we check if ".idx" counterpart exists and copy that as well
if (strSubExt.Equals(".sub"))
{
strUrl = URIUtils::ReplaceExtension(strUrl, ".idx");
if(CFile::Exists(strUrl))
{
CStdString strSubNameIdx = StringUtils::Format("%s.%s.idx", strFileName.c_str(), strSubLang.c_str());
// Handle URL encoding:
strDestFile = URIUtils::ChangeBasePath(strCurrentFilePath, strSubNameIdx, strDestPath);
CFile::Copy(strUrl, strDestFile);
}
}
// Set sub for currently playing (stack) item
if (vecFiles[i] == strCurrentFile)
SetSubtitles(strDestFile);
}
}
// Close the window
Close();
}
bool CGUIWindowMusicSongs::OnMessage(CGUIMessage& message)
{
switch ( message.GetMessage() )
{
case GUI_MSG_WINDOW_DEINIT:
if (m_thumbLoader.IsLoading())
m_thumbLoader.StopThread();
break;
case GUI_MSG_WINDOW_INIT:
{
// removed the start window check from files view
// the window translator does it by using a virtual window id (5)
// check for a passed destination path
CStdString strDestination = message.GetStringParam();
if (!strDestination.IsEmpty())
{
message.SetStringParam("");
CLog::Log(LOGINFO, "Attempting to quickpath to: %s", strDestination.c_str());
m_history.ClearPathHistory();
}
// is this the first time the window is opened?
if (m_vecItems->m_strPath == "?" && strDestination.IsEmpty())
{
strDestination = g_settings.m_defaultMusicSource;
m_vecItems->m_strPath=strDestination;
CLog::Log(LOGINFO, "Attempting to default to: %s", strDestination.c_str());
}
// try to open the destination path
if (!strDestination.IsEmpty())
{
// open root
if (strDestination.Equals("$ROOT"))
{
m_vecItems->m_strPath = "";
CLog::Log(LOGINFO, " Success! Opening root listing.");
}
// open playlists location
else if (strDestination.Equals("$PLAYLISTS"))
{
m_vecItems->m_strPath = "special://musicplaylists/";
CLog::Log(LOGINFO, " Success! Opening destination path: %s", m_vecItems->m_strPath.c_str());
}
else
{
// default parameters if the jump fails
m_vecItems->m_strPath.Empty();
bool bIsSourceName = false;
SetupShares();
VECSOURCES shares;
m_rootDir.GetSources(shares);
int iIndex = CUtil::GetMatchingSource(strDestination, shares, bIsSourceName);
if (iIndex > -1)
{
bool unlocked = true;
if (iIndex < (int)shares.size() && shares[iIndex].m_iHasLock == 2)
{
CFileItem item(shares[iIndex]);
if (!g_passwordManager.IsItemUnlocked(&item,"music"))
{
m_vecItems->m_strPath = ""; // no u don't
unlocked = false;
CLog::Log(LOGINFO, " Failure! Failed to unlock destination path: %s", strDestination.c_str());
}
}
// set current directory to matching share
if (unlocked)
{
if (bIsSourceName)
m_vecItems->m_strPath=shares[iIndex].strPath;
else
m_vecItems->m_strPath=strDestination;
CLog::Log(LOGINFO, " Success! Opened destination path: %s (%s)", strDestination.c_str(), m_vecItems->m_strPath.c_str());
}
}
else
{
CLog::Log(LOGERROR, " Failed! Destination parameter (%s) does not match a valid source!", strDestination.c_str());
}
}
// check for network up
if (CUtil::IsRemote(m_vecItems->m_strPath) && !WaitForNetwork())
m_vecItems->m_strPath.Empty();
// need file filters or GetDirectory in SetHistoryPath fails
SetHistoryForPath(m_vecItems->m_strPath);
}
return CGUIWindowMusicBase::OnMessage(message);
}
break;
case GUI_MSG_DIRECTORY_SCANNED:
{
CFileItem directory(message.GetStringParam(), true);
// Only update thumb on a local drive
if (directory.IsHD())
{
CStdString strParent;
CUtil::GetParentPath(directory.m_strPath, strParent);
if (directory.m_strPath == m_vecItems->m_strPath || strParent == m_vecItems->m_strPath)
{
Update(m_vecItems->m_strPath);
}
}
}
break;
case GUI_MSG_NOTIFY_ALL:
{
if (message.GetParam1()==GUI_MSG_REMOVED_MEDIA)
DeleteRemoveableMediaDirectoryCache();
}
break;
case GUI_MSG_CLICKED:
{
int iControl = message.GetSenderId();
if (iControl == CONTROL_BTNPLAYLISTS)
{
if (!m_vecItems->m_strPath.Equals("special://musicplaylists/"))
Update("special://musicplaylists/");
}
else if (iControl == CONTROL_BTNSCAN)
{
OnScan(-1);
}
else if (iControl == CONTROL_BTNREC)
{
if (g_application.IsPlayingAudio() )
{
if (g_application.m_pPlayer->CanRecord() )
{
bool bIsRecording = g_application.m_pPlayer->IsRecording();
g_application.m_pPlayer->Record(!bIsRecording);
UpdateButtons();
}
}
}
else if (iControl == CONTROL_BTNRIP)
{
OnRipCD();
}
}
break;
}
return CGUIWindowMusicBase::OnMessage(message);
}
bool CFileItemHandler::ParseSortMethods(const CStdString &method, const bool &ignorethe, const CStdString &order, SORT_METHOD &sortmethod, SORT_ORDER &sortorder)
{
if (order.Equals("ascending"))
sortorder = SORT_ORDER_ASC;
else if (order.Equals("descending"))
sortorder = SORT_ORDER_DESC;
else
return false;
if (method.Equals("none"))
sortmethod = SORT_METHOD_NONE;
else if (method.Equals("label"))
sortmethod = ignorethe ? SORT_METHOD_LABEL_IGNORE_THE : SORT_METHOD_LABEL;
else if (method.Equals("date"))
sortmethod = SORT_METHOD_DATE;
else if (method.Equals("size"))
sortmethod = SORT_METHOD_SIZE;
else if (method.Equals("file"))
sortmethod = SORT_METHOD_FILE;
else if (method.Equals("drivetype"))
sortmethod = SORT_METHOD_DRIVE_TYPE;
else if (method.Equals("track"))
sortmethod = SORT_METHOD_TRACKNUM;
else if (method.Equals("duration"))
sortmethod = SORT_METHOD_DURATION;
else if (method.Equals("title"))
sortmethod = ignorethe ? SORT_METHOD_TITLE_IGNORE_THE : SORT_METHOD_TITLE;
else if (method.Equals("artist"))
sortmethod = ignorethe ? SORT_METHOD_ARTIST_IGNORE_THE : SORT_METHOD_ARTIST;
else if (method.Equals("album"))
sortmethod = ignorethe ? SORT_METHOD_ALBUM_IGNORE_THE : SORT_METHOD_ALBUM;
else if (method.Equals("genre"))
sortmethod = SORT_METHOD_GENRE;
else if (method.Equals("year"))
sortmethod = SORT_METHOD_YEAR;
else if (method.Equals("videorating"))
sortmethod = SORT_METHOD_VIDEO_RATING;
else if (method.Equals("programcount"))
sortmethod = SORT_METHOD_PROGRAM_COUNT;
else if (method.Equals("playlist"))
sortmethod = SORT_METHOD_PLAYLIST_ORDER;
else if (method.Equals("episode"))
sortmethod = SORT_METHOD_EPISODE;
else if (method.Equals("videotitle"))
sortmethod = SORT_METHOD_VIDEO_TITLE;
else if (method.Equals("sorttitle"))
sortmethod = ignorethe ? SORT_METHOD_VIDEO_SORT_TITLE_IGNORE_THE : SORT_METHOD_VIDEO_SORT_TITLE;
else if (method.Equals("productioncode"))
sortmethod = SORT_METHOD_PRODUCTIONCODE;
else if (method.Equals("songrating"))
sortmethod = SORT_METHOD_SONG_RATING;
else if (method.Equals("mpaarating"))
sortmethod = SORT_METHOD_MPAA_RATING;
else if (method.Equals("videoruntime"))
sortmethod = SORT_METHOD_VIDEO_RUNTIME;
else if (method.Equals("studio"))
sortmethod = ignorethe ? SORT_METHOD_STUDIO_IGNORE_THE : SORT_METHOD_STUDIO;
else if (method.Equals("fullpath"))
sortmethod = SORT_METHOD_FULLPATH;
else if (method.Equals("lastplayed"))
sortmethod = SORT_METHOD_LASTPLAYED;
else if (method.Equals("playcount"))
sortmethod = SORT_METHOD_PLAYCOUNT;
else if (method.Equals("unsorted"))
sortmethod = SORT_METHOD_UNSORTED;
else if (method.Equals("max"))
sortmethod = SORT_METHOD_MAX;
else
return false;
return true;
}
void CGUIWindowMusicNav::SetThumb(int iItem, CONTEXT_BUTTON button)
{
CFileItem* pItem = m_vecItems->Get(iItem);
CFileItemList items;
CStdString picturePath;
CStdString strPath=pItem->m_strPath;
CStdString strThumb;
CStdString cachedThumb;
if (button == CONTEXT_BUTTON_SET_ARTIST_THUMB)
{
long idArtist = -1;
if (pItem->IsMusicDb())
{
CUtil::RemoveSlashAtEnd(strPath);
int nPos=strPath.ReverseFind("/");
if (nPos>-1)
{
// try to guess where the user should start
// browsing for the artist thumb
idArtist=atol(strPath.Mid(nPos+1));
}
}
else if (pItem->IsVideoDb())
idArtist = m_musicdatabase.GetArtistByName(pItem->GetLabel());
m_musicdatabase.GetArtistPath(idArtist, picturePath);
cachedThumb = pItem->GetCachedArtistThumb();
CArtist artist;
m_musicdatabase.GetArtistInfo(idArtist,artist);
int i=1;
for (std::vector<CScraperUrl::SUrlEntry>::iterator iter=artist.thumbURL.m_url.begin();iter != artist.thumbURL.m_url.end();++iter)
{
CStdString thumbFromWeb;
CStdString strLabel;
strLabel.Format("allmusicthumb%i.jpg",i);
CUtil::AddFileToFolder("z:\\", strLabel, thumbFromWeb);
if (CScraperUrl::DownloadThumbnail(thumbFromWeb,*iter))
{
CStdString strItemPath;
strItemPath.Format("thumb://Remote%i",i++);
CFileItem *item = new CFileItem(strItemPath, false);
item->SetThumbnailImage(thumbFromWeb);
CStdString strLabel;
item->SetLabel(g_localizeStrings.Get(20015));
items.Add(item);
}
}
}
else
{
strPath = m_vecItems->Get(iItem)->m_strPath;
strPath.Replace("plugin://music/","Q:\\plugins\\music\\");
strPath.Replace("/","\\");
picturePath = strPath;
CFileItem item(strPath,true);
cachedThumb = item.GetCachedProgramThumb();
}
if (XFILE::CFile::Exists(cachedThumb))
{
CFileItem *item = new CFileItem("thumb://Current", false);
item->SetThumbnailImage(cachedThumb);
item->SetLabel(g_localizeStrings.Get(20016));
items.Add(item);
}
if (button == CONTEXT_BUTTON_SET_PLUGIN_THUMB)
{
if (items.Size() == 0)
{
CFileItem item2(strPath,false);
CUtil::AddFileToFolder(strPath,"default.py",item2.m_strPath);
if (XFILE::CFile::Exists(item2.GetCachedProgramThumb()))
{
CFileItem *item = new CFileItem("thumb://Current", false);
item->SetThumbnailImage(item2.GetCachedProgramThumb());
item->SetLabel(g_localizeStrings.Get(20016));
items.Add(item);
}
}
CUtil::AddFileToFolder(strPath,"default.tbn",strThumb);
if (XFILE::CFile::Exists(strThumb))
{
CFileItem* item = new CFileItem(strThumb,false);
item->SetThumbnailImage(strThumb);
item->SetLabel(g_localizeStrings.Get(20017));
items.Add(item);
}
}
CUtil::AddFileToFolder(picturePath,"folder.jpg",strThumb);
if (XFILE::CFile::Exists(strThumb))
{
CFileItem* pItem = new CFileItem(strThumb,false);
pItem->SetLabel(g_localizeStrings.Get(20017));
pItem->SetThumbnailImage(strThumb);
items.Add(pItem);
}
CFileItem* nItem = new CFileItem("thumb://None",false);
nItem->SetLabel(g_localizeStrings.Get(20018));
if (button == CONTEXT_BUTTON_SET_ARTIST_THUMB)
nItem->SetThumbnailImage("DefaultArtistBig.png");
else
nItem->SetThumbnailImage("DefaultFolderBig.png");
items.Add(nItem);
if (CGUIDialogFileBrowser::ShowAndGetImage(items, g_settings.m_musicSources,
g_localizeStrings.Get(20019), picturePath))
{
CPicture picture;
if (picturePath.Equals("thumb://Current"))
return;
if (picturePath.Equals("thumb://None"))
{
XFILE::CFile::Delete(cachedThumb);
if (button == CONTEXT_BUTTON_SET_PLUGIN_THUMB)
{
CPicture picture;
picture.CacheSkinImage("DefaultFolderBig.png",cachedThumb);
CFileItem item2(strPath,false);
CUtil::AddFileToFolder(strPath,"default.py",item2.m_strPath);
XFILE::CFile::Delete(item2.GetCachedProgramThumb());
}
}
else if (button == CONTEXT_BUTTON_SET_PLUGIN_THUMB)
XFILE::CFile::Cache(picturePath,cachedThumb);
if (picturePath.Equals("thumb://None") ||
picture.DoCreateThumbnail(items.Get(picturePath)->GetThumbnailImage(), cachedThumb))
{
CMusicDatabaseDirectory dir;
dir.ClearDirectoryCache(m_vecItems->m_strPath);
CGUIMessage msg(GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_REFRESH_THUMBS);
g_graphicsContext.SendMessage(msg);
Update(m_vecItems->m_strPath);
}
else
CLog::Log(LOGERROR, " %s Could not cache artist/plugin thumb: %s", __FUNCTION__, picturePath.c_str());
}
}
bool CGUIWindowMusicNav::OnMessage(CGUIMessage& message)
{
switch (message.GetMessage())
{
case GUI_MSG_WINDOW_RESET:
m_vecItems->m_strPath = "?";
break;
case GUI_MSG_WINDOW_DEINIT:
if (m_thumbLoader.IsLoading())
m_thumbLoader.StopThread();
break;
case GUI_MSG_WINDOW_INIT:
{
/* We don't want to show Autosourced items (ie removable pendrives, memorycards) in Library mode */
m_rootDir.AllowNonLocalSources(false);
// check for valid quickpath parameter
CStdString strDestination = message.GetStringParam();
if (!strDestination.IsEmpty())
{
message.SetStringParam("");
CLog::Log(LOGINFO, "Attempting to quickpath to: %s", strDestination.c_str());
}
// is this the first time the window is opened?
if (m_vecItems->m_strPath == "?" && strDestination.IsEmpty())
{
strDestination = g_settings.m_defaultMusicLibSource;
m_vecItems->m_strPath = strDestination;
CLog::Log(LOGINFO, "Attempting to default to: %s", strDestination.c_str());
}
if (!strDestination.IsEmpty())
{
if (strDestination.Equals("$ROOT") || strDestination.Equals("Root"))
{
m_vecItems->m_strPath = "";
}
else if (strDestination.Equals("Genres"))
{
m_vecItems->m_strPath = "musicdb://1/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Artists"))
{
m_vecItems->m_strPath = "musicdb://2/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Albums"))
{
m_vecItems->m_strPath = "musicdb://3/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Songs"))
{
m_vecItems->m_strPath = "musicdb://4/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Top100"))
{
m_vecItems->m_strPath = "musicdb://5/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Top100Songs"))
{
m_vecItems->m_strPath = "musicdb://5/2/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Top100Albums"))
{
m_vecItems->m_strPath = "musicdb://5/1/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("RecentlyAddedAlbums"))
{
m_vecItems->m_strPath = "musicdb://6/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("RecentlyPlayedAlbums"))
{
m_vecItems->m_strPath = "musicdb://7/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Compilations"))
{
m_vecItems->m_strPath = "musicdb://8/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Playlists"))
{
m_vecItems->m_strPath = "special://musicplaylists/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Years"))
{
m_vecItems->m_strPath = "musicdb://9/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else if (strDestination.Equals("Plugins"))
{
m_vecItems->m_strPath = "plugin://music/";
SetHistoryForPath(m_vecItems->m_strPath);
}
else
{
CLog::Log(LOGWARNING, "Warning, destination parameter (%s) may not be valid", strDestination.c_str());
m_vecItems->m_strPath = strDestination;
SetHistoryForPath(m_vecItems->m_strPath);
break;
}
}
DisplayEmptyDatabaseMessage(false); // reset message state
if (!CGUIWindowMusicBase::OnMessage(message))
return false;
// base class has opened the database, do our check
DisplayEmptyDatabaseMessage(m_musicdatabase.GetSongsCount() <= 0);
if (m_bDisplayEmptyDatabaseMessage)
{
SET_CONTROL_FOCUS(CONTROL_BTNTYPE, 0);
Update(m_vecItems->m_strPath); // Will remove content from the list/thumb control
}
return true;
}
break;
case GUI_MSG_CLICKED:
{
int iControl = message.GetSenderId();
if (iControl == CONTROL_BTNPARTYMODE)
{
if (g_partyModeManager.IsEnabled())
g_partyModeManager.Disable();
else
{
if (!g_partyModeManager.Enable())
{
SET_CONTROL_SELECTED(GetID(),CONTROL_BTNPARTYMODE,false);
return false;
}
// Playlist directory is the root of the playlist window
if (m_guiState.get()) m_guiState->SetPlaylistDirectory("playlistmusic://");
return true;
}
UpdateButtons();
}
else if (iControl == CONTROL_BTNMANUALINFO)
{
OnManualAlbumInfo();
return true;
}
else if (iControl == CONTROL_BTN_FILTER)
{
CGUIDialogKeyboard::ShowAndGetFilter(m_filter, false);
return true;
}
else if (iControl == CONTROL_BTNSEARCH)
{
OnSearch();
return true;
}
}
break;
case GUI_MSG_PLAYBACK_STOPPED:
case GUI_MSG_PLAYBACK_ENDED:
case GUI_MSG_PLAYLISTPLAYER_STOPPED:
case GUI_MSG_PLAYBACK_STARTED:
{
SET_CONTROL_SELECTED(GetID(),CONTROL_BTNPARTYMODE, g_partyModeManager.IsEnabled());
}
break;
case GUI_MSG_NOTIFY_ALL:
{
if (message.GetParam1() == GUI_MSG_FILTER_ITEMS && IsActive())
{
m_filter = message.GetStringParam();
m_filter.TrimLeft().ToLower();
OnFilterItems();
}
if (message.GetParam1() == GUI_MSG_SEARCH_UPDATE && IsActive())
{
m_search = message.GetStringParam();
CUtil::URLEncode(m_search);
if (!m_search.IsEmpty())
{
CStdString path = "musicsearch://" + m_search + "/";
m_history.ClearPathHistory();
Update(path);
}
}
}
}
return CGUIWindowMusicBase::OnMessage(message);
}
CStdString CGUIWindowMusicNav::GetQuickpathName(const CStdString& strPath) const
{
if (strPath.Equals("musicdb://1/"))
return "Genres";
else if (strPath.Equals("musicdb://2/"))
return "Artists";
else if (strPath.Equals("musicdb://3/"))
return "Albums";
else if (strPath.Equals("musicdb://4/"))
return "Songs";
else if (strPath.Equals("musicdb://5/"))
return "Top100";
else if (strPath.Equals("musicdb://5/2/"))
return "Top100Songs";
else if (strPath.Equals("musicdb://5/1/"))
return "Top100Albums";
else if (strPath.Equals("musicdb://6/"))
return "RecentlyAddedAlbums";
else if (strPath.Equals("musicdb://7/"))
return "RecentlyPlayedAlbums";
else if (strPath.Equals("musicdb://8/"))
return "Compilations";
else if (strPath.Equals("musicdb://9/"))
return "Years";
else if (strPath.Equals("special://musicplaylists/"))
return "Playlists";
else
{
CLog::Log(LOGERROR, " CGUIWindowMusicNav::GetQuickpathName: Unknown parameter (%s)", strPath.c_str());
return strPath;
}
}
// \brief Set window to a specific directory
// \param strDirectory The directory to be displayed in list/thumb control
// This function calls OnPrepareFileItems() and OnFinalizeFileItems()
bool CGUIMediaWindow::Update(const CStdString &strDirectory)
{
// TODO: OnInitWindow calls Update() before window path has been set properly.
if (strDirectory == "?")
return false;
// get selected item
int iItem = m_viewControl.GetSelectedItem();
CStdString strSelectedItem = "";
if (iItem >= 0 && iItem < m_vecItems->Size())
{
CFileItemPtr pItem = m_vecItems->Get(iItem);
if (!pItem->IsParentFolder())
{
GetDirectoryHistoryString(pItem.get(), strSelectedItem);
}
}
CStdString strOldDirectory = m_vecItems->m_strPath;
m_history.SetSelectedItem(strSelectedItem, strOldDirectory);
CFileItemList items;
if (!GetDirectory(strDirectory, items))
{
CLog::Log(LOGERROR,"CGUIMediaWindow::GetDirectory(%s) failed", strDirectory.c_str());
// if the directory is the same as the old directory, then we'll return
// false. Else, we assume we can get the previous directory
if (strDirectory.Equals(strOldDirectory))
return false;
// We assume, we can get the parent
// directory again, but we have to
// return false to be able to eg. show
// an error message.
CStdString strParentPath = m_history.GetParentPath();
m_history.RemoveParentPath();
Update(strParentPath);
return false;
}
if (items.GetLabel().IsEmpty())
items.SetLabel(CUtil::GetTitleFromPath(items.m_strPath, true));
ClearFileItems();
m_vecItems->Copy(items);
// if we're getting the root source listing
// make sure the path history is clean
if (strDirectory.IsEmpty())
m_history.ClearPathHistory();
int iWindow = GetID();
int showLabel = 0;
if (strDirectory.IsEmpty() && (iWindow == WINDOW_MUSIC_FILES ||
iWindow == WINDOW_FILES ||
iWindow == WINDOW_PICTURES ||
iWindow == WINDOW_PROGRAMS))
showLabel = 1026;
if (strDirectory.Equals("sources://video/"))
showLabel = 999;
if (showLabel && (m_vecItems->Size() == 0 || !m_guiState->DisableAddSourceButtons())) // add 'add source button'
{
CStdString strLabel = g_localizeStrings.Get(showLabel);
CFileItemPtr pItem(new CFileItem(strLabel));
pItem->m_strPath = "add";
pItem->SetIconImage("DefaultAddSource.png");
pItem->SetLabel(strLabel);
pItem->SetLabelPreformated(true);
pItem->m_bIsFolder = true;
pItem->SetSpecialSort(SORT_ON_BOTTOM);
m_vecItems->Add(pItem);
}
m_iLastControl = GetFocusedControlID();
// Ask the derived class if it wants to load additional info
// for the fileitems like media info or additional
// filtering on the items, setting thumbs.
OnPrepareFileItems(*m_vecItems);
m_vecItems->FillInDefaultIcons();
m_guiState.reset(CGUIViewState::GetViewState(GetID(), *m_vecItems));
FormatAndSort(*m_vecItems);
// Ask the devived class if it wants to do custom list operations,
// eg. changing the label
OnFinalizeFileItems(*m_vecItems);
UpdateButtons();
m_viewControl.SetItems(*m_vecItems);
strSelectedItem = m_history.GetSelectedItem(m_vecItems->m_strPath);
bool bSelectedFound = false;
//int iSongInDirectory = -1;
for (int i = 0; i < m_vecItems->Size(); ++i)
{
CFileItemPtr pItem = m_vecItems->Get(i);
// Update selected item
if (!bSelectedFound)
{
CStdString strHistory;
GetDirectoryHistoryString(pItem.get(), strHistory);
if (strHistory == strSelectedItem)
{
m_viewControl.SetSelectedItem(i);
bSelectedFound = true;
}
}
}
// if we haven't found the selected item, select the first item
if (!bSelectedFound)
m_viewControl.SetSelectedItem(0);
m_history.AddPath(m_vecItems->m_strPath);
//m_history.DumpPathHistory();
return true;
}
CStdString CGUIMediaWindow::GetStartFolder(const CStdString &dir)
{
if (dir.Equals("$ROOT") || dir.Equals("Root"))
return "";
return dir;
}
JSONRPC_STATUS CFileOperations::GetDirectory(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CStdString media = parameterObject["media"].asString();
media = media.ToLower();
CFileItemList items;
CStdString strPath = parameterObject["directory"].asString();
if (!CFileUtils::RemoteAccessAllowed(strPath))
return InvalidParams;
CStdStringArray regexps;
CStdString extensions = "";
if (media.Equals("video"))
{
regexps = g_advancedSettings.m_videoExcludeFromListingRegExps;
extensions = g_advancedSettings.m_videoExtensions;
}
else if (media.Equals("music"))
{
regexps = g_advancedSettings.m_audioExcludeFromListingRegExps;
extensions = g_advancedSettings.m_musicExtensions;
}
else if (media.Equals("pictures"))
{
regexps = g_advancedSettings.m_pictureExcludeFromListingRegExps;
extensions = g_advancedSettings.m_pictureExtensions;
}
if (CDirectory::GetDirectory(strPath, items, extensions))
{
CFileItemList filteredFiles;
for (unsigned int i = 0; i < (unsigned int)items.Size(); i++)
{
if (CUtil::ExcludeFileOrFolder(items[i]->GetPath(), regexps))
continue;
if (items[i]->IsSmb())
{
CURL url(items[i]->GetPath());
items[i]->SetPath(url.GetWithoutUserDetails());
}
if ((media == "video" && items[i]->HasVideoInfoTag()) ||
(media == "music" && items[i]->HasMusicInfoTag()) ||
(media == "picture" && items[i]->HasPictureInfoTag()) ||
media == "files" ||
URIUtils::IsUPnP(items.GetPath()))
filteredFiles.Add(items[i]);
else
{
CFileItemPtr fileItem(new CFileItem());
if (FillFileItem(items[i], fileItem, media, parameterObject))
filteredFiles.Add(fileItem);
else
filteredFiles.Add(items[i]);
}
}
// Check if the "properties" list exists
// and make sure it contains the "file" and "filetype"
// fields
CVariant param = parameterObject;
if (!param.isMember("properties"))
param["properties"] = CVariant(CVariant::VariantTypeArray);
bool hasFileField = false;
for (CVariant::const_iterator_array itr = param["properties"].begin_array(); itr != param["properties"].end_array(); itr++)
{
if (itr->asString().compare("file") == 0)
{
hasFileField = true;
break;
}
}
if (!hasFileField)
param["properties"].append("file");
param["properties"].append("filetype");
HandleFileItemList("id", true, "files", filteredFiles, param, result);
return OK;
}
return InvalidParams;
}
void CGUIDialogProfileSettings::OnSettingChanged(SettingInfo &setting)
{
// check and update anything that needs it
if (setting.id == 1)
{
if (CGUIKeyboardFactory::ShowAndGetInput(m_strName,g_localizeStrings.Get(20093),false))
{
m_bNeedSave = true;
SET_CONTROL_LABEL(1000,m_strName);
}
}
if (setting.id == 2)
{
CStdString strThumb;
VECSOURCES shares;
g_mediaManager.GetLocalDrives(shares);
CFileItemList items;
if (!m_strThumb.IsEmpty())
{
CFileItemPtr item(new CFileItem("thumb://Current", false));
item->SetArt("thumb", m_strThumb);
item->SetLabel(g_localizeStrings.Get(20016));
items.Add(item);
}
CFileItemPtr item(new CFileItem("thumb://None", false));
item->SetArt("thumb", m_strDefaultImage);
item->SetLabel(g_localizeStrings.Get(20018));
items.Add(item);
if (CGUIDialogFileBrowser::ShowAndGetImage(items,shares,g_localizeStrings.Get(1030),strThumb) &&
!strThumb.Equals("thumb://Current"))
{
m_bNeedSave = true;
m_strThumb = strThumb.Equals("thumb://None") ? "" : strThumb;
CGUIImage *pImage = (CGUIImage*)GetControl(2);
if (pImage)
{
pImage->SetFileName("");
pImage->SetInvalid();
pImage->SetFileName(!m_strThumb.IsEmpty() ? m_strThumb : m_strDefaultImage);
}
}
}
if (setting.id == 3)
{
if (OnProfilePath(m_strDirectory, m_bIsDefault))
{
m_bNeedSave = true;
SET_CONTROL_LABEL(1001,m_strDirectory);
}
}
if (setting.id == 4)
{
if (m_bShowDetails)
{
if (CProfilesManager::Get().GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE && !m_bIsDefault)
{
if (CGUIDialogYesNo::ShowAndGetInput(20066,20118,20119,20022))
g_passwordManager.SetMasterLockMode(false);
if (CProfilesManager::Get().GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE)
return;
}
if (CGUIDialogLockSettings::ShowAndGetLock(m_locks, m_bIsDefault ? 12360 : 20068, CProfilesManager::Get().GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE || m_bIsDefault))
m_bNeedSave = true;
}
else
{
if (CGUIDialogLockSettings::ShowAndGetLock(m_locks, m_bIsDefault ? 12360 : 20068, false, false))
m_bNeedSave = true;
}
}
if (setting.id > 4)
m_bNeedSave = true;
}
void CLangInfo::CRegion::SetSpeedUnit(const CStdString& strUnit)
{
if (strUnit.Equals("kmh"))
m_speedUnit=SPEED_UNIT_KMH;
else if (strUnit.Equals("mpmin"))
m_speedUnit=SPEED_UNIT_MPMIN;
else if (strUnit.Equals("mps"))
m_speedUnit=SPEED_UNIT_MPS;
else if (strUnit.Equals("fth"))
m_speedUnit=SPEED_UNIT_FTH;
else if (strUnit.Equals("ftm"))
m_speedUnit=SPEED_UNIT_FTMIN;
else if (strUnit.Equals("fts"))
m_speedUnit=SPEED_UNIT_FTS;
else if (strUnit.Equals("mph"))
m_speedUnit=SPEED_UNIT_MPH;
else if (strUnit.Equals("kts"))
m_speedUnit=SPEED_UNIT_KTS;
else if (strUnit.Equals("beaufort"))
m_speedUnit=SPEED_UNIT_BEAUFORT;
else if (strUnit.Equals("inchs"))
m_speedUnit=SPEED_UNIT_INCHPS;
else if (strUnit.Equals("yards"))
m_speedUnit=SPEED_UNIT_YARDPS;
else if (strUnit.Equals("fpf"))
m_speedUnit=SPEED_UNIT_FPF;
}
JSONRPC_STATUS CPlayerOperations::GetPropertyValue(PlayerType player, const CStdString &property, CVariant &result)
{
if (player == None)
return FailedToExecute;
int playlist = GetPlaylist(player);
if (property.Equals("type"))
{
switch (player)
{
case Video:
result = "video";
break;
case Audio:
result = "audio";
break;
case Picture:
result = "picture";
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("partymode"))
{
switch (player)
{
case Video:
case Audio:
if (IsPVRChannel())
{
result = false;
break;
}
result = g_partyModeManager.IsEnabled();
break;
case Picture:
result = false;
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("speed"))
{
CGUIWindowSlideShow *slideshow = NULL;
switch (player)
{
case Video:
case Audio:
result = g_application.IsPaused() ? 0 : g_application.GetPlaySpeed();
break;
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow && slideshow->IsPlaying() && !slideshow->IsPaused())
result = slideshow->GetDirection();
else
result = 0;
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("time"))
{
switch (player)
{
case Video:
case Audio:
{
int ms = 0;
if (!IsPVRChannel())
ms = (int)(g_application.GetTime() * 1000.0);
else
{
EPG::CEpgInfoTag epg;
if (GetCurrentEpg(epg))
ms = epg.Progress() * 1000;
}
MillisecondsToTimeObject(ms, result);
break;
}
case Picture:
MillisecondsToTimeObject(0, result);
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("percentage"))
{
CGUIWindowSlideShow *slideshow = NULL;
switch (player)
{
case Video:
case Audio:
{
if (!IsPVRChannel())
result = g_application.GetPercentage();
else
{
EPG::CEpgInfoTag epg;
if (GetCurrentEpg(epg))
result = epg.ProgressPercentage();
else
result = 0;
}
break;
}
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow && slideshow->NumSlides() > 0)
result = (double)slideshow->CurrentSlide() / slideshow->NumSlides();
else
result = 0.0;
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("totaltime"))
{
switch (player)
{
case Video:
case Audio:
{
int ms = 0;
if (!IsPVRChannel())
ms = (int)(g_application.GetTotalTime() * 1000.0);
else
{
EPG::CEpgInfoTag epg;
if (GetCurrentEpg(epg))
ms = epg.GetDuration() * 1000;
}
MillisecondsToTimeObject(ms, result);
break;
}
case Picture:
MillisecondsToTimeObject(0, result);
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("playlistid"))
{
result = playlist;
}
else if (property.Equals("position"))
{
CGUIWindowSlideShow *slideshow = NULL;
switch (player)
{
case Video:
case Audio:
if (!IsPVRChannel() && g_playlistPlayer.GetCurrentPlaylist() == playlist)
result = g_playlistPlayer.GetCurrentSong();
else
result = -1;
break;
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow && slideshow->IsPlaying())
result = slideshow->CurrentSlide() - 1;
else
result = -1;
break;
default:
result = -1;
break;
}
}
else if (property.Equals("repeat"))
{
switch (player)
{
case Video:
case Audio:
if (IsPVRChannel())
{
result = "off";
break;
}
switch (g_playlistPlayer.GetRepeat(playlist))
{
case REPEAT_ONE:
result = "one";
break;
case REPEAT_ALL:
result = "all";
break;
default:
result = "off";
break;
}
break;
case Picture:
default:
result = "off";
break;
}
}
else if (property.Equals("shuffled"))
{
CGUIWindowSlideShow *slideshow = NULL;
switch (player)
{
case Video:
case Audio:
if (IsPVRChannel())
{
result = false;
break;
}
result = g_playlistPlayer.IsShuffled(playlist);
break;
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow && slideshow->IsPlaying())
result = slideshow->IsShuffled();
else
result = -1;
break;
default:
result = -1;
break;
}
}
else if (property.Equals("canseek"))
{
switch (player)
{
case Video:
case Audio:
if (g_application.m_pPlayer)
result = g_application.m_pPlayer->CanSeek();
else
result = false;
break;
case Picture:
default:
result = false;
break;
}
}
else if (property.Equals("canchangespeed"))
{
switch (player)
{
case Video:
case Audio:
result = !IsPVRChannel();
break;
case Picture:
default:
result = false;
break;
}
}
else if (property.Equals("canmove"))
{
switch (player)
{
case Picture:
result = true;
break;
case Video:
case Audio:
default:
result = false;
break;
}
}
else if (property.Equals("canzoom"))
{
switch (player)
{
case Picture:
result = true;
break;
case Video:
case Audio:
default:
result = false;
break;
}
}
else if (property.Equals("canrotate"))
{
switch (player)
{
case Picture:
result = true;
break;
case Video:
case Audio:
default:
result = false;
break;
}
}
else if (property.Equals("canshuffle"))
{
switch (player)
{
case Video:
case Audio:
case Picture:
result = !IsPVRChannel();
break;
default:
result = false;
break;
}
}
else if (property.Equals("canrepeat"))
{
switch (player)
{
case Video:
case Audio:
result = !IsPVRChannel();
break;
case Picture:
default:
result = false;
break;
}
}
else if (property.Equals("currentaudiostream"))
{
switch (player)
{
case Video:
case Audio:
if (g_application.m_pPlayer)
{
result = CVariant(CVariant::VariantTypeObject);
int index = g_application.m_pPlayer->GetAudioStream();
if (index >= 0)
{
result["index"] = index;
CStdString value;
g_application.m_pPlayer->GetAudioStreamName(index, value);
result["name"] = value;
value.Empty();
g_application.m_pPlayer->GetAudioStreamLanguage(index, value);
result["language"] = value;
}
result["codec"] = g_application.m_pPlayer->GetAudioCodecName();
result["bitrate"] = g_application.m_pPlayer->GetAudioBitrate();
result["channels"] = g_application.m_pPlayer->GetChannels();
}
else
result = CVariant(CVariant::VariantTypeNull);
break;
case Picture:
default:
result = CVariant(CVariant::VariantTypeNull);
break;
}
}
else if (property.Equals("audiostreams"))
{
result = CVariant(CVariant::VariantTypeArray);
switch (player)
{
case Video:
if (g_application.m_pPlayer)
{
for (int index = 0; index < g_application.m_pPlayer->GetAudioStreamCount(); index++)
{
CVariant audioStream(CVariant::VariantTypeObject);
audioStream["index"] = index;
CStdString value;
g_application.m_pPlayer->GetAudioStreamName(index, value);
audioStream["name"] = value;
value.Empty();
g_application.m_pPlayer->GetAudioStreamLanguage(index, value);
audioStream["language"] = value;
result.append(audioStream);
}
}
break;
case Audio:
case Picture:
default:
break;
}
}
else if (property.Equals("subtitleenabled"))
{
switch (player)
{
case Video:
if (g_application.m_pPlayer)
result = g_application.m_pPlayer->GetSubtitleVisible();
break;
case Audio:
case Picture:
default:
result = false;
break;
}
}
else if (property.Equals("currentsubtitle"))
{
switch (player)
{
case Video:
if (g_application.m_pPlayer)
{
result = CVariant(CVariant::VariantTypeObject);
int index = g_application.m_pPlayer->GetSubtitle();
if (index >= 0)
{
result["index"] = index;
CStdString value;
g_application.m_pPlayer->GetSubtitleName(index, value);
result["name"] = value;
value.Empty();
g_application.m_pPlayer->GetSubtitleLanguage(index, value);
result["language"] = value;
}
}
else
result = CVariant(CVariant::VariantTypeNull);
break;
case Audio:
case Picture:
default:
result = CVariant(CVariant::VariantTypeNull);
break;
}
}
else if (property.Equals("subtitles"))
{
result = CVariant(CVariant::VariantTypeArray);
switch (player)
{
case Video:
if (g_application.m_pPlayer)
{
for (int index = 0; index < g_application.m_pPlayer->GetSubtitleCount(); index++)
{
CVariant subtitle(CVariant::VariantTypeObject);
subtitle["index"] = index;
CStdString value;
g_application.m_pPlayer->GetSubtitleName(index, value);
subtitle["name"] = value;
value.Empty();
g_application.m_pPlayer->GetSubtitleLanguage(index, value);
subtitle["language"] = value;
result.append(subtitle);
}
}
break;
case Audio:
case Picture:
default:
break;
}
}
else if (property.Equals("live"))
result = IsPVRChannel();
else
return InvalidParams;
return OK;
}
void CFileCurl::ParseAndCorrectUrl(CURL &url2)
{
/*
歌方:
1、
卦指:
1、
傍苧:
1、
*/
CStdString strProtocol = url2.GetTranslatedProtocol();
url2.SetProtocol(strProtocol);
if( strProtocol.Equals("ftp")|| strProtocol.Equals("ftps") )
{
/* this is uggly, depending on from where */
/* we get the link it may or may not be */
/* url encoded. if handed from ftpdirectory */
/* it won't be so let's handle that case */
CStdString partial, filename(url2.GetFileName());
CStdStringArray array;
/* our current client doesn't support utf8 */
g_charsetConverter.utf8ToStringCharset(filename);
/* TODO: create a tokenizer that doesn't skip empty's */
CUtil::Tokenize(filename, array, "/");
filename.Empty();
for(CStdStringArray::iterator it = array.begin(); it != array.end(); it++)
{
if(it != array.begin())
filename += "/";
partial = *it;
CURL::Encode(partial);
filename += partial;
}
/* make sure we keep slashes */
if(url2.GetFileName().Right(1) == "/")
filename += "/";
url2.SetFileName(filename);
CStdString options = url2.GetOptions().Mid(1);
options.TrimRight('/'); // hack for trailing slashes being added from source
m_ftpauth = "";
m_ftpport = "";
m_ftppasvip = false;
/* parse options given */
CUtil::Tokenize(options, array, "&");
for(CStdStringArray::iterator it = array.begin(); it != array.end(); it++)
{
CStdString name, value;
int pos = it->Find('=');
if(pos >= 0)
{
name = it->Left(pos);
value = it->Mid(pos+1, it->size());
}
else
{
name = (*it);
value = "";
}
if(name.Equals("auth"))
{
m_ftpauth = value;
if(m_ftpauth.IsEmpty())
m_ftpauth = "any";
}
else if(name.Equals("active"))
{
m_ftpport = value;
if(value.IsEmpty())
m_ftpport = "-";
}
else if(name.Equals("pasvip"))
{
if(value == "0")
m_ftppasvip = false;
else
m_ftppasvip = true;
}
}
/* ftp has no options */
url2.SetOptions("");
}
else if( strProtocol.Equals("http") || strProtocol.Equals("https"))
{
if (g_guiSettings.GetBool("network.usehttpproxy") && m_proxy.IsEmpty())
{
m_proxy = "http://" + g_guiSettings.GetString("network.httpproxyserver");
m_proxy += ":" + g_guiSettings.GetString("network.httpproxyport");
if (g_guiSettings.GetString("network.httpproxyusername").length() > 0 && m_proxyuserpass.IsEmpty())
{
m_proxyuserpass = g_guiSettings.GetString("network.httpproxyusername");
m_proxyuserpass += ":" + g_guiSettings.GetString("network.httpproxypassword");
}
CLog::Log(LOGDEBUG, "Using proxy %s", m_proxy.c_str());
}
// get username and password
m_username = url2.GetUserName();
m_password = url2.GetPassWord();
// handle any protocol options
CStdString options = url2.GetProtocolOptions();
options.TrimRight('/'); // hack for trailing slashes being added from source
if (options.length() > 0)
{
// clear protocol options
url2.SetProtocolOptions("");
// set xbmc headers
CStdStringArray array;
CUtil::Tokenize(options, array, "&");
for(CStdStringArray::iterator it = array.begin(); it != array.end(); it++)
{
// parse name, value
CStdString name, value;
int pos = it->Find('=');
if(pos >= 0)
{
name = it->Left(pos);
value = it->Mid(pos+1, it->size());
}
else
{
name = (*it);
value = "";
}
// url decode value
CURL::Decode(value);
if(name.Equals("auth"))
{
m_httpauth = value;
if(m_httpauth.IsEmpty())
m_httpauth = "any";
}
else if (name.Equals("Referer"))
SetReferer(value);
else if (name.Equals("User-Agent"))
SetUserAgent(value);
else if (name.Equals("Cookie"))
SetCookie(value);
else if (name.Equals("Encoding"))
SetContentEncoding(value);
else if (name.Equals("noshout") && value.Equals("true"))
m_skipshout = true;
else
SetRequestHeader(name, value);
}
}
}
if (m_username.length() > 0 && m_password.length() > 0)
m_url = url2.GetWithoutUserDetails();
else
m_url = url2.Get();
}
bool CAirPlayServer::CTCPClient::checkAuthorization(const CStdString& authStr,
const CStdString& method,
const CStdString& uri)
{
bool authValid = true;
CStdString username;
if (authStr.empty())
return false;
//first get username - we allow all usernames for airplay (usually it is AirPlay)
username = getFieldFromString(authStr, "username");
if (username.empty())
{
authValid = false;
}
//second check realm
if (authValid)
{
if (getFieldFromString(authStr, "realm") != AUTH_REALM)
{
authValid = false;
}
}
//third check nonce
if (authValid)
{
if (getFieldFromString(authStr, "nonce") != m_authNonce)
{
authValid = false;
}
}
//forth check uri
if (authValid)
{
if (getFieldFromString(authStr, "uri") != uri)
{
authValid = false;
}
}
//last check response
if (authValid)
{
CStdString realm = AUTH_REALM;
CStdString ourResponse = calcResponse(username, ServerInstance->m_password, realm, method, uri, m_authNonce);
CStdString theirResponse = getFieldFromString(authStr, "response");
if (!theirResponse.Equals(ourResponse, false))
{
authValid = false;
CLog::Log(LOGDEBUG,"AirAuth: response mismatch - our: %s theirs: %s",ourResponse.c_str(), theirResponse.c_str());
}
else
{
CLog::Log(LOGDEBUG, "AirAuth: successfull authentication from AirPlay client");
}
}
m_bAuthenticated = authValid;
return m_bAuthenticated;
}
bool CSysInfo::GetDiskSpace(const CStdString drive,int& iTotal, int& iTotalFree, int& iTotalUsed, int& iPercentFree, int& iPercentUsed)
{
bool bRet= false;
ULARGE_INTEGER ULTotal= { { 0 } };
ULARGE_INTEGER ULTotalFree= { { 0 } };
if( !drive.IsEmpty() && !drive.Equals("*") )
{
#ifdef _WIN32
UINT uidriveType = GetDriveType(( drive + ":\\" ));
if(uidriveType != DRIVE_UNKNOWN && uidriveType != DRIVE_NO_ROOT_DIR)
#endif
bRet= ( 0 != GetDiskFreeSpaceEx( ( drive + ":\\" ), NULL, &ULTotal, &ULTotalFree) );
}
else
{
ULARGE_INTEGER ULTotalTmp= { { 0 } };
ULARGE_INTEGER ULTotalFreeTmp= { { 0 } };
#ifdef _WIN32
char* pcBuffer= NULL;
DWORD dwStrLength= GetLogicalDriveStrings( 0, pcBuffer );
if( dwStrLength != 0 )
{
dwStrLength+= 1;
pcBuffer= new char [dwStrLength];
GetLogicalDriveStrings( dwStrLength, pcBuffer );
int iPos= 0;
do {
if( DRIVE_FIXED == GetDriveType( pcBuffer + iPos ) &&
GetDiskFreeSpaceEx( ( pcBuffer + iPos ), NULL, &ULTotal, &ULTotalFree ) )
{
ULTotalTmp.QuadPart+= ULTotal.QuadPart;
ULTotalFreeTmp.QuadPart+= ULTotalFree.QuadPart;
}
iPos += (strlen( pcBuffer + iPos) + 1 );
}while( strlen( pcBuffer + iPos ) > 0 );
}
delete[] pcBuffer;
#else // for linux and osx
static const char *drv_letter[] = { "C:\\", "E:\\", "F:\\", "G:\\", "X:\\", "Y:\\", "Z:\\", NULL };
for( int i = 0; drv_letter[i]; i++)
{
if( GetDiskFreeSpaceEx( drv_letter[i], NULL, &ULTotal, &ULTotalFree ) )
{
ULTotalTmp.QuadPart+= ULTotal.QuadPart;
ULTotalFreeTmp.QuadPart+= ULTotalFree.QuadPart;
}
}
#endif
if( ULTotalTmp.QuadPart || ULTotalFreeTmp.QuadPart )
{
ULTotal.QuadPart= ULTotalTmp.QuadPart;
ULTotalFree.QuadPart= ULTotalFreeTmp.QuadPart;
bRet= true;
}
}
if( bRet )
{
iTotal = (int)( ULTotal.QuadPart / MB );
iTotalFree = (int)( ULTotalFree.QuadPart / MB );
iTotalUsed = iTotal - iTotalFree;
iPercentUsed = (int)( 100.0f * ( ULTotal.QuadPart - ULTotalFree.QuadPart ) / ULTotal.QuadPart + 0.5f );
iPercentFree = 100 - iPercentUsed;
}
return bRet;
}
bool CPlayListPLS::Load(const CStdString &strFile)
{
//read it from the file
CStdString strFileName(strFile);
m_strPlayListName = URIUtils::GetFileName(strFileName);
Clear();
bool bShoutCast = false;
if( StringUtils::StartsWithNoCase(strFileName, "shout://") )
{
strFileName.replace(0, 8, "http://");
m_strBasePath = "";
bShoutCast = true;
}
else
URIUtils::GetParentPath(strFileName, m_strBasePath);
CFile file;
if (!file.Open(strFileName) )
{
file.Close();
return false;
}
if (file.GetLength() > 1024*1024)
{
CLog::Log(LOGWARNING, "%s - File is larger than 1 MB, most likely not a playlist",__FUNCTION__);
return false;
}
char szLine[4096];
CStdString strLine;
// run through looking for the [playlist] marker.
// if we find another http stream, then load it.
while (1)
{
if ( !file.ReadString(szLine, sizeof(szLine) ) )
{
file.Close();
return size() > 0;
}
strLine = szLine;
StringUtils::Trim(strLine);
if(strLine.Equals(START_PLAYLIST_MARKER))
break;
// if there is something else before playlist marker, this isn't a pls file
if(!strLine.empty())
return false;
}
bool bFailed = false;
while (file.ReadString(szLine, sizeof(szLine) ) )
{
strLine = szLine;
StringUtils::RemoveCRLF(strLine);
size_t iPosEqual = strLine.find("=");
if (iPosEqual != std::string::npos)
{
CStdString strLeft = strLine.substr(0, iPosEqual);
iPosEqual++;
CStdString strValue = strLine.substr(iPosEqual);
StringUtils::ToLower(strLeft);
StringUtils::TrimLeft(strLeft);
if (strLeft == "numberofentries")
{
m_vecItems.reserve(atoi(strValue.c_str()));
}
else if (StringUtils::StartsWith(strLeft, "file"))
{
vector <int>::size_type idx = atoi(strLeft.c_str() + 4);
if (!Resize(idx))
{
bFailed = true;
break;
}
// Skip self - do not load playlist recursively
if (URIUtils::GetFileName(strValue).Equals(URIUtils::GetFileName(strFileName)))
continue;
if (m_vecItems[idx - 1]->GetLabel().empty())
m_vecItems[idx - 1]->SetLabel(URIUtils::GetFileName(strValue));
CFileItem item(strValue, false);
if (bShoutCast && !item.IsAudio())
strValue.replace(0, 7, "shout://");
strValue = URIUtils::SubstitutePath(strValue);
CUtil::GetQualifiedFilename(m_strBasePath, strValue);
g_charsetConverter.unknownToUTF8(strValue);
m_vecItems[idx - 1]->SetPath(strValue);
}
else if (StringUtils::StartsWith(strLeft, "title"))
{
vector <int>::size_type idx = atoi(strLeft.c_str() + 5);
if (!Resize(idx))
{
bFailed = true;
break;
}
g_charsetConverter.unknownToUTF8(strValue);
m_vecItems[idx - 1]->SetLabel(strValue);
}
else if (StringUtils::StartsWith(strLeft, "length"))
{
vector <int>::size_type idx = atoi(strLeft.c_str() + 6);
if (!Resize(idx))
{
bFailed = true;
break;
}
m_vecItems[idx - 1]->GetMusicInfoTag()->SetDuration(atol(strValue.c_str()));
}
else if (strLeft == "playlistname")
{
m_strPlayListName = strValue;
g_charsetConverter.unknownToUTF8(m_strPlayListName);
}
}
}
file.Close();
if (bFailed)
{
CLog::Log(LOGERROR, "File %s is not a valid PLS playlist. Location of first file,title or length is not permitted (eg. File0 should be File1)", URIUtils::GetFileName(strFileName).c_str());
return false;
}
// check for missing entries
ivecItems p = m_vecItems.begin();
while ( p != m_vecItems.end())
{
if ((*p)->GetPath().empty())
{
p = m_vecItems.erase(p);
}
else
{
++p;
}
}
return true;
}
bool CWinSystemX11::IsCurrentOutput(CStdString output)
{
return (output.Equals("Default")) || (m_currentOutput.compare(output) == 0);
}
CStdString CGUIWindowVideoNav::GetStartFolder(const CStdString &dir)
{
if (dir.Equals("MovieGenres"))
return "videodb://1/1/";
else if (dir.Equals("MovieTitles"))
return "videodb://1/2/";
else if (dir.Equals("MovieYears"))
return "videodb://1/3/";
else if (dir.Equals("MovieActors"))
return "videodb://1/4/";
else if (dir.Equals("MovieDirectors"))
return "videodb://1/5/";
else if (dir.Equals("MovieStudios"))
return "videodb://1/6/";
else if (dir.Equals("MovieSets"))
return "videodb://1/7/";
else if (dir.Equals("MovieCountries"))
return "videodb://1/8/";
else if (dir.Equals("Movies"))
return "videodb://1/";
else if (dir.Equals("TvShowGenres"))
return "videodb://2/1/";
else if (dir.Equals("TvShowTitles"))
return "videodb://2/2/";
else if (dir.Equals("TvShowYears"))
return "videodb://2/3/";
else if (dir.Equals("TvShowActors"))
return "videodb://2/4/";
else if (dir.Equals("TvShowStudios"))
return "videodb://2/5/";
else if (dir.Equals("TvShows"))
return "videodb://2/";
else if (dir.Equals("MusicVideoGenres"))
return "videodb://3/1/";
else if (dir.Equals("MusicVideoTitles"))
return "videodb://3/2/";
else if (dir.Equals("MusicVideoYears"))
return "videodb://3/3/";
else if (dir.Equals("MusicVideoArtists"))
return "videodb://3/4/";
else if (dir.Equals("MusicVideoDirectors"))
return "videodb://3/5/";
else if (dir.Equals("MusicVideoStudios"))
return "videodb://3/6/";
else if (dir.Equals("MusicVideos"))
return "videodb://3/";
else if (dir.Equals("RecentlyAddedMovies"))
return "videodb://4/";
else if (dir.Equals("RecentlyAddedEpisodes"))
return "videodb://5/";
else if (dir.Equals("RecentlyAddedMusicVideos"))
return "videodb://6/";
return CGUIWindowVideoBase::GetStartFolder(dir);
}
void CScraperParser::ParseNext(TiXmlElement* element)
{
TiXmlElement* pReg = element;
while (pReg)
{
TiXmlElement* pChildReg = pReg->FirstChildElement("RegExp");
if (pChildReg)
ParseNext(pChildReg);
else
{
TiXmlElement* pChildReg = pReg->FirstChildElement("clear");
if (pChildReg)
ParseNext(pChildReg);
}
int iDest = 1;
bool bAppend = false;
const char* szDest = pReg->Attribute("dest");
if (szDest)
if (strlen(szDest))
{
if (szDest[strlen(szDest)-1] == '+')
bAppend = true;
iDest = atoi(szDest);
}
const char *szInput = pReg->Attribute("input");
CStdString strInput;
if (szInput)
{
strInput = szInput;
ReplaceBuffers(strInput);
}
else
strInput = m_param[0];
const char* szConditional = pReg->Attribute("conditional");
bool bExecute = true;
if (szConditional)
{
bool bInverse=false;
if (szConditional[0] == '!')
{
bInverse = true;
szConditional++;
}
CStdString strSetting;
if (m_scraper && m_scraper->HasSettings())
strSetting = m_scraper->GetSetting(szConditional);
bExecute = bInverse != strSetting.Equals("true");
}
if (bExecute)
{
if (iDest-1 < MAX_SCRAPER_BUFFERS && iDest-1 > -1)
ParseExpression(strInput, m_param[iDest-1],pReg,bAppend);
else
CLog::Log(LOGERROR,"CScraperParser::ParseNext: destination buffer "
"out of bounds, skipping expression");
}
pReg = pReg->NextSiblingElement("RegExp");
}
}
CStdString CGUIWindowVideoNav::GetQuickpathName(const CStdString& strPath) const
{
if (strPath.Equals("videodb://1/1/"))
return "MovieGenres";
else if (strPath.Equals("videodb://1/2/"))
return "MovieTitles";
else if (strPath.Equals("videodb://1/3/"))
return "MovieYears";
else if (strPath.Equals("videodb://1/4/"))
return "MovieActors";
else if (strPath.Equals("videodb://1/5/"))
return "MovieDirectors";
else if (strPath.Equals("videodb://1/"))
return "Movies";
else if (strPath.Equals("videodb://2/1/"))
return "TvShowGenres";
else if (strPath.Equals("videodb://2/2/"))
return "TvShowTitles";
else if (strPath.Equals("videodb://2/3/"))
return "TvShowYears";
else if (strPath.Equals("videodb://2/4/"))
return "TvShowActors";
else if (strPath.Equals("videodb://2/"))
return "TvShows";
else if (strPath.Equals("videodb://3/1/"))
return "MusicVideoGenres";
else if (strPath.Equals("videodb://3/2/"))
return "MusicVideoTitles";
else if (strPath.Equals("videodb://3/3/"))
return "MusicVideoYears";
else if (strPath.Equals("videodb://3/4/"))
return "MusicVideoArtists";
else if (strPath.Equals("videodb://3/5/"))
return "MusicVideoDirectors";
else if (strPath.Equals("videodb://3/"))
return "MusicVideos";
else if (strPath.Equals("videodb://4/"))
return "RecentlyAddedMovies";
else if (strPath.Equals("videodb://5/"))
return "RecentlyAddedEpisodes";
else if (strPath.Equals("videodb://6/"))
return "RecentlyAddedMusicVideos";
else if (strPath.Equals("special://videoplaylists/"))
return "Playlists";
else
{
CLog::Log(LOGERROR, " CGUIWindowVideoNav::GetQuickpathName: Unknown parameter (%s)", strPath.c_str());
return strPath;
}
}
uint32_t CButtonTranslator::TranslateGamepadString(const char *szButton)
{
if (!szButton)
return 0;
uint32_t buttonCode = 0;
CStdString strButton = szButton;
strButton.ToLower();
if (strButton.Equals("a")) buttonCode = KEY_BUTTON_A;
else if (strButton.Equals("b")) buttonCode = KEY_BUTTON_B;
else if (strButton.Equals("x")) buttonCode = KEY_BUTTON_X;
else if (strButton.Equals("y")) buttonCode = KEY_BUTTON_Y;
else if (strButton.Equals("white")) buttonCode = KEY_BUTTON_WHITE;
else if (strButton.Equals("black")) buttonCode = KEY_BUTTON_BLACK;
else if (strButton.Equals("start")) buttonCode = KEY_BUTTON_START;
else if (strButton.Equals("back")) buttonCode = KEY_BUTTON_BACK;
else if (strButton.Equals("leftthumbbutton")) buttonCode = KEY_BUTTON_LEFT_THUMB_BUTTON;
else if (strButton.Equals("rightthumbbutton")) buttonCode = KEY_BUTTON_RIGHT_THUMB_BUTTON;
else if (strButton.Equals("leftthumbstick")) buttonCode = KEY_BUTTON_LEFT_THUMB_STICK;
else if (strButton.Equals("leftthumbstickup")) buttonCode = KEY_BUTTON_LEFT_THUMB_STICK_UP;
else if (strButton.Equals("leftthumbstickdown")) buttonCode = KEY_BUTTON_LEFT_THUMB_STICK_DOWN;
else if (strButton.Equals("leftthumbstickleft")) buttonCode = KEY_BUTTON_LEFT_THUMB_STICK_LEFT;
else if (strButton.Equals("leftthumbstickright")) buttonCode = KEY_BUTTON_LEFT_THUMB_STICK_RIGHT;
else if (strButton.Equals("rightthumbstick")) buttonCode = KEY_BUTTON_RIGHT_THUMB_STICK;
else if (strButton.Equals("rightthumbstickup")) buttonCode = KEY_BUTTON_RIGHT_THUMB_STICK_UP;
else if (strButton.Equals("rightthumbstickdown")) buttonCode = KEY_BUTTON_RIGHT_THUMB_STICK_DOWN;
else if (strButton.Equals("rightthumbstickleft")) buttonCode = KEY_BUTTON_RIGHT_THUMB_STICK_LEFT;
else if (strButton.Equals("rightthumbstickright")) buttonCode = KEY_BUTTON_RIGHT_THUMB_STICK_RIGHT;
else if (strButton.Equals("lefttrigger")) buttonCode = KEY_BUTTON_LEFT_TRIGGER;
else if (strButton.Equals("righttrigger")) buttonCode = KEY_BUTTON_RIGHT_TRIGGER;
else if (strButton.Equals("leftanalogtrigger")) buttonCode = KEY_BUTTON_LEFT_ANALOG_TRIGGER;
else if (strButton.Equals("rightanalogtrigger")) buttonCode = KEY_BUTTON_RIGHT_ANALOG_TRIGGER;
else if (strButton.Equals("dpadleft")) buttonCode = KEY_BUTTON_DPAD_LEFT;
else if (strButton.Equals("dpadright")) buttonCode = KEY_BUTTON_DPAD_RIGHT;
else if (strButton.Equals("dpadup")) buttonCode = KEY_BUTTON_DPAD_UP;
else if (strButton.Equals("dpaddown")) buttonCode = KEY_BUTTON_DPAD_DOWN;
else CLog::Log(LOGERROR, "Gamepad Translator: Can't find button %s", strButton.c_str());
return buttonCode;
}
bool CFileOperations::FillFileItemList(const CVariant ¶meterObject, CFileItemList &list)
{
if (parameterObject.isMember("directory"))
{
CStdString media = parameterObject["media"].asString();
media = media.ToLower();
CStdString strPath = parameterObject["directory"].asString();
if (!strPath.empty())
{
CFileItemList items;
CStdString extensions = "";
CStdStringArray regexps;
if (media.Equals("video"))
{
regexps = g_advancedSettings.m_videoExcludeFromListingRegExps;
extensions = g_advancedSettings.m_videoExtensions;
}
else if (media.Equals("music"))
{
regexps = g_advancedSettings.m_audioExcludeFromListingRegExps;
extensions = g_advancedSettings.m_musicExtensions;
}
else if (media.Equals("pictures"))
{
regexps = g_advancedSettings.m_pictureExcludeFromListingRegExps;
extensions = g_advancedSettings.m_pictureExtensions;
}
CDirectory directory;
if (directory.GetDirectory(strPath, items, extensions))
{
items.Sort(SortByFile, SortOrderAscending);
CFileItemList filteredDirectories;
for (unsigned int i = 0; i < (unsigned int)items.Size(); i++)
{
if (CUtil::ExcludeFileOrFolder(items[i]->GetPath(), regexps))
continue;
if (items[i]->m_bIsFolder)
filteredDirectories.Add(items[i]);
else if ((media == "video" && items[i]->HasVideoInfoTag()) ||
(media == "music" && items[i]->HasMusicInfoTag()))
list.Add(items[i]);
else
{
CFileItemPtr fileItem(new CFileItem());
if (FillFileItem(items[i], fileItem, media, parameterObject))
list.Add(fileItem);
else if (media == "files")
list.Add(items[i]);
}
}
if (parameterObject.isMember("recursive") && parameterObject["recursive"].isBoolean())
{
for (int i = 0; i < filteredDirectories.Size(); i++)
{
CVariant val = parameterObject;
val["directory"] = filteredDirectories[i]->GetPath();
FillFileItemList(val, list);
}
}
return true;
}
}
}
return false;
}
bool URIUtils::ProtocolHasEncodedHostname(const CStdString& prot)
{
return ProtocolHasParentInHostname(prot)
|| prot.Equals("musicsearch")
|| prot.Equals("image");
}
void CPVRTimers::Notify(const Observable &obs, const CStdString& msg)
{
if (msg.Equals("epg"))
g_PVRManager.TriggerTimersUpdate();
}
