---

ImageWindow.cpp

#include <glow.h>

#include "ImageWindow.h"

void default_mouse_handler(Glow::MouseButton button,
                              int x, int y,
                              Glow::Modifiers modifiers, MouseActionType action) 
{
    if(action == MOUSE_DOWN){
        if(button == Glow::leftButton){
                cerr << "Left Mouse (" << x << ',' << y << ')' << endl;
        }     
        if(button == Glow::middleButton){
                cerr << "Middle Mouse (" << x << ',' << y << ')' << endl;;
        }                                                     
        if(button == Glow::rightButton){
                cerr << "Right Mouse (" << x << ',' << y << ')' << endl;
        }                                                     
    }
/*
    if(action == MOUSE_UP){
        if(button == Glow::leftButton){
                cerr << "Left Up " << x << ' ' << y << ' ';
        }
        if(button == Glow::middleButton){
                cerr << "Middle Up" << x << ' ' << y << ' ';
        }
        if(button == Glow::rightButton){
                cerr << "Right Up " << x << ' ' << y << ' ';
        }                                                    
    }
*/
}

void default_mouse_move_handler(int x, int y){}

void default_graphics_callback(GlowComponent* parent)
{
}


ImageWindow::ImageWindow(int w, int h, const char* title )
{
        GlowWindowParams wp;

        grab_display = false ;
        grab_display_grey = false ;
        graphics_callback = default_graphics_callback ;

        wp.width  = width  = w;
        wp.height = height = h;
        wp.title  = title;
        wp.eventMask = Glow::mouseEvents | Glow::motionEvents;

        scalefactor = 1;
        // allocate enough memory for greyscale and colour images
        size = width * height;
        data = new GLubyte[size * 3];
        data_bk = new GLubyte[size * 3];
//        data_grab = new GLubyte[size * 3];
        data_grab = new GLubyte[size * 4];

        type = Image::COLOUR;
        newContent = false;

        GlowWindow::Init(wp);

        mouse_press = default_mouse_handler ;
        mouse_move = default_mouse_move_handler ;
}                               

ImageWindow::~ImageWindow()
{
        delete [] data;
        delete [] data_bk;
}

void ImageWindow::OnMouseDown(Glow::MouseButton button,
                              int x, int y,
                              Glow::Modifiers modifiers)
{
        mouse_press(button,x,y,modifiers,MOUSE_DOWN);
}

void ImageWindow::OnMouseUp(Glow::MouseButton button,
                              int x, int y,
                              Glow::Modifiers modifiers)
{
        mouse_press(button,x,y,modifiers,MOUSE_UP);
}

void ImageWindow::OnMouseMotion(int x, int y)
{
        mouse_move(x,y);
}

void ImageWindow::OnEndPaint()
{
#if 0
        static int total = 0, framecount = 0;
        static int start = Glow::GetMilliseconds(), end;
        
        end = Glow::GetMilliseconds();
        total += end - start;
        if (total > 1000) {
                cerr << framecount << " : ";
                framecount = 0;
                total -= 1000;
        }               

        start = Glow::GetMilliseconds();
        framecount++;
#endif
#if 0
        if (newContent) {
                if (type == Image::COLOUR) {
                        repackRGB();
                } else {
                        repackGrey();
                }


                newContent = false;
        }
#endif
        if(size_changed){
          Reshape((int)(width*scalefactor),(int)(height*scalefactor));
          glPixelZoom(scalefactor,scalefactor);
          size_changed = false;
        }
        //So a none multiple of 4 width image is displayed properly (CJN)
        //Maybe should go in GLOW::Init(), but don't want to touch that! i
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);


        glRasterPos2d(-1,-1) ;

        if(type == Image::COLOUR)       
            glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, data);
        else
            glDrawPixels(width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);


        graphics_callback(this) ;

        Refresh();


        // Grab display to buffer (if requested)
        if(grab_display){
            grab_rgb() ;

            grab_display = false ;
        }

        // Grab display to grey (if requested)
        if(grab_display_grey){
            grab_grey() ;

            grab_display_grey = false ;
        }

}

