#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <limits.h>
#include <unistd.h>
#include <varargs.h>
#include <midi.h>
#include <midiio.h>
#include <miditime.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/prctl.h>
#include <sys/schedctl.h>
#include <X11/Intrinsic.h>
#include <X11/Shell.h>
#include <X11/StringDefs.h>
#include <X11/Xaw/Box.h>
#include <X11/Xirisw/GlxMDraw.h>
#include <Xm/Xm.h>
#include <Xm/PushB.h>
#include <Xm/Text.h>
#include <Xm/Label.h>
#include <Xm/Scale.h>
#include <Xm/Form.h>
#include <Xm/Frame.h>
#include "rmcplibc.h"
#include "rmcptime.h"

#define WORLD_XMIN	0.0
#define WORLD_XMAX	200.0
#define WORLD_YMIN	0.0
#define WORLD_YMAX	200.0
#define GREY		8
#define MOUSE_OBJ 	1
#define LEN		700.0
#define NOTES_MAX	79

/*** (^_^;) Bug Recovery of SGI Media Library --> Original MIDI Defines !! (^_^;) ***/
#define MES(x)			( (x[0]).mm.msgbuf )
#define midi_set_status(x,d)	( MES(x) = ( ( d > 0xbf ) && ( d < 0xe0 ) ) ? 0x40000000 : 0x60000000, \
				  MES(x) &= 0xff0fffff, MES(x) |= ( ( d & 0xf0 ) << 16 ) )
#define midi_set_channel(x,d)	( MES(x) &= 0xfff0ffff, MES(x) |= ( ( d & 0x0f ) << 16 ) )
#define midi_set_keyno(x,d)	( MES(x) &= 0xffff00ff, MES(x) |= ( ( d & 0x7f ) << 8 ) )
#define midi_set_velocity(x,d)	( MES(x) &= 0xffffff00, MES(x) |= ( d & 0x7f ) )

MIport *midi_port;
MIevent midi[1];
XtAppContext app_context;
FILE *fp;

int velocity, duration, range, speed, width, notes, skip, channel, timbre, mx, my, xmin, xmax, ymin, ymax, button[3];
int interval=50, ev_old=0, ev=0, fifo[10][100];
float xrat, yrat, cx, cy;
char buff1[20], buff2[20];

void	scaler_p1(), scaler_p2(), scaler_p3(), scaler_p4(), scaler_p5(), scaler_p6(), scaler_p7(), scaler_p8(),
	mode_a(), mode_b(), mode_c(), mode_d(), mode_e(), mode_f(), mode_g(), mode_h(),
	mode_1(), mode_2(), mode_3(), mode_4(), mode_5(), mode_6(), mode_7(),
	self_kill(), midi_setup(), random_play(), midi_or_rmcp(), init_window(), do_resize(), input(), draw_screen(),
	midi_initialize(), midi_event_generate(), midi_transmit(), midi_tx_3byte(),
	handle_timeout(), ev_record(), ev_play(), ev_undo(), ev_clear(), push_load(), push_save();

