omni::proj::ScreenSetup Class Reference

Singleton class which manages the current screen setup. More...

#include <ScreenSetup.h>

Collaboration diagram for omni::proj::ScreenSetup:

Public Member Functions
	ScreenSetup (Session const *_session)
QRect	screenGeometry (QScreen const *=nullptr) const
	Returns the screen geometry for a screen If screen is null, the geometry for the virtual screen is returned. More...
Session const *	session () const
	Return const pointer to session. More...
int	subScreenCount (QScreen const *=nullptr) const
	Returns the number of subscreens for a single screen If screen is nullptr, number of subscreen for virtual screen is returned. More...
int	subScreenWidth (QScreen const *=nullptr) const
	Returns the number of subscreens for a single screen If screen is nullptr, number of subscreen for virtual screen is returned. More...
QRect	subScreenRect (int _index, QScreen const *=nullptr) const
	Returns the rectangle of a subscreen with a certain index. More...
qreal	subScreenAspectRatio (QScreen const *=nullptr) const
	Return aspect ratio of subscreen. More...
QRect	virtualScreenRect () const
	Virtual desktop rect contains all non-assigned tunings. More...
QRect	combinedDesktopRect () const
	Returns combined desktop and virtual desktop rect. More...
bool	noTuningsAssigned () const
	Returns true if no tuning is assigned to a screen. More...
bool	noTuningsAssigned (QScreen const *) const
std::set< QScreen const * >	usedScreens () const
std::set< proj::Tuning const * >	tunings (bool _excludeNonAssigned) const
QRect	tuningRect () const
	Bounding rect that unifies all tunings. More...
bool	operator== (const ScreenSetup &) const

Static Public Member Functions
static std::vector< QSize > const &	screenResolutions ()
	Returns screen size that supports triple heads. More...
static QScreen const *	standardScreen ()
	Return standard screen, where omnidome has to be placed. More...
static int	subScreenCountForScreen (QScreen const *)
	Static method for getting subscreen count for screen Screen must not be nullptr! More...
static int	subScreenWidthForScreen (QScreen const *)
	Static method for getting subscreen width for screen Screen must not be nullptr! More...
static QRect	subScreenRectForScreen (int _index, QScreen const *)
	Static method for getting subscreen count for screen Screen must not be nullptr! More...
static QRect	desktopRect (bool _excludeStandardScreen=true)
static std::vector< QScreen const * >	screens (bool _excludeStandardScreen=true)
	Return vector, optionally excluded standard screen. More...
static QScreen const *	screenFromRect (QRect const &)
	Return pointer to screen for rectangle, nullptr if no screen with. More...

Private Attributes
Session const *	session_

Detailed Description

Singleton class which manages the current screen setup.

Constructor & Destructor Documentation

omni::proj::ScreenSetup::ScreenSetup

(

Session const *

_session

)

                                                    :
      session_(_session)
    {}

Member Function Documentation

QRect omni::proj::ScreenSetup::combinedDesktopRect

(

)

const

Returns combined desktop and virtual desktop rect.

If there are no tunings assigned, ignore desktopRect

                                                 {
      /// If there are no tunings assigned, ignore desktopRect

      /*QRect _desktopRect;
         auto  _screens = ScreenSetup::screens();
         for (auto& _screen : _screens) {
          if (noTuningsAssigned(_screen)) continue;
          _desktopRect |= _screen->geometry();
         }*/
      return desktopRect() | virtualScreenRect();
    }

QRect omni::proj::ScreenSetup::desktopRect ( bool  _excludeStandardScreen = true )

static

    {
      QRect _desktopRect;
      auto  _screens = ScreenSetup::screens(_excludeStandardScreen);

      for (auto& _screen : _screens) _desktopRect |= _screen->geometry();
      return _desktopRect;
    }

bool omni::proj::ScreenSetup::noTuningsAssigned

(

)

const

Returns true if no tuning is assigned to a screen.

                                              {
      if (!session()) return true;

      for (auto& _tuning : session()->tunings()) {
        if (_tuning->hasScreen()) {
          return false;
        }
      }
      return true;
    }

bool omni::proj::ScreenSetup::noTuningsAssigned

(

QScreen const *

_screen

)

const

                                                                    {
      if (!session()) return true;

      for (auto& _tuning : session()->tunings()) {
        if (_tuning->screen() == _screen) {
          return false;
        }
      }
      return true;
    }

bool omni::proj::ScreenSetup::operator==

(

const ScreenSetup &

_rhs

)

const

    {
      return false;
    }

QScreen const * omni::proj::ScreenSetup::screenFromRect ( QRect const &  _rect )

static

Return pointer to screen for rectangle, nullptr if no screen with.

                                                                  {
      std::vector<QScreen const *> _screens;
      auto _allScreens = QGuiApplication::screens();

      for (auto& _screen : _allScreens) {
        if (_screen->geometry() == _rect) return _screen;
      }
      return nullptr;
    }

QRect omni::proj::ScreenSetup::screenGeometry

(

QScreen const *

_screen = nullptr

)

const

Returns the screen geometry for a screen If screen is null, the geometry for the virtual screen is returned.

Return geometry of virtual screen

Return geometry of actual screen

                                                                  {
      /// Return geometry of virtual screen
      if (!_screen) {
        return virtualScreenRect();
      }

      /// Return geometry of actual screen
      return _screen->geometry();
    }

std::vector< QSize > const & omni::proj::ScreenSetup::screenResolutions ( )

static

Returns screen size that supports triple heads.

    {
      static std::vector<QSize> _sizes;

      if (_sizes.empty())
        _sizes = {
          QSize(640,     480),
          QSize(800,     600),
          QSize(1024,    768),
          QSize(1280,    720),
          QSize(1280,    800),
          QSize(1920,   1080),
          QSize(1920,   1200),
          QSize(2560, 1440)
        };

      return _sizes;
    }

