xbmc/dialogs/GUIDialogProgress.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "GUIDialogProgress.h"
  10
  11 #include "guilib/GUIProgressControl.h"
  12 #include "guilib/GUIWindowManager.h"
  13 #include "guilib/LocalizeStrings.h"
  14 #include "guilib/guiinfo/GUIInfoLabels.h"
  15 #include "utils/Variant.h"
  16 #include "utils/log.h"
  17
  18 #include <mutex>
  19
  20 using namespace std::chrono_literals;
  21
  22 CGUIDialogProgress::CGUIDialogProgress(void)
  23     : CGUIDialogBoxBase(WINDOW_DIALOG_PROGRESS, "DialogConfirm.xml")
  24 {
  25   Reset();
  26 }
  27
  28 CGUIDialogProgress::~CGUIDialogProgress(void) = default;
  29
  30 void CGUIDialogProgress::Reset()
  31 {
  32   std::unique_lock<CCriticalSection> lock(m_section);
  33   m_iCurrent = 0;
  34   m_iMax = 0;
  35   m_percentage = 0;
  36   m_showProgress = true;
  37   m_bCanCancel = true;
  38   m_iChoice = CHOICE_NONE;
  39   m_supportedChoices = {};
  40
  41   SetInvalid();
  42 }
  43
  44 void CGUIDialogProgress::SetCanCancel(bool bCanCancel)
  45 {
  46   std::unique_lock<CCriticalSection> lock(m_section);
  47   m_bCanCancel = bCanCancel;
  48   SetInvalid();
  49 }
  50
  51 void CGUIDialogProgress::ShowChoice(int iChoice, const CVariant& label)
  52 {
  53   if (iChoice >= 0 && iChoice < DIALOG_MAX_CHOICES)
  54   {
  55     m_supportedChoices[iChoice] = true;
  56     SetChoice(iChoice, label);
  57     SetInvalid();
  58   }
  59 }
  60
  61 int CGUIDialogProgress::GetChoice() const
  62 {
  63   return m_iChoice;
  64 }
  65
  66 void CGUIDialogProgress::Open(const std::string &param /* = "" */)
  67 {
  68   CLog::Log(LOGDEBUG, "DialogProgress::Open called {}", m_active ? "(already running)!" : "");
  69
  70   {
  71     std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
  72     ShowProgressBar(true);
  73   }
  74
  75   CGUIDialog::Open(false, param);
  76
  77   while (m_active && IsAnimating(ANIM_TYPE_WINDOW_OPEN))
  78   {
  79     Progress();
  80     // we should have rendered at least once by now - if we haven't, then
  81     // we must be running from fullscreen video or similar where the
  82     // calling thread handles rendering (ie not main app thread) but
  83     // is waiting on this routine before rendering begins
  84     if (!HasProcessed())
  85       break;
  86   }
  87 }
  88
  89 void CGUIDialogProgress::Progress()
  90 {
  91   if (m_active)
  92   {
  93     ProcessRenderLoop();
  94   }
  95 }
  96
  97 bool CGUIDialogProgress::OnMessage(CGUIMessage& message)
  98 {
  99   switch ( message.GetMessage() )
 100   {
 101
 102   case GUI_MSG_WINDOW_DEINIT:
 103     Reset();
 104     break;
 105
 106   case GUI_MSG_CLICKED:
 107     {
 108       int iControl = message.GetSenderId();
 109       if (iControl >= CONTROL_CHOICES_START && iControl < (CONTROL_CHOICES_START + DIALOG_MAX_CHOICES))
 110       {
 111         // special handling for choice 0 mapped to cancel button
 112         if (m_bCanCancel && !m_supportedChoices[0] && (iControl == CONTROL_CHOICES_START))
 113         {
 114           if (m_iChoice != CHOICE_CANCELED)
 115           {
 116             std::string strHeading = m_strHeading;
 117             strHeading.append(" : ");
 118             strHeading.append(g_localizeStrings.Get(16024));
 119             CGUIDialogBoxBase::SetHeading(CVariant{strHeading});
 120             m_iChoice = CHOICE_CANCELED;
 121           }
 122         }
 123         else
 124         {
 125           m_iChoice = iControl - CONTROL_CHOICES_START;
 126         }
 127         return true;
 128       }
 129     }
 130     break;
 131   }
 132   return CGUIDialog::OnMessage(message);
 133 }
 134
 135 bool CGUIDialogProgress::OnBack(int actionID)
 136 {
 137   if (m_bCanCancel)
 138     m_iChoice = CHOICE_CANCELED;
 139   else
 140     m_iChoice = CHOICE_NONE;
 141
 142   return true;
 143 }
 144
 145 void CGUIDialogProgress::OnWindowLoaded()
 146 {
 147   CGUIDialog::OnWindowLoaded();
 148   CGUIControl *control = GetControl(CONTROL_PROGRESS_BAR);
 149   if (control && control->GetControlType() == CGUIControl::GUICONTROL_PROGRESS)
 150   {
 151     // make sure we have the appropriate info set
 152     CGUIProgressControl *progress = static_cast<CGUIProgressControl*>(control);
 153     if (!progress->GetInfo())
 154       progress->SetInfo(SYSTEM_PROGRESS_BAR);
 155   }
 156 }
 157
 158 void CGUIDialogProgress::SetPercentage(int iPercentage)
 159 {
 160   if (iPercentage < 0) iPercentage = 0;
 161   if (iPercentage > 100) iPercentage = 100;
 162
 163   if (iPercentage != m_percentage)
 164     MarkDirtyRegion();
 165
 166   m_percentage = iPercentage;
 167 }
 168
 169 void CGUIDialogProgress::SetProgressMax(int iMax)
 170 {
 171   m_iMax=iMax;
 172   m_iCurrent=0;
 173 }
 174
 175 void CGUIDialogProgress::SetProgressAdvance(int nSteps/*=1*/)
 176 {
 177   m_iCurrent+=nSteps;
 178
 179   if (m_iCurrent>m_iMax)
 180     m_iCurrent=0;
 181
 182   if (m_iMax > 0)
 183     SetPercentage((m_iCurrent*100)/m_iMax);
 184 }
 185
 186 bool CGUIDialogProgress::Abort()
 187 {
 188   return m_active ? IsCanceled() : false;
 189 }
 190
 191 void CGUIDialogProgress::ShowProgressBar(bool bOnOff)
 192 {
 193   std::unique_lock<CCriticalSection> lock(m_section);
 194   m_showProgress = bOnOff;
 195   SetInvalid();
 196 }
 197
 198 bool CGUIDialogProgress::Wait(int progresstime /*= 10*/)
 199 {
 200   CEvent m_done;
 201   while (!m_done.Wait(std::chrono::milliseconds(progresstime)) && m_active && !IsCanceled())
 202     Progress();
 203
 204   return !IsCanceled();
 205 }
 206
 207 bool CGUIDialogProgress::WaitOnEvent(CEvent& event)
 208 {
 209   while (!event.Wait(1ms))
 210   {
 211     if (IsCanceled())
 212       return false;
 213
 214     Progress();
 215   }
 216
 217   return !IsCanceled();
 218 }
 219
 220 void CGUIDialogProgress::UpdateControls()
 221 {
 222   // take a copy to save holding the lock for too long
 223   bool bShowProgress;
 224   bool bShowCancel;
 225   std::array<bool, DIALOG_MAX_CHOICES> choices;
 226   {
 227     std::unique_lock<CCriticalSection> lock(m_section);
 228     bShowProgress = m_showProgress;
 229     bShowCancel = m_bCanCancel;
 230     choices = m_supportedChoices;
 231   }
 232
 233   if (bShowProgress)
 234     SET_CONTROL_VISIBLE(CONTROL_PROGRESS_BAR);
 235   else
 236     SET_CONTROL_HIDDEN(CONTROL_PROGRESS_BAR);
 237
 238   bool bAllHidden = true;
 239   for (int i = 0; i < DIALOG_MAX_CHOICES; ++i)
 240   {
 241     if (choices[i])
 242     {
 243       bAllHidden = false;
 244       SET_CONTROL_VISIBLE(CONTROL_CHOICES_START + i);
 245     }
 246     else
 247       SET_CONTROL_HIDDEN(CONTROL_CHOICES_START + i);
 248   }
 249
 250   // special handling for choice 0 mapped to cancel button
 251   if (bShowCancel && bAllHidden)
 252     SET_CONTROL_VISIBLE(CONTROL_CHOICES_START);
 253 }
 254
 255 void CGUIDialogProgress::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
 256 {
 257   if (m_bInvalidated)
 258     UpdateControls();
 259
 260   CGUIDialogBoxBase::Process(currentTime, dirtyregions);
 261 }
 262
 263 void CGUIDialogProgress::OnInitWindow()
 264 {
 265   UpdateControls();
 266
 267   bool bNoFocus = true;
 268   for (int i = 0; i < DIALOG_MAX_CHOICES; ++i)
 269   {
 270     if (m_supportedChoices[i])
 271     {
 272       bNoFocus = false;
 273       SET_CONTROL_FOCUS(CONTROL_CHOICES_START + i, 0);
 274       break;
 275     }
 276   }
 277
 278   // special handling for choice 0 mapped to cancel button
 279   if (m_bCanCancel && bNoFocus)
 280     SET_CONTROL_FOCUS(CONTROL_CHOICES_START,0 );
 281
 282   CGUIDialogBoxBase::OnInitWindow();
 283 }
 284
 285 int CGUIDialogProgress::GetDefaultLabelID(int controlId) const
 286 {
 287   // special handling for choice 0 mapped to cancel button
 288   if (m_bCanCancel && !m_supportedChoices[0] && (controlId == CONTROL_CHOICES_START))
 289     return 222; // Cancel
 290
 291   return CGUIDialogBoxBase::GetDefaultLabelID(controlId);
 292 }