int CGUIDialogYesNo::ShowAndGetInput(CVariant heading, CVariant text, CVariant noLabel, CVariant yesLabel, CVariant customLabel, unsigned int autoCloseTime)
{
CGUIDialogYesNo *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
if (!dialog)
return false;
dialog->SetHeading(heading);
dialog->SetText(text);
if (autoCloseTime)
dialog->SetAutoClose(autoCloseTime);
dialog->m_bCanceled = false;
dialog->m_bCustom = false;
dialog->SetChoice(0, !noLabel.empty() ? noLabel : 106);
dialog->SetChoice(1, !yesLabel.empty() ? yesLabel : 107);
dialog->SetChoice(2, customLabel); // Button only visible when label is not empty
dialog->Open();
if (dialog->m_bCanceled)
return -1;
else if (dialog->m_bCustom)
return 2;
else if (dialog->IsConfirmed())
return 1;
else
return 0;
}
bool CGUIWindowPVRBase::ActionDeleteChannel(CFileItem *item)
{
CPVRChannelPtr channel(item->GetPVRChannelInfoTag());
/* check if the channel tag is valid */
if (!channel || channel->ChannelNumber() <= 0)
return false;
/* show a confirmation dialog */
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*) g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return false;
pDialog->SetHeading(CVariant{19039});
pDialog->SetLine(0, CVariant{""});
pDialog->SetLine(1, CVariant{channel->ChannelName()});
pDialog->SetLine(2, CVariant{""});
pDialog->Open();
/* prompt for the user's confirmation */
if (!pDialog->IsConfirmed())
return false;
g_PVRChannelGroups->GetGroupAll(channel->IsRadio())->RemoveFromGroup(channel);
Refresh(true);
return true;
}
bool CFileUtils::DeleteItem(const CFileItemPtr &item, bool force)
{
if (!item || item->IsParentFolder())
return false;
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!force && pDialog)
{
pDialog->SetHeading(CVariant{122});
pDialog->SetLine(0, CVariant{125});
pDialog->SetLine(1, CVariant{CURL(item->GetPath()).GetWithoutUserDetails()});
pDialog->SetLine(2, CVariant{""});
pDialog->Open();
if (!pDialog->IsConfirmed()) return false;
}
// Create a temporary item list containing the file/folder for deletion
CFileItemPtr pItemTemp(new CFileItem(*item));
pItemTemp->Select(true);
CFileItemList items;
items.Add(pItemTemp);
// grab the real filemanager window, set up the progress bar,
// and process the delete action
CFileOperationJob op(CFileOperationJob::ActionDelete, items, "");
return op.DoWork();
}
bool CGUIWindowSettingsScreenCalibration::OnAction(const CAction &action)
{
switch (action.GetID())
{
case ACTION_CALIBRATE_SWAP_ARROWS:
{
NextControl();
return true;
}
break;
case ACTION_CALIBRATE_RESET:
{
CGUIDialogYesNo* pDialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
pDialog->SetHeading(CVariant{20325});
std::string strText = StringUtils::Format(g_localizeStrings.Get(20326).c_str(), CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo(m_Res[m_iCurRes]).strMode.c_str());
pDialog->SetLine(0, CVariant{std::move(strText)});
pDialog->SetLine(1, CVariant{20327});
pDialog->SetChoice(0, CVariant{222});
pDialog->SetChoice(1, CVariant{186});
pDialog->Open();
if (pDialog->IsConfirmed())
{
CServiceBroker::GetWinSystem()->GetGfxContext().ResetScreenParameters(m_Res[m_iCurRes]);
ResetControls();
}
return true;
}
break;
case ACTION_CHANGE_RESOLUTION:
// choose the next resolution in our list
{
m_iCurRes = (m_iCurRes+1) % m_Res.size();
CServiceBroker::GetWinSystem()->GetGfxContext().SetVideoResolution(m_Res[m_iCurRes], false);
ResetControls();
return true;
}
break;
// ignore all gesture meta actions
case ACTION_GESTURE_BEGIN:
case ACTION_GESTURE_END:
case ACTION_GESTURE_ABORT:
case ACTION_GESTURE_NOTIFY:
case ACTION_GESTURE_PAN:
case ACTION_GESTURE_ROTATE:
case ACTION_GESTURE_ZOOM:
return true;
}
// if we see a mouse move event without dx and dy (amount2 and amount3) these
// are the focus actions which are generated on touch events and those should
// be eaten/ignored here. Else we will switch to the screencalibration controls
// which are at that x/y value on each touch/tap/swipe which makes the whole window
// unusable for touch screens
if (action.GetID() == ACTION_MOUSE_MOVE && action.GetAmount(2) == 0 && action.GetAmount(3) == 0)
return true;
return CGUIWindow::OnAction(action); // base class to handle basic movement etc.
}
bool CGUIDialogPVRGroupManager::ActionButtonDeleteGroup(CGUIMessage &message)
{
bool bReturn = false;
unsigned int iControl = message.GetSenderId();
if (iControl == BUTTON_DELGROUP)
{
if (!m_selectedGroup)
return bReturn;
CGUIDialogYesNo* pDialog = g_windowManager.GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return bReturn;
pDialog->SetHeading(CVariant{117});
pDialog->SetLine(0, CVariant{""});
pDialog->SetLine(1, CVariant{m_selectedGroup->GroupName()});
pDialog->SetLine(2, CVariant{""});
pDialog->Open();
if (pDialog->IsConfirmed())
{
if (static_cast<CPVRChannelGroups*>(CServiceBroker::GetPVRManager().ChannelGroups()->Get(m_bIsRadio))->DeleteGroup(*m_selectedGroup))
Update();
}
bReturn = true;
}
return bReturn;
}
bool CGUIDialogPVRChannelManager::OnClickButtonRadioTV(CGUIMessage &message)
{
if (m_bContainsChanges)
{
CGUIDialogYesNo* pDialog = g_windowManager.GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return true;
pDialog->SetHeading(CVariant{20052});
pDialog->SetLine(0, CVariant{""});
pDialog->SetLine(1, CVariant{19212});
pDialog->SetLine(2, CVariant{20103});
pDialog->Open();
if (pDialog->IsConfirmed())
SaveList();
}
m_iSelected = 0;
m_bMovingMode = false;
m_bAllowNewChannel = false;
m_bContainsChanges = false;
m_bIsRadio = !m_bIsRadio;
SetProperty("IsRadio", m_bIsRadio ? "true" : "");
Update();
SetData(m_iSelected);
return true;
}
bool Dialog::yesno(const String& heading, const String& line1,
const String& line2,
const String& line3,
const String& nolabel,
const String& yeslabel,
int autoclose)
{
DelayedCallGuard dcguard(languageHook);
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (pDialog == NULL)
throw WindowException("Error: Window is NULL, this is not possible :-)");
// get lines, last 4 lines are optional.
if (!heading.empty())
pDialog->SetHeading(CVariant{heading});
if (!line1.empty())
pDialog->SetLine(0, CVariant{line1});
if (!line2.empty())
pDialog->SetLine(1, CVariant{line2});
if (!line3.empty())
pDialog->SetLine(2, CVariant{line3});
if (!nolabel.empty())
pDialog->SetChoice(0, CVariant{nolabel});
if (!yeslabel.empty())
pDialog->SetChoice(1, CVariant{yeslabel});
if (autoclose > 0)
pDialog->SetAutoClose(autoclose);
pDialog->Open();
return pDialog->IsConfirmed();
}
bool CGUIWindowPVRChannels::OnContextButtonUpdateEpg(CFileItem *item, CONTEXT_BUTTON button)
{
bool bReturn = false;
if (button == CONTEXT_BUTTON_UPDATE_EPG)
{
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return bReturn;
CPVRChannelPtr channel(item->GetPVRChannelInfoTag());
pDialog->SetHeading(CVariant{19251});
pDialog->SetLine(0, CVariant{g_localizeStrings.Get(19252)});
pDialog->SetLine(1, CVariant{channel->ChannelName()});
pDialog->SetLine(2, CVariant{""});
pDialog->Open();
if (!pDialog->IsConfirmed())
return bReturn;
bReturn = UpdateEpgForChannel(item);
std::string strMessage = StringUtils::Format("%s: '%s'", g_localizeStrings.Get(bReturn ? 19253 : 19254).c_str(), channel->ChannelName().c_str());
CGUIDialogKaiToast::QueueNotification(bReturn ? CGUIDialogKaiToast::Info : CGUIDialogKaiToast::Error,
g_localizeStrings.Get(19166),
strMessage);
}
return bReturn;
}
bool CGUIDialogPVRChannelManager::OnContextButton(int itemNumber, CONTEXT_BUTTON button)
{
/* Check file item is in list range and get his pointer */
if (itemNumber < 0 || itemNumber >= (int)m_channelItems->Size()) return false;
CFileItemPtr pItem = m_channelItems->Get(itemNumber);
if (!pItem)
return false;
if (button == CONTEXT_BUTTON_MOVE)
{
m_bMovingMode = true;
pItem->Select(true);
}
else if (button == CONTEXT_BUTTON_SETTINGS)
{
PVR_ERROR ret = CServiceBroker::GetPVRManager().Clients()->OpenDialogChannelSettings(pItem->GetPVRChannelInfoTag());
if (ret == PVR_ERROR_NOT_IMPLEMENTED)
CGUIDialogOK::ShowAndGetInput(CVariant{19033}, CVariant{19038}); // "Information", "Not supported by the PVR backend."
else if (ret != PVR_ERROR_NO_ERROR)
CGUIDialogOK::ShowAndGetInput(CVariant{2103}, CVariant{16029}); // "Add-on error", "Check the log for more information about this message."
}
else if (button == CONTEXT_BUTTON_DELETE)
{
CGUIDialogYesNo* pDialog = g_windowManager.GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return true;
pDialog->SetHeading(CVariant{19211}); // Delete channel
pDialog->SetText(CVariant{750}); // Are you sure?
pDialog->Open();
if (pDialog->IsConfirmed())
{
CPVRChannelPtr channel = pItem->GetPVRChannelInfoTag();
PVR_ERROR ret = CServiceBroker::GetPVRManager().Clients()->DeleteChannel(channel);
if (ret == PVR_ERROR_NO_ERROR)
{
CServiceBroker::GetPVRManager().ChannelGroups()->GetGroupAll(channel->IsRadio())->RemoveFromGroup(channel);
m_channelItems->Remove(m_iSelected);
m_viewControl.SetItems(*m_channelItems);
Renumber();
}
else if (ret == PVR_ERROR_NOT_IMPLEMENTED)
CGUIDialogOK::ShowAndGetInput(CVariant{19033}, CVariant{19038}); // "Information", "Not supported by the PVR backend."
else
CGUIDialogOK::ShowAndGetInput(CVariant{2103}, CVariant{16029}); // "Add-on error", "Check the log for more information about this message."
}
}
else if (button == CONTEXT_BUTTON_EDIT_SOURCE)
{
std::string strURL = pItem->GetProperty("StreamURL").asString();
if (CGUIKeyboardFactory::ShowAndGetInput(strURL, CVariant{g_localizeStrings.Get(19214)}, false))
pItem->SetProperty("StreamURL", strURL);
}
return true;
}
bool CGUIWindowPVRBase::ActionRecord(CFileItem *item)
{
bool bReturn = false;
CEpgInfoTagPtr epgTag(item->GetEPGInfoTag());
if (!epgTag)
return bReturn;
CPVRChannelPtr channel = epgTag->ChannelTag();
if (!channel || !g_PVRManager.CheckParentalLock(channel))
return bReturn;
if (epgTag->Timer() == NULL)
{
/* create a confirmation dialog */
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*) g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return bReturn;
pDialog->SetHeading(CVariant{264});
pDialog->SetLine(0, CVariant{""});
pDialog->SetLine(1, CVariant{epgTag->Title()});
pDialog->SetLine(2, CVariant{""});
pDialog->Open();
/* prompt for the user's confirmation */
if (!pDialog->IsConfirmed())
return bReturn;
CPVRTimerInfoTagPtr newTimer = CPVRTimerInfoTag::CreateFromEpg(epgTag);
if (newTimer)
{
bReturn = g_PVRTimers->AddTimer(newTimer);
}
else
{
bReturn = false;
}
}
else
{
CGUIDialogOK::ShowAndGetInput(CVariant{19033}, CVariant{19034});
bReturn = true;
}
return bReturn;
}
bool CProfilesManager::DeleteProfile(size_t index)
{
CSingleLock lock(m_critical);
const CProfile *profile = GetProfile(index);
if (profile == NULL)
return false;
CGUIDialogYesNo* dlgYesNo = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogYesNo>(WINDOW_DIALOG_YES_NO);
if (dlgYesNo == NULL)
return false;
std::string str = g_localizeStrings.Get(13201);
dlgYesNo->SetHeading(CVariant{13200});
dlgYesNo->SetLine(0, CVariant{StringUtils::Format(str.c_str(), profile->getName().c_str())});
dlgYesNo->SetLine(1, CVariant{""});
dlgYesNo->SetLine(2, CVariant{""});
dlgYesNo->Open();
if (!dlgYesNo->IsConfirmed())
return false;
// fall back to master profile if necessary
if ((int)index == m_autoLoginProfile)
m_autoLoginProfile = 0;
// delete profile
std::string strDirectory = profile->getDirectory();
m_profiles.erase(m_profiles.begin() + index);
// fall back to master profile if necessary
if (index == m_currentProfile)
{
LoadProfile(0);
m_settings.Save();
}
CFileItemPtr item = CFileItemPtr(new CFileItem(URIUtils::AddFileToFolder(GetUserDataFolder(), strDirectory)));
item->SetPath(URIUtils::AddFileToFolder(GetUserDataFolder(), strDirectory + "/"));
item->m_bIsFolder = true;
item->Select(true);
CGUIComponent *gui = CServiceBroker::GetGUI();
if (gui && gui->ConfirmDelete(item->GetPath()))
CFileUtils::DeleteItem(item);
return Save();
}
bool CGUIDialogYesNo::ShowAndGetInput(CVariant heading, CVariant text, bool &bCanceled, CVariant noLabel /* = "" */, CVariant yesLabel /* = "" */, unsigned int autoCloseTime)
{
CGUIDialogYesNo *dialog = (CGUIDialogYesNo *)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!dialog)
return false;
dialog->SetHeading(heading);
dialog->SetText(text);
if (autoCloseTime)
dialog->SetAutoClose(autoCloseTime);
dialog->m_bCanceled = false;
dialog->SetChoice(0, !noLabel.empty() ? noLabel : 106);
dialog->SetChoice(1, !yesLabel.empty() ? yesLabel : 107);
dialog->Open();
bCanceled = dialog->m_bCanceled;
return (dialog->IsConfirmed()) ? true : false;
}
void CAddonStatusHandler::Process()
{
CSingleLock lock(m_critSection);
std::string heading = StringUtils::Format("%s: %s", TranslateType(m_addon->Type(), true).c_str(), m_addon->Name().c_str());
/* Request to restart the AddOn and data structures need updated */
if (m_status == ADDON_STATUS_NEED_RESTART)
{
CGUIDialogOK* pDialog = (CGUIDialogOK*)g_windowManager.GetWindow(WINDOW_DIALOG_OK);
if (!pDialog) return;
pDialog->SetHeading(CVariant{heading});
pDialog->SetLine(1, CVariant{24074});
pDialog->Open();
CAddonMgr::GetInstance().GetCallbackForType(m_addon->Type())->RequestRestart(m_addon, true);
}
/* Some required settings are missing/invalid */
else if ((m_status == ADDON_STATUS_NEED_SETTINGS) || (m_status == ADDON_STATUS_NEED_SAVEDSETTINGS))
{
CGUIDialogYesNo* pDialogYesNo = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!pDialogYesNo) return;
pDialogYesNo->SetHeading(CVariant{heading});
pDialogYesNo->SetLine(1, CVariant{24070});
pDialogYesNo->SetLine(2, CVariant{24072});
pDialogYesNo->SetLine(3, CVariant{m_message});
pDialogYesNo->Open();
if (!pDialogYesNo->IsConfirmed()) return;
if (!m_addon->HasSettings())
return;
if (CGUIDialogAddonSettings::ShowAndGetInput(m_addon))
{
//! @todo Doesn't dialogaddonsettings save these automatically? It should do this.
m_addon->SaveSettings();
CAddonMgr::GetInstance().GetCallbackForType(m_addon->Type())->RequestRestart(m_addon, true);
}
}
}
bool CGUIWindowPVRRecordings::ActionDeleteRecording(CFileItem *item)
{
bool bReturn = false;
if ((!item->IsPVRRecording() && !item->m_bIsFolder) || item->IsParentFolder())
return bReturn;
/* show a confirmation dialog */
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return bReturn;
int iLine0 = item->m_bIsFolder ? 19113 : item->GetPVRRecordingInfoTag()->IsDeleted() ? 19294 : 19112;
pDialog->SetHeading(CVariant{122}); // Confirm delete
pDialog->SetLine(0, CVariant{iLine0}); // Delete all recordings in this folder? / Delete this recording permanently? / Delete this recording?
pDialog->SetLine(1, CVariant{""});
pDialog->SetLine(2, CVariant{item->GetLabel()});
pDialog->SetChoice(1, CVariant{117}); // Delete
/* prompt for the user's confirmation */
pDialog->Open();
if (!pDialog->IsConfirmed())
return bReturn;
/* delete the recording */
if (g_PVRRecordings->Delete(*item))
{
g_PVRManager.TriggerRecordingsUpdate();
bReturn = true;
/* remove the item from the list immediately, otherwise the
item count further down may be wrong */
m_vecItems->Remove(item);
/* go to the parent folder if we're in a subdirectory and just deleted the last item */
CPVRRecordingsPath path(m_vecItems->GetPath());
if (path.IsValid() && !path.IsRecordingsRoot() && m_vecItems->GetObjectCount() == 0)
GoParentFolder();
}
return bReturn;
}
bool CGUIDialogYesNo::ShowAndGetInput(CVariant heading, CVariant line0, CVariant line1, CVariant line2, bool &bCanceled, CVariant noLabel, CVariant yesLabel, unsigned int autoCloseTime)
{
CGUIDialogYesNo *dialog = static_cast<CGUIDialogYesNo *>(g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO));
if (!dialog)
return false;
dialog->SetHeading(heading);
dialog->SetLine(0, line0);
dialog->SetLine(1, line1);
dialog->SetLine(2, line2);
if (autoCloseTime)
dialog->SetAutoClose(autoCloseTime);
dialog->SetChoice(0, !noLabel.empty() ? noLabel : 106);
dialog->SetChoice(1, !yesLabel.empty() ? yesLabel : 107);
dialog->m_bCanceled = false;
dialog->Open();
bCanceled = dialog->m_bCanceled;
return (dialog->IsConfirmed()) ? true : false;
}
bool CGUIWindowPVRRecordings::OnContextButtonDeleteAll(CFileItem *item, CONTEXT_BUTTON button)
{
bool bReturn = false;
if (button != CONTEXT_BUTTON_DELETE_ALL || !item->IsDeletedPVRRecording())
return bReturn;
/* show a confirmation dialog */
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (!pDialog)
return bReturn;
pDialog->SetHeading(CVariant{19292}); // Delete all permanently
pDialog->SetLine(0, CVariant{19293}); // Delete all recordings permanently?
pDialog->SetLine(1, CVariant{""});
pDialog->SetLine(2, CVariant{""});
pDialog->SetChoice(1, CVariant{117}); // Delete
/* prompt for the user's confirmation */
pDialog->Open();
if (!pDialog->IsConfirmed())
return bReturn;
/* undelete the recording */
if (g_PVRRecordings->DeleteAllRecordingsFromTrash())
{
g_PVRManager.TriggerRecordingsUpdate();
bReturn = true;
/* remove the item from the list immediately, otherwise the
item count further down may be wrong */
m_vecItems->Clear();
/* go to the parent folder if we're in a subdirectory and just deleted the last item */
CPVRRecordingsPath path(m_vecItems->GetPath());
if (path.IsValid() && !path.IsRecordingsRoot() && m_vecItems->GetObjectCount() == 0)
GoParentFolder();
}
return bReturn;
}
void CGUIWindowVideoNav::OnDeleteItem(CFileItemPtr pItem)
{
if (m_vecItems->IsParentFolder())
return;
if (!m_vecItems->IsVideoDb() && !pItem->IsVideoDb())
{
if (!pItem->IsPath("newsmartplaylist://video") &&
!pItem->IsPath("special://videoplaylists/") &&
!pItem->IsPath("sources://video/") &&
!URIUtils::IsProtocol(pItem->GetPath(), "newtag"))
CGUIWindowVideoBase::OnDeleteItem(pItem);
}
else if (StringUtils::StartsWithNoCase(pItem->GetPath(), "videodb://movies/sets/") &&
pItem->GetPath().size() > 22 && pItem->m_bIsFolder)
{
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
pDialog->SetHeading(CVariant{432});
std::string strLabel = StringUtils::Format(g_localizeStrings.Get(433).c_str(),pItem->GetLabel().c_str());
pDialog->SetLine(1, CVariant{std::move(strLabel)});
pDialog->SetLine(2, CVariant{""});
pDialog->Open();
if (pDialog->IsConfirmed())
{
CFileItemList items;
CDirectory::GetDirectory(pItem->GetPath(),items,"",DIR_FLAG_NO_FILE_DIRS);
for (int i=0;i<items.Size();++i)
OnDeleteItem(items[i]);
CVideoDatabaseDirectory dir;
CQueryParams params;
dir.GetQueryParams(pItem->GetPath(),params);
m_database.DeleteSet(params.GetSetId());
}
}
else if (m_vecItems->GetContent() == "tags" && pItem->m_bIsFolder)
{
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*)g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
pDialog->SetHeading(CVariant{432});
pDialog->SetLine(1, CVariant{ StringUtils::Format(g_localizeStrings.Get(433).c_str(), pItem->GetLabel().c_str()) });
pDialog->SetLine(2, CVariant{""});
pDialog->Open();
if (pDialog->IsConfirmed())
{
CVideoDatabaseDirectory dir;
CQueryParams params;
dir.GetQueryParams(pItem->GetPath(), params);
m_database.DeleteTag(params.GetTagId(), (VIDEODB_CONTENT_TYPE)params.GetContentType());
}
}
else if (m_vecItems->IsPath(CUtil::VideoPlaylistsLocation()) ||
m_vecItems->IsPath("special://videoplaylists/"))
{
pItem->m_bIsFolder = false;
CFileUtils::DeleteItem(pItem);
}
else
{
if (!CGUIDialogVideoInfo::DeleteVideoItem(pItem))
return;
}
int itemNumber = m_viewControl.GetSelectedItem();
int select = itemNumber >= m_vecItems->Size()-1 ? itemNumber-1 : itemNumber;
m_viewControl.SetSelectedItem(select);
CUtil::DeleteVideoDatabaseDirectoryCache();
}
bool CGUIWindowPVRBase::PlayFile(CFileItem *item, bool bPlayMinimized /* = false */, bool bCheckResume /* = true */)
{
if (item->m_bIsFolder)
{
return false;
}
CPVRChannelPtr channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : CPVRChannelPtr();
if (item->GetPath() == g_application.CurrentFile() ||
(channel && channel->HasRecording() && channel->GetRecording()->GetPath() == g_application.CurrentFile()))
{
CGUIMessage msg(GUI_MSG_FULLSCREEN, 0, GetID());
g_windowManager.SendMessage(msg);
return true;
}
CMediaSettings::GetInstance().SetVideoStartWindowed(bPlayMinimized);
if (item->HasPVRRecordingInfoTag())
{
return PlayRecording(item, bPlayMinimized, bCheckResume);
}
else
{
bool bSwitchSuccessful(false);
CPVRChannelPtr channel(item->GetPVRChannelInfoTag());
if (channel && g_PVRManager.CheckParentalLock(channel))
{
CPVRRecordingPtr recording = channel->GetRecording();
if (recording)
{
CGUIDialogYesNo* pDialog = (CGUIDialogYesNo*) g_windowManager.GetWindow(WINDOW_DIALOG_YES_NO);
if (pDialog)
{
pDialog->SetHeading(CVariant{19687}); // Play recording
pDialog->SetLine(0, CVariant{""});
pDialog->SetLine(1, CVariant{12021}); // Start from beginning
pDialog->SetLine(2, CVariant{recording->m_strTitle});
pDialog->Open();
if (pDialog->IsConfirmed())
{
CFileItem recordingItem(recording);
return PlayRecording(&recordingItem, CSettings::GetInstance().GetBool(CSettings::SETTING_PVRPLAYBACK_PLAYMINIMIZED), bCheckResume);
}
}
}
/* try a fast switch */
if ((g_PVRManager.IsPlayingTV() || g_PVRManager.IsPlayingRadio()) &&
(channel->IsRadio() == g_PVRManager.IsPlayingRadio()))
{
if (channel->StreamURL().empty())
bSwitchSuccessful = g_application.m_pPlayer->SwitchChannel(channel);
}
if (!bSwitchSuccessful)
{
CApplicationMessenger::GetInstance().PostMsg(TMSG_MEDIA_PLAY, 0, 0, static_cast<void*>(new CFileItem(*item)));
return true;
}
}
if (!bSwitchSuccessful)
{
std::string channelName = g_localizeStrings.Get(19029); // Channel
if (channel)
channelName = channel->ChannelName();
std::string msg = StringUtils::Format(g_localizeStrings.Get(19035).c_str(), channelName.c_str()); // CHANNELNAME could not be played. Check the log for details.
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error,
g_localizeStrings.Get(19166), // PVR information
msg);
return false;
}
}
return true;
}
bool CRarManager::CacheRarredFile(std::string& strPathInCache, const std::string& strRarPath, const std::string& strPathInRar, uint8_t bOptions, const std::string& 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;
std::map<std::string, std::pair<ArchiveList_struct*, std::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(CVariant{120});
pDialog->SetLine(0, CVariant{645});
pDialog->SetLine(1, CVariant{URIUtils::GetFileName(strPathInRar)});
pDialog->SetLine(2, CVariant{""});
pDialog->Open();
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;
}
}
std::string strPath = strPathInRar;
#ifndef TARGET_POSIX
StringUtils::Replace(strPath, '/', '\\');
#endif
//g_charsetConverter.unknownToUTF8(strPath);
std::string 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->next)
{
std::string 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 == strPath)
{
iOffset = pIterator->item.iOffset;
break;
}
}
}
bool bShowProgress=false;
if (iSize > 1024*1024 || iSize == -2) // 1MB
bShowProgress=true;
std::string strDir2 = URIUtils::GetDirectory(strCachedPath);
URIUtils::RemoveSlashAtEnd(strDir2);
if (!CDirectory::Exists(strDir2))
CDirectory::Create(strDir2);
progress_info info(CURL(strPath).GetWithoutUserDetails());
iRes = urarlib_get(const_cast<char*>(strRarPath.c_str()), const_cast<char*>(strDir2.c_str()),
const_cast<char*>(strPath.c_str()),NULL,&iOffset,bShowProgress ? ProgressCallback : NULL, &info);
}
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(std::make_pair(strRarPath, std::make_pair(pArchiveList, std::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;
}
