mac_c.c

MIDI解码程序(用VC编写)

		nPlaying=cell.v;
		mac_HandleControl();
	}
}

static void update_ListWin()
{
	SetPortWindowPort(win.ref);
	LUpdate( win.ref->visRgn, gPlaylist);
	DrawGrowIcon(win.ref);
}

static int message_ListWin(int message, long param)
{
	Cell	cell;
	Rect	rect;
	
	switch(message){
	case MW_GROW:
		rect=win.ref->portRect;
		LSize(rect.right-14, rect.bottom-14, gPlaylist);
		return 0;

	case MW_LIST_SELECT:
		LDeselectAll(gPlaylist);
		cell.h=0; cell.v=param;
		LSetSelect(true, cell, gPlaylist);
		LAutoScroll(gPlaylist);
		return 0;
	}

	return -1; //not supported
}

#undef win
// *****************************************************
#pragma mark -
#pragma mark ==================Doc Window

static int open_DocWin();
static void click_DocWin(Point local, short modifiers);
static void update_DocWin();
static void close_DocWin();
static int	message_DocWin(int message, long param);

#define win mac_DocWindow
MacWindow win={
	0,	//WindowRef
	open_DocWin,
	click_DocWin,
	update_DocWin,
	goaway_default,
	close_default,
	message_DocWin,
	0, 150,150, 300,200
};

static void	PrintDocStr(char str[])
{
	if( (**gDocTE).teLength > 10000)	/* clear first half*/
	{
		TESetSelect(0, 5000, gDocTE);
		TEDelete(gDocTE);
	}
	
	TESetSelect((**gDocTE).teLength, (**gDocTE).teLength, gDocTE); /* move to end*/
	TEInsert(str, strlen(str), gDocTE);
	TESelView(gDocTE);
}

static int open_DocWin()
		/*success-> return 0;*/
{
	Rect	r;

	open_window(&win, kDocWinID);
	position_window(&win);
	setsize_window(&win);
	
	SetPortWindowPort(win.ref);
	TextSize(10);
	r=win.ref->portRect; r.right-=16;
	gDocTE=TENew(&r, &r);
	if( gDocTE==0 ) mac_ErrorExit("\pCannot open DocWindow!");
	
	TEFeatureFlag(teFAutoScroll, teBitSet, gDocTE);
	TEActivate(gDocTE);
	return 0;
}

static void click_DocWin(Point local, short /*modifiers*/)
{
	TEClick(local, 0, gDocTE);
}

static void update_DocWin()
{
	SetPortWindowPort(win.ref);
	DrawGrowIcon(win.ref);
	TEUpdate(&win.ref->portRect, gDocTE);
}

static int	message_DocWin(int message, long param)
{	
	switch(message){
	case MW_GROW:
		{
			Rect rect;
			rect=win.ref->portRect;
			//rect.right-=15; rect.bottom-=15;
			rect = win.ref->portRect;
			rect.right  -= 16;
			//rect.bottom -= 15;
			(**gDocTE).viewRect= (**gDocTE).destRect= rect;
			//(**gDocTE).destRect.right = (**gDocTE).destRect.right - 14;
			TECalText(gDocTE);
			TESetSelect((**gDocTE).teLength, (**gDocTE).teLength, gDocTE);
			return 0;
		}
	case MW_DOC_SET:
		{
			const char	*midiname=(char*)param;
			char		*p, docname[256];

			//midiname= (char*)param;
		    strcpy(docname, midiname, 256);
	    	if((p = strrchr(docname, '.')) == NULL){
				return 0;
		    }
            else if(p - docname >= 256 - 4) {
                /* cannot strcpy: that cause buffer overrun */
            }
		    if('A' <= p[1] && p[1] <= 'Z')	strcpy(p + 1, "DOC");
	    						else		strcpy(p + 1, "doc");

	    	TEReadFile( docname, gDocTE );
			break;
		}
	}

	return -1;  //not supported
}

#undef win
// *****************************************************
#pragma mark -
#pragma mark ================== spec Window

static int open_SpecWin();
static void click_SpecWin(Point local, short modifiers);
static void update_SpecWin();
static void goaway_SpecWin(MacWindow*);
static int	message_SpecWin(int message, long param);

#define win mac_SpecWindow
MacWindow win={
	0,	//WindowRef
	open_SpecWin,
	click_SpecWin,
	update_SpecWin,
	goaway_SpecWin,
	close_default,
	message_SpecWin,
	0, 100,100
};

