[openvrml-commit] openvrml/lib/gtkglext/examples .cvsignore, NONE, 1.2.2.1 Makefile.am, NONE, 1.1.1

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/openvrml/openvrml/lib/gtkglext/examples
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv7146/lib/gtkglext/examples

Added Files:
      Tag: OpenVRML-0_16-BRANCH
	.cvsignore Makefile.am Makefile.mingw Makefile.msc alien.lwo 
	button.c color.c coolwave.c coolwave2.c font-pangoft2-tex.c 
	font-pangoft2.c font.c gears.c girl.rgb glxinfo.c logo-g.c 
	logo-k.c logo-model.c logo-model.h logo-t.c logo.c low-level.c 
	lw.c lw.h multiarb.c penguin.lwo pixmap-mixed.c pixmap.c 
	readtex.c readtex.h reflect.rgb rotating-square.c 
	scribble-gl.c shapes.c share-lists.c simple-mixed.c 
	simple-pbuffer-sgix.c simple.c template.c trackball.c 
	trackball.h viewlw.c wglinfo.c 
Log Message:
Build/package the GtkPlug application separately from the Mozilla plug-in.  The Mozilla plug-in is just one possible client for this application.

--- NEW FILE: rotating-square.c ---
/**************************************************************************
 * rotatingSquare.c
 *
 * Copyright (c) 2002 Alif Wahid <aw...@us...>
 *
 * A simple animation to demonstrate GtkGLExt.
 *
 * This program is in the public domain and you are using it at
 * your own risk.
 *
 **************************************************************************/

/* 
 * Modified by Naofumi Yasufuku  <na...@us...>
 */

/**************************************************************************
 * Header file inclusions.
 **************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include <gtk/gtkgl.h>
/*** Use OpenGL extensions. ***/
/* #include <gdk/gdkglglext.h> */

#ifdef G_OS_WIN32
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif

#include <GL/gl.h>
#include <GL/glu.h>

/**************************************************************************
 * The following section contains all the macro definitions.
 **************************************************************************/

#define DEFAULT_WIDTH  200
#define DEFAULT_HEIGHT 200
#define DEFAULT_TITLE  "Rotating Square"

/**************************************************************************
 * Global variable declarations.
 **************************************************************************/

static gboolean animate = TRUE;

static float spin = 0.0;

/**************************************************************************
 * The following section contains the function prototype declarations.
 **************************************************************************/

static void         idle_add          (GtkWidget   *widget);
static void         idle_remove       (GtkWidget   *widget);

static void         toggle_animation  (GtkWidget   *widget);

static GdkGLConfig *configure_gl      (void);

static GtkWidget   *create_popup_menu (GtkWidget   *drawing_area);
static GtkWidget   *create_window     (GdkGLConfig *glconfig);

/**************************************************************************
 * The following section contains all the callback function definitions.
 **************************************************************************/

/***
 *** The "realize" signal handler. All the OpenGL initialization
 *** should be performed here, such as default background colour,
 *** certain states etc.
 ***/
static void
realize (GtkWidget *widget,
	 gpointer   data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return;

  glClearColor (0.0, 0.0, 0.0, 0.0);
  glShadeModel (GL_FLAT);

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return;
}

/***
 *** The "configure_event" signal handler. Any processing required when
 *** the OpenGL-capable drawing area is re-configured should be done here.
 *** Almost always it will be used to resize the OpenGL viewport when
 *** the window is resized.
 ***/
static gboolean
configure_event (GtkWidget         *widget,
		 GdkEventConfigure *event,
		 gpointer           data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  GLfloat w = widget->allocation.width;
  GLfloat h = widget->allocation.height;

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return FALSE;

  glViewport (0, 0, (GLsizei) w, (GLsizei) h);
  glMatrixMode (GL_PROJECTION);
  glLoadIdentity ();
  glOrtho (-50.0, 50.0, -50.0, 50.0, -1.0, 1.0);
  glMatrixMode (GL_MODELVIEW);
  glLoadIdentity ();

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return TRUE;
}

/***
 *** The "expose_event" signal handler. All the OpenGL re-drawing should
 *** be done here. This is repeatedly called as the painting routine
 *** every time the 'expose'/'draw' event is signalled.
 ***/
static gboolean
expose_event (GtkWidget      *widget,
	      GdkEventExpose *event,
	      gpointer        data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return FALSE;

  glClear (GL_COLOR_BUFFER_BIT);

  glPushMatrix ();
    glRotatef (spin, 0.0, 0.0, 1.0);
    glColor3f (1.0, 1.0, 1.0);
    glRectf (-25.0, -25.0, 25.0, 25.0);
  glPopMatrix ();

  /* Swap buffers */
  if (gdk_gl_drawable_is_double_buffered (gldrawable))
    gdk_gl_drawable_swap_buffers (gldrawable);
  else
    glFlush ();

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return TRUE;
}

/***
 *** The idle function. Often in animations,
 *** idle functions are suitable for continous
 *** frame updates.
 ***/
static gboolean
idle (GtkWidget *widget)
{
  spin += 2.0;
  if (spin > 360.0) spin -= 360.0;

  /* Invalidate the whole window. */
  gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);

  /* Update synchronously. */
  gdk_window_process_updates (widget->window, FALSE);

  return TRUE;
}

/***
 *** The "motion_notify_event" signal handler. Any processing required when
 *** the OpenGL-capable drawing area is under drag motion should be done here.
 ***/
static gboolean
motion_notify_event (GtkWidget      *widget,
		     GdkEventMotion *event,
		     gpointer        data)
{

  /*** Fill in the details here. ***/

  return FALSE;
}

/***
 *** The "button_press_event" signal handler. Any processing required when
 *** mouse buttons (only left and middle buttons) are pressed on the OpenGL-
 *** capable drawing area should be done here.
 ***/
static gboolean
button_press_event (GtkWidget      *widget,
		    GdkEventButton *event,
		    gpointer        data)
{
  /* Starts/Stops animation according mouse button clicks.*/
  if (event->button == 1)
    {
      toggle_animation (widget);
      return TRUE;
    }

  return FALSE;
}

/* For popup menu. */
static gboolean
button_press_event_popup_menu (GtkWidget      *widget,
			       GdkEventButton *event,
			       gpointer        data)
{
  if (event->button == 3)
    {
      /* Popup menu. */
      gtk_menu_popup (GTK_MENU (widget), NULL, NULL, NULL, NULL,
		      event->button, event->time);
      return TRUE;
    }

  return FALSE;
}

/***
 *** The "key_press_event" signal handler. Any processing required when key
 *** presses occur should be done here.
 ***/
static gboolean
key_press_event (GtkWidget   *widget,
		 GdkEventKey *event,
		 gpointer     data)
{
  switch (event->keyval)
    {
    case GDK_Left:
      /* Rotate left. */
      if (!animate)
	{
	  spin += 2.0;
	  if (spin > 360.0) spin -= 360.0;
	  gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
	}
      break;

    case GDK_Right:
      /* Rotate right. */
      if (!animate)
	{
	  spin -= 2.0;
	  if (spin < 360.0) spin += 360.0;
	  gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
	}
      break;

    case GDK_a:
      /* Toggle animation. */
      toggle_animation (widget);
      break;

    case GDK_Escape:
      /* Quit. */
      gtk_main_quit ();
      break;

    default:
      return FALSE;
    }

  return TRUE;
}

/***
 *** The "unrealize" signal handler. Any processing required when
 *** the OpenGL-capable window is unrealized should be done here.
 ***/
static void
unrealize (GtkWidget *widget,
	   gpointer   data)
{

  /*** Fill in the details here ***/

}

/**************************************************************************
 * The following section contains the idle function management routines.
 **************************************************************************/

/***
 *** Helper functions to add or remove the idle function.
 ***/

static guint idle_id = 0;

static void
idle_add (GtkWidget *widget)
{
  if (idle_id == 0)
    {
      idle_id = g_idle_add_full (GDK_PRIORITY_REDRAW,
                                 (GSourceFunc) idle,
                                 widget,
                                 NULL);
    }
}

static void
idle_remove (GtkWidget *widget)
{
  if (idle_id != 0)
    {
      g_source_remove (idle_id);
      idle_id = 0;
    }
}

