omni::ui::Input Class Reference

Input List widget. More...

#include <Input.h>

Inheritance diagram for omni::ui::Input:

Collaboration diagram for omni::ui::Input:

Public Slots
void	addInput (QAction *)
void	removeSelection ()
	Removes all selected inputs. More...
void	clear ()
	Removes all inputs. More...
void	changeSelection (QModelIndex)
	Select input at model index. More...

Signals
void	inputChanged ()
void	inputRemoved ()
void	dataModelChanged ()
void	inputIndexChanged ()

Public Member Functions
	Input (QWidget *=nullptr)
	~Input ()
Public Member Functions inherited from omni::ui::DockWidget
	DockWidget (QWidget *=nullptr)
template<typename UI >
	DockWidget (UI &_ui, QWidget *_parent=nullptr)
virtual	~DockWidget ()
Public Member Functions inherited from omni::ui::mixin::DataModel< DATAMODEL, SHARED >
	DataModel ()
void	setDataModel (pointer_type _dataModel)
	Set new data model. More...
pointer_type	dataModel ()
	Return pointer to data model. More...
const pointer_type	dataModel () const
	Return pointer to data model (const version) More...
virtual void	updateFrontend ()
	Push data to frontend widgets and all child widgets. More...
virtual void	updateDataModel ()
	Update the data model interface. More...

Private Member Functions
void	dataToFrontend ()
	Update sliders from given blend mask. More...
bool	frontendToData ()
	Assign slider values to blend mask. More...
void	setupInputMenu (QMenu *)
void	inputUpdatedEmitter ()
void	selectInputId (QString const &)
void	prepareModel ()
	Setup the item model with columns etc. More...
bool	showSettingsDialog (input::Interface *)
QString	itemId (int _row) const
void	addItem (QString const &_id, input::Interface *)
	Add an item to input list widget. More...
void	parameterWidgetSetupOptions (QWidget *_paramWidget) const
	Additional options. Is called during setup process. More...
void	showParameterWidget ()
Private Member Functions inherited from omni::ui::mixin::ParameterWidget<>
void	removeParameterWidget (PARENT_WIDGET *_widget)
	Remove parameter widget from given widget. More...
bool	setupParameterWidget (PARENT_WIDGET *_widget, INTERFACE *_interface)
	Setup widget for interface and place it onto widget. More...
widget_type *	parameterWidget ()
	Return pointer to parameterWidget. More...

Private Attributes
std::unique_ptr< Ui::Input >	ui_
std::unique_ptr < QStandardItemModel >	model_

Additional Inherited Members
Public Types inherited from omni::ui::mixin::DataModel< DATAMODEL, SHARED >
typedef DATAMODEL	data_model_type
	Data type. More...
typedef DataModel < data_model_type, SHARED >	type
	This type. More...
typedef detail::PointerType < data_model_type, SHARED >	pointer_type_handler
	Pointer type handler. More...
typedef pointer_type_handler::type	pointer_type
	Derived pointer type. More...
Protected Member Functions inherited from omni::ui::DockWidget
template<typename UI >
void	setup (UI &_ui)
	Setup ui form UI parameter is smart pointer (e.g. unique_ptr) to UI form. More...
Protected Member Functions inherited from omni::ui::mixin::Locked
template<typename F >
void	locked (F f)
	Lock widget and execute given functor. More...
bool	isLocked () const
	Return true if widget is locked. More...
Private Types inherited from omni::ui::mixin::ParameterWidget<>
typedef QWidget	widget_type

Detailed Description

Input List widget.

Constructor & Destructor Documentation

omni::ui::Input::Input

(

QWidget *

_parent = nullptr

)

                                 :
        DockWidget(_parent)
    {
        this->setup(ui_);

      // Make popup menu for adding inputs
      {
        QMenu* _menu = new QMenu();
        setupInputMenu(_menu);
        ui_->btnAddInput->setMenu(_menu);
        connect(_menu,SIGNAL(triggered(QAction*)),this,SLOT(addInput(QAction*)));
      }

      connect(ui_->inputList,SIGNAL(clicked(QModelIndex)),this,SLOT(changeSelection(QModelIndex)));
      connect(ui_->inputList,SIGNAL(activated(QModelIndex)),this,SLOT(changeSelection(QModelIndex)));
      connect(ui_->btnRemoveInput,SIGNAL(clicked()),this,SLOT(removeSelection()));

      prepareModel();
    }

