---

video_X.cpp

//FILE:       video_X.cpp
//AUTHOR:     Andrew Van Pernis <arakel@vr.clemson.edu>

#include "video_X.h"
#include <iostream>

//Static constant definitions
#ifdef GLX_SGIX_fbconfig
const int video_X::VISUAL_ATTRIBUTES_8BPP[] = {
  GLX_DRAWABLE_TYPE_SGIX, GLX_WINDOW_BIT_SGIX,
  GLX_RENDER_TYPE_SGIX, GLX_RGBA_BIT_SGIX,
  GLX_DOUBLEBUFFER, GL_TRUE,
  GLX_RED_SIZE, 2,
  GLX_GREEN_SIZE, 2,
  GLX_BLUE_SIZE, 2,
  GLX_ALPHA_SIZE, 2,
  None
};

const int video_X::VISUAL_ATTRIBUTES_16BPP[] = {
  GLX_DRAWABLE_TYPE_SGIX, GLX_WINDOW_BIT_SGIX,
  GLX_RENDER_TYPE_SGIX, GLX_RGBA_BIT_SGIX,
  GLX_DOUBLEBUFFER, GL_TRUE,
  GLX_RED_SIZE, 4,
  GLX_GREEN_SIZE, 4,
  GLX_BLUE_SIZE, 4,
  GLX_ALPHA_SIZE, 4,
  None
};

const int video_X::VISUAL_ATTRIBUTES_24BPP[] = {
  GLX_DRAWABLE_TYPE_SGIX, GLX_WINDOW_BIT_SGIX,
  GLX_RENDER_TYPE_SGIX, GLX_RGBA_BIT_SGIX,
  GLX_DOUBLEBUFFER, GL_TRUE,
  GLX_RED_SIZE, 6,
  GLX_GREEN_SIZE, 6,
  GLX_BLUE_SIZE, 6,
  GLX_ALPHA_SIZE, 6,
  None  
};

const int video_X::VISUAL_ATTRIBUTES_32BPP[] = {
  GLX_DRAWABLE_TYPE_SGIX, GLX_WINDOW_BIT_SGIX,
  GLX_RENDER_TYPE_SGIX, GLX_RGBA_BIT_SGIX,
  GLX_DOUBLEBUFFER, GL_TRUE,
  GLX_RED_SIZE, 8,
  GLX_GREEN_SIZE, 8,
  GLX_BLUE_SIZE, 8,
  GLX_ALPHA_SIZE, 8,
  None
};
#else
const int video_X::VISUAL_ATTRIBUTES_8BPP[] = {
  GLX_DOUBLEBUFFER, GL_TRUE,
  GLX_RED_SIZE, 2,
  GLX_GREEN_SIZE, 2,
  GLX_BLUE_SIZE, 2,
  GLX_ALPHA_SIZE, 2,
  None
};

const int video_X::VISUAL_ATTRIBUTES_16BPP[] = {
  GLX_DOUBLEBUFFER, GL_TRUE,
  GLX_RED_SIZE, 4,
  GLX_GREEN_SIZE, 4,
  GLX_BLUE_SIZE, 4,
  GLX_ALPHA_SIZE, 4,
  None
};

const int video_X::VISUAL_ATTRIBUTES_24BPP[] = {
  GLX_DOUBLEBUFFER, GL_TRUE,
  GLX_RED_SIZE, 6,
  GLX_GREEN_SIZE, 6,
  GLX_BLUE_SIZE, 6,
  GLX_ALPHA_SIZE, 6,
  None  
};

const int video_X::VISUAL_ATTRIBUTES_32BPP[] = {
  GLX_DOUBLEBUFFER, GL_TRUE,
  GLX_RED_SIZE, 8,
  GLX_GREEN_SIZE, 8,
  GLX_BLUE_SIZE, 8,
  GLX_ALPHA_SIZE, 8,
  None
};
#endif
const int video_X::LARGE = 10000;

//Method definitions for video_X class

video_X::video_X(void){
  m_window_title = std::string("Uber");
  m_display = NULL;
  m_selected_visual = NULL;
  m_GL_attributes = NULL;
#ifdef GLX_SGIX_fbconfig
  m_available_configs = NULL;
  m_num_available_configs = 0;
#endif
}

/*===========================================================================*/

video_X::~video_X(void){
#ifdef GLX_SGIX_fbconfig
  if (m_available_configs != NULL){
    delete(m_available_configs);
    m_available_configs = NULL;
  }
#endif
  if (m_selected_visual != NULL){
    delete(m_selected_visual);
    m_selected_visual = NULL;
  }
  if (m_GL_attributes != NULL){
    delete(m_GL_attributes);
    m_GL_attributes = NULL;
  }
}