/***
 *** The "map_event" signal handler. Any processing required when the
 *** OpenGL-capable drawing area is mapped should be done here.
 ***/
static gboolean
map_event (GtkWidget *widget,
	   GdkEvent  *event,
	   gpointer   data)
{
  if (animate)
    idle_add (widget);

  return TRUE;
}

/***
 *** The "unmap_event" signal handler. Any processing required when the
 *** OpenGL-capable drawing area is unmapped should be done here.
 ***/
static gboolean
unmap_event (GtkWidget *widget,
	     GdkEvent  *event,
	     gpointer   data)
{
  idle_remove (widget);

  return TRUE;
}

/***
 *** The "visibility_notify_event" signal handler. Any processing required
 *** when the OpenGL-capable drawing area is visually obscured should be
 *** done here.
 ***/
static gboolean
visibility_notify_event (GtkWidget          *widget,
			 GdkEventVisibility *event,
			 gpointer            data)
{
  if (animate)
    {
      if (event->state == GDK_VISIBILITY_FULLY_OBSCURED)
	idle_remove (widget);
      else
	idle_add (widget);
    }

  return TRUE;
}

/**************************************************************************
 * The following section contains some miscellaneous utility functions.
 **************************************************************************/

/***
 *** Toggle animation.
 ***/
static void
toggle_animation (GtkWidget *widget)
{
  animate = !animate;

  if (animate)
    {
      idle_add (widget);
    }
  else
    {
      idle_remove (widget);
      gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
    }
}

/**************************************************************************
 * The following section contains the GUI building function definitions.
 **************************************************************************/

/***
 *** Creates the popup menu to be displayed.
 ***/
static GtkWidget *
create_popup_menu (GtkWidget *drawing_area)
{
  GtkWidget *menu;
  GtkWidget *menu_item;

  menu = gtk_menu_new ();

  /* Toggle animation */
  menu_item = gtk_menu_item_new_with_label ("Toggle Animation");
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
  g_signal_connect_swapped (G_OBJECT (menu_item), "activate",
			    G_CALLBACK (toggle_animation), drawing_area);
  gtk_widget_show (menu_item);

  /* Quit */
  menu_item = gtk_menu_item_new_with_label ("Quit");
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
  g_signal_connect (G_OBJECT (menu_item), "activate",
		    G_CALLBACK (gtk_main_quit), NULL);
  gtk_widget_show (menu_item);

  return menu;
}

/***
 *** Creates the simple application window with one
 *** drawing area that has an OpenGL-capable visual.
 ***/
static GtkWidget *
create_window (GdkGLConfig *glconfig)
{
  GtkWidget *window;
  GtkWidget *vbox;
  GtkWidget *drawing_area;
  GtkWidget *menu;
  GtkWidget *button;

  /*
   * Top-level window.
   */

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), DEFAULT_TITLE);

  /* Get automatically redrawn if any of their children changed allocation. */
  gtk_container_set_reallocate_redraws (GTK_CONTAINER (window), TRUE);

  /* Connect signal handlers to the window */
  g_signal_connect (G_OBJECT (window), "delete_event",
		    G_CALLBACK (gtk_main_quit), NULL);

  /*
   * VBox.
   */

  vbox = gtk_vbox_new (FALSE, 0);
  gtk_container_add (GTK_CONTAINER (window), vbox);
  gtk_widget_show (vbox);

  /*
   * Drawing area to draw OpenGL scene.
   */

  drawing_area = gtk_drawing_area_new ();
  gtk_widget_set_size_request (drawing_area, DEFAULT_WIDTH, DEFAULT_HEIGHT);

  /* Set OpenGL-capability to the widget */
  gtk_widget_set_gl_capability (drawing_area,
				glconfig,
				NULL,
				TRUE,
				GDK_GL_RGBA_TYPE);

  gtk_widget_add_events (drawing_area,
			 GDK_BUTTON1_MOTION_MASK    |
			 GDK_BUTTON2_MOTION_MASK    |
			 GDK_BUTTON_PRESS_MASK      |
			 GDK_VISIBILITY_NOTIFY_MASK);

  /* Connect signal handlers to the drawing area */
  g_signal_connect_after (G_OBJECT (drawing_area), "realize",
                          G_CALLBACK (realize), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "configure_event",
		    G_CALLBACK (configure_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "expose_event",
		    G_CALLBACK (expose_event), NULL);

  g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event",
		    G_CALLBACK (motion_notify_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "button_press_event",
		    G_CALLBACK (button_press_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "unrealize",
		    G_CALLBACK (unrealize), NULL);

  /* key_press_event handler for top-level window */
  g_signal_connect_swapped (G_OBJECT (window), "key_press_event",
			    G_CALLBACK (key_press_event), drawing_area);

  /* For idle function. */
  g_signal_connect (G_OBJECT (drawing_area), "map_event",
		    G_CALLBACK (map_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "unmap_event",
		    G_CALLBACK (unmap_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "visibility_notify_event",
		    G_CALLBACK (visibility_notify_event), NULL);

  gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);

  gtk_widget_show (drawing_area);

  /*
   * Popup menu.
   */

  menu = create_popup_menu (drawing_area);

  g_signal_connect_swapped (G_OBJECT (drawing_area), "button_press_event",
			    G_CALLBACK (button_press_event_popup_menu), menu);

  /*
   * Simple quit button.
   */

  button = gtk_button_new_with_label ("Quit");

  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (gtk_main_quit), NULL);

  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

  gtk_widget_show (button);

  return window;
}

/**************************************************************************
 * The following section contains utility function definitions.
 **************************************************************************/

/***
 *** Configure the OpenGL framebuffer.
 ***/
static GdkGLConfig *
configure_gl (void)
{
  GdkGLConfig *glconfig;

  /* Try double-buffered visual */
  glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB    |
					GDK_GL_MODE_DEPTH  |
					GDK_GL_MODE_DOUBLE);
  if (glconfig == NULL)
    {
      g_print ("\n*** Cannot find the double-buffered visual.\n");
      g_print ("\n*** Trying single-buffered visual.\n");

      /* Try single-buffered visual */
      glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB   |
					    GDK_GL_MODE_DEPTH);
      if (glconfig == NULL)
	{
	  g_print ("*** No appropriate OpenGL-capable visual found.\n");
	  exit (1);
	}
    }

  return glconfig;
}

/**************************************************************************
 * The main function is rather trivial.
 **************************************************************************/

int
main (int   argc,
      char *argv[])
{
  GtkWidget *window;
  GdkGLConfig *glconfig;

  /* Initialize GTK. */
  gtk_init (&argc, &argv);

  /* Initialize GtkGLExt. */
  gtk_gl_init (&argc, &argv);

  /* Configure OpenGL framebuffer. */
  glconfig = configure_gl ();

  /* Create and show the application window. */
  window = create_window (glconfig);
  gtk_widget_show (window);

  gtk_main ();

  return 0;
}

/**************************************************************************
 * End of file.
 **************************************************************************/

--- NEW FILE: viewlw.c ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: logo-t.c ---
/*
 * AC3D triangle data
 */

/* "T" */

#define LOGO_T_V_SIZE 28

