gui.c

Go to the documentation of this file.

/* This code is (C) AllegroGL contributors, and double licensed under
 * the GPL and zlib licenses. See gpl.txt or zlib.txt for details.
 */
#include "alleggl.h"
#include "allglint.h"

#include <allegro/internal/aintern.h>


static struct {
    GLuint texture;
    int hidden;
    int xfocus;
    int yfocus;
    int width;
    int height;
} allegro_gl_mouse = { 0, TRUE, 0, 0, 0, 0};


int algl_do_dialog (DIALOG *dialog, int focus_obj)
{
    DIALOG_PLAYER *player;

    AGL_LOG(2, "allegro_gl_do_dialog\n");

    /* Allegro GUI routines generally use the 2D gfx functions therefore
       we set default behaviour to allegro_gl_set_allegro_mode so that we
       can use the GUI functions "as is" */
    allegro_gl_set_allegro_mode();

    player = init_dialog (dialog, focus_obj);
    show_mouse(screen);

    /* Nothing to do here.
     * Redrawing is done from d_algl_viewport_proc() callback. */
    while (update_dialog (player)) {}

    show_mouse(NULL);
    /* restore previous projection matrices */
    allegro_gl_unset_allegro_mode();

    return shutdown_dialog (player);
}



int algl_popup_dialog (DIALOG *dialog, int focus_obj)
{
    void *backdrop;
    DIALOG_PLAYER *player;
    GLint read_buffer;

    AGL_LOG(2, "allegro_gl_popup_dialog\n");

    /* Allegro GUI routines generally use the 2D gfx functions therefore
       we set default behaviour to allegro_gl_set_allegro_mode so that we
       can use the GUI functions "as is" */
    allegro_gl_set_allegro_mode();

    glGetIntegerv(GL_READ_BUFFER, &read_buffer);
    glReadBuffer (GL_FRONT); /* TODO: don't clobber */
    glDisable(GL_DEPTH_TEST);
    backdrop = malloc (SCREEN_W * SCREEN_H * 3 * 4);
    glReadPixels (0, 0, SCREEN_W, SCREEN_H, GL_RGB, GL_UNSIGNED_BYTE, backdrop);
    glReadBuffer(read_buffer);

    player = init_dialog (dialog, focus_obj);
    show_mouse(screen);

    while (update_dialog (player)) {

        /* Redraw the GUI every frame */
        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glRasterPos2f (0., SCREEN_H-.5); /* TODO: don't clobber */
        glDrawPixels (SCREEN_W, SCREEN_H, GL_RGB, GL_UNSIGNED_BYTE, backdrop);
        broadcast_dialog_message (MSG_DRAW, 0);

        /* Draw the mouse cursor */
        algl_draw_mouse();

        /* Flip buffers */
        allegro_gl_flip();
    }

    glRasterPos2f (0., SCREEN_H-.5); /* TODO: don't clobber */
    glDrawPixels (SCREEN_W, SCREEN_H, GL_RGB, GL_UNSIGNED_BYTE, backdrop);
    glEnable(GL_DEPTH_TEST);
    free (backdrop);

    show_mouse(NULL);
    /* restore previous projection matrices */
    allegro_gl_unset_allegro_mode();

    return shutdown_dialog (player);
}



/* User mouse drawing callback */
static void (*__algl_user_draw_mouse)(void) = NULL;