/*===========================================================================*/

bool video_X::init(unsigned int w, unsigned int h, unsigned int bpp, bool fs){
  int screen, num_modes, best_mode_width = LARGE, best_mode_height = LARGE,
    best_mode, i, attributes_size;
  int *attributes, *ptr;
  Window root_window;
  XSetWindowAttributes window_attributes;
  XColor white;
  XF86VidModeModeInfo **modes;
  Atom wm_delete;
  
  //Check to see if arguments are sane
  if (w < 1)
    w = 1;
  if (h < 1)
    h = 1;
  if (bpp < 8)
    bpp = 8;

  //Check to see if the X display can be opened and grab some defaults
  if ((m_display = XOpenDisplay(NULL)) == NULL){
    set_error("Unable to open the X display.");
    return false;
  }
  screen = DefaultScreen(m_display);
  root_window = RootWindow(m_display, screen);

  //Get the video modes for the X display
  if (!(XF86VidModeGetAllModeLines(m_display, screen, &num_modes, &modes))){
    set_error("Unable to obtain the X video modes.");
    return false;
  }
  m_desktop_mode = (*modes)[0];
  best_mode = -1;
  for (i=0; i<num_modes; i++){
    if ((modes[i]->hdisplay >= w) && (modes[i]->vdisplay >= h) && 
        (modes[i]->hdisplay <= best_mode_width) && (modes[i]->vdisplay <= best_mode_height)){
      best_mode = i;
      best_mode_width = modes[i]->hdisplay;
      best_mode_height = modes[i]->vdisplay;
    }
  }

  //Select the appropriate attribute set
  if (bpp < 16)
    attributes = (int*)VISUAL_ATTRIBUTES_8BPP;
  else if (bpp < 24)
    attributes = (int*)VISUAL_ATTRIBUTES_16BPP;
  else if (bpp < 32)
    attributes = (int*)VISUAL_ATTRIBUTES_24BPP;
  else
    attributes = (int*)VISUAL_ATTRIBUTES_32BPP;

#ifdef GLX_SGIX_fbconfig
  //Get a list of frame buffer configurations
  m_num_available_configs = 0;
  m_available_configs = glXChooseFBConfigSGIX(m_display, screen, attributes, &m_num_available_configs);
  if (m_num_available_configs == 0){
    set_error("A framebuffer configuration with the chosen bit depth could not be found.");
    return false;
  }

  //Choose a visual based on the frame buffer configuration
  if (m_num_available_configs > 0)
    m_selected_visual = glXGetVisualFromFBConfigSGIX(m_display, m_available_configs[0]);
  else{
    set_error("Unable to find an appropriate X visual.");
    return false;
  }
#else
  //Obtain a visual from the X server for the window
  m_selected_visual = glXChooseVisual(m_display, screen, attributes);
  if (m_selected_visual == NULL){
    set_error("Unable to find an appropriate X visual.");
    return false;
  }
#endif
  
  //Create a color map for the window
  window_attributes.colormap = XCreateColormap(m_display, root_window, 
                                               m_selected_visual->visual, AllocNone);
  white.red = white.green = white.blue = 0xffff;
  XAllocColor(m_display, window_attributes.colormap, &white);
  window_attributes.border_pixel = white.pixel;

  //Create an OpenGL context for the window
  m_window_context = glXCreateContext(m_display, m_selected_visual, NULL, True);

  //Check whether or not to make the window fullscreen
  if (fs){

    //Switch X to the appropriate video mode
    if(!(XF86VidModeSwitchToMode(m_display, screen, modes[best_mode]))){
      set_error("Unable to switch the X video mode.");
      return false;
    }
    XF86VidModeSetViewPort(m_display, screen, 0, 0);
    w = modes[best_mode]->hdisplay;
    h = modes[best_mode]->vdisplay;
    XFree(modes);

    //Create a fullscreen window
    window_attributes.override_redirect = True;
    window_attributes.event_mask = ExposureMask;
    m_window = XCreateWindow(m_display, root_window, 0, 0, w, h, 0,
                             m_selected_visual->depth, InputOutput, m_selected_visual->visual,
                             CWBorderPixel|CWColormap|CWEventMask|CWOverrideRedirect, &window_attributes);
    XWarpPointer(m_display, None, m_window, 0, 0, 0, 0, 0, 0);

    //Map the window into existence
    XMapRaised(m_display, m_window);

    //Grab keyboard and mouse
    XGrabKeyboard(m_display, m_window, True, GrabModeAsync, GrabModeAsync, CurrentTime);
    XGrabPointer(m_display, m_window, True, ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
                 GrabModeAsync, GrabModeAsync, m_window, None, CurrentTime);
  }
  else {
    
    //Create a window in windowed mode
    window_attributes.event_mask = ExposureMask;
    m_window = XCreateWindow(m_display, root_window, 0, 0, w, h, 0,
                             m_selected_visual->depth, InputOutput, m_selected_visual->visual,
                             CWBorderPixel|CWColormap|CWEventMask, &window_attributes);
  
    //Set the title and handle window manager delete events
    wm_delete = XInternAtom(m_display, "WM_DELETE_WINDOW", True);
    XSetWMProtocols(m_display, m_window, &wm_delete, 1);
    XSetStandardProperties(m_display, m_window, m_window_title.c_str(), m_window_title.c_str(), None, NULL, 0, NULL);

    //Map the window into existence
    XMapRaised(m_display, m_window);
  }

  //Initialize OpenGL
  glXMakeContextCurrent(m_display, m_window, m_window, m_window_context);
  gl::init(w, h);
  
  //Initialize the clock
  m_clock.reset();

  //Find the size of the GL attributes array
  attributes_size = 0;
  ptr = attributes;
  while (*ptr != None){
    attributes_size++;
    ptr++;
  }
  attributes_size++;
  
  //Copy parameters to internal variables
  m_width = w;
  m_height = h;
  m_bpp = bpp;
  m_fullscreen = fs;
  m_GL_attributes = new int(attributes_size);
  memcpy(m_GL_attributes, attributes, attributes_size);
  return true;
}