static GLfloat logo_t_v[LOGO_T_V_SIZE][3][3] = {
  { { 0.672290, -3.400000, 7.600000 }, { -0.496390, 2.769170, 7.600000 }, { -0.496390, -3.400000, 7.600000 } },
  { { -0.496390, 2.769170, 7.600000 }, { -3.400000, 3.600000, 7.600000 }, { -3.400000, 2.769170, 7.600000 } },
  { { -3.400000, 3.600000, 7.600000 }, { -0.496390, 2.769170, 7.600000 }, { 3.600000, 3.600000, 7.600000 } },
  { { 3.600000, 3.600000, 7.600000 }, { -0.496390, 2.769170, 7.600000 }, { 0.672290, 2.769170, 7.600000 } },
  { { 0.672290, 2.769170, 7.600000 }, { -0.496390, 2.769170, 7.600000 }, { 0.672290, -3.400000, 7.600000 } },
  { { 3.600000, 3.600000, 7.600000 }, { 0.672290, 2.769170, 7.600000 }, { 3.600000, 2.769170, 7.600000 } },
  { { 3.600000, 3.600000, 8.350000 }, { -3.400000, 2.769170, 8.350000 }, { -3.400000, 3.600000, 8.350000 } },
  { { -3.400000, 2.769170, 8.350000 }, { 3.600000, 3.600000, 8.350000 }, { -0.496390, 2.769170, 8.350000 } },
  { { -0.496390, 2.769170, 8.350000 }, { 3.600000, 3.600000, 8.350000 }, { 0.672290, 2.769170, 8.350000 } },
  { { -0.496390, 2.769170, 8.350000 }, { 0.672290, 2.769170, 8.350000 }, { -0.496390, -3.400000, 8.350000 } },
  { { 0.672290, 2.769170, 8.350000 }, { 3.600000, 3.600000, 8.350000 }, { 3.600000, 2.769170, 8.350000 } },
  { { 0.672290, -3.400000, 8.350000 }, { -0.496390, -3.400000, 8.350000 }, { 0.672290, 2.769170, 8.350000 } },
  { { 0.672290, 2.769170, 8.350000 }, { 3.600000, 2.769170, 7.600000 }, { 0.672290, 2.769170, 7.600000 } },
  { { 3.600000, 2.769170, 7.600000 }, { 0.672290, 2.769170, 8.350000 }, { 3.600000, 2.769170, 8.350000 } },
  { { 3.600000, 3.600000, 8.350000 }, { 3.600000, 2.769170, 7.600000 }, { 3.600000, 2.769170, 8.350000 } },
  { { 3.600000, 2.769170, 7.600000 }, { 3.600000, 3.600000, 8.350000 }, { 3.600000, 3.600000, 7.600000 } },
  { { 3.600000, 3.600000, 8.350000 }, { -3.400000, 3.600000, 7.600000 }, { 3.600000, 3.600000, 7.600000 } },
  { { -3.400000, 3.600000, 7.600000 }, { 3.600000, 3.600000, 8.350000 }, { -3.400000, 3.600000, 8.350000 } },
  { { -3.400000, 3.600000, 7.600000 }, { -3.400000, 2.769170, 8.350000 }, { -3.400000, 2.769170, 7.600000 } },
  { { -3.400000, 2.769170, 8.350000 }, { -3.400000, 3.600000, 7.600000 }, { -3.400000, 3.600000, 8.350000 } },
  { { -3.400000, 2.769170, 8.350000 }, { -0.496390, 2.769170, 7.600000 }, { -3.400000, 2.769170, 7.600000 } },
  { { -0.496390, 2.769170, 7.600000 }, { -3.400000, 2.769170, 8.350000 }, { -0.496390, 2.769170, 8.350000 } },
  { { -0.496390, 2.769170, 7.600000 }, { -0.496390, -3.400000, 8.350000 }, { -0.496390, -3.400000, 7.600000 } },
  { { -0.496390, -3.400000, 8.350000 }, { -0.496390, 2.769170, 7.600000 }, { -0.496390, 2.769170, 8.350000 } },
  { { -0.496390, -3.400000, 8.350000 }, { 0.672290, -3.400000, 7.600000 }, { -0.496390, -3.400000, 7.600000 } },
  { { 0.672290, -3.400000, 7.600000 }, { -0.496390, -3.400000, 8.350000 }, { 0.672290, -3.400000, 8.350000 } },
  { { 0.672290, 2.769170, 8.350000 }, { 0.672290, -3.400000, 7.600000 }, { 0.672290, -3.400000, 8.350000 } },
  { { 0.672290, -3.400000, 7.600000 }, { 0.672290, 2.769170, 8.350000 }, { 0.672290, 2.769170, 7.600000 } }
};

--- NEW FILE: logo.c ---
/*
 * logo.c:
 * GtkGLExt logo demo.
 *
 * written by Naofumi Yasufuku  <na...@us...>
 */

#include <stdlib.h>
#include <string.h>
#include <math.h>

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include <gtk/gtkgl.h>

#ifdef G_OS_WIN32
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif

#include <GL/gl.h>
#include <GL/glu.h>

#include "logo-model.h"
#include "trackball.h"

#define DIG_2_RAD (G_PI / 180.0)
#define RAD_2_DIG (180.0 / G_PI)

#define TIMEOUT_INTERVAL 10

#define DEFAULT_ROT_COUNT 100

#define VIEW_INIT_AXIS_X 1.0
#define VIEW_INIT_AXIS_Y 0.0
#define VIEW_INIT_AXIS_Z 0.0
#define VIEW_INIT_ANGLE  20.0

#define VIEW_SCALE_MAX 2.0
#define VIEW_SCALE_MIN 0.5

#define LOGO_CUBE       1
#define LOGO_G_FORWARD  2
#define LOGO_G_BACKWARD 3
#define LOGO_T_FORWARD  4
#define LOGO_T_BACKWARD 5
#define LOGO_K_FORWARD  6
#define LOGO_K_BACKWARD 7

static float view_quat[4] = { 0.0, 0.0, 0.0, 1.0 };
static float view_scale = 1.0;

static float logo_quat[4] = { 0.0, 0.0, 0.0, 1.0 };

static gboolean animate = TRUE;

static void toggle_animation (GtkWidget *widget);
static void init_logo_view   (GtkWidget *widget);

static void
init_view (void)
{
  float sine = sin (0.5 * VIEW_INIT_ANGLE * DIG_2_RAD);
  view_quat[0] = VIEW_INIT_AXIS_X * sine;
  view_quat[1] = VIEW_INIT_AXIS_Y * sine;
  view_quat[2] = VIEW_INIT_AXIS_Z * sine;
  view_quat[3] = cos (0.5 * VIEW_INIT_ANGLE * DIG_2_RAD);
  view_scale = 1.0;
}

static void
init_logo_quat (void)
{
  logo_quat[0] = 0.0;
  logo_quat[1] = 0.0;
  logo_quat[2] = 0.0;
  logo_quat[3] = 1.0;
}

static void
realize (GtkWidget *widget,
	 gpointer   data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  static GLfloat light0_position[] = { 0.0, 0.0, 30.0, 0.0 };
  static GLfloat light0_diffuse[]  = { 1.0, 1.0, 1.0, 1.0 };
  static GLfloat light0_specular[] = { 1.0, 1.0, 1.0, 1.0 };

  static GLfloat mat_specular[]  = { 0.5, 0.5, 0.5, 1.0 };
  static GLfloat mat_shininess[] = { 10.0 };
  static GLfloat mat_black[]     = { 0.0, 0.0, 0.0, 1.0 };
  static GLfloat mat_red[]       = { 1.0, 0.0, 0.0, 1.0 };
  static GLfloat mat_green[]     = { 0.0, 1.0, 0.0, 1.0 };
  static GLfloat mat_blue[]      = { 0.0, 0.0, 1.0, 1.0 };

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return;

  glClearColor (0.5, 0.5, 0.8, 1.0);
  glClearDepth (1.0);

  glLightfv (GL_LIGHT0, GL_POSITION, light0_position);
  glLightfv (GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
  glLightfv (GL_LIGHT0, GL_SPECULAR, light0_specular);

  glEnable (GL_LIGHTING);
  glEnable (GL_LIGHT0);
  glEnable (GL_DEPTH_TEST);

  glEnable (GL_CULL_FACE);

  glShadeModel (GL_SMOOTH);

  glMaterialfv (GL_FRONT, GL_SPECULAR, mat_specular);
  glMaterialfv (GL_FRONT, GL_SHININESS, mat_shininess);

  /* Center black cube. */
  glNewList (LOGO_CUBE, GL_COMPILE);
    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_black);
    logo_draw_cube ();
  glEndList ();

  /* Forward "G". */
  glNewList (LOGO_G_FORWARD, GL_COMPILE);
    glDisable (GL_CULL_FACE);
    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_blue);
    logo_draw_g_plane ();
    glEnable (GL_CULL_FACE);

    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_black);
    logo_draw_g ();
  glEndList ();

  /* Backward "G". */
  glNewList (LOGO_G_BACKWARD, GL_COMPILE);
    glPushMatrix ();
      glRotatef (180.0, 1.0, 0.0, 0.0);

      glDisable (GL_CULL_FACE);
      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_blue);
      logo_draw_g_plane ();
      glEnable (GL_CULL_FACE);

      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_black);
      logo_draw_g ();

    glPopMatrix ();
  glEndList ();

  /* Forward "T". */
  glNewList (LOGO_T_FORWARD, GL_COMPILE);
    glDisable (GL_CULL_FACE);
    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_red);
    logo_draw_t_plane ();
    glEnable (GL_CULL_FACE);

    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_black);
    logo_draw_t ();
  glEndList ();

  /* Backward "T". */
  glNewList (LOGO_T_BACKWARD, GL_COMPILE);
    glPushMatrix ();
      glRotatef (180.0, 1.0, 0.0, 0.0);

      glDisable (GL_CULL_FACE);
      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_red);
      logo_draw_t_plane ();
      glEnable (GL_CULL_FACE);

      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_black);
      logo_draw_t ();

    glPopMatrix ();
  glEndList ();

  /* Forward "K". */
  glNewList (LOGO_K_FORWARD, GL_COMPILE);
    glDisable (GL_CULL_FACE);
    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_green);
    logo_draw_k_plane ();
    glEnable (GL_CULL_FACE);

    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_black);
    logo_draw_k ();
  glEndList ();

  /* Backward "K". */
  glNewList (LOGO_K_BACKWARD, GL_COMPILE);
    glPushMatrix ();
      glRotatef (180.0, 0.0, 0.0, 1.0);

      glDisable (GL_CULL_FACE);
      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_green);
      logo_draw_k_plane ();
      glEnable (GL_CULL_FACE);

      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_black);
      logo_draw_k ();
    glPopMatrix ();
  glEndList ();

  glEnable (GL_NORMALIZE);

  /* Init logo orientation. */
  init_logo_quat ();

  /* Init view. */
  init_view ();

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/
}

