key.cpp

miXo is a buzz machine (www.buzzmachines.com) - a plugin for the freely available jeskola buzz track

// Key.cpp: implementation of the CKey class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "mixer.h"
#include "Key.h"
#include "MachineInterface.h"
#include <sstream>

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
static const char cszDono[] = "Unknown";
static const CCmdDescToken st_Tokens[]= { 
	CCmdDescToken(cmd::seperator,";",0),
	CCmdDescToken(cmd::equals,"=",0),
	CCmdDescToken(cmd::End,"end",0),
	CCmdDescToken(cmd::Max,"max",0), 
	CCmdDescToken(cmd::Min,"min",0),
	CCmdDescToken(cmd::Plus,"++",0),
	CCmdDescToken(cmd::Minus,"--",0),
	CCmdDescToken(cmd::Panic,"panic",0),
	CCmdDescToken(cmd::ToMe,"2me",0),
	CCmdDescToken(cmd::ToAll,"2all",0),
	CCmdDescToken(cmd::ToAllButMe,"2others",0),
	CCmdDescToken(cmd::ToOne,"2",1),
	CCmdDescToken(cmd::Inc,"+",1),
	CCmdDescToken(cmd::Dec,"-",1),
	CCmdDescToken(cmd::Slow,"slow",1),
	CCmdDescToken(cmd::Fast,"fast",1),
	CCmdDescToken(cmd::Wait,"wait",1),
	CCmdDescToken(cmd::Repeat,"repeat",1),
	CCmdDescToken(cmd::Mult,"*",1)
};
const char *CCmdSeq::GetDispText(cmd::TCmd c,int& n) const
{
	int i=0;
	while(i < sizeof(st_Tokens)/sizeof(CCmdDescToken)) {
		if(c == st_Tokens[i].Cmd()) {
			n=st_Tokens[i].NumOfPara();
			return st_Tokens[i].Desc().c_str();
		}
		i++;
	}
	n=0;
	return cszDono;
}
void CCmdSeq::Compile(string str) throw(CCmdCompileException)
{
	stringstream stm;
	m_str="";
	int i=0;									//erasing all unused chars
	while((i=str.find(' ')) != string::npos)	//should do this differently
		str.erase(i,1);
	while((i=str.find('\t')) != string::npos)
		str.erase(i,1);
	while((i=str.find('\r')) != string::npos)
		str.erase(i,1);
	while((i=str.find('\n')) != string::npos)
		str.erase(i,1);
	int iDummy;
	string strSep=string(GetDispText(cmd::seperator,iDummy));
	string strEquals=string(GetDispText(cmd::equals,iDummy));
	int iPos=0;
	while(iPos <= str.length()) {
		int iSep=str.find(strSep,iPos);
		int iEquals=str.find(strEquals,iPos);
		int iEndPos;
		if((iSep == string::npos) && (iEquals == string::npos))
			iEndPos=string::npos;
		else {
			if(iEquals == string::npos)
				iEndPos=iSep-iPos;
			else {
				if(iSep == string::npos)
					iEndPos=iEquals-iPos;
				else
					iEndPos=((iSep < iEquals)?iSep:iEquals)-iPos;
			}
		}
		string strToken=str.substr(iPos,iEndPos);
		int iSizeOToken=sizeof(st_Tokens)/sizeof(CCmdDescToken);
		for(i=0;i<iSizeOToken;i++) {
			if(st_Tokens[i].Desc() == strToken) {
				stm << static_cast<char>(st_Tokens[i].Cmd());
				if(st_Tokens[i].NumOfPara() > 0) {
					for(int j=0;j < st_Tokens[i].NumOfPara();j++) {
						float f;
						char *c=(char*)&f;
						int iParaSep=str.find(strSep,iPos+iEndPos);
						string strPara=str.substr(iPos+iEndPos+1,iParaSep-(iPos+iEndPos+1));
						f=atof(strPara.c_str());
						for(int k=0;k < (sizeof(float)/sizeof(char));k++)
							stm << c[k];
						iPos=iParaSep-iEndPos;
					}
				}
				break;
			}
		}
		if(iEndPos == string::npos)
			break;
		iPos+=iEndPos+1;
	}
	stm << ends;
	m_str=stm.str();
}
void CCmdSeq::AddFloat(const float f)
{
	const char *pc=reinterpret_cast<const char*>(&f);
	for(int i=0;i<(sizeof(float)/sizeof(char));i++) {
		m_str+=pc[i];
	}
}
void CAbKey::Init(CMachineDataInput * const pi,unsigned)
{
//	cmd::TCmd cmdTmp=cmd::Max;
	char c;
	stringstream stmName;
	int iLen;
	pi->Read(iLen);
	for(int i=0;i<iLen;i++) {
		pi->Read(char(c));
		stmName << c;
	}
	stmName << ends;
	m_CmdSeq.Set(stmName.str());
/*
#ifdef _DEBUG
	OutputDebugString(stmName.str().c_str());
#endif
*/
}
void CAbKey::Save(CMachineDataOutput * const po)
{
	int iLen=m_CmdSeq.GetSize();
	po->Write(iLen);
	for(int i=0;i<iLen;i++) {
		char c=m_CmdSeq.Get(i);
		po->Write(c);
	}
}
CKey::CKey(char k,CCmdSeq s) : CAbKey(s),m_uVirtKey(0) 
{ 
	char szBuf[2] ={ k,'\0'};
	m_uVirtKey=GetVirtKey(tolower(k)); 
	m_str=szBuf;
}
long CKey::RemapVirtKey(long l) const
{
	return (::MapVirtualKey(l,0))<<16;
}
void CKey::Init(CMachineDataInput * const pi,unsigned u)
{
	if(u > 0x2) {
		dword dw;
		pi->Read(dw);
//		long lData=
//		LPARAM lParam=lData << 16;
		SetVirtKey(dw,RemapVirtKey(dw));
	}
//	if(u >0x3)
//		pi->Read(m_cKey[0]);
//	m_cKey[1]=0;
/*VK_LSHIFT 

#ifdef _DEBUG
	OutputDebugString(m_cKey);
#endif
*/
	CAbKey::Init(pi,u);
}

void CKey::Save(CMachineDataOutput * const po)
{
	dword dw=m_uVirtKey;
	po->Write(dw);
//	po->Write(m_cKey[0]);
	CAbKey::Save(po);
}
unsigned CKey::GetVirtKey(char c) const 
{
	return ::VkKeyScan(c);// & 0xff; eliminates SHIFT,CTRL & ALT
}
void CKey::SetVirtKey(int iKey,long lData)
{
	m_uVirtKey=iKey;
	char szBuf[30];
	::GetKeyNameText(RemapVirtKey(iKey),szBuf,29);
	m_str=szBuf;
}