Control.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */
 
#pragma once
 
#include "Alternative.h"
#include "ListItem.h"
#include "Tuple.h"
#include "guilib/GUIControl.h"
#include "guilib/GUIFont.h"
#include "input/Key.h"
#include "swighelper.h"
#include "utils/Color.h"
 
#include <vector>
 
 
// hardcoded offsets for button controls (and controls that use button controls)
// ideally they should be dynamically read in as with all the other properties.
#define CONTROL_TEXT_OFFSET_X 10
#define CONTROL_TEXT_OFFSET_Y 2
 
namespace XBMCAddon
{
  namespace xbmcgui
  {
 
    //
    class Control : public AddonClass
    {
    protected:
      Control() = default;
 
    public:
      ~Control() override;
 
#ifndef SWIG
      virtual CGUIControl* Create();
#endif
 
      // currently we only accept messages from a button or controllist with a select action
      virtual bool canAcceptMessages(int actionId) { return false; }
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getId()
#else
      virtual int getId() { return iControlId; }
#endif
 
      inline bool operator==(const Control& other) const { return iControlId == other.iControlId; }
      inline bool operator>(const Control& other) const { return iControlId > other.iControlId; }
      inline bool operator<(const Control& other) const { return iControlId < other.iControlId; }
 
      // hack this because it returns a tuple
#ifdef DOXYGEN_SHOULD_USE_THIS
      getPosition();
#else
      virtual std::vector<int> getPosition();
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getX();
#else
      int getX() { return dwPosX; }
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getY();
#else
      int getY() { return dwPosY; }
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getHeight();
#else
      virtual int getHeight() { return dwHeight; }
#endif
 
      // getWidth() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getWidth();
#else
      virtual int getWidth() { return dwWidth; }
#endif
 
      // setEnabled() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setEnabled(...);
#else
      virtual void setEnabled(bool enabled);
#endif
 
      // setVisible() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setVisible(...);
#else
      virtual void setVisible(bool visible);
#endif
 
      // isVisible() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      isVisible(...);
#else
      virtual bool isVisible();
#endif
 
      // setVisibleCondition() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setVisibleCondition(...);
#else
      virtual void setVisibleCondition(const char* visible, bool allowHiddenFocus = false);
#endif
 
      // setEnableCondition() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setEnableCondition(...);
#else
      virtual void setEnableCondition(const char* enable);
#endif
 
      // setAnimations() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setAnimations(...);
#else
      virtual void setAnimations(const std::vector< Tuple<String,String> >& eventAttr);
#endif
 
      // setPosition() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setPosition(...);
#else
      virtual void setPosition(long x, long y);
#endif
 
      // setWidth() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setWidth(...);
#else
      virtual void setWidth(long width);
#endif
 
      // setHeight() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setHeight(...);
#else
      virtual void setHeight(long height);
#endif
 
      // setNavigation() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      //
      setNavigation(...);
#else
      virtual void setNavigation(const Control* up, const Control* down,
                                 const Control* left, const Control* right);
#endif
 
      // controlUp() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      controlUp(...);
#else
      virtual void controlUp(const Control* up);
#endif
 
      // controlDown() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      controlDown(...);
#else
      virtual void controlDown(const Control* control);
#endif
 
      // controlLeft() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      controlLeft(...);
#else
      virtual void controlLeft(const Control* control);
#endif
 
      // controlRight() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      controlRight(...);
#else
      virtual void controlRight(const Control* control);
#endif
 
#ifndef SWIG
      int iControlId = 0;
      int iParentId = 0;
      int dwPosX = 0;
      int dwPosY = 0;
      int dwWidth = 0;
      int dwHeight = 0;
      int iControlUp = 0;
      int iControlDown = 0;
      int iControlLeft = 0;
      int iControlRight = 0;
      std::string m_label{};
      bool m_visible{true};
      CGUIControl* pGUIControl = nullptr;
#endif
 
    };
 
    class ControlSpin : public Control
    {
    public:
      ~ControlSpin() override;
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setTextures(...);
#else
      virtual void setTextures(const char* up, const char* down,
                               const char* upFocus,
                               const char* downFocus,
                               const char* upDisabled, const char* downDisabled);
#endif
 
#ifndef SWIG
      UTILS::Color color;
      std::string strTextureUp;
      std::string strTextureDown;
      std::string strTextureUpFocus;
      std::string strTextureDownFocus;
      std::string strTextureUpDisabled;
      std::string strTextureDownDisabled;
#endif
 
    private:
      ControlSpin();
 
      friend class Window;
      friend class ControlList;
 
    };
 
    class ControlLabel : public Control
    {
    public:
      ControlLabel(long x, long y, long width, long height, const String& label,
                  const char* font = NULL, const char* textColor = NULL,
                  const char* disabledColor = NULL,
                  long alignment = XBFONT_LEFT,
                  bool hasPath = false, long angle = 0);
 
