head	1.1;
access;
symbols;
locks
	ingo:1.1; strict;
comment	@ * @;


1.1
date	2002.11.11.18.43.59;	author ingo;	state Exp;
branches;
next	;


desc
@@


1.1
log
@Initial revision
@
text
@#include <stdio.h>
#include <assert.h>
#include <pthread.h>
#include <X11/Xlib.h>
#include <libguile.h>

// gdraw variables which give access to the window
Display*  gd_display = 0;
Window    gd_window;
Drawable  gd_drawable;
GC        gd_gc;
GC        gd_window_gc;
Visual*   gd_visual;
int       gd_screen;
XGCValues gd_gcv;
int       gd_init    = 0;
XSetWindowAttributes gd_attributes;
unsigned long gd_attributemask;
int       gd_use_doublebuffer = 0;
int       gd_width;
int       gd_height;

int       gd_mouse_x = 0;
int       gd_mouse_y = 0;

#define   GD_MAX_MOUSE_BUTTONS 10
int       gd_mouse_buttons[GD_MAX_MOUSE_BUTTONS];

pthread_t    gd_thread_id;
//struct pthread_attr gd_thread_attributes;

SCM gd_clear_screen ();
SCM gd_flip_screen ();

void* gd_event_loop (void* v)
{
  XEvent event;
  while (1) {
    XNextEvent (gd_display, &event);
    switch (event.type) {
    case MotionNotify:
      puts ("Motion event");
      printf ("%d %d\n", event.xmotion.x, event.xmotion.y);
      gd_mouse_x = event.xmotion.x;
      gd_mouse_y = event.xmotion.y;
      break;
    case ButtonPress:
      puts ("Button press");
      printf("%d\n", event.xbutton.button);
      gd_mouse_buttons[event.xbutton.button] = 1;
      break;
    case ButtonRelease:
      puts ("Button release");
      gd_mouse_buttons[event.xbutton.button] = 0;
      break;
    case KeyPress:
      puts ("key press");
      break;
    case KeyRelease:
      puts ("key release");
      break;
    case Expose:
      if (event.xexpose.count == 0)
        gd_flip_screen ();
      break;
    default:
      puts ("Unhandled event");
      break;
    }
  }
  return NULL;
}

SCM gdraw_hello_world ()
{
  puts ("Hello World");
  return SCM_UNSPECIFIED;
}

SCM gdraw_hello_world2 (SCM x, SCM y)
{
  printf ("Hello World: X=%d Y=%d\n", 
          scm_num2int (x, 1, "X Wrong"),
          scm_num2int (y, 2, "Y Worng"));
  return SCM_UNSPECIFIED;
}

SCM gd_init_screen (SCM s_width, SCM s_height, SCM s_doublebuffer)
{
  gd_width  = scm_num2int (s_width,  1, "init_screen");
  gd_height = scm_num2int (s_height, 2, "init_screen");
  gd_use_doublebuffer = SCM_NFALSEP(s_doublebuffer);

  gd_display = XOpenDisplay(NULL);
  gd_screen = DefaultScreen(gd_display);
  gd_visual= CopyFromParent;

  gd_attributes.background_pixel= WhitePixel(gd_display, gd_screen);
  gd_attributes.border_pixel = WhitePixel(gd_display, gd_screen);

  gd_attributes.event_mask = KeyPressMask|ExposureMask|PointerMotionMask|ButtonPressMask|ButtonReleaseMask|StructureNotifyMask;

  gd_attributemask = CWBackPixel|CWBorderPixel|CWEventMask;
  gd_window = XCreateWindow(gd_display, RootWindow(gd_display, gd_screen),
                            0,0, // position
                            gd_width, gd_height,0,
                            CopyFromParent, InputOutput, gd_visual, gd_attributemask,&gd_attributes);

  if (gd_use_doublebuffer)
    {
      puts ("Using double buffer");
      gd_drawable = XCreatePixmap (gd_display, gd_window, gd_width, gd_height, 
                                   DefaultDepth(gd_display, gd_screen));
    }
  else
    {
      gd_drawable = gd_window;
    }

  XMapRaised(gd_display, gd_window);

  gd_gcv.foreground = 0xFFFFFF;
  gd_gcv.background = 0x000000;
  
  gd_gc = XCreateGC(gd_display, gd_drawable, GCForeground, &gd_gcv);
  gd_window_gc = XCreateGC(gd_display, gd_window, GCForeground, &gd_gcv);

  gd_clear_screen ();
  XFlush(gd_display);

  pthread_create(&gd_thread_id, NULL,
                 &gd_event_loop, NULL);

  {
    int i;
    for (i = 0; i < GD_MAX_MOUSE_BUTTONS; ++i)
      gd_mouse_buttons[i] = 0;
  }

  gd_init = 1;
  return SCM_UNSPECIFIED;
}

SCM gd_clear_screen ()
{
  XSetForeground (gd_display, gd_gc, 0x000000);
  XFillRectangle (gd_display, gd_drawable, gd_gc, 0, 0, gd_width, gd_height);
  XSetForeground (gd_display, gd_gc, 0xFFFFFF);
  XFlush(gd_display);

  return SCM_UNSPECIFIED;
}

