xskin_i.c

MIDI解码程序(用VC编写)

/*
    TiMidity++ -- MIDI to WAVE converter and player
    Copyright (C) 1999-2002 Masanao Izumo <[e-mail]>
    Copyright (C) 1995 Tuukka Toivonen <[e-mail]>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    xskin_i.c

    Oct.06.1998  Daisuke Nagano
*/

#include "xskin.h"

#include "timidity.h"
#include "common.h"
#include "instrum.h"
#include "playmidi.h"
#include "output.h"
#include "controls.h"
#include "miditrace.h"

extern void xskin_pipe_write(char *);
extern int  xskin_pipe_read(char *,int);

/* text positions */

static int text_posx[] = {
/*     !   ""   #   $   %   &   '   (   )   *   +   ,   -   .   /  */
  30, 17, 26, 30, 29, 26, 25, 16, 13, 14,  4, 19, 10, 15, 10, 21,
/* 0   1   2   3   4   5   6   7   8   9   :   ;   <   =   >   ?  */ 
   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 12, 12, 30, 28, 30,  3,
  27,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 22, 20, 23, 24, 18
};
static int text_posy[] = {
   0,  1,  0,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,
   1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  0,  2,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1
};

static char local_buf[300];

static int load_skins( void );
static void xskin_jobs( int );
static void repaint( void );

static void install_sighandler( void );
static void signal_vector( int );
static void delete_shm( void );

static int fshuf,frep,fequ,fpll;
static int fplay,fpause;
static int fremain;
static int play_val, vol_val;
static char last_text[1024];
static int last_current_time;
static int total_time;

static int shmid;
static unsigned char *speana_buf;

Visual *xskin_vis;
unsigned int xskin_depth;

Display *xskin_d;
Window xskin_r,xskin_w;
GC xskin_gc;

Pixmap xskin_back,xskin_titlebar,xskin_playpaus,xskin_numbers,xskin_cbuttons;
Pixmap xskin_monoster,xskin_posbar,xskin_shufrep,xskin_text,xskin_volume;

/* text */

void ts_puttext( int x0, int y0, char *message ) {
  int i,l;
  int c;
  int x,px,py;

  if ( x0 == MESSAGE_X ) {
    px=text_posx[0]*TEXT_W;
    py=text_posy[0]*TEXT_H;
    for ( i=0 ; i<31 ; i++ ) {
      x = x0+i*TEXT_W;
      XCopyArea( xskin_d, xskin_text, xskin_w, xskin_gc,
		 px, py, TEXT_W, TEXT_H, x, y0 );
    }
  } else if ( x0 == BITRATE_X ) {
    XCopyArea( xskin_d, xskin_back, xskin_w, xskin_gc,
	       111, 43, 15, 6, 111, 43 );
  } else if ( x0 == SAMPLE_X ) {
    XCopyArea( xskin_d, xskin_back, xskin_w, xskin_gc,
	       156, 43, 10, 6, 156, 43 );
  }

  l = strlen( message );
  if ( l<=0 ) return;
  for ( i=0 ; i<l ; i++ ) {
    c = (int)(message[i]);
    if ( (c>='a') && (c<='z') ) c = c-'a'+'A';
    if ( c<' ' ) c = '.';
    if ( c>'_' ) c = '.';

    c-=' ';
    if ( c>=64 ) c=0;
    px = text_posx[c]*TEXT_W;
    py = text_posy[c]*TEXT_H;
    x = x0+i*TEXT_W;
    if (( x0 == MESSAGE_X && i<31 ) ||
	( x0 == BITRATE_X && i<3  ) ||
	( x0 == SAMPLE_X  && i<2  )) {
      XCopyArea( xskin_d, xskin_text, xskin_w, xskin_gc,
		 px, py, TEXT_W, TEXT_H, x, y0 );
    }
  }
  XSync( xskin_d, True ); /* discards any events in the queue */

  if ( x0 == MESSAGE_X )
    strncpy( last_text, message, sizeof(last_text) );

  return;
}

/* numbers */

void ts_putnum( int x, int y, int val ) {

  int x0,y0;

  if ( (val>9) || (val<0 ) ) return;
  x0=val*9;
  y0=0;

  XCopyArea( xskin_d, xskin_numbers, xskin_w, xskin_gc,
	     x0, y0, NUM_W, NUM_H, x, y );

  return ;
}

/* cbuttons */

void ts_prev( int i ) {

  XCopyArea( xskin_d, xskin_cbuttons, xskin_w, xskin_gc,
	     PREV_SX(i), PREV_SY(i), PREV_W, PREV_H, PREV_DX, PREV_DY );

  return;
}

void ts_play( int i ) {

  XCopyArea( xskin_d, xskin_cbuttons, xskin_w, xskin_gc,
	     PLAY_SX(i), PLAY_SY(i), PLAY_W, PLAY_H, PLAY_DX, PLAY_DY );

  return;
}