      ~ControlLabel() override;
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getLabel();
#else
      virtual String getLabel();
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setLabel(...);
#else
      virtual void setLabel(const String& label = emptyString,
                            const char* font = NULL,
                            const char* textColor = NULL,
                            const char* disabledColor = NULL,
                            const char* shadowColor = NULL,
                            const char* focusedColor = NULL,
                            const String& label2 = emptyString);
#endif
 
#ifndef SWIG
      ControlLabel() = default;
 
      std::string strFont;
      std::string strText;
      UTILS::Color textColor;
      UTILS::Color disabledColor;
      uint32_t align;
      bool bHasPath = false;
      int iAngle = 0;
 
      CGUIControl* Create() override;
 
#endif
    };
 
    // ControlEdit class
    class ControlEdit : public Control
    {
    public:
      ControlEdit(long x, long y, long width, long height, const String& label,
                  const char* font = NULL, const char* textColor = NULL,
                  const char* disabledColor = NULL,
                  long _alignment = XBFONT_LEFT, const char* focusTexture = NULL,
                  const char* noFocusTexture = NULL);
 
 
      // setLabel() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setLabel(...);
#else
      virtual void setLabel(const String& label = emptyString,
                            const char* font = NULL,
                            const char* textColor = NULL,
                            const char* disabledColor = NULL,
                            const char* shadowColor = NULL,
                            const char* focusedColor = NULL,
                            const String& label2 = emptyString);
#endif
 
      // getLabel() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getLabel();
#else
      virtual String getLabel();
#endif
 
      // setText() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setText(...);
#else
      virtual void setText(const String& text);
#endif
 
      // getText() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getText();
#else
      virtual String getText();
#endif
 
#ifndef SWIG
      ControlEdit() = default;
 
      std::string strFont;
      std::string strText;
      std::string strTextureFocus;
      std::string strTextureNoFocus;
      UTILS::Color textColor;
      UTILS::Color disabledColor;
      uint32_t align;
 
      CGUIControl* Create() override;
#endif
 
      // setType() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setType(...);
#else
      virtual void setType(int type, const String& heading);
#endif
    };
 
    // ControlList class
    class ControlList : public Control
    {
      void internAddListItem(const AddonClass::Ref<ListItem>& listitem, bool sendMessage);
 
    public:
      ControlList(long x, long y, long width, long height, const char* font = NULL,
                  const char* textColor = NULL, const char* buttonTexture = NULL,
                  const char* buttonFocusTexture = NULL,
                  const char* selectedColor = NULL,
                  long _imageWidth=10, long _imageHeight=10, long _itemTextXOffset = CONTROL_TEXT_OFFSET_X,
                  long _itemTextYOffset = CONTROL_TEXT_OFFSET_Y, long _itemHeight = 27, long _space = 2,
                  long _alignmentY = XBFONT_CENTER_Y);
 
      ~ControlList() override;
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      addItem(...);
#else
      virtual void addItem(const Alternative<String, const XBMCAddon::xbmcgui::ListItem* > & item, bool sendMessage = true);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      addItems(...);
#else
      virtual void addItems(const std::vector<Alternative<String, const XBMCAddon::xbmcgui::ListItem* > > & items);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      selectItem(...);
#else
      virtual void selectItem(long item);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      removeItem(...);
#else
      virtual void removeItem(int index);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      reset();
#else
      virtual void reset();
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getSpinControl();
#else
      virtual Control* getSpinControl();
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getSelectedPosition();
#else
      virtual long getSelectedPosition();
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getSelectedItem();
#else
      virtual XBMCAddon::xbmcgui::ListItem* getSelectedItem();
#endif
 
      // setImageDimensions() method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setImageDimensions(...);
#else
      virtual void setImageDimensions(long imageWidth,long imageHeight);
#endif
 
      // setItemHeight() method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setItemHeight(...);
#else
      virtual void setItemHeight(long height);
#endif
 
      // setSpace() method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setSpace(...);
#else
      virtual void setSpace(int space);
#endif
 
      // setPageControlVisible() method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setPageControlVisible(...);
#else
      virtual void setPageControlVisible(bool visible);
#endif
 
      // size() method
#ifdef DOXYGEN_SHOULD_USE_THIS
      size();
#else
      virtual long size();
#endif
 
      // getItemHeight() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getItemHeight();
#else
      virtual long getItemHeight();
#endif
 
      // getSpace() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getSpace();
#else
      virtual long getSpace();
#endif
 
      // getListItem() method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getListItem(...);
#else
      virtual XBMCAddon::xbmcgui::ListItem* getListItem(int index);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setStaticContent(...);
#else
      virtual void setStaticContent(const ListItemList* items);
#endif
 
#ifndef SWIG
      void sendLabelBind(int tail);
 