static int open_SpecWin()
		/*success-> return 0;*/
{
#ifdef SUPPORT_SOUNDSPEC
	open_window(&win, kSpecWinID);
	position_window(&win);
	
	//always 
	//if( win.show ){ //Preference on
		open_soundspec();
	   	soundspec_update_wave(NULL, 0);
	//}
#endif /* SUPPORT_SOUNDSPEC */
	return 0;
}

static void click_SpecWin(Point /*local*/, short /*modifiers*/)
{
}

static void update_SpecWin()
{
	SetPortWindowPort(win.ref);
}

static void goaway_SpecWin(MacWindow *macwin)
{
	goaway_default(macwin);
	//close_soundspec();
}

static int	message_SpecWin(int message, long /*param*/)
{
	Rect rect;
	
	switch(message){
	case MW_GROW:
		rect=win.ref->portRect;
		//rect.right-=15; rect.bottom-=15;
		rect = win.ref->portRect;
		rect.right  -= 15;
		//rect.bottom -= 15;
		return 0;
	
	}

	return -1;  //not supported
}

#undef win
// *****************************************************
#pragma mark -
static MacWindow* WindowList[]={
	&mac_PlayerWindow,
	&mac_LogWindow,
	&mac_ListWindow,
	&mac_WrdWindow,
	&mac_DocWindow,
	&mac_SpecWindow,
	&mac_TraceWindow,
	&mac_SkinWindow,
	0
};

void DoUpdate(WindowRef win_ref)
{
	MacWindow* macwin;
	
	macwin = (MacWindow*)GetWRefCon(win_ref);
	if( macwin ) macwin->update();
}

static void mac_AdjustMenus(short modifiers)
{
	MenuHandle	filenemu=GetMenu(mFile),
				synthemu=GetMenu(mSynth);
	
	
	//CheckItem(filenemu, iLogWindow  & 0xFFFF, gShowMsg);
	//CheckItem(filenemu, iListWindow & 0xFFFF, gShowList);
	//CheckItem(filenemu, iWrdWindow  & 0xFFFF, gShowWrd);
	if( modifiers & optionKey ){
		//EnableItem(filenemu, iSkinWindow);
		EnableItem(synthemu, iQuickTime);
		EnableItem(synthemu, iOMS);
	}
}

void HandleMouseDown(EventRecord *event)
{
	short	part;
	WindowRef	window;
	MacWindow   *macwin;
	Rect		growRect={100,100,32000,32000};
	long		size;
	
	part=FindWindow(event->where, &window);
	macwin = (MacWindow*)GetWRefCon(window);
	
	switch(part)
	{
	case inMenuBar:
		mac_AdjustMenus(event->modifiers);
		mac_HandleMenuSelect(MenuSelect(event->where), event->modifiers);
		HiliteMenu(0);
		break;
	case inContent:
		SetPortWindowPort(window);
		SelectWindow(window);
		GlobalToLocal(&event->where);
		if(macwin) macwin->click(event->where, event->modifiers);
		break;
	case inDrag:
		DragWindow(window, event->where, &qd.screenBits.bounds);
		break;
	case inGrow:
		SetPortWindowPort(window);
		size=GrowWindow(window, event->where, &growRect);
		if( size )
		{
			SizeWindow(window, size&0x0000FFFF, size>>16, 0);
			EraseRect(&GetWindowPort(window)->portRect);
			InvalRect(&GetWindowPort(window)->portRect);
			if( macwin ) macwin->message(MW_GROW, size);
		}
		break;
	case inGoAway:
		if( TrackGoAway(window, event->where) ){
			if( macwin ){
				macwin->goaway(macwin);
			}
		}
		break;
	//case inZoomIn:
	//case inZoomOut:
	//	break;
	}
}

// *****************************************************
#pragma mark -
#pragma mark ===============control function 


static int ctl_open(int /*using_stdin*/, int /*using_stdout*/)
		/*success-> return 0;*/
{
	int i, err;
	
	for(i=0; WindowList[i]; i++){
		err=WindowList[i]->open();
		if(err) break;
	}
	if( !err ) ctl.opened=1;
	return err;
}

static void ctl_close(void)
{
	int i;
	for( i=0; WindowList[i]; i++ ){
		WindowList[i]->close(WindowList[i]);
	}
	
	ctl.opened=0;
	return;
}


static void ctl_pass_playing_list(int init_number_of_files,
				  char * /*init_list_of_files*/ [])
{
	EventRecord	event;

	if( init_number_of_files!=0 ){
		cmsg(CMSG_FATAL, VERB_NORMAL,
		  "ctl_pass_playing_list: Sorry. Fatal error.");
	}
	
#ifdef MAC_USE_OMS
	mac_oms_setup();
#endif
	
	{
		FSSpec	spec;
		OSErr	err;
		err=FSMakeFSSpec(0, 0, MAC_STARTUP_FOLDER_NAME, &spec);
		if( err==noErr ){ mac_add_fsspec( &spec ); }
	}
	
	gQuit=false;
	while(!gQuit)
	{
		WaitNextEvent(everyEvent, &event, 1,0);
		mac_HandleEvent(&event);
	}	
	Do_Quit();
}