static gboolean
configure_event (GtkWidget         *widget,
		 GdkEventConfigure *event,
		 gpointer           data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  GLfloat w = widget->allocation.width;
  GLfloat h = widget->allocation.height;
  GLfloat aspect;

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return FALSE;

  glViewport (0, 0, w, h);

  glMatrixMode (GL_PROJECTION);
  glLoadIdentity ();
  if (w > h)
    {
      aspect = w / h;
      glFrustum (-aspect, aspect, -1.0, 1.0, 2.0, 60.0);
    }
  else
    {
      aspect = h / w;
      glFrustum (-1.0, 1.0, -aspect, aspect, 2.0, 60.0);
    }

  glMatrixMode (GL_MODELVIEW);

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return TRUE;
}

static float axis_x[3] = { 1.0, 0.0, 0.0 };
static float axis_y[3] = { 0.0, 1.0, 0.0 };
static float axis_z[3] = { 0.0, 0.0, 1.0 };

/* Logo rotation mode. */
typedef struct _RotMode
{
  float *axis;
  float sign;
} RotMode;

static RotMode rot_mode[] = {
  { axis_x,  1.0 },
  { axis_y,  1.0 },
  { axis_x,  1.0 },
  { axis_z,  1.0 },
  { axis_x,  1.0 },
  { axis_y, -1.0 },
  { axis_x,  1.0 },
  { axis_z, -1.0 },
  { NULL,    0.0 }  /* terminator */
};

static int rot_count = DEFAULT_ROT_COUNT;
static int mode = 0;
static int counter = 0;

static gboolean
expose_event (GtkWidget      *widget,
	      GdkEventExpose *event,
	      gpointer        data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  float d_quat[4];
  float m[4][4];

  if (animate)
    {

      if (counter == rot_count)
	{
	  if (rot_mode[++mode].axis == NULL)
	    mode = 0;
	  counter = 0;
	}

      axis_to_quat (rot_mode[mode].axis,
		    rot_mode[mode].sign * G_PI_2 / rot_count,
		    d_quat);
      add_quats (d_quat, logo_quat, logo_quat);

      counter++;

    }

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return FALSE;

  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glLoadIdentity ();

  /* View transformation. */
  glTranslatef (0.0, 0.0, -30.0);
  glScalef (view_scale, view_scale, view_scale);
  build_rotmatrix (m, view_quat);
  glMultMatrixf (&m[0][0]);

  /* Logo model. */
  glPushMatrix ();
    build_rotmatrix (m, logo_quat);
    glMultMatrixf (&m[0][0]);

    glRotatef (90.0, 1.0, 0.0, 0.0);
    glCallList (LOGO_CUBE);
    glCallList (LOGO_G_FORWARD);
    glCallList (LOGO_G_BACKWARD);
    glCallList (LOGO_T_FORWARD);
    glCallList (LOGO_T_BACKWARD);
    glCallList (LOGO_K_FORWARD);
    glCallList (LOGO_K_BACKWARD);
  glPopMatrix ();

  /* Swap buffers. */
  if (gdk_gl_drawable_is_double_buffered (gldrawable))
    gdk_gl_drawable_swap_buffers (gldrawable);
  else
    glFlush ();

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return TRUE;
}

static float begin_x = 0.0;
static float begin_y = 0.0;

static gboolean
button_press_event (GtkWidget      *widget,
		    GdkEventButton *event,
		    GtkWidget      *menu)
{
  begin_x = event->x;
  begin_y = event->y;

  return FALSE;
}

static gboolean
motion_notify_event (GtkWidget      *widget,
		     GdkEventMotion *event,
		     gpointer        data)
{
  float w = widget->allocation.width;
  float h = widget->allocation.height;
  float x = event->x;
  float y = event->y;
  float d_quat[4];
  gboolean redraw = FALSE;

  /* Rotation. */
  if (event->state & GDK_BUTTON1_MASK)
    {
      trackball (d_quat,
		 (2.0 * begin_x - w) / w,
		 (h - 2.0 * begin_y) / h,
		 (2.0 * x - w) / w,
		 (h - 2.0 * y) / h);
      add_quats (d_quat, view_quat, view_quat);
      redraw = TRUE;
    }

  /* Scaling. */
  if (event->state & GDK_BUTTON2_MASK)
    {
      view_scale = view_scale * (1.0 + (y - begin_y) / h);
      if (view_scale > VIEW_SCALE_MAX)
	view_scale = VIEW_SCALE_MAX;
      else if (view_scale < VIEW_SCALE_MIN)
	view_scale = VIEW_SCALE_MIN;
      redraw = TRUE;
    }

  begin_x = x;
  begin_y = y;

  if (redraw && !animate)
    gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);

  return TRUE;
}

static gboolean
key_press_event (GtkWidget   *widget,
		 GdkEventKey *event,
		 gpointer     data)
{
  switch (event->keyval)
    {
    case GDK_a:
      toggle_animation (widget);
      break;
    case GDK_i:
      init_logo_view (widget);
      break;
    case GDK_Escape:
      gtk_main_quit ();
      break;
    default:
      return TRUE;
    }

  return TRUE;
}

static gboolean
timeout (GtkWidget *widget)
{
  /* Invalidate the whole window. */
  gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);

  /* Update synchronously. */
  gdk_window_process_updates (widget->window, FALSE);

  return TRUE;
}

static guint timeout_id = 0;

static void
timeout_add (GtkWidget *widget)
{
  if (timeout_id == 0)
    {
      timeout_id = g_timeout_add (TIMEOUT_INTERVAL,
                                  (GSourceFunc) timeout,
                                  widget);
    }
}

static void
timeout_remove (GtkWidget *widget)
{
  if (timeout_id != 0)
    {
      g_source_remove (timeout_id);
      timeout_id = 0;
    }
}

static gboolean
map_event (GtkWidget   *widget,
	   GdkEventAny *event,
	   gpointer     data)
{
  if (animate)
    timeout_add (widget);

  return TRUE;
}

static gboolean
unmap_event (GtkWidget   *widget,
	     GdkEventAny *event,
	     gpointer     data)
{
  timeout_remove (widget);

  return TRUE;
}

