omni::ui::proj::TuningList Class Reference

#include <TuningList.h>

Inheritance diagram for omni::ui::proj::TuningList:

Collaboration diagram for omni::ui::proj::TuningList:

Public Slots
void	sessionModeChange ()
	Change current mode for all tuning widgets. More...
void	addTuning ()
	Add a new tuning and tuning widget, with automatically detected settings. More...
void	addTuning (QString const &_projSetupId)
	Add tuning with specific projector setup. More...
void	removeTuning (int _index)
	Remove tuning. More...
void	setCurrentTuning ()
	Set current tuning from currently selected widget. More...
void	setTuningIndex (int)
	Set current tuning index manually (currentIndexChanged signal is emitted) More...
void	clear ()
	Remove all tunings from session and all associated widgets. More...
void	updateViews ()
	Updates/Repaints GL Views of all tunings widgets. More...
void	updateSceneSize (bool _rescaleValues)
	Adjust sliders to scene scale. More...
void	updateUnits ()
	Set unit of sliders. More...
void	disableAllTunings ()
	Disable all tunings and fullscreen. More...
void	enableAllTunings ()
	Enable all tunings and fullscreen. More...
void	enableSelectedTuningOnly ()
	Enable selected tuning and show only this in fullscreen. More...

Signals
void	currentIndexChanged (int)
	Signal which is emitted when the current tuning has changed. More...
void	dataModelChanged ()
	Signal which is emitted when parameters of one tuning have changed. More...
void	tuningAdded ()
	Signal is emitted when a tuning was added. More...
void	tuningRemoved ()
	Signal is emitted when a tuning was removed. More...
void	tuningChanged ()
	Emitted when a single tuning has changed. More...

Public Member Functions
	TuningList (QWidget *=nullptr)
	~TuningList ()
std::set< TuningGLView * >	getViews (int _index) const
	Return fullscreen and preview widget from index. More...
Tuning *	widget (int _index)
	Return tuning widget at index, nullptr if index is not valid. More...
Tuning const *	widget (int _index) const
	Return tuning widget at index, nullptr if index is not valid (const) More...
Tuning *	widgetFromTuning (omni::proj::Tuning *)
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...

Protected Member Functions
void	resizeEvent (QResizeEvent *)
void	keyPressEvent (QKeyEvent *)
bool	eventFilter (QObject *obj, QEvent *event)
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 Member Functions
void	dataToFrontend ()
	Update sliders from current session. More...
bool	frontendToData ()
	Assign slider values to current session. More...
void	addTuning (omni::proj::Tuning *_tuning)
	Add widget from existing tuning. More...
void	removeWidgets ()
	Removes all widgets in the scroll area Unlike clear() it does not remove tunings from session. More...
QColor	getTuningColor ()
	Get most differing color for a new tuning. More...

Private Attributes
QWidget *	contents_
QLayout *	layout_
std::vector< QUniquePtr< Tuning > >	widgets_

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...

Constructor & Destructor Documentation

omni::ui::proj::TuningList::TuningList

(

QWidget *

_parent = nullptr

)

                                                   :
                QScrollArea(_parent),
                layout_(new QVBoxLayout())
            {
                // Set contents and layout, so tuning widgets can be placed
                // vertically using
                // QScrollArea funcionality
                layout_->setSizeConstraint(QLayout::SetMinAndMaxSize);
                layout_->setSpacing(3);
                layout_->setContentsMargins(0, 0, 16, 0);

                this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);

                contents_ = new QWidget(this);
                contents_->setLayout(layout_);
                this->setWidget(contents_);
                contents_->show();

                this->setWidgetResizable(true);
            }

omni::ui::proj::TuningList::~TuningList

(

)

            {
            }

Member Function Documentation

void omni::ui::proj::TuningList::addTuning ( )

slot

Add a new tuning and tuning widget, with automatically detected settings.

            {

                QString _setupId = "PeripheralSetup";

                if (!dataModel()->tunings().empty())
                {
                    // Set setup id from last tuning
                    auto *_setup =
                        dataModel()->tunings()[dataModel()->tunings().size() -
                                               1]->projector().setup();

                    if (_setup) _setupId = _setup->getTypeId();
                }
                addTuning(_setupId);
            }