void ts_pause( int i ) {

  XCopyArea( xskin_d, xskin_cbuttons, xskin_w, xskin_gc,
	     PAUSE_SX(i), PAUSE_SY(i), PAUSE_W, PAUSE_H, PAUSE_DX, PAUSE_DY);

  return;
}

void ts_stop ( int i ) {

  XCopyArea( xskin_d, xskin_cbuttons, xskin_w, xskin_gc,
	     STOP_SX(i), STOP_SY(i), STOP_W, STOP_H, STOP_DX, STOP_DY );

  return;
}

void ts_next( int i ) {

  XCopyArea( xskin_d, xskin_cbuttons, xskin_w, xskin_gc,
	     NEXT_SX(i), NEXT_SY(i), NEXT_W, NEXT_H, NEXT_DX, NEXT_DY );

  return;
}

void ts_eject( int i ) {

  XCopyArea( xskin_d, xskin_cbuttons, xskin_w, xskin_gc,
	     EJECT_SX(i), EJECT_SY(i), EJECT_W, EJECT_H, EJECT_DX, EJECT_DY );
  return;
}

/* titlebar */

void ts_titlebar( int i ) {

  XCopyArea( xskin_d, xskin_titlebar, xskin_w, xskin_gc,
	     TITLEBAR_SX(i), TITLEBAR_SY(i),
	     TITLEBAR_W, TITLEBAR_H, TITLEBAR_DX, TITLEBAR_DY );
  return;
}

void ts_exitbutton( int i ) {
  
  XCopyArea( xskin_d, xskin_titlebar, xskin_w, xskin_gc,
	     EXITBUTTON_SX(i), EXITBUTTON_SY(i),
	     EXITBUTTON_W, EXITBUTTON_H, EXITBUTTON_DX, EXITBUTTON_DY );

  return;
}

void ts_menubutton( int i ) {

  XCopyArea( xskin_d, xskin_titlebar, xskin_w, xskin_gc,
	     MENUBUTTON_SX(i), MENUBUTTON_SY(i),
	     MENUBUTTON_W, MENUBUTTON_H, MENUBUTTON_DX, MENUBUTTON_DY );
  return;
}

void ts_iconbutton( int i ) {

  XCopyArea( xskin_d, xskin_titlebar, xskin_w, xskin_gc,
	     ICONBUTTON_SX(i), ICONBUTTON_SY(i),
	     ICONBUTTON_W, ICONBUTTON_H, ICONBUTTON_DX, ICONBUTTON_DY );
  return;
}

void ts_minibutton( int i ) {

  XCopyArea( xskin_d, xskin_titlebar, xskin_w, xskin_gc,
	     MINIBUTTON_SX(i), MINIBUTTON_SY(i),
	     MINIBUTTON_W, MINIBUTTON_H, MINIBUTTON_DX, MINIBUTTON_DY );
  return;
}

/* monoster */

void ts_mono( int i ) {

  XCopyArea( xskin_d, xskin_monoster, xskin_w, xskin_gc,
	     MONO_SX(i), MONO_SY(i),
	     MONO_W, MONO_H, MONO_DX, MONO_DY );
  return;
}

void ts_stereo( int i ) {

  XCopyArea( xskin_d, xskin_monoster, xskin_w, xskin_gc,
	     STEREO_SX(i), STEREO_SY(i),
	     STEREO_W, STEREO_H, STEREO_DX, STEREO_DY );
  return;
}

/* playpaus */

void ts_pstate( int i ) {

  XCopyArea( xskin_d, xskin_playpaus, xskin_w, xskin_gc,
	     PSTATE1_SX(i), PSTATE1_SY(i),
	     PSTATE1_W, PSTATE1_H, PSTATE1_DX, PSTATE1_DY );
  XCopyArea( xskin_d, xskin_playpaus, xskin_w, xskin_gc,
	     PSTATE2_SX(i), PSTATE2_SY(i),
	     PSTATE2_W, PSTATE2_H, PSTATE2_DX, PSTATE2_DY );
  return;
}

/* shufrep */

void ts_shuf( int i ) {

  XCopyArea( xskin_d, xskin_shufrep, xskin_w, xskin_gc,
	     SHUF_SX(i), SHUF_SY(i),
	     SHUF_W, SHUF_H, SHUF_DX, SHUF_DY );

  return;
}

void ts_rep( int i ) {

  XCopyArea( xskin_d, xskin_shufrep, xskin_w, xskin_gc,
	     REP_SX(i), REP_SY(i),
	     REP_W, REP_H, REP_DX, REP_DY );

  return;
}