static Boolean UserWantsControl()
{
	/* Mouse down·or key downˉ*/
	KeyMap km;

	GetKeys(km);
	km[1] &= ~0x02; /* exclude caps lock */
	return   Button() || km[0]|| km[1] || km[2] || km[3] || skin_state==PAUSE;
}

static int ctl_read(int32* /*valp*/)
{
	int			ret;
	
	//if( gCursorIsWatch ){ gCursorIsWatch=false; InitCursor(); }
	if( gQuit ) Do_Quit();	/* Quit Apple event occured */
	if( mac_rc ){ret=mac_rc; mac_rc=0; return ret;}
	if( !gBusy || UserWantsControl()){
		YieldToAnyThread();
	}
	return RC_NONE;
}

static void ctl_lyric(int lyricid)
{
	char *lyric;

	lyric = event2string(lyricid);
	if(lyric == NULL) return;
	ctl.cmsg(CMSG_TEXT, VERB_VERBOSE, "%s", lyric + 1);
}

static void ctl_gslcd(int lyricid)
{
	char *lyric;

	lyric = event2string(lyricid);
	if(lyric == NULL) return;
	
	if( lyric[0] == ME_GSLCD ){
		int i,j, data, mask;
		char tmp[3]= "00";
		
		lyric++;
		for( j=0; j<4; j++ ){
		for( i=0; i<16; i++ ){
			tmp[0]= lyric[0]; tmp[1]= lyric[1]; lyric+=2;
			sscanf(tmp, "%X", &data);
			mask=0x10;
			ctl_note((data&mask)? VOICE_ON:-1, i, 40+j*10, 127);
			ctl_note((data&mask)? VOICE_ON:-1, i, 41+j*10, 127); mask>>=1;
			ctl_note((data&mask)? VOICE_ON:-1, i, 42+j*10, 127);
			ctl_note((data&mask)? VOICE_ON:-1, i, 43+j*10, 127); mask>>=1;
			ctl_note((data&mask)? VOICE_ON:-1, i, 44+j*10, 127);
			ctl_note((data&mask)? VOICE_ON:-1, i, 45+j*10, 127); mask>>=1;
			ctl_note((data&mask)? VOICE_ON:-1, i, 46+j*10, 127);
			ctl_note((data&mask)? VOICE_ON:-1, i, 47+j*10, 127); mask>>=1;
			ctl_note((data&mask)? VOICE_ON:-1, i, 48+j*10, 127);
			ctl_note((data&mask)? VOICE_ON:-1, i, 49+j*10, 127); mask>>=1;
		}
		}
		return;
	}
	//else normal text
	ctl.cmsg(CMSG_TEXT, VERB_VERBOSE, "%s", lyric + 1);
}

static int cmsg(int type, int verbosity_level, char * fmt, ...)
{
#define BUFSIZE 1024
  char	buf[BUFSIZE];
  va_list ap;

  if ((type==CMSG_TEXT || type==CMSG_INFO || type==CMSG_WARNING) &&
      ctl.verbosity<verbosity_level){
		return 0;
	}
  va_start(ap, fmt);
    {
    	vsnprintf(buf, BUFSIZE, fmt, ap);
		if(mac_LogWindow.ref ){
			PrintLogStr(buf);
			PrintLogStr("\r");
		}
		if( !mac_LogWindow.ref || type==CMSG_FATAL){
      		StopAlertMessage(c2pstr(buf));  /* no Window or Fatal ERR*/
    	}
	}
  	va_end(ap);
  	return 0;
}

static void ctl_refresh(void)
{}

static void ctl_total_time(int tt)
{
	mac_trc_update_time( -1, tt/play_mode->rate);
	mac_SkinWindow.message(MW_SKIN_TOTAL_TIME, tt/play_mode->rate);
}

static void ctl_master_volume(int /*mv*/) {}

static void ctl_file_name(char *name)
{
	int	i;
	char	*s;
	
	for( i=strlen(name); i>=0; i--)
		if( name[i]==PATH_SEP ) {
			s=&name[i]+1; //remove pathname
			break;
		}
	snprintf(fileStr, FILESTR_LEN, "%d. %s", nPlaying+1, s);
	
	if (ctl.verbosity>=0 || ctl.trace_playing){
		DrawFileStr();
	}
	mac_ListWindow.message(MW_LIST_SELECT, nPlaying);
	mac_DocWindow.message(MW_DOC_SET, (long)name);
	mac_trc_update_all_info();
	mac_SkinWindow.message(MW_SKIN_FILENAME, (long)fileStr);
}