omni::ui::Input::~Input

(

)

    {
    }

Member Function Documentation

void omni::ui::Input::addInput ( QAction *  _action )

slot

    {
      if (!dataModel()) return;

      auto _idInput = dataModel()->inputs().addInput(_action->text());
      auto& _id = _idInput.first;
      auto& _input = _idInput.second;

      if (!_input) return;

      if (_input->canAdd())
      {
        addItem(_id,_input);
        selectInputId(_id);
        showParameterWidget();
        emit inputIndexChanged();
      } else
      {
        dataModel()->inputs().removeInput(_id);
      }
    }

void omni::ui::Input::addItem ( QString const &  _id, input::Interface *  _input  )

private

Add an item to input list widget.

    {
      if (!_input) return;

      QList<QStandardItem*> _row;
      auto _addItem = [&](QString const& _id) {
          QStandardItem* _item = new QStandardItem(_id);
          _item->setEditable(false);
          _row << _item;
      };

      _addItem(_id);
      _addItem(_input->getTypeId().str());
      _addItem(_input->infoText());

      model_->invisibleRootItem()->appendRow(_row);
      ui_->inputList->resizeColumnToContents(0);
      ui_->inputList->resizeColumnToContents(1);
      ui_->inputList->resizeColumnToContents(2);

      _input->setUpdateCallback(std::bind(&Input::inputUpdatedEmitter,this));
    }

void omni::ui::Input::changeSelection ( QModelIndex  _index )

slot

Select input at model index.

    {
      if (!dataModel() || this->isLocked()) return;
      int _row = _index.row();

      if (_row < 1 || _row > dataModel()->inputs().numberOfChildren())
      {
          _row = -1;
      }

      if (itemId(_row) == dataModel()->inputs().currentId()) return;

      selectInputId(itemId(_row));
      showParameterWidget();
      emit inputIndexChanged();
    }

void omni::ui::Input::clear ( )

slot

Removes all inputs.

    {
      if (!dataModel()) return;
      dataModel()->inputs().clear();
      prepareModel();
      showParameterWidget();
      emit inputIndexChanged();
    }

void omni::ui::Input::dataModelChanged ( )

signal

void omni::ui::Input::dataToFrontend ( )

privatevirtual

Update sliders from given blend mask.

Implements omni::ui::mixin::DataModel< DATAMODEL, SHARED >.

    {
      prepareModel();
      for (auto& _input : dataModel()->inputs())
      {
        addItem(_input.first,_input.second.get());
      }
      selectInputId(dataModel()->inputs().currentId());
      showParameterWidget();
      emit inputIndexChanged();
    }

bool omni::ui::Input::frontendToData ( )

inlineprivatevirtual

Assign slider values to blend mask.

Implements omni::ui::mixin::DataModel< DATAMODEL, SHARED >.

                                     {
          return false;
        }

void omni::ui::Input::inputChanged ( )

signal

void omni::ui::Input::inputIndexChanged ( )

signal

void omni::ui::Input::inputRemoved ( )

signal

void omni::ui::Input::inputUpdatedEmitter ( )

private

                                    {
      emit inputChanged();
    }

QString omni::ui::Input::itemId ( int  _row ) const

private

                                        {
      auto* _item = model_->item(_row);
      if (!_item) return QString();
      return _item->text();
    }

void omni::ui::Input::parameterWidgetSetupOptions ( QWidget *  _paramWidget ) const

privatevirtual

Additional options. Is called during setup process.

Reimplemented from omni::ui::mixin::ParameterWidget<>.

                                                                       {
            QSizePolicy _sizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
            _sizePolicy.setVerticalStretch(1);
            _paramWidget->setSizePolicy(_sizePolicy);
            _paramWidget->setMinimumSize(QSize(0,128));
    }