void omni::ui::proj::TuningList::addTuning ( QString const &  _projSetupId )

slot

Add tuning with specific projector setup.

            {
                if (dataModel()->tunings().size() >= OMNI_MAX_NUMBER_TUNINGS)
                {
                    QMessageBox::information(this, "Information",
                                             QString(
                                                 "You have reached the maximum of %1 projectors.").arg(
                                                 OMNI_MAX_NUMBER_TUNINGS));
                    return;
                }
                
                auto *_tuning = dataModel()->tunings().add(false);

                if (!_tuning) return;

                _tuning->setColor(getTuningColor());
                _tuning->projector().setup(_projSetupId,dataModel()->scene().size());
                addTuning(_tuning);

                // Select this tuning index
                setTuningIndex(dataModel()->tunings().size() - 1);
            }

void omni::ui::proj::TuningList::addTuning ( omni::proj::Tuning *  _tuning )

private

Add widget from existing tuning.

            {

                int _index = 0;

                for (auto& _sessionTuning : dataModel()->tunings())
                {
                    if (_sessionTuning.get() == _tuning)
                    {
                        break;
                    }
                    ++_index;
                }

                widgets_.emplace_back(new ui::proj::Tuning(_index, dataModel(),
                                                           this));
                auto _widget = widgets_.back().get();
                contents_->layout()->addWidget(_widget);

                _widget->connect(_widget, SIGNAL(selected(
                                                     int)),    this,
                                 SLOT(setTuningIndex(int)));
                _widget->connect(_widget, SIGNAL(closed(
                                                     int)),    this,
                                 SLOT(removeTuning(int)));
                _widget->connect(_widget, SIGNAL(
                                     projectorSetupChanged()), this,
                                 SIGNAL(tuningChanged()));
                _widget->connect(_widget, SIGNAL(
                                     dataModelChanged()), this,
                                 SIGNAL(tuningChanged()));
                _widget->sessionModeChange();

                emit tuningAdded();
            }

void omni::ui::proj::TuningList::clear ( )

slot

Remove all tunings from session and all associated widgets.

            {
                removeWidgets();
                if (dataModel()) {
                  dataModel()->tunings().clear();
                }
            }

void omni::ui::proj::TuningList::currentIndexChanged ( int  )

signal

Signal which is emitted when the current tuning has changed.

void omni::ui::proj::TuningList::dataModelChanged ( )

signal

Signal which is emitted when parameters of one tuning have changed.

void omni::ui::proj::TuningList::dataToFrontend ( )

privatevirtual

Update sliders from current session.

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

                                            {
                removeWidgets();

                for (auto& _tuning : dataModel()->tunings()) addTuning(
                        _tuning.get());

                sessionModeChange();
            }

void omni::ui::proj::TuningList::disableAllTunings ( )

slot

Disable all tunings and fullscreen.

                                               {
              for (auto& _widget : widgets_) {
                _widget->fullscreenToggle(false);
              }
            }

void omni::ui::proj::TuningList::enableAllTunings ( )

slot

Enable all tunings and fullscreen.

                                              {
              for (auto& _widget : widgets_) {
                _widget->fullscreenToggle(true);
              }
            }

void omni::ui::proj::TuningList::enableSelectedTuningOnly ( )

slot

Enable selected tuning and show only this in fullscreen.

                                                      {
              for (auto& _widget : widgets_) {
                _widget->fullscreenToggle(_widget->index() == dataModel()->tunings().currentIndex());
              }
            }

bool omni::ui::proj::TuningList::eventFilter ( QObject *  obj, QEvent *  event  )

protected

                                                                    {
                if (event->type() == QEvent::KeyPress) {
                    auto *keyEvent = static_cast<QKeyEvent *>(event);
                    keyPressEvent(keyEvent);
                }
                return QWidget::eventFilter(obj, event);
            }

bool omni::ui::proj::TuningList::frontendToData ( )

inlineprivatevirtual

Assign slider values to current session.

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

                                       {
              return false;
          }

QColor omni::ui::proj::TuningList::getTuningColor ( )

private

Get most differing color for a new tuning.

Find first color in spectrum that is not already used

Compare R,G,B channels for both colors, alpha can be