/*===========================================================================*/

bool video_X::init(unsigned int w, unsigned int h, unsigned int bpp, const int attributes[], bool fs){
  int screen, num_modes, best_mode_width = LARGE, best_mode_height = LARGE,
    best_mode, i, attributes_size;
  int *ptr;
  Window root_window;
  XSetWindowAttributes window_attributes;
  XColor white;
  XF86VidModeModeInfo **modes;
  Atom wm_delete;
  
  //Check to see if arguments are sane
  if (w < 1)
    w = 1;
  if (h < 1)
    h = 1;
  if (bpp < 8)
    bpp = 8;

  //Check to see if the X display can be opened and grab some defaults
  if ((m_display = XOpenDisplay(NULL)) == NULL){
    set_error("Unable to open the X display.");
    return false;
  }
  screen = DefaultScreen(m_display);
  root_window = RootWindow(m_display, screen);

  //Get the video modes for the X display
  if (!(XF86VidModeGetAllModeLines(m_display, screen, &num_modes, &modes))){
    set_error("Unable to obtain the X video modes.");
    return false;
  }
  m_desktop_mode = (*modes)[0];

#ifdef GLX_SGIX_fbconfig
  //Get a list of frame buffer configurations
  m_num_available_configs = 0;
  m_available_configs = glXChooseFBConfigSGIX(m_display, screen, attributes, &m_num_available_configs);
  if (m_num_available_configs == 0){
    set_error("A framebuffer configuration with the chosen bit depth could not be found.");
    return false;
  }

  //Choose a visual based on the frame buffer configuration
  if (m_num_available_configs > 0)
    m_selected_visual = glXGetVisualFromFBConfigSGIX(m_display, m_available_configs[0]);
  else{
    set_error("Unable to find an appropriate X visual.");
    return false;
  }
#else
  //Obtain a visual from the X server for the window
  m_selected_visual = glXChooseVisual(m_display, screen, attributes);
  if (m_selected_visual == NULL){
    set_error("Unable to find an appropriate X visual.");
    return false;
  }
#endif
  
  //Create a color map for the window
  window_attributes.colormap = XCreateColormap(m_display, root_window, 
                                               m_selected_visual->visual, AllocNone);
  white.red = white.green = white.blue = 0xffff;
  XAllocColor(m_display, window_attributes.colormap, &white);
  window_attributes.border_pixel = white.pixel;

  //Create an OpenGL context for the window
  m_window_context = glXCreateContext(m_display, m_selected_visual, NULL, True);

  //Check whether or not to make the window fullscreen
  if (fs){
    
    //Find the best video mode to switch to
    best_mode = -1;
    for (i=0; i<num_modes; i++){
      if ((modes[i]->hdisplay >= w) && (modes[i]->vdisplay >= h) && 
          (modes[i]->hdisplay <= best_mode_width) && (modes[i]->vdisplay <= best_mode_height)){
        best_mode = i;
        best_mode_width = modes[i]->hdisplay;
        best_mode_height = modes[i]->vdisplay;
      }
    }
    if (best_mode == -1){
      set_error("A suitable video mode could not be found for X.");
      return false;
    }
      
    //Switch X to the appropriate video mode
    if(!(XF86VidModeSwitchToMode(m_display, screen, modes[best_mode]))){
      set_error("Unable to switch the X video mode.");
      return false;
    }
    XF86VidModeSetViewPort(m_display, screen, 0, 0);
    w = modes[best_mode]->hdisplay;
    h = modes[best_mode]->vdisplay;
    XFree(modes);

    //Create a fullscreen window
    window_attributes.override_redirect = True;
    window_attributes.event_mask = ExposureMask;
    m_window = XCreateWindow(m_display, root_window, 0, 0, w, h, 0,
                             m_selected_visual->depth, InputOutput, m_selected_visual->visual,
                             CWBorderPixel|CWColormap|CWEventMask|CWOverrideRedirect, &window_attributes);
    XWarpPointer(m_display, None, m_window, 0, 0, 0, 0, 0, 0);

    //Map the window into existence
    XMapRaised(m_display, m_window);

    //Grab keyboard and mouse
    XGrabKeyboard(m_display, m_window, True, GrabModeAsync, GrabModeAsync, CurrentTime);
    XGrabPointer(m_display, m_window, True, ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
                 GrabModeAsync, GrabModeAsync, m_window, None, CurrentTime);    
  }
  else {
    
    //Create a window in windowed mode
    window_attributes.event_mask = ExposureMask;
    m_window = XCreateWindow(m_display, root_window, 0, 0, w, h, 0,
                             m_selected_visual->depth, InputOutput, m_selected_visual->visual,
                             CWBorderPixel|CWColormap|CWEventMask, &window_attributes);
  
    //Set the title and handle window manager delete events
    wm_delete = XInternAtom(m_display, "WM_DELETE_WINDOW", True);
    XSetWMProtocols(m_display, m_window, &wm_delete, 1);
    XSetStandardProperties(m_display, m_window, m_window_title.c_str(), m_window_title.c_str(), None, NULL, 0, NULL);

    //Map the window into existence
    XMapRaised(m_display, m_window);
  }

  //Initialize OpenGL
  glXMakeContextCurrent(m_display, m_window, m_window, m_window_context);
  gl::init(w, h);
  
  //Initialize the clock
  m_clock.reset();
  m_clock.reset();

  //Find the size of the GL attributes array
  attributes_size = 0;
  ptr = (int*)attributes;
  while (*ptr != None){
    attributes_size++;
    ptr++;
  }
  attributes_size++;

  //Copy parameters to internal variables
  m_width = w;
  m_height = h;
  m_bpp = bpp;
  m_fullscreen = fs;
  m_GL_attributes = new int(attributes_size);
  memcpy(m_GL_attributes, attributes, attributes_size);
  return true;
}