std::vector< QScreen const * > omni::proj::ScreenSetup::screens ( bool  _excludeStandardScreen = true )

static

Return vector, optionally excluded standard screen.

    {
      std::vector<QScreen const *> _screens;
      auto _allScreens = QGuiApplication::screens();

      for (auto& _screen : _allScreens) {
        if (_screen == standardScreen()) continue;

        _screens.push_back(_screen);
      }

      if (!_excludeStandardScreen) {
        _screens.push_back(nullptr);
      }
      return _screens;
    }

Session const * omni::proj::ScreenSetup::session

(

)

const

Return const pointer to session.

                                               {
      return session_;
    }

QScreen const * omni::proj::ScreenSetup::standardScreen ( )

static

Return standard screen, where omnidome has to be placed.

    {
      return QGuiApplication::primaryScreen();
    }

qreal omni::proj::ScreenSetup::subScreenAspectRatio

(

QScreen const *

_screen = nullptr

)

const

Return aspect ratio of subscreen.

                                                                        {
      return float(subScreenWidth(_screen)) / float(screenGeometry(_screen).height());
    }

int omni::proj::ScreenSetup::subScreenCount

(

QScreen const *

_screen = nullptr

)

const

Returns the number of subscreens for a single screen If screen is nullptr, number of subscreen for virtual screen is returned.

    {
      // Return subscreen count for virtual screen,
      // which is equal to the number of unassigned projectors
      if (!_screen) {
        int _numberOfUnassignedProjectors = 0;

        for (auto& _tuning : session_->tunings()) {
          if (!_tuning->screen()) ++_numberOfUnassignedProjectors;
        }
        return _numberOfUnassignedProjectors;
      }

      return subScreenCountForScreen(_screen);
    }

int omni::proj::ScreenSetup::subScreenCountForScreen ( QScreen const *  _screen )

static

Static method for getting subscreen count for screen Screen must not be nullptr!

                                                                      {
      // Go through list of screen resolutions and see if the
      // current screen has subscreens
      for (auto& _screenSize : screenResolutions())
      {
        if (_screenSize.height() == _screen->geometry().height())
        {
          if ((_screen->geometry().width() % _screenSize.width()) == 0)
          {
            return _screen->geometry().width() / _screenSize.width();
          }
        }
      }
      return 1;

    }

QRect omni::proj::ScreenSetup::subScreenRect	(	int	_index,
		QScreen const *	_screen = nullptr
	)		const

Returns the rectangle of a subscreen with a certain index.

    {
      int _w = subScreenWidth(_screen);
      return QRect(_w * _subScreenIndex, 0, _w, screenGeometry(_screen).height());
    }

QRect omni::proj::ScreenSetup::subScreenRectForScreen ( int  _index, QScreen const *  _screen  )

static

Static method for getting subscreen count for screen Screen must not be nullptr!

                                                                                         {
      int _w = subScreenWidthForScreen(_screen);
      return QRect(_w * _subScreenIndex, 0, _w, _screen->size().height());
    }

int omni::proj::ScreenSetup::subScreenWidth

(

QScreen const *

_screen = nullptr

)

const

Returns the number of subscreens for a single screen If screen is nullptr, number of subscreen for virtual screen is returned.

    {
      return screenGeometry(_screen).width() / subScreenCount(_screen);
    }

int omni::proj::ScreenSetup::subScreenWidthForScreen ( QScreen const *  _screen )

static

Static method for getting subscreen width for screen Screen must not be nullptr!

    {
      return _screen->geometry().width() / subScreenCountForScreen(_screen);
    }

QRect omni::proj::ScreenSetup::tuningRect

(

)

const

Bounding rect that unifies all tunings.

                                        {
      if (!session()) return QRect();

      QRect _rect;

      for (auto& _tuning : session()->tunings()) {
        _rect |=  _tuning->contentGeometry().translated(_tuning->screenGeometry().topLeft()) & _tuning->screenGeometry();
      }
      return _rect;
    }

std::set< proj::Tuning const * > omni::proj::ScreenSetup::tunings

(

bool

_excludeNonAssigned

)

const

                                      {
      std::set<proj::Tuning const *> _tunings;

      for (auto& _tuning : session()->tunings()) {
        if (!_excludeNonAssigned || _tuning->hasScreen()) {
          _tunings.insert(_tuning.get());
        }
      }

      return _tunings;
    }

std::set< QScreen const * > omni::proj::ScreenSetup::usedScreens

(

)

const

                                                          {
      std::set<QScreen const*> _screens;

      bool _excludeVirtualScreen = session_->exportSettings().excludeUnassignedProjectors();

      for (auto& _tuning : session()->tunings()) {
        if (!_tuning->hasScreen() && _excludeVirtualScreen) continue;
        _screens.insert(_tuning->screen());
        }
      return _screens;
    }

QRect omni::proj::ScreenSetup::virtualScreenRect

(

)

const

Virtual desktop rect contains all non-assigned tunings.

                                               {
      QRect _rect;
      int   _w = standardScreen()->geometry().width();
      int   _h = standardScreen()->geometry().height();

      for (auto& _tuning : session()->tunings()) {
        if (_tuning->hasScreen()) continue;
        _rect |= QRect(_rect.width(), 0,
                       _w, _h);
      }
      return _rect.translated(desktopRect().topRight());
    }

Field Documentation

Session const* omni::proj::ScreenSetup::session_

private

---

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

• include/omni/proj/ScreenSetup.h
• src/lib/proj/ScreenSetup.cpp