Return the first color which is not equal to an existing

            {
                // Generate standard colors, for tuning
                static std::vector<QColor> _colors;

                if (_colors.empty())
                {
                    _colors.reserve(OMNI_MAX_NUMBER_TUNINGS);

                    int _hue     = 0;
                    int _hueDiff = 120;

                    for (int i = 0; i < OMNI_MAX_NUMBER_TUNINGS; ++i)
                    {
                        int _saturation = float(OMNI_MAX_NUMBER_TUNINGS / 2 - i / 2) /
                                          OMNI_MAX_NUMBER_TUNINGS * 2.0 * 255.0;
                        _colors.push_back(QColor::fromHsv(_hue, _saturation,
                                                          255));

                        _hue += 120;

                        if (_hue >= 360)
                        {
                            _hueDiff /= 2;
                            _hue     += _hueDiff;
                            _hue     %= 360;
                        }
                    }
                }
                int _numTunings = dataModel()->tunings().size();

                if (dataModel()->tunings().size() > OMNI_MAX_NUMBER_TUNINGS) return QColor("#000000");

                /// Find first color in spectrum that is not already used
                for (int j = 0; j < OMNI_MAX_NUMBER_TUNINGS; ++j)
                {
                    auto _color       = _colors[j];
                    bool _colorsEqual = false;

                    for (int i = 0; i < _numTunings; ++i)
                    {
                        auto _tuningColor = dataModel()->tunings()[i]->color();

                        /// Compare R,G,B channels for both colors, alpha can be
                        // ignored
                        _colorsEqual |= _color.red() == _tuningColor.red() &&
                                        _color.green() == _tuningColor.green() &&
                                        _color.blue() == _tuningColor.blue();
                    }

                    /// Return the first color which is not equal to an existing
                    if (!_colorsEqual) return _color;
                }

                return _colors[_numTunings - 1];
            }

std::set< TuningGLView * > omni::ui::proj::TuningList::getViews

(

int

_index

)

const

Return fullscreen and preview widget from index.

            {
                std::set<TuningGLView *> _views;

                if ((_index < 0) || (_index >= widgets_.size())) return _views;

                auto *_widget = widgets_[_index].get();
                _views.insert(_widget->fullscreenWidget());
                _views.insert(_widget->previewWidget());

                return _views;
            }

void omni::ui::proj::TuningList::keyPressEvent ( QKeyEvent *  _event )

protected

                                                            {
                int   _tuningIndex = dataModel()->tunings().currentIndex();
                auto *_widget      = widget(_tuningIndex);

                if (!_widget) return;

                if (_widget->hasFocus() && !_widget->isSelected()) return;

                if (_event->key() == Qt::Key_Up) {
                    if (!_widget->focusPrev(false) && (_tuningIndex > 0)) {
                        setTuningIndex(_tuningIndex - 1);
                        widget(_tuningIndex - 1)->focusLast();
                    }
                }

                if (_event->key() == Qt::Key_Down) {
                    if (!_widget->focusNext(false) &&
                        (_tuningIndex < dataModel()->tunings().size() - 1)) {
                        setTuningIndex(_tuningIndex + 1);
                        widget(_tuningIndex + 1)->focusFirst();
                    }
                }
            }

void omni::ui::proj::TuningList::removeTuning ( int  _index )

slot

Remove tuning.

            {
                if ((_index < 0) || (_index >= widgets_.size())) return;

                auto& _widget = widgets_[_index];
                contents_->layout()->removeWidget(_widget.get());
                _widget->setParent(nullptr);
                widgets_.erase(widgets_.begin() + _index);

                dataModel()->tunings().remove(_index);

                // Re assign tuning indices to remaining widgets
                for (int i = 0; i < dataModel()->tunings().size(); ++i)
                {
                    dataModel()->tunings()[i]->makeVisualizer();
                    widgets_[i]->setIndex(i);
                    widgets_[i]->setDataModel(dataModel());
                }
                setTuningIndex(std::max(_index - 1, 0));

                emit tuningRemoved();
                emit dataModelChanged();
            }

void omni::ui::proj::TuningList::removeWidgets ( )

private