void ts_equ( int i ) {

  XCopyArea( xskin_d, xskin_shufrep, xskin_w, xskin_gc,
	     EQU_SX(i), EQU_SY(i),
	     EQU_W, EQU_H, EQU_DX, EQU_DY );
  return;
}

void ts_plist( int i ) {

  XCopyArea( xskin_d, xskin_shufrep, xskin_w, xskin_gc,
	     PLIST_SX(i), PLIST_SY(i),
	     PLIST_W, PLIST_H, PLIST_DX, PLIST_DY );
  return;
}

/* posbar */

int ts_pos( int i, int j ) {

  int x,y;
  int p;

  if ( j<0 ) p=-j;
  else {
    if (j<POS_MIN_DX) j=POS_MIN_DX;
    if (j>POS_MAX_DX) j=POS_MAX_DX;
    p = 100*(j-POS_MIN_DX)/(POS_MAX_DX-POS_MIN_DX);
  }

  x = POS_MIN_DX + (POS_MAX_DX-POS_MIN_DX)*p/100;
  y = POS_DY;

  XCopyArea( xskin_d, xskin_posbar, xskin_w, xskin_gc,
	     BAR_SX, BAR_SY, BAR_W, BAR_H, BAR_DX, BAR_DY );
  XCopyArea( xskin_d, xskin_posbar, xskin_w, xskin_gc,
	     POS_SX(i), POS_SY(i), POS_W, POS_H, x, y );
  return p;
}

int ts_volume( int i, int j ) {

  int x,y;
  int t,p;

  if ( j<0 ) p=-j;
  else {
    if (j<VOL_MIN_DX) j=VOL_MIN_DX;
    if (j>VOL_MAX_DX) j=VOL_MAX_DX;
    p = 100*(j-VOL_MIN_DX)/(VOL_MAX_DX-VOL_MIN_DX);
  }

  x = VOL_MIN_DX + (VOL_MAX_DX-VOL_MIN_DX)*p/100;
  y = VOL_DY;
  t=27*(int)p/100;
  XCopyArea( xskin_d, xskin_volume, xskin_w, xskin_gc,
	     VOLUME_SX, t*VOLUME_H,
	     VOLUME_W, VOLUME_H-2, VOLUME_DX, VOLUME_DY );
  XCopyArea( xskin_d, xskin_volume, xskin_w, xskin_gc,
	     VOL_SX(i), VOL_SY(i), VOL_W, VOL_H, x, y );
  return p;
}

int ts_pan( int i, int j ) {

  int x,y;
  int t,p;

  if ( j<0 ) p=-j;
  else {
    if (j<PAN_MIN_DX) j=PAN_MIN_DX;
    if (j>PAN_MAX_DX) j=PAN_MAX_DX;
    p = 100*(j-PAN_MIN_DX)/(PAN_MAX_DX-PAN_MIN_DX);
  }

  x = PAN_MIN_DX + (PAN_MAX_DX-PAN_MIN_DX)*p/100;
  y = PAN_DY;
  t=27*((p>50)?((float)p-50)/50:(50-(float)p)/50);
  if ( t<2 ) t=0;
  XCopyArea( xskin_d, xskin_volume, xskin_w, xskin_gc,
	     PANPOT_SX, t*PANPOT_H,
	     PANPOT_W, PANPOT_H-2, PANPOT_DX, PANPOT_DY );
  XCopyArea( xskin_d, xskin_volume, xskin_w, xskin_gc,
	     PAN_SX(i), PAN_SY(i),
	     PAN_W, PAN_H, x, y );
  return p;
}

static void pauseOn()
{
    if(!fpause) {
	fpause = 1;
	xskin_pipe_write("U");
    }
}

static void pauseOff()
{
    if(fpause) {
	fpause = 0;
	xskin_pipe_write("U");
    }
}

/* main loop */

#define ISIN(x,y,x0,y0,w,h) ( (x>=x0)&&(x<x0+w)&&(y>=y0)&&(y<y0+h) )?1:0