/*===========================================================================*/

void video_X::set_title(const std::string& title){
  if (!m_fullscreen){

    //Change the title of the window
    XStoreName(m_display, m_window, title.c_str());
    
    //Change the title for the icon
    XSetIconName(m_display, m_window, title.c_str());
  }

  //Copy the title
  m_window_title = title;
}

/*===========================================================================*/

void video_X::resize(unsigned int w, unsigned int h){  
  if (!m_fullscreen){
    
    //Change the size of the window
    XResizeWindow(m_display, m_window, w, h);
    
    //Copy changed variables
    m_width = w;
    m_height = h;
  }
}

/*===========================================================================*/

void video_X::start_frame(void){

  //Update the clock
  m_clock.update();
  
  //Update the instant fps
  m_fps = 1.0/m_clock.elapsed();

  //Increment the frame count
  ++m_frame_count;

  //Update the average fps
  m_fps_sum += m_clock.elapsed();
  if (m_fps_sum > 1.0){
    m_avg_fps = m_fps_sum * static_cast<double>(m_frame_count);
    m_fps_sum = 0.0;
    m_frame_count = 0;
  }
}

/*===========================================================================*/

void video_X::end_frame(void){

  //Swap the OpenGL back buffer to the front
  activate();
  glXSwapBuffers(m_display, m_window);
}

/*===========================================================================*/