Removes all widgets in the scroll area Unlike clear() it does not remove tunings from session.

            {
                for (auto& _widget : widgets_)
                {
                    contents_->layout()->removeWidget(_widget.get());
                    _widget->setParent(nullptr);
                }
                widgets_.clear();
            }

void omni::ui::proj::TuningList::resizeEvent ( QResizeEvent *  event )

protected

            {
                for (auto& _widget : widgets_) _widget->layout()->update();

                QScrollArea::resizeEvent(event);
            }

void omni::ui::proj::TuningList::sessionModeChange ( )

slot

Change current mode for all tuning widgets.

            {
                if (!dataModel()) return;

                auto _currentIndex = dataModel()->tunings().currentIndex();

                for (auto& _widget : widgets_) {
                    _widget->sessionModeChange();
                }

                if ((_currentIndex >= 0) && (_currentIndex < widgets_.size())) {
                    widgets_[_currentIndex]->setFocus();
                }
            }

void omni::ui::proj::TuningList::setCurrentTuning ( )

slot

Set current tuning from currently selected widget.

            {
                if (!dataModel()) return;

                int _index = 0;

                for (auto& _widget : widgets_)
                {
                    if (_widget->isSelected())
                    {
                        setTuningIndex(_index);
                    } else {
                        _widget->setSelected(false);
                    }
                    ++_index;
                }
            }

void omni::ui::proj::TuningList::setTuningIndex ( int  _index )

slot

Set current tuning index manually (currentIndexChanged signal is emitted)

            {
                int _oldIndex = dataModel()->tunings().currentIndex();

                dataModel()->tunings().setCurrentIndex(_index);

                for (auto& _widget : widgets_) {
                    if ((_widget->index() != _index) && _widget->isSelected()) {
                        _widget->setSelected(false);
                    }
                }

                if (_index != _oldIndex) emit currentIndexChanged(_index);

                emit dataModelChanged();
            }

void omni::ui::proj::TuningList::tuningAdded ( )

signal

Signal is emitted when a tuning was added.

void omni::ui::proj::TuningList::tuningChanged ( )

signal

Emitted when a single tuning has changed.

void omni::ui::proj::TuningList::tuningRemoved ( )

signal

Signal is emitted when a tuning was removed.

void omni::ui::proj::TuningList::updateSceneSize ( bool  _rescaleValues )

slot

Adjust sliders to scene scale.

                                                                {
                if (!dataModel() || isLocked()) return;

                for (auto& _widget : widgets_) {
                    _widget->setRescaleValues(_rescaleValues);
                    _widget->setScale(dataModel()->scene().size());
                }
            }

void omni::ui::proj::TuningList::updateUnits ( )

slot

Set unit of sliders.

                                         {
                if (!dataModel() || isLocked()) return;

                for (auto& _widget : widgets_) {
                    _widget->setUnit(dataModel()->scene().unit().abbreviation());
                }
            }

void omni::ui::proj::TuningList::updateViews ( )

slot

Updates/Repaints GL Views of all tunings widgets.

            {
                for (auto& _widget : widgets_) _widget->updateViews();
            }

Tuning * omni::ui::proj::TuningList::widget

(

int

_index

)

Return tuning widget at index, nullptr if index is not valid.

                                                  {
                return (_index >= 0) && (_index < widgets_.size()) ?
                       widgets_[_index].get() : nullptr;
            }

Tuning const * omni::ui::proj::TuningList::widget

(

int

_index

)

const

Return tuning widget at index, nullptr if index is not valid (const)

                                                              {
                return (_index >= 0) && (_index < widgets_.size()) ?
                       widgets_[_index].get() : nullptr;
            }

Tuning * omni::ui::proj::TuningList::widgetFromTuning

(

omni::proj::Tuning *

_tuning

)

                                                                        {
              for (auto& _widget : widgets_) {
                if (_widget->tuning() == _tuning) return _widget.get();
              }
              return nullptr;
            }

Field Documentation

QWidget* omni::ui::proj::TuningList::contents_

private

QLayout* omni::ui::proj::TuningList::layout_

private

std::vector<QUniquePtr<Tuning> > omni::ui::proj::TuningList::widgets_

private

---

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

• src/app/proj/TuningList.h
• src/app/proj/TuningList.cpp