Subversion Repositories seema-scanner

#include "OpenGLContext.h"

#include <GLFW/glfw3.h>

#include <stdio.h>

#ifdef __unix__

    #define GLFW_EXPOSE_NATIVE_X11

    #define GLFW_EXPOSE_NATIVE_GLX

    #include <cstring>

    #include <X11/X.h>

 typedef XID RRCrtc;

    #include <GLFW/glfw3native.h>

#endif

struct OpenGLContext::OpenGLContextInfo{

    GLFWmonitor* monitor;

    GLFWwindow* window;

    OpenGLContextInfo() : monitor(NULL), window(NULL){}

};

void error_callback(int error, const char* description){

    std::cerr << "GLFW error code " << error << " " << description << std::endl;

}

std::vector<ScreenInfo> OpenGLContext::GetScreenInfo(){

    std::vector<ScreenInfo> ret;

    if (!glfwInit())

        std::cerr << "Could not initialize GLFW!" << std::endl;

    glfwSetErrorCallback(error_callback);

    int nScreens = 0;

    GLFWmonitor **monitors;

    monitors = glfwGetMonitors(&nScreens);

    for(int i=0; i<nScreens; i++){

        GLFWmonitor *monitor = monitors[i];

        const GLFWvidmode *videoMode = glfwGetVideoMode(monitor);

        ScreenInfo screen;

        screen.resX = videoMode->width;

        screen.resY = videoMode->height;

        const char *screenName = glfwGetMonitorName(monitor);

        screen.name = screenName;

        ret.push_back(screen);

    }

    //glfwTerminate();

    return ret;

}

OpenGLContext::OpenGLContext(uint _screenNum) : screenNum(_screenNum), screenResX(0), screenResY(0){

    contextInfo = new OpenGLContextInfo();

    if (!glfwInit())

        std::cerr << "Could not initialize GLFW!" << std::endl;

    glfwSetErrorCallback(error_callback);

    int nScreens = 0;

    GLFWmonitor **monitors;

    monitors = glfwGetMonitors(&nScreens);

    if((unsigned int)nScreens < screenNum+1)

        std::cerr << "Could not open screen " << screenNum << std::endl;

    contextInfo->monitor = monitors[screenNum];

    const GLFWvidmode *videoMode = glfwGetVideoMode(contextInfo->monitor);

    screenResX = videoMode->width;

    screenResY = videoMode->height;

    // Set window hints

    glfwDefaultWindowHints();

    // highest available refresh rate

    glfwWindowHint(GLFW_REFRESH_RATE, 0);

    // Create fullscreen window

    contextInfo->window = glfwCreateWindow(screenResX, screenResY, "GLFW OpenGL Context", contextInfo->monitor, NULL);

    // make cursor invisible

    glfwSetInputMode(contextInfo->window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);

#ifdef a__unix__

    Display *display = glfwGetX11Display();

    Window window = glfwGetX11Window(contextInfo->window);

    Atom wmStateAbove = XInternAtom( display, "_NET_WM_STATE_ABOVE", 1 );

    if( wmStateAbove != None ) {

        printf( "_NET_WM_STATE_ABOVE has atom of %ld\n", (long)wmStateAbove );

    } else {

        printf( "ERROR: cannot find atom for _NET_WM_STATE_ABOVE !\n" );

    }

    Atom wmNetWmState = XInternAtom( display, "_NET_WM_STATE", 1 );

    if( wmNetWmState != None ) {

        printf( "_NET_WM_STATE has atom of %ld\n", (long)wmNetWmState );

    } else {

        printf( "ERROR: cannot find atom for _NET_WM_STATE !\n" );

    }

    // set window always on top hint

    if( wmStateAbove != None ) {

        XClientMessageEvent xclient;

        memset( &xclient, 0, sizeof (xclient) );

        //

        //window  = the respective client window

        //message_type = _NET_WM_STATE

        //format = 32

        //data.l[0] = the action, as listed below

        //data.l[1] = first property to alter

        //data.l[2] = second property to alter

        //data.l[3] = source indication (0-unk,1-normal app,2-pager)

        //other data.l[] elements = 0

        //

        xclient.type = ClientMessage;

        xclient.window = window; // GDK_WINDOW_XID(window);

        xclient.message_type = wmNetWmState; //gdk_x11_get_xatom_by_name_for_display( display, "_NET_WM_STATE" );

        xclient.format = 32;

        xclient.data.l[0] = 1; // add the state

        xclient.data.l[1] = wmStateAbove; //gdk_x11_atom_to_xatom_for_display (display, state1);

        xclient.data.l[2] = 0; //gdk_x11_atom_to_xatom_for_display (display, state2);

        xclient.data.l[3] = 0;

        xclient.data.l[4] = 0;

        //gdk_wmspec_change_state( FALSE, window,

        //  gdk_atom_intern_static_string ("_NET_WM_STATE_BELOW"),

        //  GDK_NONE );

        XSendEvent( display,

          //mywin - wrong, not app window, send to root window!

          DefaultRootWindow(display),

          False,

          SubstructureRedirectMask | SubstructureNotifyMask,

          (XEvent *)&xclient );

      }

//    // Set swap interval to 1 for standard vsync

//    typedef GLvoid (*glXSwapIntervalSGIFunc) (GLint);

//    const char *glx_extensions = glXQueryExtensionsString(display, screenNum);

//    if (strstr(glx_extensions, "GLX_SGI_swap_control")) {

//        PFNGLXSWAPINTERVALSGIPROC SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalSGI");

//        SwapIntervalSGI(1);

//    } else if (strstr(glx_extensions, "GLX_EXT_swap_control")) {

//        PFNGLXSWAPINTERVALEXTPROC SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");

//        SwapIntervalEXT(display, window, 1);

//    } else {

//        std::cerr << "OpenGLContext.Unix Error: Could not access swap interval extension!" << std::endl;

//    }

#endif

    glfwMakeContextCurrent(contextInfo->window);

    // Set vsync (swap interval 1)

    glfwSwapInterval(1);

    // Adjust gamma to one

    this->setGamma(1.0);

}

void OpenGLContext::setGamma(float gamma){

    glfwSetGamma(contextInfo->monitor, gamma);

}

void OpenGLContext::makeContextCurrent(){

    glfwMakeContextCurrent(contextInfo->window);

}

void OpenGLContext::flush(){

    // Swap buffers

    glfwSwapBuffers(contextInfo->window);

    // Poll events in order not to lock up

    glfwPollEvents();

    //glfwWaitEvents();

//    glFinish();

}

OpenGLContext::~OpenGLContext(){

    glfwDestroyWindow(contextInfo->window);

    glfwTerminate();

    delete contextInfo;

}