LiteWindow.h

Go to the documentation of this file.

#ifndef LITE_WINDOW_H
#define LITE_WINDOW_H

//#define WINDOW_PREFER_GLUT

#if defined(WINDOW_PREFER_GLUT)

#ifdef __APPLE__
        #include "GLUT/glut.h"
#else
        #include "GL/glut.h"
#endif
//for apple, use GLUT to create the window..
class LiteWindow
{
    int glut_id;
public:
    LiteWindow()            {  glut_id = 0;         }
    int IsValid()           {  return glut_id > 0; }        
    virtual ~LiteWindow()   {  if(glut_id > 0) glutDestroyWindow(glut_id);  }
    void MakeCurrent()      {  glutSetWindow(glut_id);    }
    void Create(int x = -1, int y = -1, const char* display = NULL)
    {
            static int _glut_init_called = 0;
        if(glut_id != 0) return;

            //see if there is an existing window
            if(_glut_init_called) glut_id = glutGetWindow();

            //create one if no glut window exists
            if(glut_id != 0) return;

            if(_glut_init_called == 0)
            {
                    int argc = 1;
                    char * argv[4] = { "-iconic", 0 , 0, 0};
            if(display) 
            {
                argc = 3;
                argv[1] = "-display";
                argv[2] = (char*) display;
            }
                    glutInit(&argc, argv);
                    glutInitDisplayMode (GLUT_RGBA ); 
                    _glut_init_called = 1; 
            }
            if(x != -1) glutInitWindowPosition(x, y);
        if(display || x != -1) std::cout << "Using display ["
            << (display? display : "\0" )<< "] at (" << x << "," << y << ")\n";
            glut_id = glutCreateWindow ("SIFT_GPU_GLUT");
            glutHideWindow();
    }
};
#elif defined( _WIN32)

#ifndef _INC_WINDOWS
#ifndef WIN32_LEAN_AND_MEAN
        #define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#endif 

class LiteWindow
{
    HWND hWnd;
    HGLRC hContext;
    HDC hdc;
public:
    LiteWindow()
    {
        hWnd = NULL;
        hContext = NULL;
        hdc = NULL;
    }
    virtual ~LiteWindow()
    {
        if(hContext)wglDeleteContext(hContext);
        if(hdc)ReleaseDC(hWnd, hdc);
        if(hWnd)DestroyWindow(hWnd);
    }
    int IsValid()
    {  
        return hContext != NULL;  
    }

    //display is ignored under Win32
    void Create(int x = -1, int y = -1, const char* display = NULL)
    {
        if(hContext) return;
        WNDCLASSEX wcex = { sizeof(WNDCLASSEX),  CS_HREDRAW | CS_VREDRAW,  
                            (WNDPROC)DefWindowProc,  0, 4, 0, 0, 0, 0, 0,
                            ("SIFT_GPU_LITE"),    0};
        RegisterClassEx(&wcex);
        hWnd = CreateWindow("SIFT_GPU_LITE", "SIFT_GPU", 0,    
                            CW_USEDEFAULT, CW_USEDEFAULT, 
                            100, 100, NULL, NULL, 0, 0);

        //move the window so that it can be on the second monitor
        if(x !=-1) 
        {
            MoveWindow(hWnd, x, y, 100, 100, 0);
            std::cout << "CreateWindow at (" << x << "," << y<<")\n";
        }

        PIXELFORMATDESCRIPTOR pfd = 
        {
            sizeof(PIXELFORMATDESCRIPTOR), 1, 
            PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL ,        
            PFD_TYPE_RGBA,16,0, 0, 0, 0, 0, 0, 0, 0, 
            0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0                     
        };
        hdc=GetDC(hWnd);
        int pixelformat = ChoosePixelFormat(hdc, &pfd);
        DescribePixelFormat(hdc, pixelformat, sizeof(pfd), &pfd);
        SetPixelFormat(hdc, pixelformat, &pfd);    
        hContext = wglCreateContext(hdc);

    }
    void MakeCurrent()
    {
        wglMakeCurrent(hdc, hContext);
    }
};

#else

#include <unistd.h>
#include <X11/Xlib.h>
#include <GL/glx.h>

class LiteWindow
{
    Display*     xDisplay;
    XVisualInfo* xVisual;    
    Window       xWin;
    GLXContext   xContext;
    Colormap     xColormap;
public:
    LiteWindow()
    {
        xDisplay = NULL;
        xVisual = NULL;
        xWin = 0;
        xColormap = 0;
        xContext = NULL;
    }
    int IsValid ()  
    {
        return xContext != NULL  && glXIsDirect(xDisplay, xContext);
    }
    virtual ~LiteWindow()
    {
        if(xWin) XDestroyWindow(xDisplay, xWin);
        if(xContext) glXDestroyContext(xDisplay, xContext);
        if(xColormap) XFreeColormap(xDisplay, xColormap);
        if(xDisplay) XCloseDisplay(xDisplay);
    }
    void Create(int x = 0, int y = 0, const char * display = NULL)
    {
        if(xDisplay) return;
        if(display) std::cout << "Using display ["<<display<<"]\n";

        //xDisplay = XOpenDisplay(display && display[0] ? display : NULL);
        if ( display == NULL )
          xDisplay = XOpenDisplay(NULL);
        else if ( display[0] != '\0' )
          xDisplay = XOpenDisplay(display);
        else
          xDisplay = XOpenDisplay(NULL);
        
        if(xDisplay == NULL) return;
        int attrib[] =  {GLX_RGBA, GLX_RED_SIZE, 1, 
                         GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1,  0 }; 
        xVisual = glXChooseVisual(xDisplay, DefaultScreen(xDisplay), attrib);
        if(xVisual == NULL) return;
        xColormap = XCreateColormap(
            xDisplay, RootWindow(xDisplay, xVisual->screen), 
            xVisual->visual, AllocNone);

        XSetWindowAttributes wa;
        wa.event_mask       = 0;
        wa.border_pixel     = 0;
        wa.colormap = xColormap;
           
        xWin = XCreateWindow( xDisplay, RootWindow(xDisplay, xVisual->screen) , 
                              x, y, 100, 100, 0, xVisual->depth, 
                              InputOutput, xVisual->visual, 
                              CWBorderPixel |CWColormap | CWEventMask, &wa);
            
        xContext = glXCreateContext(xDisplay, xVisual,  0, GL_TRUE); 
    }
    void MakeCurrent()
    {
        if(xContext) glXMakeCurrent(xDisplay, xWin, xContext);
    }
};

#endif


#endif