static gboolean
visibility_notify_event (GtkWidget          *widget,
			 GdkEventVisibility *event,
			 gpointer            data)
{
  if (animate)
    {
      if (event->state == GDK_VISIBILITY_FULLY_OBSCURED)
	timeout_remove (widget);
      else
	timeout_add (widget);
    }

  return TRUE;
}

static void
toggle_animation (GtkWidget *widget)
{
  animate = !animate;

  if (animate)
    {
      timeout_add (widget);
    }
  else
    {
      timeout_remove (widget);
      gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
    }
}

static void
init_logo_view (GtkWidget *widget)
{
  init_logo_quat ();
  init_view ();
  mode = 0;
  counter = 0;

  if (!animate)
    gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
}

/* For popup menu. */
static gboolean
button_press_event_popup_menu (GtkWidget      *widget,
			       GdkEventButton *event,
			       gpointer        data)
{
  if (event->button == 3)
    {
      /* Popup menu. */
      gtk_menu_popup (GTK_MENU (widget), NULL, NULL, NULL, NULL,
		      event->button, event->time);
      return TRUE;
    }

  return FALSE;
}

/* Creates the popup menu.*/
static GtkWidget *
create_popup_menu (GtkWidget *drawing_area)
{
  GtkWidget *menu;
  GtkWidget *menu_item;

  menu = gtk_menu_new ();

  /* Toggle animation */
  menu_item = gtk_menu_item_new_with_label ("Toggle Animation");
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
  g_signal_connect_swapped (G_OBJECT (menu_item), "activate",
			    G_CALLBACK (toggle_animation), drawing_area);
  gtk_widget_show (menu_item);

  /* Init orientation */
  menu_item = gtk_menu_item_new_with_label ("Initialize");
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
  g_signal_connect_swapped (G_OBJECT (menu_item), "activate",
			    G_CALLBACK (init_logo_view), drawing_area);
  gtk_widget_show (menu_item);

  /* Quit */
  menu_item = gtk_menu_item_new_with_label ("Quit");
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
  g_signal_connect (G_OBJECT (menu_item), "activate",
		    G_CALLBACK (gtk_main_quit), NULL);
  gtk_widget_show (menu_item);

  return menu;
}

static void
print_gl_config_attrib (GdkGLConfig *glconfig,
                        const gchar *attrib_str,
                        int          attrib,
                        gboolean     is_boolean)
{
  int value;

  g_print ("%s = ", attrib_str);
  if (gdk_gl_config_get_attrib (glconfig, attrib, &value))
    {
      if (is_boolean)
        g_print ("%s\n", value == TRUE ? "TRUE" : "FALSE");
      else
        g_print ("%d\n", value);
    }
  else
    g_print ("*** Cannot get %s attribute value\n", attrib_str);
}

static void
examine_gl_config_attrib (GdkGLConfig *glconfig)
{
  g_print ("\nOpenGL visual configurations :\n\n");

  g_print ("gdk_gl_config_is_rgba (glconfig) = %s\n",
           gdk_gl_config_is_rgba (glconfig) ? "TRUE" : "FALSE");
  g_print ("gdk_gl_config_is_double_buffered (glconfig) = %s\n",
           gdk_gl_config_is_double_buffered (glconfig) ? "TRUE" : "FALSE");
  g_print ("gdk_gl_config_is_stereo (glconfig) = %s\n",
           gdk_gl_config_is_stereo (glconfig) ? "TRUE" : "FALSE");
  g_print ("gdk_gl_config_has_alpha (glconfig) = %s\n",
           gdk_gl_config_has_alpha (glconfig) ? "TRUE" : "FALSE");
  g_print ("gdk_gl_config_has_depth_buffer (glconfig) = %s\n",
           gdk_gl_config_has_depth_buffer (glconfig) ? "TRUE" : "FALSE");
  g_print ("gdk_gl_config_has_stencil_buffer (glconfig) = %s\n",
           gdk_gl_config_has_stencil_buffer (glconfig) ? "TRUE" : "FALSE");
  g_print ("gdk_gl_config_has_accum_buffer (glconfig) = %s\n",
           gdk_gl_config_has_accum_buffer (glconfig) ? "TRUE" : "FALSE");

  g_print ("\n");

  print_gl_config_attrib (glconfig, "GDK_GL_USE_GL",           GDK_GL_USE_GL,           TRUE);
  print_gl_config_attrib (glconfig, "GDK_GL_BUFFER_SIZE",      GDK_GL_BUFFER_SIZE,      FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_LEVEL",            GDK_GL_LEVEL,            FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_RGBA",             GDK_GL_RGBA,             TRUE);
  print_gl_config_attrib (glconfig, "GDK_GL_DOUBLEBUFFER",     GDK_GL_DOUBLEBUFFER,     TRUE);
  print_gl_config_attrib (glconfig, "GDK_GL_STEREO",           GDK_GL_STEREO,           TRUE);
  print_gl_config_attrib (glconfig, "GDK_GL_AUX_BUFFERS",      GDK_GL_AUX_BUFFERS,      FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_RED_SIZE",         GDK_GL_RED_SIZE,         FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_GREEN_SIZE",       GDK_GL_GREEN_SIZE,       FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_BLUE_SIZE",        GDK_GL_BLUE_SIZE,        FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_ALPHA_SIZE",       GDK_GL_ALPHA_SIZE,       FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_DEPTH_SIZE",       GDK_GL_DEPTH_SIZE,       FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_STENCIL_SIZE",     GDK_GL_STENCIL_SIZE,     FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_ACCUM_RED_SIZE",   GDK_GL_ACCUM_RED_SIZE,   FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_ACCUM_GREEN_SIZE", GDK_GL_ACCUM_GREEN_SIZE, FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_ACCUM_BLUE_SIZE",  GDK_GL_ACCUM_BLUE_SIZE,  FALSE);
  print_gl_config_attrib (glconfig, "GDK_GL_ACCUM_ALPHA_SIZE", GDK_GL_ACCUM_ALPHA_SIZE, FALSE);

  g_print ("\n");
}

int
main(int   argc,
     char *argv[])
{
  GdkGLConfig *glconfig;
  gint major, minor;

  GtkWidget *window;
  GtkWidget *vbox;
  GtkWidget *drawing_area;
  GtkWidget *menu;
  GtkWidget *button;

  int i;
  gboolean arg_count = FALSE;

  /*
   * Init GTK.
   */

  gtk_init (&argc, &argv);

  /*
   * Init GtkGLExt.
   */

  gtk_gl_init (&argc, &argv);

  /*
   * Parse arguments.
   */

  for (i = 1; i < argc; i++)
    {
      if (arg_count)
	rot_count = atoi (argv[i]);

      if (strcmp (argv[i], "--help") == 0 ||
	  strcmp (argv[i], "-h") == 0)
	{
	  g_print ("Usage: %s [--count num] [--no-anim] [--help]\n", argv[0]);
	  exit (0);
	}

      if (strcmp (argv[i], "--count") == 0)
	arg_count = TRUE;

      if (strcmp (argv[i], "--no-anim") == 0)
	animate = FALSE;
    }

  /*
   * Query OpenGL extension version.
   */

  gdk_gl_query_version (&major, &minor);
  g_print ("\nOpenGL extension version - %d.%d\n",
           major, minor);

  /*
   * Configure OpenGL-capable visual.
   */

  /* Try double-buffered visual */
  glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB    |
					GDK_GL_MODE_DEPTH  |
					GDK_GL_MODE_DOUBLE);
  if (glconfig == NULL)
    {
      g_print ("*** Cannot find the double-buffered visual.\n");
      g_print ("*** Trying single-buffered visual.\n");

      /* Try single-buffered visual */
      glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB   |
					    GDK_GL_MODE_DEPTH);
      if (glconfig == NULL)
	{
	  g_print ("*** No appropriate OpenGL-capable visual found.\n");
	  exit (1);
	}
    }

  examine_gl_config_attrib (glconfig);

  /*
   * Top-level window.
   */

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), "logo");

  /* Get automatically redrawn if any of their children changed allocation. */
  gtk_container_set_reallocate_redraws (GTK_CONTAINER (window), TRUE);

  g_signal_connect (G_OBJECT (window), "delete_event",
		    G_CALLBACK (gtk_main_quit), NULL);

  /*
   * VBox.
   */

  vbox = gtk_vbox_new (FALSE, 0);
  gtk_container_add (GTK_CONTAINER (window), vbox);
  gtk_widget_show (vbox);

  /*
   * Drawing area for drawing OpenGL scene.
   */

  drawing_area = gtk_drawing_area_new ();
  gtk_widget_set_size_request (drawing_area, 300, 300);

  /* Set OpenGL-capability to the widget. */
  gtk_widget_set_gl_capability (drawing_area,
				glconfig,
				NULL,
				TRUE,
				GDK_GL_RGBA_TYPE);

  gtk_widget_add_events (drawing_area,
			 GDK_BUTTON1_MOTION_MASK    |
			 GDK_BUTTON2_MOTION_MASK    |
			 GDK_BUTTON_PRESS_MASK      |
			 GDK_VISIBILITY_NOTIFY_MASK);

  g_signal_connect_after (G_OBJECT (drawing_area), "realize",
                          G_CALLBACK (realize), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "configure_event",
		    G_CALLBACK (configure_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "expose_event",
		    G_CALLBACK (expose_event), NULL);

  g_signal_connect (G_OBJECT (drawing_area), "button_press_event",
		    G_CALLBACK (button_press_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event",
		    G_CALLBACK (motion_notify_event), NULL);

  g_signal_connect (G_OBJECT (drawing_area), "map_event",
		    G_CALLBACK (map_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "unmap_event",
		    G_CALLBACK (unmap_event), NULL);
  g_signal_connect (G_OBJECT (drawing_area), "visibility_notify_event",
		    G_CALLBACK (visibility_notify_event), NULL);

  g_signal_connect_swapped (G_OBJECT (window), "key_press_event",
			    G_CALLBACK (key_press_event), drawing_area);

  gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);

  gtk_widget_show (drawing_area);

  /*
   * Popup menu.
   */

  menu = create_popup_menu (drawing_area);

  /* Signal handler */
  g_signal_connect_swapped (G_OBJECT (drawing_area), "button_press_event",
                            G_CALLBACK (button_press_event_popup_menu), menu);

  /*
   * Simple quit button.
   */

  button = gtk_button_new_with_label ("Quit");

  g_signal_connect (G_OBJECT (button), "clicked",
                    G_CALLBACK (gtk_main_quit), NULL);

  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

  gtk_widget_show (button);

  /*
   * Show window.
   */

  gtk_widget_show (window);

  /*
   * Main loop.
   */

  gtk_main ();

  return 0;
}

--- NEW FILE: shapes.c ---
/*
 * shapes.c:
 * shapes demo.
 *
 * written by Naofumi Yasufuku  <na...@us...>
 */

#include <stdlib.h>
#include <math.h>

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include <gtk/gtkgl.h>

#ifdef G_OS_WIN32
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif
[...965 lines suppressed...]
                    G_CALLBACK (gtk_main_quit), NULL);

  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);

  gtk_widget_show (button);

  /*
   * Show window.
   */

  gtk_widget_show (window);

  /*
   * Main loop.
   */

  gtk_main ();

  return 0;
}