void omni::ui::Input::prepareModel ( )

private

Setup the item model with columns etc.

    {
      this->removeParameterWidget(widget());

      model_.reset(new QStandardItemModel());
      model_->clear();
      model_->setColumnCount(3);
      model_->setHeaderData(0,Qt::Horizontal,"Id");
      model_->setHeaderData(1,Qt::Horizontal,"Input Type");
      model_->setHeaderData(2,Qt::Horizontal,"Info");
      ui_->inputList->setModel(model_.get());

      QList<QStandardItem*> _row;
      QStandardItem* _hash = new QStandardItem("#");
      _hash->setEditable(false);
      QStandardItem* _item = new QStandardItem("(no input)");
      _item->setEditable(false);
      _row << _hash;
      _row << _item;
      model_->invisibleRootItem()->appendRow(_row);
      ui_->inputList->resizeColumnToContents(0);
      ui_->inputList->resizeColumnToContents(1);
      ui_->inputList->resizeColumnToContents(2);
    }

void omni::ui::Input::removeSelection ( )

slot

Removes all selected inputs.

    {
      if (dataModel()->inputs().empty()) return;

      int _row = ui_->inputList->currentIndex().row();

      if (_row < 1 || _row > dataModel()->inputs().numberOfChildren()) return;

      auto* _item = model_->item(_row);
      if (!_item) return;

      dataModel()->inputs().removeInput(_item->text());
      model_->removeRows(_row,1);

      this->removeParameterWidget(widget());
      changeSelection(model_->index(_row,0));
      emit inputRemoved();
    }

void omni::ui::Input::selectInputId ( QString const &  _id )

private

                                                {
        dataModel()->inputs().setCurrentId(_id);
        auto* _current = dataModel()->inputs().current();
        if (_current) {
          for (auto& _input : dataModel()->inputs()) {
            input::Controller::instance()->deactivate(_input.second.get());
          }
          input::Controller::instance()->activate(_current);
          _current->update();
          emit inputChanged();
        }
    }

void omni::ui::Input::setupInputMenu ( QMenu *  _menu )

private

Find all categories

No categories exist

                                           {
      std::map<QString,QMenu*> _categoryMenus;
      /// Find all categories
      for (auto& _idInputClass : omni::input::Factory::classes()) {
        auto* _input = omni::input::Factory::create(_idInputClass.first,nullptr);
        if (!_input) continue;

        auto _id = _idInputClass.first.str();

        auto _categories = _input->categories();
        if (_categories.empty()) {
            QAction* _menuItem = new QAction(QIcon(QString(":/input/")+ _id + QString(".png")),_id,_menu);
            _menu->addAction(_menuItem);
        }

        for (auto& _category : _categories) {
          if (!_categoryMenus.count(_category)) {
            _categoryMenus[_category] = new QMenu(_category);
          }
          auto* _catMenu = _categoryMenus[_category];
          QAction* _menuItem = new QAction(QIcon(QString(":/input/")+ _id + QString(".png")),_id,_menu);
          _catMenu->addAction(_menuItem);
        }
      }

      /// No categories exist
      for (auto& _categoryMenu : _categoryMenus) {
        _menu->addMenu(_categoryMenu.second);
      }
    }

void omni::ui::Input::showParameterWidget ( )

private

                                    {

      this->setupParameterWidget(widget(),dataModel()->inputs().current());
      if (this->parameterWidget()) {
          connect(this->parameterWidget(),SIGNAL(inputChanged()),this,SIGNAL(inputChanged()));
          connect(this,SIGNAL(inputChanged()),this->parameterWidget(),SLOT(triggerUpdate()));
      }
    }

bool omni::ui::Input::showSettingsDialog ( input::Interface *  )

private

Field Documentation

std::unique_ptr<QStandardItemModel> omni::ui::Input::model_

private

std::unique_ptr<Ui::Input> omni::ui::Input::ui_

private

---

The documentation for this class was generated from the following files:

• src/app/Input.h
• src/app/Input.cpp