void main(unsigned int argc, char** argv)
{
	Widget toplevel, sbox[7], pb3[7], pb2[8], pb1[5], p1, p2, p3, p4, p5, p6, p7, p8, glw, form, frame, panel, glp;
	Widget box1, box2, text1, text2;
	XmString xmstr;
	Arg args[20];
	int i,n;
	GLXconfig glxConfig [] = { { GLX_NORMAL, GLX_RGB, FALSE }, { GLX_NORMAL, GLX_DOUBLE, TRUE }, { 0,0,0 }, };
	long background[] = { 0, 0, 0 };

/***** Motif Screen Define *****/
	toplevel = XtAppInitialize(&app_context, "", (XrmOptionDescList)NULL , 
			0, (Cardinal*)&argc, (String*)argv, (String*)NULL, (ArgList)NULL, 0);
	n = 0;
	XtSetArg(args[n], XtNwidth, 1050); n++;
	XtSetArg(args[n], XtNheight, 800); n++;
	form = XtCreateManagedWidget("", boxWidgetClass, toplevel, args, n);
	n = 0;
	XtSetArg(args[n], XtNwidth, 60); n++;
	XtSetArg(args[n], XtNheight, 400); n++;
	panel = XtCreateManagedWidget("", xmFrameWidgetClass, form, args, n);
	n = 0;
	XtSetArg(args[n], GlxNglxConfig, glxConfig); n++;
	glp = XtCreateManagedWidget("", glxMDrawWidgetClass, panel, args, n);
	n = 0;
	XtSetArg(args[n], XtNwidth, 700); n++;
	XtSetArg(args[n], XtNheight, 400); n++;
	frame = XtCreateManagedWidget("", xmFrameWidgetClass, form, args, n);
	n = 0;
	XtSetArg(args[n], GlxNglxConfig, glxConfig); n++;
	glw = XtCreateManagedWidget("", glxMDrawWidgetClass, frame, args, n);
	for(i=0;i<6;i++){ sbox[i] = XtCreateManagedWidget( "", boxWidgetClass, form, NULL, 0 );}

	box1 = XtCreateManagedWidget( "", boxWidgetClass, sbox[5], NULL, 0 );
	box2 = XtCreateManagedWidget( "", boxWidgetClass, sbox[5], NULL, 0 );
	n = 0;
	xmstr = XmStringCreateSimple("Load File Name");
	XtSetArg( args[n], XmNlabelString, xmstr ); n++;
	XtCreateManagedWidget( "", xmLabelWidgetClass, box1, args, n );
	n = 0;
	XtSetArg( args[n], XmNwidth, 150 ); n++;
	text1 = XtCreateManagedWidget( "", xmTextWidgetClass, box1, args, n );
	n = 0;
	xmstr = XmStringCreateSimple("Save File Name");
	XtSetArg( args[n], XmNlabelString, xmstr ); n++;
	XtCreateManagedWidget( "", xmLabelWidgetClass, box2, args, n );
	n = 0;
	XtSetArg( args[n], XmNwidth, 150 ); n++;
	text2 = XtCreateManagedWidget( "", xmTextWidgetClass, box2, args, n );
	n = 0;
	xmstr = XmStringCreateSimple(" SOUNDS ");
	XtSetArg( args[n], XmNlabelString, xmstr ); n++;
	XtCreateManagedWidget( "", xmLabelWidgetClass, sbox[0], args, n );
	pb2[0] = XtCreateManagedWidget( "Piano", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb2[1] = XtCreateManagedWidget( "E.Piano", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb2[2] = XtCreateManagedWidget( "Glocken", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb2[3] = XtCreateManagedWidget( "Marimba", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb2[4] = XtCreateManagedWidget( "Guitar", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb2[5] = XtCreateManagedWidget( "Timpani", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb2[6] = XtCreateManagedWidget( "Voices", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	pb2[7] = XtCreateManagedWidget( "Percus.", xmPushButtonWidgetClass, sbox[0], NULL, 0 );
	n = 0;
	xmstr = XmStringCreateSimple(" ACTION ");
	XtSetArg( args[n], XmNlabelString, xmstr ); n++;
	XtCreateManagedWidget( "", xmLabelWidgetClass, sbox[1], args, n );
	pb1[0] = XtCreateManagedWidget( "Record", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	pb1[1] = XtCreateManagedWidget( "Play", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	pb1[2] = XtCreateManagedWidget( "Undo", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	pb1[3] = XtCreateManagedWidget( "Clear", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	pb1[4] = XtCreateManagedWidget( "Quit", xmPushButtonWidgetClass, sbox[1], NULL, 0 );
	n = 0;
	xmstr = XmStringCreateSimple("   RANDOMS   ");
	XtSetArg( args[n], XmNlabelString, xmstr ); n++;
	XtCreateManagedWidget( "", xmLabelWidgetClass, sbox[2], args, n );
	pb3[0] = XtCreateManagedWidget( "[Strings]", xmPushButtonWidgetClass, sbox[2], NULL, 0 );
	pb3[1] = XtCreateManagedWidget( "[Vibraphone]", xmPushButtonWidgetClass, sbox[2], NULL, 0 );
	pb3[2] = XtCreateManagedWidget( "[Voice Oohs]", xmPushButtonWidgetClass, sbox[2], NULL, 0 );
	pb3[3] = XtCreateManagedWidget( "[Syn. Brass]", xmPushButtonWidgetClass, sbox[2], NULL, 0 );
	pb3[4] = XtCreateManagedWidget( "[Pan Flute]", xmPushButtonWidgetClass, sbox[2], NULL, 0 );
	pb3[5] = XtCreateManagedWidget( "[Fantasia]", xmPushButtonWidgetClass, sbox[2], NULL, 0 );
	pb3[6] = XtCreateManagedWidget( "[Orch. Hit]", xmPushButtonWidgetClass, sbox[2], NULL, 0 );
	n = 0;
	XtSetArg( args[n], XmNminimum, 21 ); n++;
	XtSetArg( args[n], XmNmaximum, 103 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 25 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 200 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Pitch");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	p1 = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[3], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 30 ); n++;
	XtSetArg( args[n], XmNmaximum, 100 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 25 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 200 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Volume");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	p2 = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[3], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 50 ); n++;
	XtSetArg( args[n], XmNmaximum, 999 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 25 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 200 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Duration");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	p3 = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[3], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 0 ); n++;
	XtSetArg( args[n], XmNmaximum, 127 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 25 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 200 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("(reserved)");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	p4 = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[3], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 70 ); n++;
	XtSetArg( args[n], XmNmaximum, 300 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 25 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 200 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Speed");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	p5 = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[4], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 1 ); n++;
	XtSetArg( args[n], XmNmaximum, 82 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 25 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 200 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Width");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	p6 = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[4], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 3 ); n++;
	XtSetArg( args[n], XmNmaximum, 12 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 25 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 200 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Notes");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	p7 = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[4], args, n );
	n = 0;
	XtSetArg( args[n], XmNminimum, 1 ); n++;
	XtSetArg( args[n], XmNmaximum, 7 ); n++;
	XtSetArg( args[n], XmNscaleHeight, 25 ); n++;
	XtSetArg( args[n], XmNscaleWidth, 200 ); n++;
	XtSetArg( args[n], XmNorientation, XmHORIZONTAL ); n++;
	xmstr = XmStringCreateSimple("Skip");
	XtSetArg( args[n], XmNtitleString, xmstr ); n++;
	XtSetArg( args[n], XmNshowValue, True ); n++;
	p8 = XtCreateManagedWidget( "", xmScaleWidgetClass, sbox[4], args, n );

/***** Callback Routine Define *****/
	XtAddCallback( pb1[0], XmNactivateCallback, ev_record, NULL );
	XtAddCallback( pb1[1], XmNactivateCallback, ev_play, NULL );
	XtAddCallback( pb1[2], XmNactivateCallback, ev_undo, NULL );
	XtAddCallback( pb1[3], XmNactivateCallback, ev_clear, NULL );
	XtAddCallback( pb1[4], XmNactivateCallback, self_kill, NULL );
	XtAddCallback( pb2[0], XmNactivateCallback, mode_a, NULL );
	XtAddCallback( pb2[1], XmNactivateCallback, mode_b, NULL );
	XtAddCallback( pb2[2], XmNactivateCallback, mode_c, NULL );
	XtAddCallback( pb2[3], XmNactivateCallback, mode_d, NULL );
	XtAddCallback( pb2[4], XmNactivateCallback, mode_e, NULL );
	XtAddCallback( pb2[5], XmNactivateCallback, mode_f, NULL );
	XtAddCallback( pb2[6], XmNactivateCallback, mode_g, NULL );
	XtAddCallback( pb2[7], XmNactivateCallback, mode_h, NULL );
	XtAddCallback( pb3[0], XmNactivateCallback, mode_1, NULL );
	XtAddCallback( pb3[1], XmNactivateCallback, mode_2, NULL );
	XtAddCallback( pb3[2], XmNactivateCallback, mode_3, NULL );
	XtAddCallback( pb3[3], XmNactivateCallback, mode_4, NULL );
	XtAddCallback( pb3[4], XmNactivateCallback, mode_5, NULL );
	XtAddCallback( pb3[5], XmNactivateCallback, mode_6, NULL );
	XtAddCallback( pb3[6], XmNactivateCallback, mode_7, NULL );
	XtAddCallback( p1, XmNdragCallback, scaler_p1, NULL );
	XtAddCallback( p2, XmNdragCallback, scaler_p2, NULL );
	XtAddCallback( p3, XmNdragCallback, scaler_p3, NULL );
	XtAddCallback( p4, XmNdragCallback, scaler_p4, NULL );
	XtAddCallback( p5, XmNdragCallback, scaler_p5, NULL );
	XtAddCallback( p6, XmNdragCallback, scaler_p6, NULL );
	XtAddCallback( p7, XmNdragCallback, scaler_p7, NULL );
	XtAddCallback( p8, XmNdragCallback, scaler_p8, NULL );
	XtAddCallback( p1, XmNvalueChangedCallback, scaler_p1, NULL );
	XtAddCallback( p2, XmNvalueChangedCallback, scaler_p2, NULL );
	XtAddCallback( p3, XmNvalueChangedCallback, scaler_p3, NULL );
	XtAddCallback( p4, XmNvalueChangedCallback, scaler_p4, NULL );
	XtAddCallback( p5, XmNvalueChangedCallback, scaler_p5, NULL );
	XtAddCallback( p6, XmNvalueChangedCallback, scaler_p6, NULL );
	XtAddCallback( p7, XmNvalueChangedCallback, scaler_p7, NULL );
	XtAddCallback( p8, XmNvalueChangedCallback, scaler_p8, NULL );
	XtAddCallback( glw, GlxNginitCallback, init_window, 0);
	XtAddCallback( glw, GlxNinputCallback, input, 0);
	XtAddCallback( glw, GlxNresizeCallback, do_resize, 0);
	XtAddCallback(text1, XmNactivateCallback, push_load, NULL);
	XtAddCallback(text2, XmNactivateCallback, push_save, NULL);

/***** RMCP Setup *****/
	open_RMCPclnt() ;
	RMCP_cspec.to	   = RMCP_TO_ALLSERVER ;
	RMCP_cspec.color.r = 60000L ; RMCP_cspec.color.g = 20000L ; RMCP_cspec.color.b = 30000L ;
	RMCP_cts.tstype = RMCP_TSTYPE_ABSOLUTE ;

/***** Start Realize ! *****/
	midi_setup();
	srandom(1);
	velocity = 64; duration = 100; range = 48; speed = 80; width = 12; notes = 3; skip = 1; timbre = 0;
	strcpy(buff1,"[^_^] RMCP <^_^>"); buff1[0] = buff1[11] = 0x28; buff1[4] = buff1[15] = 0x29;
	strcpy(buff2,"Improvisession!");

	XtAppAddTimeOut(app_context, interval, handle_timeout, glp);
	WidgetBackgroundToGlC3i(glw,background);
	XtRealizeWidget(toplevel);
	installColormap(toplevel,glw);
	XtAppMainLoop(app_context);
}

void self_kill()
{
	int i;
	u_char buff[4];
	for(i=0;i<16;i++){
		CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec) ;
		buff[0] = 0xb0 + i ;	/* Channel + Status */
		buff[1] = 0x78;
		buff[2] = 0;
		send_RMCP_smidi_buf(buff, 3) ;
	}
	printf("\nBye Bye !  (^o^)/\n\n");
	close_RMCPclnt() ;
	MIclose( midi_port );
	MIfreeport( midi_port );
	exit(0);
}

void midi_setup(){
	u_char buff[4];
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc0;	buff[1] = 0; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc8;	buff[1] = 4; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xca;	buff[1] = 9; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xcb;	buff[1] = 12; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xcc;	buff[1] = 24; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xcd;	buff[1] = 47; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xce;	buff[1] = 52; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc1;	buff[1] = 48; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc2;	buff[1] = 11; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc3;	buff[1] = 53; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc4;	buff[1] = 62; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc5;	buff[1] = 75; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc6;	buff[1] = 88; send_RMCP_smidi_buf(buff, 2);
	CONV_RMCP_MSEC2TSTAMP(get_RMCP_ctime(), RMCP_cts.sec, RMCP_cts.msec);
	buff[0] = 0xc7;	buff[1] = 55; send_RMCP_smidi_buf(buff, 2);
}

void random_play( int ch )
{
	int i, wide, scop;
	u_char buff[16];
	long ctime, stime;
	stime = get_RMCP_ctime();
	for(i=0; i<notes; i++){
		ctime = stime + (long)i * (long)speed;
		CONV_RMCP_MSEC2TSTAMP(ctime, RMCP_cts.sec, RMCP_cts.msec) ;
		buff[0] = 0x90 + ch ;
		if( (range+width)<104 ) wide = width;
		else wide = 104 - range;
		scop = (int)random() % wide;
		buff[1] = skip * (scop / skip) + range;
		buff[2] = velocity;
		send_RMCP_smidi_buf(buff, 3) ;
		ctime += (long)duration;
		CONV_RMCP_MSEC2TSTAMP(ctime, RMCP_cts.sec, RMCP_cts.msec) ;
		buff[2] = 0;
		send_RMCP_smidi_buf(buff, 3) ;
	}
}

void mode_a(){	timbre=0; }
void mode_b(){	timbre=8; }
void mode_c(){	timbre=10; }
void mode_d(){	timbre=11; }
void mode_e(){	timbre=12; }
void mode_f(){	timbre=13; }
void mode_g(){	timbre=14; }
void mode_h(){	timbre=9; }
void mode_1(){	random_play(1); }
void mode_2(){	random_play(2); }
void mode_3(){	random_play(3); }
void mode_4(){	random_play(4); }
void mode_5(){	random_play(5); }
void mode_6(){	random_play(6); }
void mode_7(){	random_play(7); }

void scaler_p1(Widget w, caddr_t message, caddr_t para)
{
	u_char buff[16];
	long ctime;
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	range = callback->value;
}

void scaler_p2(Widget w, caddr_t message, caddr_t para)
{
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	velocity = callback->value;
}

void scaler_p3(Widget w, caddr_t message, caddr_t para)
{
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	duration = callback->value;
}

void scaler_p4(Widget w, caddr_t message, caddr_t para)
{
}

void scaler_p5(Widget w, caddr_t message, caddr_t para)
{
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	speed = callback->value;
}

void scaler_p6(Widget w, caddr_t message, caddr_t para)
{
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	width = callback->value;
}

void scaler_p7(Widget w, caddr_t message, caddr_t para)
{
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	notes = callback->value;
}

void scaler_p8(Widget w, caddr_t message, caddr_t para)
{
	int buff;
	XmScaleCallbackStruct  *callback = (XmScaleCallbackStruct *) para;
	buff = callback->value;
	if(width>buff) skip = buff;
	else skip = 1;
}

void init_window(Widget w, caddr_t client_data, GlxDrawCallbackStruct *call_data)
{
	Matrix C_spline={{-0.5,1.5,-1.5,0.5},{1.0,-2.5,2.0,-0.5},{-0.5,0.0,0.5,0.0},{0.0,1.0,0.0,0.0},};
	ortho2( WORLD_XMIN, WORLD_XMAX, WORLD_YMIN, WORLD_YMAX );
	defbasis( 100, C_spline );
	curveprecision( 20 );
	curvebasis( 100);
	makeobj(MOUSE_OBJ);
		color(WHITE); rectf(-4.0,-6.0,4.0,6.0);
		color(BLACK); rect(-4.0,-6.0,4.0,6.0); rect(-2.75,0.0,-1.25,4.5);
		rect(-0.75,0.0, 0.75,4.5); rect( 1.25,0.0, 2.75,4.5);
		color(GREY); rectf(-3.0,-6.0,5.0,-7.0); rectf(4.0,-7.0,5.0,5.0);
	closeobj();
	button[0] = button[1] = button[2] = 0;
	do_resize(w,client_data,call_data);
	midi_initialize();
}

void do_resize(Widget w, caddr_t client_data, GlxDrawCallbackStruct *call_data)
{
	GLXwinset(XtDisplay(w), XtWindow(w));
	xmin = 0; xmax = (Screencoord)call_data->width - 1;
	ymin = 0; ymax = (Screencoord)call_data->height - 1;
	xrat = (WORLD_XMAX - WORLD_XMIN) / (float)(xmax - xmin);
	yrat = (WORLD_YMAX - WORLD_YMIN) / (float)(ymax - ymin);
	viewport( 0, xmax, 0, ymax );
	mx = xmax / 2; my = ymax / 2;
	draw_screen(w);
}

void draw_screen(Widget w)
{
	static Coord geom[4][3] = { { WORLD_XMIN, 6.0-LEN, 0.0 }, { 0.0, 6.0, 0.0 },
				{ WORLD_XMIN, WORLD_YMAX, 0.0 }, { 0.0, WORLD_YMAX+LEN, 0.0 }, };
	GLXwinset(XtDisplay(w), XtWindow(w));
	color(15);
	clear();
	color(BLACK);
	geom[0][1] = cy + 6.0 - LEN;
	geom[1][0] = cx;
	geom[1][1] = cy + 6.0; 
	geom[3][0] = cx;
	crvn(4,geom);
	pushmatrix();
	translate( cx, cy, 0.0 );
	callobj(MOUSE_OBJ);
	if ( button[0] == 1 ) rectf(-2.75,0.0,-1.25,4.5);
	if ( button[1] == 1 ) rectf(-0.75,0.0, 0.75,4.5);
	if ( button[2] == 1 ) rectf( 1.25,0.0, 2.75,4.5);
	popmatrix();
	swapbuffers();
}

void input(Widget w, caddr_t client_data, GlxDrawCallbackStruct *call_data)
{
	int stt, d, new_x, new_y;
	mx = call_data->event->xbutton.x;
	my = call_data->event->xbutton.y;
	cx = (float)(mx - xmin) * xrat;
	cy = (float)(ymax - ymin - my) * yrat;
	new_x = 20 + (int)( cx * 0.4 );
	new_y = 20 + (int)( cy * 0.4 );
	stt = 144 + timbre;
	switch(call_data->event->type){
		case ButtonPress:
			switch(call_data->event->xbutton.button){
				case Button1:	button[0] = 1;
					midi_or_rmcp( 1, stt, new_x, new_y );
					break;
				case Button2:	button[1] = 1;
					midi_or_rmcp( 0, stt, new_x, new_y );
					if((ev>0)&&(ev<NOTES_MAX)){
						fifo[0][ev] = new_x;
						fifo[1][ev] = new_y;
						fifo[2][ev] = timbre;
						fifo[3][ev] = duration / 256;
						fifo[4][ev] = duration % 256;
						ev++;
					}
					break;
				case Button3:	button[2] = 1;
					midi_or_rmcp( 0, stt, new_x, new_y );
					break;
			}
			draw_screen(w);
			break;
		case ButtonRelease:
			switch(call_data->event->xbutton.button){
				case Button1:	button[0] = 0;	break;
				case Button2:	button[1] = 0;	break;
				case Button3:	button[2] = 0;	break;
			}
			draw_screen(w);
			break;
		case MotionNotify:
			if (call_data->event->xmotion.state){
				if( button[0] == 1 ){
					if( (cx<0.0)||(cx>200.0)||(cy<0.0)||(cy>200.0) ){}
					else midi_or_rmcp( 1, stt, new_x, new_y );
				}
				draw_screen(w);
			}
			break;
	}	
}

void midi_initialize()
{
	MIconfig *c;
	u_int pbuf[8];
	c = MInewconfig();
	midi_port = MInewport();
	if( MIopen( midi_port, "w", &c ) < 0 ) exit(-1);
}

void midi_transmit( int status, int channel, int keyno, int velocity )
{
	midi_set_status( midi, ( status & 0xf0 ) );
	midi_set_channel( midi, ( channel & 0x0f ) );
	midi_set_keyno( midi, ( keyno & 0x7f ) );
	midi_set_velocity ( midi, ( velocity & 0x7f ) );
	if( MIsend( midi_port, midi, 1 ) < 0 ) exit(-1);
}

void midi_tx_3byte( int status_byte, int keyno, int velocity )
{
	midi_transmit( ( status_byte & 0xf0 ), ( status_byte & 0x0f ), keyno, velocity );
}


void midi_or_rmcp( int mode, int status, int keyno, int vel )
{
	u_char buff[16];
	long ctime;
	if(mode==0){
		(midi[0]).dt.opaque1 = 0L;
		(midi[0]).dt.opaque2 = 0L;
		midi_tx_3byte( status, keyno, vel );
		(midi[0]).dt.opaque1 = (long)duration / 1000;
		(midi[0]).dt.opaque2 = ((long)duration % 1000) * 1000;
		midi_tx_3byte( status, keyno, 0 );
	}
	else{
		ctime = get_RMCP_ctime() ;
		CONV_RMCP_MSEC2TSTAMP(ctime, RMCP_cts.sec, RMCP_cts.msec) ;
		buff[0] = status;
		buff[1] = keyno;
		buff[2] = vel;
		send_RMCP_smidi_buf(buff, 3) ;
		ctime += (long)duration;
		CONV_RMCP_MSEC2TSTAMP(ctime, RMCP_cts.sec, RMCP_cts.msec) ;
		buff[2] = 0;
		send_RMCP_smidi_buf(buff, 3) ;
	}
}

void handle_timeout(Widget w)
{
	int i;
	XtAppAddTimeOut(app_context, interval, handle_timeout, w);
	GLXwinset(XtDisplay(w), XtWindow(w));
	if( ev != ev_old ){
		if( ev == -1 ){
			color(15);
			clear();
			swapbuffers();
			ev = 0;
		}
		else if( ev < NOTES_MAX ){
			color(10);
			clear();
			color(4);					
			pushmatrix();
			for(i=1;i<ev;i++) rectf(5,i*5,48,i*5+3);
			popmatrix();
			swapbuffers();
		}
		ev_old = ev;
	}
}

void ev_record(){ ev = 1; }
void ev_undo(){ if(ev>1) ev--; }
void ev_clear(){ ev = -1; }

void ev_play(){ 
	int i;
	u_char buff[16];
	long ctime, stime;
	if(ev>0){
		stime = get_RMCP_ctime();
		for(i=1; i<ev; i++){
			ctime = stime + (long)i * (long)speed;
			CONV_RMCP_MSEC2TSTAMP(ctime, RMCP_cts.sec, RMCP_cts.msec) ;
			buff[0] = 0x90 + fifo[2][i] ;
			buff[1] = fifo[0][i];
			buff[2] = fifo[1][i];
			send_RMCP_smidi_buf(buff, 3) ;
			ctime += (long)(256*fifo[3][i]+fifo[4][i]);
			CONV_RMCP_MSEC2TSTAMP(ctime, RMCP_cts.sec, RMCP_cts.msec) ;
			buff[2] = 0;
			send_RMCP_smidi_buf(buff, 3) ;
		}
	}
}

void push_load(Widget widget, caddr_t client_data, caddr_t call_data)
{
	char *string, bf1[20], bf2[20];
	int i, j, fg=0;
	string = XmTextGetString(widget);
	if( (fp=fopen( string, "rb" )) == NULL ){
		XtFree(string);
		ev = -1;
		return;
	}
	XtFree(string);
	for(i=0;i<16;i++){ if( fgetc(fp) != buff1[i] ) {fclose(fp); return;} }
	for(i=0;i<15;i++){ if( fgetc(fp) != buff2[i] ) {fclose(fp); return;} }
	ev = fgetc(fp);
	for(i=1;i<ev;i++){
		for(j=0;j<5;j++) fifo[j][i] = fgetc(fp);
	}
	fclose(fp);
}

void push_save(Widget widget, caddr_t client_data, caddr_t call_data)
{
	char *string;
	int i,j;
	string = XmTextGetString(widget);
	if( (fp=fopen( string, "wb" )) != NULL ){
		for(i=0;i<strlen(buff1);i++) fputc(buff1[i],fp);
		for(i=0;i<strlen(buff2);i++) fputc(buff2[i],fp);
		fputc(ev,fp);
		for(i=1;i<ev;i++){
			for(j=0;j<5;j++) fputc(fifo[j][i],fp);
		}
		fclose(fp);
	}
	XtFree(string);
}