      bool canAcceptMessages(int actionId) override
      { return ((actionId == ACTION_SELECT_ITEM) | (actionId == ACTION_MOUSE_LEFT_CLICK)); }
 
      // This is called from AddonWindow.cpp but shouldn't be available
      //  to the scripting languages.
      ControlList() = default;
 
      std::vector<AddonClass::Ref<ListItem> > vecItems;
      std::string strFont;
      AddonClass::Ref<ControlSpin> pControlSpin;
 
      UTILS::Color textColor;
      UTILS::Color selectedColor;
      std::string strTextureButton;
      std::string strTextureButtonFocus;
 
      int imageHeight = 0;
      int imageWidth = 0;
      int itemHeight = 0;
      int space = 0;
 
      int itemTextOffsetX = 0;
      int itemTextOffsetY = 0;
      uint32_t alignmentY;
 
      CGUIControl* Create() override;
#endif
    };
 
    // ControlFadeLabel class
    class ControlFadeLabel : public Control
    {
    public:
      ControlFadeLabel(long x, long y, long width, long height,
                       const char* font = NULL,
                       const char* textColor = NULL,
                       long _alignment = XBFONT_LEFT);
 
      // addLabel() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      addLabel(...);
#else
      virtual void addLabel(const String& label);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setScrolling(...);
#else
      virtual void setScrolling(bool scroll);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      reset();
#else
      virtual void reset();
#endif
 
#ifndef SWIG
      std::string strFont;
      UTILS::Color textColor;
      std::vector<std::string> vecLabels;
      uint32_t align;
 
      CGUIControl* Create() override;
 
      ControlFadeLabel() = default;
#endif
    };
 
    // ControlTextBox class
    class ControlTextBox : public Control
    {
    public:
      ControlTextBox(long x, long y, long width, long height,
                     const char* font = NULL,
                     const char* textColor = NULL);
 
      // SetText() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setText(...);
#else
      virtual void setText(const String& text);
#endif
 
      // getText() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getText();
#else
      virtual String getText();
#endif
 
      // reset() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      reset();
#else
      virtual void reset();
#endif
 
      // scroll() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      scroll(...);
#else
      virtual void scroll(long id);
#endif
 
      // autoScroll() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      autoScroll(...);
#else
      virtual void autoScroll(int delay, int time, int repeat);
#endif
 
#ifndef SWIG
      std::string strFont;
      UTILS::Color textColor;
 
      CGUIControl* Create() override;
 
      ControlTextBox() = default;
#endif
    };
 
    // ControlImage class
    class ControlImage : public Control
    {
    public:
      ControlImage(long x, long y, long width, long height,
                   const char* filename, long aspectRatio = 0,
                   const char* colorDiffuse = NULL);
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setImage(...);
#else
      virtual void setImage(const char* imageFilename, const bool useCache = true);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setColorDiffuse(...);
#else
      virtual void setColorDiffuse(const char* hexString);
#endif
 
#ifndef SWIG
      ControlImage() = default;
 
      std::string strFileName;
      int aspectRatio = 0;
      UTILS::Color colorDiffuse;
 
      CGUIControl* Create() override;
#endif
    };
 
    // ControlImage class
    class ControlProgress : public Control
    {
    public:
      ControlProgress(long x, long y, long width, long height,
                      const char* texturebg = NULL,
                      const char* textureleft = NULL,
                      const char* texturemid = NULL,
                      const char* textureright = NULL,
                      const char* textureoverlay = NULL);
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setPercent(...);
#else
      virtual void setPercent(float pct);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getPercent();
#else
      virtual float getPercent();
#endif
 
#ifndef SWIG
      std::string strTextureLeft;
      std::string strTextureMid;
      std::string strTextureRight;
      std::string strTextureBg;
      std::string strTextureOverlay;
      int aspectRatio = 0;
      UTILS::Color colorDiffuse;
 
      CGUIControl* Create() override;
      ControlProgress() = default;
#endif
    };
 
    // ControlButton class
    class ControlButton : public Control
    {
    public:
      ControlButton(long x, long y, long width, long height, const String& label,
                    const char* focusTexture = NULL, const char* noFocusTexture = NULL,
                    long textOffsetX = CONTROL_TEXT_OFFSET_X,
                    long textOffsetY = CONTROL_TEXT_OFFSET_Y,
                    long alignment = (XBFONT_LEFT | XBFONT_CENTER_Y),
                    const char* font = NULL, const char* textColor = NULL,
                    const char* disabledColor = NULL, long angle = 0,
                    const char* shadowColor = NULL, const char* focusedColor = NULL);
 
      // setLabel() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setLabel(...);
#else
      virtual void setLabel(const String& label = emptyString,
                            const char* font = NULL,
                            const char* textColor = NULL,
                            const char* disabledColor = NULL,
                            const char* shadowColor = NULL,
                            const char* focusedColor = NULL,
                            const String& label2 = emptyString);
#endif
 
