xbmc/pvr/guilib/GUIEPGGridContainer.cpp

   1 /*
   2  *  Copyright (C) 2012-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 "GUIEPGGridContainer.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "ServiceBroker.h"
  14 #include "guilib/DirtyRegion.h"
  15 #include "guilib/GUIAction.h"
  16 #include "guilib/GUIMessage.h"
  17 #include "guilib/guiinfo/GUIInfoLabels.h"
  18 #include "input/actions/Action.h"
  19 #include "input/actions/ActionIDs.h"
  20 #include "input/mouse/MouseEvent.h"
  21 #include "messaging/ApplicationMessenger.h"
  22 #include "pvr/PVRManager.h"
  23 #include "pvr/channels/PVRChannel.h"
  24 #include "pvr/channels/PVRChannelGroupMember.h"
  25 #include "pvr/epg/EpgInfoTag.h"
  26 #include "pvr/guilib/GUIEPGGridContainerModel.h"
  27 #include "utils/MathUtils.h"
  28 #include "utils/StringUtils.h"
  29 #include "utils/Variant.h"
  30
  31 #include <algorithm>
  32 #include <memory>
  33 #include <mutex>
  34 #include <string>
  35 #include <utility>
  36
  37 #include <tinyxml.h>
  38
  39 using namespace KODI;
  40 using namespace PVR;
  41
  42 #define BLOCKJUMP    4 // how many blocks are jumped with each analogue scroll action
  43 static const int BLOCK_SCROLL_OFFSET = 60 / CGUIEPGGridContainerModel::MINSPERBLOCK; // how many blocks are jumped if we are at left/right edge of grid
  44
  45 CGUIEPGGridContainer::CGUIEPGGridContainer(int parentID,
  46                                            int controlID,
  47                                            float posX,
  48                                            float posY,
  49                                            float width,
  50                                            float height,
  51                                            ORIENTATION orientation,
  52                                            int scrollTime,
  53                                            int preloadItems,
  54                                            int timeBlocks,
  55                                            int rulerUnit,
  56                                            const CTextureInfo& progressIndicatorTexture)
  57   : IGUIContainer(parentID, controlID, posX, posY, width, height),
  58     m_orientation(orientation),
  59     m_rulerUnit(rulerUnit),
  60     m_blocksPerPage(timeBlocks),
  61     m_cacheChannelItems(preloadItems),
  62     m_cacheProgrammeItems(preloadItems),
  63     m_cacheRulerItems(preloadItems),
  64     m_guiProgressIndicatorTexture(
  65         CGUITexture::CreateTexture(posX, posY, width, height, progressIndicatorTexture)),
  66     m_scrollTime(scrollTime ? scrollTime : 1),
  67     m_gridModel(new CGUIEPGGridContainerModel)
  68 {
  69   ControlType = GUICONTAINER_EPGGRID;
  70 }
  71
  72 CGUIEPGGridContainer::CGUIEPGGridContainer(const CGUIEPGGridContainer& other)
  73   : IGUIContainer(other),
  74     m_renderOffset(other.m_renderOffset),
  75     m_orientation(other.m_orientation),
  76     m_channelLayouts(other.m_channelLayouts),
  77     m_focusedChannelLayouts(other.m_focusedChannelLayouts),
  78     m_focusedProgrammeLayouts(other.m_focusedProgrammeLayouts),
  79     m_programmeLayouts(other.m_programmeLayouts),
  80     m_rulerLayouts(other.m_rulerLayouts),
  81     m_rulerDateLayouts(other.m_rulerDateLayouts),
  82     m_channelLayout(other.m_channelLayout),
  83     m_focusedChannelLayout(other.m_focusedChannelLayout),
  84     m_programmeLayout(other.m_programmeLayout),
  85     m_focusedProgrammeLayout(other.m_focusedProgrammeLayout),
  86     m_rulerLayout(other.m_rulerLayout),
  87     m_rulerDateLayout(other.m_rulerDateLayout),
  88     m_pageControl(other.m_pageControl),
  89     m_rulerUnit(other.m_rulerUnit),
  90     m_channelsPerPage(other.m_channelsPerPage),
  91     m_programmesPerPage(other.m_programmesPerPage),
  92     m_channelCursor(other.m_channelCursor),
  93     m_channelOffset(other.m_channelOffset),
  94     m_blocksPerPage(other.m_blocksPerPage),
  95     m_blockCursor(other.m_blockCursor),
  96     m_blockOffset(other.m_blockOffset),
  97     m_blockTravelAxis(other.m_blockTravelAxis),
  98     m_cacheChannelItems(other.m_cacheChannelItems),
  99     m_cacheProgrammeItems(other.m_cacheProgrammeItems),
 100     m_cacheRulerItems(other.m_cacheRulerItems),
 101     m_rulerDateHeight(other.m_rulerDateHeight),
 102     m_rulerDateWidth(other.m_rulerDateWidth),
 103     m_rulerPosX(other.m_rulerPosX),
 104     m_rulerPosY(other.m_rulerPosY),
 105     m_rulerHeight(other.m_rulerHeight),
 106     m_rulerWidth(other.m_rulerWidth),
 107     m_channelPosX(other.m_channelPosX),
 108     m_channelPosY(other.m_channelPosY),
 109     m_channelHeight(other.m_channelHeight),
 110     m_channelWidth(other.m_channelWidth),
 111     m_gridPosX(other.m_gridPosX),
 112     m_gridPosY(other.m_gridPosY),
 113     m_gridWidth(other.m_gridWidth),
 114     m_gridHeight(other.m_gridHeight),
 115     m_blockSize(other.m_blockSize),
 116     m_analogScrollCount(other.m_analogScrollCount),
 117     m_guiProgressIndicatorTexture(other.m_guiProgressIndicatorTexture->Clone()),
 118     m_lastItem(other.m_lastItem),
 119     m_lastChannel(other.m_lastChannel),
 120     m_scrollTime(other.m_scrollTime),
 121     m_programmeScrollLastTime(other.m_programmeScrollLastTime),
 122     m_programmeScrollSpeed(other.m_programmeScrollSpeed),
 123     m_programmeScrollOffset(other.m_programmeScrollOffset),
 124     m_channelScrollLastTime(other.m_channelScrollLastTime),
 125     m_channelScrollSpeed(other.m_channelScrollSpeed),
 126     m_channelScrollOffset(other.m_channelScrollOffset),
 127     m_gridModel(new CGUIEPGGridContainerModel(*other.m_gridModel)),
 128     m_updatedGridModel(other.m_updatedGridModel
 129                            ? new CGUIEPGGridContainerModel(*other.m_updatedGridModel)
 130                            : nullptr),
 131     m_itemStartBlock(other.m_itemStartBlock)
 132 {
 133 }
 134
 135 bool CGUIEPGGridContainer::HasData() const
 136 {
 137   return m_gridModel && m_gridModel->HasChannelItems();
 138 }
 139
 140 void CGUIEPGGridContainer::AllocResources()
 141 {
 142   IGUIContainer::AllocResources();
 143   m_guiProgressIndicatorTexture->AllocResources();
 144 }
 145
 146 void CGUIEPGGridContainer::FreeResources(bool immediately)
 147 {
 148   m_guiProgressIndicatorTexture->FreeResources(immediately);
 149   IGUIContainer::FreeResources(immediately);
 150 }
 151
 152 void CGUIEPGGridContainer::SetPageControl(int id)
 153 {
 154   m_pageControl = id;
 155 }
 156
 157 void CGUIEPGGridContainer::Process(unsigned int currentTime, CDirtyRegionList& dirtyregions)
 158 {
 159   ValidateOffset();
 160
 161   if (m_bInvalidated)
 162   {
 163     UpdateLayout();
 164
 165     if (m_pageControl)
 166     {
 167       int iItemsPerPage;
 168       int iTotalItems;
 169
 170       if (m_orientation == VERTICAL)
 171       {
 172         iItemsPerPage = m_channelsPerPage;
 173         iTotalItems = m_gridModel->ChannelItemsSize();
 174       }
 175       else
 176       {
 177         iItemsPerPage = m_blocksPerPage;
 178         iTotalItems = m_gridModel->GridItemsSize();
 179       }
 180
 181       CGUIMessage msg(GUI_MSG_LABEL_RESET, GetID(), m_pageControl, iItemsPerPage, iTotalItems);
 182       SendWindowMessage(msg);
 183     }
 184   }
 185
 186   UpdateScrollOffset(currentTime);
 187   ProcessChannels(currentTime, dirtyregions);
 188   ProcessRulerDate(currentTime, dirtyregions);
 189   ProcessRuler(currentTime, dirtyregions);
 190   ProcessProgrammeGrid(currentTime, dirtyregions);
 191   ProcessProgressIndicator(currentTime, dirtyregions);
 192
 193   if (m_pageControl)
 194   {
 195     int iItem =
 196         (m_orientation == VERTICAL)
 197             ? MathUtils::round_int(static_cast<double>(m_channelScrollOffset / m_channelHeight))
 198             : MathUtils::round_int(
 199                   static_cast<double>(m_programmeScrollOffset / (m_gridHeight / m_blocksPerPage)));
 200
 201     CGUIMessage msg(GUI_MSG_ITEM_SELECT, GetID(), m_pageControl, iItem);
 202     SendWindowMessage(msg);
 203   }
 204
 205   CGUIControl::Process(currentTime, dirtyregions);
 206 }
 207
 208 void CGUIEPGGridContainer::Render()
 209 {
 210   if (CServiceBroker::GetWinSystem()->GetGfxContext().GetRenderOrder() ==
 211       RENDER_ORDER_FRONT_TO_BACK)
 212   {
 213     RenderProgressIndicator();
 214     RenderProgrammeGrid();
 215     RenderRuler();
 216     RenderRulerDate();
 217     RenderChannels();
 218   }
 219   else
 220   {
 221     RenderChannels();
 222     RenderRulerDate();
 223     RenderRuler();
 224     RenderProgrammeGrid();
 225     RenderProgressIndicator();
 226   }
 227
 228   CGUIControl::Render();
 229 }
 230
 231 void CGUIEPGGridContainer::ProcessChannels(unsigned int currentTime, CDirtyRegionList& dirtyregions)
 232 {
 233   HandleChannels(false, currentTime, dirtyregions);
 234 }
 235
 236 void CGUIEPGGridContainer::RenderChannels()
 237 {
 238   // params not needed for render.
 239   unsigned int dummyTime = 0;
 240   CDirtyRegionList dummyRegions;
 241   HandleChannels(true, dummyTime, dummyRegions);
 242 }
 243
 244 void CGUIEPGGridContainer::ProcessRulerDate(unsigned int currentTime, CDirtyRegionList& dirtyregions)
 245 {
 246   HandleRulerDate(false, currentTime, dirtyregions);
 247 }
 248
 249 void CGUIEPGGridContainer::RenderRulerDate()
 250 {
 251   // params not needed for render.
 252   unsigned int dummyTime = 0;
 253   CDirtyRegionList dummyRegions;
 254   HandleRulerDate(true, dummyTime, dummyRegions);
 255 }
 256
 257 void CGUIEPGGridContainer::ProcessRuler(unsigned int currentTime, CDirtyRegionList& dirtyregions)
 258 {
 259   HandleRuler(false, currentTime, dirtyregions);
 260 }
 261
 262 void CGUIEPGGridContainer::RenderRuler()
 263 {
 264   // params not needed for render.
 265   unsigned int dummyTime = 0;
 266   CDirtyRegionList dummyRegions;
 267   HandleRuler(true, dummyTime, dummyRegions);
 268 }
 269
 270 void CGUIEPGGridContainer::ProcessProgrammeGrid(unsigned int currentTime, CDirtyRegionList& dirtyregions)
 271 {
 272   HandleProgrammeGrid(false, currentTime, dirtyregions);
 273 }
 274
 275 void CGUIEPGGridContainer::RenderProgrammeGrid()
 276 {
 277   // params not needed for render.
 278   unsigned int dummyTime = 0;
 279   CDirtyRegionList dummyRegions;
 280   HandleProgrammeGrid(true, dummyTime, dummyRegions);
 281 }
 282
 283 float CGUIEPGGridContainer::GetCurrentTimePositionOnPage() const
 284 {
 285   if (!m_gridModel->GetGridStart().IsValid())
 286     return -1.0f;
 287
 288   const CDateTimeSpan startDelta(CDateTime::GetUTCDateTime() - m_gridModel->GetGridStart());
 289   const float fPos = (startDelta.GetSecondsTotal() * m_blockSize) /
 290                          (CGUIEPGGridContainerModel::MINSPERBLOCK * 60) -
 291                      GetProgrammeScrollOffsetPos();
 292   return std::min(fPos, m_orientation == VERTICAL ? m_gridWidth : m_gridHeight);
 293 }
 294
 295 float CGUIEPGGridContainer::GetProgressIndicatorWidth() const
 296 {
 297   return (m_orientation == VERTICAL) ? GetCurrentTimePositionOnPage() : m_rulerWidth + m_gridWidth;
 298 }
 299
 300 float CGUIEPGGridContainer::GetProgressIndicatorHeight() const
 301 {
 302   return (m_orientation == VERTICAL) ? m_rulerHeight + m_gridHeight : GetCurrentTimePositionOnPage();
 303 }
 304
 305 void CGUIEPGGridContainer::ProcessProgressIndicator(unsigned int currentTime, CDirtyRegionList& dirtyregions)
 306 {
 307   float width = GetProgressIndicatorWidth();
 308   float height = GetProgressIndicatorHeight();
 309
 310   if (width > 0 && height > 0)
 311   {
 312     m_guiProgressIndicatorTexture->SetVisible(true);
 313     m_guiProgressIndicatorTexture->SetPosition(m_rulerPosX + m_renderOffset.x,
 314                                                m_rulerPosY + m_renderOffset.y);
 315     m_guiProgressIndicatorTexture->SetWidth(width);
 316     m_guiProgressIndicatorTexture->SetHeight(height);
 317   }
 318   else
 319   {
 320     m_guiProgressIndicatorTexture->SetVisible(false);
 321   }
 322
 323   m_guiProgressIndicatorTexture->Process(currentTime);
 324 }
 325
 326 void CGUIEPGGridContainer::RenderProgressIndicator()
 327 {
 328   if (CServiceBroker::GetWinSystem()->GetGfxContext().SetClipRegion(m_rulerPosX, m_rulerPosY, GetProgressIndicatorWidth(), GetProgressIndicatorHeight()))
 329   {
 330     m_guiProgressIndicatorTexture->SetDiffuseColor(m_diffuseColor);
 331     m_guiProgressIndicatorTexture->Render(0, m_guiProgressIndicatorTextureDepth);
 332     CServiceBroker::GetWinSystem()->GetGfxContext().RestoreClipRegion();
 333   }
 334 }
 335
 336 void CGUIEPGGridContainer::ProcessItem(float posX, float posY, const CFileItemPtr& item, CFileItemPtr& lastitem,
 337   bool focused, CGUIListItemLayout* normallayout, CGUIListItemLayout* focusedlayout,
 338   unsigned int currentTime, CDirtyRegionList& dirtyregions, float resize /* = -1.0f */)
 339 {
 340   if (!normallayout || !focusedlayout)
 341     return;
 342
 343   // set the origin
 344   CServiceBroker::GetWinSystem()->GetGfxContext().SetOrigin(posX, posY);
 345
 346   if (m_bInvalidated)
 347     item->SetInvalid();
 348
 349   if (focused)
 350   {
 351     if (!item->GetFocusedLayout())
 352     {
 353       item->SetFocusedLayout(std::make_unique<CGUIListItemLayout>(*focusedlayout, this));
 354     }
 355
 356     if (resize != -1.0f)
 357     {
 358       if (m_orientation == VERTICAL)
 359         item->GetFocusedLayout()->SetWidth(resize);
 360       else
 361         item->GetFocusedLayout()->SetHeight(resize);
 362     }
 363
 364     if (item != lastitem || !HasFocus())
 365       item->GetFocusedLayout()->SetFocusedItem(0);
 366
 367     if (item != lastitem && HasFocus())
 368     {
 369       item->GetFocusedLayout()->ResetAnimation(ANIM_TYPE_UNFOCUS);
 370
 371       unsigned int subItem = 1;
 372       if (lastitem && lastitem->GetFocusedLayout())
 373         subItem = lastitem->GetFocusedLayout()->GetFocusedItem();
 374
 375       item->GetFocusedLayout()->SetFocusedItem(subItem ? subItem : 1);
 376     }
 377
 378     item->GetFocusedLayout()->Process(item.get(), m_parentID, currentTime, dirtyregions);
 379     lastitem = item;
 380   }
 381   else
 382   {
 383     if (!item->GetLayout())
 384     {
 385       item->SetLayout(std::make_unique<CGUIListItemLayout>(*normallayout, this));
 386     }
 387
 388     if (resize != -1.0f)
 389     {
 390       if (m_orientation == VERTICAL)
 391         item->GetLayout()->SetWidth(resize);
 392       else
 393         item->GetLayout()->SetHeight(resize);
 394     }
 395
 396     if (item->GetFocusedLayout())
 397       item->GetFocusedLayout()->SetFocusedItem(0);
 398
 399     if (item->GetFocusedLayout() && item->GetFocusedLayout()->IsAnimating(ANIM_TYPE_UNFOCUS))
 400       item->GetFocusedLayout()->Process(item.get(), m_parentID, currentTime, dirtyregions);
 401     else
 402       item->GetLayout()->Process(item.get(), m_parentID, currentTime, dirtyregions);
 403   }
 404   CServiceBroker::GetWinSystem()->GetGfxContext().RestoreOrigin();
 405 }
 406
 407 void CGUIEPGGridContainer::RenderItem(float posX, float posY, CGUIListItem* item, bool focused)
 408 {
 409   // set the origin
 410   CServiceBroker::GetWinSystem()->GetGfxContext().SetOrigin(posX, posY);
 411
 412   if (focused)
 413   {
 414     if (item->GetFocusedLayout())
 415       item->GetFocusedLayout()->Render(item, m_parentID);
 416   }
 417   else
 418   {
 419     if (item->GetFocusedLayout() && item->GetFocusedLayout()->IsAnimating(ANIM_TYPE_UNFOCUS))
 420       item->GetFocusedLayout()->Render(item, m_parentID);
 421     else if (item->GetLayout())
 422       item->GetLayout()->Render(item, m_parentID);
 423   }
 424   CServiceBroker::GetWinSystem()->GetGfxContext().RestoreOrigin();
 425 }
 426
 427 bool CGUIEPGGridContainer::OnAction(const CAction& action)
 428 {
 429   switch (action.GetID())
 430   {
 431     case ACTION_MOVE_LEFT:
 432     case ACTION_MOVE_RIGHT:
 433     case ACTION_MOVE_DOWN:
 434     case ACTION_MOVE_UP:
 435     case ACTION_NAV_BACK:
 436       // use base class implementation
 437       return CGUIControl::OnAction(action);
 438
 439     case ACTION_NEXT_ITEM:
 440       // skip +12h
 441       ScrollToBlockOffset(m_blockOffset + (12 * 60  / CGUIEPGGridContainerModel::MINSPERBLOCK));
 442       SetBlock(m_blockCursor);
 443       return true;
 444
 445     case ACTION_PREV_ITEM:
 446       // skip -12h
 447       ScrollToBlockOffset(m_blockOffset - (12 * 60 / CGUIEPGGridContainerModel::MINSPERBLOCK));
 448       SetBlock(m_blockCursor);
 449       return true;
 450
 451     case REMOTE_0:
 452       GoToNow();
 453       return true;
 454
 455     case ACTION_PAGE_UP:
 456       if (m_orientation == VERTICAL)
 457       {
 458         if (m_channelOffset == 0)
 459         {
 460           // already on the first page, so move to the first item
 461           SetChannel(0);
 462         }
 463         else
 464         {
 465           // scroll up to the previous page
 466           ChannelScroll(-m_channelsPerPage);
 467         }
 468       }
 469       else
 470       {
 471         if (m_blockOffset == 0)
 472         {
 473           // already on the first page, so move to the first item
 474           SetBlock(0);
 475         }
 476         else
 477         {
 478           // scroll up to the previous page
 479           ProgrammesScroll(-m_blocksPerPage);
 480         }
 481       }
 482       return true;
 483
 484     case ACTION_PAGE_DOWN:
 485       if (m_orientation == VERTICAL)
 486       {
 487         if (m_channelOffset == m_gridModel->ChannelItemsSize() - m_channelsPerPage ||
 488             m_gridModel->ChannelItemsSize() < m_channelsPerPage)
 489         {
 490           // already at the last page, so move to the last item.
 491           SetChannel(m_gridModel->GetLastChannel() - m_channelOffset);
 492         }
 493         else
 494         {
 495           // scroll down to the next page
 496           ChannelScroll(m_channelsPerPage);
 497         }
 498       }
 499       else
 500       {
 501         if (m_blockOffset == m_gridModel->GridItemsSize() - m_blocksPerPage ||
 502             m_gridModel->GridItemsSize() < m_blocksPerPage)
 503         {
 504           // already at the last page, so move to the last item.
 505           SetBlock(m_gridModel->GetLastBlock() - m_blockOffset);
 506         }
 507         else
 508         {
 509           // scroll down to the next page
 510           ProgrammesScroll(m_blocksPerPage);
 511         }
 512       }
 513
 514       return true;
 515
 516     // smooth scrolling (for analog controls)
 517     case ACTION_TELETEXT_RED:
 518     case ACTION_TELETEXT_GREEN:
 519     case ACTION_SCROLL_UP: // left horizontal scrolling
 520       if (m_orientation == VERTICAL)
 521       {
 522         int blocksToJump = action.GetID() == ACTION_TELETEXT_RED ? m_blocksPerPage / 2 : m_blocksPerPage / 4;
 523
 524         m_analogScrollCount += action.GetAmount() * action.GetAmount();
 525         bool handled = false;
 526
 527         while (m_analogScrollCount > 0.4f)
 528         {
 529           handled = true;
 530           m_analogScrollCount -= 0.4f;
 531
 532           if (m_blockOffset > 0 && m_blockCursor <= m_blocksPerPage / 2)
 533             ProgrammesScroll(-blocksToJump);
 534           else if (m_blockCursor > blocksToJump)
 535             SetBlock(m_blockCursor - blocksToJump);
 536         }
 537         return handled;
 538       }
 539       else
 540       {
 541         int channelsToJump = action.GetID() == ACTION_TELETEXT_RED ? m_channelsPerPage / 2 : m_channelsPerPage / 4;
 542
 543         m_analogScrollCount += action.GetAmount() * action.GetAmount();
 544         bool handled = false;
 545
 546         while (m_analogScrollCount > 0.4f)
 547         {
 548           handled = true;
 549           m_analogScrollCount -= 0.4f;
 550
 551           if (m_channelOffset > 0 && m_channelCursor <= m_channelsPerPage / 2)
 552             ChannelScroll(-channelsToJump);
 553           else if (m_channelCursor > channelsToJump)
 554             SetChannel(m_channelCursor - channelsToJump);
 555         }
 556         return handled;
 557       }
 558       break;
 559
 560     case ACTION_TELETEXT_BLUE:
 561     case ACTION_TELETEXT_YELLOW:
 562     case ACTION_SCROLL_DOWN: // right horizontal scrolling
 563       if (m_orientation == VERTICAL)
 564       {
 565         int blocksToJump = action.GetID() == ACTION_TELETEXT_BLUE ? m_blocksPerPage / 2 : m_blocksPerPage / 4;
 566
 567         m_analogScrollCount += action.GetAmount() * action.GetAmount();
 568         bool handled = false;
 569
 570         while (m_analogScrollCount > 0.4f)
 571         {
 572           handled = true;
 573           m_analogScrollCount -= 0.4f;
 574
 575           if (m_blockOffset + m_blocksPerPage < m_gridModel->GridItemsSize() &&
 576               m_blockCursor >= m_blocksPerPage / 2)
 577             ProgrammesScroll(blocksToJump);
 578           else if (m_blockCursor < m_blocksPerPage - blocksToJump &&
 579                    m_blockOffset + m_blockCursor < m_gridModel->GridItemsSize() - blocksToJump)
 580             SetBlock(m_blockCursor + blocksToJump);
 581         }
 582         return handled;
 583       }
 584       else
 585       {
 586         int channelsToJump = action.GetID() == ACTION_TELETEXT_BLUE ? m_channelsPerPage / 2 : m_channelsPerPage / 4;
 587
 588         m_analogScrollCount += action.GetAmount() * action.GetAmount();
 589         bool handled = false;
 590
 591         while (m_analogScrollCount > 0.4f)
 592         {
 593           handled = true;
 594           m_analogScrollCount -= 0.4f;
 595
 596           if (m_channelOffset + m_channelsPerPage < m_gridModel->ChannelItemsSize() && m_channelCursor >= m_channelsPerPage / 2)
 597             ChannelScroll(channelsToJump);
 598           else if (m_channelCursor < m_channelsPerPage - channelsToJump && m_channelOffset + m_channelCursor < m_gridModel->ChannelItemsSize() - channelsToJump)
 599             SetChannel(m_channelCursor + channelsToJump);
 600         }
 601         return handled;
 602       }
 603       break;
 604
 605     default:
 606       if (action.GetID())
 607         return OnClick(action.GetID());
 608
 609       break;
 610   }
 611
 612   return false;
 613 }
 614
 615 bool CGUIEPGGridContainer::OnMessage(CGUIMessage& message)
 616 {
 617   if (message.GetControlId() == GetID())
 618   {
 619     switch (message.GetMessage())
 620     {
 621       case GUI_MSG_PAGE_CHANGE:
 622         if (message.GetSenderId() == m_pageControl && IsVisible())
 623         {
 624           if (m_orientation == VERTICAL)
 625           {
 626             ScrollToChannelOffset(message.GetParam1());
 627             SetChannel(m_channelCursor);
 628           }
 629           else
 630           {
 631             ScrollToBlockOffset(message.GetParam1());
 632             SetBlock(m_blockCursor);
 633           }
 634           return true;
 635         }
 636         break;
 637
 638       case GUI_MSG_LABEL_BIND:
 639         UpdateItems();
 640         return true;
 641
 642       case GUI_MSG_REFRESH_LIST:
 643         // update our list contents
 644         m_gridModel->SetInvalid();
 645         break;
 646     }
 647   }
 648
 649   return CGUIControl::OnMessage(message);
 650 }
 651
 652 void CGUIEPGGridContainer::UpdateItems()
 653 {
 654   std::unique_lock<CCriticalSection> lock(m_critSection);
 655
 656   if (!m_updatedGridModel)
 657     return;
 658
 659   // Save currently selected epg tag and grid coordinates. Selection shall be restored after update.
 660   std::shared_ptr<CPVREpgInfoTag> prevSelectedEpgTag;
 661   if (HasData())
 662     prevSelectedEpgTag =
 663         m_gridModel->GetGridItem(m_channelCursor + m_channelOffset, m_blockCursor + m_blockOffset)
 664             ->GetEPGInfoTag();
 665
 666   const int oldChannelIndex = m_channelOffset + m_channelCursor;
 667   const int oldBlockIndex = m_blockOffset + m_blockCursor;
 668   const CDateTime oldGridStart(m_gridModel->GetGridStart());
 669   int eventOffset = oldBlockIndex;
 670   int newChannelIndex = oldChannelIndex;
 671   int newBlockIndex = oldBlockIndex;
 672   int channelUid = -1;
 673   unsigned int broadcastUid = 0;
 674
 675   if (prevSelectedEpgTag)
 676   {
 677     // get the block offset relative to the first block of the selected event
 678     eventOffset =
 679         oldBlockIndex - m_gridModel->GetGridItemStartBlock(oldChannelIndex, oldBlockIndex);
 680
 681     if (!prevSelectedEpgTag->IsGapTag()) // "normal" tag selected
 682     {
 683       if (oldGridStart >= prevSelectedEpgTag->StartAsUTC())
 684       {
 685         // start of previously selected event is before grid start
 686         newBlockIndex = eventOffset;
 687       }
 688       else
 689       {
 690         newBlockIndex = m_gridModel->GetFirstEventBlock(prevSelectedEpgTag) + eventOffset;
 691       }
 692
 693       channelUid = prevSelectedEpgTag->UniqueChannelID();
 694       broadcastUid = prevSelectedEpgTag->UniqueBroadcastID();
 695     }
 696     else // "gap" tag selected
 697     {
 698       channelUid = prevSelectedEpgTag->UniqueChannelID();
 699
 700       // As gap tags do not have a unique broadcast id, we will look for the real tag preceding
 701       // the gap tag and add the respective offset to restore the gap tag selection, assuming that
 702       // the real tag is still the predecessor of the gap tag after the grid model update.
 703
 704       const std::shared_ptr<CFileItem> prevItem = GetPrevItem().first;
 705       if (prevItem)
 706       {
 707         const std::shared_ptr<const CPVREpgInfoTag> tag = prevItem->GetEPGInfoTag();
 708         if (tag && !tag->IsGapTag())
 709         {
 710           if (oldGridStart >= tag->StartAsUTC())
 711           {
 712             // start of previously selected event is before grid start
 713             newBlockIndex = eventOffset;
 714           }
 715           else
 716           {
 717             newBlockIndex = m_gridModel->GetFirstEventBlock(tag);
 718             eventOffset += m_gridModel->GetFirstEventBlock(prevSelectedEpgTag) - newBlockIndex;
 719           }
 720
 721           broadcastUid = tag->UniqueBroadcastID();
 722         }
 723       }
 724     }
 725   }
 726
 727   m_lastItem = nullptr;
 728   m_lastChannel = nullptr;
 729
 730   // always use asynchronously precalculated grid data.
 731   m_gridModel = std::move(m_updatedGridModel);
 732
 733   if (prevSelectedEpgTag)
 734   {
 735     if (oldGridStart != m_gridModel->GetGridStart())
 736     {
 737       // grid start changed. block offset for selected event might have changed.
 738       newBlockIndex += m_gridModel->GetBlock(oldGridStart);
 739       if (newBlockIndex < 0 || newBlockIndex > m_gridModel->GetLastBlock())
 740       {
 741         // previous selection is no longer in grid.
 742         SetInvalid();
 743         m_bEnableChannelScrolling = false;
 744         GoToChannel(newChannelIndex);
 745         m_bEnableProgrammeScrolling = false;
 746         GoToNow();
 747         return;
 748       }
 749     }
 750
 751     if (newChannelIndex >= m_gridModel->ChannelItemsSize() ||
 752         newBlockIndex >= m_gridModel->GridItemsSize() ||
 753         m_gridModel->GetGridItem(newChannelIndex, newBlockIndex)->GetEPGInfoTag() !=
 754             prevSelectedEpgTag)
 755     {
 756       int iChannelIndex = CGUIEPGGridContainerModel::INVALID_INDEX;
 757       int iBlockIndex = CGUIEPGGridContainerModel::INVALID_INDEX;
 758       m_gridModel->FindChannelAndBlockIndex(channelUid, broadcastUid, eventOffset, iChannelIndex, iBlockIndex);
 759
 760       if (iBlockIndex != CGUIEPGGridContainerModel::INVALID_INDEX)
 761       {
 762         newBlockIndex = iBlockIndex;
 763       }
 764       else if (newBlockIndex > m_gridModel->GetLastBlock())
 765       {
 766         // default to now
 767         newBlockIndex = m_gridModel->GetNowBlock();
 768
 769         if (newBlockIndex > m_gridModel->GetLastBlock())
 770         {
 771           // last block is in the past. default to last block
 772           newBlockIndex = m_gridModel->GetLastBlock();
 773         }
 774       }
 775
 776       if (iChannelIndex != CGUIEPGGridContainerModel::INVALID_INDEX)
 777       {
 778         newChannelIndex = iChannelIndex;
 779       }
 780       else if (newChannelIndex >= m_gridModel->ChannelItemsSize() ||
 781                (m_gridModel->GetGridItem(newChannelIndex, newBlockIndex)->GetEPGInfoTag()->UniqueChannelID() != prevSelectedEpgTag->UniqueChannelID() &&
 782                 m_gridModel->GetGridItem(newChannelIndex, newBlockIndex)->GetEPGInfoTag()->ClientID() != prevSelectedEpgTag->ClientID()))
 783       {
 784         // default to first channel
 785         newChannelIndex = 0;
 786       }
 787     }
 788
 789     // restore previous selection.
 790     if (newChannelIndex == oldChannelIndex && newBlockIndex == oldBlockIndex)
 791     {
 792       // same coordinates, keep current grid view port
 793       UpdateItem();
 794     }
 795     else
 796     {
 797       // new coordinates, move grid view port accordingly
 798       SetInvalid();
 799
 800       if (newBlockIndex != oldBlockIndex)
 801       {
 802         m_bEnableProgrammeScrolling = false;
 803         GoToBlock(newBlockIndex);
 804       }
 805
 806       if (newChannelIndex != oldChannelIndex)
 807       {
 808         m_bEnableChannelScrolling = false;
 809         GoToChannel(newChannelIndex);
 810       }
 811     }
 812   }
 813   else
 814   {
 815     // no previous selection, goto now
 816     SetInvalid();
 817     m_bEnableProgrammeScrolling = false;
 818     GoToNow();
 819   }
 820 }
 821
 822 float CGUIEPGGridContainer::GetChannelScrollOffsetPos() const
 823 {
 824   if (m_bEnableChannelScrolling)
 825     return m_channelScrollOffset;
 826   else
 827     return m_channelOffset * m_channelLayout->Size(m_orientation);
 828 }
 829
 830 float CGUIEPGGridContainer::GetProgrammeScrollOffsetPos() const
 831 {
 832   if (m_bEnableProgrammeScrolling)
 833     return m_programmeScrollOffset;
 834   else
 835     return m_blockOffset * m_blockSize;
 836 }
 837
 838 int CGUIEPGGridContainer::GetChannelScrollOffset(CGUIListItemLayout* layout) const
 839 {
 840   if (m_bEnableChannelScrolling)
 841     return MathUtils::round_int(
 842         static_cast<double>(m_channelScrollOffset / layout->Size(m_orientation)));
 843   else
 844     return m_channelOffset;
 845 }
 846
 847 int CGUIEPGGridContainer::GetProgrammeScrollOffset() const
 848 {
 849   if (m_bEnableProgrammeScrolling)
 850     return MathUtils::round_int(static_cast<double>(m_programmeScrollOffset / m_blockSize));
 851   else
 852     return m_blockOffset;
 853 }
 854
 855 void CGUIEPGGridContainer::ChannelScroll(int amount)
 856 {
 857   // increase or decrease the vertical offset
 858   int offset = m_channelOffset + amount;
 859
 860   if (offset > m_gridModel->ChannelItemsSize() - m_channelsPerPage)
 861     offset = m_gridModel->ChannelItemsSize() - m_channelsPerPage;
 862
 863   if (offset < 0)
 864     offset = 0;
 865
 866   ScrollToChannelOffset(offset);
 867   SetChannel(m_channelCursor);
 868 }
 869
 870 void CGUIEPGGridContainer::ProgrammesScroll(int amount)
 871 {
 872   // increase or decrease the horizontal offset
 873   ScrollToBlockOffset(m_blockOffset + amount);
 874   SetBlock(m_blockCursor);
 875 }
 876
 877 void CGUIEPGGridContainer::OnUp()
 878 {
 879   if (!HasData())
 880     return CGUIControl::OnUp();
 881
 882   if (m_orientation == VERTICAL)
 883   {
 884     CGUIAction action = GetAction(ACTION_MOVE_UP);
 885     if (m_channelCursor > 0)
 886     {
 887       SetChannel(m_channelCursor - 1);
 888     }
 889     else if (m_channelCursor == 0 && m_channelOffset)
 890     {
 891       ScrollToChannelOffset(m_channelOffset - 1);
 892       SetChannel(0);
 893     }
 894     else if (action.GetNavigation() == GetID() || !action.HasActionsMeetingCondition()) // wrap around
 895     {
 896       int offset = m_gridModel->ChannelItemsSize() - m_channelsPerPage;
 897
 898       if (offset < 0)
 899         offset = 0;
 900
 901       SetChannel(m_gridModel->GetLastChannel() - offset);
 902       ScrollToChannelOffset(offset);
 903     }
 904     else
 905       CGUIControl::OnUp();
 906   }
 907   else
 908   {
 909     if (m_gridModel->GetGridItemStartBlock(m_channelCursor + m_channelOffset,
 910                                            m_blockCursor + m_blockOffset) > m_blockOffset)
 911     {
 912       // this is not first item on page
 913       SetItem(GetPrevItem());
 914       UpdateBlock();
 915       return;
 916     }
 917     else if (m_blockCursor <= 0 && m_blockOffset && m_blockOffset - BLOCK_SCROLL_OFFSET >= 0)
 918     {
 919       // this is the first item on page
 920       ScrollToBlockOffset(m_blockOffset - BLOCK_SCROLL_OFFSET);
 921       UpdateBlock();
 922       return;
 923     }
 924
 925     CGUIControl::OnUp();
 926   }
 927 }
 928
 929 void CGUIEPGGridContainer::OnDown()
 930 {
 931   if (!HasData())
 932     return CGUIControl::OnDown();
 933
 934   if (m_orientation == VERTICAL)
 935   {
 936     CGUIAction action = GetAction(ACTION_MOVE_DOWN);
 937     if (m_channelOffset + m_channelCursor < m_gridModel->GetLastChannel())
 938     {
 939       if (m_channelCursor + 1 < m_channelsPerPage)
 940       {
 941         SetChannel(m_channelCursor + 1);
 942       }
 943       else
 944       {
 945         ScrollToChannelOffset(m_channelOffset + 1);
 946         SetChannel(m_channelsPerPage - 1);
 947       }
 948     }
 949     else if (action.GetNavigation() == GetID() || !action.HasActionsMeetingCondition()) // wrap around
 950     {
 951       ScrollToChannelOffset(0);
 952       SetChannel(0);
 953     }
 954     else
 955       CGUIControl::OnDown();
 956   }
 957   else
 958   {
 959     if (m_gridModel->GetGridItemEndBlock(m_channelCursor + m_channelOffset,
 960                                          m_blockCursor + m_blockOffset) <
 961         (m_blockOffset + m_blocksPerPage - 1))
 962     {
 963       // this is not last item on page
 964       SetItem(GetNextItem());
 965       UpdateBlock();
 966       return;
 967     }
 968     else if ((m_blockOffset != m_gridModel->GridItemsSize() - m_blocksPerPage) &&
 969              m_gridModel->GridItemsSize() > m_blocksPerPage &&
 970              m_blockOffset + BLOCK_SCROLL_OFFSET < m_gridModel->GetLastBlock())
 971     {
 972       // this is the last item on page
 973       ScrollToBlockOffset(m_blockOffset + BLOCK_SCROLL_OFFSET);
 974       UpdateBlock();
 975       return;
 976     }
 977
 978     CGUIControl::OnDown();
 979   }
 980 }
 981
 982 void CGUIEPGGridContainer::OnLeft()
 983 {
 984   if (!HasData())
 985     return CGUIControl::OnLeft();
 986
 987   if (m_orientation == VERTICAL)
 988   {
 989     if (m_gridModel->GetGridItemStartBlock(m_channelCursor + m_channelOffset,
 990                                            m_blockCursor + m_blockOffset) > m_blockOffset)
 991     {
 992       // this is not first item on page
 993       SetItem(GetPrevItem());
 994       UpdateBlock();
 995       return;
 996     }
 997     else if (m_blockCursor <= 0 && m_blockOffset && m_blockOffset - BLOCK_SCROLL_OFFSET >= 0)
 998     {
 999       // this is the first item on page
1000       ScrollToBlockOffset(m_blockOffset - BLOCK_SCROLL_OFFSET);
1001       UpdateBlock();
1002       return;
1003     }
1004
1005     CGUIControl::OnLeft();
1006   }
1007   else
1008   {
1009     CGUIAction action = GetAction(ACTION_MOVE_LEFT);
1010     if (m_channelCursor > 0)
1011     {
1012       SetChannel(m_channelCursor - 1);
1013     }
1014     else if (m_channelCursor == 0 && m_channelOffset)
1015     {
1016       ScrollToChannelOffset(m_channelOffset - 1);
1017       SetChannel(0);
1018     }
1019     else if (action.GetNavigation() == GetID() || !action.HasActionsMeetingCondition()) // wrap around
1020     {
1021       int offset = m_gridModel->ChannelItemsSize() - m_channelsPerPage;
1022
1023       if (offset < 0)
1024         offset = 0;
1025
1026       SetChannel(m_gridModel->GetLastChannel() - offset);
1027       ScrollToChannelOffset(offset);
1028     }
1029     else
1030       CGUIControl::OnLeft();
1031   }
1032 }
1033
1034 void CGUIEPGGridContainer::OnRight()
1035 {
1036   if (!HasData())
1037     return CGUIControl::OnRight();
1038
1039   if (m_orientation == VERTICAL)
1040   {
1041     if (m_gridModel->GetGridItemEndBlock(m_channelCursor + m_channelOffset,
1042                                          m_blockCursor + m_blockOffset) <
1043         (m_blockOffset + m_blocksPerPage - 1))
1044     {
1045       // this is not last item on page
1046       SetItem(GetNextItem());
1047       UpdateBlock();
1048       return;
1049     }
1050     else if ((m_blockOffset != m_gridModel->GridItemsSize() - m_blocksPerPage) &&
1051              m_gridModel->GridItemsSize() > m_blocksPerPage &&
1052              m_blockOffset + BLOCK_SCROLL_OFFSET < m_gridModel->GetLastBlock())
1053     {
1054       // this is the last item on page
1055       ScrollToBlockOffset(m_blockOffset + BLOCK_SCROLL_OFFSET);
1056       UpdateBlock();
1057       return;
1058     }
1059
1060     CGUIControl::OnRight();
1061   }
1062   else
1063   {
1064     CGUIAction action = GetAction(ACTION_MOVE_RIGHT);
1065     if (m_channelOffset + m_channelCursor < m_gridModel->GetLastChannel())
1066     {
1067       if (m_channelCursor + 1 < m_channelsPerPage)
1068       {
1069         SetChannel(m_channelCursor + 1);
1070       }
1071       else
1072       {
1073         ScrollToChannelOffset(m_channelOffset + 1);
1074         SetChannel(m_channelsPerPage - 1);
1075       }
1076     }
1077     else if (action.GetNavigation() == GetID() || !action.HasActionsMeetingCondition()) // wrap around
1078     {
1079       SetChannel(0);
1080       ScrollToChannelOffset(0);
1081     }
1082     else
1083       CGUIControl::OnRight();
1084   }
1085 }
1086
1087 bool CGUIEPGGridContainer::SetChannel(const std::string& channel)
1088 {
1089   for (int iIndex = 0; iIndex < m_gridModel->ChannelItemsSize(); iIndex++)
1090   {
1091     std::string strPath = m_gridModel->GetChannelItem(iIndex)->GetProperty("path").asString();
1092     if (strPath == channel)
1093     {
1094       GoToChannel(iIndex);
1095       return true;
1096     }
1097   }
1098   return false;
1099 }
1100
1101 bool CGUIEPGGridContainer::SetChannel(const std::shared_ptr<CPVRChannel>& channel)
1102 {
1103   for (int iIndex = 0; iIndex < m_gridModel->ChannelItemsSize(); iIndex++)
1104   {
1105     int iChannelId = static_cast<int>(m_gridModel->GetChannelItem(iIndex)->GetProperty("channelid").asInteger(-1));
1106     if (iChannelId == channel->ChannelID())
1107     {
1108       GoToChannel(iIndex);
1109       return true;
1110     }
1111   }
1112   return false;
1113 }
1114
1115 bool CGUIEPGGridContainer::SetChannel(const CPVRChannelNumber& channelNumber)
1116 {
1117   for (int iIndex = 0; iIndex < m_gridModel->ChannelItemsSize(); iIndex++)
1118   {
1119     const CPVRChannelNumber& number =
1120         m_gridModel->GetChannelItem(iIndex)->GetPVRChannelGroupMemberInfoTag()->ChannelNumber();
1121     if (number == channelNumber)
1122     {
1123       GoToChannel(iIndex);
1124       return true;
1125     }
1126   }
1127   return false;
1128 }
1129
1130 void CGUIEPGGridContainer::SetChannel(int channel)
1131 {
1132   std::unique_lock<CCriticalSection> lock(m_critSection);
1133
1134   int channelIndex = channel + m_channelOffset;
1135   int blockIndex = m_blockCursor + m_blockOffset;
1136   if (channelIndex < m_gridModel->ChannelItemsSize() && blockIndex < m_gridModel->GridItemsSize())
1137   {
1138     if (SetItem(m_gridModel->GetGridItem(channelIndex, m_blockTravelAxis), channelIndex,
1139                 m_blockTravelAxis))
1140     {
1141       m_channelCursor = channel;
1142       MarkDirtyRegion();
1143       UpdateBlock(false);
1144     }
1145   }
1146 }
1147
1148 void CGUIEPGGridContainer::SetBlock(int block, bool bUpdateBlockTravelAxis /* = true */)
1149 {
1150   std::unique_lock<CCriticalSection> lock(m_critSection);
1151
1152   if (block < 0)
1153     m_blockCursor = 0;
1154   else if (block > m_blocksPerPage - 1)
1155     m_blockCursor = m_blocksPerPage - 1;
1156   else
1157     m_blockCursor = block;
1158
1159   if (bUpdateBlockTravelAxis)
1160     m_blockTravelAxis = m_blockOffset + m_blockCursor;
1161
1162   UpdateItem();
1163   MarkDirtyRegion();
1164 }
1165
1166 void CGUIEPGGridContainer::UpdateBlock(bool bUpdateBlockTravelAxis /* = true */)
1167 {
1168   SetBlock(m_itemStartBlock > 0 ? m_itemStartBlock - m_blockOffset : 0, bUpdateBlockTravelAxis);
1169 }
1170
1171 CGUIListItemLayout* CGUIEPGGridContainer::GetFocusedLayout() const
1172 {
1173   std::shared_ptr<CGUIListItem> item = GetListItem(0);
1174
1175   if (item)
1176     return item->GetFocusedLayout();
1177
1178   return nullptr;
1179 }
1180
1181 bool CGUIEPGGridContainer::SelectItemFromPoint(const CPoint& point, bool justGrid /* = false */)
1182 {
1183   /* point has already had origin set to m_posX, m_posY */
1184   if (!m_focusedProgrammeLayout || !m_programmeLayout || (justGrid && point.x < 0))
1185     return false;
1186
1187   int channel;
1188   int block;
1189
1190   if (m_orientation == VERTICAL)
1191   {
1192     channel = point.y / m_channelHeight;
1193     block = point.x / m_blockSize;
1194   }
1195   else
1196   {
1197     channel = point.x / m_channelWidth;
1198     block = point.y / m_blockSize;
1199   }
1200
1201   if (channel > m_channelsPerPage)
1202     channel = m_channelsPerPage - 1;
1203
1204   if (channel >= m_gridModel->ChannelItemsSize())
1205     channel = m_gridModel->GetLastChannel();
1206
1207   if (channel < 0)
1208     channel = 0;
1209
1210   if (block > m_blocksPerPage)
1211     block = m_blocksPerPage - 1;
1212
1213   if (block < 0)
1214     block = 0;
1215
1216   int channelIndex = channel + m_channelOffset;
1217   int blockIndex = block + m_blockOffset;
1218
1219   // bail if out of range
1220   if (channelIndex >= m_gridModel->ChannelItemsSize() || blockIndex >= m_gridModel->GridItemsSize())
1221     return false;
1222
1223   // bail if block isn't occupied
1224   if (!m_gridModel->GetGridItem(channelIndex, blockIndex))
1225     return false;
1226
1227   SetChannel(channel);
1228   SetBlock(block);
1229   return true;
1230 }
1231
1232 EVENT_RESULT CGUIEPGGridContainer::OnMouseEvent(const CPoint& point,
1233                                                 const MOUSE::CMouseEvent& event)
1234 {
1235   switch (event.m_id)
1236   {
1237   case ACTION_MOUSE_LEFT_CLICK:
1238     OnMouseClick(0, point);
1239     return EVENT_RESULT_HANDLED;
1240   case ACTION_MOUSE_RIGHT_CLICK:
1241     OnMouseClick(1, point);
1242     return EVENT_RESULT_HANDLED;
1243   case ACTION_MOUSE_DOUBLE_CLICK:
1244     OnMouseDoubleClick(0, point);
1245     return EVENT_RESULT_HANDLED;
1246   case ACTION_MOUSE_WHEEL_UP:
1247     OnMouseWheel(-1, point);
1248     return EVENT_RESULT_HANDLED;
1249   case ACTION_MOUSE_WHEEL_DOWN:
1250     OnMouseWheel(1, point);
1251     return EVENT_RESULT_HANDLED;
1252   case ACTION_GESTURE_BEGIN:
1253     {
1254       // we want exclusive access
1255       CGUIMessage msg(GUI_MSG_EXCLUSIVE_MOUSE, GetID(), GetParentID());
1256       SendWindowMessage(msg);
1257       return EVENT_RESULT_HANDLED;
1258     }
1259   case ACTION_GESTURE_END:
1260   case ACTION_GESTURE_ABORT:
1261     {
1262       // we're done with exclusive access
1263       CGUIMessage msg(GUI_MSG_EXCLUSIVE_MOUSE, 0, GetParentID());
1264       SendWindowMessage(msg);
1265       ScrollToChannelOffset(MathUtils::round_int(
1266           static_cast<double>(m_channelScrollOffset / m_channelLayout->Size(m_orientation))));
1267       SetChannel(m_channelCursor);
1268       ScrollToBlockOffset(
1269           MathUtils::round_int(static_cast<double>(m_programmeScrollOffset / m_blockSize)));
1270       SetBlock(m_blockCursor);
1271       return EVENT_RESULT_HANDLED;
1272     }
1273   case ACTION_GESTURE_PAN:
1274     {
1275       m_programmeScrollOffset -= event.m_offsetX;
1276       m_channelScrollOffset -= event.m_offsetY;
1277
1278       {
1279         std::unique_lock<CCriticalSection> lock(m_critSection);
1280
1281         m_channelOffset = MathUtils::round_int(
1282             static_cast<double>(m_channelScrollOffset / m_channelLayout->Size(m_orientation)));
1283         m_blockOffset =
1284             MathUtils::round_int(static_cast<double>(m_programmeScrollOffset / m_blockSize));
1285         ValidateOffset();
1286       }
1287       return EVENT_RESULT_HANDLED;
1288     }
1289   default:
1290     return EVENT_RESULT_UNHANDLED;
1291   }
1292 }
1293
1294 bool CGUIEPGGridContainer::OnMouseOver(const CPoint& point)
1295 {
1296   // select the item under the pointer
1297   SelectItemFromPoint(point - CPoint(m_gridPosX, m_gridPosY), false);
1298   return CGUIControl::OnMouseOver(point);
1299 }
1300
1301 bool CGUIEPGGridContainer::OnMouseClick(int dwButton, const CPoint& point)
1302 {
1303   if (SelectItemFromPoint(point - CPoint(m_gridPosX, m_gridPosY)))
1304   {
1305     // send click message to window
1306     OnClick(ACTION_MOUSE_LEFT_CLICK + dwButton);
1307     return true;
1308   }
1309   return false;
1310 }
1311
1312 bool CGUIEPGGridContainer::OnMouseDoubleClick(int dwButton, const CPoint& point)
1313 {
1314   if (SelectItemFromPoint(point - CPoint(m_gridPosX, m_gridPosY)))
1315   {
1316     // send double click message to window
1317     OnClick(ACTION_MOUSE_DOUBLE_CLICK + dwButton);
1318     return true;
1319   }
1320   return false;
1321 }
1322
1323 bool CGUIEPGGridContainer::OnClick(int actionID)
1324 {
1325   int subItem = 0;
1326
1327   if (actionID == ACTION_SELECT_ITEM || actionID == ACTION_MOUSE_LEFT_CLICK)
1328   {
1329     // grab the currently focused subitem (if applicable)
1330     CGUIListItemLayout* focusedLayout = GetFocusedLayout();
1331
1332     if (focusedLayout)
1333       subItem = focusedLayout->GetFocusedItem();
1334   }
1335
1336   // Don't know what to do, so send to our parent window.
1337   CGUIMessage msg(GUI_MSG_CLICKED, GetID(), GetParentID(), actionID, subItem);
1338   return SendWindowMessage(msg);
1339 }
1340
1341 bool CGUIEPGGridContainer::OnMouseWheel(char wheel, const CPoint& point)
1342 {
1343   // doesn't work while an item is selected?
1344   ProgrammesScroll(-wheel);
1345   return true;
1346 }
1347
1348 std::shared_ptr<CPVRChannelGroupMember> CGUIEPGGridContainer::GetSelectedChannelGroupMember() const
1349 {
1350   CFileItemPtr fileItem;
1351   {
1352     std::unique_lock<CCriticalSection> lock(m_critSection);
1353     if (m_channelCursor + m_channelOffset < m_gridModel->ChannelItemsSize())
1354       fileItem = m_gridModel->GetChannelItem(m_channelCursor + m_channelOffset);
1355   }
1356
1357   if (fileItem)
1358     return fileItem->GetPVRChannelGroupMemberInfoTag();
1359
1360   return {};
1361 }
1362
1363 CDateTime CGUIEPGGridContainer::GetSelectedDate() const
1364 {
1365   return m_gridModel->GetStartTimeForBlock(m_blockOffset + m_blockCursor);
1366 }
1367
1368 CFileItemPtr CGUIEPGGridContainer::GetSelectedGridItem(int offset /*= 0*/) const
1369 {
1370   CFileItemPtr item;
1371
1372   if (m_channelCursor + m_channelOffset + offset < m_gridModel->ChannelItemsSize() &&
1373       m_blockCursor + m_blockOffset < m_gridModel->GridItemsSize())
1374     item = m_gridModel->GetGridItem(m_channelCursor + m_channelOffset, m_blockCursor + m_blockOffset);
1375
1376   return item;
1377 }
1378
1379 std::shared_ptr<CGUIListItem> CGUIEPGGridContainer::GetListItem(int offset, unsigned int flag) const
1380 {
1381   if (!m_gridModel->HasChannelItems())
1382     return std::shared_ptr<CGUIListItem>();
1383
1384   int item = m_channelCursor + m_channelOffset + offset;
1385   if (flag & INFOFLAG_LISTITEM_POSITION)
1386     item = GetChannelScrollOffset(m_channelLayout);
1387
1388   if (flag & INFOFLAG_LISTITEM_WRAP)
1389   {
1390     item %= m_gridModel->ChannelItemsSize();
1391     if (item < 0)
1392       item += m_gridModel->ChannelItemsSize();
1393
1394     return m_gridModel->GetChannelItem(item);
1395   }
1396   else
1397   {
1398     if (item >= 0 && item < m_gridModel->ChannelItemsSize())
1399       return m_gridModel->GetChannelItem(item);
1400   }
1401   return std::shared_ptr<CGUIListItem>();
1402 }
1403
1404 std::string CGUIEPGGridContainer::GetLabel(int info) const
1405 {
1406   std::string label;
1407   switch (info)
1408   {
1409   case CONTAINER_NUM_PAGES:
1410     if (m_channelsPerPage > 0)
1411       label = std::to_string((m_gridModel->ChannelItemsSize() + m_channelsPerPage - 1) /
1412                              m_channelsPerPage);
1413     else
1414       label = std::to_string(0);
1415     break;
1416   case CONTAINER_CURRENT_PAGE:
1417     if (m_channelsPerPage > 0)
1418       label = std::to_string(1 + (m_channelCursor + m_channelOffset) / m_channelsPerPage);
1419     else
1420       label = std::to_string(1);
1421     break;
1422   case CONTAINER_POSITION:
1423     label = std::to_string(1 + m_channelCursor + m_channelOffset);
1424     break;
1425   case CONTAINER_NUM_ITEMS:
1426     label = std::to_string(m_gridModel->ChannelItemsSize());
1427     break;
1428   default:
1429       break;
1430   }
1431   return label;
1432 }
1433
1434 void CGUIEPGGridContainer::SetItem(const std::pair<std::shared_ptr<CFileItem>, int>& itemInfo)
1435 {
1436   SetItem(itemInfo.first, m_channelCursor + m_channelOffset, itemInfo.second);
1437 }
1438
1439 bool CGUIEPGGridContainer::SetItem(const std::shared_ptr<CFileItem>& item,
1440                                    int channelIndex,
1441                                    int blockIndex)
1442 {
1443   if (item && channelIndex < m_gridModel->ChannelItemsSize() &&
1444       blockIndex < m_gridModel->GridItemsSize())
1445   {
1446     m_itemStartBlock = m_gridModel->GetGridItemStartBlock(channelIndex, blockIndex);
1447     return true;
1448   }
1449   else
1450   {
1451     m_itemStartBlock = 0;
1452     return false;
1453   }
1454 }
1455
1456 std::shared_ptr<CFileItem> CGUIEPGGridContainer::GetItem() const
1457 {
1458   const int channelIndex = m_channelCursor + m_channelOffset;
1459   const int blockIndex = m_blockCursor + m_blockOffset;
1460
1461   if (channelIndex >= m_gridModel->ChannelItemsSize() || blockIndex >= m_gridModel->GridItemsSize())
1462     return {};
1463
1464   return m_gridModel->GetGridItem(m_channelCursor + m_channelOffset, m_blockCursor + m_blockOffset);
1465 }
1466
1467 std::pair<std::shared_ptr<CFileItem>, int> CGUIEPGGridContainer::GetNextItem() const
1468 {
1469   int block = m_gridModel->GetGridItemEndBlock(m_channelCursor + m_channelOffset,
1470                                                m_blockCursor + m_blockOffset);
1471   if (block < m_gridModel->GridItemsSize())
1472   {
1473     // first block of next event is one block after end block of selected event
1474     block += 1;
1475   }
1476
1477   return {m_gridModel->GetGridItem(m_channelCursor + m_channelOffset, block), block};
1478 }
1479
1480 std::pair<std::shared_ptr<CFileItem>, int> CGUIEPGGridContainer::GetPrevItem() const
1481 {
1482   int block = m_gridModel->GetGridItemStartBlock(m_channelCursor + m_channelOffset,
1483                                                  m_blockCursor + m_blockOffset);
1484   if (block > 0)
1485   {
1486     // last block of previous event is one block before start block of selected event
1487     block -= 1;
1488   }
1489
1490   return {m_gridModel->GetGridItem(m_channelCursor + m_channelOffset, block), block};
1491 }
1492
1493 void CGUIEPGGridContainer::UpdateItem()
1494 {
1495   SetItem(GetItem(), m_channelCursor + m_channelOffset, m_blockCursor + m_blockOffset);
1496 }
1497
1498 void CGUIEPGGridContainer::SetFocus(bool focus)
1499 {
1500   if (focus != HasFocus())
1501     SetInvalid();
1502
1503   CGUIControl::SetFocus(focus);
1504 }
1505
1506 void CGUIEPGGridContainer::ScrollToChannelOffset(int offset)
1507 {
1508   std::unique_lock<CCriticalSection> lock(m_critSection);
1509
1510   float size = m_programmeLayout->Size(m_orientation);
1511   int range = m_channelsPerPage / 4;
1512
1513   if (range <= 0)
1514     range = 1;
1515
1516   if (offset * size < m_channelScrollOffset && m_channelScrollOffset - offset * size > size * range)
1517   {
1518     // scrolling up, and we're jumping more than 0.5 of a screen
1519     m_channelScrollOffset = (offset + range) * size;
1520   }
1521
1522   if (offset * size > m_channelScrollOffset && offset * size - m_channelScrollOffset > size * range)
1523   {
1524     // scrolling down, and we're jumping more than 0.5 of a screen
1525     m_channelScrollOffset = (offset - range) * size;
1526   }
1527
1528   m_channelScrollSpeed = (offset * size - m_channelScrollOffset) / m_scrollTime;
1529   m_channelOffset = offset;
1530   MarkDirtyRegion();
1531 }
1532
1533 void CGUIEPGGridContainer::ScrollToBlockOffset(int offset)
1534 {
1535   std::unique_lock<CCriticalSection> lock(m_critSection);
1536
1537   // make sure offset is in valid range
1538   offset = std::max(0, std::min(offset, m_gridModel->GridItemsSize() - m_blocksPerPage));
1539
1540   float size = m_blockSize;
1541   int range = m_blocksPerPage / 1;
1542
1543   if (range <= 0)
1544     range = 1;
1545
1546   if (offset * size < m_programmeScrollOffset && m_programmeScrollOffset - offset * size > size * range)
1547   {
1548     // scrolling left, and we're jumping more than 0.5 of a screen
1549     m_programmeScrollOffset = (offset + range) * size;
1550   }
1551
1552   if (offset * size > m_programmeScrollOffset && offset * size - m_programmeScrollOffset > size * range)
1553   {
1554     // scrolling right, and we're jumping more than 0.5 of a screen
1555     m_programmeScrollOffset = (offset - range) * size;
1556   }
1557
1558   m_programmeScrollSpeed = (offset * size - m_programmeScrollOffset) / m_scrollTime;
1559   m_blockOffset = offset;
1560   MarkDirtyRegion();
1561 }
1562
1563 void CGUIEPGGridContainer::ValidateOffset()
1564 {
1565   std::unique_lock<CCriticalSection> lock(m_critSection);
1566
1567   if (!m_programmeLayout)
1568     return;
1569
1570   float pos = (m_orientation == VERTICAL) ? m_channelHeight : m_channelWidth;
1571
1572   if (m_gridModel->ChannelItemsSize() &&
1573       (m_channelOffset > m_gridModel->ChannelItemsSize() - m_channelsPerPage ||
1574        m_channelScrollOffset > (m_gridModel->ChannelItemsSize() - m_channelsPerPage) * pos))
1575   {
1576     m_channelOffset = m_gridModel->ChannelItemsSize() - m_channelsPerPage;
1577     m_channelScrollOffset = m_channelOffset * pos;
1578   }
1579
1580   if (m_channelOffset < 0 || m_channelScrollOffset < 0)
1581   {
1582     m_channelOffset = 0;
1583     m_channelScrollOffset = 0;
1584   }
1585
1586   if (m_gridModel->GridItemsSize() &&
1587       (m_blockOffset > m_gridModel->GridItemsSize() - m_blocksPerPage ||
1588        m_programmeScrollOffset > (m_gridModel->GridItemsSize() - m_blocksPerPage) * m_blockSize))
1589   {
1590     m_blockOffset = m_gridModel->GridItemsSize() - m_blocksPerPage;
1591     m_programmeScrollOffset = m_blockOffset * m_blockSize;
1592   }
1593
1594   if (m_blockOffset < 0 || m_programmeScrollOffset < 0)
1595   {
1596     m_blockOffset = 0;
1597     m_programmeScrollOffset = 0;
1598   }
1599 }
1600
1601 void CGUIEPGGridContainer::LoadLayout(TiXmlElement* layout)
1602 {
1603   /* layouts for the channel column */
1604   TiXmlElement* itemElement = layout->FirstChildElement("channellayout");
1605   while (itemElement)
1606   {
1607     m_channelLayouts.emplace_back();
1608     m_channelLayouts.back().LoadLayout(itemElement, GetParentID(), false, m_width, m_height);
1609     itemElement = itemElement->NextSiblingElement("channellayout");
1610   }
1611   itemElement = layout->FirstChildElement("focusedchannellayout");
1612   while (itemElement)
1613   {
1614     m_focusedChannelLayouts.emplace_back();
1615     m_focusedChannelLayouts.back().LoadLayout(itemElement, GetParentID(), true, m_width, m_height);
1616     itemElement = itemElement->NextSiblingElement("focusedchannellayout");
1617   }
1618
1619   /* layouts for the grid items */
1620   itemElement = layout->FirstChildElement("focusedlayout");
1621   while (itemElement)
1622   {
1623     m_focusedProgrammeLayouts.emplace_back();
1624     m_focusedProgrammeLayouts.back().LoadLayout(itemElement, GetParentID(), true, m_width, m_height);
1625     itemElement = itemElement->NextSiblingElement("focusedlayout");
1626   }
1627   itemElement = layout->FirstChildElement("itemlayout");
1628   while (itemElement)
1629   {
1630     m_programmeLayouts.emplace_back();
1631     m_programmeLayouts.back().LoadLayout(itemElement, GetParentID(), false, m_width, m_height);
1632     itemElement = itemElement->NextSiblingElement("itemlayout");
1633   }
1634
1635   /* layout for the date label for the grid */
1636   itemElement = layout->FirstChildElement("rulerdatelayout");
1637   while (itemElement)
1638   {
1639     m_rulerDateLayouts.emplace_back();
1640     m_rulerDateLayouts.back().LoadLayout(itemElement, GetParentID(), false, m_width, m_height);
1641     itemElement = itemElement->NextSiblingElement("rulerdatelayout");
1642   }
1643
1644   /* layout for the timeline for the grid */
1645   itemElement = layout->FirstChildElement("rulerlayout");
1646   while (itemElement)
1647   {
1648     m_rulerLayouts.emplace_back();
1649     m_rulerLayouts.back().LoadLayout(itemElement, GetParentID(), false, m_width, m_height);
1650     itemElement = itemElement->NextSiblingElement("rulerlayout");
1651   }
1652
1653   UpdateLayout();
1654 }
1655
1656 std::string CGUIEPGGridContainer::GetDescription() const
1657 {
1658   std::unique_lock<CCriticalSection> lock(m_critSection);
1659
1660   const int channelIndex = m_channelCursor + m_channelOffset;
1661   const int blockIndex = m_blockCursor + m_blockOffset;
1662
1663   if (channelIndex < m_gridModel->ChannelItemsSize() && blockIndex < m_gridModel->GridItemsSize())
1664   {
1665     const std::shared_ptr<CFileItem> item = m_gridModel->GetGridItem(channelIndex, blockIndex);
1666     if (item)
1667       return item->GetLabel();
1668   }
1669
1670   return {};
1671 }
1672
1673 void CGUIEPGGridContainer::JumpToNow()
1674 {
1675   m_bEnableProgrammeScrolling = false;
1676   GoToNow();
1677 }
1678
1679 void CGUIEPGGridContainer::JumpToDate(const CDateTime& date)
1680 {
1681   m_bEnableProgrammeScrolling = false;
1682   GoToDate(date);
1683 }
1684
1685 void CGUIEPGGridContainer::GoToBegin()
1686 {
1687   ScrollToBlockOffset(0);
1688   SetBlock(0);
1689 }
1690
1691 void CGUIEPGGridContainer::GoToEnd()
1692 {
1693   ScrollToBlockOffset(m_gridModel->GetLastBlock() - m_blocksPerPage + 1);
1694   SetBlock(m_blocksPerPage - 1);
1695 }
1696
1697 void CGUIEPGGridContainer::GoToNow()
1698 {
1699   GoToDate(CDateTime::GetUTCDateTime());
1700 }
1701
1702 void CGUIEPGGridContainer::GoToDate(const CDateTime& date)
1703 {
1704   unsigned int offset = m_gridModel->GetPageNowOffset();
1705   ScrollToBlockOffset(m_gridModel->GetBlock(date) - offset);
1706
1707   // ensure we're selecting the active event, not its predecessor.
1708   const int iChannel = m_channelOffset + m_channelCursor;
1709   const int iBlock = m_blockOffset + offset;
1710   if (iChannel >= m_gridModel->ChannelItemsSize() || iBlock >= m_gridModel->GridItemsSize() ||
1711       m_gridModel->GetGridItemEndTime(iChannel, iBlock) > date)
1712   {
1713     SetBlock(offset);
1714   }
1715   else
1716   {
1717     SetBlock(offset + 1);
1718   }
1719 }
1720
1721 void CGUIEPGGridContainer::GoToFirstChannel()
1722 {
1723   GoToChannel(0);
1724 }
1725
1726 void CGUIEPGGridContainer::GoToLastChannel()
1727 {
1728   if (m_gridModel->ChannelItemsSize())
1729     GoToChannel(m_gridModel->GetLastChannel());
1730   else
1731     GoToChannel(0);
1732 }
1733
1734 void CGUIEPGGridContainer::GoToTop()
1735 {
1736   if (m_orientation == VERTICAL)
1737   {
1738     GoToChannel(0);
1739   }
1740   else
1741   {
1742     GoToBlock(0);
1743   }
1744 }
1745
1746 void CGUIEPGGridContainer::GoToBottom()
1747 {
1748   if (m_orientation == VERTICAL)
1749   {
1750     if (m_gridModel->HasChannelItems())
1751       GoToChannel(m_gridModel->GetLastChannel());
1752     else
1753       GoToChannel(0);
1754   }
1755   else
1756   {
1757     if (m_gridModel->GridItemsSize())
1758       GoToBlock(m_gridModel->GetLastBlock());
1759     else
1760       GoToBlock(0);
1761   }
1762 }
1763
1764 void CGUIEPGGridContainer::GoToMostLeft()
1765 {
1766   if (m_orientation == VERTICAL)
1767   {
1768     GoToBlock(0);
1769   }
1770   else
1771   {
1772     GoToChannel(0);
1773   }
1774 }
1775
1776 void CGUIEPGGridContainer::GoToMostRight()
1777 {
1778   if (m_orientation == VERTICAL)
1779   {
1780     if (m_gridModel->GridItemsSize())
1781       GoToBlock(m_gridModel->GetLastBlock());
1782     else
1783       GoToBlock(0);
1784   }
1785   else
1786   {
1787     if (m_gridModel->HasChannelItems())
1788       GoToChannel(m_gridModel->GetLastChannel());
1789     else
1790       GoToChannel(0);
1791   }
1792 }
1793
1794 void CGUIEPGGridContainer::SetTimelineItems(const std::unique_ptr<CFileItemList>& items,
1795                                             const CDateTime& gridStart,
1796                                             const CDateTime& gridEnd)
1797 {
1798   int iRulerUnit;
1799   int iFirstChannel;
1800   int iChannelsPerPage;
1801   int iBlocksPerPage;
1802   int iFirstBlock;
1803   float fBlockSize;
1804   {
1805     std::unique_lock<CCriticalSection> lock(m_critSection);
1806
1807     iRulerUnit = m_rulerUnit;
1808     iFirstChannel = m_channelOffset;
1809     iChannelsPerPage = m_channelsPerPage;
1810     iFirstBlock = m_blockOffset;
1811     iBlocksPerPage = m_blocksPerPage;
1812     fBlockSize = m_blockSize;
1813   }
1814
1815   std::unique_ptr<CGUIEPGGridContainerModel> oldUpdatedGridModel;
1816   std::unique_ptr<CGUIEPGGridContainerModel> newUpdatedGridModel(new CGUIEPGGridContainerModel);
1817
1818   newUpdatedGridModel->Initialize(items, gridStart, gridEnd, iFirstChannel, iChannelsPerPage,
1819                                   iFirstBlock, iBlocksPerPage, iRulerUnit, fBlockSize);
1820   {
1821     std::unique_lock<CCriticalSection> lock(m_critSection);
1822
1823     // grid contains CFileItem instances. CFileItem dtor locks global graphics mutex.
1824     // by increasing its refcount make sure, old data are not deleted while we're holding own mutex.
1825     oldUpdatedGridModel = std::move(m_updatedGridModel);
1826
1827     m_updatedGridModel = std::move(newUpdatedGridModel);
1828   }
1829 }
1830
1831 std::unique_ptr<CFileItemList> CGUIEPGGridContainer::GetCurrentTimeLineItems() const
1832 {
1833   return m_gridModel->GetCurrentTimeLineItems(m_channelOffset, m_channelsPerPage);
1834 }
1835
1836 void CGUIEPGGridContainer::GoToChannel(int channelIndex)
1837 {
1838   if (channelIndex < m_channelsPerPage)
1839   {
1840     // first page
1841     ScrollToChannelOffset(0);
1842     SetChannel(channelIndex);
1843   }
1844   else if (channelIndex > m_gridModel->ChannelItemsSize() - m_channelsPerPage)
1845   {
1846     // last page
1847     ScrollToChannelOffset(m_gridModel->ChannelItemsSize() - m_channelsPerPage);
1848     SetChannel(channelIndex - (m_gridModel->ChannelItemsSize() - m_channelsPerPage));
1849   }
1850   else
1851   {
1852     ScrollToChannelOffset(channelIndex - m_channelCursor);
1853     SetChannel(m_channelCursor);
1854   }
1855 }
1856
1857 void CGUIEPGGridContainer::GoToBlock(int blockIndex)
1858 {
1859   int lastPage = m_gridModel->GridItemsSize() - m_blocksPerPage;
1860   if (blockIndex > lastPage)
1861   {
1862     // last page
1863     ScrollToBlockOffset(lastPage);
1864     SetBlock(blockIndex - lastPage);
1865   }
1866   else
1867   {
1868     ScrollToBlockOffset(blockIndex - m_blockCursor);
1869     SetBlock(m_blockCursor);
1870   }
1871 }
1872
1873 void CGUIEPGGridContainer::UpdateLayout()
1874 {
1875   CGUIListItemLayout* oldFocusedChannelLayout = m_focusedChannelLayout;
1876   CGUIListItemLayout* oldChannelLayout = m_channelLayout;
1877   CGUIListItemLayout* oldFocusedProgrammeLayout = m_focusedProgrammeLayout;
1878   CGUIListItemLayout* oldProgrammeLayout = m_programmeLayout;
1879   CGUIListItemLayout* oldRulerLayout = m_rulerLayout;
1880   CGUIListItemLayout* oldRulerDateLayout = m_rulerDateLayout;
1881
1882   GetCurrentLayouts();
1883
1884   // Note: m_rulerDateLayout is optional
1885   if (!m_focusedProgrammeLayout || !m_programmeLayout || !m_focusedChannelLayout || !m_channelLayout || !m_rulerLayout)
1886     return;
1887
1888   if (oldChannelLayout == m_channelLayout && oldFocusedChannelLayout == m_focusedChannelLayout &&
1889       oldProgrammeLayout == m_programmeLayout && oldFocusedProgrammeLayout == m_focusedProgrammeLayout &&
1890       oldRulerLayout == m_rulerLayout && oldRulerDateLayout == m_rulerDateLayout)
1891     return; // nothing has changed, so don't update stuff
1892
1893   std::unique_lock<CCriticalSection> lock(m_critSection);
1894
1895   m_channelHeight = m_channelLayout->Size(VERTICAL);
1896   m_channelWidth = m_channelLayout->Size(HORIZONTAL);
1897
1898   m_rulerDateHeight = m_rulerDateLayout ? m_rulerDateLayout->Size(VERTICAL) : 0;
1899   m_rulerDateWidth = m_rulerDateLayout ? m_rulerDateLayout->Size(HORIZONTAL) : 0;
1900
1901   if (m_orientation == VERTICAL)
1902   {
1903     m_rulerHeight = m_rulerLayout->Size(VERTICAL);
1904     m_gridPosX = m_posX + m_channelWidth;
1905     m_gridPosY = m_posY + m_rulerHeight + m_rulerDateHeight;
1906     m_gridWidth = m_width - m_channelWidth;
1907     m_gridHeight = m_height - m_rulerHeight - m_rulerDateHeight;
1908     m_blockSize = m_gridWidth / m_blocksPerPage;
1909     m_rulerWidth = m_rulerUnit * m_blockSize;
1910     m_channelPosX = m_posX;
1911     m_channelPosY = m_posY + m_rulerHeight + m_rulerDateHeight;
1912     m_rulerPosX = m_posX + m_channelWidth;
1913     m_rulerPosY = m_posY + m_rulerDateHeight;
1914     m_channelsPerPage = m_gridHeight / m_channelHeight;
1915     m_programmesPerPage = (m_gridWidth / m_blockSize) + 1;
1916
1917     m_programmeLayout->SetHeight(m_channelHeight);
1918     m_focusedProgrammeLayout->SetHeight(m_channelHeight);
1919   }
1920   else
1921   {
1922     m_rulerWidth = m_rulerLayout->Size(HORIZONTAL);
1923     m_gridPosX = m_posX + m_rulerWidth;
1924     m_gridPosY = m_posY + m_channelHeight + m_rulerDateHeight;
1925     m_gridWidth = m_width - m_rulerWidth;
1926     m_gridHeight = m_height - m_channelHeight - m_rulerDateHeight;
1927     m_blockSize = m_gridHeight / m_blocksPerPage;
1928     m_rulerHeight = m_rulerUnit * m_blockSize;
1929     m_channelPosX = m_posX + m_rulerWidth;
1930     m_channelPosY = m_posY + m_rulerDateHeight;
1931     m_rulerPosX = m_posX;
1932     m_rulerPosY = m_posY + m_channelHeight + m_rulerDateHeight;
1933     m_channelsPerPage = m_gridWidth / m_channelWidth;
1934     m_programmesPerPage = (m_gridHeight / m_blockSize) + 1;
1935
1936     m_programmeLayout->SetWidth(m_channelWidth);
1937     m_focusedProgrammeLayout->SetWidth(m_channelWidth);
1938   }
1939
1940   // ensure that the scroll offsets are a multiple of our sizes
1941   m_channelScrollOffset = m_channelOffset * m_programmeLayout->Size(m_orientation);
1942   m_programmeScrollOffset = m_blockOffset * m_blockSize;
1943 }
1944
1945 void CGUIEPGGridContainer::UpdateScrollOffset(unsigned int currentTime)
1946 {
1947   if (!m_programmeLayout)
1948     return;
1949
1950   m_channelScrollOffset += m_channelScrollSpeed * (currentTime - m_channelScrollLastTime);
1951   if ((m_channelScrollSpeed < 0 && m_channelScrollOffset < m_channelOffset * m_programmeLayout->Size(m_orientation)) ||
1952       (m_channelScrollSpeed > 0 && m_channelScrollOffset > m_channelOffset * m_programmeLayout->Size(m_orientation)))
1953   {
1954     m_channelScrollOffset = m_channelOffset * m_programmeLayout->Size(m_orientation);
1955     m_channelScrollSpeed = 0;
1956     m_bEnableChannelScrolling = true;
1957   }
1958
1959   m_channelScrollLastTime = currentTime;
1960   m_programmeScrollOffset += m_programmeScrollSpeed * (currentTime - m_programmeScrollLastTime);
1961
1962   if ((m_programmeScrollSpeed < 0 && m_programmeScrollOffset < m_blockOffset * m_blockSize) ||
1963       (m_programmeScrollSpeed > 0 && m_programmeScrollOffset > m_blockOffset * m_blockSize))
1964   {
1965     m_programmeScrollOffset = m_blockOffset * m_blockSize;
1966     m_programmeScrollSpeed = 0;
1967     m_bEnableProgrammeScrolling = true;
1968   }
1969
1970   m_programmeScrollLastTime = currentTime;
1971
1972   if (m_channelScrollSpeed || m_programmeScrollSpeed)
1973     MarkDirtyRegion();
1974 }
1975
1976 void CGUIEPGGridContainer::GetCurrentLayouts()
1977 {
1978   m_channelLayout = nullptr;
1979
1980   for (unsigned int i = 0; i < m_channelLayouts.size(); i++)
1981   {
1982     if (m_channelLayouts[i].CheckCondition())
1983     {
1984       m_channelLayout = &m_channelLayouts[i];
1985       break;
1986     }
1987   }
1988
1989   if (!m_channelLayout && !m_channelLayouts.empty())
1990     m_channelLayout = &m_channelLayouts[0]; // failsafe
1991
1992   m_focusedChannelLayout = nullptr;
1993
1994   for (unsigned int i = 0; i < m_focusedChannelLayouts.size(); i++)
1995   {
1996     if (m_focusedChannelLayouts[i].CheckCondition())
1997     {
1998       m_focusedChannelLayout = &m_focusedChannelLayouts[i];
1999       break;
2000     }
2001   }
2002
2003   if (!m_focusedChannelLayout && !m_focusedChannelLayouts.empty())
2004     m_focusedChannelLayout = &m_focusedChannelLayouts[0]; // failsafe
2005
2006   m_programmeLayout = nullptr;
2007
2008   for (unsigned int i = 0; i < m_programmeLayouts.size(); i++)
2009   {
2010     if (m_programmeLayouts[i].CheckCondition())
2011     {
2012       m_programmeLayout = &m_programmeLayouts[i];
2013       break;
2014     }
2015   }
2016
2017   if (!m_programmeLayout && !m_programmeLayouts.empty())
2018     m_programmeLayout = &m_programmeLayouts[0]; // failsafe
2019
2020   m_focusedProgrammeLayout = nullptr;
2021
2022   for (unsigned int i = 0; i < m_focusedProgrammeLayouts.size(); i++)
2023   {
2024     if (m_focusedProgrammeLayouts[i].CheckCondition())
2025     {
2026       m_focusedProgrammeLayout = &m_focusedProgrammeLayouts[i];
2027       break;
2028     }
2029   }
2030
2031   if (!m_focusedProgrammeLayout && !m_focusedProgrammeLayouts.empty())
2032     m_focusedProgrammeLayout = &m_focusedProgrammeLayouts[0]; // failsafe
2033
2034   m_rulerLayout = nullptr;
2035
2036   for (unsigned int i = 0; i < m_rulerLayouts.size(); i++)
2037   {
2038     if (m_rulerLayouts[i].CheckCondition())
2039     {
2040       m_rulerLayout = &m_rulerLayouts[i];
2041       break;
2042     }
2043   }
2044
2045   if (!m_rulerLayout && !m_rulerLayouts.empty())
2046     m_rulerLayout = &m_rulerLayouts[0]; // failsafe
2047
2048   m_rulerDateLayout = nullptr;
2049
2050   for (unsigned int i = 0; i < m_rulerDateLayouts.size(); i++)
2051   {
2052     if (m_rulerDateLayouts[i].CheckCondition())
2053     {
2054       m_rulerDateLayout = &m_rulerDateLayouts[i];
2055       break;
2056     }
2057   }
2058
2059   // Note: m_rulerDateLayout is optional; so no "failsafe" logic here (see above)
2060 }
2061
2062 void CGUIEPGGridContainer::SetRenderOffset(const CPoint& offset)
2063 {
2064   m_renderOffset = offset;
2065 }
2066
2067 void CGUIEPGGridContainer::GetChannelCacheOffsets(int& cacheBefore, int& cacheAfter)
2068 {
2069   if (m_channelScrollSpeed > 0)
2070   {
2071     cacheBefore = 0;
2072     cacheAfter = m_cacheChannelItems;
2073   }
2074   else if (m_channelScrollSpeed < 0)
2075   {
2076     cacheBefore = m_cacheChannelItems;
2077     cacheAfter = 0;
2078   }
2079   else
2080   {
2081     cacheBefore = m_cacheChannelItems / 2;
2082     cacheAfter = m_cacheChannelItems / 2;
2083   }
2084 }
2085
2086 void CGUIEPGGridContainer::GetProgrammeCacheOffsets(int& cacheBefore, int& cacheAfter)
2087 {
2088   if (m_programmeScrollSpeed > 0)
2089   {
2090     cacheBefore = 0;
2091     cacheAfter = m_cacheProgrammeItems;
2092   }
2093   else if (m_programmeScrollSpeed < 0)
2094   {
2095     cacheBefore = m_cacheProgrammeItems;
2096     cacheAfter = 0;
2097   }
2098   else
2099   {
2100     cacheBefore = m_cacheProgrammeItems / 2;
2101     cacheAfter = m_cacheProgrammeItems / 2;
2102   }
2103 }
2104
2105 void CGUIEPGGridContainer::HandleChannels(bool bRender,
2106                                           unsigned int currentTime,
2107                                           CDirtyRegionList& dirtyregions,
2108                                           bool bAssignDepth)
2109 {
2110   if (!m_focusedChannelLayout || !m_channelLayout)
2111     return;
2112
2113   const int chanOffset = GetChannelScrollOffset(m_programmeLayout);
2114
2115   int cacheBeforeChannel, cacheAfterChannel;
2116   GetChannelCacheOffsets(cacheBeforeChannel, cacheAfterChannel);
2117
2118   if (bRender)
2119   {
2120     if (m_orientation == VERTICAL)
2121       CServiceBroker::GetWinSystem()->GetGfxContext().SetClipRegion(m_channelPosX, m_channelPosY, m_channelWidth, m_gridHeight);
2122     else
2123       CServiceBroker::GetWinSystem()->GetGfxContext().SetClipRegion(m_channelPosX, m_channelPosY, m_gridWidth, m_channelHeight);
2124   }
2125   else
2126   {
2127     // Free memory not used on screen
2128     if (m_gridModel->ChannelItemsSize() > m_channelsPerPage + cacheBeforeChannel + cacheAfterChannel)
2129       m_gridModel->FreeChannelMemory(chanOffset - cacheBeforeChannel,
2130                                      chanOffset + m_channelsPerPage - 1 + cacheAfterChannel);
2131   }
2132
2133   CPoint originChannel = CPoint(m_channelPosX, m_channelPosY) + m_renderOffset;
2134   float pos;
2135   float end;
2136
2137   if (m_orientation == VERTICAL)
2138   {
2139     pos = originChannel.y;
2140     end = m_posY + m_height;
2141   }
2142   else
2143   {
2144     pos = originChannel.x;
2145     end = m_posX + m_width;
2146   }
2147
2148   // we offset our draw position to take into account scrolling and whether or not our focused
2149   // item is offscreen "above" the list.
2150   float drawOffset = (chanOffset - cacheBeforeChannel) * m_channelLayout->Size(m_orientation) -
2151                      GetChannelScrollOffsetPos();
2152   if (m_channelOffset + m_channelCursor < chanOffset)
2153     drawOffset += m_focusedChannelLayout->Size(m_orientation) - m_channelLayout->Size(m_orientation);
2154
2155   pos += drawOffset;
2156   end += cacheAfterChannel * m_channelLayout->Size(m_orientation);
2157
2158   float focusedPos = 0;
2159   std::shared_ptr<CGUIListItem> focusedItem;
2160
2161   CFileItemPtr item;
2162   int current = chanOffset - cacheBeforeChannel;
2163   while (pos < end && m_gridModel->HasChannelItems())
2164   {
2165     int itemNo = current;
2166     if (itemNo >= m_gridModel->ChannelItemsSize())
2167       break;
2168
2169     bool focused = (current == m_channelOffset + m_channelCursor);
2170     if (itemNo >= 0)
2171     {
2172       item = m_gridModel->GetChannelItem(itemNo);
2173       if (bRender)
2174       {
2175         // render our item
2176         if (focused)
2177         {
2178           focusedPos = pos;
2179           focusedItem = item;
2180         }
2181         else
2182         {
2183           if (m_orientation == VERTICAL)
2184             RenderItem(originChannel.x, pos, item.get(), false);
2185           else
2186             RenderItem(pos, originChannel.y, item.get(), false);
2187         }
2188       }
2189       else if (bAssignDepth)
2190       {
2191         if (focused)
2192           focusedItem = item;
2193         else
2194           AssignItemDepth(item.get(), false);
2195       }
2196       else
2197       {
2198         // process our item
2199         if (m_orientation == VERTICAL)
2200           ProcessItem(originChannel.x, pos, item, m_lastItem, focused, m_channelLayout, m_focusedChannelLayout, currentTime, dirtyregions);
2201         else
2202           ProcessItem(pos, originChannel.y, item, m_lastItem, focused, m_channelLayout, m_focusedChannelLayout, currentTime, dirtyregions);
2203       }
2204     }
2205     // increment our position
2206     pos += focused ? m_focusedChannelLayout->Size(m_orientation) : m_channelLayout->Size(m_orientation);
2207     current++;
2208   }
2209
2210   if (bRender)
2211   {
2212     // render focused item last so it can overlap other items
2213     if (focusedItem)
2214     {
2215       if (m_orientation == VERTICAL)
2216         RenderItem(originChannel.x, focusedPos, focusedItem.get(), true);
2217       else
2218         RenderItem(focusedPos, originChannel.y, focusedItem.get(), true);
2219     }
2220
2221     CServiceBroker::GetWinSystem()->GetGfxContext().RestoreClipRegion();
2222   }
2223   else if (bAssignDepth && focusedItem)
2224   {
2225     AssignItemDepth(focusedItem.get(), true);
2226   }
2227 }
2228
2229 void CGUIEPGGridContainer::HandleRulerDate(bool bRender,
2230                                            unsigned int currentTime,
2231                                            CDirtyRegionList& dirtyregions,
2232                                            bool bAssignDepth)
2233 {
2234   if (!m_rulerDateLayout || m_gridModel->RulerItemsSize() <= 1 || m_gridModel->IsZeroGridDuration())
2235     return;
2236
2237   CFileItemPtr item(m_gridModel->GetRulerItem(0));
2238
2239   if (bRender)
2240   {
2241     // Render single ruler item with date of selected programme
2242     CServiceBroker::GetWinSystem()->GetGfxContext().SetClipRegion(m_posX, m_posY, m_rulerDateWidth, m_rulerDateHeight);
2243     RenderItem(m_posX, m_posY, item.get(), false);
2244     CServiceBroker::GetWinSystem()->GetGfxContext().RestoreClipRegion();
2245   }
2246   else if (bAssignDepth)
2247   {
2248     AssignItemDepth(item.get(), false);
2249   }
2250   else
2251   {
2252     const int rulerOffset = GetProgrammeScrollOffset();
2253     item->SetLabel(m_gridModel->GetRulerItem(rulerOffset / m_rulerUnit + 1)->GetLabel2());
2254
2255     CFileItemPtr lastitem;
2256     ProcessItem(m_posX, m_posY, item, lastitem, false, m_rulerDateLayout, m_rulerDateLayout, currentTime, dirtyregions);
2257   }
2258 }
2259
2260 void CGUIEPGGridContainer::HandleRuler(bool bRender,
2261                                        unsigned int currentTime,
2262                                        CDirtyRegionList& dirtyregions,
2263                                        bool bAssignDepth)
2264 {
2265   if (!m_rulerLayout || m_gridModel->RulerItemsSize() <= 1 || m_gridModel->IsZeroGridDuration())
2266     return;
2267
2268   int rulerOffset = GetProgrammeScrollOffset();
2269
2270   CFileItemPtr item(m_gridModel->GetRulerItem(0));
2271   CFileItemPtr lastitem;
2272   int cacheBeforeRuler, cacheAfterRuler;
2273
2274   if (bRender)
2275   {
2276     if (!m_rulerDateLayout)
2277     {
2278       // Render single ruler item with date of selected programme
2279       CServiceBroker::GetWinSystem()->GetGfxContext().SetClipRegion(m_posX, m_posY, m_width, m_height);
2280       RenderItem(m_posX, m_posY, item.get(), false);
2281       CServiceBroker::GetWinSystem()->GetGfxContext().RestoreClipRegion();
2282     }
2283
2284     // render ruler items
2285     GetProgrammeCacheOffsets(cacheBeforeRuler, cacheAfterRuler);
2286
2287     if (m_orientation == VERTICAL)
2288       CServiceBroker::GetWinSystem()->GetGfxContext().SetClipRegion(m_rulerPosX, m_rulerPosY, m_gridWidth, m_rulerHeight);
2289     else
2290       CServiceBroker::GetWinSystem()->GetGfxContext().SetClipRegion(m_rulerPosX, m_rulerPosY, m_rulerWidth, m_gridHeight);
2291   }
2292   else if (bAssignDepth)
2293   {
2294     if (!m_rulerDateLayout)
2295       AssignItemDepth(item.get(), false);
2296     GetProgrammeCacheOffsets(cacheBeforeRuler, cacheAfterRuler);
2297   }
2298   else
2299   {
2300     if (!m_rulerDateLayout)
2301     {
2302       item->SetLabel(m_gridModel->GetRulerItem(rulerOffset / m_rulerUnit + 1)->GetLabel2());
2303       ProcessItem(m_posX, m_posY, item, lastitem, false, m_rulerLayout, m_rulerLayout, currentTime, dirtyregions, m_channelWidth);
2304     }
2305
2306     GetProgrammeCacheOffsets(cacheBeforeRuler, cacheAfterRuler);
2307
2308     // Free memory not used on screen
2309     if (m_gridModel->RulerItemsSize() > m_blocksPerPage + cacheBeforeRuler + cacheAfterRuler)
2310       m_gridModel->FreeRulerMemory(rulerOffset / m_rulerUnit + 1 - cacheBeforeRuler,
2311                                    rulerOffset / m_rulerUnit + 1 + m_blocksPerPage - 1 +
2312                                        cacheAfterRuler);
2313   }
2314
2315   CPoint originRuler = CPoint(m_rulerPosX, m_rulerPosY) + m_renderOffset;
2316   float pos;
2317   float end;
2318
2319   if (m_orientation == VERTICAL)
2320   {
2321     pos = originRuler.x;
2322     end = m_posX + m_width;
2323   }
2324   else
2325   {
2326     pos = originRuler.y;
2327     end = m_posY + m_height;
2328   }
2329
2330   const float drawOffset =
2331       (rulerOffset - cacheBeforeRuler) * m_blockSize - GetProgrammeScrollOffsetPos();
2332   pos += drawOffset;
2333   end += cacheAfterRuler * m_rulerLayout->Size(m_orientation == VERTICAL ? HORIZONTAL : VERTICAL);
2334
2335   if (rulerOffset % m_rulerUnit != 0)
2336   {
2337     /* first ruler marker starts before current view */
2338     int startBlock = rulerOffset - 1;
2339
2340     while (startBlock % m_rulerUnit != 0)
2341       startBlock--;
2342
2343     int missingSection = rulerOffset - startBlock;
2344
2345     pos -= missingSection * m_blockSize;
2346   }
2347
2348   while (pos < end && (rulerOffset / m_rulerUnit + 1) < m_gridModel->RulerItemsSize())
2349   {
2350     item = m_gridModel->GetRulerItem(rulerOffset / m_rulerUnit + 1);
2351
2352     if (m_orientation == VERTICAL)
2353     {
2354       if (bRender)
2355         RenderItem(pos, originRuler.y, item.get(), false);
2356       else if (bAssignDepth)
2357         AssignItemDepth(item.get(), false);
2358       else
2359         ProcessItem(pos, originRuler.y, item, lastitem, false, m_rulerLayout, m_rulerLayout, currentTime, dirtyregions, m_rulerWidth);
2360
2361       pos += m_rulerWidth;
2362     }
2363     else
2364     {
2365       if (bRender)
2366         RenderItem(originRuler.x, pos, item.get(), false);
2367       else if (bAssignDepth)
2368         AssignItemDepth(item.get(), false);
2369       else
2370         ProcessItem(originRuler.x, pos, item, lastitem, false, m_rulerLayout, m_rulerLayout, currentTime, dirtyregions, m_rulerHeight);
2371
2372       pos += m_rulerHeight;
2373     }
2374
2375     rulerOffset += m_rulerUnit;
2376   }
2377
2378   if (bRender)
2379     CServiceBroker::GetWinSystem()->GetGfxContext().RestoreClipRegion();
2380 }
2381
2382 void CGUIEPGGridContainer::HandleProgrammeGrid(bool bRender,
2383                                                unsigned int currentTime,
2384                                                CDirtyRegionList& dirtyregions,
2385                                                bool bAssignDepth)
2386 {
2387   if (!m_focusedProgrammeLayout || !m_programmeLayout || m_gridModel->RulerItemsSize() <= 1 || m_gridModel->IsZeroGridDuration())
2388     return;
2389
2390   const int blockOffset = GetProgrammeScrollOffset();
2391   const int chanOffset = GetChannelScrollOffset(m_programmeLayout);
2392
2393   int cacheBeforeProgramme, cacheAfterProgramme;
2394   GetProgrammeCacheOffsets(cacheBeforeProgramme, cacheAfterProgramme);
2395
2396   if (bRender)
2397   {
2398     CServiceBroker::GetWinSystem()->GetGfxContext().SetClipRegion(m_gridPosX, m_gridPosY, m_gridWidth, m_gridHeight);
2399   }
2400   else if (!bAssignDepth)
2401   {
2402     int cacheBeforeChannel, cacheAfterChannel;
2403     GetChannelCacheOffsets(cacheBeforeChannel, cacheAfterChannel);
2404
2405     // Free memory not used on screen
2406     int firstChannel = chanOffset - cacheBeforeChannel;
2407     if (firstChannel < 0)
2408       firstChannel = 0;
2409     int lastChannel = chanOffset + m_channelsPerPage - 1 + cacheAfterChannel;
2410     if (lastChannel > m_gridModel->GetLastChannel())
2411       lastChannel = m_gridModel->GetLastChannel();
2412     int firstBlock = blockOffset - cacheBeforeProgramme;
2413     if (firstBlock < 0)
2414       firstBlock = 0;
2415     int lastBlock = blockOffset + m_programmesPerPage - 1 + cacheAfterProgramme;
2416     if (lastBlock > m_gridModel->GetLastBlock())
2417       lastBlock = m_gridModel->GetLastBlock();
2418
2419     if (m_gridModel->FreeProgrammeMemory(firstChannel, lastChannel, firstBlock, lastBlock))
2420     {
2421       // announce changed viewport
2422       const CGUIMessage msg(
2423           GUI_MSG_REFRESH_LIST, GetParentID(), GetID(), static_cast<int>(PVREvent::Epg));
2424       CServiceBroker::GetAppMessenger()->SendGUIMessage(msg);
2425     }
2426   }
2427
2428   CPoint originProgramme = CPoint(m_gridPosX, m_gridPosY) + m_renderOffset;
2429   float posA;
2430   float endA;
2431   float posB;
2432   float endB;
2433
2434   if (m_orientation == VERTICAL)
2435   {
2436     posA = originProgramme.x;
2437     endA = m_posX + m_width;
2438     posB = originProgramme.y;
2439     endB = m_gridPosY + m_gridHeight;
2440   }
2441   else
2442   {
2443     posA = originProgramme.y;
2444     endA = m_posY + m_height;
2445     posB = originProgramme.x;
2446     endB = m_gridPosX + m_gridWidth;
2447   }
2448
2449   endA += cacheAfterProgramme * m_blockSize;
2450
2451   const float drawOffsetA = blockOffset * m_blockSize - GetProgrammeScrollOffsetPos();
2452   posA += drawOffsetA;
2453   const float drawOffsetB =
2454       (chanOffset - cacheBeforeProgramme) * m_channelLayout->Size(m_orientation) -
2455       GetChannelScrollOffsetPos();
2456   posB += drawOffsetB;
2457
2458   int channel = chanOffset - cacheBeforeProgramme;
2459
2460   float focusedPosX = 0;
2461   float focusedPosY = 0;
2462   CFileItemPtr focusedItem;
2463   CFileItemPtr item;
2464
2465   const int lastChannel = m_gridModel->GetLastChannel();
2466   while (posB < endB && HasData() && channel <= lastChannel)
2467   {
2468     if (channel >= 0)
2469     {
2470       int block = blockOffset;
2471       float posA2 = posA;
2472
2473       const int startBlock = blockOffset == 0 ? 0 : blockOffset - 1;
2474       if (startBlock == 0 || m_gridModel->IsSameGridItem(channel, block, startBlock))
2475       {
2476         // First program starts before current view
2477         block = m_gridModel->GetGridItemStartBlock(channel, startBlock);
2478         const int missingSection = blockOffset - block;
2479         posA2 -= missingSection * m_blockSize;
2480       }
2481
2482       const int lastBlock = m_gridModel->GetLastBlock();
2483       while (posA2 < endA && HasData() && block <= lastBlock)
2484       {
2485         item = m_gridModel->GetGridItem(channel, block);
2486
2487         bool focused = (channel == m_channelOffset + m_channelCursor) &&
2488                        m_gridModel->IsSameGridItem(m_channelOffset + m_channelCursor,
2489                                                    m_blockOffset + m_blockCursor, block);
2490
2491         if (bRender)
2492         {
2493           // reset to grid start position if first item is out of grid view
2494           if (posA2 < posA)
2495             posA2 = posA;
2496
2497           // render our item
2498           if (focused)
2499           {
2500             focusedPosX = posA2;
2501             focusedPosY = posB;
2502             focusedItem = item;
2503           }
2504           else
2505           {
2506             if (m_orientation == VERTICAL)
2507               RenderItem(posA2, posB, item.get(), focused);
2508             else
2509               RenderItem(posB, posA2, item.get(), focused);
2510           }
2511         }
2512         else if (bAssignDepth)
2513         {
2514           // reset to grid start position if first item is out of grid view
2515           if (posA2 < posA)
2516             posA2 = posA;
2517
2518           // render our item
2519           if (focused)
2520           {
2521             focusedPosX = posA2;
2522             focusedPosY = posB;
2523             focusedItem = item;
2524           }
2525           else
2526           {
2527             AssignItemDepth(item.get(), focused);
2528           }
2529         }
2530         else
2531         {
2532           // calculate the size to truncate if item is out of grid view
2533           float truncateSize = 0;
2534           if (posA2 < posA)
2535           {
2536             truncateSize = posA - posA2;
2537             posA2 = posA; // reset to grid start position
2538           }
2539
2540           {
2541             std::unique_lock<CCriticalSection> lock(m_critSection);
2542             // truncate item's width
2543             m_gridModel->DecreaseGridItemWidth(channel, block, truncateSize);
2544           }
2545
2546           if (m_orientation == VERTICAL)
2547             ProcessItem(posA2, posB, item, m_lastChannel, focused, m_programmeLayout,
2548                         m_focusedProgrammeLayout, currentTime, dirtyregions,
2549                         m_gridModel->GetGridItemWidth(channel, block));
2550           else
2551             ProcessItem(posB, posA2, item, m_lastChannel, focused, m_programmeLayout,
2552                         m_focusedProgrammeLayout, currentTime, dirtyregions,
2553                         m_gridModel->GetGridItemWidth(channel, block));
2554         }
2555
2556         // increment our X position
2557         posA2 += m_gridModel->GetGridItemWidth(
2558             channel, block); // assumes focused & unfocused layouts have equal length
2559         block += MathUtils::round_int(
2560             static_cast<double>(m_gridModel->GetGridItemOriginWidth(channel, block) / m_blockSize));
2561       }
2562     }
2563
2564     // increment our Y position
2565     channel++;
2566     posB += (m_orientation == VERTICAL) ? m_channelHeight : m_channelWidth;
2567   }
2568
2569   if (bRender)
2570   {
2571     // and render the focused item last (for overlapping purposes)
2572     if (focusedItem)
2573     {
2574       if (m_orientation == VERTICAL)
2575         RenderItem(focusedPosX, focusedPosY, focusedItem.get(), true);
2576       else
2577         RenderItem(focusedPosY, focusedPosX, focusedItem.get(), true);
2578     }
2579
2580     CServiceBroker::GetWinSystem()->GetGfxContext().RestoreClipRegion();
2581   }
2582   else if (bAssignDepth && focusedItem)
2583   {
2584     AssignItemDepth(focusedItem.get(), true);
2585   }
2586 }
2587
2588 void CGUIEPGGridContainer::AssignDepth()
2589 {
2590   unsigned int dummyTime = 0;
2591   CDirtyRegionList dummyRegions;
2592   HandleChannels(false, dummyTime, dummyRegions, true);
2593   HandleRuler(false, dummyTime, dummyRegions, true);
2594   HandleRulerDate(false, dummyTime, dummyRegions, true);
2595   HandleProgrammeGrid(false, dummyTime, dummyRegions, true);
2596   m_guiProgressIndicatorTextureDepth = CServiceBroker::GetWinSystem()->GetGfxContext().GetDepth();
2597 }
2598
2599 void CGUIEPGGridContainer::AssignItemDepth(CGUIListItem* item, bool focused)
2600 {
2601   if (focused)
2602   {
2603     if (item->GetFocusedLayout())
2604       item->GetFocusedLayout()->AssignDepth();
2605   }
2606   else
2607   {
2608     if (item->GetFocusedLayout() && item->GetFocusedLayout()->IsAnimating(ANIM_TYPE_UNFOCUS))
2609       item->GetFocusedLayout()->AssignDepth();
2610     else if (item->GetLayout())
2611       item->GetLayout()->AssignDepth();
2612   }
2613 }