void ImageWindow::grab_rgb()
{
    unsigned int sz, wdth, hgt ;

    wdth = (unsigned int)((double)width*scalefactor) ;
    hgt = (unsigned int)((double)height*scalefactor) ;
    sz = wdth * hgt ;

    glReadPixels(0,0, wdth, hgt,
                 GL_RGB, GL_UNSIGNED_BYTE, data_grab) ;

    GLubyte *d = data_grab + (sz - wdth) * 3 ;
    GLint   *p = gd_ptr;

    // GL expects the array to start at the bottom left,
    // but the data starts at the top left
    for(unsigned int i = 0; i < hgt; i++, d -= 6 * wdth)
    {
        for (unsigned int j = 0; j < wdth; j++)
        {
                *(p++) = *(d++);
                *(p++) = *(d++);
                *(p++) = *(d++);
         }
    }


    cerr << "Grabbing RGB" << endl ;
}

void ImageWindow::grab_grey()
{
    unsigned int sz, wdth, hgt ;

    wdth = (unsigned int)((double)width*scalefactor) ;
    hgt = (unsigned int)((double)height*scalefactor) ;
    sz = wdth * hgt ;

    glReadPixels(0,0, wdth, hgt,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, data_grab) ;

    GLubyte *d = data_grab + (sz - wdth) ;
    GLint   *p = gd_ptr;

    // GL expects the array to start at the bottom left,
    // but the data starts at the top left
    for(unsigned int i = 0; i < hgt; i++, d -= 2 * wdth)
    {
        for (unsigned int j = 0; j < wdth; j++)
        {
                *(p++) = *(d++) ;
        }
    }


    cerr << "Grabbing Grey" << endl ;
}


void ImageWindow::operator >> (ImageRGB& img)
/*
 * Grabs VISIBLE display to an image
 */
{
    grab_display = true ;
    gd_ptr = (int*)img.data ;

    while(grab_display) { }
}

void ImageWindow::operator >> (ImageGrey& img)
/*
 * Grabs VISIBLE display to a greyscale image
 */
{
    grab_display_grey = true ;
    gd_ptr = (int*)img.brightness ;

    while(grab_display_grey) { }
}


void ImageWindow::operator << (ImageRGB& img)
{
        GLubyte *tmp_ptr ; 

        pixels = (GLint *)img.data;
        type = Image::COLOUR;
        newContent = true;
        repackRGB();

        // Swap back and front buffer
        tmp_ptr = data_bk ;
        data_bk = data ;
        data = tmp_ptr ;
}


void ImageWindow::operator << (ImageGrey& img)
{
        GLubyte *tmp_ptr ; 

        pixels = (GLint*)img.brightness;
        type = Image::GREYSCALE;
        newContent = true;
        repackGrey();

        // Swap back and front buffer
        tmp_ptr = data_bk ;
        data_bk = data ;
        data = tmp_ptr ;
}


void ImageWindow::operator << (Image& img)
{       
        (type == Image::COLOUR)? *this << (ImageRGB&)img
                               : *this << (ImageGrey&)img;
        newContent = true;
}


void ImageWindow::repackRGB()
{
        GLubyte *d = data_bk + (size - width) * 3 ;
        GLint   *p = pixels;

        // GL expects the array to start at the bottom left,
        // but the data starts at the top left
        for(unsigned int i = 0; i < height; i++, d -= 6 * width)
        {
                for (unsigned int j = 0; j < width; j++)
                {
                        *(d++) = *(p++);
                        *(d++) = *(p++);
                        *(d++) = *(p++);
                }
        }
}


void ImageWindow::repackGrey()
{
        GLubyte *d = data_bk + size - width ;
        GLint   *p = pixels;

        // GL expects the array to start at the bottom left,
        // but the data starts at the top left
        for(unsigned int i = 0; i < height; i++, d -= 2 * width)
        {
                for (unsigned int j = 0; j < width; j++, d++, p++) 
                        *d = *p;
        }
}

void ImageWindow::set_zoom(float zoom)
{
        unsigned int sz ;
        GLubyte *new_d ;
        GLubyte *old_d ;

        scalefactor = zoom;
        size_changed = true;

        // Re-allocate memory (for screen grabbing purposes)
        sz = (unsigned int)(width*zoom) * (unsigned int)(height*zoom) ;

//        new_d = new GLubyte[sz * 3] ;
        new_d = new GLubyte[sz * 4] ;
        old_d = data_grab ;
        data_grab = new_d ;
        delete old_d ;
}

---