static void ctl_current_time(int current, int /*v*/)
{
	static int	lastSec=-1, lastYieldThread=-1;
	int			mins, secs, realSecs;
	
	if( gStartTick==0 ) gStartTick=TickCount();
						/*select*/
	realSecs=(TickCount()-gStartTick)/60; /*real time*/
	secs=current;

	if( secs!=lastSec && (skin_state==PLAYING || skin_state==PAUSE))
	{
		lastSec=secs;
		mins=secs/60;
		secs-=mins*60;
		snprintf(timeStr, TIMESTR_LEN, "%02d:%02d", mins, secs);
		DrawTimeStr();
		mac_trc_update_time(current,-1);
		mac_SkinWindow.message(MW_SKIN_TIME, lastSec);
	}
	if( realSecs!=lastYieldThread ){
		lastYieldThread= realSecs;
		mac_trc_update_time(current,-1);
		mac_trc_update_voices();
		if( (realSecs % (evil_level*evil_level))==0 )
			YieldToAnyThread();		// YieldToAnyThread every 1sec
	}
}

static void ctl_note(int status, int ch, int note, int vel)
{
	if( ! mac_TraceWindow.show ) return;
    if(note == -1)
    {
	//if(ctl.trace_playing && !midi_trace.flush_flag)
	//    push_midi_trace0(update_indicator);
	return;
    }
    //push_midi_note(v_ctl_note, note);
    v_ctl_note( status, ch, note, vel);
}

static void ctl_program(int ch, int val, char *comm){mac_ctl_program(ch,val,comm);}

static void ctl_volume(int /*channel*/, int /*val*/) {}

static void ctl_expression(int /*channel*/, int /*val*/) {}

static void ctl_panning(int /*channel*/, int /*val*/) {}

static void ctl_sustain(int /*channel*/, int /*val*/) {}

static void ctl_pitch_bend(int /*channel*/, int /*val*/) {}

static void ctl_reset(void)
{
	mac_ctl_reset_trc();
}

static void ctl_event(CtlEvent *e)
{
    switch(e->type)
    {
      case CTLE_NOW_LOADING:
	ctl_file_name((char *)e->v1);
	break;
      case CTLE_LOADING_DONE:
	break;
      case CTLE_PLAY_START:
	ctl_total_time((int)e->v1);
	break;
      case CTLE_PLAY_END:
	break;
      case CTLE_TEMPO:
	break;
      case CTLE_METRONOME:
	break;
      case CTLE_CURRENT_TIME:
	ctl_current_time((int)e->v1, (int)e->v2);
	break;
      case CTLE_NOTE:
	ctl_note((int)e->v1, (int)e->v2, (int)e->v3, (int)e->v4);
	break;
      case CTLE_MASTER_VOLUME:
	ctl_master_volume((int)e->v1);
	break;
      case CTLE_PROGRAM:
	ctl_program((int)e->v1, (int)e->v2, (char *)e->v3);
	break;
      case CTLE_VOLUME:
	ctl_volume((int)e->v1, (int)e->v2);
	break;
      case CTLE_EXPRESSION:
	ctl_expression((int)e->v1, (int)e->v2);
	break;
      case CTLE_PANNING:
	ctl_panning((int)e->v1, (int)e->v2);
	break;
      case CTLE_SUSTAIN:
	ctl_sustain((int)e->v1, (int)e->v2);
	break;
      case CTLE_PITCH_BEND:
	ctl_pitch_bend((int)e->v1, (int)e->v2);
	break;
      case CTLE_MOD_WHEEL:
	ctl_pitch_bend((int)e->v1, e->v2 ? -1 : 0x2000);
	break;
      case CTLE_CHORUS_EFFECT:
	break;
      case CTLE_REVERB_EFFECT:
	break;
      case CTLE_LYRIC:
	ctl_lyric((int)e->v1);
	break;
      case CTLE_GSLCD:
	ctl_gslcd((int)e->v1);
	break;
      case CTLE_REFRESH:
	ctl_refresh();
	break;
      case CTLE_RESET:
	ctl_reset();
	break;
#ifdef SUPPORT_SOUNDSPEC
      case CTLE_SPEANA:
        ctl_speana_data((double *)e->v1, (int)e->v2);
      break;
#endif /* SUPPORT_SOUNDSPEC */
    }
}