/* error.c 1.1 */
/*
    Copyright 1992, 1993 O'Reilly and Associates, Inc.  Permission to
    use, copy, and modify this program is hereby granted, as long as
    this copyright notice appears in each copy of the program source
    code.
*/

#include "book_utils.h"

static char*
get_oc_type( dpy, error )
    Display		*dpy;
    XErrorEvent		*error;
{
    PEXOCErrorEvent	*oc_error = (PEXOCErrorEvent *) error;
    char		*type;
    
    switch ( oc_error->op_code ) {
    case PEXOCNURBCurve:
	type = "NURB Curve";
	break;
    
    case PEXOCNURBSurface:
	type = "NURB Surface";
	break;
    
    case PEXOCInteriorBundleIndex:
	type = "Set Interior Bundle Index";
	break;

    default:
	type = "Unknown";
	break;
    }
    return type;
}

static int
error_handler( dpy, error )
    Display		*dpy;
    XErrorEvent		*error;
{
    PEXExtensionInfo	*pexinfo;
    char		buffer[80], *oc_type;
    
    pexinfo = PEXGetExtensionInfo( dpy );

    /* See if it's a PEX error. */
    if ( error->request_code == pexinfo->major_opcode ) {

	/* Form a message about the error. */
	switch ( error->error_code - pexinfo->first_error ) {
	
	case BadPEXOutputCommand:
	    oc_type = get_oc_type( dpy, error );
	    sprintf( buffer, "%s output command error\n", oc_type );
	    break;
	
	case BadPEXLabel:
	    sprintf( buffer, "Label not found\n" );
	    break;
	
	case BadPEXRenderer:
	    sprintf( buffer, "PEX Renderer ID is invalid.\n" );
	    break;
	
	default:
	    XGetErrorText( dpy, error->error_code, buffer,
			   sizeof(buffer) );
	    break;
	}
    
    } else
	XGetErrorText( dpy, error->error_code, buffer,
		       sizeof(buffer) );

    /* Print the error message. */
    fprintf( stderr, buffer );
}

static void
redraw( dpy, window, renderer )
    Display	*dpy;
    Window	window;
    PEXRenderer	renderer;
{
    PEXColor		color;
    
    XClearWindow( dpy, window );
    
    /* Force a renderer error. */
    PEXBeginRendering( dpy, window, 9999 );
    
    PEXBeginRendering( dpy, window, renderer ); {
	/* Force an OC error. */
	PEXSetInteriorBundleIndex( dpy, renderer, PEXOCRender, 0 );
    }
    PEXEndRendering( dpy, renderer, True );
    XFlush( dpy );
}

#define WIN_GEOM	"500x500+50+50"

main( argc, argv )
    int		argc;
    char	*argv[];
{
    Display			*dpy;
    Window			window;
    XEvent			event;
    XVisualInfo			vis_info;
    XColor			bkgd_color;
    XStandardColormap		cmap_info;
    PEXColorApproxEntry		capx_info;
    PEXRenderer			renderer;
    PEXRendererAttributes	rattrs;
    PEXExtensionInfo		*pexinfo;
    int				done = 0;
    char			err[80];
    
    (void)XSetErrorHandler( error_handler );
    
    /* Open a display and initialize PEX. */
    dpy = ora_init_pex( argv, &pexinfo );
    if ( !dpy ) exit(1);

    /* Determine the best visual to use. */
    ora_find_best_visual( dpy, &vis_info );

    /* Get a standard colormap for the visual. */
    if ( !ora_get_standard_colormap( dpy, &vis_info, &cmap_info ) ) {
	fprintf ( stderr, "Cannot find a standard colormap\n" );
	exit(1);
    }
    ora_set_stdcmap_approx( &vis_info, &cmap_info, &capx_info );

    /* Create the window. */
    bkgd_color.red = bkgd_color.green = bkgd_color.blue = 0;
    bkgd_color.flags = DoRed | DoGreen | DoBlue;
    window = ora_create_window( dpy, &vis_info, &cmap_info,
			        WIN_GEOM, &bkgd_color );
    
    if ( IMMED_MODE_SPT( pexinfo ) ) {
	renderer = ora_setup_renderer( dpy, window, &capx_info,
				       &rattrs );
    } else {
	fprintf( stderr, "No immediate mode.\n" );
	exit(1);
    }
    
    /* Read and respond to X events. */
    XSelectInput( dpy, window, ExposureMask | ButtonPressMask );
    while ( !done ) {
	XNextEvent( dpy, &event );
	switch ( event.type ) {
	case Expose:
	    /* Flush remaining Expose events, then redraw. */
	    while ( XCheckTypedWindowEvent( dpy, window,
					    Expose, &event ) )
		; /* empty statement */
	    redraw( dpy, window, renderer );
	    break;
	case ButtonPress:
	    done = 1;
	    break;
	}
    }

    XCloseDisplay( dpy );
    return 0;
}