--- NEW FILE: readtex.h ---
/* readtex.h */

#ifndef READTEX_H
#define READTEX_H

#include <GL/gl.h>

extern GLboolean
LoadRGBMipmaps( const char *imageFile, GLint intFormat );

extern GLboolean
LoadRGBMipmaps2( const char *imageFile, GLenum target,
                 GLint intFormat, GLint *width, GLint *height );

extern GLubyte *
LoadRGBImage( const char *imageFile,
              GLint *width, GLint *height, GLenum *format );

#endif

--- NEW FILE: alien.lwo ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: reflect.rgb ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: Makefile.msc ---
# -*- Makefile -*-
#
# Sample makefile for GtkGLExt example programs
#   Naofumi Yasufuku <na...@us...>
#

# -------------------------------------------------------------------------
# NMAKE Options
#
# Use the table below to determine the additional options for NMAKE to
# generate various application debugging, profiling and performance tuning
# information.
#
# Application Information Type         Invoke NMAKE
# ----------------------------         ------------
# For No Debugging Info                nmake nodebug=1
# For Working Set Tuner Info           nmake tune=1
# For Call Attributed Profiling Info   nmake profile=1
#
# Note: The three options above are mutually exclusive (you may use only
#       one to compile/link the application).
#
# Note: creating the environment variables NODEBUG, TUNE, and PROFILE is an
#       alternate method to setting these options via the nmake command line.
#

# Some nmake macros for Win32 apps development
TARGETOS = BOTH
#NODEBUG = 1

!include <WIN32.MAK>

# Generate makefile using 'pkg-config --cflags' command.
PKGCONFIG_CFLAGS = 
PKGCONFIG_CFLAGS_MAK = PKGCONFIG_CFLAGS.mak
!if [echo PKGCONFIG_CFLAGS = \> $(PKGCONFIG_CFLAGS_MAK)]
!else
!if [pkg-config --msvc-syntax --cflags gtkglext-1.0 pangoft2 >> $(PKGCONFIG_CFLAGS_MAK)]
!else
!include $(PKGCONFIG_CFLAGS_MAK)
!endif
!endif

# Generate makefile using 'pkg-config --libs' command.
PKGCONFIG_LIBS = 
PKGCONFIG_LIBS_MAK = PKGCONFIG_LIBS.mak
!if [echo PKGCONFIG_LIBS = \> $(PKGCONFIG_LIBS_MAK)]
!else
!if [pkg-config --msvc-syntax --libs gtkglext-1.0 >> $(PKGCONFIG_LIBS_MAK)]
!else
!include $(PKGCONFIG_LIBS_MAK)
!endif
!endif

# Generate makefile using 'pkg-config --libs' command.
PKGCONFIG_LIBS_WITH_PANGOFT2 = 
PKGCONFIG_LIBS_WITH_PANGOFT2_MAK = PKGCONFIG_LIBS_WITH_PANGOFT2.mak
!if [echo PKGCONFIG_LIBS_WITH_PANGOFT2 = \> $(PKGCONFIG_LIBS_WITH_PANGOFT2_MAK)]
!else
!if [pkg-config --msvc-syntax --libs gtkglext-1.0 pangoft2 >> $(PKGCONFIG_LIBS_WITH_PANGOFT2_MAK)]
!else
!include $(PKGCONFIG_LIBS_WITH_PANGOFT2_MAK)
!endif
!endif

# required includes and libs
INCLUDES = $(PKGCONFIG_CFLAGS)
LIBS = $(PKGCONFIG_LIBS)
LIBS_WITH_PANGOFT2 = $(PKGCONFIG_LIBS_WITH_PANGOFT2)
DEFINES = 

# debug flags (from win32.mak)
!IFDEF NODEBUG
CDEBUG = -Ox
!ELSE
!IFDEF PROFILE
CDEBUG = -Gh -Zd -Ox
!ELSE
!IFDEF TUNE
CDEBUG = -Gh -Zd -Ox
!ELSE
CDEBUG = -Zi -Od
!ENDIF
!ENDIF
!ENDIF

# warning control
WARNING = -wd4244 -wd4305

# options for cl.exe
#CFLAGS = $(cflags) $(cvars) $(cdebug) $(WARNING) $(INCLUDES) $(DEFINES)
CFLAGS = $(cflags) $(cvars) $(CDEBUG) $(WARNING) $(INCLUDES) $(DEFINES)

EXEEXT = .exe

HEADERS = \
	trackball.h		\
	logo-model.h		\
	readtex.h		\
	lw.h

SOURCES = \
	low-level.c		\
	simple.c		\
	simple-mixed.c		\
	pixmap.c		\
	pixmap-mixed.c		\
	share-lists.c		\
	color.c			\
	font.c			\
	button.c		\
	trackball.c		\
	shapes.c		\
	logo-model.c		\
	logo.c			\
	gears.c			\
	readtex.c		\
	multiarb.c		\
	viewlw.c		\
	lw.c			\
	rotating-square.c	\
	coolwave.c		\
	coolwave2.c		\
	template.c		\
	scribble-gl.c		\
	font-pangoft2.c		\
	font-pangoft2-tex.c	\
	wglinfo.c

