xbmc/guilib/GUIControlGroup.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "GUIControlGroup.h"
  10
  11 #include "GUIMessage.h"
  12
  13 #include <cassert>
  14 #include <utility>
  15
  16 CGUIControlGroup::CGUIControlGroup()
  17 {
  18   m_defaultControl = 0;
  19   m_defaultAlways = false;
  20   m_focusedControl = 0;
  21   m_renderFocusedLast = false;
  22   ControlType = GUICONTROL_GROUP;
  23 }
  24
  25 CGUIControlGroup::CGUIControlGroup(int parentID, int controlID, float posX, float posY, float width, float height)
  26 : CGUIControlLookup(parentID, controlID, posX, posY, width, height)
  27 {
  28   m_defaultControl = 0;
  29   m_defaultAlways = false;
  30   m_focusedControl = 0;
  31   m_renderFocusedLast = false;
  32   ControlType = GUICONTROL_GROUP;
  33 }
  34
  35 CGUIControlGroup::CGUIControlGroup(const CGUIControlGroup &from)
  36 : CGUIControlLookup(from)
  37 {
  38   m_defaultControl = from.m_defaultControl;
  39   m_defaultAlways = from.m_defaultAlways;
  40   m_renderFocusedLast = from.m_renderFocusedLast;
  41
  42   // run through and add our controls
  43   for (auto *i : from.m_children)
  44     AddControl(i->Clone());
  45
  46   // defaults
  47   m_focusedControl = 0;
  48   ControlType = GUICONTROL_GROUP;
  49 }
  50
  51 CGUIControlGroup::~CGUIControlGroup(void)
  52 {
  53   ClearAll();
  54 }
  55
  56 void CGUIControlGroup::AllocResources()
  57 {
  58   CGUIControl::AllocResources();
  59   for (auto *control : m_children)
  60   {
  61     if (!control->IsDynamicallyAllocated())
  62       control->AllocResources();
  63   }
  64 }
  65
  66 void CGUIControlGroup::FreeResources(bool immediately)
  67 {
  68   CGUIControl::FreeResources(immediately);
  69   for (auto *control : m_children)
  70   {
  71     control->FreeResources(immediately);
  72   }
  73 }
  74
  75 void CGUIControlGroup::DynamicResourceAlloc(bool bOnOff)
  76 {
  77   for (auto *control : m_children)
  78   {
  79     control->DynamicResourceAlloc(bOnOff);
  80   }
  81 }
  82
  83 void CGUIControlGroup::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
  84 {
  85   CPoint pos(GetPosition());
  86   CServiceBroker::GetWinSystem()->GetGfxContext().SetOrigin(pos.x, pos.y);
  87
  88   CRect rect;
  89   for (auto *control : m_children)
  90   {
  91     control->UpdateVisibility(nullptr);
  92     unsigned int oldDirty = dirtyregions.size();
  93     control->DoProcess(currentTime, dirtyregions);
  94     if (control->IsVisible() || (oldDirty != dirtyregions.size())) // visible or dirty (was visible?)
  95       rect.Union(control->GetRenderRegion());
  96   }
  97
  98   CServiceBroker::GetWinSystem()->GetGfxContext().RestoreOrigin();
  99   CGUIControl::Process(currentTime, dirtyregions);
 100   m_renderRegion = rect;
 101 }
 102
 103 void CGUIControlGroup::Render()
 104 {
 105   CPoint pos(GetPosition());
 106   CServiceBroker::GetWinSystem()->GetGfxContext().SetOrigin(pos.x, pos.y);
 107   CGUIControl *focusedControl = NULL;
 108   for (auto *control : m_children)
 109   {
 110     if (m_renderFocusedLast && control->HasFocus())
 111       focusedControl = control;
 112     else
 113       control->DoRender();
 114   }
 115   if (focusedControl)
 116     focusedControl->DoRender();
 117   CGUIControl::Render();
 118   CServiceBroker::GetWinSystem()->GetGfxContext().RestoreOrigin();
 119 }
 120
 121 void CGUIControlGroup::RenderEx()
 122 {
 123   for (auto *control : m_children)
 124     control->RenderEx();
 125   CGUIControl::RenderEx();
 126 }
 127
 128 bool CGUIControlGroup::OnAction(const CAction &action)
 129 {
 130   assert(false);  // unimplemented
 131   return false;
 132 }
 133
 134 bool CGUIControlGroup::HasFocus() const
 135 {
 136   for (auto *control : m_children)
 137   {
 138     if (control->HasFocus())
 139       return true;
 140   }
 141   return false;
 142 }
 143
 144 bool CGUIControlGroup::OnMessage(CGUIMessage& message)
 145 {
 146   switch (message.GetMessage() )
 147   {
 148   case GUI_MSG_ITEM_SELECT:
 149     {
 150       if (message.GetControlId() == GetID())
 151       {
 152         m_focusedControl = message.GetParam1();
 153         return true;
 154       }
 155       break;
 156     }
 157   case GUI_MSG_ITEM_SELECTED:
 158     {
 159       if (message.GetControlId() == GetID())
 160       {
 161         message.SetParam1(m_focusedControl);
 162         return true;
 163       }
 164       break;
 165     }
 166   case GUI_MSG_FOCUSED:
 167     { // a control has been focused
 168       m_focusedControl = message.GetControlId();
 169       SetFocus(true);
 170       // tell our parent thatwe have focus
 171       if (m_parentControl)
 172         m_parentControl->OnMessage(message);
 173       return true;
 174     }
 175   case GUI_MSG_SETFOCUS:
 176     {
 177       // first try our last focused control...
 178       if (!m_defaultAlways && m_focusedControl)
 179       {
 180         CGUIControl *control = GetFirstFocusableControl(m_focusedControl);
 181         if (control)
 182         {
 183           CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
 184           return control->OnMessage(msg);
 185         }
 186       }
 187       // ok, no previously focused control, try the default control first
 188       if (m_defaultControl)
 189       {
 190         CGUIControl *control = GetFirstFocusableControl(m_defaultControl);
 191         if (control)
 192         {
 193           CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
 194           return control->OnMessage(msg);
 195         }
 196       }
 197       // no success with the default control, so just find one to focus
 198       CGUIControl *control = GetFirstFocusableControl(0);
 199       if (control)
 200       {
 201         CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
 202         return control->OnMessage(msg);
 203       }
 204       // unsuccessful
 205       return false;
 206       break;
 207     }
 208   case GUI_MSG_LOSTFOCUS:
 209     {
 210       // set all subcontrols unfocused
 211       for (auto *control : m_children)
 212         control->SetFocus(false);
 213       if (!GetControl(message.GetParam1()))
 214       { // we don't have the new id, so unfocus
 215         SetFocus(false);
 216         if (m_parentControl)
 217           m_parentControl->OnMessage(message);
 218       }
 219       return true;
 220     }
 221     break;
 222   case GUI_MSG_PAGE_CHANGE:
 223   case GUI_MSG_REFRESH_THUMBS:
 224   case GUI_MSG_REFRESH_LIST:
 225   case GUI_MSG_WINDOW_RESIZE:
 226     { // send to all child controls (make sure the target is the control id)
 227       for (auto *control : m_children)
 228       {
 229         CGUIMessage msg(message.GetMessage(), message.GetSenderId(), control->GetID(), message.GetParam1());
 230         control->OnMessage(msg);
 231       }
 232       return true;
 233     }
 234     break;
 235   case GUI_MSG_REFRESH_TIMER:
 236     if (!IsVisible() || !IsVisibleFromSkin())
 237       return true;
 238     break;
 239   }
 240   bool handled(false);
 241   //not intended for any specific control, send to all childs and our base handler.
 242   if (message.GetControlId() == 0)
 243   {
 244     for (auto *control : m_children)
 245     {
 246       handled |= control->OnMessage(message);
 247     }
 248     return CGUIControl::OnMessage(message) || handled;
 249   }
 250   // if it's intended for us, then so be it
 251   if (message.GetControlId() == GetID())
 252     return CGUIControl::OnMessage(message);
 253
 254   return SendControlMessage(message);
 255 }
 256
 257 bool CGUIControlGroup::SendControlMessage(CGUIMessage &message)
 258 {
 259   IDCollector collector(m_idCollector);
 260
 261   CGUIControl *ctrl(GetControl(message.GetControlId(), collector.m_collector));
 262   // see if a child matches, and send to the child control if so
 263   if (ctrl && ctrl->OnMessage(message))
 264     return true;
 265
 266   // Unhandled - send to all matching invisible controls as well
 267   bool handled(false);
 268   for (auto *control : *collector.m_collector)
 269     if (control->OnMessage(message))
 270       handled = true;
 271
 272   return handled;
 273 }
 274
 275 bool CGUIControlGroup::CanFocus() const
 276 {
 277   if (!CGUIControl::CanFocus()) return false;
 278   // see if we have any children that can be focused
 279   for (auto *control : m_children)
 280   {
 281     if (control->CanFocus())
 282       return true;
 283   }
 284   return false;
 285 }
 286
 287 void CGUIControlGroup::SetInitialVisibility()
 288 {
 289   CGUIControl::SetInitialVisibility();
 290   for (auto *control : m_children)
 291     control->SetInitialVisibility();
 292 }
 293
 294 void CGUIControlGroup::QueueAnimation(ANIMATION_TYPE animType)
 295 {
 296   CGUIControl::QueueAnimation(animType);
 297   // send window level animations to our children as well
 298   if (animType == ANIM_TYPE_WINDOW_OPEN || animType == ANIM_TYPE_WINDOW_CLOSE)
 299   {
 300     for (auto *control : m_children)
 301       control->QueueAnimation(animType);
 302   }
 303 }
 304
 305 void CGUIControlGroup::ResetAnimation(ANIMATION_TYPE animType)
 306 {
 307   CGUIControl::ResetAnimation(animType);
 308   // send window level animations to our children as well
 309   if (animType == ANIM_TYPE_WINDOW_OPEN || animType == ANIM_TYPE_WINDOW_CLOSE)
 310   {
 311     for (auto *control : m_children)
 312       control->ResetAnimation(animType);
 313   }
 314 }
 315
 316 void CGUIControlGroup::ResetAnimations()
 317 { // resets all animations, regardless of condition
 318   CGUIControl::ResetAnimations();
 319   for (auto *control : m_children)
 320     control->ResetAnimations();
 321 }
 322
 323 bool CGUIControlGroup::IsAnimating(ANIMATION_TYPE animType)
 324 {
 325   if (CGUIControl::IsAnimating(animType))
 326     return true;
 327
 328   if (IsVisible())
 329   {
 330     for (auto *control : m_children)
 331     {
 332       if (control->IsAnimating(animType))
 333         return true;
 334     }
 335   }
 336   return false;
 337 }
 338
 339 bool CGUIControlGroup::HasAnimation(ANIMATION_TYPE animType)
 340 {
 341   if (CGUIControl::HasAnimation(animType))
 342     return true;
 343
 344   if (IsVisible())
 345   {
 346     for (auto *control : m_children)
 347     {
 348       if (control->HasAnimation(animType))
 349         return true;
 350     }
 351   }
 352   return false;
 353 }
 354
 355 EVENT_RESULT CGUIControlGroup::SendMouseEvent(const CPoint &point, const CMouseEvent &event)
 356 {
 357   // transform our position into child coordinates
 358   CPoint childPoint(point);
 359   m_transform.InverseTransformPosition(childPoint.x, childPoint.y);
 360
 361   if (CGUIControl::CanFocus())
 362   {
 363     CPoint pos(GetPosition());
 364     // run through our controls in reverse order (so that last rendered is checked first)
 365     for (rControls i = m_children.rbegin(); i != m_children.rend(); ++i)
 366     {
 367       CGUIControl *child = *i;
 368       EVENT_RESULT ret = child->SendMouseEvent(childPoint - pos, event);
 369       if (ret)
 370       { // we've handled the action, and/or have focused an item
 371         return ret;
 372       }
 373     }
 374     // none of our children want the event, but we may want it.
 375     EVENT_RESULT ret;
 376     if (HitTest(childPoint) && (ret = OnMouseEvent(childPoint, event)))
 377       return ret;
 378   }
 379   m_focusedControl = 0;
 380   return EVENT_RESULT_UNHANDLED;
 381 }
 382
 383 void CGUIControlGroup::UnfocusFromPoint(const CPoint &point)
 384 {
 385   CPoint controlCoords(point);
 386   m_transform.InverseTransformPosition(controlCoords.x, controlCoords.y);
 387   controlCoords -= GetPosition();
 388   for (auto *child : m_children)
 389   {
 390     child->UnfocusFromPoint(controlCoords);
 391   }
 392   CGUIControl::UnfocusFromPoint(point);
 393 }
 394
 395 int CGUIControlGroup::GetFocusedControlID() const
 396 {
 397   if (m_focusedControl) return m_focusedControl;
 398   CGUIControl *control = GetFocusedControl();
 399   if (control) return control->GetID();
 400   return 0;
 401 }
 402
 403 CGUIControl *CGUIControlGroup::GetFocusedControl() const
 404 {
 405   // try lookup first
 406   if (m_focusedControl)
 407   {
 408     // we may have multiple controls with same id - we pick first that has focus
 409     std::pair<LookupMap::const_iterator, LookupMap::const_iterator> range = GetLookupControls(m_focusedControl);
 410
 411     for (LookupMap::const_iterator i = range.first; i != range.second; ++i)
 412     {
 413       if (i->second->HasFocus())
 414         return i->second;
 415     }
 416   }
 417
 418   // if lookup didn't find focused control, iterate m_children to find it
 419   for (auto *control : m_children)
 420   {
 421     // Avoid calling HasFocus() on control group as it will (possibly) recursively
 422     // traverse entire group tree just to check if there is focused control.
 423     // We are recursively traversing it here so no point in doing it twice.
 424     CGUIControlGroup *groupControl(dynamic_cast<CGUIControlGroup*>(control));
 425     if (groupControl)
 426     {
 427       CGUIControl* focusedControl = groupControl->GetFocusedControl();
 428       if (focusedControl)
 429         return focusedControl;
 430     }
 431     else if (control->HasFocus())
 432       return control;
 433   }
 434   return NULL;
 435 }
 436
 437 // in the case of id == 0, we don't match id
 438 CGUIControl *CGUIControlGroup::GetFirstFocusableControl(int id)
 439 {
 440   if (!CanFocus()) return NULL;
 441   if (id && id == GetID()) return this; // we're focusable and they want us
 442   for (auto *pControl : m_children)
 443   {
 444     CGUIControlGroup *group(dynamic_cast<CGUIControlGroup*>(pControl));
 445     if (group)
 446     {
 447       CGUIControl *control = group->GetFirstFocusableControl(id);
 448       if (control) return control;
 449     }
 450     if ((!id || pControl->GetID() == id) && pControl->CanFocus())
 451       return pControl;
 452   }
 453   return NULL;
 454 }
 455
 456 void CGUIControlGroup::AddControl(CGUIControl *control, int position /* = -1*/)
 457 {
 458   if (!control) return;
 459   if (position < 0 || position > (int)m_children.size())
 460     position = (int)m_children.size();
 461   m_children.insert(m_children.begin() + position, control);
 462   control->SetParentControl(this);
 463   control->SetControlStats(m_controlStats);
 464   control->SetPushUpdates(m_pushedUpdates);
 465   AddLookup(control);
 466   SetInvalid();
 467 }
 468
 469 bool CGUIControlGroup::InsertControl(CGUIControl *control, const CGUIControl *insertPoint)
 470 {
 471   // find our position
 472   for (unsigned int i = 0; i < m_children.size(); i++)
 473   {
 474     CGUIControl *child = m_children[i];
 475     CGUIControlGroup *group(dynamic_cast<CGUIControlGroup*>(child));
 476     if (group && group->InsertControl(control, insertPoint))
 477       return true;
 478     else if (child == insertPoint)
 479     {
 480       AddControl(control, i);
 481       return true;
 482     }
 483   }
 484   return false;
 485 }
 486
 487 void CGUIControlGroup::SaveStates(std::vector<CControlState> &states)
 488 {
 489   // save our state, and that of our children
 490   states.emplace_back(GetID(), m_focusedControl);
 491   for (auto *control : m_children)
 492     control->SaveStates(states);
 493 }
 494
 495 // Note: This routine doesn't delete the control.  It just removes it from the control list
 496 bool CGUIControlGroup::RemoveControl(const CGUIControl *control)
 497 {
 498   for (iControls it = m_children.begin(); it != m_children.end(); ++it)
 499   {
 500     CGUIControl *child = *it;
 501     CGUIControlGroup *group(dynamic_cast<CGUIControlGroup*>(child));
 502     if (group && group->RemoveControl(control))
 503       return true;
 504     if (control == child)
 505     {
 506       m_children.erase(it);
 507       RemoveLookup(child);
 508       SetInvalid();
 509       return true;
 510     }
 511   }
 512   return false;
 513 }
 514
 515 void CGUIControlGroup::ClearAll()
 516 {
 517   // first remove from the lookup table
 518   RemoveLookup();
 519
 520   // and delete all our children
 521   for (auto *control : m_children)
 522   {
 523     delete control;
 524   }
 525   m_focusedControl = 0;
 526   m_children.clear();
 527   ClearLookup();
 528   SetInvalid();
 529 }
 530
 531 #ifdef _DEBUG
 532 void CGUIControlGroup::DumpTextureUse()
 533 {
 534   for (auto *control : m_children)
 535     control->DumpTextureUse();
 536 }
 537 #endif