mixerkeytable.cpp

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

// MixerKeyTable.cpp: implementation of the CMixerKeyTable class.
//
//////////////////////////////////////////////////////////////////////
#include <sstream>
#include "StdAfx.h"
#include "globdefs.h"
#include "MixerKeyTable.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMixerKeyTable::CMixerKeyTable() : m_lstKeyDef(),m_bDefTableInit(false),m_bLoadFromIni(false),
	m_strAll("All"),m_strNone("None")
{
	InitDefaultTable();
}

CMixerKeyTable::~CMixerKeyTable()
{
//WM_KEYDOWN
}
void CMixerKeyTable::Save(CMachineDataOutput * const pcOut)
{
	pcOut->Write(int(m_lstKeyDef.size()));
	for(int i=0;i<m_lstKeyDef.size();i++) {
		m_lstKeyDef[i].Save(pcOut);
	}
}
void CMixerKeyTable::Init(CMachineDataInput * const pcIn,unsigned uDataVersion)
{
	if(!m_lstKeyDef.empty())
		m_lstKeyDef.clear();
	int iNum;
	pcIn->Read(iNum);
	for(int i=0;i<iNum;i++) {
		CMixerKeyDef cKeyDef;
		cKeyDef.Init(pcIn,uDataVersion);
		AddKeyDef(cKeyDef);
	}
	m_bDefTableInit=true;			//whatfor??!!!
}

void CMixerKeyTable::InitDefaultTable()
{
	if(!m_bDefTableInit && m_bLoadFromIni) {
			m_bDefTableInit=true;
	}else{
		if(!m_bDefTableInit) {
			//default 8 track keydefs
			const int aiDefMax[] =   {'1','2','3','4','5','6','7','8',0x0};
			const int aiDefMin[] =   {'Q','W','E','R','T','Z','U','I',0x0};
			const int aiDefPlus[] =  {'A','S','D','F','G','H','J','K',0x0};
			const int aiDefMinus[] = {'Y','X','C','V','B','N','M',',',0x0};
			m_bDefTableInit=true;
			int iListIdx=0;
			for(int i=0;i<G_Const_iDefMixerSets;i++) {
				stringstream strmName;
				strmName << '#' << (i+1) << ends;
				string strName=strmName.str();
				CMixerKeyDef cKeyDef(strName.c_str(),aiDefPlus[iListIdx],aiDefMinus[iListIdx],
					aiDefMax[iListIdx],aiDefMin[iListIdx]);
				AddKeyDef(cKeyDef);
				if(aiDefPlus[iListIdx] != 0x0)
					iListIdx++;
				else
					iListIdx=0;
			}
			//default 2 track X-fade keydefs
			CMixerKeyDef cCross1;
			cCross1.SetName("X1");
			const char szMax[]={cmd::Max,cmd::ToAllButMe,cmd::Min,cmd::End,0x0};
			CKey ckXMax('1',CCmdSeq(szMax));
			cCross1.AddKey(ckXMax);
			const char szMin[]={cmd::Min,cmd::ToAllButMe,cmd::Max,cmd::End,0x0};
			CKey ckXMin('Q',CCmdSeq(szMin));
			cCross1.AddKey(ckXMin);
			const char szPlus[]={cmd::Plus,cmd::ToAllButMe,cmd::Minus,cmd::End,0x0};
			CKey ckXPlus('A',CCmdSeq(szPlus));
			cCross1.AddKey(ckXPlus);
			const char szMinus[]={cmd::Minus,cmd::ToAllButMe,cmd::Plus,cmd::End,0x0};
			CKey ckXMinus('Y',CCmdSeq(szMinus));
			cCross1.AddKey(ckXMinus);

			CCmdSeq ccPlusLg;
			ccPlusLg <<cmd::Mult<<1.6f<<cmd::ToAllButMe<<cmd::Mult<<0.95f<<cmd::End;
			CKey ckXPlusLg('S',ccPlusLg);
			cCross1.AddKey(ckXPlusLg);
			CCmdSeq ccMinusLg;
			ccMinusLg <<cmd::Mult<<0.95f<<cmd::ToAllButMe<<cmd::Mult<<1.6f<<cmd::End;
			CKey ckXMinusLg('X',ccMinusLg);
			cCross1.AddKey(ckXMinusLg);

			AddKeyDef(cCross1);
			CMixerKeyDef cCross2;
			cCross2.SetName("X2");
			AddKeyDef(cCross2);
			CMixerKeyDef cEmpty;
			//default empty keydef
			cEmpty.SetName("empty");
			AddKeyDef(cEmpty);
			CMixerKeyDef cGlob;
			//default global keydef
			cGlob.SetName("global");
			CKey ckPanic('#',CCmdSeq(cmd::Panic,cmd::End));
			ckPanic.SetVirtKey(VK_BACK,0);
			cGlob.AddKey(ckPanic); 
			AddKeyDef(cGlob);
		}
	}
}
int CMixerKeyTable::AddKeyDef(CMixerKeyDef &c)
{
	int i=GetSize();
	c.SetId(i);
	m_lstKeyDef.push_back(c);
#ifdef _DEBUG
	OutputDebugString(m_lstKeyDef.back().GetName().c_str());
#endif
	return i;
}
CMixerKeyDef *CMixerKeyTable::GetKeyDef(const string &s) 
{
	for(int i=0;i<m_lstKeyDef.size();i++) {
		if(m_lstKeyDef[i].IsNameEqual(s)) {
			return &m_lstKeyDef[i];
		}
	}
	return NULL;
}
const string &CMixerKeyTable::GetNameOf(int i) const 
{ 
	if(CheckRange(i)) 
		return m_lstKeyDef[i].GetName(); 
	else {
		if(i==-1) 
			return m_strAll; 
		else 
			return m_strNone; 
	}
}

void CMixerKeyTable::CreateFromDef(const char *szDef,const char *szNewName)
{
	//first check if the new isnt alread in list
	for(int i=0;i<m_lstKeyDef.size();i++) {

	}
	//me_DuplicateKeyDefName
}
CMixerKeyDef *CMixerKeyTable::FindFirstKeyDefByKey(TKey k) 
{
	m_ite=(m_lstKeyDef.begin());
	return FindNextKeyDefByKey(k);
}
CMixerKeyDef *CMixerKeyTable::FindNextKeyDefByKey(TKey k)
{
	while(m_ite != m_lstKeyDef.end()) {
		if(m_ite->IsKeyInDef(k))
			return &(*m_ite++);
		m_ite++;
	}
	return NULL;
}