void IsoCodesPrivate::buildIsoEntryList()
{
loaded = true;
QFile file(QString("%1/iso_%2.xml").arg(isoCodesXmlDir, isoCode));
if( !file.open(QFile::ReadOnly | QFile::Text) ) {
kError() << "Can't open the xml file" << file.fileName();
return;
}
XmlHandler xmlHandler(isoCode, isoEntryList);
QXmlSimpleReader reader;
reader.setContentHandler(&xmlHandler);
reader.setErrorHandler(&xmlHandler);
QXmlInputSource xmlInputSource(&file);
if( ! reader.parse(xmlInputSource) ) {
kError() << "Failed to parse the xml file" << file.fileName();
return;
}
kDebug() << "Loaded" << isoEntryList.count() << ("iso entry definitions for iso"+isoCode) << "from" << file.fileName();
}
void
DemoApp::SetupScore()
{
TTValue args, out;
TTObject xmlHandler("XmlHandler");
TTLogMessage("\n*** Initialisation of Score environnement ***\n");
/////////////////////////////////////////////////////////////////////
// Init the Score library (passing the folder path where all the dylibs are)
TTScoreInit("/usr/local/jamoma");
TTLogMessage("\n*** Reading of an interactive scenario file ***\n");
/////////////////////////////////////////////////////////////////////
// Create an empty Scenario
mScenario = TTObject("Scenario");
// Read DemoScenario1.score file to fill mScenario
xmlHandler.set("object", mScenario);
xmlHandler.send("Read", "../DemoScenario.score", out);
TTLogMessage("\n*** Prepare scenario observation ***\n");
/////////////////////////////////////////////////////////////////////
// Create a callback for the "EventStatusChanged" notification sent by each event
mEventStatusChangedCallback = TTObject("callback");
mEventStatusChangedCallback.set("baton", TTPtr(this));
mEventStatusChangedCallback.set("function", TTPtr(&DemoAppEventStatusChangedCallback));
mEventStatusChangedCallback.set("notification", TTSymbol("EventStatusChanged"));
// Get all events of the scenario and attach a callback to them
TTValue timeEvents;
mScenario.get("timeEvents", timeEvents);
for (TTElementIter it = timeEvents.begin() ; it != timeEvents.end() ; it++) {
TTObject event = TTElement(*it);
event.registerObserverForNotifications(mEventStatusChangedCallback);
}
TTLogMessage("\n*** Start scenario execution ***\n");
/////////////////////////////////////////////////////////////////////
// Set the execution speed of the scenario
mScenario.set("speed", 2.);
// Start the scenario
mScenario.send("Start");
// Poll Scenario information
mPollingThread = new TTThread(TTThreadCallbackType(DemoAppScenarioPollingThread), this);
}
TiXmlElement *duWindowManager::GetWindowXmlElement(LPCTSTR lpszWindowName)
{
if (lpszWindowName == NULL || m_pDocXml == NULL)
return NULL;
TiXmlElement *pElement = NULL;
TiXmlHandle xmlHandler(m_pDocXml->FirstChildElement(_T("directui")));
pElement = xmlHandler.FirstChildElement(_T("ducontrol")).FirstChildElement(_T("duwindow")).Element();
while(pElement)
{
dustring strWindowName = ReadXmlAttributeText(pElement, _T("name"));
if (strWindowName == lpszWindowName)
return pElement;
pElement = pElement->NextSiblingElement(_T("duwindow"));
}
return NULL;
}
BOOL WINAPI duWindowManager::ChangeSkin(LPCTSTR lpszFile)
{
if (lpszFile == NULL || *lpszFile == 0 || !::PathFileExists(lpszFile))
return FALSE;
TCHAR szOldSkinPath[MAX_PATH];
_tcsncpy(szOldSkinPath, m_szSkinPath, MAX_PATH);
_tcsncpy(m_szSkinPath, lpszFile, MAX_PATH);
TCHAR *pChar = _tcsrchr(m_szSkinPath, '\\');
pChar++;
*pChar = _T('\0');
HANDLE hMem = NULL;
IStream *pStream = NULL;
PBYTE pXMLData = GetResource(_T("config.xml"), hMem, pStream);
if (pXMLData == NULL || hMem == NULL || pStream == NULL)
{
_tcsncpy(m_szSkinPath, szOldSkinPath, MAX_PATH);
return FALSE;
}
duResManager *pResManager = new duResManager;
pResManager->SetWindowManager(this);
TiXmlDocument *pDocXml = new TiXmlDocument;
int nSize = ::GlobalSize(hMem);
char *p = new char[nSize + 2];
memcpy(p, pXMLData, nSize);
p[nSize] = _T('\0');
p[nSize+1] = _T('\0');
wchar_t *pW = (wchar_t *)p;
pW++;
pDocXml->Parse(pW, NULL);
SAFE_DELETE_ARRAY(p);
ReleaseResource(hMem, pStream);
TiXmlElement *pElement = NULL;
TiXmlHandle xmlHandler(pDocXml->FirstChildElement(_T("directui")));
pElement = xmlHandler.FirstChildElement(_T("theme")).Element();
if (!pResManager->OnCreate(pElement))
{
delete pResManager;
delete pDocXml;
_tcsncpy(m_szSkinPath, szOldSkinPath, MAX_PATH);
return FALSE;
}
duJavaScript *pJavaScript = new duJavaScript;
hMem = NULL;
pStream = NULL;
PBYTE pByte = GetResource(_T("DirectUI.js"), hMem, pStream);
if (pByte == NULL || pStream == NULL || hMem == NULL)
{
delete pResManager;
delete pDocXml;
delete pJavaScript;
_tcsncpy(m_szSkinPath, szOldSkinPath, MAX_PATH);
return FALSE;
}
nSize = GlobalSize(hMem);
p = new char[nSize + 128];
ZeroMemory(p, nSize);
memcpy(p, pByte, nSize);
p[nSize] = _T('\0');
p[nSize+1] = _T('\0');
pW = (wchar_t *)p;
pW++;
lstrcat(pW, _T("\r\nCollectGarbage();\r\n"));
pJavaScript->InitJavaScript(pW);
SAFE_DELETE_ARRAY(p);
pJavaScript->AddObject(_T("winManager"), this);
pJavaScript->AddObject(_T("resManager"), pResManager);
if (m_pDocXml)
delete m_pDocXml;
if (m_pJavaScript)
delete m_pJavaScript;
if (m_pResManager)
delete m_pResManager;
//
m_pDocXml = pDocXml;
m_pResManager = pResManager;
m_pJavaScript = pJavaScript;
ResetEditHFont();
return TRUE;
}
//////////////////////////////////////////////////////////////////////////
// Member
BOOL WINAPI duWindowManager::OpenSkin(LPCTSTR lpszXmlFile)
{
if (lpszXmlFile == NULL || *lpszXmlFile == 0)
return FALSE;
InitTrialBitmap();
LPCTSTR lpszTypeName = GetTypeInfoName();
ITypeInfo *pTypeInfo = GetTypeInfoByName(lpszTypeName);
SetTypeInfo(pTypeInfo);
_tcsncpy(m_szSkinPath, lpszXmlFile, MAX_PATH);
TCHAR *lpszChar = _tcsrchr(m_szSkinPath, '\\');
if (lpszChar == NULL)
{
ZeroMemory(m_szSkinPath, MAX_PATH * sizeof(TCHAR));
return FALSE;
}
lpszChar++;
*lpszChar = 0;
IStream *pStream = NULL;
HANDLE hMem = NULL;
PBYTE pByte = GetResource(_T("config.xml"), hMem, pStream);
if (pByte == NULL || pStream == NULL || hMem == NULL)
return FALSE;
m_pResManager = new duResManager();
m_pResManager->SetWindowManager(this);
m_pDocXml = new TiXmlDocument;
#ifdef _UNICODE
int nSize = GlobalSize(hMem);
char *p = new char[nSize + 2];
memcpy(p, pByte, nSize);
p[nSize] = _T('\0');
p[nSize+1] = _T('\0');
wchar_t *pW = (wchar_t *)p;
pW++;
m_pDocXml->Parse(pW, NULL);
SAFE_DELETE_ARRAY(p);
#else
m_pDocXml->Parse((LPCTSTR)pByte, NULL);
#endif
ReleaseResource(hMem, pStream);
TiXmlElement *pElement = NULL;
TiXmlHandle xmlHandler(m_pDocXml->FirstChildElement(_T("directui")));
pElement = xmlHandler.FirstChildElement(_T("theme")).Element();
if (!m_pResManager->OnCreate(pElement))
return FALSE;
//
//×öÑźÚ×ÖÌåµÄÅжϣ¬Èç¹ûûÓÐÑźÚ×ÖÌ壬¾Í½«ÑźڼӴָÄΪÕý³£´ÖϸµÄ
//
g_bYaheiExist = FALSE;
EnumFonts(::GetDC(NULL), NULL, (FONTENUMPROC)FPC_EnumFontProc, NULL);
if (!g_bYaheiExist) //Ñźڲ»´æÔÚ
{
int i;
int nFontCount = m_pResManager->GetResObjCount(DU_RES_FONT);
for (i = 0;i < nFontCount; i++)
{
duFont *pFont = (duFont *)m_pResManager->GetResObjByIndex(i,DU_RES_FONT);
if (pFont->GetWeight() != 400)
{
pFont->SetWeight(400);
pFont->CreateFont();
}
}
}
m_pJavaScript = new duJavaScript;
hMem = NULL;
pStream = NULL;
pByte = GetResource(_T("DirectUI.js"), hMem, pStream);
if (pByte == NULL || pStream == NULL || hMem == NULL)
return TRUE;
nSize = GlobalSize(hMem);
p = new char[nSize + 128];
ZeroMemory(p, nSize);
memcpy(p, pByte, nSize);
p[nSize] = _T('\0');
p[nSize+1] = _T('\0');
pW = (wchar_t *)p;
pW++;
lstrcat(pW, _T("\r\nCollectGarbage();\r\n"));
m_pJavaScript->InitJavaScript(pW);
SAFE_DELETE_ARRAY(p);
lpszTypeName = m_pResManager->GetTypeInfoName();
pTypeInfo = GetTypeInfoByName(lpszTypeName);
m_pResManager->SetTypeInfo(pTypeInfo);
ReleaseResource(hMem, pStream);
m_pJavaScript->AddObject(_T("winManager"), this);
m_pJavaScript->AddObject(_T("resManager"), m_pResManager);
return TRUE;
}
// Create
void* allpassmod_new(t_symbol* s, long argc, t_atom* argv)
{
t_allpassmod* x = (t_allpassmod*)object_alloc(s_allpassmod_class);
long attrstart = attr_args_offset(argc, argv); // support normal arguments
TTString name = "/";
TTPtr context = TTPtr(x);
TTValue none;
object_obex_lookup(x, gensym("#P"), (t_object**)&context);
if (attrstart) {
if (atom_getsym(argv)->s_name[0] == '/')
name += atom_getsym(argv)->s_name + 1;
else
name += atom_getsym(argv)->s_name;
}
else
name += s->s_name;
x->name = TTAddress(name); // need to cache so we can free
// 1. Create the DSP objects
x->allpass = TTAudioObject("allpass.1", 2);
x->signalOut = TTObject(kTTSym_audiosignal, 2);
x->signalIn = TTObject(kTTSym_audiosignal, 2);
// 2. Create the "model" container
{
TTValue container_args; // TODO: (optional) pass address callback and value callback (these are both for the activity return mechanism)
x->model = TTObject(kTTSym_Container, container_args);
x->model.set(kTTSym_tags, kTTSym_model);
TTValue registration_args(x->name, x->model, context);
MaxApplication.send("ObjectRegister", registration_args, none);
x->model.set("address", x->name);
}
// 3. Create the "clear" message
{
x->message_clear = TTObject(kTTSym_Data, kTTSym_message);
x->message_clear.set(kTTSym_baton, TTPtr(x));
x->message_clear.set(kTTSym_function, TTPtr(allpassmod_parameter_clear_callback));
x->message_clear.set(kTTSym_type, kTTSym_none);
x->message_clear.set(kTTSym_description, TTSymbol("Clear the filter history"));
TTAddress address = x->name.appendAddress("/clear");
TTValue registration_args(address, x->message_clear, context);
MaxApplication.send("ObjectRegister", registration_args, none);
}
// 4. Create the "gain" parameter (linear)
{
x->parameter_coefficient = TTObject(kTTSym_Data, kTTSym_parameter);
x->parameter_coefficient.set(kTTSym_baton, TTPtr(x));
x->parameter_coefficient.set(kTTSym_function, TTPtr(allpassmod_parameter_coefficient_callback));
x->parameter_coefficient.set(kTTSym_type, kTTSym_decimal);
x->parameter_coefficient.set(kTTSym_valueDefault, 0.7);
x->parameter_coefficient.set(kTTSym_description, TTSymbol("Gain coefficient"));
TTAddress address = x->name.appendAddress("/coefficient");
TTValue registration_args(address, x->parameter_coefficient, context);
MaxApplication.send("ObjectRegister", registration_args, none);
}
// 5. Create the "delay" parameter (milliseconds)
{
x->parameter_delay = TTObject(kTTSym_Data, kTTSym_parameter);
x->parameter_delay.set(kTTSym_baton, TTPtr(x));
x->parameter_delay.set(kTTSym_function, TTPtr(allpassmod_parameter_delay_callback));
x->parameter_delay.set(kTTSym_type, kTTSym_decimal);
x->parameter_delay.set(kTTSym_valueDefault, 0.2);
x->parameter_delay.set(kTTSym_description, TTSymbol("Delay time"));
TTAddress address = x->name.appendAddress("/delay");
TTValue registration_args(address, x->parameter_delay, context);
MaxApplication.send("ObjectRegister", registration_args, none);
}
// 6. Create the Input access points
{
// left input
{
x->in_left = TTObject("Input.audio");
TTAddress address = x->name.appendAddress("/in.left");
TTValue registration_args(address, x->in_left, context);
MaxApplication.send("ObjectRegister", registration_args, none);
}
// right input
{
x->in_right = TTObject("Input.audio");
TTAddress address = x->name.appendAddress("/in.right");
TTValue registration_args(address, x->in_right, context);
MaxApplication.send("ObjectRegister", registration_args, none);
}
}
// 7. Create the Output access points
{
// left output
{
x->out_left = TTObject("Output.audio");
TTAddress address = x->name.appendAddress("/out.left");
TTValue registration_args(address, x->out_left, context);
MaxApplication.send("ObjectRegister", registration_args, none);
}
// right output
{
x->out_right = TTObject("Output.audio");
TTAddress address = x->name.appendAddress("/out.right");
TTValue registration_args(address, x->out_right, context);
MaxApplication.send("ObjectRegister", registration_args, none);
}
}
// 8. Add the preset functions
{
x->preset = TTObject(kTTSym_PresetManager);
x->preset.set("address", x->name);
TTAddress address = x->name.appendAddress("/preset");
TTValue registration_args(address, x->preset, context);
MaxApplication.send("ObjectRegister", registration_args, none);
// load a preset file and recall the first preset
{
TTValue out;
TTObject xmlHandler("XmlHandler");
// set the object attr of the above object to be the PresetManager
xmlHandler.set("object", x->preset);
// TODO : get the filepath as an argument
TTSymbol path;
xmlHandler.send("Read", path, out);
// recall the first preset
x->preset.send("Recall", 1, none);
}
}
// 9. Initialize the module (set default values, etc)
x->model.send("Init");
// 10. Do some final Max-specific stuff
dsp_setup((t_pxobject*)x, 2);
x->obj.z_misc = Z_NO_INPLACE;
for (int i=0; i < 2; i++)
outlet_new((t_pxobject*)x, "signal");
attr_args_process(x, argc, argv);
return x;
}
int main(int argc, const char * argv[])
{
// parsing arguments (ignoring the first)
TTValue args;
for (TTUInt8 i = 1; i < argc; i++)
{
TTSymbol arg(argv[i]);
args.append(arg);
}
// check for file path
if (args.size() == 1)
{
if (args[0].type() == kTypeSymbol)
{
TTSymbol filepath = args[0]; // .score file to load
// initialisation of Modular environnement (passing the folder path where all the dylibs are)
TTModularInit("/usr/local/jamoma", true);
// create an application manager
TTObject applicationManager("ApplicationManager");
// create a local application named i-score
TTObject applicationLocal = applicationManager.send("ApplicationInstantiateLocal", "i-score");
// loads protocol unit
// TODO : when parsing project file
{
// create Minuit protocol unit
TTObject protocolMinuit = applicationManager.send("ProtocolInstantiate", "Minuit");
// create OSC protocol unit
TTObject protocolOSC = applicationManager.send("ProtocolInstantiate", "OSC");
// create WebSocket protocol unit
TTObject protocolWebSocket = applicationManager.send("ProtocolInstantiate", "WebSocket");
}
// initialisation of Score environnement (passing the folder path where all the dylibs are)
TTScoreInit("/usr/local/jamoma");
// create a scenario
TTObject scenario("Scenario");
// load project file
TTObject xmlHandler("XmlHandler");
xmlHandler.set("object", TTValue(applicationManager, scenario));
xmlHandler.send("Read", filepath);
// run scenario
scenario.send("Start");
// wait for scenario
TTBoolean running;
do
{
sleep(1);
scenario.get("running", running);
}
while (running);
return EXIT_SUCCESS;
}
}
return EXIT_FAILURE;
}