void xskin_start_interface( int pipe_in ) {

  int xskin_sc;
  XEvent xskin_e;
  XSetWindowAttributes xskin_attr;

  XSizeHints xskin_hint;
  XClassHint xskin_chint;
  XTextProperty ct;
  char *namlist[2];


  /* setup window */

  xskin_d     = XOpenDisplay( NULL );
  xskin_sc    = DefaultScreen( xskin_d );
  xskin_r     = RootWindow( xskin_d, xskin_sc );
  xskin_gc    = DefaultGC( xskin_d, xskin_sc );
  xskin_vis   = DefaultVisual( xskin_d, xskin_sc );
  xskin_depth = DefaultDepth( xskin_d, xskin_sc );

  xskin_w = XCreateSimpleWindow( xskin_d, xskin_r, 0, 0,
				 skin_width, skin_height, 0,
				 WhitePixel( xskin_d, xskin_sc ),
				 BlackPixel( xskin_d, xskin_sc ) );

  xskin_attr.backing_store = True;
  xskin_attr.override_redirect = False;
  XChangeWindowAttributes( xskin_d, xskin_w,
			   CWBackingStore|CWOverrideRedirect, &xskin_attr );

  XSelectInput( xskin_d, xskin_w,
		KeyPressMask|ExposureMask|
		EnterWindowMask|LeaveWindowMask|
		ButtonPressMask|ButtonReleaseMask|
		Button1MotionMask );

  xskin_hint.flags = USSize | PMinSize | PMaxSize | USPosition;
  xskin_hint.width = xskin_hint.min_width = xskin_hint.max_width
    = skin_width;
  xskin_hint.height = xskin_hint.min_height = xskin_hint.max_height
    = skin_height;
  XSetNormalHints( xskin_d, xskin_w, &xskin_hint );

  xskin_chint.res_name  = XSKIN_RES_NAME;
  xskin_chint.res_class = XSKIN_RES_CLASS;
  XSetClassHint( xskin_d, xskin_w, &xskin_chint );

  namlist[0]=(char *)safe_malloc(strlen(XSKIN_WINDOW_NAME)+1);
  strcpy( namlist[0], XSKIN_WINDOW_NAME );
  XmbTextListToTextProperty( xskin_d, namlist, 1, XCompoundTextStyle, &ct );
  XSetWMName( xskin_d, xskin_w, &ct );
  XSetWMIconName( xskin_d, xskin_w, &ct );
  free(namlist[0]);


  /* setup pixmaps */

  if ( load_skins()!=0 ) goto finish;

  XSetWindowBackgroundPixmap( xskin_d, xskin_w, xskin_back );
  XClearWindow( xskin_d, xskin_w );

  XMapWindow( xskin_d, xskin_w );
  while( 1 ) {
    XNextEvent( xskin_d, &xskin_e );
    if ( xskin_e.type == Expose ) break; 
  }

  fshuf=0;
  frep=0;
  fequ=1;
  fpll=1;
  fplay=0;
  fpause=0;
  fremain=0;
  play_val=1;
  vol_val=50;
  last_current_time=0;
  total_time=0;
  speana_buf = NULL;
  strcpy( last_text, "welcome to timidity" );

  install_sighandler();

  repaint();
  ts_spectrum( -1, speana_buf );

  XFlush(xskin_d);

  xskin_jobs( pipe_in );   /* tskin main jobs */

finish:
  signal_vector(0);  /* finish */
}

#define ISIN(x,y,x0,y0,w,h) ( (x>=x0)&&(x<x0+w)&&(y>=y0)&&(y<y0+h) )?1:0

static void xskin_jobs( int pipe_in ) {
  XEvent e;
  int x,y;
  int window_x,window_y;
  int fspe=0;
  int pr=-1;
  int z;
  int p;
  int master_volume=0;
  char file_name[1024], tmp[1024];

  int last_puttext_time;
  int last_window_x=-1, last_window_y=-1;

  int max_files;
  int i;
  fd_set fds;
  static struct timeval tv;

  Window t_w;
  unsigned int t_width, t_height, t_border, t_depth;

  xskin_pipe_write( "READY" );

  shmid = shmget( IPC_PRIVATE, sizeof(char)*SPE_W, IPC_CREAT|0600 );
  if ( shmid<0 ) xskin_pipe_write( "ERROR" );
  else {
    sprintf( local_buf, "%d", shmid );
    xskin_pipe_write( local_buf );
    speana_buf = (unsigned char *)shmat( shmid, 0, 0 );
  }

  xskin_pipe_read( local_buf, sizeof(local_buf) );
  max_files = atoi( local_buf );
  for ( i=0 ; i<max_files ; i++ ) {
    xskin_pipe_read( local_buf, sizeof(local_buf) );
  }

  z=1;
  last_puttext_time=0;
  last_current_time=0;

  XGetGeometry( xskin_d, xskin_w, &t_w,
		&window_x, &window_y,
		&t_width, &t_height, &t_border, &t_depth );

  while( z ) {

    XFlush( xskin_d );

    FD_ZERO( &fds );
    FD_SET( pipe_in, &fds );
    tv.tv_sec=0;
    tv.tv_usec=20000L; /* 20 msec */
    i=select( pipe_in+1, &fds, NULL, NULL, &tv );

    if ( i!=0 ) {
      xskin_pipe_read( local_buf, sizeof(local_buf) );
      switch (local_buf[0]) {

      case 'A': /* total time */
	total_time=atoi( local_buf+2 );
	last_current_time=0;
	last_puttext_time=0;
	break;
	
      case 'T': /* current time */
	{
	  int min,sec;
	  sscanf( local_buf+2, "%02d:%02d", &min, &sec );