xbmc/pictures/GUIWindowPictures.cpp

   1 /*
   2  *  Copyright (C) 2005-2020 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 "GUIWindowPictures.h"
  10
  11 #include "Autorun.h"
  12 #include "FileItem.h"
  13 #include "FileItemList.h"
  14 #include "GUIDialogPictureInfo.h"
  15 #include "GUIPassword.h"
  16 #include "GUIWindowSlideShow.h"
  17 #include "PictureInfoLoader.h"
  18 #include "ServiceBroker.h"
  19 #include "URL.h"
  20 #include "Util.h"
  21 #include "addons/gui/GUIDialogAddonInfo.h"
  22 #include "application/Application.h"
  23 #include "application/ApplicationComponents.h"
  24 #include "application/ApplicationPlayer.h"
  25 #include "dialogs/GUIDialogMediaSource.h"
  26 #include "dialogs/GUIDialogProgress.h"
  27 #include "guilib/GUIComponent.h"
  28 #include "guilib/GUIWindowManager.h"
  29 #include "input/actions/ActionIDs.h"
  30 #include "media/MediaLockState.h"
  31 #include "messaging/helpers/DialogOKHelper.h"
  32 #include "pictures/SlideShowDelegator.h"
  33 #include "playlists/PlayList.h"
  34 #include "playlists/PlayListFactory.h"
  35 #include "settings/MediaSourceSettings.h"
  36 #include "settings/Settings.h"
  37 #include "settings/SettingsComponent.h"
  38 #include "utils/SortUtils.h"
  39 #include "utils/StringUtils.h"
  40 #include "utils/URIUtils.h"
  41 #include "utils/Variant.h"
  42 #include "utils/XTimeUtils.h"
  43 #include "utils/log.h"
  44 #include "video/VideoFileItemClassify.h"
  45 #include "view/GUIViewState.h"
  46
  47 #define CONTROL_BTNSORTASC          4
  48 #define CONTROL_LABELFILES         12
  49
  50 using namespace XFILE;
  51 using namespace KODI::MESSAGING;
  52 using namespace KODI;
  53
  54 using namespace std::chrono_literals;
  55
  56 #define CONTROL_BTNSLIDESHOW   6
  57 #define CONTROL_BTNSLIDESHOW_RECURSIVE   7
  58 #define CONTROL_SHUFFLE      9
  59
  60 CGUIWindowPictures::CGUIWindowPictures(void)
  61     : CGUIMediaWindow(WINDOW_PICTURES, "MyPics.xml")
  62 {
  63   m_thumbLoader.SetObserver(this);
  64   m_slideShowStarted = false;
  65   m_dlgProgress = NULL;
  66 }
  67
  68 void CGUIWindowPictures::OnInitWindow()
  69 {
  70   CGUIMediaWindow::OnInitWindow();
  71   if (m_slideShowStarted)
  72   {
  73     CSlideShowDelegator& slideShow = CServiceBroker::GetSlideShowDelegator();
  74     std::string path;
  75     if (slideShow.GetCurrentSlide())
  76       path = URIUtils::GetDirectory(slideShow.GetCurrentSlide()->GetPath());
  77     if (m_vecItems->IsPath(path))
  78     {
  79       if (slideShow.GetCurrentSlide())
  80         m_viewControl.SetSelectedItem(slideShow.GetCurrentSlide()->GetPath());
  81       SaveSelectedItemInHistory();
  82     }
  83     m_slideShowStarted = false;
  84   }
  85 }
  86
  87 CGUIWindowPictures::~CGUIWindowPictures(void) = default;
  88
  89 bool CGUIWindowPictures::OnMessage(CGUIMessage& message)
  90 {
  91   switch ( message.GetMessage() )
  92   {
  93   case GUI_MSG_WINDOW_DEINIT:
  94     {
  95       if (m_thumbLoader.IsLoading())
  96         m_thumbLoader.StopThread();
  97
  98     }
  99     break;
 100
 101   case GUI_MSG_WINDOW_INIT:
 102     {
 103       // is this the first time accessing this window?
 104       if (m_vecItems->GetPath() == "?" && message.GetStringParam().empty())
 105         message.SetStringParam(CMediaSourceSettings::GetInstance().GetDefaultSource("pictures"));
 106
 107       m_dlgProgress = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogProgress>(WINDOW_DIALOG_PROGRESS);
 108     }
 109     break;
 110
 111   case GUI_MSG_CLICKED:
 112     {
 113       int iControl = message.GetSenderId();
 114       if (iControl == CONTROL_BTNSLIDESHOW) // Slide Show
 115       {
 116         OnSlideShow();
 117       }
 118       else if (iControl == CONTROL_BTNSLIDESHOW_RECURSIVE) // Recursive Slide Show
 119       {
 120         OnSlideShowRecursive();
 121       }
 122       else if (iControl == CONTROL_SHUFFLE)
 123       {
 124         const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings();
 125         settings->ToggleBool(CSettings::SETTING_SLIDESHOW_SHUFFLE);
 126         settings->Save();
 127       }
 128       else if (m_viewControl.HasControl(iControl))  // list/thumb control
 129       {
 130         int iItem = m_viewControl.GetSelectedItem();
 131         int iAction = message.GetParam1();
 132
 133         // iItem is checked for validity inside these routines
 134         if (iAction == ACTION_DELETE_ITEM)
 135         {
 136           // is delete allowed?
 137           if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_FILELISTS_ALLOWFILEDELETION))
 138             OnDeleteItem(iItem);
 139           else
 140             return false;
 141         }
 142         else if (iAction == ACTION_PLAYER_PLAY)
 143         {
 144           ShowPicture(iItem, true);
 145           return true;
 146         }
 147         else if (iAction == ACTION_SHOW_INFO)
 148         {
 149           OnItemInfo(iItem);
 150           return true;
 151         }
 152       }
 153     }
 154     break;
 155   }
 156   return CGUIMediaWindow::OnMessage(message);
 157 }
 158
 159 void CGUIWindowPictures::UpdateButtons()
 160 {
 161   CGUIMediaWindow::UpdateButtons();
 162
 163   // Update the shuffle button
 164   SET_CONTROL_SELECTED(GetID(), CONTROL_SHUFFLE, CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_SLIDESHOW_SHUFFLE));
 165
 166   // check we can slideshow or recursive slideshow
 167   int nFolders = m_vecItems->GetFolderCount();
 168   if (nFolders == m_vecItems->Size() ||
 169       m_vecItems->GetPath() == "addons://sources/image/")
 170   {
 171     CONTROL_DISABLE(CONTROL_BTNSLIDESHOW);
 172   }
 173   else
 174   {
 175     CONTROL_ENABLE(CONTROL_BTNSLIDESHOW);
 176   }
 177   if (m_guiState.get() && !m_guiState->HideParentDirItems())
 178     nFolders--;
 179   if (m_vecItems->Size() == 0 || nFolders == 0 ||
 180       m_vecItems->GetPath() == "addons://sources/image/")
 181   {
 182     CONTROL_DISABLE(CONTROL_BTNSLIDESHOW_RECURSIVE);
 183   }
 184   else
 185   {
 186     CONTROL_ENABLE(CONTROL_BTNSLIDESHOW_RECURSIVE);
 187   }
 188 }
 189
 190 void CGUIWindowPictures::OnPrepareFileItems(CFileItemList& items)
 191 {
 192   CGUIMediaWindow::OnPrepareFileItems(items);
 193
 194   for (int i=0;i<items.Size();++i )
 195     if (StringUtils::EqualsNoCase(items[i]->GetLabel(), "folder.jpg"))
 196       items.Remove(i);
 197
 198   if (items.GetFolderCount() == items.Size() || !CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_PICTURES_USETAGS))
 199     return;
 200
 201   // Start the music info loader thread
 202   CPictureInfoLoader loader;
 203   loader.SetProgressCallback(m_dlgProgress);
 204   loader.Load(items);
 205
 206   bool bShowProgress = !CServiceBroker::GetGUI()->GetWindowManager().HasModalDialog(true);
 207   bool bProgressVisible = false;
 208
 209   auto start = std::chrono::steady_clock::now();
 210
 211   while (loader.IsLoading() && m_dlgProgress && !m_dlgProgress->IsCanceled())
 212   {
 213     if (bShowProgress)
 214     { // Do we have to init a progress dialog?
 215       auto end = std::chrono::steady_clock::now();
 216       auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
 217
 218       if (!bProgressVisible && duration.count() > 1500 && m_dlgProgress)
 219       { // tag loading takes more then 1.5 secs, show a progress dialog
 220         CURL url(items.GetPath());
 221
 222         m_dlgProgress->SetHeading(CVariant{189});
 223         m_dlgProgress->SetLine(0, CVariant{505});
 224         m_dlgProgress->SetLine(1, CVariant{""});
 225         m_dlgProgress->SetLine(2, CVariant{url.GetWithoutUserDetails()});
 226         m_dlgProgress->Open();
 227         m_dlgProgress->ShowProgressBar(true);
 228         bProgressVisible = true;
 229       }
 230
 231       if (bProgressVisible && m_dlgProgress)
 232       { // keep GUI alive
 233         m_dlgProgress->Progress();
 234       }
 235     } // if (bShowProgress)
 236     KODI::TIME::Sleep(1ms);
 237   } // while (loader.IsLoading())
 238
 239   if (bProgressVisible && m_dlgProgress)
 240     m_dlgProgress->Close();
 241 }
 242
 243 bool CGUIWindowPictures::Update(const std::string &strDirectory, bool updateFilterPath /* = true */)
 244 {
 245   if (m_thumbLoader.IsLoading())
 246     m_thumbLoader.StopThread();
 247
 248   if (!CGUIMediaWindow::Update(strDirectory, updateFilterPath))
 249     return false;
 250
 251   m_vecItems->SetArt("thumb", "");
 252   if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_PICTURES_GENERATETHUMBS))
 253     m_thumbLoader.Load(*m_vecItems);
 254
 255   CPictureThumbLoader thumbLoader;
 256   std::string thumb = thumbLoader.GetCachedImage(*m_vecItems, "thumb");
 257   m_vecItems->SetArt("thumb", thumb);
 258
 259   return true;
 260 }
 261
 262 bool CGUIWindowPictures::OnClick(int iItem, const std::string &player)
 263 {
 264   if ( iItem < 0 || iItem >= m_vecItems->Size() ) return true;
 265   CFileItemPtr pItem = m_vecItems->Get(iItem);
 266
 267   if (pItem->IsCBZ() || pItem->IsCBR())
 268   {
 269     CURL pathToUrl;
 270     if (pItem->IsCBZ())
 271       pathToUrl = URIUtils::CreateArchivePath("zip", pItem->GetURL(), "");
 272     else
 273       pathToUrl = URIUtils::CreateArchivePath("rar", pItem->GetURL(), "");
 274
 275     OnShowPictureRecursive(pathToUrl.Get());
 276     return true;
 277   }
 278   else if (CGUIMediaWindow::OnClick(iItem, player))
 279     return true;
 280
 281   return false;
 282 }
 283
 284 bool CGUIWindowPictures::GetDirectory(const std::string &strDirectory, CFileItemList& items)
 285 {
 286   if (!CGUIMediaWindow::GetDirectory(strDirectory, items))
 287     return false;
 288
 289   std::string label;
 290   if (items.GetLabel().empty() && m_rootDir.IsSource(items.GetPath(), CMediaSourceSettings::GetInstance().GetSources("pictures"), &label))
 291     items.SetLabel(label);
 292
 293   if (items.GetContent().empty() && !items.IsVirtualDirectoryRoot() && !items.IsPlugin())
 294     items.SetContent("images");
 295   return true;
 296 }
 297
 298 bool CGUIWindowPictures::OnPlayMedia(int iItem, const std::string &player)
 299 {
 300   if (VIDEO::IsVideo(*m_vecItems->Get(iItem)))
 301     return CGUIMediaWindow::OnPlayMedia(iItem);
 302
 303   return ShowPicture(iItem, false);
 304 }
 305
 306 bool CGUIWindowPictures::ShowPicture(int iItem, bool startSlideShow)
 307 {
 308   if ( iItem < 0 || iItem >= m_vecItems->Size() ) return false;
 309   CFileItemPtr pItem = m_vecItems->Get(iItem);
 310   std::string strPicture = pItem->GetPath();
 311
 312 #ifdef HAS_OPTICAL_DRIVE
 313   if (pItem->IsDVD())
 314     return MEDIA_DETECT::CAutorun::PlayDiscAskResume(m_vecItems->Get(iItem)->GetPath());
 315 #endif
 316
 317   if (pItem->m_bIsShareOrDrive)
 318     return false;
 319
 320   //! @todo this should be reactive, based on a given event app player should stop the playback
 321   const auto& components = CServiceBroker::GetAppComponents();
 322   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 323   if (appPlayer->IsPlayingVideo())
 324     g_application.StopPlaying();
 325
 326   CSlideShowDelegator& slideShow = CServiceBroker::GetSlideShowDelegator();
 327   slideShow.Reset();
 328   bool bShowVideos = CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_PICTURES_SHOWVIDEOS);
 329   for (const auto& pItem : *m_vecItems)
 330   {
 331     if (!pItem->m_bIsFolder &&
 332         !(URIUtils::IsRAR(pItem->GetPath()) || URIUtils::IsZIP(pItem->GetPath())) &&
 333         (pItem->IsPicture() || (bShowVideos && VIDEO::IsVideo(*pItem))))
 334     {
 335       slideShow.Add(pItem.get());
 336     }
 337   }
 338
 339   if (slideShow.NumSlides() == 0)
 340     return false;
 341
 342   slideShow.Select(strPicture);
 343
 344   if (startSlideShow)
 345     slideShow.StartSlideShow();
 346   else
 347   {
 348     slideShow.PlayPicture();
 349   }
 350
 351   //! @todo this should trigger some event that should led the window manager to activate another window
 352   // look into using OnPlay announce!
 353   m_slideShowStarted = true;
 354   CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_SLIDESHOW);
 355
 356   return true;
 357 }
 358
 359 void CGUIWindowPictures::OnShowPictureRecursive(const std::string& strPath)
 360 {
 361   // stop any video
 362   //! @todo this should be reactive, based on a given event app player should stop the playback
 363   const auto& components = CServiceBroker::GetAppComponents();
 364   const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 365   if (appPlayer->IsPlayingVideo())
 366     g_application.StopPlaying();
 367
 368   CSlideShowDelegator& slideShow = CServiceBroker::GetSlideShowDelegator();
 369   SortDescription sorting = m_guiState->GetSortMethod();
 370   slideShow.AddFromPath(strPath, true, sorting.sortBy, sorting.sortOrder, sorting.sortAttributes);
 371   //! @todo window manager should react to a given event and start the window itself!
 372   if (slideShow.NumSlides())
 373   {
 374     m_slideShowStarted = true;
 375     CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_SLIDESHOW);
 376   }
 377 }
 378
 379 void CGUIWindowPictures::OnSlideShowRecursive(const std::string &strPicture)
 380 {
 381
 382     std::string strExtensions;
 383     CFileItemList items;
 384     CGUIViewState* viewState=CGUIViewState::GetViewState(GetID(), items);
 385     if (viewState)
 386     {
 387       strExtensions = viewState->GetExtensions();
 388       delete viewState;
 389     }
 390     m_slideShowStarted = true;
 391
 392     CSlideShowDelegator& slideShow = CServiceBroker::GetSlideShowDelegator();
 393     SortDescription sorting = m_guiState->GetSortMethod();
 394     slideShow.RunSlideShow(strPicture, true,
 395                            CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
 396                                CSettings::SETTING_SLIDESHOW_SHUFFLE),
 397                            false, "", true, sorting.sortBy, sorting.sortOrder,
 398                            sorting.sortAttributes, strExtensions);
 399 }
 400
 401 void CGUIWindowPictures::OnSlideShowRecursive()
 402 {
 403   OnSlideShowRecursive(m_vecItems->GetPath());
 404 }
 405
 406 void CGUIWindowPictures::OnSlideShow()
 407 {
 408   OnSlideShow(m_vecItems->GetPath());
 409 }
 410
 411 void CGUIWindowPictures::OnSlideShow(const std::string &strPicture)
 412 {
 413   std::string strExtensions;
 414   CFileItemList items;
 415   CGUIViewState* viewState = CGUIViewState::GetViewState(GetID(), items);
 416   if (viewState)
 417   {
 418     strExtensions = viewState->GetExtensions();
 419     delete viewState;
 420   }
 421   CSlideShowDelegator& slideShow = CServiceBroker::GetSlideShowDelegator();
 422   m_slideShowStarted = true;
 423   SortDescription sorting = m_guiState->GetSortMethod();
 424   slideShow.RunSlideShow(strPicture, false, false, false, "", true, sorting.sortBy,
 425                          sorting.sortOrder, sorting.sortAttributes, strExtensions);
 426 }
 427
 428 void CGUIWindowPictures::OnRegenerateThumbs()
 429 {
 430   if (m_thumbLoader.IsLoading()) return;
 431   m_thumbLoader.SetRegenerateThumbs(true);
 432   m_thumbLoader.Load(*m_vecItems);
 433 }
 434
 435 void CGUIWindowPictures::GetContextButtons(int itemNumber, CContextButtons &buttons)
 436 {
 437   CFileItemPtr item;
 438   if (itemNumber >= 0 && itemNumber < m_vecItems->Size())
 439     item = m_vecItems->Get(itemNumber);
 440
 441   if (item)
 442   {
 443     if ( m_vecItems->IsVirtualDirectoryRoot() || m_vecItems->GetPath() == "sources://pictures/" )
 444     {
 445       CGUIDialogContextMenu::GetContextButtons("pictures", item, buttons);
 446     }
 447     else
 448     {
 449       if (item)
 450       {
 451         if (!(item->m_bIsFolder || item->IsZIP() || item->IsRAR() || item->IsCBZ() || item->IsCBR() || item->IsScript()))
 452         {
 453           if (item->IsPicture())
 454             buttons.Add(CONTEXT_BUTTON_INFO, 13406); // picture info
 455           buttons.Add(CONTEXT_BUTTON_VIEW_SLIDESHOW, item->m_bIsFolder ? 13317 : 13422);      // View Slideshow
 456         }
 457         if (item->m_bIsFolder)
 458           buttons.Add(CONTEXT_BUTTON_RECURSIVE_SLIDESHOW, 13318);     // Recursive Slideshow
 459
 460         if (!m_thumbLoader.IsLoading())
 461           buttons.Add(CONTEXT_BUTTON_REFRESH_THUMBS, 13315);         // Create Thumbnails
 462         if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_FILELISTS_ALLOWFILEDELETION) && !item->IsReadOnly())
 463         {
 464           buttons.Add(CONTEXT_BUTTON_DELETE, 117);
 465           buttons.Add(CONTEXT_BUTTON_RENAME, 118);
 466         }
 467       }
 468
 469       if (!item->IsPlugin() && !item->IsScript() && !m_vecItems->IsPlugin())
 470         buttons.Add(CONTEXT_BUTTON_SWITCH_MEDIA, 523);
 471     }
 472   }
 473   CGUIMediaWindow::GetContextButtons(itemNumber, buttons);
 474 }
 475
 476 bool CGUIWindowPictures::OnContextButton(int itemNumber, CONTEXT_BUTTON button)
 477 {
 478   CFileItemPtr item = (itemNumber >= 0 && itemNumber < m_vecItems->Size()) ? m_vecItems->Get(itemNumber) : CFileItemPtr();
 479   if (CGUIDialogContextMenu::OnContextButton("pictures", item, button))
 480   {
 481     Update("");
 482     return true;
 483   }
 484   switch (button)
 485   {
 486   case CONTEXT_BUTTON_VIEW_SLIDESHOW:
 487     if (item && item->m_bIsFolder)
 488       OnSlideShow(item->GetPath());
 489     else
 490       ShowPicture(itemNumber, true);
 491     return true;
 492   case CONTEXT_BUTTON_RECURSIVE_SLIDESHOW:
 493     if (item)
 494       OnSlideShowRecursive(item->GetPath());
 495     return true;
 496   case CONTEXT_BUTTON_INFO:
 497     OnItemInfo(itemNumber);
 498     return true;
 499   case CONTEXT_BUTTON_REFRESH_THUMBS:
 500     OnRegenerateThumbs();
 501     return true;
 502   case CONTEXT_BUTTON_DELETE:
 503     OnDeleteItem(itemNumber);
 504     return true;
 505   case CONTEXT_BUTTON_RENAME:
 506     OnRenameItem(itemNumber);
 507     return true;
 508   case CONTEXT_BUTTON_SWITCH_MEDIA:
 509     CGUIDialogContextMenu::SwitchMedia("pictures", m_vecItems->GetPath());
 510     return true;
 511   default:
 512     break;
 513   }
 514   return CGUIMediaWindow::OnContextButton(itemNumber, button);
 515 }
 516
 517 bool CGUIWindowPictures::OnAddMediaSource()
 518 {
 519   return CGUIDialogMediaSource::ShowAndAddMediaSource("pictures");
 520 }
 521
 522 void CGUIWindowPictures::OnItemLoaded(CFileItem *pItem)
 523 {
 524   CPictureThumbLoader::ProcessFoldersAndArchives(pItem);
 525 }
 526
 527 void CGUIWindowPictures::LoadPlayList(const std::string& strPlayList)
 528 {
 529   CLog::Log(LOGDEBUG,
 530             "CGUIWindowPictures::LoadPlayList()... converting playlist into slideshow: {}",
 531             strPlayList);
 532   std::unique_ptr<PLAYLIST::CPlayList> pPlayList(PLAYLIST::CPlayListFactory::Create(strPlayList));
 533   if (nullptr != pPlayList)
 534   {
 535     if (!pPlayList->Load(strPlayList))
 536     {
 537       HELPERS::ShowOKDialogText(CVariant{6}, CVariant{477});
 538       return ; //hmmm unable to load playlist?
 539     }
 540   }
 541
 542   PLAYLIST::CPlayList playlist = *pPlayList;
 543   if (playlist.size() > 0)
 544   {
 545     //! @todo this should be reactive, based on a given event app player should stop the playback
 546     const auto& components = CServiceBroker::GetAppComponents();
 547     const auto appPlayer = components.GetComponent<CApplicationPlayer>();
 548     if (appPlayer->IsPlayingVideo())
 549       g_application.StopPlaying();
 550
 551     CSlideShowDelegator& slideShow = CServiceBroker::GetSlideShowDelegator();
 552     // convert playlist items into slideshow items
 553     slideShow.Reset();
 554     for (int i = 0; i < playlist.size(); ++i)
 555     {
 556       CFileItemPtr pItem = playlist[i];
 557       //CLog::Log(LOGDEBUG,"-- playlist item: {}", pItem->GetPath());
 558       if (pItem->IsPicture() && !(pItem->IsZIP() || pItem->IsRAR() || pItem->IsCBZ() || pItem->IsCBR()))
 559       {
 560         slideShow.Add(pItem.get());
 561       }
 562     }
 563
 564     // start slideshow if there are items
 565     slideShow.StartSlideShow();
 566     //! @todo this should be reactive based on a triggered event the window manager is the only component
 567     // that should be responsible to activate the slideshow window
 568     if (slideShow.NumSlides())
 569       CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_SLIDESHOW);
 570   }
 571 }
 572
 573 void CGUIWindowPictures::OnItemInfo(int itemNumber)
 574 {
 575   CFileItemPtr item = m_vecItems->Get(itemNumber);
 576   if (!item)
 577     return;
 578   if (!m_vecItems->IsPlugin() && (item->IsPlugin() || item->IsScript()))
 579   {
 580     CGUIDialogAddonInfo::ShowForItem(item);
 581     return;
 582   }
 583   if (item->m_bIsFolder || item->IsZIP() || item->IsRAR() || item->IsCBZ() || item->IsCBR() || !item->IsPicture())
 584     return;
 585   CGUIDialogPictureInfo *pictureInfo = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogPictureInfo>(WINDOW_DIALOG_PICTURE_INFO);
 586   if (pictureInfo)
 587   {
 588     pictureInfo->SetPicture(item.get());
 589     pictureInfo->Open();
 590   }
 591 }
 592
 593 std::string CGUIWindowPictures::GetStartFolder(const std::string &dir)
 594 {
 595   if (StringUtils::EqualsNoCase(dir, "plugins") ||
 596       StringUtils::EqualsNoCase(dir, "addons"))
 597     return "addons://sources/image/";
 598
 599   SetupShares();
 600   VECSOURCES shares;
 601   m_rootDir.GetSources(shares);
 602   bool bIsSourceName = false;
 603   int iIndex = CUtil::GetMatchingSource(dir, shares, bIsSourceName);
 604   if (iIndex > -1)
 605   {
 606     if (iIndex < static_cast<int>(shares.size()) && shares[iIndex].m_iHasLock == LOCK_STATE_LOCKED)
 607     {
 608       CFileItem item(shares[iIndex]);
 609       if (!g_passwordManager.IsItemUnlocked(&item,"pictures"))
 610         return "";
 611     }
 612     if (bIsSourceName)
 613       return shares[iIndex].strPath;
 614     return dir;
 615   }
 616   return CGUIMediaWindow::GetStartFolder(dir);
 617 }