void video_X::toggle_fullscreen(void){
  int screen = DefaultScreen(m_display), i, best_mode, best_mode_width = LARGE,
    best_mode_height = LARGE, num_modes;
  XSetWindowAttributes window_attributes;
  XF86VidModeModeInfo **modes;
  Atom wm_delete;

  //Handle the case of in fullscreen mode
  if (m_fullscreen){

    //Release the keyboard and mouse
    XUngrabKeyboard(m_display, CurrentTime);
    XUngrabPointer(m_display, CurrentTime);
 
    //Unmap the window
    XUnmapWindow(m_display, m_window);
   
    //Switch out of fullscreen mode
    XF86VidModeSwitchToMode(m_display, screen, &m_desktop_mode);
    XF86VidModeSetViewPort(m_display, screen, 0, 0);

    //Set the title and handle window manager delete events
    wm_delete = XInternAtom(m_display, "WM_DELETE_WINDOW", True);
    XSetWMProtocols(m_display, m_window, &wm_delete, 1);
    XSetStandardProperties(m_display, m_window, m_window_title.c_str(), m_window_title.c_str(), None, NULL, 0, NULL);

    //Change window attributes for windowed mode
    window_attributes.override_redirect = False;
    XChangeWindowAttributes(m_display, m_window, CWOverrideRedirect, &window_attributes);

    //Map the window back into existence
    XMapRaised(m_display, m_window);
    m_fullscreen = false;
  }

  //Handle the case of in windowed mode
  else{

    //Get the video modes for the X display
    XF86VidModeGetAllModeLines(m_display, screen, &num_modes, &modes);
    
    //Find the best video mode to switch to
    best_mode = -1;
    for (i=0; i<num_modes; i++){
      if ((modes[i]->hdisplay >= m_width) && (modes[i]->vdisplay >= m_height) && 
          (modes[i]->hdisplay <= best_mode_width) && (modes[i]->vdisplay <= best_mode_height)){
        best_mode = i;
        best_mode_width = modes[i]->hdisplay;
        best_mode_height = modes[i]->vdisplay;
      }
    }
    if (best_mode == -1){
      set_error("A suitable video mode could not be found for X.");
      return;
    }
    
    //Unmap the window
    XUnmapWindow(m_display, m_window);
 
    //Switch X to the appropriate video mode
    if(!(XF86VidModeSwitchToMode(m_display, screen, modes[best_mode]))){
      set_error("Unable to switch the X video mode.");
      return;
    }
    XF86VidModeSetViewPort(m_display, screen, 0, 0);
    m_width = modes[best_mode]->hdisplay;
    m_height = modes[best_mode]->vdisplay;
    XFree(modes);
    XResizeWindow(m_display, m_window, m_width, m_height);
   
    //Change the window attributes for fullscreen mode
    window_attributes.override_redirect = True;
    XChangeWindowAttributes(m_display, m_window, CWOverrideRedirect, &window_attributes);
    XWarpPointer(m_display, None, m_window, 0, 0, 0, 0 ,0 ,0);
    
    //Map the window into existence
    XMapRaised(m_display, m_window);
    XMoveWindow(m_display, m_window, 0, 0);

    //Grab keyboard and mouse
    XGrabKeyboard(m_display, m_window, True, GrabModeAsync, GrabModeAsync, CurrentTime);
    XGrabPointer(m_display, m_window, True, ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
                 GrabModeAsync, GrabModeAsync, m_window, None, CurrentTime);
    m_fullscreen = true;
  } 
}

/*===========================================================================*/

void video_X::activate(void){

  //Switch to the GL context for the window
  glXMakeContextCurrent(m_display, m_window, m_window, m_window_context);
}

/*===========================================================================*/

void video_X::shutdown(void){
  int screen = DefaultScreen(m_display);
  
  //Destroy the GL context
  glXDestroyContext(m_display, m_window_context);
  m_window_context = NULL;

  //Switch back to the desktop resolution if in fullscreen mode
  if (m_fullscreen){
    XF86VidModeSwitchToMode(m_display, screen, &m_desktop_mode);
    XF86VidModeSetViewPort(m_display, screen, 0, 0);
  }
  XCloseDisplay(m_display);
  m_display = NULL;
}

/*===========================================================================*/

void video_X::set_eventmask(long eventmask){
  
  //Change the X event mask
  XSelectInput(m_display, m_window, eventmask);
}

/*===========================================================================*/

void video_X::move_pointer(int x, int y){
  
  //Warp the pointer to the new location
  XWarpPointer(m_display, None, m_window, 0, 0, 0, 0, x, y);
}

/*===========================================================================*/

bool video_X::get_pointer(int *x, int *y){
  int root_x, root_y;
  unsigned int mask;
  bool result;
  Window result_window, result_root;
  
  //Check the position of the pointer
  result = XQueryPointer(m_display, m_window, &result_root, &result_window,
                         &root_x, &root_y, x, y, &mask);
  return result;
}

---