EXTRA_SOURCES = \
	logo-g.c		\
	logo-t.c		\
	logo-k.c

OBJECTS = $(SOURCES:.c=.obj)

PROGRAMS = \
	low-level$(EXEEXT)		\
	simple$(EXEEXT)			\
	simple-mixed$(EXEEXT)		\
	pixmap$(EXEEXT)			\
	pixmap-mixed$(EXEEXT)		\
	share-lists$(EXEEXT)		\
	color$(EXEEXT)			\
	font$(EXEEXT)			\
	button$(EXEEXT)			\
	shapes$(EXEEXT)			\
	logo$(EXEEXT)			\
	gears$(EXEEXT)			\
	multiarb$(EXEEXT)		\
	viewlw$(EXEEXT)			\
	rotating-square$(EXEEXT)	\
	coolwave$(EXEEXT)		\
	coolwave2$(EXEEXT)		\
	template$(EXEEXT)		\
	scribble-gl$(EXEEXT)		\
	wglinfo$(EXEEXT)

.SUFFIXES:
.SUFFIXES: .c .obj

all: $(PROGRAMS)

#
# Compile command
#

.c.obj:
	$(cc) $(CFLAGS) $<

#
# Building executables
#

low-level$(EXEEXT): low-level.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

simple$(EXEEXT): simple.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

simple-mixed$(EXEEXT): simple-mixed.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

pixmap$(EXEEXT): pixmap.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

pixmap-mixed$(EXEEXT): pixmap-mixed.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

share-lists$(EXEEXT): share-lists.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

color$(EXEEXT): color.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

font$(EXEEXT): font.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

button$(EXEEXT): button.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

shapes$(EXEEXT): trackball.obj shapes.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

logo$(EXEEXT): trackball.obj logo-model.obj logo.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

gears$(EXEEXT): gears.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

multiarb$(EXEEXT): readtex.obj multiarb.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

viewlw$(EXEEXT): trackball.obj lw.obj viewlw.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

rotating-square$(EXEEXT): rotating-square.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

coolwave$(EXEEXT): coolwave.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

coolwave2$(EXEEXT): coolwave2.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

template$(EXEEXT): template.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

scribble-gl$(EXEEXT): scribble-gl.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS)

font-pangoft2$(EXEEXT): font-pangoft2.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS_WITH_PANGOFT2)

font-pangoft2-tex$(EXEEXT): font-pangoft2-tex.obj
	$(link) $(linkdebug) -out:$@ $** $(LIBS_WITH_PANGOFT2)

wglinfo$(EXEEXT): wglinfo.obj
	$(link) $(linkdebug) -out:$@ $** opengl32.lib $(guilibs)

#
# Clean up
#

clean-obj:
	-del *.obj
	-del *.pdb
	-del *.ilk

clean: clean-obj
	-del *$(EXEEXT)

distclean: clean
	-del $(PKGCONFIG_CFLAGS_MAK)
	-del $(PKGCONFIG_LIBS_MAK)
	-del $(PKGCONFIG_LIBS_WITH_PANGOFT2_MAK)
	-del *~

--- NEW FILE: coolwave2.c ---
/**************************************************************************
 * coolwave2.c
 *
 * Copyright (c) 2002 Alif Wahid <aw...@us...>
 *
 * A program to demonstrate GtkGLExt. It's a modified version
 * of the old IrisGL demo 'newave', first ported to OpenGL and
 * Glut by Erik Larsen. Now I have modified it to use Gtk and GtkGLExt
 * comprehensively along with ofcourse OpenGL.
 *
 * This program is in the public domain and you are using it at
 * your own risk.
 *
 **************************************************************************/

/*
 * Modified by Naofumi Yasufuku  <na...@us...>
 */

/* September, 2003.
 *
 * A slightly different version from the coolwave.c example program. Here
 * the primary goal is to test how well GtkGLExt works with GTK's
 * ability to display a window in fullscreen mode. It's quite nice to have
 * a 3D animation displayed in fullscreen mode!
 *
 * So just use the menu items to change between the fullscreen and normal
 * size mode.
 *
 * Alif Wahid.
 */

/**************************************************************************
 * Header file inclusions.
 **************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include <gtk/gtkgl.h>
/*** Use OpenGL extensions. ***/
#include <gdk/gdkglglext.h>

#ifdef G_OS_WIN32
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#endif

#include <GL/gl.h>
#include <GL/glu.h>

/**************************************************************************
 * The following section contains all the macro definitions.
 **************************************************************************/

#define DEFAULT_WIDTH  300
#define DEFAULT_HEIGHT 200
#define DEFAULT_TITLE  "CoolWave2"

#define TIMEOUT_INTERVAL 10

#define MAXGRID 64
#define SQRTOFTWOINV (1.0 / 1.414213562)

/**************************************************************************
 * Global variable declarations.
 **************************************************************************/

static gboolean animate = TRUE;

static int grid = (MAXGRID/2);
static int beginX, beginY;

static float force[MAXGRID][MAXGRID];
static float veloc[MAXGRID][MAXGRID];
static float posit[MAXGRID][MAXGRID];

static float dt = 0.008;
static float sphi = 90.0;
static float stheta = 45.0;
static float sdepth = 5.0/4.0 * (MAXGRID/2);
static float zNear = (MAXGRID/2)/10.0;
static float zFar = (MAXGRID/2)*3.0;
static float aspect = 5.0/4.0;

static float lightPosition[4] = {0.0, 0.0, 1.0, 1.0};

/**************************************************************************
 * The following section contains the function prototype declarations.
 **************************************************************************/

static void         timeout_add       (GtkWidget   *widget);
static void         timeout_remove    (GtkWidget   *widget);

static void         toggle_animation  (GtkWidget   *widget);
static void         init_wireframe    (GtkWidget   *widget);

static GdkGLConfig *configure_gl      (void);

static GtkWidget   *create_popup_menu (GtkWidget   *window, GtkWidget   *drawing_area);
static GtkWidget   *create_window     (GdkGLConfig *glconfig);

/**************************************************************************
 * The waving functions.
 **************************************************************************/

void getforce (void)
{
  int i=0, j=0;
  float d;

  for(i=0;i<grid;i++)
    {
      for(j=0;j<grid;j++)
	{
	  force[i][j]=0.0;
	}
    }

  for(i=2;i<grid-2;i++)
    {
      for(j=2;j<grid-2;j++)
	{
	  d=posit[i][j]-posit[i][j-1];
	  force[i][j] -= d;
	  force[i][j-1] += d;

	  d=posit[i][j]-posit[i-1][j];
	  force[i][j] -= d;
	  force[i-1][j] += d;

	  d= (posit[i][j]-posit[i][j+1]);
	  force[i][j] -= d ;
	  force[i][j+1] += d;

	  d= (posit[i][j]-posit[i+1][j]);
	  force[i][j] -= d ;
	  force[i+1][j] += d;

	  d= (posit[i][j]-posit[i+1][j+1])*SQRTOFTWOINV;
	  force[i][j] -= d ;
	  force[i+1][j+1] += d;

	  d= (posit[i][j]-posit[i-1][j-1])*SQRTOFTWOINV;
	  force[i][j] -= d ;
	  force[i-1][j-1] += d;

	  d= (posit[i][j]-posit[i+1][j-1])*SQRTOFTWOINV;
	  force[i][j] -= d ;
	  force[i+1][j-1] += d;

	  d= (posit[i][j]-posit[i-1][j+1])*SQRTOFTWOINV;
	  force[i][j] -= d ;
	  force[i- 1][j+1] += d;
	}
    }
}

void getvelocity (void)
{
  int i=0, j=0;

  for(i=0;i<grid;i++)
    {
      for(j=0;j<grid;j++) veloc[i][j]+=force[i][j] * dt;
    }
}

void getposition (void)
{
  int i=0, j=0;

  for(i=0;i<grid;i++)
    {
      for(j=0;j<grid;j++) posit[i][j]+=veloc[i][j];
    }
}