void algl_draw_mouse (void)
{
    AGL_LOG(2, "allegro_gl_draw_mouse\n");

    /* don't draw the mouse if it's not in our window */
    if (!_mouse_on || allegro_gl_mouse.hidden) return;

    if (__algl_user_draw_mouse) {

        __algl_user_draw_mouse();

    } else {

#if 0
        float x = mouse_x;
        float y = mouse_y;

        int depth_enabled = glIsEnabled (GL_DEPTH_TEST);
        int cull_enabled = glIsEnabled (GL_CULL_FACE);
        if (depth_enabled) glDisable (GL_DEPTH_TEST);
        if (cull_enabled) glDisable (GL_CULL_FACE);

        glBegin (GL_TRIANGLES);

            #define draw(dx,dy) \
                glVertex2f (x + dx, y + dy); \
                glVertex2f (x + dx, y + dy + 10); \
                glVertex2f (x + dx + 7, y + dy + 7); \
                glVertex2f (x + dx + 1.5, y + dy + 6); \
                glVertex2f (x + dx + 5.5, y + dy + 14); \
                glVertex2f (x + dx + 7.5, y + dy + 14); \
                glVertex2f (x + dx + 3.5, y + dy + 6); \
                glVertex2f (x + dx + 1.5, y + dy + 6); \
                glVertex2f (x + dx + 7.5, y + dy + 14);

            glColor3f (0, 0, 0);
            draw(-1,0)
            draw(1,0)
            draw(0,-1)
            draw(0,1)

            glColor3f (1, 1, 1);
            draw(0,0)

            #undef draw

        glEnd();

        if (depth_enabled) glEnable (GL_DEPTH_TEST);
        if (cull_enabled) glEnable (GL_CULL_FACE);
#endif

        int x = mouse_x - allegro_gl_mouse.xfocus;
        int y = mouse_y - allegro_gl_mouse.yfocus;
    
        glPushAttrib(GL_COLOR_BUFFER_BIT);
        glAlphaFunc(GL_GREATER, 0.5);
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_ALPHA_TEST);

        glBindTexture(GL_TEXTURE_2D, allegro_gl_mouse.texture);
        glColor4f(1., 1., 1., 1.);
        glTranslatef(-0.375, -0.375, 0);
        glBegin(GL_QUADS);
            glTexCoord2f(0., 1.);
            glVertex2f(x, y);
            glTexCoord2f(0., 0.);
            glVertex2f(x, y + allegro_gl_mouse.height);
            glTexCoord2f(1., 0.);
            glVertex2f(x + allegro_gl_mouse.width, y + allegro_gl_mouse.height);
            glTexCoord2f(1., 1.);
            glVertex2f(x + allegro_gl_mouse.width, y);
        glEnd();
        glTranslatef(0.375, 0.375, 0);
        glPopAttrib();
        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);
    }
}


void algl_set_mouse_drawer (void (*user_draw_mouse)(void))
{
    AGL_LOG(2, "allegro_gl_set_mouse_drawer\n");

    __algl_user_draw_mouse = user_draw_mouse;
}





static DIALOG alert_dialog[] =
{
   /* (dialog proc)        (x)   (y)   (w)   (h)   (fg)  (bg)  (key) (flags)  (d1)  (d2)  (dp)  (dp2) (dp3) */
   { _gui_shadow_box_proc, 0,    0,    0,    0,    0,    0,    0,    0,       0,    0,    NULL, NULL, NULL  },
   { _gui_ctext_proc,      0,    0,    0,    0,    0,    0,    0,    0,       0,    0,    NULL, NULL, NULL  },
   { _gui_ctext_proc,      0,    0,    0,    0,    0,    0,    0,    0,       0,    0,    NULL, NULL, NULL  },
   { _gui_ctext_proc,      0,    0,    0,    0,    0,    0,    0,    0,       0,    0,    NULL, NULL, NULL  },
   { _gui_button_proc,     0,    0,    0,    0,    0,    0,    0,    D_EXIT,  0,    0,    NULL, NULL, NULL  },
   { _gui_button_proc,     0,    0,    0,    0,    0,    0,    0,    D_EXIT,  0,    0,    NULL, NULL, NULL  },
   { _gui_button_proc,     0,    0,    0,    0,    0,    0,    0,    D_EXIT,  0,    0,    NULL, NULL, NULL  },
   { d_yield_proc,         0,    0,    0,    0,    0,    0,    0,    0,       0,    0,    NULL, NULL, NULL  },
   { NULL,                 0,    0,    0,    0,    0,    0,    0,    0,       0,    0,    NULL, NULL, NULL  }
};


#define A_S1  1
#define A_S2  2
#define A_S3  3
#define A_B1  4
#define A_B2  5
#define A_B3  6



