// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_X11_sg_viewer
#define tools_X11_sg_viewer

// not pure X11 version. The class inherits tools::sg::viewer that uses GL.

#include "session"

#include "../sg/GL_viewer"

#include "simple_dispatcher"

namespace tools{namespace sg{class device_interactor;}}

namespace tools {
namespace X11 {

class sg_viewer : public sg::GL_viewer {
  typedef sg::GL_viewer parent;
private:
  class dispatcher : public simple_dispatcher {
    typedef simple_dispatcher parent;
  public:
    virtual void win_render() {m_sg_viewer.win_render();}
    virtual void set_size(unsigned int a_width,unsigned int a_height) {m_sg_viewer.set_size(a_width,a_height);}
    virtual dispatcher* copy() const {return new dispatcher(*this);}
  public:
    dispatcher(sg_viewer& a_sg_viewer)
    :parent(a_sg_viewer.m_session,a_sg_viewer.m_win)
    ,m_sg_viewer(a_sg_viewer){}
    virtual ~dispatcher(){}
  protected:
    dispatcher(const dispatcher& a_from)
    :parent(a_from)
    ,m_sg_viewer(a_from.m_sg_viewer)
    {}
    dispatcher& operator=(const dispatcher& a_from) {
      parent::operator=(a_from);
      return *this;
    }
  protected:
    sg_viewer& m_sg_viewer;
  };

public:
  sg_viewer(session& a_session,
            int a_x = 0,int a_y = 0,
            unsigned int a_width = 500,unsigned int a_height = 500,
            const std::string& a_win_title = "")
  :parent(a_session.out(),a_width,a_height)
  ,m_session(a_session)
  ,m_win(0)
  {
    if(!m_session.display()) return; //throw
    m_win = m_session.create_window(a_win_title.c_str(),a_x,a_y,a_width,a_height);
    if(!m_win) return; //throw
    m_session.add_dispatcher(new dispatcher(*this));
  }
  virtual ~sg_viewer() {
    if(m_win) {
      m_session.remove_dispatchers_with_window(m_win);
      m_session.delete_window(m_win);
      m_session.sync();
    }
  }
public:
  sg_viewer(const sg_viewer& a_from)
  :parent(a_from)
  ,m_session(a_from.m_session)
  ,m_win(a_from.m_win)
  {}
  sg_viewer& operator=(const sg_viewer& a_from){
    parent::operator=(a_from);
    m_win = a_from.m_win;
    return *this;
  }
public:
  bool has_window() const {return m_win?true:false;} //for SWIG

  Window window() const {return m_win;}

  bool show() {
    if(!m_win) return false;
    m_session.show_window(m_win);
    return true;
  }

  void win_render() {
    if(!m_win) return;
    if(::glXMakeCurrent(m_session.display(),m_win,m_session.context())==False){
      m_session.out() << "tools::X11::sg_viewer::win_render : glXMakeCurrent failed." << std::endl;
      return;
    }
    render(); //viewer::render()
    ::glXSwapBuffers(m_session.display(),m_win);
    if(::glXMakeCurrent(m_session.display(),None,NULL)==False){
      m_session.out() << "tools::X11::sg_viewer::win_render : glXMakeCurrent(None,NULL) failed." << std::endl;
    }
  }

public:
  void set_device_interactor(tools::sg::device_interactor*) {}
protected:
  session& m_session;
  Window m_win;
};

}}

#endif