Line data    Source code

       1             : 
       2             : /* Copyright (c) 2011-2017, Stefan Eilemann <eile@eyescale.ch>
       3             :  *                          Petros Kataras <petroskataras@gmail.com>
       4             :  *
       5             :  * This library is free software; you can redistribute it and/or modify it under
       6             :  * the terms of the GNU Lesser General Public License version 2.1 as published
       7             :  * by the Free Software Foundation.
       8             :  *
       9             :  * This library is distributed in the hope that it will be useful, but WITHOUT
      10             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
      11             :  * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
      12             :  * details.
      13             :  *
      14             :  * You should have received a copy of the GNU Lesser General Public License
      15             :  * along with this library; if not, write to the Free Software Foundation, Inc.,
      16             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      17             :  */
      18             : 
      19             : #include "window.h"
      20             : 
      21             : #include "config.h"
      22             : #include "pipe.h"
      23             : #include "renderer.h"
      24             : 
      25             : #include <eq/fabric/event.h>
      26             : #include <eq/util/objectManager.h>
      27             : #include <seq/renderer.h>
      28             : 
      29             : namespace seq
      30             : {
      31             : namespace detail
      32             : {
      33           2 : Window::Window(eq::Pipe* parent)
      34           2 :     : eq::Window(parent)
      35             : {
      36           2 : }
      37             : 
      38           4 : Window::~Window()
      39             : {
      40           4 : }
      41             : 
      42           2 : Config* Window::getConfig()
      43             : {
      44           2 :     return static_cast<Config*>(eq::Window::getConfig());
      45             : }
      46             : 
      47          13 : Pipe* Window::getPipe()
      48             : {
      49          13 :     return static_cast<Pipe*>(eq::Window::getPipe());
      50             : }
      51             : 
      52           5 : seq::Renderer* Window::getRenderer()
      53             : {
      54           5 :     return getPipe()->getRenderer();
      55             : }
      56             : 
      57           8 : detail::Renderer* Window::getRendererImpl()
      58             : {
      59           8 :     return getPipe()->getRendererImpl();
      60             : }
      61             : 
      62           2 : void Window::frameStart(const uint128_t& frameID, const uint32_t frameNumber)
      63             : {
      64           2 :     getRendererImpl()->setWindow(this);
      65           2 :     eq::Window::frameStart(frameID, frameNumber);
      66           2 : }
      67             : 
      68           2 : void Window::frameFinish(const uint128_t& frameID, const uint32_t frameNumber)
      69             : {
      70           2 :     getRendererImpl()->setWindow(0);
      71           2 :     eq::Window::frameFinish(frameID, frameNumber);
      72           2 : }
      73             : 
      74           2 : bool Window::configInitGL(const uint128_t&)
      75             : {
      76           2 :     Renderer* rendererImpl = getRendererImpl();
      77           2 :     rendererImpl->setWindow(this);
      78             : 
      79           2 :     co::Object* initData = getConfig()->getInitData();
      80           2 :     seq::Renderer* const renderer = getRenderer();
      81           2 :     const bool first = !getObjectManager().isShared();
      82             : 
      83           2 :     if (first && !renderer->init(initData))
      84             :     {
      85           0 :         rendererImpl->setWindow(0);
      86           0 :         return false;
      87             :     }
      88           2 :     const bool ret = renderer->initContext(initData);
      89             : 
      90           2 :     rendererImpl->setWindow(0);
      91           2 :     return ret;
      92             : }
      93             : 
      94           2 : bool Window::configExitGL()
      95             : {
      96           2 :     Renderer* rendererImpl = getRendererImpl();
      97           2 :     rendererImpl->setWindow(this);
      98           2 :     seq::Renderer* const renderer = getRenderer();
      99           2 :     const bool last = !getObjectManager().isShared();
     100             : 
     101           2 :     bool ret = renderer->exitContext();
     102           2 :     if (last && !renderer->exit())
     103           0 :         ret = false;
     104             : 
     105           2 :     rendererImpl->setWindow(0);
     106           2 :     return ret;
     107             : }
     108             : 
     109           1 : bool Window::processEvent(const eq::EventType type)
     110             : {
     111           1 :     seq::Renderer* const renderer = getRenderer();
     112           1 :     if (renderer->processEvent(EventType(type)))
     113           0 :         return true;
     114           1 :     return eq::Window::processEvent(type);
     115             : }
     116             : 
     117             : template <class E>
     118           0 : bool Window::_processEvent(const eq::EventType type, E& event)
     119             : {
     120           0 :     seq::Renderer* const renderer = getRenderer();
     121           0 :     if (renderer->processEvent(EventType(type), event))
     122           0 :         return true;
     123           0 :     return eq::Window::processEvent(type, event);
     124             : }
     125             : 
     126             : template <class E>
     127           0 : bool Window::_processEvent(E& event)
     128             : {
     129           0 :     seq::Renderer* const renderer = getRenderer();
     130           0 :     if (renderer->processEvent(event))
     131           0 :         return true;
     132           0 :     return eq::Window::processEvent(event);
     133             : }
     134             : 
     135           0 : bool Window::processEvent(const eq::EventType type, SizeEvent& event)
     136             : {
     137           0 :     return _processEvent(type, event);
     138             : }
     139             : 
     140           0 : bool Window::processEvent(const eq::EventType type, PointerEvent& event)
     141             : {
     142           0 :     return _processEvent(type, event);
     143             : }
     144             : 
     145           0 : bool Window::processEvent(const eq::EventType type, KeyEvent& event)
     146             : {
     147           0 :     return _processEvent(type, event);
     148             : }
     149             : 
     150           0 : bool Window::processEvent(AxisEvent& event)
     151             : {
     152           0 :     return _processEvent(event);
     153             : }
     154             : 
     155           0 : bool Window::processEvent(ButtonEvent& event)
     156             : {
     157           0 :     return _processEvent(event);
     158             : }
     159             : }
     160          30 : }