SCM gd_flip_screen ()
{
  if (gd_use_doublebuffer)
    {
      puts ("Flipping screen");
      if (1)
        {
          XCopyArea (gd_display, gd_drawable, gd_window, gd_window_gc,
                     0, 0, // source
                     gd_width, gd_height,
                     0, 0 // destination
                     );
          XFlush (gd_display);
        }
      else
        {
          XSetFillStyle(gd_display, gd_window_gc, FillTiled);
          XSetTile(gd_display, gd_window_gc, gd_drawable);
          XFillRectangle(gd_display, gd_window, gd_window_gc, 
                         0, 0, gd_width, gd_height);
          XFlush (gd_display);
        }
    }
  else
    {
      puts ("No flipscreen, since no doublebuffer");
    }
  
  return SCM_UNSPECIFIED;
}

SCM gd_set_fg_color (SCM s_color)
{
  int color = scm_num2int (s_color, 1, "gd_set_fg_color");
  assert (gd_init);
  XSetForeground(gd_display, gd_gc, color);
  return SCM_UNSPECIFIED;
}

SCM gd_get_mouse_x ()
{
  return SCM_MAKINUM(gd_mouse_x);
}

SCM gd_get_mouse_y ()
{
  return SCM_MAKINUM(gd_mouse_y);
}

SCM gd_get_mouse_button (SCM s_number)
{
  int number = scm_num2int (s_number, 1, "gd_get_mouse_button");
  if (number >= GD_MAX_MOUSE_BUTTONS)
    return SCM_BOOL_F;
  else
    return SCM_BOOL (gd_mouse_buttons[number]);
}

SCM gd_set_bg_color (SCM s_color)
{
  int color = scm_num2int (s_color, 1, "gd_set_bg_color");
  assert (gd_init);
  XSetBackground(gd_display, gd_gc, color);
  return SCM_UNSPECIFIED;
}

SCM gd_next_event ()
{
  XEvent event;
  XNextEvent (gd_display, &event);
  return SCM_UNSPECIFIED;
}

SCM gd_flush_screen ()
{
  XFlush (gd_display);
  return SCM_UNSPECIFIED;
}

SCM gd_sync_screen ()
{
  XSync (gd_display, 0);
  return SCM_UNSPECIFIED;
}

SCM gd_draw_rect (SCM s_x1, SCM s_y1, SCM s_width, SCM s_height, SCM s_fill)
{
  int x1     = scm_num2int (s_x1, 1, "gd_draw_rect");
  int y1     = scm_num2int (s_y1, 2, "gd_draw_rect");
  int width  = scm_num2int (s_width, 3, "gd_draw_rect");
  int height = scm_num2int (s_height, 4, "gd_draw_rect");
  int fill   = SCM_FALSEP (s_fill);

  if (fill)
    XDrawRectangle (gd_display, gd_drawable, gd_gc, x1, y1, width, height);
  else
    XFillRectangle (gd_display, gd_drawable, gd_gc, x1, y1, width, height);

  gd_flip_screen ();

  return SCM_UNSPECIFIED;
}

SCM gd_draw_line (SCM s_x1, SCM s_y1, SCM s_x2, SCM s_y2)
{
  int x1 = scm_num2int (s_x1, 1, "gd_draw_line");
  int y1 = scm_num2int (s_y1, 2, "gd_draw_line");
  int x2 = scm_num2int (s_x2, 3, "gd_draw_line");
  int y2 = scm_num2int (s_y2, 4, "gd_draw_line");

  assert (gd_init);

  XDrawLine (gd_display, gd_drawable, gd_gc, x1, y1, x2, y2);
  gd_flip_screen ();
  XFlush(gd_display);
  
  return SCM_UNSPECIFIED;
}

void init_gdraw ()
{
  scm_c_define_gsubr ("hello-world", 0, 0, 0, gdraw_hello_world);
  scm_c_define_gsubr ("hello-world2", 2, 0, 0, gdraw_hello_world2);

  scm_c_define_gsubr ("init-screen", 3, 0, 0, gd_init_screen);

  scm_c_define_gsubr ("draw-line",   4, 0, 0, gd_draw_line);
  scm_c_define_gsubr ("draw-rect",   4, 1, 0, gd_draw_rect);

  scm_c_define_gsubr ("set-fg-color",   1, 0, 0, gd_set_fg_color); 
  scm_c_define_gsubr ("set-bg-color",   1, 0, 0, gd_set_bg_color); 
  scm_c_define_gsubr ("flush-screen",   0, 0, 0, gd_flush_screen); 
  scm_c_define_gsubr ("sync-screen",   0, 0, 0, gd_sync_screen); 
  scm_c_define_gsubr ("next-event",     0, 0, 0, gd_next_event); 
  scm_c_define_gsubr ("flip-screen",    0, 0, 0, gd_flip_screen); 
  scm_c_define_gsubr ("clear-screen",    0, 0, 0, gd_clear_screen); 

  scm_c_define_gsubr ("mouse:get-x", 0, 0, 0, gd_get_mouse_x);
  scm_c_define_gsubr ("mouse:get-y", 0, 0, 0, gd_get_mouse_y);
  scm_c_define_gsubr ("mouse:get-button", 1, 0, 0, gd_get_mouse_button);
}

int main ()
{
  scm_init_guile ();

  init_gdraw ();
  
  scm_shell (0, NULL);
  return 0;
}

/* EOF */
@