void drawWireframe (void)
{
  int i=0, j=0;

  glColor3f(1.0, 1.0, 1.0);

  for(i=0;i<grid;i++)
    {
      glBegin(GL_LINE_STRIP);
      for(j=0;j<grid;j++) glVertex3f((float)i,(float)j,(float)posit[i][j]);
      glEnd();
    }

  for(i=0;i<grid;i++)
    {
      glBegin(GL_LINE_STRIP);
      for(j=0;j<grid;j++) glVertex3f((float)j,(float)i,(float)posit[j][i]);
      glEnd();
    }
}

void resetWireframe (void)
{
  int i=0, j=0;

  for(i=0;i<grid;i++)
    {
      for(j=0;j<grid;j++)
	{
	  force[i][j]=0.0;
	  veloc[i][j]=0.0;

	  posit[i][j]= 	(sin(G_PI*2 * ((float)i/(float)grid)) +
			 sin(G_PI*2 * ((float)j/(float)grid)))* grid/6.0;

	  if (i==0||j==0||i==grid-1||j==grid-1) posit[i][j]=0.0;
	}
    }
}

/**************************************************************************
 * The following section contains all the callback function definitions.
 **************************************************************************/

/***
 *** The "realize" signal handler. All the OpenGL initialization
 *** should be performed here, such as default background colour,
 *** certain states etc.
 ***/
static void
realize (GtkWidget *widget,
	 gpointer   data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  GdkGLProc proc = NULL;

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return;

  /* glPolygonOffsetEXT */
  proc = gdk_gl_get_glPolygonOffsetEXT ();
  if (proc == NULL)
    {
      /* glPolygonOffset */
      proc = gdk_gl_get_proc_address ("glPolygonOffset");
      if (proc == NULL)
	{
	  g_print ("Sorry, glPolygonOffset() is not supported by this renderer.\n");
	  exit (1);
	}
    }

  glEnable (GL_DEPTH_TEST);
  glDepthFunc (GL_LEQUAL);
  glClearColor (0.0, 0.0, 0.0, 0.0);
  gdk_gl_glPolygonOffsetEXT (proc, 1.0, 1.0);
  glEnable (GL_CULL_FACE);
  glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
  glHint (GL_POLYGON_SMOOTH_HINT, GL_NICEST);
  glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
  glEnable (GL_COLOR_MATERIAL);
  glColorMaterial (GL_FRONT, GL_DIFFUSE);
  glLightfv (GL_LIGHT0, GL_POSITION, lightPosition);
  glEnable (GL_LIGHT0);
  glShadeModel (GL_FLAT);
  glDisable (GL_LIGHTING);

  resetWireframe ();

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return;
}

/***
 *** The "configure_event" signal handler. Any processing required when
 *** the OpenGL-capable drawing area is re-configured should be done here.
 *** Almost always it will be used to resize the OpenGL viewport when
 *** the window is resized.
 ***/
static gboolean
configure_event (GtkWidget         *widget,
		 GdkEventConfigure *event,
		 gpointer           data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  GLfloat w = widget->allocation.width;
  GLfloat h = widget->allocation.height;

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return FALSE;

  aspect = (float)w/(float)h;
  glViewport (0, 0, w, h);

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return TRUE;
}

/***
 *** The "expose_event" signal handler. All the OpenGL re-drawing should
 *** be done here. This is repeatedly called as the painting routine
 *** every time the 'expose'/'draw' event is signalled.
 ***/
static gboolean
expose_event (GtkWidget      *widget,
	      GdkEventExpose *event,
	      gpointer        data)
{
  GdkGLContext *glcontext = gtk_widget_get_gl_context(widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget);

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))
    return FALSE;

  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glMatrixMode (GL_PROJECTION);
  glLoadIdentity ();
  gluPerspective (64.0, aspect, zNear, zFar);
  glMatrixMode (GL_MODELVIEW);
  glLoadIdentity ();

  glTranslatef (0.0,0.0,-sdepth);
  glRotatef (-stheta, 1.0, 0.0, 0.0);
  glRotatef (sphi, 0.0, 0.0, 1.0);
  glTranslatef (-(float)((grid+1)/2-1), -(float)((grid+1)/2-1), 0.0);

  drawWireframe ();

  /* Swap buffers */
  if (gdk_gl_drawable_is_double_buffered (gldrawable))
    gdk_gl_drawable_swap_buffers (gldrawable);
  else
    glFlush ();

  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return TRUE;
}

/***
 *** The timeout function. Often in animations,
 *** timeout functions are suitable for continous
 *** frame updates.
 ***/
static gboolean
timeout (GtkWidget *widget)
{
  getforce ();
  getvelocity ();
  getposition ();

  /* Invalidate the whole window. */
  gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);

  /* Update synchronously (fast). */
  gdk_window_process_updates (widget->window, FALSE);

  return TRUE;
}

/***
 *** The "motion_notify_event" signal handler. Any processing required when
 *** the OpenGL-capable drawing area is under drag motion should be done here.
 ***/
static gboolean
motion_notify_event (GtkWidget      *widget,
		     GdkEventMotion *event,
		     gpointer        data)
{
  gboolean redraw = FALSE;

  if (event->state & GDK_BUTTON1_MASK)
    {
      sphi += (float)(event->x - beginX) / 4.0;
      stheta += (float)(beginY - event->y) / 4.0;

      redraw = TRUE;
    }

  if (event->state & GDK_BUTTON2_MASK)
    {
      sdepth -= ((event->y - beginY)/(widget->allocation.height))*(MAXGRID/2);

      redraw = TRUE;
    }

  beginX = event->x;
  beginY = event->y;

  if (redraw && !animate)
    gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);

  return TRUE;
}

/***
 *** The "button_press_event" signal handler. Any processing required when
 *** mouse buttons (only left and middle buttons) are pressed on the OpenGL-
 *** capable drawing area should be done here.
 ***/
static gboolean
button_press_event (GtkWidget      *widget,
		    GdkEventButton *event,
		    gpointer        data)
{
  if (event->button == 1)
    {
      beginX = event->x;
      beginY = event->y;
      return TRUE;
    }

  if (event->button == 2)
    {
      beginX = event->x;
      beginY = event->y;
      return TRUE;
    }

  return FALSE;
}

/* For popup menu. */
static gboolean
button_press_event_popup_menu (GtkWidget      *widget,
			       GdkEventButton *event,
			       gpointer        data)
{
  if (event->button == 3)
    {
      /* Popup menu. */
      gtk_menu_popup (GTK_MENU(widget), NULL, NULL, NULL, NULL,
		      event->button, event->time);
      return TRUE;
    }

  return FALSE;
}

/***
 *** The "key_press_event" signal handler. Any processing required when key
 *** presses occur should be done here.
 ***/

static gboolean
key_press_event (GtkWidget   *widget,
		 GdkEventKey *event,
		 gpointer     data)
{
  switch (event->keyval)
    {
    case GDK_r:
      init_wireframe (widget);
      break;

    case GDK_a:
      toggle_animation (widget);
      break;

    case GDK_w:
      if (!animate)
	timeout (widget);
      break;

    case GDK_plus:
      sdepth -= 2.0;
      break;

    case GDK_minus:
      sdepth += 2.0;
      break;

    case GDK_Escape:
      gtk_main_quit ();
      break;

    default:
      return FALSE;
    }

  if (!animate)
    gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);

  return TRUE;
}

/***
 *** The "unrealize" signal handler. Any processing required when
 *** the OpenGL-capable window is unrealized should be done here.
 ***/
static void
unrealize (GtkWidget *widget,
	   gpointer   data)
{
  /*** Fill in the details here ***/

}

/**************************************************************************
 * The following section contains the timeout function management routines.
 **************************************************************************/

/***
 *** Helper functions to add or remove the timeout function.
 ***/

static guint timeout_id = 0;

static void
timeout_add (GtkWidget *widget)
{
  if (timeout_id == 0)
    {
      timeout_id = g_timeout_add (TIMEOUT_INTERVAL,
                                  (GSourceFunc) timeout,
                                  widget);
    }
}

static void
timeout_remove (GtkWidget *widget)
{
  if (timeout_id != 0)
    {
      g_sour...

[truncated message content]