xbmc/pictures/GUIWindowSlideShow.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 "GUIWindowSlideShow.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "GUIDialogPictureInfo.h"
  14 #include "GUIInfoManager.h"
  15 #include "GUIUserMessages.h"
  16 #include "ServiceBroker.h"
  17 #include "URL.h"
  18 #include "application/Application.h"
  19 #include "application/ApplicationComponents.h"
  20 #include "application/ApplicationPlayer.h"
  21 #include "application/ApplicationPowerHandling.h"
  22 #include "filesystem/Directory.h"
  23 #include "guilib/GUIComponent.h"
  24 #include "guilib/GUILabelControl.h"
  25 #include "guilib/GUIWindowManager.h"
  26 #include "guilib/LocalizeStrings.h"
  27 #include "guilib/Texture.h"
  28 #include "imagefiles/ImageFileURL.h"
  29 #include "input/actions/Action.h"
  30 #include "input/actions/ActionIDs.h"
  31 #include "input/mouse/MouseEvent.h"
  32 #include "interfaces/AnnouncementManager.h"
  33 #include "pictures/GUIViewStatePictures.h"
  34 #include "pictures/PictureThumbLoader.h"
  35 #include "pictures/SlideShowDelegator.h"
  36 #include "playlists/PlayListTypes.h"
  37 #include "rendering/RenderSystem.h"
  38 #include "settings/DisplaySettings.h"
  39 #include "settings/Settings.h"
  40 #include "settings/SettingsComponent.h"
  41 #include "utils/Random.h"
  42 #include "utils/URIUtils.h"
  43 #include "utils/Variant.h"
  44 #include "utils/XTimeUtils.h"
  45 #include "utils/log.h"
  46 #include "video/VideoFileItemClassify.h"
  47
  48 #include <memory>
  49 #include <random>
  50
  51 using namespace KODI;
  52 using namespace KODI::VIDEO;
  53 using namespace MESSAGING;
  54 using namespace XFILE;
  55 using namespace std::chrono_literals;
  56
  57 #define MAX_ZOOM_FACTOR                     10
  58 #define MAX_PICTURE_SIZE             2048*2048
  59
  60 #define IMMEDIATE_TRANSITION_TIME          1
  61
  62 #define PICTURE_MOVE_AMOUNT              0.02f
  63 #define PICTURE_MOVE_AMOUNT_ANALOG       0.01f
  64 #define PICTURE_MOVE_AMOUNT_TOUCH        0.002f
  65 #define PICTURE_VIEW_BOX_COLOR      0xffffff00 // YELLOW
  66 #define PICTURE_VIEW_BOX_BACKGROUND 0xff000000 // BLACK
  67
  68 #define ROTATION_SNAP_RANGE              10.0f
  69
  70 #define LABEL_ROW1                          10
  71 #define CONTROL_PAUSE                       13
  72
  73 static float zoomamount[10] = { 1.0f, 1.2f, 1.5f, 2.0f, 2.8f, 4.0f, 6.0f, 9.0f, 13.5f, 20.0f };
  74
  75 CBackgroundPicLoader::CBackgroundPicLoader() : CThread("BgPicLoader")
  76 {
  77 }
  78
  79 CBackgroundPicLoader::~CBackgroundPicLoader()
  80 {
  81   StopThread();
  82 }
  83
  84 void CBackgroundPicLoader::Create(CGUIWindowSlideShow *pCallback)
  85 {
  86   m_pCallback = pCallback;
  87   m_isLoading = false;
  88   CThread::Create(false);
  89 }
  90
  91 void CBackgroundPicLoader::Process()
  92 {
  93   auto totalTime = std::chrono::milliseconds(0);
  94   unsigned int count = 0;
  95   while (!m_bStop)
  96   { // loop around forever, waiting for the app to call LoadPic
  97     if (AbortableWait(m_loadPic, 10ms) == WAIT_SIGNALED)
  98     {
  99       if (m_pCallback)
 100       {
 101         auto start = std::chrono::steady_clock::now();
 102         std::unique_ptr<CTexture> texture =
 103             CTexture::LoadFromFile(m_strFileName, m_maxWidth, m_maxHeight);
 104
 105         auto end = std::chrono::steady_clock::now();
 106         auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
 107
 108         totalTime += duration;
 109         count++;
 110         // tell our parent
 111         bool bFullSize = false;
 112         if (texture)
 113         {
 114           bFullSize = ((int)texture->GetWidth() < m_maxWidth) && ((int)texture->GetHeight() < m_maxHeight);
 115           if (!bFullSize)
 116           {
 117             int iSize = texture->GetWidth() * texture->GetHeight() - MAX_PICTURE_SIZE;
 118             if ((iSize + (int)texture->GetWidth() > 0) || (iSize + (int)texture->GetHeight() > 0))
 119               bFullSize = true;
 120             if (!bFullSize && texture->GetWidth() == CServiceBroker::GetRenderSystem()->GetMaxTextureSize())
 121               bFullSize = true;
 122             if (!bFullSize && texture->GetHeight() == CServiceBroker::GetRenderSystem()->GetMaxTextureSize())
 123               bFullSize = true;
 124           }
 125         }
 126         m_pCallback->OnLoadPic(m_iPic, m_iSlideNumber, m_strFileName, std::move(texture),
 127                                bFullSize);
 128         m_isLoading = false;
 129       }
 130     }
 131   }
 132   if (count > 0)
 133     CLog::Log(LOGDEBUG, "Time for loading {} images: {} ms, average {} ms", count,
 134               totalTime.count(), totalTime.count() / count);
 135 }
 136
 137 void CBackgroundPicLoader::LoadPic(int iPic, int iSlideNumber, const std::string &strFileName, const int maxWidth, const int maxHeight)
 138 {
 139   m_iPic = iPic;
 140   m_iSlideNumber = iSlideNumber;
 141   m_strFileName = strFileName;
 142   m_maxWidth = maxWidth;
 143   m_maxHeight = maxHeight;
 144   m_isLoading = true;
 145   m_loadPic.Set();
 146 }
 147
 148 CGUIWindowSlideShow::CGUIWindowSlideShow(void)
 149     : CGUIDialog(WINDOW_SLIDESHOW, "SlideShow.xml")
 150 {
 151   m_Resolution = RES_INVALID;
 152   m_loadType = KEEP_IN_MEMORY;
 153   m_bLoadNextPic = false;
 154   CServiceBroker::GetSlideShowDelegator().SetDelegate(this);
 155   CServiceBroker::GetAnnouncementManager()->AddAnnouncer(this);
 156   Reset();
 157 }
 158
 159 CGUIWindowSlideShow::~CGUIWindowSlideShow()
 160 {
 161   CServiceBroker::GetSlideShowDelegator().ResetDelegate();
 162   CServiceBroker::GetAnnouncementManager()->RemoveAnnouncer(this);
 163 }
 164
 165 void CGUIWindowSlideShow::Announce(ANNOUNCEMENT::AnnouncementFlag flag,
 166                                    const std::string& sender,
 167                                    const std::string& message,
 168                                    const CVariant& data)
 169 {
 170   if (flag & ANNOUNCEMENT::Player)
 171   {
 172     if (message == "OnPlay" || message == "OnResume")
 173     {
 174       if (data.isMember("player") && data["player"].isMember("playerid") &&
 175           data["player"]["playerid"] == static_cast<int>(PLAYLIST::Id::TYPE_VIDEO))
 176         Close();
 177     }
 178   }
 179 }
 180
 181 void CGUIWindowSlideShow::AnnouncePlayerPlay(const CFileItemPtr& item)
 182 {
 183   CVariant param;
 184   param["player"]["speed"] = m_bSlideShow && !m_bPause ? 1 : 0;
 185   param["player"]["playerid"] = static_cast<int>(PLAYLIST::Id::TYPE_PICTURE);
 186   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Player, "OnPlay", item, param);
 187 }
 188
 189 void CGUIWindowSlideShow::AnnouncePlayerPause(const CFileItemPtr& item)
 190 {
 191   CVariant param;
 192   param["player"]["speed"] = 0;
 193   param["player"]["playerid"] = static_cast<int>(PLAYLIST::Id::TYPE_PICTURE);
 194   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Player, "OnPause", item, param);
 195 }
 196
 197 void CGUIWindowSlideShow::AnnouncePlayerStop(const CFileItemPtr& item)
 198 {
 199   CVariant param;
 200   param["player"]["playerid"] = static_cast<int>(PLAYLIST::Id::TYPE_PICTURE);
 201   param["end"] = true;
 202   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Player, "OnStop", item, param);
 203 }
 204
 205 void CGUIWindowSlideShow::AnnouncePlaylistClear()
 206 {
 207   CVariant data;
 208   data["playlistid"] = static_cast<int>(PLAYLIST::Id::TYPE_PICTURE);
 209   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Playlist, "OnClear", data);
 210 }
 211
 212 void CGUIWindowSlideShow::AnnouncePlaylistAdd(const CFileItemPtr& item, int pos)
 213 {
 214   CVariant data;
 215   data["playlistid"] = static_cast<int>(PLAYLIST::Id::TYPE_PICTURE);
 216   data["position"] = pos;
 217   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Playlist, "OnAdd", item, data);
 218 }
 219
 220 void CGUIWindowSlideShow::AnnouncePropertyChanged(const std::string &strProperty, const CVariant &value)
 221 {
 222   if (strProperty.empty() || value.isNull())
 223     return;
 224
 225   CVariant data;
 226   data["player"]["playerid"] = static_cast<int>(PLAYLIST::Id::TYPE_PICTURE);
 227   data["property"][strProperty] = value;
 228   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Player, "OnPropertyChanged",
 229                                                      data);
 230 }
 231
 232 bool CGUIWindowSlideShow::IsPlaying() const
 233 {
 234   return m_Image[m_iCurrentPic]->IsLoaded();
 235 }
 236
 237 void CGUIWindowSlideShow::Reset()
 238 {
 239   m_bSlideShow = false;
 240   m_bShuffled = false;
 241   m_bPause = false;
 242   m_bPlayingVideo = false;
 243   m_bErrorMessage = false;
 244
 245   if (m_Image[0])
 246   {
 247     m_Image[0]->UnLoad();
 248     m_Image[0]->Close();
 249   }
 250
 251   m_Image[0] = CSlideShowPic::CreateSlideShowPicture();
 252
 253   if (m_Image[1])
 254   {
 255     m_Image[1]->UnLoad();
 256     m_Image[1]->Close();
 257   }
 258
 259   m_Image[1] = CSlideShowPic::CreateSlideShowPicture();
 260
 261   m_fRotate = 0.0f;
 262   m_fInitialRotate = 0.0f;
 263   m_iZoomFactor = 1;
 264   m_fZoom = 1.0f;
 265   m_fInitialZoom = 0.0f;
 266   m_iCurrentSlide = 0;
 267   m_iNextSlide = 1;
 268   m_iCurrentPic = 0;
 269   m_iDirection = 1;
 270   m_iLastFailedNextSlide = -1;
 271   m_slides.clear();
 272   AnnouncePlaylistClear();
 273   m_Resolution = CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution();
 274 }
 275
 276 void CGUIWindowSlideShow::OnDeinitWindow(int nextWindowID)
 277 {
 278   if (m_Resolution != CDisplaySettings::GetInstance().GetCurrentResolution())
 279   {
 280     //FIXME: Use GUI resolution for now
 281     //CServiceBroker::GetWinSystem()->GetGfxContext().SetVideoResolution(CDisplaySettings::GetInstance().GetCurrentResolution(), true);
 282   }
 283
 284   if (nextWindowID != WINDOW_FULLSCREEN_VIDEO &&
 285       nextWindowID != WINDOW_FULLSCREEN_GAME)
 286   {
 287     // wait for any outstanding picture loads
 288     if (m_pBackgroundLoader)
 289     {
 290       // sleep until the loader finishes loading the current pic
 291       CLog::Log(LOGDEBUG,"Waiting for BackgroundLoader thread to close");
 292       while (m_pBackgroundLoader->IsLoading())
 293         KODI::TIME::Sleep(10ms);
 294       // stop the thread
 295       CLog::Log(LOGDEBUG,"Stopping BackgroundLoader thread");
 296       m_pBackgroundLoader->StopThread();
 297       m_pBackgroundLoader.reset();
 298     }
 299     // and close the images.
 300     m_Image[0]->Close();
 301     m_Image[1]->Close();
 302   }
 303   CServiceBroker::GetGUI()->GetInfoManager().GetInfoProviders().GetPicturesInfoProvider().SetCurrentSlide(nullptr);
 304   m_bSlideShow = false;
 305
 306   CGUIDialog::OnDeinitWindow(nextWindowID);
 307 }
 308
 309 void CGUIWindowSlideShow::Add(const CFileItem *picture)
 310 {
 311   CFileItemPtr item(new CFileItem(*picture));
 312   if (!item->HasVideoInfoTag() && !item->HasPictureInfoTag())
 313   {
 314     // item without tag; get mimetype then we can tell whether it's video item
 315     item->FillInMimeType();
 316
 317     if (!IsVideo(*item))
 318       // then it is a picture and force tag generation
 319       item->GetPictureInfoTag();
 320   }
 321   AnnouncePlaylistAdd(item, m_slides.size());
 322
 323   m_slides.emplace_back(std::move(item));
 324 }
 325
 326 void CGUIWindowSlideShow::ShowNext()
 327 {
 328   if (m_slides.size() == 1)
 329     return;
 330
 331   m_iDirection   = 1;
 332   m_iNextSlide   = GetNextSlide();
 333   m_iZoomFactor  = 1;
 334   m_fZoom        = 1.0f;
 335   m_fRotate      = 0.0f;
 336   m_bLoadNextPic = true;
 337 }
 338
 339 void CGUIWindowSlideShow::ShowPrevious()
 340 {
 341   if (m_slides.size() == 1)
 342     return;
 343
 344   m_iDirection   = -1;
 345   m_iNextSlide   = GetNextSlide();
 346   m_iZoomFactor  = 1;
 347   m_fZoom        = 1.0f;
 348   m_fRotate      = 0.0f;
 349   m_bLoadNextPic = true;
 350 }
 351
 352 void CGUIWindowSlideShow::Select(const std::string& strPicture)
 353 {
 354   for (size_t i = 0; i < m_slides.size(); ++i)
 355   {
 356     const CFileItemPtr item = m_slides.at(i);
 357     if (item->GetPath() == strPicture)
 358     {
 359       m_iDirection = 1;
 360       if (!m_Image[m_iCurrentPic]->IsLoaded() &&
 361           (!m_pBackgroundLoader || !m_pBackgroundLoader->IsLoading()))
 362       {
 363         // will trigger loading current slide when next Process call.
 364         m_iCurrentSlide = i;
 365         m_iNextSlide = GetNextSlide();
 366       }
 367       else
 368       {
 369         m_iNextSlide = i;
 370         m_bLoadNextPic = true;
 371       }
 372       return ;
 373     }
 374   }
 375 }
 376
 377 void CGUIWindowSlideShow::GetSlideShowContents(CFileItemList &list)
 378 {
 379   for (size_t index = 0; index < m_slides.size(); index++)
 380     list.Add(std::make_shared<CFileItem>(*m_slides.at(index)));
 381 }
 382
 383 std::shared_ptr<const CFileItem> CGUIWindowSlideShow::GetCurrentSlide()
 384 {
 385   if (m_iCurrentSlide >= 0 && m_iCurrentSlide < static_cast<int>(m_slides.size()))
 386     return m_slides.at(m_iCurrentSlide);
 387   return CFileItemPtr();
 388 }
 389
 390 bool CGUIWindowSlideShow::InSlideShow() const
 391 {
 392   return m_bSlideShow;
 393 }
 394
 395 void CGUIWindowSlideShow::StartSlideShow()
 396 {
 397   m_bSlideShow = true;
 398   m_iDirection = 1;
 399   if (m_slides.size())
 400     AnnouncePlayerPlay(m_slides.at(m_iCurrentSlide));
 401 }
 402
 403 void CGUIWindowSlideShow::SetDirection(int direction)
 404 {
 405   direction = direction >= 0 ? 1 : -1;
 406   if (m_iDirection != direction)
 407   {
 408     m_iDirection = direction;
 409     m_iNextSlide = GetNextSlide();
 410   }
 411 }
 412
 413 void CGUIWindowSlideShow::Process(unsigned int currentTime, CDirtyRegionList &regions)
 414 {
 415   const RESOLUTION_INFO res = CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo();
 416
 417   // reset the screensaver if we're in a slideshow
 418   // (unless we are the screensaver!)
 419   auto& components = CServiceBroker::GetAppComponents();
 420   const auto appPower = components.GetComponent<CApplicationPowerHandling>();
 421   if (m_bSlideShow && !m_bPause && !appPower->IsInScreenSaver())
 422     appPower->ResetScreenSaver();
 423   int iSlides = m_slides.size();
 424   if (!iSlides)
 425     return;
 426
 427   // if we haven't processed yet, we should mark the whole screen
 428   if (!HasProcessed())
 429   {
 430     regions.emplace_back(CRect(
 431         0.0f, 0.0f, static_cast<float>(CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth()),
 432         static_cast<float>(CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight())));
 433     MarkDirtyRegion();
 434   }
 435
 436   if (m_iCurrentSlide < 0 || m_iCurrentSlide >= static_cast<int>(m_slides.size()))
 437     m_iCurrentSlide = 0;
 438   if (m_iNextSlide < 0 || m_iNextSlide >= static_cast<int>(m_slides.size()))
 439     m_iNextSlide = GetNextSlide();
 440
 441   // Create our background loader if necessary
 442   if (!m_pBackgroundLoader)
 443   {
 444     m_pBackgroundLoader = std::make_unique<CBackgroundPicLoader>();
 445     m_pBackgroundLoader->Create(this);
 446   }
 447
 448   bool bSlideShow = m_bSlideShow && !m_bPause && !m_bPlayingVideo;
 449   if (bSlideShow && m_slides.at(m_iCurrentSlide)->HasProperty("unplayable"))
 450   {
 451     m_iNextSlide = GetNextSlide();
 452     if (m_iCurrentSlide == m_iNextSlide)
 453       return;
 454     m_iCurrentSlide = m_iNextSlide;
 455     m_iNextSlide = GetNextSlide();
 456   }
 457
 458   if (m_bErrorMessage)
 459   { // we have an error when loading either the current or next picture
 460     // check to see if we have a picture loaded
 461     CLog::Log(LOGDEBUG, "We have an error loading picture {}!", m_pBackgroundLoader->SlideNumber());
 462     if (m_iCurrentSlide == m_pBackgroundLoader->SlideNumber())
 463     {
 464       if (m_Image[m_iCurrentPic]->IsLoaded())
 465       {
 466         // current image was already loaded, so we can ignore this error.
 467         m_bErrorMessage = false;
 468       }
 469       else
 470       {
 471         CLog::Log(LOGERROR, "Error loading the current image {}: {}", m_iCurrentSlide,
 472                   m_slides.at(m_iCurrentSlide)->GetPath());
 473         if (!IsVideo(*m_slides.at(m_iCurrentPic)))
 474         {
 475           // try next if we are in slideshow
 476           CLog::Log(LOGINFO, "set image {} unplayable", m_slides.at(m_iCurrentSlide)->GetPath());
 477           m_slides.at(m_iCurrentSlide)->SetProperty("unplayable", true);
 478         }
 479         if (m_bLoadNextPic || (bSlideShow && !m_bPause && !IsVideo(*m_slides.at(m_iCurrentPic))))
 480         {
 481           // change to next item, wait loading.
 482           m_iCurrentSlide = m_iNextSlide;
 483           m_iNextSlide    = GetNextSlide();
 484           m_bErrorMessage = false;
 485         }
 486         // else just drop through - there's nothing we can do (error message will be displayed)
 487       }
 488     }
 489     else if (m_iNextSlide == m_pBackgroundLoader->SlideNumber())
 490     {
 491       CLog::Log(LOGERROR, "Error loading the next image {}: {}", m_iNextSlide,
 492                 m_slides.at(m_iNextSlide)->GetPath());
 493       // load next image failed, then skip to load next of next if next is not video.
 494       if (!IsVideo(*m_slides.at(m_iNextSlide)))
 495       {
 496         CLog::Log(LOGINFO, "set image {} unplayable", m_slides.at(m_iNextSlide)->GetPath());
 497         m_slides.at(m_iNextSlide)->SetProperty("unplayable", true);
 498         // change to next item, wait loading.
 499         m_iNextSlide = GetNextSlide();
 500       }
 501       else
 502       { // prevent reload the next pic and repeat fail.
 503         m_iLastFailedNextSlide = m_iNextSlide;
 504       }
 505       m_bErrorMessage = false;
 506     }
 507     else
 508     { // Non-current and non-next slide, just ignore error.
 509       CLog::Log(LOGERROR, "Error loading the non-current non-next image {}/{}: {}", m_iNextSlide,
 510                 m_pBackgroundLoader->SlideNumber(), m_slides.at(m_iNextSlide)->GetPath());
 511       m_bErrorMessage = false;
 512     }
 513   }
 514
 515   if (m_bErrorMessage)
 516   { // hack, just mark it all
 517     regions.emplace_back(CRect(
 518         0.0f, 0.0f, static_cast<float>(CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth()),
 519         static_cast<float>(CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight())));
 520     MarkDirtyRegion();
 521     return;
 522   }
 523
 524   if (!m_Image[m_iCurrentPic]->IsLoaded() && !m_pBackgroundLoader->IsLoading())
 525   { // load first image
 526     CFileItemPtr item = m_slides.at(m_iCurrentSlide);
 527     std::string picturePath = GetPicturePath(item.get());
 528     if (!picturePath.empty())
 529     {
 530       if (IsVideo(*item))
 531         CLog::Log(LOGDEBUG, "Loading the thumb {} for current video {}: {}", picturePath,
 532                   m_iCurrentSlide, item->GetPath());
 533       else
 534         CLog::Log(LOGDEBUG, "Loading the current image {}: {}", m_iCurrentSlide, item->GetPath());
 535
 536       // load using the background loader
 537       int maxWidth, maxHeight;
 538
 539       GetCheckedSize((float)res.iWidth * m_fZoom,
 540         (float)res.iHeight * m_fZoom,
 541         maxWidth, maxHeight);
 542       m_pBackgroundLoader->LoadPic(m_iCurrentPic, m_iCurrentSlide, picturePath, maxWidth, maxHeight);
 543       m_iLastFailedNextSlide = -1;
 544       m_bLoadNextPic = false;
 545     }
 546   }
 547
 548   // check if we should discard an already loaded next slide
 549   if (m_Image[1 - m_iCurrentPic]->IsLoaded() &&
 550       m_Image[1 - m_iCurrentPic]->SlideNumber() != m_iNextSlide)
 551     m_Image[1 - m_iCurrentPic]->Close();
 552
 553   if (m_iNextSlide != m_iCurrentSlide && m_Image[m_iCurrentPic]->IsLoaded() &&
 554       !m_Image[1 - m_iCurrentPic]->IsLoaded() && !m_pBackgroundLoader->IsLoading() &&
 555       m_iLastFailedNextSlide != m_iNextSlide)
 556   { // load the next image
 557     m_iLastFailedNextSlide = -1;
 558     CFileItemPtr item = m_slides.at(m_iNextSlide);
 559     std::string picturePath = GetPicturePath(item.get());
 560     if (!picturePath.empty() && (!IsVideo(*item) || !m_bSlideShow || m_bPause))
 561     {
 562       if (IsVideo(*item))
 563         CLog::Log(LOGDEBUG, "Loading the thumb {} for next video {}: {}", picturePath, m_iNextSlide,
 564                   item->GetPath());
 565       else
 566         CLog::Log(LOGDEBUG, "Loading the next image {}: {}", m_iNextSlide, item->GetPath());
 567
 568       int maxWidth, maxHeight;
 569       GetCheckedSize((float)res.iWidth * m_fZoom,
 570                      (float)res.iHeight * m_fZoom,
 571                      maxWidth, maxHeight);
 572       m_pBackgroundLoader->LoadPic(1 - m_iCurrentPic, m_iNextSlide, picturePath, maxWidth, maxHeight);
 573     }
 574   }
 575
 576   bool bPlayVideo = IsVideo(*m_slides.at(m_iCurrentSlide)) && m_iVideoSlide != m_iCurrentSlide;
 577   if (bPlayVideo)
 578     bSlideShow = false;
 579
 580   // render the current image
 581   if (m_Image[m_iCurrentPic]->IsLoaded())
 582   {
 583     if (m_Image[m_iCurrentPic]->IsAnimating())
 584       MarkDirtyRegion();
 585
 586     m_Image[m_iCurrentPic]->SetInSlideshow(bSlideShow);
 587     m_Image[m_iCurrentPic]->Pause(!bSlideShow);
 588     m_Image[m_iCurrentPic]->Process(currentTime, regions);
 589   }
 590
 591   // Check if we should be transitioning immediately
 592   if (m_bLoadNextPic && m_Image[m_iCurrentPic]->IsLoaded())
 593   {
 594     CLog::Log(LOGDEBUG, "Starting immediate transition due to user wanting slide {}",
 595               m_slides.at(m_iNextSlide)->GetPath());
 596     if (m_Image[m_iCurrentPic]->StartTransition())
 597     {
 598       m_Image[m_iCurrentPic]->SetTransitionTime(1, IMMEDIATE_TRANSITION_TIME);
 599       m_bLoadNextPic = false;
 600       MarkDirtyRegion();
 601     }
 602   }
 603
 604   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 605
 606   // render the next image
 607   if (m_Image[m_iCurrentPic]->DrawNextImage())
 608   {
 609     if (m_bSlideShow && !m_bPause && IsVideo(*m_slides.at(m_iNextSlide)))
 610     {
 611       // do not show thumb of video when playing slideshow
 612     }
 613     else if (m_Image[1 - m_iCurrentPic]->IsLoaded())
 614     {
 615       if (appPlayer->IsPlayingVideo())
 616         appPlayer->ClosePlayer();
 617       m_bPlayingVideo = false;
 618       m_iVideoSlide = -1;
 619
 620       // first time render the next image, make sure using current display effect.
 621       if (!m_Image[1 - m_iCurrentPic]->IsStarted())
 622       {
 623         CSlideShowPic::DISPLAY_EFFECT effect = GetDisplayEffect(m_iNextSlide);
 624         if (m_Image[1 - m_iCurrentPic]->DisplayEffectNeedChange(effect))
 625           m_Image[1 - m_iCurrentPic]->Reset(effect);
 626       }
 627
 628       if (m_Image[1 - m_iCurrentPic]->IsAnimating())
 629         MarkDirtyRegion();
 630
 631       // set the appropriate transition time
 632       m_Image[1 - m_iCurrentPic]->SetTransitionTime(0,
 633                                                     m_Image[m_iCurrentPic]->GetTransitionTime(1));
 634       m_Image[1 - m_iCurrentPic]->Pause(!m_bSlideShow || m_bPause ||
 635                                         IsVideo(*m_slides.at(m_iNextSlide)));
 636       m_Image[1 - m_iCurrentPic]->Process(currentTime, regions);
 637     }
 638     else // next pic isn't loaded.  We should hang around if it is in progress
 639     {
 640       if (m_pBackgroundLoader->IsLoading())
 641       {
 642         //        CLog::Log(LOGDEBUG, "Having to hold the current image ({}) while we load {}", m_vecSlides[m_iCurrentSlide], m_vecSlides[m_iNextSlide]);
 643         m_Image[m_iCurrentPic]->Keep();
 644       }
 645     }
 646   }
 647
 648   // check if we should swap images now
 649   if (m_Image[m_iCurrentPic]->IsFinished() ||
 650       (m_bLoadNextPic && !m_Image[m_iCurrentPic]->IsLoaded()))
 651   {
 652     m_bLoadNextPic = false;
 653     if (m_Image[m_iCurrentPic]->IsFinished())
 654       CLog::Log(LOGDEBUG, "Image {} is finished rendering, switching to {}",
 655                 m_slides.at(m_iCurrentSlide)->GetPath(), m_slides.at(m_iNextSlide)->GetPath());
 656     else
 657       // what if it's bg loading?
 658       CLog::Log(LOGDEBUG, "Image {} is not loaded, switching to {}",
 659                 m_slides.at(m_iCurrentSlide)->GetPath(), m_slides.at(m_iNextSlide)->GetPath());
 660
 661     if (m_Image[m_iCurrentPic]->IsFinished() && m_iCurrentSlide == m_iNextSlide &&
 662         m_Image[m_iCurrentPic]->SlideNumber() == m_iNextSlide)
 663       m_Image[m_iCurrentPic]->Reset(GetDisplayEffect(m_iCurrentSlide));
 664     else
 665     {
 666       if (m_Image[m_iCurrentPic]->IsLoaded())
 667         m_Image[m_iCurrentPic]->Reset(GetDisplayEffect(m_iCurrentSlide));
 668       else
 669         m_Image[m_iCurrentPic]->Close();
 670
 671       if ((m_Image[1 - m_iCurrentPic]->IsLoaded() &&
 672            m_Image[1 - m_iCurrentPic]->SlideNumber() == m_iNextSlide) ||
 673           (m_pBackgroundLoader->IsLoading() && m_pBackgroundLoader->SlideNumber() == m_iNextSlide &&
 674            m_pBackgroundLoader->Pic() == 1 - m_iCurrentPic))
 675       {
 676         m_iCurrentPic = 1 - m_iCurrentPic;
 677       }
 678       else
 679       {
 680         m_Image[1 - m_iCurrentPic]->Close();
 681         m_iCurrentPic = 1 - m_iCurrentPic;
 682       }
 683       m_iCurrentSlide = m_iNextSlide;
 684       m_iNextSlide    = GetNextSlide();
 685
 686       bPlayVideo = IsVideo(*m_slides.at(m_iCurrentSlide)) && m_iVideoSlide != m_iCurrentSlide;
 687     }
 688     AnnouncePlayerPlay(m_slides.at(m_iCurrentSlide));
 689
 690     m_iZoomFactor = 1;
 691     m_fZoom = 1.0f;
 692     m_fRotate = 0.0f;
 693   }
 694
 695   if (bPlayVideo && !PlayVideo())
 696       return;
 697
 698   if (m_Image[m_iCurrentPic]->IsLoaded())
 699     CServiceBroker::GetGUI()->GetInfoManager().GetInfoProviders().GetPicturesInfoProvider().SetCurrentSlide(m_slides.at(m_iCurrentSlide).get());
 700
 701   RenderPause();
 702   if (IsVideo(*m_slides.at(m_iCurrentSlide)) && appPlayer && appPlayer->IsRenderingGuiLayer())
 703   {
 704     MarkDirtyRegion();
 705   }
 706   CGUIWindow::Process(currentTime, regions);
 707   m_renderRegion.SetRect(0, 0, (float)CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth(), (float)CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight());
 708 }
 709
 710 void CGUIWindowSlideShow::Render()
 711 {
 712   if (m_slides.empty())
 713     return;
 714
 715   CGraphicContext& gfxCtx = CServiceBroker::GetWinSystem()->GetGfxContext();
 716   gfxCtx.Clear(0xff000000);
 717
 718   if (IsVideo(*m_slides.at(m_iCurrentSlide)))
 719   {
 720     gfxCtx.SetViewWindow(0, 0, m_coordsRes.iWidth, m_coordsRes.iHeight);
 721     gfxCtx.SetRenderingResolution(gfxCtx.GetVideoResolution(), false);
 722
 723     auto& components = CServiceBroker::GetAppComponents();
 724     const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 725
 726     if (appPlayer->IsRenderingVideoLayer())
 727     {
 728       const CRect old = gfxCtx.GetScissors();
 729       CRect region = GetRenderRegion();
 730       region.Intersect(old);
 731       gfxCtx.SetScissors(region);
 732       gfxCtx.Clear(0);
 733       gfxCtx.SetScissors(old);
 734     }
 735     else if (appPlayer)
 736     {
 737       const ::UTILS::COLOR::Color alpha = gfxCtx.MergeAlpha(0xff000000) >> 24;
 738       appPlayer->Render(false, alpha);
 739     }
 740
 741     gfxCtx.SetRenderingResolution(m_coordsRes, m_needsScaling);
 742   }
 743   else
 744   {
 745     if (m_Image[m_iCurrentPic]->IsLoaded())
 746       m_Image[m_iCurrentPic]->Render();
 747
 748     if (m_Image[m_iCurrentPic]->DrawNextImage() && m_Image[1 - m_iCurrentPic]->IsLoaded())
 749       m_Image[1 - m_iCurrentPic]->Render();
 750   }
 751
 752   RenderErrorMessage();
 753   CGUIWindow::Render();
 754 }
 755
 756 void CGUIWindowSlideShow::RenderEx()
 757 {
 758   if (IsVideo(*m_slides.at(m_iCurrentSlide)))
 759   {
 760     auto& components = CServiceBroker::GetAppComponents();
 761     const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 762     appPlayer->Render(false, 255, false);
 763   }
 764
 765   CGUIWindow::RenderEx();
 766 }
 767
 768 int CGUIWindowSlideShow::GetNextSlide()
 769 {
 770   if (m_slides.size() <= 1)
 771     return m_iCurrentSlide;
 772   int step = m_iDirection >= 0 ? 1 : -1;
 773   int nextSlide = (m_iCurrentSlide + step + m_slides.size()) % m_slides.size();
 774   while (nextSlide != m_iCurrentSlide)
 775   {
 776     if (!m_slides.at(nextSlide)->HasProperty("unplayable"))
 777       return nextSlide;
 778     nextSlide = (nextSlide + step + m_slides.size()) % m_slides.size();
 779   }
 780   return m_iCurrentSlide;
 781 }
 782
 783 EVENT_RESULT CGUIWindowSlideShow::OnMouseEvent(const CPoint& point, const MOUSE::CMouseEvent& event)
 784 {
 785   if (event.m_id == ACTION_GESTURE_NOTIFY)
 786   {
 787     int result = EVENT_RESULT_ROTATE | EVENT_RESULT_ZOOM;
 788     if (m_iZoomFactor == 1 || !m_Image[m_iCurrentPic]->m_bCanMoveHorizontally)
 789       result |= EVENT_RESULT_SWIPE;
 790     else
 791       result |= EVENT_RESULT_PAN_HORIZONTAL;
 792
 793     if (m_Image[m_iCurrentPic]->m_bCanMoveVertically)
 794       result |= EVENT_RESULT_PAN_VERTICAL;
 795
 796     return (EVENT_RESULT)result;
 797   }
 798   else if (event.m_id == ACTION_GESTURE_BEGIN)
 799   {
 800     m_firstGesturePoint = point;
 801     m_fInitialZoom = m_fZoom;
 802     m_fInitialRotate = m_fRotate;
 803     return EVENT_RESULT_HANDLED;
 804   }
 805   else if (event.m_id == ACTION_GESTURE_PAN)
 806   {
 807     // zoomed in - free move mode
 808     if (m_iZoomFactor != 1 && (m_Image[m_iCurrentPic]->m_bCanMoveHorizontally ||
 809                                m_Image[m_iCurrentPic]->m_bCanMoveVertically))
 810     {
 811       Move(PICTURE_MOVE_AMOUNT_TOUCH / m_iZoomFactor * (m_firstGesturePoint.x - point.x), PICTURE_MOVE_AMOUNT_TOUCH / m_iZoomFactor * (m_firstGesturePoint.y - point.y));
 812       m_firstGesturePoint = point;
 813     }
 814     return EVENT_RESULT_HANDLED;
 815   }
 816   else if (event.m_id == ACTION_GESTURE_SWIPE_LEFT || event.m_id == ACTION_GESTURE_SWIPE_RIGHT)
 817   {
 818     if (m_iZoomFactor == 1 || !m_Image[m_iCurrentPic]->m_bCanMoveHorizontally)
 819     {
 820       // on zoomlevel 1 just detect swipe left and right
 821       if (event.m_id == ACTION_GESTURE_SWIPE_LEFT)
 822         OnAction(CAction(ACTION_NEXT_PICTURE));
 823       else
 824         OnAction(CAction(ACTION_PREV_PICTURE));
 825     }
 826   }
 827   else if (event.m_id == ACTION_GESTURE_END || event.m_id == ACTION_GESTURE_ABORT)
 828   {
 829     if (m_fRotate != 0.0f)
 830     {
 831       // "snap" to nearest of 0, 90, 180 and 270 if the
 832       // difference in angle is +/-10 degrees
 833       float reminder = fmodf(m_fRotate, 90.0f);
 834       if (fabs(reminder) < ROTATION_SNAP_RANGE)
 835         Rotate(-reminder);
 836       else if (reminder > 90.0f - ROTATION_SNAP_RANGE)
 837         Rotate(90.0f - reminder);
 838       else if (-reminder > 90.0f - ROTATION_SNAP_RANGE)
 839         Rotate(-90.0f - reminder);
 840     }
 841
 842     m_fInitialZoom = 0.0f;
 843     m_fInitialRotate = 0.0f;
 844     return EVENT_RESULT_HANDLED;
 845   }
 846   else if (event.m_id == ACTION_GESTURE_ZOOM)
 847   {
 848     ZoomRelative(m_fInitialZoom * event.m_offsetX, true);
 849     return EVENT_RESULT_HANDLED;
 850   }
 851   else if (event.m_id == ACTION_GESTURE_ROTATE)
 852   {
 853     Rotate(m_fInitialRotate + event.m_offsetX - m_fRotate, true);
 854     return EVENT_RESULT_HANDLED;
 855   }
 856   return EVENT_RESULT_UNHANDLED;
 857 }
 858
 859 bool CGUIWindowSlideShow::OnAction(const CAction &action)
 860 {
 861   switch (action.GetID())
 862   {
 863   case ACTION_SHOW_INFO:
 864     {
 865       CGUIDialogPictureInfo *pictureInfo = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogPictureInfo>(WINDOW_DIALOG_PICTURE_INFO);
 866       if (pictureInfo)
 867       {
 868         // no need to set the picture here, it's done in Render()
 869         pictureInfo->Open();
 870       }
 871     }
 872     break;
 873   case ACTION_STOP:
 874   {
 875     if (m_slides.size())
 876       AnnouncePlayerStop(m_slides.at(m_iCurrentSlide));
 877     auto& components = CServiceBroker::GetAppComponents();
 878     const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 879     if (appPlayer->IsPlayingVideo())
 880       appPlayer->ClosePlayer();
 881     Close();
 882     break;
 883   }
 884
 885   case ACTION_NEXT_PICTURE:
 886       ShowNext();
 887     break;
 888
 889   case ACTION_PREV_PICTURE:
 890       ShowPrevious();
 891     break;
 892
 893   case ACTION_MOVE_RIGHT:
 894     if (m_iZoomFactor == 1 || !m_Image[m_iCurrentPic]->m_bCanMoveHorizontally)
 895       ShowNext();
 896     else
 897       Move(PICTURE_MOVE_AMOUNT, 0);
 898     break;
 899
 900   case ACTION_MOVE_LEFT:
 901     if (m_iZoomFactor == 1 || !m_Image[m_iCurrentPic]->m_bCanMoveHorizontally)
 902       ShowPrevious();
 903     else
 904       Move( -PICTURE_MOVE_AMOUNT, 0);
 905     break;
 906
 907   case ACTION_MOVE_DOWN:
 908     Move(0, PICTURE_MOVE_AMOUNT);
 909     break;
 910
 911   case ACTION_MOVE_UP:
 912     Move(0, -PICTURE_MOVE_AMOUNT);
 913     break;
 914
 915   case ACTION_PAUSE:
 916   case ACTION_PLAYER_PLAY:
 917     if (m_slides.size() == 0)
 918       break;
 919     if (IsVideo(*m_slides.at(m_iCurrentSlide)))
 920     {
 921       if (!m_bPlayingVideo)
 922       {
 923         if (m_bSlideShow)
 924         {
 925           SetDirection(1);
 926           m_bPause = false;
 927         }
 928         PlayVideo();
 929       }
 930     }
 931     else if (!m_bSlideShow || m_bPause)
 932     {
 933       m_bSlideShow = true;
 934       m_bPause = false;
 935       SetDirection(1);
 936       if (m_Image[m_iCurrentPic]->IsLoaded())
 937       {
 938         CSlideShowPic::DISPLAY_EFFECT effect = GetDisplayEffect(m_iCurrentSlide);
 939         if (m_Image[m_iCurrentPic]->DisplayEffectNeedChange(effect))
 940           m_Image[m_iCurrentPic]->Reset(effect);
 941       }
 942       AnnouncePlayerPlay(m_slides.at(m_iCurrentSlide));
 943     }
 944     else if (action.GetID() == ACTION_PAUSE)
 945     {
 946       m_bPause = true;
 947       AnnouncePlayerPause(m_slides.at(m_iCurrentSlide));
 948     }
 949     break;
 950
 951   case ACTION_ZOOM_OUT:
 952     Zoom(m_iZoomFactor - 1);
 953     break;
 954
 955   case ACTION_ZOOM_IN:
 956     Zoom(m_iZoomFactor + 1);
 957     break;
 958
 959   case ACTION_GESTURE_SWIPE_UP:
 960   case ACTION_GESTURE_SWIPE_DOWN:
 961     if (m_iZoomFactor == 1 || !m_Image[m_iCurrentPic]->m_bCanMoveVertically)
 962     {
 963       bool swipeOnLeft = action.GetAmount() < CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth() / 2.0f;
 964       bool swipeUp = action.GetID() == ACTION_GESTURE_SWIPE_UP;
 965       if (swipeUp == swipeOnLeft)
 966         Rotate(90.0f);
 967       else
 968         Rotate(-90.0f);
 969     }
 970     break;
 971
 972   case ACTION_ROTATE_PICTURE_CW:
 973     Rotate(90.0f);
 974     break;
 975
 976   case ACTION_ROTATE_PICTURE_CCW:
 977     Rotate(-90.0f);
 978     break;
 979
 980   case ACTION_ZOOM_LEVEL_NORMAL:
 981   case ACTION_ZOOM_LEVEL_1:
 982   case ACTION_ZOOM_LEVEL_2:
 983   case ACTION_ZOOM_LEVEL_3:
 984   case ACTION_ZOOM_LEVEL_4:
 985   case ACTION_ZOOM_LEVEL_5:
 986   case ACTION_ZOOM_LEVEL_6:
 987   case ACTION_ZOOM_LEVEL_7:
 988   case ACTION_ZOOM_LEVEL_8:
 989   case ACTION_ZOOM_LEVEL_9:
 990     Zoom((action.GetID() - ACTION_ZOOM_LEVEL_NORMAL) + 1);
 991     break;
 992
 993   case ACTION_ANALOG_MOVE:
 994     // this action is used and works, when CAction object provides both x and y coordinates
 995     Move(action.GetAmount()*PICTURE_MOVE_AMOUNT_ANALOG, -action.GetAmount(1)*PICTURE_MOVE_AMOUNT_ANALOG);
 996     break;
 997   case ACTION_ANALOG_MOVE_X_LEFT:
 998     Move(-action.GetAmount()*PICTURE_MOVE_AMOUNT_ANALOG, 0.0f);
 999     break;
1000   case ACTION_ANALOG_MOVE_X_RIGHT:
1001     Move(action.GetAmount()*PICTURE_MOVE_AMOUNT_ANALOG, 0.0f);
1002     break;
1003   case ACTION_ANALOG_MOVE_Y_UP:
1004     Move(0.0f, -action.GetAmount()*PICTURE_MOVE_AMOUNT_ANALOG);
1005     break;
1006   case ACTION_ANALOG_MOVE_Y_DOWN:
1007     Move(0.0f, action.GetAmount()*PICTURE_MOVE_AMOUNT_ANALOG);
1008     break;
1009
1010   default:
1011     return CGUIDialog::OnAction(action);
1012   }
1013   MarkDirtyRegion();
1014   return true;
1015 }
1016
1017 void CGUIWindowSlideShow::RenderErrorMessage()
1018 {
1019   if (!m_bErrorMessage)
1020     return ;
1021
1022   const CGUIControl *control = GetControl(LABEL_ROW1);
1023   if (NULL == control || control->GetControlType() != CGUIControl::GUICONTROL_LABEL)
1024   {
1025      return;
1026   }
1027
1028   CGUIFont *pFont = static_cast<const CGUILabelControl*>(control)->GetLabelInfo().font;
1029   CGUITextLayout::DrawText(pFont, 0.5f*CServiceBroker::GetWinSystem()->GetGfxContext().GetWidth(), 0.5f*CServiceBroker::GetWinSystem()->GetGfxContext().GetHeight(), 0xffffffff, 0, g_localizeStrings.Get(747), XBFONT_CENTER_X | XBFONT_CENTER_Y);
1030 }
1031
1032 bool CGUIWindowSlideShow::OnMessage(CGUIMessage& message)
1033 {
1034   switch ( message.GetMessage() )
1035   {
1036   case GUI_MSG_WINDOW_INIT:
1037     {
1038       m_Resolution = (RESOLUTION) CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_PICTURES_DISPLAYRESOLUTION);
1039
1040       //FIXME: Use GUI resolution for now
1041       if (false /*m_Resolution != CDisplaySettings::GetInstance().GetCurrentResolution() && m_Resolution != INVALID && m_Resolution!=AUTORES*/)
1042         CServiceBroker::GetWinSystem()->GetGfxContext().SetVideoResolution(m_Resolution, false);
1043       else
1044         m_Resolution = CServiceBroker::GetWinSystem()->GetGfxContext().GetVideoResolution();
1045
1046       CGUIDialog::OnMessage(message);
1047
1048       // turn off slideshow if we only have 1 image
1049       if (m_slides.size() <= 1)
1050         m_bSlideShow = false;
1051
1052       return true;
1053     }
1054     break;
1055
1056   case GUI_MSG_SHOW_PICTURE:
1057     {
1058       const std::string& strFile = message.GetStringParam();
1059       Reset();
1060       CFileItem item(strFile, false);
1061       Add(&item);
1062       RunSlideShow("", false, false, true, "", false);
1063     }
1064     break;
1065
1066   case GUI_MSG_START_SLIDESHOW:
1067     {
1068       const std::string& strFolder = message.GetStringParam();
1069       unsigned int iParams = message.GetParam1();
1070       const std::string& beginSlidePath = message.GetStringParam(1);
1071       //decode params
1072       bool bRecursive = false;
1073       bool bRandom = false;
1074       bool bNotRandom = false;
1075       bool bPause = false;
1076       if (iParams > 0)
1077       {
1078         if ((iParams & 1) == 1)
1079           bRecursive = true;
1080         if ((iParams & 2) == 2)
1081           bRandom = true;
1082         if ((iParams & 4) == 4)
1083           bNotRandom = true;
1084         if ((iParams & 8) == 8)
1085           bPause = true;
1086       }
1087       RunSlideShow(strFolder, bRecursive, bRandom, bNotRandom, beginSlidePath, !bPause);
1088     }
1089     break;
1090
1091     case GUI_MSG_PLAYLISTPLAYER_STOPPED:
1092       {
1093       }
1094       break;
1095
1096     case GUI_MSG_PLAYBACK_STOPPED:
1097       {
1098         if (m_bPlayingVideo)
1099         {
1100           m_bPlayingVideo = false;
1101           m_iVideoSlide = -1;
1102           if (m_bSlideShow)
1103             m_bPause = true;
1104         }
1105       }
1106       break;
1107
1108     case GUI_MSG_PLAYBACK_ENDED:
1109       {
1110         if (m_bPlayingVideo)
1111         {
1112           m_bPlayingVideo = false;
1113           m_iVideoSlide = -1;
1114           if (m_bSlideShow)
1115           {
1116             m_bPause = false;
1117             if (m_iCurrentSlide == m_iNextSlide)
1118               break;
1119             m_Image[m_iCurrentPic]->Close();
1120             m_iCurrentPic = 1 - m_iCurrentPic;
1121             m_iCurrentSlide = m_iNextSlide;
1122             m_iNextSlide    = GetNextSlide();
1123             AnnouncePlayerPlay(m_slides.at(m_iCurrentSlide));
1124             m_iZoomFactor = 1;
1125             m_fZoom = 1.0f;
1126             m_fRotate = 0.0f;
1127           }
1128         }
1129       }
1130       break;
1131   }
1132   return CGUIDialog::OnMessage(message);
1133 }
1134
1135 void CGUIWindowSlideShow::RenderPause()
1136 { // display the pause icon
1137   if (m_bPause)
1138   {
1139     SET_CONTROL_VISIBLE(CONTROL_PAUSE);
1140   }
1141   else
1142   {
1143     SET_CONTROL_HIDDEN(CONTROL_PAUSE);
1144   }
1145 }
1146
1147 void CGUIWindowSlideShow::Rotate(float fAngle, bool immediate /* = false */)
1148 {
1149   if (m_Image[m_iCurrentPic]->DrawNextImage())
1150     return;
1151
1152   m_fRotate += fAngle;
1153
1154   m_Image[m_iCurrentPic]->Rotate(fAngle, immediate);
1155 }
1156
1157 void CGUIWindowSlideShow::Zoom(int iZoom)
1158 {
1159   if (iZoom > MAX_ZOOM_FACTOR || iZoom < 1)
1160     return;
1161
1162   ZoomRelative(zoomamount[iZoom - 1]);
1163 }
1164
1165 void CGUIWindowSlideShow::ZoomRelative(float fZoom, bool immediate /* = false */)
1166 {
1167   if (fZoom < zoomamount[0])
1168     fZoom = zoomamount[0];
1169   else if (fZoom > zoomamount[MAX_ZOOM_FACTOR - 1])
1170     fZoom = zoomamount[MAX_ZOOM_FACTOR - 1];
1171
1172   if (m_Image[m_iCurrentPic]->DrawNextImage())
1173     return;
1174
1175   m_fZoom = fZoom;
1176
1177   // find the nearest zoom factor
1178   for (unsigned int i = 1; i < MAX_ZOOM_FACTOR; i++)
1179   {
1180     if (m_fZoom > zoomamount[i])
1181       continue;
1182
1183     if (fabs(m_fZoom - zoomamount[i - 1]) < fabs(m_fZoom - zoomamount[i]))
1184       m_iZoomFactor = i;
1185     else
1186       m_iZoomFactor = i + 1;
1187
1188     break;
1189   }
1190
1191   m_Image[m_iCurrentPic]->Zoom(m_fZoom, immediate);
1192 }
1193
1194 void CGUIWindowSlideShow::Move(float fX, float fY)
1195 {
1196   if (m_Image[m_iCurrentPic]->IsLoaded() && m_Image[m_iCurrentPic]->GetZoom() > 1)
1197   { // we move in the opposite direction, due to the fact we are moving
1198     // the viewing window, not the picture.
1199     m_Image[m_iCurrentPic]->Move(-fX, -fY);
1200   }
1201 }
1202
1203 bool CGUIWindowSlideShow::PlayVideo()
1204 {
1205   CFileItemPtr item = m_slides.at(m_iCurrentSlide);
1206   if (!item || !IsVideo(*item))
1207     return false;
1208   CLog::Log(LOGDEBUG, "Playing current video slide {}", item->GetPath());
1209   m_bPlayingVideo = true;
1210   m_iVideoSlide = m_iCurrentSlide;
1211   bool ret = g_application.PlayFile(*item, "");
1212   if (ret == true)
1213     return true;
1214   else
1215   {
1216     CLog::Log(LOGINFO, "set video {} unplayable", item->GetPath());
1217     item->SetProperty("unplayable", true);
1218   }
1219   m_bPlayingVideo = false;
1220   m_iVideoSlide = -1;
1221   return false;
1222 }
1223
1224 CSlideShowPic::DISPLAY_EFFECT CGUIWindowSlideShow::GetDisplayEffect(int iSlideNumber) const
1225 {
1226   if (m_bSlideShow && !m_bPause && !IsVideo(*m_slides.at(iSlideNumber)))
1227     return CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_SLIDESHOW_DISPLAYEFFECTS) ? CSlideShowPic::EFFECT_RANDOM : CSlideShowPic::EFFECT_NONE;
1228   else
1229     return CSlideShowPic::EFFECT_NO_TIMEOUT;
1230 }
1231
1232 void CGUIWindowSlideShow::OnLoadPic(int iPic,
1233                                     int iSlideNumber,
1234                                     const std::string& strFileName,
1235                                     std::unique_ptr<CTexture> pTexture,
1236                                     bool bFullSize)
1237 {
1238   if (pTexture)
1239   {
1240     // set the pic's texture + size etc.
1241     if (iSlideNumber >= static_cast<int>(m_slides.size()) || GetPicturePath(m_slides.at(iSlideNumber).get()) != strFileName)
1242     { // throw this away - we must have cleared the slideshow while we were still loading
1243       return;
1244     }
1245     CLog::Log(LOGDEBUG, "Finished background loading slot {}, {}: {}", iPic, iSlideNumber,
1246               m_slides.at(iSlideNumber)->GetPath());
1247     m_Image[iPic]->SetOriginalSize(pTexture->GetOriginalWidth(), pTexture->GetOriginalHeight(),
1248                                    bFullSize);
1249     m_Image[iPic]->SetTexture(iSlideNumber, std::move(pTexture), GetDisplayEffect(iSlideNumber));
1250
1251     m_Image[iPic]->m_bIsComic = false;
1252     if (URIUtils::IsInRAR(m_slides.at(m_iCurrentSlide)->GetPath()) || URIUtils::IsInZIP(m_slides.at(m_iCurrentSlide)->GetPath())) // move to top for cbr/cbz
1253     {
1254       CURL url(m_slides.at(m_iCurrentSlide)->GetPath());
1255       const std::string& strHostName = url.GetHostName();
1256       if (URIUtils::HasExtension(strHostName, ".cbr|.cbz"))
1257       {
1258         m_Image[iPic]->m_bIsComic = true;
1259         m_Image[iPic]->Move((float)m_Image[iPic]->GetOriginalWidth(),
1260                             (float)m_Image[iPic]->GetOriginalHeight());
1261       }
1262     }
1263   }
1264   else if (iSlideNumber >= static_cast<int>(m_slides.size()) || GetPicturePath(m_slides.at(iSlideNumber).get()) != strFileName)
1265   { // Failed to load image. and not match values calling LoadPic, then something is changed, ignore.
1266     CLog::Log(LOGDEBUG,
1267               "CGUIWindowSlideShow::OnLoadPic({}, {}, {}) on failure not match current state (cur "
1268               "{}, next {}, curpic {}, pic[0, 1].slidenumber={}, {}, {})",
1269               iPic, iSlideNumber, strFileName, m_iCurrentSlide, m_iNextSlide, m_iCurrentPic,
1270               m_Image[0]->SlideNumber(), m_Image[1]->SlideNumber(),
1271               iSlideNumber >= static_cast<int>(m_slides.size())
1272                   ? ""
1273                   : m_slides.at(iSlideNumber)->GetPath());
1274   }
1275   else
1276   { // Failed to load image.  What should be done??
1277     // We should wait for the current pic to finish rendering, then transition it out,
1278     // release the texture, and try and reload this pic from scratch
1279     m_bErrorMessage = true;
1280   }
1281   MarkDirtyRegion();
1282 }
1283
1284 void CGUIWindowSlideShow::Shuffle()
1285 {
1286   KODI::UTILS::RandomShuffle(m_slides.begin(), m_slides.end());
1287   m_iCurrentSlide = 0;
1288   m_iNextSlide = GetNextSlide();
1289   m_bShuffled = true;
1290
1291   AnnouncePropertyChanged("shuffled", true);
1292 }
1293
1294 int CGUIWindowSlideShow::NumSlides() const
1295 {
1296   return m_slides.size();
1297 }
1298
1299 int CGUIWindowSlideShow::CurrentSlide() const
1300 {
1301   return m_iCurrentSlide + 1;
1302 }
1303
1304 void CGUIWindowSlideShow::AddFromPath(const std::string &strPath,
1305                                       bool bRecursive,
1306                                       SortBy method, SortOrder order, SortAttribute sortAttributes,
1307                                       const std::string &strExtensions)
1308 {
1309   if (strPath!="")
1310   {
1311     // reset the slideshow
1312     Reset();
1313     if (bRecursive)
1314     {
1315       path_set recursivePaths;
1316       AddItems(strPath, &recursivePaths, method, order, sortAttributes);
1317     }
1318     else
1319       AddItems(strPath, NULL, method, order, sortAttributes);
1320   }
1321 }
1322
1323 void CGUIWindowSlideShow::RunSlideShow(const std::string &strPath,
1324                                        bool bRecursive /* = false */, bool bRandom /* = false */,
1325                                        bool bNotRandom /* = false */, const std::string &beginSlidePath /* = "" */,
1326                                        bool startSlideShow /* = true */, SortBy method /* = SortByLabel */,
1327                                        SortOrder order /* = SortOrderAscending */, SortAttribute sortAttributes /* = SortAttributeNone */,
1328                                        const std::string &strExtensions)
1329 {
1330   // stop any video
1331   const auto& components = CServiceBroker::GetAppComponents();
1332   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
1333   if (appPlayer->IsPlayingVideo())
1334     g_application.StopPlaying();
1335
1336   AddFromPath(strPath, bRecursive, method, order, sortAttributes, strExtensions);
1337
1338   if (!NumSlides())
1339     return;
1340
1341   // mutually exclusive options
1342   // if both are set, clear both and use the gui setting
1343   if (bRandom && bNotRandom)
1344     bRandom = bNotRandom = false;
1345
1346   // NotRandom overrides the window setting
1347   if ((!bNotRandom && CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_SLIDESHOW_SHUFFLE)) || bRandom)
1348     Shuffle();
1349
1350   if (!beginSlidePath.empty())
1351     Select(beginSlidePath);
1352
1353   if (startSlideShow)
1354     StartSlideShow();
1355   else
1356   {
1357     PlayPicture();
1358   }
1359
1360   CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_SLIDESHOW);
1361 }
1362
1363 void CGUIWindowSlideShow::PlayPicture()
1364 {
1365   if (m_iCurrentSlide >= 0 && m_iCurrentSlide < static_cast<int>(m_slides.size()))
1366     AnnouncePlayerPlay(m_slides.at(m_iCurrentSlide));
1367 }
1368
1369 void CGUIWindowSlideShow::AddItems(const std::string &strPath, path_set *recursivePaths, SortBy method, SortOrder order, SortAttribute sortAttributes)
1370 {
1371   // check whether we've already added this path
1372   if (recursivePaths)
1373   {
1374     std::string path(strPath);
1375     URIUtils::RemoveSlashAtEnd(path);
1376     if (recursivePaths->find(path) != recursivePaths->end())
1377       return;
1378     recursivePaths->insert(path);
1379   }
1380
1381   CFileItemList items;
1382   CGUIViewStateWindowPictures viewState(items);
1383
1384   // fetch directory and sort accordingly
1385   if (!CDirectory::GetDirectory(strPath, items, viewState.GetExtensions(), DIR_FLAG_NO_FILE_DIRS))
1386     return;
1387
1388   items.Sort(method, order, sortAttributes);
1389
1390   // need to go into all subdirs
1391   for (int i = 0; i < items.Size(); i++)
1392   {
1393     CFileItemPtr item = items[i];
1394     if (item->m_bIsFolder && recursivePaths)
1395     {
1396       AddItems(item->GetPath(), recursivePaths);
1397     }
1398     else if (!item->m_bIsFolder && !URIUtils::IsRAR(item->GetPath()) && !URIUtils::IsZIP(item->GetPath()))
1399     { // add to the slideshow
1400       Add(item.get());
1401     }
1402   }
1403 }
1404
1405 void CGUIWindowSlideShow::GetCheckedSize(float width, float height, int &maxWidth, int &maxHeight)
1406 {
1407   maxWidth = CServiceBroker::GetRenderSystem()->GetMaxTextureSize();
1408   maxHeight = CServiceBroker::GetRenderSystem()->GetMaxTextureSize();
1409 }
1410
1411 std::string CGUIWindowSlideShow::GetPicturePath(CFileItem *item)
1412 {
1413   bool isVideo = IsVideo(*item);
1414   std::string picturePath = item->GetDynPath();
1415   if (isVideo)
1416   {
1417     picturePath = item->GetArt("thumb");
1418     if (picturePath.empty() && !item->HasProperty("nothumb"))
1419     {
1420       CPictureThumbLoader thumbLoader;
1421       thumbLoader.LoadItem(item);
1422       picturePath = item->GetArt("thumb");
1423       if (picturePath.empty())
1424         item->SetProperty("nothumb", true);
1425     }
1426   }
1427   return picturePath;
1428 }
1429
1430
1431 void CGUIWindowSlideShow::RunSlideShow(const std::vector<std::string>& paths, int start /* = 0*/)
1432 {
1433   auto dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIWindowSlideShow>(WINDOW_SLIDESHOW);
1434   if (dialog)
1435   {
1436     std::vector<CFileItemPtr> items;
1437     items.reserve(paths.size());
1438     for (const auto& path : paths)
1439       items.push_back(std::make_shared<CFileItem>(IMAGE_FILES::URLFromFile(path), false));
1440
1441     dialog->Reset();
1442     dialog->m_bPause = true;
1443     dialog->m_bSlideShow = false;
1444     dialog->m_iDirection = 1;
1445     dialog->m_iCurrentSlide = start;
1446     dialog->m_iNextSlide = (start + 1) % items.size();
1447     dialog->m_slides = std::move(items);
1448     dialog->Open();
1449   }
1450 }