      // setDisabledColor() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setDisabledColor(...);
#else
      virtual void setDisabledColor(const char* color);
#endif
 
      // getLabel() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getLabel();
#else
      virtual String getLabel();
#endif
 
      // getLabel2() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      getLabel2();
#else
      virtual String getLabel2();
#endif
 
#ifndef SWIG
      bool canAcceptMessages(int actionId) override { return true; }
 
      int textOffsetX = 0;
      int textOffsetY = 0;
      UTILS::Color align;
      std::string strFont;
      UTILS::Color textColor;
      UTILS::Color disabledColor;
      int iAngle = 0;
      int shadowColor = 0;
      int focusedColor = 0;
      std::string strText;
      std::string strText2;
      std::string strTextureFocus;
      std::string strTextureNoFocus;
 
      CGUIControl* Create() override;
 
      ControlButton() = default;
#endif
    };
 
    // ControlGroup class
    class ControlGroup : public Control
    {
    public:
      ControlGroup(long x, long y, long width, long height);
 
#ifndef SWIG
      CGUIControl* Create() override;
 
      inline ControlGroup() = default;
#endif
    };
 
    // ControlRadioButton class
    class ControlRadioButton : public Control
    {
    public:
      ControlRadioButton(long x, long y, long width, long height, const String& label,
                         const char* focusOnTexture = NULL, const char* noFocusOnTexture = NULL,
                         const char* focusOffTexture = NULL, const char* noFocusOffTexture = NULL,
                         const char* focusTexture = NULL, const char* noFocusTexture = NULL,
                         long textOffsetX = CONTROL_TEXT_OFFSET_X,
                         long textOffsetY = CONTROL_TEXT_OFFSET_Y,
                         long _alignment = (XBFONT_LEFT | XBFONT_CENTER_Y),
                         const char* font = NULL, const char* textColor = NULL,
                         const char* disabledColor = NULL, long angle = 0,
                         const char* shadowColor = NULL, const char* focusedColor = NULL,
                         const char* disabledOnTexture = NULL, const char* disabledOffTexture = NULL);
 
      // setSelected() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setSelected(...);
#else
      virtual void setSelected(bool selected);
#endif
 
      // isSelected() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      isSelected();
#else
      virtual bool isSelected();
#endif
 
      // setLabel() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setLabel(...);
#else
      virtual void setLabel(const String& label = emptyString,
                            const char* font = NULL,
                            const char* textColor = NULL,
                            const char* disabledColor = NULL,
                            const char* shadowColor = NULL,
                            const char* focusedColor = NULL,
                            const String& label2 = emptyString);
#endif
 
      // setRadioDimension() Method
#ifdef DOXYGEN_SHOULD_USE_THIS
      setRadioDimension(...);
#else
      virtual void setRadioDimension(long x, long y, long width, long height);
#endif
 
#ifndef SWIG
      bool canAcceptMessages(int actionId) override { return true; }
 
      std::string strFont;
      std::string strText;
      std::string strTextureFocus;
      std::string strTextureNoFocus;
      std::string strTextureRadioOnFocus;
      std::string strTextureRadioOnNoFocus;
      std::string strTextureRadioOffFocus;
      std::string strTextureRadioOffNoFocus;
      std::string strTextureRadioOnDisabled;
      std::string strTextureRadioOffDisabled;
      UTILS::Color textColor;
      UTILS::Color disabledColor;
      int textOffsetX = 0;
      int textOffsetY = 0;
     uint32_t align;
      int iAngle = 0;
      UTILS::Color shadowColor;
      UTILS::Color focusedColor;
 
      CGUIControl* Create() override;
 
      ControlRadioButton() = default;
#endif
    };
 
    class ControlSlider : public Control
    {
    public:
      ControlSlider(long x, long y, long width, long height,
                    const char* textureback = NULL,
                    const char* texture = NULL,
                    const char* texturefocus = NULL, int orientation = 1);
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getPercent();
#else
      virtual float getPercent();
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setPercent(...);
#else
      virtual void setPercent(float pct);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getInt();
#else
      virtual int getInt();
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setInt(...);
#else
      virtual void setInt(int value, int min, int delta, int max);
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      getFloat();
#else
      virtual float getFloat();
#endif
 
#ifdef DOXYGEN_SHOULD_USE_THIS
      setFloat(...);
#else
      virtual void setFloat(float value, float min, float delta, float max);
#endif
 
#ifndef SWIG
      std::string strTextureBack;
      std::string strTexture;
      std::string strTextureFoc;
      int iOrientation;
 
      CGUIControl* Create() override;
 
      inline ControlSlider() = default;
#endif
    };
  }
}