int algl_alert3(AL_CONST char *s1, AL_CONST char *s2, AL_CONST char *s3, AL_CONST char *b1, AL_CONST char *b2, AL_CONST char *b3, int c1, int c2, int c3)
{
   char tmp[16];
   int avg_w, avg_h;
   int len1, len2, len3;
   int maxlen = 0;
   int buttons = 0;
   int b[3];
   int c;

   AGL_LOG(2, "allegro_gl_alert3\n");

   #define SORT_OUT_BUTTON(x) {                                            \
      if (b##x) {                                                          \
     alert_dialog[A_B##x].flags &= ~D_HIDDEN;                          \
     alert_dialog[A_B##x].key = c##x;                                  \
     alert_dialog[A_B##x].dp = (char *)b##x;                           \
     len##x = gui_strlen(b##x);                                        \
     b[buttons++] = A_B##x;                                            \
      }                                                                    \
      else {                                                               \
     alert_dialog[A_B##x].flags |= D_HIDDEN;                           \
     len##x = 0;                                                       \
      }                                                                    \
   }

   usetc(tmp+usetc(tmp, ' '), 0);

   avg_w = text_length(font, tmp);
   avg_h = text_height(font);

   alert_dialog[A_S1].dp = alert_dialog[A_S2].dp = alert_dialog[A_S3].dp = 
   alert_dialog[A_B1].dp = alert_dialog[A_B2].dp = empty_string;

   if (s1) {
      alert_dialog[A_S1].dp = (char *)s1;
      maxlen = text_length(font, s1);
   }

   if (s2) {
      alert_dialog[A_S2].dp = (char *)s2;
      len1 = text_length(font, s2);
      if (len1 > maxlen)
     maxlen = len1;
   }

   if (s3) {
      alert_dialog[A_S3].dp = (char *)s3;
      len1 = text_length(font, s3);
      if (len1 > maxlen)
     maxlen = len1;
   }

   SORT_OUT_BUTTON(1);
   SORT_OUT_BUTTON(2);
   SORT_OUT_BUTTON(3);

   len1 = MAX(len1, MAX(len2, len3)) + avg_w*3;
   if (len1*buttons > maxlen)
      maxlen = len1*buttons;

   maxlen += avg_w*4;
   alert_dialog[0].w = maxlen;
   alert_dialog[A_S1].x = alert_dialog[A_S2].x = alert_dialog[A_S3].x = 
                        alert_dialog[0].x + maxlen/2;

   alert_dialog[A_B1].w = alert_dialog[A_B2].w = alert_dialog[A_B3].w = len1;

   alert_dialog[A_B1].x = alert_dialog[A_B2].x = alert_dialog[A_B3].x = 
                       alert_dialog[0].x + maxlen/2 - len1/2;

   if (buttons == 3) {
      alert_dialog[b[0]].x = alert_dialog[0].x + maxlen/2 - len1*3/2 - avg_w;
      alert_dialog[b[2]].x = alert_dialog[0].x + maxlen/2 + len1/2 + avg_w;
   }
   else if (buttons == 2) {
      alert_dialog[b[0]].x = alert_dialog[0].x + maxlen/2 - len1 - avg_w;
      alert_dialog[b[1]].x = alert_dialog[0].x + maxlen/2 + avg_w;
   }

   alert_dialog[0].h = avg_h*8;
   alert_dialog[A_S1].y = alert_dialog[0].y + avg_h;
   alert_dialog[A_S2].y = alert_dialog[0].y + avg_h*2;
   alert_dialog[A_S3].y = alert_dialog[0].y + avg_h*3;
   alert_dialog[A_S1].h = alert_dialog[A_S2].h = alert_dialog[A_S3].h = avg_h;
   alert_dialog[A_B1].y = alert_dialog[A_B2].y = alert_dialog[A_B3].y = alert_dialog[0].y + avg_h*5;
   alert_dialog[A_B1].h = alert_dialog[A_B2].h = alert_dialog[A_B3].h = avg_h*2;

   centre_dialog(alert_dialog);
   set_dialog_color(alert_dialog, gui_fg_color, gui_bg_color);
   for (c = 0; alert_dialog[c].proc; c++)
      if (alert_dialog[c].proc == _gui_ctext_proc)
     alert_dialog[c].bg = -1;

   clear_keybuf();

   do {
   } while (gui_mouse_b());

   c = algl_popup_dialog(alert_dialog, A_B1);

   if (c == A_B1)
      return 1;
   else if (c == A_B2)
      return 2;
   else
      return 3;
}



int algl_alert(AL_CONST char *s1, AL_CONST char *s2, AL_CONST char *s3, AL_CONST char *b1, AL_CONST char *b2, int c1, int c2)
{
   int ret;

   AGL_LOG(2, "allegro_gl_alert\n");

   ret = algl_alert3(s1, s2, s3, b1, b2, NULL, c1, c2, 0);

   if (ret > 2)
      ret = 2;

   return ret;
}



int d_algl_viewport_proc(int msg, DIALOG *d, int c)
{
    int ret = D_O_K;
    typedef int (*_callback)(BITMAP*, int, int);
    _callback callback = (_callback) d->dp;
    BITMAP *viewport = create_sub_bitmap(screen, d->x, d->y, d->w, d->h);

    AGL_LOG(3, "d_algl_viewport_proc\n");

    /* First we get back into a 3D mode */
    allegro_gl_unset_allegro_mode();

    if (msg == MSG_DRAW) {
        /* Draws the background */
        clear_to_color(viewport, d->bg);
    }

    /* Save the Viewport and Scissor states */
    glPushAttrib(GL_SCISSOR_BIT | GL_VIEWPORT_BIT);

    /* Adapt the viewport to the object size */
    glViewport(d->x, SCREEN_H - d->y - d->h, d->w, d->h);
    glScissor(d->x, SCREEN_H - d->y - d->h, d->w, d->h);
    glEnable(GL_SCISSOR_TEST);
    
    /* Clear the depth buffer for this scissor region */
    if (msg == MSG_DRAW) {
        glClear(GL_DEPTH_BUFFER_BIT);
    }

    /* Call the callback function */
    if (callback)
        ret = callback(viewport, msg, c);

    /* Restore the previous state */
    glPopAttrib();
    allegro_gl_set_allegro_mode();
    destroy_bitmap(viewport);

    /* Redraw the GUI every frame */
    if (msg == MSG_IDLE) {
        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        broadcast_dialog_message (MSG_DRAW, 0);

        /* Draw the mouse cursor */
        algl_draw_mouse();

        /* Flip buffers */
        allegro_gl_flip();
    }


    return ret;
}



/*****************/
/* Mouse manager */
/*****************/

int allegro_gl_set_mouse_sprite(BITMAP *sprite, int xfocus, int yfocus)
{
    BITMAP *bmp = NULL;
    GLint old_texture;
    
    AGL_LOG(2, "allegro_gl_set_mouse_sprite\n");

    glGetIntegerv(GL_TEXTURE_2D_BINDING, &old_texture);

    bmp = create_bitmap_ex(bitmap_color_depth(sprite),
             __allegro_gl_make_power_of_2(sprite->w),
             __allegro_gl_make_power_of_2(sprite->h));

    if (allegro_gl_mouse.texture) {
        glDeleteTextures(1, &allegro_gl_mouse.texture);
        allegro_gl_mouse.texture = 0;
    }
    
    clear_to_color(bmp, bitmap_mask_color(sprite));
    blit(sprite, bmp, 0, 0, 0, 0, sprite->w, sprite->h);
#ifdef DEBUGMODE
    save_bmp("mcursor.bmp",bmp,NULL);
#endif

    allegro_gl_mouse.texture = allegro_gl_make_texture_ex(AGL_TEXTURE_RESCALE
                            | AGL_TEXTURE_MASKED | AGL_TEXTURE_FLIP, bmp, -1);
    if (!allegro_gl_mouse.texture) {
        destroy_bitmap(bmp);
        return -1;
    }

    glBindTexture(GL_TEXTURE_2D, allegro_gl_mouse.texture);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    
    if (allegro_gl_extensions_GL.SGIS_texture_edge_clamp) {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    }
    else {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    }

    glBindTexture(GL_TEXTURE_2D, old_texture);

    allegro_gl_mouse.width  = bmp->w;
    allegro_gl_mouse.height = bmp->h;
    allegro_gl_mouse.xfocus = xfocus;
    allegro_gl_mouse.yfocus = yfocus;

    destroy_bitmap(bmp);
    return 0;
}



int allegro_gl_show_mouse(BITMAP* bmp, int x, int y)
{
    AGL_LOG(3, "allegro_gl_show_mouse\n");
    allegro_gl_mouse.hidden = FALSE;
    return 0;
}



void allegro_gl_hide_mouse(void)
{
    AGL_LOG(3, "allegro_gl_hide_mouse\n");
    allegro_gl_mouse.hidden = TRUE;
}



void allegro_gl_move_mouse(int x, int y)
{
    AGL_LOG(3, "allegro_gl_move_mouse\n");
    /* This function is not called from the main thread, so
     * we must not call any OpenGL command there !!!
     */
}

---