MythTV  master
mythuibuttontree.cpp
Go to the documentation of this file.
1 
2 // Own header
3 #include "mythuibuttontree.h"
4 
5 // Qt headers
6 #include <QDomDocument>
7 #include <utility>
8 
9 // Mythdb headers
10 #include "mythlogging.h"
11 
12 // Mythui Headers
13 #include "mythmainwindow.h"
14 #include "mythgesture.h"
15 
16 MythUIButtonTree::MythUIButtonTree(MythUIType *parent, const QString &name)
17  : MythUIType(parent, name)
18 {
19  SetCanTakeFocus(true);
20 
21  connect(this, &MythUIType::TakingFocus, this, &MythUIButtonTree::Select);
23 }
24 
30 {
31  if (!m_listTemplate)
32  m_listTemplate = dynamic_cast<MythUIButtonList *>
33  (GetChild("listtemplate"));
34 
35  if (!m_listTemplate)
36  {
37  LOG(VB_GENERAL, LOG_ERR, QString("(%1) MythUIButtonList listtemplate "
38  "is required in mythuibuttonlist: %2")
39  .arg(GetXMLLocation().arg(objectName())));
40  return;
41  }
42 
43  m_listTemplate->SetVisible(false);
44 
45  int width = (m_area.width() - (m_listSpacing * (m_numLists - 1))) / m_numLists;
46  int height = m_area.height();
47 
48  int i = 0;
49 
50  while (i < (int)m_numLists)
51  {
52  QString listname = QString("buttontree list %1").arg(i);
53  auto *list = new MythUIButtonList(this, listname);
54  list->CopyFrom(m_listTemplate);
55  list->SetVisible(false);
56  list->SetActive(false);
57  list->SetCanTakeFocus(false);
58  int x = i * (width + m_listSpacing);
59  MythRect listArea = MythRect(x, 0, width, height);
60  list->SetArea(listArea);
61  m_buttonlists.append(list);
62  i++;
63  }
64 
65  m_initialized = true;
66 }
67 
71 void MythUIButtonTree::SetTreeState(bool refreshAll)
72 {
73  if (!m_initialized)
74  Init();
75 
76  if (!m_rootNode)
77  return;
78 
79  if (!m_currentNode)
81  if (!m_currentNode)
82  return;
83 
84  QList<MythGenericTree *> route = m_currentNode->getRoute();
85 
86  // Sanity Checks
87  if (m_depthOffset >= route.size())
88  m_depthOffset = 0;
89 
90  if (((int)m_currentDepth + m_depthOffset) >= route.size())
91  m_currentDepth = 0;
92 
93  MythGenericTree *node = route.at(m_currentDepth + m_depthOffset);
94 
96  refreshAll = true;
97 
99 
100  m_visibleLists = 0;
101  uint listid = 0;
102 
103  while (listid < (uint)m_buttonlists.count())
104  {
105  MythUIButtonList *list = m_buttonlists.at(listid);
106 
107  list->SetVisible(false);
108  list->SetActive(false);
109 
110  MythGenericTree *selectedNode = nullptr;
111 
112  if (node)
113  selectedNode = node->getSelectedChild(true);
114 
115  if (refreshAll || m_activeListID < listid)
116  {
117  if (!UpdateList(list, node))
118  {
119  listid++;
120  continue;
121  }
122  }
123 
124  if (m_active && (listid == m_activeListID))
125  {
126  m_activeList = list;
127  list->SetActive(true);
128  DoSetCurrentNode(selectedNode);
129  emit itemSelected(list->GetItemCurrent());
130  }
131 
132  listid++;
133 
134  list->SetVisible(true);
135  m_visibleLists++;
136 
137  node = selectedNode;
138  }
139 }
140 
150 {
151  disconnect(list, nullptr, nullptr, nullptr);
152 
153  list->Reset();
154 
155  QList<MythGenericTree *> *nodelist = nullptr;
156 
157  if (node)
158  nodelist = node->getAllChildren();
159 
160  if (!nodelist || nodelist->isEmpty())
161  return false;
162 
163  MythGenericTree *selectedNode = node->getSelectedChild(true);
164 
165  MythUIButtonListItem *selectedItem = nullptr;
166  QList<MythGenericTree *>::iterator it;
167 
168  for (it = nodelist->begin(); it != nodelist->end(); ++it)
169  {
170  MythGenericTree *childnode = *it;
171 
172  if (!childnode->IsVisible())
173  continue;
174 
175  MythUIButtonListItem *item = childnode->CreateListButton(list);
176 
177  if (childnode == selectedNode)
178  selectedItem = item;
179  }
180 
181  if (list->IsEmpty())
182  return false;
183 
184  if (selectedItem)
185  list->SetItemCurrent(selectedItem);
186 
187  connect(list, &MythUIButtonList::itemSelected,
189  connect(list, &MythUIButtonList::itemClicked,
191  connect(list, &MythUIButtonList::itemVisible,
193 
194  return true;
195 }
196 
212 {
213  if (!tree || !tree->visibleChildCount())
214  return false;
215 
216  if (m_rootNode)
217  Reset();
218 
219  m_rootNode = tree;
221  // The node we are given may not be the root node of that tree, we need
222  // to keep track of our depth in the tree so that we can navigate
223  // as though the parent nodes do not exist
225  SetTreeState(true);
226  emit rootChanged(m_rootNode);
227 
228  return true;
229 }
230 
235 {
236  m_rootNode = m_currentNode = nullptr;
237  m_visibleLists = 0;
239  m_activeList = nullptr;
240  m_activeListID = 0;
241  m_active = true;
242 
243  SetTreeState(true);
244  emit rootChanged(m_rootNode);
245 
247 }
248 
257 bool MythUIButtonTree::SetNodeById(QList<int> route)
258 {
259  MythGenericTree *node = m_rootNode->findNode(std::move(route));
260 
261  if (node && node->isSelectable())
262  {
263  DoSetCurrentNode(node);
264  SetTreeState();
265  return true;
266  }
267 
268  return false;
269 }
270 
279 bool MythUIButtonTree::SetNodeByString(QStringList route)
280 {
281  if (!m_rootNode)
282  {
283  DoSetCurrentNode(nullptr);
284  return false;
285  }
286 
287  MythGenericTree *foundNode = m_rootNode;
288 
289  bool foundit = false;
290 
291  if (!route.isEmpty())
292  {
293  if (route[0] == m_rootNode->GetText())
294  {
295  if (route.size() > 1)
296  {
297  for (int i = 1; i < route.size(); i ++)
298  {
299  MythGenericTree *node = foundNode->getChildByName(route[i]);
300 
301  if (node)
302  {
303  node->becomeSelectedChild();
304  foundNode = node;
305  foundit = true;
306  }
307  else
308  {
309  node = foundNode->getChildAt(0);
310 
311  if (node)
312  {
313  node->becomeSelectedChild();
314  foundNode = node;
315  }
316 
317  break;
318  }
319  }
320  }
321  else
322  foundit = true;
323  }
324  }
325 
326  DoSetCurrentNode(foundNode);
327 
328  m_currentDepth = qMax(0, (int)(foundNode->currentDepth() - m_depthOffset - m_numLists));
329  m_activeListID = qMin(foundNode->currentDepth() - m_depthOffset - 1, (int)(m_numLists - 1));
330 
331  SetTreeState(true);
332 
333  return foundit;
334 }
335 
345 {
346  if (!node)
347  return false;
348 
349  if (node == m_currentNode)
350  return true;
351 
352  QStringList route = node->getRouteByString();
353 
354  return SetNodeByString(route);
355 }
356 
358 {
359  if (m_activeList)
361 }
362 
364 {
365  if (node)
366  {
367  if (node == m_currentNode)
368  return true;
369 
370  m_currentNode = node;
371  node->becomeSelectedChild();
373  return true;
374  }
375 
376  return false;
377 }
378 
388 {
389  if (!item || !m_rootNode)
390  return;
391 
392  auto *node = item->GetData().value<MythGenericTree *>();
393 
394  if (node && node->getParent())
395  {
396  DoSetCurrentNode(node->getParent());
397 
398  if (deleteNode)
399  node->getParent()->deleteNode(node);
400  else
401  node->SetVisible(false);
402  }
403 
404  MythUIButtonList *list = item->parent();
405 
406  list->RemoveItem(item);
407 
408  if (list->IsEmpty())
409  {
410  if (m_currentDepth > 0)
411  m_currentDepth--;
412  else if (m_activeListID > 1)
413  m_activeListID--;
414 
415  SetTreeState(true);
416  }
417 }
418 
427 {
428  RemoveItem(GetItemCurrent(), deleteNode);
429 }
430 
437 {
438  m_active = active;
439 
440  if (m_initialized)
441  SetTreeState();
442 }
443 
445 {
446  SetActive(true);
447 }
448 
450 {
451  SetActive(false);
452 }
453 
454 
462 {
463  bool doUpdate = false;
464 
465  if (right)
466  {
467  if ((m_activeListID + 1 < m_visibleLists) &&
468  (m_activeListID + 1 < (uint)m_buttonlists.count()))
469  m_activeListID++;
470  else if (m_currentNode && m_currentNode->visibleChildCount() > 0)
471  {
472  m_currentDepth++;
473  doUpdate = true;
474  }
475  else
476  return;
477  }
478  else if (!right)
479  {
480  if (m_activeListID > 0)
481  m_activeListID--;
482  else if (m_currentDepth > 0)
483  {
484  m_currentDepth--;
485  doUpdate = true;
486  }
487  else
488  return;
489  }
490 
491  if (doUpdate)
492  SetTreeState();
493  else
494  {
495  if (m_activeList)
497 
498  if (m_activeListID < (uint)m_buttonlists.count())
499  {
501  m_activeList->Select();
502  }
503  }
504 }
505 
512 {
513  if (!item)
514  return;
515 
516  MythUIButtonList *list = item->parent();
517  QString name = list->objectName();
518 
519  // New list is automatically selected so we just need to deselect the old
520  // list
521  if (m_activeList)
523 
524  m_activeListID = name.section(' ', 2, 2).toInt();
525  m_activeList = list;
526 
527 
528  auto *node = item->GetData().value<MythGenericTree *> ();
529  DoSetCurrentNode(node);
530  SetTreeState();
531 }
532 
539 {
540  if (!item)
541  return;
542 
543  auto *node = item->GetData().value<MythGenericTree *>();
544 
545  if (DoSetCurrentNode(node))
546  emit itemClicked(item);
547 }
548 
555 {
556  if (m_activeList)
557  return m_activeList->GetItemCurrent();
558 
559  return nullptr;
560 }
561 
568 {
569  if (!item)
570  return;
571 
572  emit itemVisible(item);
573 }
574 
578 bool MythUIButtonTree::keyPressEvent(QKeyEvent *event)
579 {
580  QStringList actions;
581  bool handled = false;
582  handled = GetMythMainWindow()->TranslateKeyPress("Global", event, actions);
583 
584  for (int i = 0; i < actions.size() && !handled; i++)
585  {
586  QString action = actions[i];
587  handled = true;
588 
590  {
591  if (action == "SELECT" && m_currentNode->visibleChildCount() > 0)
592  {
593  SwitchList(true);
594  }
595  else if (action == "ESCAPE" && m_currentDepth > 0)
596  {
597  SwitchList(false);
598  }
599  else
600  handled = false;
601  }
602  else
603  {
604  if (action == "RIGHT" && m_currentNode->visibleChildCount() > 0)
605  {
606  SwitchList(true);
607  }
608  else if (action == "LEFT" && !(m_currentDepth == 0 && m_activeListID == 0))
609  {
610  SwitchList(false);
611  }
612  else
613  handled = false;
614  }
615  }
616 
617  if (!handled && m_activeList)
618  handled = m_activeList->keyPressEvent(event);
619 
620  return handled;
621 }
622 
624 {
625  bool handled = false;
626 
627  if (event->GetGesture() == MythGestureEvent::Click)
628  {
629  // We want the relative position of the click
630  QPoint position = event->GetPosition() -
631  m_parent->GetArea().topLeft();
632 
633  MythUIType *type = GetChildAt(position, false, false);
634 
635  if (!type)
636  return false;
637 
638  auto *list = dynamic_cast<MythUIButtonList *>(type);
639 
640  if (list)
641  handled = list->gestureEvent(event);
642  }
643 
644  return handled;
645 }
646 
651  const QString &filename, QDomElement &element, bool showWarnings)
652 {
653  if (element.tagName() == "spacing")
654  {
655  m_listSpacing = NormX(getFirstText(element).toInt());
656  }
657  else if (element.tagName() == "numlists")
658  {
659  m_numLists = getFirstText(element).toInt();
660  }
661  else
662  {
663  return MythUIType::ParseElement(filename, element, showWarnings);
664  }
665 
666  return true;
667 }
668 
673 {
674  auto *bt = new MythUIButtonTree(parent, objectName());
675  bt->CopyFrom(this);
676 }
677 
682 {
683  auto *bt = dynamic_cast<MythUIButtonTree *>(base);
684 
685  if (!bt)
686  return;
687 
688  m_numLists = bt->m_numLists;
689  m_listSpacing = bt->m_listSpacing;
690  m_active = bt->m_active;
691 
692  MythUIType::CopyFrom(base);
693 
694  m_listTemplate = dynamic_cast<MythUIButtonList *>(GetChild("listtemplate"));
695 
696  m_initialized = false;
697 }
MythUIType::m_area
MythRect m_area
Definition: mythuitype.h:251
mythuibuttontree.h
MythUIButtonTree::m_buttonlists
QList< MythUIButtonList * > m_buttonlists
Definition: mythuibuttontree.h:75
MythUIButtonTree::gestureEvent
bool gestureEvent(MythGestureEvent *event) override
Mouse click/movement handler, receives mouse gesture events from the QCoreApplication event loop.
Definition: mythuibuttontree.cpp:623
MythUIButtonTree::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: mythuibuttontree.cpp:578
MythUIButtonList::GetItemCurrent
MythUIButtonListItem * GetItemCurrent() const
Definition: mythuibuttonlist.cpp:1590
MythUIButtonTree::m_listTemplate
MythUIButtonList * m_listTemplate
Definition: mythuibuttontree.h:76
MythGenericTree::GetText
QString GetText(const QString &name="") const
Definition: mythgenerictree.cpp:548
MythUIButtonTree::CreateCopy
void CreateCopy(MythUIType *parent) override
Copy the state of this widget to the one given, it must be of the same type.
Definition: mythuibuttontree.cpp:672
MythGestureEvent::GetGesture
Gesture GetGesture() const
Definition: mythgesture.h:85
MythUIButtonTree::m_initialized
bool m_initialized
Definition: mythuibuttontree.h:69
MythUIButtonList::gestureEvent
bool gestureEvent(MythGestureEvent *event) override
Mouse click/movement handler, receives mouse gesture events from the QCoreApplication event loop.
Definition: mythuibuttonlist.cpp:2624
MythMainWindow::TranslateKeyPress
bool TranslateKeyPress(const QString &context, QKeyEvent *e, QStringList &actions, bool allowJumps=true)
Get a list of actions for a keypress in the given context.
Definition: mythmainwindow.cpp:1139
MythUIType::GetChild
MythUIType * GetChild(const QString &name) const
Get a named child of this UIType.
Definition: mythuitype.cpp:131
MythUIButtonList::RemoveItem
void RemoveItem(MythUIButtonListItem *item)
Definition: mythuibuttonlist.cpp:1488
MythGenericTree::visibleChildCount
uint visibleChildCount() const
Definition: mythgenerictree.h:91
MythUIButtonTree::SetNodeById
bool SetNodeById(QList< int > route)
Using a path based on the node IDs, set the currently selected node.
Definition: mythuibuttontree.cpp:257
MythGenericTree::currentDepth
int currentDepth(void)
Establish how deep in the current tree this node lies.
Definition: mythgenerictree.cpp:271
MythUIButtonList::m_layout
LayoutType m_layout
Definition: mythuibuttonlist.h:290
MythUIButtonTree::itemSelected
void itemSelected(MythUIButtonListItem *item)
MythUIButtonList::itemSelected
void itemSelected(MythUIButtonListItem *item)
arg
arg(title).arg(filename).arg(doDelete))
MythUIButtonTree::Deselect
void Deselect()
Definition: mythuibuttontree.cpp:449
MythUIButtonTree::GetItemCurrent
MythUIButtonListItem * GetItemCurrent(void) const
Return the currently selected list item.
Definition: mythuibuttontree.cpp:554
MythUIType::SetCanTakeFocus
void SetCanTakeFocus(bool set=true)
Set whether this widget can take focus.
Definition: mythuitype.cpp:343
MythUIButtonListItem::parent
MythUIButtonList * parent() const
Definition: mythuibuttonlist.cpp:3539
MythUIButtonTree::SetCurrentNode
bool SetCurrentNode(MythGenericTree *node)
Set the currently selected node.
Definition: mythuibuttontree.cpp:344
MythGenericTree::getChildByName
MythGenericTree * getChildByName(const QString &a_name) const
Definition: mythgenerictree.cpp:379
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
MythUIButtonTree::RemoveItem
void RemoveItem(MythUIButtonListItem *item, bool deleteNode=false)
Remove the item from the tree.
Definition: mythuibuttontree.cpp:387
MythUIButtonTree::m_numLists
uint m_numLists
Definition: mythuibuttontree.h:70
MythGenericTree::isSelectable
bool isSelectable() const
Definition: mythgenerictree.h:97
MythUIButtonTree::AssignTree
bool AssignTree(MythGenericTree *tree)
Assign the root node of the tree to be displayed.
Definition: mythuibuttontree.cpp:211
MythUIButtonTree::Select
void Select()
Definition: mythuibuttontree.cpp:444
MythRect
Wrapper around QRect allowing us to handle percentage and other relative values for areas in mythui.
Definition: mythrect.h:18
MythUIButtonTree::handleSelect
void handleSelect(MythUIButtonListItem *item)
Handle a list item receiving focus.
Definition: mythuibuttontree.cpp:511
MythUIType::TakingFocus
void TakingFocus()
MythUIType::GetArea
virtual MythRect GetArea(void) const
If the object has a minimum area defined, return it, other wise return the default area.
Definition: mythuitype.cpp:870
MythUIButtonTree::MythUIButtonTree
MythUIButtonTree(MythUIType *parent, const QString &name)
Definition: mythuibuttontree.cpp:16
MythUIButtonTree::handleClick
void handleClick(MythUIButtonListItem *item)
Handle a list item being clicked.
Definition: mythuibuttontree.cpp:538
MythGenericTree::getChildAt
MythGenericTree * getChildAt(uint reference) const
Definition: mythgenerictree.cpp:283
MythUIButtonTree::rootChanged
void rootChanged(MythGenericTree *node)
MythGenericTree::getSelectedChild
MythGenericTree * getSelectedChild(bool onlyVisible=false) const
Definition: mythgenerictree.cpp:312
MythUIButtonListItem
Definition: mythuibuttonlist.h:28
MythUIButtonTree::itemClicked
void itemClicked(MythUIButtonListItem *item)
MythUIButtonList::IsEmpty
bool IsEmpty() const
Definition: mythuibuttonlist.cpp:1671
MythUIButtonTree::SwitchList
void SwitchList(bool right)
Move from list, or one level of the tree, to another.
Definition: mythuibuttontree.cpp:461
mythlogging.h
MythUIButtonList::itemClicked
void itemClicked(MythUIButtonListItem *item)
MythUIButtonList::Deselect
void Deselect()
Definition: mythuibuttonlist.cpp:84
MythUIType::GetXMLLocation
QString GetXMLLocation(void) const
Definition: mythuitype.h:158
MythUIButtonTree::m_activeList
MythUIButtonList * m_activeList
Definition: mythuibuttontree.h:77
MythUIButtonList::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: mythuibuttonlist.cpp:2490
MythGenericTree::getRouteByString
QStringList getRouteByString(void)
Definition: mythgenerictree.cpp:228
MythGenericTree::IsVisible
bool IsVisible() const
Definition: mythgenerictree.h:100
MythUIButtonTree::SetActive
void SetActive(bool active)
Set the widget active/inactive.
Definition: mythuibuttontree.cpp:436
XMLParseBase::getFirstText
static QString getFirstText(QDomElement &element)
Definition: xmlparsebase.cpp:53
MythUIButtonTree::m_activeListID
uint m_activeListID
Definition: mythuibuttontree.h:78
MythUIButtonTree::ParseElement
bool ParseElement(const QString &filename, QDomElement &element, bool showWarnings) override
Parse the xml definition of this widget setting the state of the object accordingly.
Definition: mythuibuttontree.cpp:650
MythUIButtonTree::Init
void Init(void)
Initialise the tree having loaded the formatting options from the theme.
Definition: mythuibuttontree.cpp:29
MythUIType::m_parent
MythUIType * m_parent
Definition: mythuitype.h:271
MythUIButtonTree::m_currentNode
MythGenericTree * m_currentNode
Definition: mythuibuttontree.h:80
filename
QString filename
Definition: mythplugins/mytharchive/mytharchivehelper/main.cpp:637
MythGenericTree::CreateListButton
virtual MythUIButtonListItem * CreateListButton(MythUIButtonList *list)
Definition: mythgenerictree.cpp:502
MythUIButtonTree
A tree widget for displaying and navigating a MythGenericTree()
Definition: mythuibuttontree.h:17
MythUIButtonTree::m_listSpacing
uint m_listSpacing
Definition: mythuibuttontree.h:81
MythGestureEvent::Click
@ Click
Definition: mythgesture.h:77
MythUIType::CopyFrom
virtual void CopyFrom(MythUIType *base)
Copy this widgets state from another.
Definition: mythuitype.cpp:1151
MythUIButtonTree::SetTreeState
void SetTreeState(bool refreshAll=false)
Update the widget following a change.
Definition: mythuibuttontree.cpp:71
MythUIButtonListItem::GetData
QVariant GetData()
Definition: mythuibuttonlist.cpp:3580
uint
unsigned int uint
Definition: compat.h:140
MythUIButtonTree::m_depthOffset
int m_depthOffset
Definition: mythuibuttontree.h:73
MythUIButtonTree::SetNodeByString
bool SetNodeByString(QStringList route)
Using a path based on the node string, set the currently selected node.
Definition: mythuibuttontree.cpp:279
MythUIButtonList::itemVisible
void itemVisible(MythUIButtonListItem *item)
mythgesture.h
A C++ ripoff of the stroke library for MythTV.
MythGenericTree::getAllChildren
QList< MythGenericTree * > * getAllChildren() const
Definition: mythgenerictree.cpp:278
MythUIType::Reset
virtual void Reset(void)
Reset the widget to it's original state, should not reset changes made by the theme.
Definition: mythuitype.cpp:70
MythGenericTree::findNode
MythGenericTree * findNode(QList< int > route_of_branches)
Definition: mythgenerictree.cpp:158
MythUIType
The base class on which all widgets and screens are based.
Definition: mythuitype.h:66
MythUIButtonTree::UpdateList
bool UpdateList(MythUIButtonList *list, MythGenericTree *node) const
Update a list with children of the tree node.
Definition: mythuibuttontree.cpp:149
MythUIButtonTree::m_active
bool m_active
Definition: mythuibuttontree.h:68
MythUIButtonTree::Reset
void Reset(void) override
Reset the widget to it's original state, should not reset changes made by the theme.
Definition: mythuibuttontree.cpp:234
MythUIButtonTree::CopyFrom
void CopyFrom(MythUIType *base) override
Copy this widgets state from another.
Definition: mythuibuttontree.cpp:681
MythUIButtonTree::RemoveCurrentItem
void RemoveCurrentItem(bool deleteNode=false)
Remove the currently selected item from the tree.
Definition: mythuibuttontree.cpp:426
MythRect::topLeft
MythPoint topLeft(void) const
Definition: mythrect.cpp:288
MythUIButtonTree::handleVisible
void handleVisible(MythUIButtonListItem *item)
Handle a list item becoming visible.
Definition: mythuibuttontree.cpp:567
MythUIButtonTree::m_visibleLists
uint m_visibleLists
Definition: mythuibuttontree.h:71
MythGenericTree
Definition: mythgenerictree.h:21
MythUIButtonTree::m_currentDepth
uint m_currentDepth
Definition: mythuibuttontree.h:72
MythUIType::GetChildAt
MythUIType * GetChildAt(const QPoint &p, bool recursive=true, bool focusable=true) const
Return the first MythUIType at the given coordinates.
Definition: mythuitype.cpp:222
MythUIType::SetVisible
virtual void SetVisible(bool visible)
Definition: mythuitype.cpp:1086
MythUIButtonList::Reset
void Reset() override
Reset the widget to it's original state, should not reset changes made by the theme.
Definition: mythuibuttonlist.cpp:114
GetMythMainWindow
MythMainWindow * GetMythMainWindow(void)
Definition: mythmainwindow.cpp:105
MythUIButtonList::SetItemCurrent
void SetItemCurrent(MythUIButtonListItem *item)
Definition: mythuibuttonlist.cpp:1557
MythUIButtonTree::DoSetCurrentNode
bool DoSetCurrentNode(MythGenericTree *node)
Definition: mythuibuttontree.cpp:363
MythGenericTree::getRoute
QList< MythGenericTree * > getRoute(void)
Definition: mythgenerictree.cpp:242
build_compdb.action
action
Definition: build_compdb.py:9
MythUIButtonTree::ShowSearchDialog
void ShowSearchDialog(void)
Definition: mythuibuttontree.cpp:357
MythGestureEvent
A custom event that represents a mouse gesture.
Definition: mythgesture.h:40
MythUIButtonList::LayoutGrid
@ LayoutGrid
Definition: mythuibuttonlist.h:159
MythUIButtonTree::m_oldDepth
uint m_oldDepth
Definition: mythuibuttontree.h:74
MythUIType::NormX
static int NormX(int width)
Definition: mythuitype.cpp:1138
MythUIButtonList::ShowSearchDialog
void ShowSearchDialog(void)
Definition: mythuibuttonlist.cpp:3096
MythUIType::LosingFocus
void LosingFocus()
MythUIType::ParseElement
virtual bool ParseElement(const QString &filename, QDomElement &element, bool showWarnings)
Parse the xml definition of this widget setting the state of the object accordingly.
Definition: mythuitype.cpp:1217
MythUIButtonList::Select
void Select()
Definition: mythuibuttonlist.cpp:74
MythUIButtonList
List widget, displays list items in a variety of themeable arrangements and can trigger signals when ...
Definition: mythuibuttonlist.h:144
mythmainwindow.h
MythUIButtonTree::m_rootNode
MythGenericTree * m_rootNode
Definition: mythuibuttontree.h:79
MythGenericTree::becomeSelectedChild
void becomeSelectedChild(void)
Definition: mythgenerictree.cpp:326
MythUIButtonTree::itemVisible
void itemVisible(MythUIButtonListItem *item)
MythUIButtonTree::nodeChanged
void nodeChanged(MythGenericTree *node)
MythUIButtonList::SetActive
void SetActive(bool active)
Definition: mythuibuttonlist.cpp:100