DISTRHO
/
DISTRHO-Ports-Extra
mirror of https://github.com/DISTRHO/DISTRHO-Ports-Extra
1
0
Fork 0
Code Releases 0 Activity
Extra "ports" of juce-based plugins using the distrho build system
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
28MB
Tree: d45623e876
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd45623e876'
${ noResults }
DISTRHO-Ports-Extra/ports/cabbage/source/CabbageGUIClass.cpp

1886 lines
67KB
Raw Blame History 

  1. /*

  2.   Copyright (C) 2007 Rory Walsh

  3. 

  4.   Cabbage is free software; you can redistribute it

  5.   and/or modify it under the terms of the GNU Lesser General Public

  6.   License as published by the Free Software Foundation; either

  7.   version 2.1 of the License, or (at your option) any later version.

  8.    

  9.   Cabbage is distributed in the hope that it will be useful,

  10.   but WITHOUT ANY WARRANTY; without even the implied warranty of

  11.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12.   GNU Lesser General Public License for more details.

  13. 

  14.   You should have received a copy of the GNU Lesser General Public

  15.   License along with Csound; if not, write to the Free Software

  16.   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

  17.   02111-1307 USA

  18.   

  19. */

  20.   

  21. #include "CabbageGUIClass.h"

  22. 

  23. CabbageGUIClass::CabbageGUIClass(String compStr, int ID):

  24. 								debugMessage(""), 

  25. 								plant(""), 

  26. 								reltoplant(""), 

  27. 								scaleX(1), 

  28. 								scaleY(1), 

  29. 								midiChan(-99), 

  30. 								midiCtrl(-99),

  31. 								boundsText(""),

  32. 								posText(""),

  33. 								sizeText(""),

  34. 								preset(""),

  35. 								trackerFill(),

  36. 								masterSnap(0),

  37. 								width(0),

  38. 								height(0),

  39. 								left(0),

  40. 								top(0), 

  41. 								fill(Colours::cornflowerblue),

  42. 								xyAutoIndex(0),

  43. 								fileType(""),

  44. 								workingDir(""),

  45. 								alpha(1),

  46. 								sliderRange(1),

  47. 								numTables(0),

  48. 								sliderIncr(.01),

  49. 								decimalPlaces(0),

  50. 								tabbed(0),

  51. 								soundfilerIndex(0),

  52. 								native("")

  53. {

  54. //Default values are assigned to all attributres 

  55. //before parsing begins

  56. 	cabbageIdentifiers.set("scalex", 1);

  57. 	cabbageIdentifiers.set("scaley", 1);

  58. 	items.clear();

  59. 	items.add("");

  60. 	key.clear();

  61. 	min=0;

  62. 	max=1;

  63. 	sliderSkew = 1;

  64. 	value = 0;

  65. 	StringArray strTokens;

  66. 	strTokens.addTokens(compStr, " ", "\"");

  67. 	//changing case to lower to make syntax non case-sensitive

  68. 

  69. 	//===============sliders==================//

  70. 	if(strTokens[0].trim() == "hslider"){

  71. 		cabbageIdentifiers.set(CabbageIDs::basetype, "interactive");

  72. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  73. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  74. 		cabbageIdentifiers.set(CabbageIDs::width, 150);

  75. 		cabbageIdentifiers.set(CabbageIDs::height, 50);		

  76. 		var channels;

  77. 		channels.append("hslider");

  78. 		cabbageIdentifiers.set(CabbageIDs::channel, channels);

  79. 		cabbageIdentifiers.set(CabbageIDs::min, 0);

  80. 		cabbageIdentifiers.set(CabbageIDs::max, 100);	

  81. 		cabbageIdentifiers.set(CabbageIDs::value, 50);

  82. 		cabbageIdentifiers.set(CabbageIDs::text, "");

  83. 		cabbageIdentifiers.set(CabbageIDs::textbox, 0.f);

  84. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  85. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::white.toString());

  86. 		cabbageIdentifiers.set(CabbageIDs::trackercolour, Colours::lime.toString());

  87. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, CabbageUtils::getComponentFontColour().toString());	

  88. 		cabbageIdentifiers.set(CabbageIDs::sliderskew, 1);

  89. 		cabbageIdentifiers.set(CabbageIDs::sliderincr, .0001);

  90. 		cabbageIdentifiers.set(CabbageIDs::midichan, -99);

  91. 		cabbageIdentifiers.set(CabbageIDs::midictrl, -99);

  92. 

  93. 		//these don't appear in the props dialog

  94. 		cabbageIdentifiers.set(CabbageIDs::name, "hslider");

  95. 		cabbageIdentifiers.set(CabbageIDs::type, cabbageIdentifiers.getWithDefault("name", "").toString());

  96. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  97. 		cabbageIdentifiers.set(CabbageIDs::kind, "horizontal");

  98. 		cabbageIdentifiers.set(CabbageIDs::decimalplaces, 1);

  99. 

  100. 	}

  101.     else if(strTokens[0].trim() == "vslider"){

  102. 		cabbageIdentifiers.set(CabbageIDs::basetype, "interactive");

  103. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  104. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  105. 		cabbageIdentifiers.set(CabbageIDs::width, 50);

  106. 		cabbageIdentifiers.set(CabbageIDs::height, 150);	

  107. 		var channels;

  108. 		channels.append("vslider");

  109. 		cabbageIdentifiers.set(CabbageIDs::channel, channels);		  

  110. 		cabbageIdentifiers.set(CabbageIDs::min, 0);

  111. 		cabbageIdentifiers.set(CabbageIDs::max, 100);	

  112. 		cabbageIdentifiers.set(CabbageIDs::value, 50);

  113. 		cabbageIdentifiers.set(CabbageIDs::text, "");

  114. 		cabbageIdentifiers.set(CabbageIDs::textbox, 0.f);

  115. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  116. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::white.toString());

  117. 		cabbageIdentifiers.set(CabbageIDs::trackercolour, Colours::lime.toString());

  118. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, CabbageUtils::getComponentFontColour().toString());	

  119. 		cabbageIdentifiers.set(CabbageIDs::sliderskew, 1);

  120. 		cabbageIdentifiers.set(CabbageIDs::sliderincr, .0001);

  121. 		cabbageIdentifiers.set(CabbageIDs::midichan, -99);

  122. 		cabbageIdentifiers.set(CabbageIDs::midictrl, -99);

  123. 	

  124. 		//these don't appear in the props dialog

  125. 		cabbageIdentifiers.set(CabbageIDs::name, "vslider");

  126. 		cabbageIdentifiers.set(CabbageIDs::type, cabbageIdentifiers.getWithDefault("name", "").toString());

  127. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  128. 		cabbageIdentifiers.set(CabbageIDs::kind, "vertical");

  129. 		cabbageIdentifiers.set(CabbageIDs::decimalplaces, 1);	

  130. 		

  131. 

  132. 	}

  133.     else if(strTokens[0].trim() == "rslider"){

  134. 		cabbageIdentifiers.set(CabbageIDs::basetype, "interactive");

  135. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  136. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  137. 		cabbageIdentifiers.set(CabbageIDs::width, 60);

  138. 		cabbageIdentifiers.set(CabbageIDs::height, 60);

  139. 		var channels;

  140. 		channels.append("rslider");

  141. 		cabbageIdentifiers.set(CabbageIDs::channel, channels);	

  142. 		cabbageIdentifiers.set(CabbageIDs::min, 0);

  143. 		cabbageIdentifiers.set(CabbageIDs::max, 100);	

  144. 		cabbageIdentifiers.set(CabbageIDs::value, 50);

  145. 		cabbageIdentifiers.set(CabbageIDs::text, "");

  146. 		cabbageIdentifiers.set(CabbageIDs::textbox, 0.f);

  147. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  148. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::white.toString());

  149. 		cabbageIdentifiers.set(CabbageIDs::trackercolour, Colours::lime.toString());

  150. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, CabbageUtils::getComponentFontColour().toString());	

  151. 		cabbageIdentifiers.set(CabbageIDs::sliderskew, 1);

  152. 		cabbageIdentifiers.set(CabbageIDs::sliderincr, .0001);

  153. 		cabbageIdentifiers.set(CabbageIDs::midichan, -99);

  154. 		cabbageIdentifiers.set(CabbageIDs::midictrl, -99);

  155. 		

  156. 		//these don't appear in the props dialog

  157. 		cabbageIdentifiers.set(CabbageIDs::name, "rslider");

  158. 		cabbageIdentifiers.set(CabbageIDs::type, cabbageIdentifiers.getWithDefault("name", "").toString());

  159. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  160. 		cabbageIdentifiers.set(CabbageIDs::kind, "rotary");

  161. 		cabbageIdentifiers.set(CabbageIDs::decimalplaces, 1);			

  162. 		

  163. 	}

  164. 

  165.     else if(strTokens[0].trim() == "source"){

  166. 		  cabbageIdentifiers.set("basetype", "layout");

  167.           top = 10;

  168.           left = 10;

  169.           width = 400;

  170.           height = 240;

  171.           channel = "";

  172.           name = "source";

  173. 		  caption = "";

  174. 		  type = name;

  175.           //name.append(String(ID), 1024);

  176. 	}

  177. 

  178. 	//===============info button==================//

  179.     else if(strTokens[0].trim() == "infobutton"){

  180. 		  cabbageIdentifiers.set("basetype", "layout");

  181.           top = 10;

  182.           left = 10;

  183.           width = 600;

  184.           height = 440;

  185.           channel = "";

  186.           name = "infobutton";

  187. 		  caption = "";

  188. 		  type = name;

  189.           //name.append(String(ID), 1024);

  190. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  191. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  192. 		cabbageIdentifiers.set(CabbageIDs::width, 80);

  193. 		cabbageIdentifiers.set(CabbageIDs::height, 40);	

  194. 		cabbageIdentifiers.set(CabbageIDs::text, "");

  195. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  196. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::black.toString());	

  197. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, Colours::white.toString());	

  198. 		cabbageIdentifiers.set(CabbageIDs::type, "infobutton");

  199. 		cabbageIdentifiers.set(CabbageIDs::name, "infobutton");

  200. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  201. 		

  202. 	}

  203. 

  204. 	//===============directory list==================//

  205.     else if(strTokens[0].trim() == "directorylist"){

  206. 		  cabbageIdentifiers.set("basetype", "layout");

  207.           top = 10;

  208.           left = 10;

  209.           width = 600;

  210.           height = 440;

  211.           channel = "";

  212.           name = "directorylist";

  213. 		  caption = "";

  214. 		  type = name;

  215.           //name.append(String(ID), 1024);

  216. 	}

  217. 

  218. 

  219.     else if(strTokens[0].trim() == "patmatrix"){

  220. 		  cabbageIdentifiers.set("basetype", "layout");

  221.           top = 10;

  222.           left = 10;

  223.           width = 400;

  224.           height = 240;

  225.           channel = "";

  226.           name = "patmatrix";

  227. 		  caption = "Pattern Matrix";

  228. 		  type = name;

  229. 		  noSteps = 8;

  230. 		  noPatterns=1;

  231. 		  rCtrls=0;

  232.           //name.append(String(ID), 1024);

  233. 	}

  234. 

  235. 	//===============file button==================//

  236.     else if(strTokens[0].trim() == "filebutton"){

  237. 		cabbageIdentifiers.set("basetype", "layout");

  238. 		top = 10;

  239. 		left = 10;

  240. 		width = 80;

  241. 		height = 40;

  242. 		channel = "filebuttonchan";

  243. 		var array;

  244. 		array.append("Open file");

  245. 		array.append("Open file");

  246. 		items.add("");

  247. 		items.add("");

  248. 		name = "filebutton";

  249. 		max = 1;

  250. 		min = 0;

  251. 		caption = "";

  252. 		type = name;

  253. 		name.append(String(ID), 1024);

  254. 

  255. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  256. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  257. 		cabbageIdentifiers.set(CabbageIDs::width, 80);

  258. 		cabbageIdentifiers.set(CabbageIDs::height, 40);	

  259. 		var channels;

  260. 		channels.append("filebutton");

  261. 		cabbageIdentifiers.set(CabbageIDs::channel, channels);

  262. 		cabbageIdentifiers.set(CabbageIDs::value, 1);	

  263. 		cabbageIdentifiers.set(CabbageIDs::text, array);

  264. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  265. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::black.toString());	

  266. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, Colours::white.toString());	

  267. 		cabbageIdentifiers.set(CabbageIDs::type, "filebutton");

  268. 		cabbageIdentifiers.set(CabbageIDs::name, "filebutton");

  269. 		cabbageIdentifiers.set(CabbageIDs::mode, "open");

  270. 		

  271. 		

  272. 		cabbageIdentifiers.set("name", cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));	

  273. 		var populate;

  274. 		populate.append("");

  275. 		populate.append("");

  276. 		cabbageIdentifiers.set("populate", populate);  

  277. 	}

  278. 

  279. 	//===============button==================//

  280.     else if(strTokens[0].trim() == "button"){

  281. 		cabbageIdentifiers.set("basetype", "interactive");

  282. 		top = 10;

  283. 		left = 10;

  284. 		width = 80;

  285. 		height = 40;

  286. 		channel = "buttonchan";

  287. 		items.add("");

  288. 		items.add("");

  289. 		name = "button";

  290. 		max = 1;

  291. 		min = 0;

  292. 		caption = "";

  293. 		type = name;

  294. 		name.append(String(ID), 1024);

  295. 

  296. 		var array;

  297. 		array.append("Push me");

  298. 		array.append("Push me");

  299. 

  300. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  301. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  302. 		cabbageIdentifiers.set(CabbageIDs::width, 80);

  303. 		cabbageIdentifiers.set(CabbageIDs::height, 40);	

  304. 		var channels;

  305. 		channels.append("buttonchan");

  306. 		cabbageIdentifiers.set(CabbageIDs::channel, channels);

  307. 		cabbageIdentifiers.set(CabbageIDs::value, 1);	

  308. 		cabbageIdentifiers.set(CabbageIDs::text, array);

  309. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  310. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::black.toString());	

  311. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, Colours::white.toString());	

  312. 		cabbageIdentifiers.set(CabbageIDs::latched, 1);

  313. 		cabbageIdentifiers.set(CabbageIDs::type, "button");

  314. 		cabbageIdentifiers.set(CabbageIDs::name, "button");

  315. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  316. 		  

  317. 	}

  318. 

  319. 	//===============checkbox==================//

  320.     else if(strTokens[0].trim() == "checkbox"){

  321. 		cabbageIdentifiers.set("basetype", "interactive");

  322. 		top = 10;

  323. 		left = 10;

  324. 		width = 100;

  325. 		height = 22;

  326. 		channel = "checkchan";

  327. 		type = "checkbox";

  328. 		caption = "";

  329. 		name = "checkbox";

  330. 		caption = "";

  331. 		items.add("");

  332. 

  333. 		var array;

  334. 		array.append("Check box");

  335. 

  336. 		min = 0;

  337. 		max = 1;

  338. 		shape = "square";

  339. 		name.append(String(ID), 1024);

  340. 		//default colour for toggles

  341. 		colour = Colours::lime;

  342. 

  343. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  344. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  345. 		cabbageIdentifiers.set(CabbageIDs::width, 100);

  346. 		cabbageIdentifiers.set(CabbageIDs::height, 22);	

  347. 		var channels;

  348. 		channels.append("checkchan");

  349. 		cabbageIdentifiers.set(CabbageIDs::channel, channels);

  350. 		cabbageIdentifiers.set(CabbageIDs::text, array);

  351. 		cabbageIdentifiers.set(CabbageIDs::value, 0);	

  352. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  353. 		cabbageIdentifiers.set(CabbageIDs::shape, "square");

  354. 		

  355. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::lime.toString());	

  356. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, CabbageUtils::getComponentFontColour().toString());

  357. 		cabbageIdentifiers.set(CabbageIDs::type, "checkbox");

  358. 		cabbageIdentifiers.set(CabbageIDs::name, "checkbox");

  359. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));		  

  360. 		  

  361. 	}

  362. 	//===============combobox==================//

  363.     else if(strTokens[0].trim() == "combobox"){

  364. 		cabbageIdentifiers.set("basetype", "interactive");

  365. 		items.clear();

  366. 		top = 10;

  367. 		left = 10;

  368. 		width = 80;

  369. 		height = 22;

  370. 		channel = "combochan";

  371. 		caption = "";

  372. 		//add one item by befault, will be overwritten by users values

  373. 		var array;

  374. 		array.append("Item 1");

  375. 		array.append("Item 2");

  376. 		array.append("Item 3");

  377. 		array.append("Item 4");

  378. 

  379. 		items.add("Item 1");

  380. 		items.add("Item 2");

  381. 		items.add("Item 3");

  382. 		items.add("Item 4");

  383. 

  384. 

  385. 		name = "combobox";		 

  386. 		type = name;

  387. 		name.append(String(ID), 1024);

  388. 		min=1;

  389. 		value = 1;

  390. 

  391. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  392. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  393. 		cabbageIdentifiers.set(CabbageIDs::width, 80);

  394. 		cabbageIdentifiers.set(CabbageIDs::height, 20);	

  395. 		var channels;

  396. 		channels.append("combochan");

  397. 		cabbageIdentifiers.set(CabbageIDs::channel, channels);

  398. 		cabbageIdentifiers.set(CabbageIDs::channeltype, "number");

  399. 		cabbageIdentifiers.set(CabbageIDs::text, array);

  400. 		cabbageIdentifiers.set(CabbageIDs::value, 1);	

  401. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  402. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::black.toString());

  403. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, CabbageUtils::getComponentFontColour().toString());

  404. 		cabbageIdentifiers.set(CabbageIDs::type, "combobox");

  405. 		cabbageIdentifiers.set(CabbageIDs::name, "combobox");		

  406. 		cabbageIdentifiers.set(CabbageIDs::comborange, 4);

  407. 		var populate;

  408. 		populate.append("");

  409. 		populate.append("");

  410. 		cabbageIdentifiers.set(CabbageIDs::populate, populate);

  411. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  412. 		 

  413. 	} 

  414. 	//===============label==================//

  415.     else if(strTokens[0].trim() == "label"){

  416. 		cabbageIdentifiers.set("basetype", "layout");

  417. 		top = 10;

  418. 		left = 10;

  419. 		width = 100;

  420. 		height = 16;

  421. 		channel = "label";

  422. 		beveltype = "none";

  423. 		colour = CabbageUtils::getComponentFontColour();

  424. 		fontcolour = CabbageUtils::getComponentFontColour();

  425. 		text = "hello";

  426. 		name = "label";

  427. 		type = name;

  428. 		

  429. 		name.append(String(ID), 1024);

  430. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  431. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  432. 		cabbageIdentifiers.set(CabbageIDs::width, 80);

  433. 		cabbageIdentifiers.set(CabbageIDs::height, 16);	

  434. 		cabbageIdentifiers.set(CabbageIDs::text, "hello");	

  435. 		cabbageIdentifiers.set(CabbageIDs::min, 1);

  436. 		cabbageIdentifiers.set(CabbageIDs::name, "label");

  437. 		cabbageIdentifiers.set(CabbageIDs::type, cabbageIdentifiers.getWithDefault("name", "").toString());

  438. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  439. 		cabbageIdentifiers.set(CabbageIDs::colour, CabbageUtils::getComponentFontColour().toString());

  440. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, CabbageUtils::getComponentFontColour().toString());

  441. 	}

  442. 	//===============multitab==================//	

  443.     else if(strTokens[0].trim() == "multitab"){

  444. 		cabbageIdentifiers.set("basetype", "layout");

  445. 		top = 10;

  446. 		left = 10;

  447. 		width = 100;

  448. 		height = 16;

  449. 		channel = "multitab";

  450. 		colour = CabbageUtils::getComponentFontColour();

  451. 		fontcolour = CabbageUtils::getComponentFontColour();

  452. 		items.add("Tab 1");

  453. 		name = "multitab";

  454. 		type = name;

  455. 		name.append(String(ID), 1024);

  456. 	}	

  457. 	//===============soundfiler==================//	

  458.     else if(strTokens[0].trim() == "soundfiler"){

  459. 		cabbageIdentifiers.set("basetype", "layout");

  460. 		top = 10;

  461. 		left = 10;

  462. 		width = 300;

  463. 		height = 200;

  464. 		colour = Colours::lime;

  465. 		fontcolour = CabbageUtils::getComponentFontColour();

  466. 		text = "";

  467. 		name = "soundfiler";

  468. 		type = name;

  469. 		name.append(String(ID), 1024);

  470. 

  471. 

  472. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  473. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  474. 		cabbageIdentifiers.set(CabbageIDs::width, 300);

  475. 		cabbageIdentifiers.set(CabbageIDs::height, 200);	

  476. 		var channels;

  477. 		channels.append("soundfiler1");

  478. 		channels.append("soundfiler2");

  479. 		cabbageIdentifiers.set(CabbageIDs::channel, channels);	  

  480. 		cabbageIdentifiers.set(CabbageIDs::colour, CabbageUtils::getComponentFontColour().toString());

  481. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, CabbageUtils::getComponentFontColour().toString());

  482. 		cabbageIdentifiers.set(CabbageIDs::type, "soundfiler");

  483. 		cabbageIdentifiers.set(CabbageIDs::name, "soundfiler");

  484. 		cabbageIdentifiers.set(CabbageIDs::file, "");

  485. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  486. 	}	

  487. 	//===============snapshot==================//	

  488.     else if(strTokens[0].trim() == "snapshot"){

  489. 		cabbageIdentifiers.set("basetype", "layout");

  490. 		items.clear();

  491. 		top = 10;

  492. 		left = 10;

  493. 		width = 200;

  494. 		height = 20;

  495. 		channel = "snapshot";

  496. 		colour = CabbageUtils::getComponentFontColour();

  497. 		fontcolour = Colours::white;

  498. 		text = "Snap";

  499. 		name = "snapshot";

  500. 		type = name;

  501. 		name.append(String(ID), 1024);

  502. 		items.add("One");

  503. 		items.add("Two");

  504. 		items.add("Three");

  505. 		items.add("Four");

  506. 		min=1;

  507. 		value=1;

  508. 		var val;

  509. 		val.append("One");

  510. 		val.append("Two");

  511. 		val.append("Three");

  512. 		val.append("Four");

  513. 		val.append("Five");

  514. 

  515. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  516. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  517. 		cabbageIdentifiers.set(CabbageIDs::width, 200);

  518. 		cabbageIdentifiers.set(CabbageIDs::height, 20);	

  519. 		cabbageIdentifiers.set(CabbageIDs::text, val);

  520. 		cabbageIdentifiers.set(CabbageIDs::value, value);

  521. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, Colours::white.toString());

  522. 		cabbageIdentifiers.set(CabbageIDs::colour, CabbageUtils::getComponentFontColour().toString());

  523. 		cabbageIdentifiers.set(CabbageIDs::type, "snapshot");

  524. 		cabbageIdentifiers.set(CabbageIDs::name, "snapshot");

  525. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  526. 

  527. 		  

  528. 	}

  529. 	//===============image==================//

  530.     else if(strTokens[0].trim() == "image"){

  531. 		cabbageIdentifiers.set("basetype", "layout");

  532. 		top = 10;

  533. 		left = 10;

  534. 		width = 160;

  535. 		height = 120;

  536. 		channel = "";

  537. 		beveltype = "none";

  538. 		fontcolour = Colours::white;

  539. 		text = "";

  540. 		line = 2;

  541. 		name = "image";

  542. 		type = name;

  543. 		shape="rounded";

  544. 		outline = Colours::black;

  545. 		colour = Colours::white;

  546. 		name.append(String(ID), 1024);

  547. 		plantButton = 0;

  548. 

  549. 

  550. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  551. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  552. 		cabbageIdentifiers.set(CabbageIDs::width, 160);

  553. 		cabbageIdentifiers.set(CabbageIDs::height, 120);	

  554. 		cabbageIdentifiers.set(CabbageIDs::shape, "rounded");		

  555. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::white.toString());

  556. 		cabbageIdentifiers.set(CabbageIDs::outline, Colours::white.toString());

  557. 		cabbageIdentifiers.set(CabbageIDs::popup, 0);

  558. 		cabbageIdentifiers.set(CabbageIDs::plant, "");

  559. 		cabbageIdentifiers.set(CabbageIDs::type, "image");

  560. 		cabbageIdentifiers.set(CabbageIDs::file, "");

  561. 		cabbageIdentifiers.set(CabbageIDs::name, "image");

  562. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  563. 		  

  564. 	}

  565. 	//===============groupbox==================//

  566.     else if(strTokens[0].trim() == "groupbox"){

  567. 		line = 1;

  568. 		plantButton = 0;

  569. 		cabbageIdentifiers.set(CabbageIDs::basetype, "layout");

  570. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  571. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  572. 		cabbageIdentifiers.set(CabbageIDs::width, 80);

  573. 		cabbageIdentifiers.set(CabbageIDs::height, 22);		

  574. 		cabbageIdentifiers.set(CabbageIDs::colour, CabbageUtils::getComponentSkin().toString());

  575. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, CabbageUtils::getComponentFontColour().toString());	

  576. 		cabbageIdentifiers.set(CabbageIDs::popup, 0);

  577. 		cabbageIdentifiers.set(CabbageIDs::plant, "");

  578. 		cabbageIdentifiers.set(CabbageIDs::line, 1);

  579. 		cabbageIdentifiers.set(CabbageIDs::type, "groupbox");

  580. 		cabbageIdentifiers.set(CabbageIDs::name, "groupbox");

  581. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));		  

  582. 		  

  583. 	}

  584. 	//===============line==================//

  585.     else if(strTokens[0].trim() == "line"){

  586. 		cabbageIdentifiers.set("basetype", "layout");

  587. 		top = 10;

  588. 		left = 10;

  589. 		width = 180;

  590. 		height = 2;

  591. 		name = "line";

  592. 		type = name;

  593. 		name.append(String(ID), 1024);

  594. 

  595. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  596. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  597. 		cabbageIdentifiers.set(CabbageIDs::width, 160);

  598. 		cabbageIdentifiers.set(CabbageIDs::height, 2);	

  599. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::white.toString());

  600. 		cabbageIdentifiers.set(CabbageIDs::type, "line");

  601. 		cabbageIdentifiers.set(CabbageIDs::name, "line");

  602. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  603. 		  

  604. 	}

  605. 	//===============transport==================//

  606.     else if(strTokens[0].trim() == "transport"){

  607. 		cabbageIdentifiers.set("basetype", "layout");

  608.           top = 0;

  609.           left = 0;

  610.           width = 100;

  611.           height = 40;

  612.           name = "transport";

  613. 		  type = name;

  614.           name.append(String(ID), 1024);

  615. 	}

  616. 	//===============csoundoutput==================//	

  617.     else if(strTokens[0].trim() == "csoundoutput"){

  618. 		cabbageIdentifiers.set("basetype", "layout");

  619. 		top = 10;

  620. 		left = 10;

  621. 		width = 400;

  622. 		height = 200;

  623. 		colour = Colours::white;

  624. 		name = "csoundoutput";

  625. 		type = name;

  626. 		name.append(String(ID), 1024);

  627. 

  628. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  629. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  630. 		cabbageIdentifiers.set(CabbageIDs::width, 400);

  631. 		cabbageIdentifiers.set(CabbageIDs::text, "Csound output");

  632. 		cabbageIdentifiers.set(CabbageIDs::height, 200);	

  633. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::white.toString());

  634. 		cabbageIdentifiers.set(CabbageIDs::name, "csoundoutput");

  635. 		cabbageIdentifiers.set(CabbageIDs::type, "csoundoutput");

  636. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  637. 

  638. 	}

  639. 	//===============vemeter==================//

  640.     else if(strTokens[0].trim() == "vumeter"){

  641. 		cabbageIdentifiers.set("basetype", "layout");

  642. 		top = 10;

  643. 		left = 10;

  644. 		width = 400;

  645. 		height = 200;

  646. 		vuConfig.clear();

  647. 		colour = Colours::white;

  648. 		name = "vumeter";

  649. 		type = name;

  650. 		name.append(String(ID), 1024);

  651. 	}

  652. 	//===============table==================//

  653.     else if(strTokens[0].trim() == "table"){

  654. 		cabbageIdentifiers.set("basetype", "layout");

  655. 		top = 10;

  656. 		left = 10;

  657. 		width = 400;

  658. 		height = 200;

  659. 		colour = Colours::lime;

  660. 		name = "table";

  661. 		type = name;

  662. 		value = 1;

  663. 		tableNum = 1;

  664. 		name.append(String(ID), 1024);

  665. 

  666. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  667. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  668. 		cabbageIdentifiers.set(CabbageIDs::width, 400);

  669. 		cabbageIdentifiers.set(CabbageIDs::height, 200);	

  670. 		cabbageIdentifiers.set(CabbageIDs::tablenumber, 1);

  671. 		cabbageIdentifiers.set(CabbageIDs::drawmode, 0);

  672. 		cabbageIdentifiers.set(CabbageIDs::resizemode, 0);

  673. 		cabbageIdentifiers.set(CabbageIDs::readonly, 0);

  674. 		cabbageIdentifiers.set(CabbageIDs::tablecolour, Colours::lime.toString());

  675. 		cabbageIdentifiers.set(CabbageIDs::amprange, 0);

  676. 		cabbageIdentifiers.set(CabbageIDs::type, "table");

  677. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  678. 		  

  679. 	}

  680.     else if(strTokens[0].trim() == "pvsview"){

  681. 		cabbageIdentifiers.set("basetype", "layout");

  682.           top = 10;

  683.           left = 10;

  684.           width = 400;

  685.           height = 200;

  686.           colour = Colours::white;

  687.           name = "pvsview";

  688. 		  type = name;

  689. 		  value = 1;

  690. 		  tableNum = 1;

  691.           name.append(String(ID), 1024);

  692. 		  overlapSize = 256;

  693. 		  fftSize = 1024;

  694. 		  frameSize = 1024;

  695. 	}

  696. 	//===============xypad==================//

  697.     else if(strTokens[0].trim() == "xypad"){

  698. 		cabbageIdentifiers.set("basetype", "interactive");

  699. 		top = 10;

  700. 		left = 10;

  701. 		width = 200;

  702. 		height = 200;

  703. 		xChannel = "xypadchanX";

  704. 		yChannel = "xypadchanY";

  705. 		channel = "";

  706. 		caption = "";

  707. 		name = "xypad";

  708. 		caption = "";

  709. 		minX = 0;

  710. 		maxX = 200;

  711. 		minY = 0;

  712. 		maxY = 200;

  713. 		valueX = 0;

  714. 		decimalPlaces = 2;

  715. 		valueY = 0;

  716. 		type = "xypad";

  717. 		name.append(String(ID), 1024);

  718. 		xyChannel = "";

  719. 		colour = Colours::lime;

  720. 		fontcolour = Colours::cornflowerblue;	

  721. 		var channels;

  722. 		channels.append("xChan");

  723. 		channels.append("yChan");

  724. 		cabbageIdentifiers.set(CabbageIDs::xyautoindex, 0);	

  725. 		cabbageIdentifiers.set(CabbageIDs::xchannel, channels[0]);

  726. 		cabbageIdentifiers.set(CabbageIDs::ychannel, channels[1]);

  727. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  728. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  729. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  730. 		cabbageIdentifiers.set(CabbageIDs::width, 200);

  731. 		cabbageIdentifiers.set(CabbageIDs::height, 200);

  732. 		cabbageIdentifiers.set(CabbageIDs::minx, 0);

  733. 		cabbageIdentifiers.set(CabbageIDs::maxx, 200);	

  734. 		cabbageIdentifiers.set(CabbageIDs::text, "");	

  735. 		cabbageIdentifiers.set(CabbageIDs::miny, 0);

  736. 		cabbageIdentifiers.set(CabbageIDs::maxy, 200);		

  737. 		cabbageIdentifiers.set(CabbageIDs::valuex, 0);	

  738. 		cabbageIdentifiers.set(CabbageIDs::valuey, 0);	

  739. 		cabbageIdentifiers.set(CabbageIDs::colour, Colours::lime.toString());	    

  740. 		cabbageIdentifiers.set(CabbageIDs::fontcolour, Colours::cornflowerblue.toString());	

  741. 		cabbageIdentifiers.set(CabbageIDs::type, "xypad");

  742. 		cabbageIdentifiers.set(CabbageIDs::name, "xypad");

  743. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));	    

  744. 		  

  745. 	}

  746. 	//===============keyboard==================//

  747.     else if(strTokens[0].trim() == "keyboard"){

  748. 		cabbageIdentifiers.set("basetype", "layout");

  749. 		top = 10;

  750. 		left = 10;

  751. 		width = 400;

  752. 		height = 100;

  753. 		name = "keyboard";

  754. 		type = name;

  755. 		name.append(String(ID), 1024);

  756. 		value=60;

  757. 

  758. 

  759. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  760. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  761. 		cabbageIdentifiers.set(CabbageIDs::width, 400);

  762. 		cabbageIdentifiers.set(CabbageIDs::height, 100);	

  763. 		cabbageIdentifiers.set(CabbageIDs::value, 60);	

  764. 		cabbageIdentifiers.set(CabbageIDs::type, "keyboard");	

  765. 		cabbageIdentifiers.set(CabbageIDs::name, "keyboard");

  766. 		cabbageIdentifiers.set(CabbageIDs::name, cabbageIdentifiers.getWithDefault("name", "").toString()+String(ID));

  767. 		  

  768. 	}

  769. 	//===============form==================//

  770.     else if(strTokens[0].trim() == "form"){

  771. 	    cabbageIdentifiers.set(CabbageIDs::basetype, "layout");

  772. 		cabbageIdentifiers.set(CabbageIDs::top, 10);

  773. 		cabbageIdentifiers.set(CabbageIDs::left, 10);

  774. 		cabbageIdentifiers.set(CabbageIDs::width, 600);

  775. 		cabbageIdentifiers.set(CabbageIDs::height, 300);	

  776. 		cabbageIdentifiers.set(CabbageIDs::caption, "");

  777. 		cabbageIdentifiers.set(CabbageIDs::name, "form");

  778. 		cabbageIdentifiers.set(CabbageIDs::type, "form");

  779. 		cabbageIdentifiers.set(CabbageIDs::guirefresh, 20);

  780. 	}

  781. 

  782.     else if(strTokens[0].trim() == "hostbpm"){

  783. 		cabbageIdentifiers.set(CabbageIDs::basetype, "layout");

  784.         cabbageIdentifiers.set(CabbageIDs::name, "hostbpm");

  785. 		cabbageIdentifiers.set(CabbageIDs::type, "hostbpm");

  786. 	}

  787. 

  788.     else if(strTokens[0].trim() == "hostppqpos"){

  789. 		cabbageIdentifiers.set(CabbageIDs::basetype, "layout");

  790.         cabbageIdentifiers.set(CabbageIDs::name, "hostppqpos");

  791. 		cabbageIdentifiers.set(CabbageIDs::type, "hostppqpos");

  792. 	}

  793. 

  794.     else if(strTokens[0].trim() == "hostplaying"){

  795. 		cabbageIdentifiers.set(CabbageIDs::basetype, "layout");

  796.         cabbageIdentifiers.set(CabbageIDs::name, "hostplaying");

  797. 		cabbageIdentifiers.set(CabbageIDs::type, "hostplaying");

  798. 	}

  799. 

  800.     else if(strTokens[0].trim() == "hostrecording"){

  801. 		cabbageIdentifiers.set(CabbageIDs::basetype, "layout");

  802.         cabbageIdentifiers.set(CabbageIDs::name, "hostrecording");

  803. 		cabbageIdentifiers.set(CabbageIDs::type, "hostrecording");

  804. 	}

  805. 

  806.     else if(strTokens[0].trim() == "hosttime"){

  807. 		cabbageIdentifiers.set(CabbageIDs::basetype, "layout");

  808.         cabbageIdentifiers.set(CabbageIDs::name, "hosttime");

  809. 		cabbageIdentifiers.set(CabbageIDs::type, "hosttime");

  810. 	}

  811. 

  812. 	tabpage = String("");

  813. 	

  814. //parse the text now that all default values ahve been assigned

  815. parse(compStr);

  816. }

  817. 

  818. CabbageGUIClass::~CabbageGUIClass()

  819. {

  820. 

  821. }

  822. //===========================================================================================

  823. int CabbageGUIClass::parse(String inStr)

  824. {

  825. 	//Logger::writeToLog(str);

  826. 	//remove any text after a semicolon and take out tabs..

  827. 	String str = inStr.removeCharacters("\t");

  828. 	if(str.indexOf(0, ";")!=-1)

  829. 		str = str.substring(0, str.indexOf(0, ";"));

  830. 

  831. 	

  832. 	//making this static would also speed things up!!

  833. 	String typeOfWidget="";

  834. 	StringArray identArray;

  835. 	identArray.clear();

  836.     identArray.add(",colour(");

  837. 	identArray.add("tablecolour(");

  838. 	identArray.add(" colour(");

  839.     identArray.add(",colours(");

  840. 	identArray.add(" colours(");

  841.     identArray.add("fontcolour(");

  842. 	identArray.add("size(");

  843. 	identArray.add("items(");

  844.     identArray.add("pos(");

  845.     identArray.add("min(");

  846.     identArray.add("max(");

  847.     identArray.add("value(");

  848. 	identArray.add("tabpage(");

  849. 	identArray.add("guirefresh(");

  850. 	identArray.add("midictrl(");

  851. 	//check line values with spaces, otherwise

  852. 	//it gets confused with the outline identifier

  853. 	identArray.add(" line(");

  854. 	identArray.add(",line(");

  855. 	identArray.add("bounds(");

  856. 	identArray.add("populate(");

  857. 	identArray.add(",range(");

  858. 	identArray.add(" range(");

  859. 	identArray.add("amprange(");

  860. 

  861. 	identArray.add("rangex(");

  862. 	identArray.add("rangey(");

  863. 	identArray.add("plant(");

  864. 	identArray.add("alpha(");

  865.     identArray.add(",channel(");

  866. 	identArray.add("channel(");

  867. 	identArray.add("channeltype(");

  868. 	identArray.add(" chan(");

  869.     identArray.add("channels(");

  870. 	identArray.add(" chans(");

  871.     identArray.add("name(");

  872.     identArray.add("textbox(");

  873. 	identArray.add("instrs(");

  874.     identArray.add("caption(");

  875.     identArray.add("topitem(");

  876.     identArray.add("menuitem(");

  877.     identArray.add("stdout(");

  878. 	identArray.add("native(");

  879.     identArray.add("exit(");

  880.     identArray.add("cssetup(");

  881.     identArray.add("kind(");

  882. 	identArray.add("config(");

  883.     identArray.add("beveltype(");

  884. 	identArray.add("text(");

  885.     identArray.add("runcsound(");

  886. 	identArray.add("tabs(");

  887. 	identArray.add("tab(");

  888. 	identArray.add(" mode(");

  889. 	identArray.add(",mode(");

  890. 	identArray.add("tablenumber(");

  891. 	identArray.add("tablenum(");

  892. 	identArray.add("tablenumbers(");

  893. 	identArray.add("tablenums(");

  894. 	identArray.add("fill(");

  895. 	identArray.add("file(");

  896. 	identArray.add("outline(");

  897. 	identArray.add("master(");

  898. 	identArray.add("shape("); 

  899. 	identArray.add("textcolour("); 

  900. 	identArray.add("scale(");

  901. 	identArray.add("chan(");

  902. 	identArray.add("key(");

  903. 	identArray.add("steps(");

  904. 	identArray.add("pluginid(");

  905. 	identArray.add("rctrls(");

  906. 	identArray.add("trackercolour(");

  907. 	identArray.add("preset(");

  908. 	identArray.add("popup(");

  909. 	identArray.add("fftsize(");

  910. 	identArray.add("overlap(");

  911. 	identArray.add("framesize(");

  912. 	identArray.add("pvschan(");

  913. 	identArray.add("author(");

  914. 	identArray.add("tabpage(");

  915. 	identArray.add("drawmode(");

  916. 	identArray.add("resizemode(");

  917. 	identArray.add("readonly(");

  918. 	identArray.add("latched(");

  919. 	//add a few dummy identifiers so we can catch bogus one in the Cabbage code

  920. 	identArray.add("");

  921. 	identArray.add("");

  922. 	identArray.add("");

  923. 	//Logger::writeToLog(String(identArray.size()));

  924. 	//retrieve paramters consisting of strings

  925. 	for(int indx=0;indx<identArray.size();indx++)

  926. 	{

  927. 		//check to see if identifier is part of input string..turn to lowercase first..

  928. 		//Logger::writeToLog("index:"+String(indx)+" arrayItem:"+identArray.getReference(indx)+" line:\n"+str);

  929. 		int identPos = str.toLowerCase().indexOf(identArray.getReference(indx));

  930.           if(identPos!=-1){

  931. 			StringArray strTokens, fillStrTokens;

  932. 			fillStrTokens.addTokens(str, ", \t", "\"");

  933. 			typeOfWidget = fillStrTokens[0];

  934. 			

  935. 			String newString = str.substring(identPos+identArray.getReference(indx).length());

  936. 			

  937. 			String tstr = newString.substring(0, newString.indexOf(0, ")"));

  938. 			

  939. 			if(tstr.length()==0) return 0;

  940. 			

  941. 			strTokens.addTokens(tstr.removeCharacters("\t()\""), ",", "\"");

  942. 			

  943. 			//for(int i=0;i<strTokens.size();i++)

  944. 			//	showMessage(strTokens[i]);

  945. 

  946. 			if(identArray[indx].equalsIgnoreCase("name(")){

  947. 					name = strTokens[0].trim();

  948. 					cabbageIdentifiers.set(CabbageIDs::name, strTokens[0].trim());

  949. 			} 

  950. 			else if(identArray[indx].equalsIgnoreCase("plant(")){

  951. 				cabbageIdentifiers.set(CabbageIDs::plant, strTokens[0].trim());

  952. 				plant = strTokens[0].trim();

  953. 			} 

  954. 			else if(identArray[indx].equalsIgnoreCase("caption(")){

  955. 			caption = strTokens[0].trim();

  956. 			cabbageIdentifiers.set(CabbageIDs::caption, strTokens[0].trim());

  957. 			} 

  958. 			

  959.             else if(identArray[indx].equalsIgnoreCase("channel(")||

  960. 				identArray[indx].equalsIgnoreCase(",channel(")||

  961. 				identArray[indx].equalsIgnoreCase(" chans(") ||

  962. 				identArray[indx].equalsIgnoreCase("channel(") ||

  963. 				identArray[indx].equalsIgnoreCase(" channels("))

  964. 				{

  965. 					channel = strTokens[0].trim();

  966. 					channels.add(channel);

  967. 					var array;

  968. 					array.append(strTokens[0].trim());

  969. 					if(str.containsIgnoreCase("xypad"))

  970. 					{

  971. 					xChannel = strTokens[0].trim();

  972. 					yChannel = strTokens[1].trim();

  973. 					cabbageIdentifiers.set(CabbageIDs::xchannel, strTokens[0].trim());

  974. 					cabbageIdentifiers.set(CabbageIDs::ychannel, strTokens[1].trim());

  975. 					}

  976. 					else if(str.containsIgnoreCase("vumeter"))

  977. 						{

  978. 						channels.clear();

  979. 						array.resize(0);					

  980. 						for(int u=0;u<strTokens.size();u++)

  981. 							{

  982. 							channels.add(strTokens[u].trim());

  983. 							array.append(strTokens[u].trim());

  984. 							}

  985. 						}

  986. 					else{ 

  987. 						if(strTokens.size()>1)

  988. 						for(int i=1;i<strTokens.size();i++)

  989. 							{

  990. 							channels.add(strTokens[i].trim());

  991. 							array.append(strTokens[i].trim());						

  992. 							}

  993. 						}

  994. 					cabbageIdentifiers.set(CabbageIDs::channel, array);	

  995. 				

  996. 				}

  997. 

  998.             else if(identArray[indx].equalsIgnoreCase(" colour(")||

  999. 				identArray[indx].equalsIgnoreCase(",colour(")||

  1000. 				identArray[indx].equalsIgnoreCase(" colours(")||

  1001. 				identArray[indx].equalsIgnoreCase(", colours(")){

  1002. 					if(strTokens.size()<2){

  1003. 						colour = Colours::findColourForName(strTokens[0].trim(), Colours::white);

  1004. 					}

  1005. 						

  1006. 					else if(strTokens.size()==4)

  1007. 						colour = Colour::fromRGBA (strTokens[0].getIntValue(),

  1008. 															strTokens[1].getIntValue(), 

  1009. 															strTokens[2].getIntValue(),

  1010. 															strTokens[3].getIntValue());

  1011. 					else if(strTokens.size()==3)

  1012. 						colour = Colour::fromRGB (strTokens[0].getIntValue(),

  1013. 									strTokens[1].getIntValue(), 

  1014. 									strTokens[2].getIntValue());

  1015. 									

  1016. 					for(int i=0;i<strTokens.size();i++)

  1017. 						colours.add(Colours::findColourForName(strTokens[i].trim(), Colours::white).toString());

  1018. 

  1019. 					//var RGBA;

  1020. 					//RGBA.append(colour.getRed());

  1021. 					//RGBA.append(colour.getGreen());

  1022. 					//RGBA.append(colour.getBlue());

  1023. 					//RGBA.append(colour.getAlpha());

  1024. 					cabbageIdentifiers.set(CabbageIDs::colour, colour.toString());

  1025. 									

  1026. 			}

  1027. 

  1028. 

  1029.             else if(identArray[indx].equalsIgnoreCase("fontcolour(")){

  1030. 					if(strTokens.size()<2)

  1031. 						fontcolour = Colours::findColourForName(strTokens[0].trim(), Colours::white);

  1032. 					else if(strTokens.size()==4)

  1033. 						fontcolour = Colour::fromRGBA (strTokens[0].getIntValue(),

  1034. 															strTokens[1].getIntValue(), 

  1035. 															strTokens[2].getIntValue(),

  1036. 															strTokens[3].getIntValue());

  1037. 					else if(strTokens.size()==3)

  1038. 						fontcolour = Colour::fromRGBA (strTokens[0].getIntValue(),

  1039. 									strTokens[1].getIntValue(), 

  1040. 									strTokens[2].getIntValue(), 

  1041. 									255);

  1042. 									

  1043. 					cabbageIdentifiers.set(CabbageIDs::fontcolour, fontcolour.toString());				

  1044. 			}

  1045. 

  1046.             else if(identArray[indx].equalsIgnoreCase("tablecolour(")){

  1047. 					var colours;

  1048. 					for(int i=0;i<strTokens.size();i++)

  1049. 						colours.append(strTokens[i].trim());

  1050. 						

  1051. 					cabbageIdentifiers.set(CabbageIDs::tablecolour, colours);	

  1052. 					}

  1053. 

  1054.             else if(identArray[indx].equalsIgnoreCase("trackercolour(")){

  1055. 

  1056. 					if(strTokens.size()<2){

  1057. 						if(strTokens[0].trim().length()>2)

  1058. 						trackerFill = Colours::findColourForName(strTokens[0].trim(), Colours::white);

  1059. 						else 

  1060. 						trackerFill = Colour::fromRGBA (255, 255, 255, 0);

  1061. 					}

  1062. 					else if(strTokens.size()==4)

  1063. 						trackerFill = Colour::fromRGBA (strTokens[0].getIntValue(),

  1064. 															strTokens[1].getIntValue(), 

  1065. 															strTokens[2].getIntValue(),

  1066. 															strTokens[3].getIntValue());

  1067. 					else if(strTokens.size()==3)

  1068. 						trackerFill = Colour::fromRGB (strTokens[0].getIntValue(),

  1069. 									strTokens[1].getIntValue(), 

  1070. 									strTokens[2].getIntValue());

  1071. 									

  1072. 					cabbageIdentifiers.set(CabbageIDs::trackercolour, trackerFill.toString());					

  1073. 			}

  1074. 

  1075. 			else if(identArray[indx].equalsIgnoreCase("kind(")){

  1076. 				kind = strTokens[0].trim();

  1077. 				cabbageIdentifiers.set(CabbageIDs::kind, strTokens[0].trim());	

  1078. 			} 

  1079. 			else if(identArray[indx].equalsIgnoreCase("file(")){

  1080. 				file = strTokens[0].trim();

  1081. 				cabbageIdentifiers.set(CabbageIDs::file, strTokens[0].trim());	

  1082. 			} 

  1083. 			else if(identArray[indx].equalsIgnoreCase("fill(")){

  1084. 					if(strTokens.size()<2)

  1085. 						fill = Colours::findColourForName(strTokens[0].trim(), Colours::white);

  1086. 					else if(strTokens.size()==4)

  1087. 						fill = Colour::fromRGBA (strTokens[0].getIntValue(),

  1088. 															strTokens[1].getIntValue(), 

  1089. 															strTokens[2].getIntValue(),

  1090. 															strTokens[3].getIntValue());

  1091. 					else if(strTokens.size()==3)

  1092. 						fill = Colour::fromRGB (strTokens[0].getIntValue(),

  1093. 									strTokens[1].getIntValue(), 

  1094. 									strTokens[2].getIntValue());

  1095. 									

  1096. 					cabbageIdentifiers.set(CabbageIDs::fill, trackerFill.toString());		

  1097. 

  1098. 			}

  1099. 			else if(identArray[indx].equalsIgnoreCase("shape(")){

  1100. 				shape = strTokens[0].trim();

  1101. 				cabbageIdentifiers.set(CabbageIDs::shape, strTokens[0].trim());	

  1102. 			} 

  1103. 			else if(identArray[indx].equalsIgnoreCase("outline(")){

  1104. 					if(strTokens.size()<2)

  1105. 						outline = Colours::findColourForName(strTokens[0].trim(), Colours::white);

  1106. 					else if(strTokens.size()==4)

  1107. 						outline = Colour::fromRGBA (strTokens[0].getIntValue(),

  1108. 															strTokens[1].getIntValue(), 

  1109. 															strTokens[2].getIntValue(),

  1110. 															strTokens[3].getIntValue());

  1111. 					else if(strTokens.size()==3)

  1112. 						outline = Colour::fromRGB (strTokens[0].getIntValue(),

  1113. 									strTokens[1].getIntValue(), 

  1114. 									strTokens[2].getIntValue());

  1115. 									

  1116. 					cabbageIdentifiers.set(CabbageIDs::outline, trackerFill.toString());	

  1117. 			}

  1118. 			else if(identArray[indx].equalsIgnoreCase("textcolour(")){

  1119. 					if(strTokens.size()<2)

  1120. 						textcolour = Colours::findColourForName(strTokens[0].trim(), Colours::white);

  1121. 					else if(strTokens.size()==4)

  1122. 						textcolour = Colour::fromRGBA (strTokens[0].getIntValue(),

  1123. 															strTokens[1].getIntValue(), 

  1124. 															strTokens[2].getIntValue(),

  1125. 															strTokens[3].getIntValue());

  1126. 					else if(strTokens.size()==3)

  1127. 						textcolour = Colour::fromRGB (strTokens[0].getIntValue(),

  1128. 									strTokens[1].getIntValue(), 

  1129. 									strTokens[2].getIntValue());

  1130. 					cabbageIdentifiers.set(CabbageIDs::textcolour, textcolour.toString());	

  1131. 			}

  1132. 			

  1133. 			//!!! This haven't been set for the generic data system

  1134.             else if(identArray[indx].equalsIgnoreCase("key(")){

  1135. 				key.clear();

  1136. 				if(strTokens.size()==1){

  1137. 					key.add(strTokens[0].trim());

  1138. 				}

  1139. 				else if(strTokens.size()==2){

  1140. 					key.add(strTokens[0].trim());

  1141. 					key.add(strTokens[1].trim());

  1142. 				}

  1143. 				else

  1144. 					debugMessage ="WARNING: Too many parameters passed to key(): usage key(\"key1\", \"key2\"\")";

  1145. 

  1146. 			}

  1147. 

  1148. 			else if(identArray[indx].equalsIgnoreCase("pluginid(")){

  1149. 				pluginID = strTokens[0].trim();

  1150. 				cabbageIdentifiers.set(CabbageIDs::pluginid, strTokens[0].trim());

  1151. 			}

  1152. 

  1153.             else if(identArray[indx].equalsIgnoreCase("items(")||

  1154. 					identArray[indx].equalsIgnoreCase("text(")){

  1155.               items.clear();//clear any unwanted items

  1156. 			  text = strTokens[0];

  1157. 			  //CabbageUtils::showMessage(typeOfWidget+":"+text);

  1158. 			  var value;

  1159. 			  for(int i= 0;i<(int)strTokens.size();i++)

  1160. 					{

  1161. 					//Logger::writeToLog(strTokens[i]);

  1162. 					String test = strTokens[i]; 

  1163. 					items.add(strTokens[i]);	

  1164. 					value.append(strTokens[i].trim());

  1165. 					//if((int)strTokens.size()<2) {

  1166. 					//	items.add(strTokens[i]);

  1167. 					//	value.append(strTokens[i].trim());

  1168. 					//	i++;

  1169. 					//	}

  1170. 					comboRange = i+1;

  1171. 					}

  1172. 					//Logger::writeToLog(String(value.size())+typeOfWidget);

  1173. 					if((value.size()==1) && ((typeOfWidget=="button") || (typeOfWidget=="filebutton"))){

  1174. 						value.append(strTokens[0]);

  1175. 						//Logger::writeToLog(strTokens[0].trim());

  1176. 					}

  1177. 						

  1178. 			  cabbageIdentifiers.set(CabbageIDs::text, value);

  1179. 			  cabbageIdentifiers.set(CabbageIDs::comborange, comboRange);

  1180. 			}

  1181. 

  1182. 			//!!! This haven't been set for the generic data system

  1183. 			else if(identArray[indx].equalsIgnoreCase("instrs(")){

  1184.               items.clear();//clear any unwanted items

  1185. 			  for(int i= 0;i<(int)strTokens.size();i++){

  1186. 				String test = strTokens[i]; 

  1187. 				items.add(strTokens[i]);	

  1188. 				}

  1189. 			}

  1190. 

  1191. 			else if(identArray[indx].equalsIgnoreCase("preset(")){

  1192. 				//CabbageUtils::showMessage("preset is no longer supported, see docs");

  1193. 			}

  1194. 

  1195. 			else if(identArray[indx].equalsIgnoreCase(" mode(") ||

  1196. 					identArray[indx].equalsIgnoreCase(",mode(")){

  1197. 				cabbageIdentifiers.set(CabbageIDs::mode, strTokens[0].trim());	

  1198. 			}

  1199. 			

  1200. 			else if(identArray[indx].equalsIgnoreCase("native(")){

  1201. 				native = strTokens[0].trim();

  1202. 				cabbageIdentifiers.set("native", strTokens[0].trim());	

  1203. 				//Logger::writeToLog(native);

  1204. 			}

  1205. 			

  1206. 			else if(identArray[indx].equalsIgnoreCase("channeltype(")){

  1207. 				cabbageIdentifiers.set(CabbageIDs::channeltype, strTokens[0].trim());	

  1208. 			}

  1209. 			

  1210. 			else if(identArray[indx].equalsIgnoreCase("populate(")){

  1211. 				fileType = strTokens[0].trim();

  1212. 				cabbageIdentifiers.set(CabbageIDs::filetype, strTokens[0].trim());	

  1213. 				if(strTokens.size()>1){

  1214. 					workingDir = strTokens[1].trim();

  1215. 					cabbageIdentifiers.set(CabbageIDs::workingdir, strTokens[1].trim());	

  1216. 				}

  1217. 			}

  1218. 

  1219. 			else if(identArray[indx].equalsIgnoreCase("author(")){

  1220. 				author = strTokens[0].trim();

  1221. 				cabbageIdentifiers.set(CabbageIDs::author, strTokens[0].trim());	

  1222. 			}

  1223. 

  1224. 		

  1225. 			else if(identArray[indx].equalsIgnoreCase("tabs(")){

  1226. 				items.clear();

  1227. 				var value;

  1228. 				for(int i= 0;i<(int)strTokens.size();i++){

  1229. 				items.add(strTokens[i]);	

  1230. 				value.append(strTokens[i].trim());

  1231. 				}

  1232. 				cabbageIdentifiers.set(CabbageIDs::tabs, strTokens[0].trim());	

  1233. 			}

  1234. 

  1235. 			else if(identArray[indx].equalsIgnoreCase("tabpage(")){

  1236. 				tabpage = strTokens[0].trim();  

  1237. 				cabbageIdentifiers.set(CabbageIDs::tabpage, strTokens[0].trim());	

  1238. 			} 

  1239. 

  1240. 			//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  1241. 			//numeric paramters

  1242. 			//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  1243. 			

  1244. 			else if(identArray[indx].equalsIgnoreCase("size(")){

  1245. 				if(strTokens.size()<2){

  1246. 					debugMessage ="WARNING: Not enough paramters passed to size(): usage pos(width, height\")";

  1247. 				}

  1248. 				else{

  1249. 					sizeText = identArray.getReference(indx)+tstr+")";

  1250. 					width = strTokens[0].trim().getFloatValue(); 

  1251. 					height = strTokens[1].trim().getFloatValue(); 

  1252. 					cabbageIdentifiers.set(CabbageIDs::width, strTokens[0].trim().getFloatValue());					

  1253. 					cabbageIdentifiers.set(CabbageIDs::height, strTokens[1].trim().getFloatValue());

  1254. 				}

  1255.             }

  1256. 			//!!! This haven't been set for the generic data system

  1257. 			else if(identArray[indx].equalsIgnoreCase("scale(")){

  1258. 				if(strTokens.size()<2){

  1259. 					debugMessage ="WARNING: Not enough paramters passed to scale(): usage scale(width, height\")";

  1260. 				}

  1261. 				else{

  1262.               scaleX = strTokens[0].trim().getFloatValue();  

  1263. 			  scaleX = scaleX/width;

  1264.               scaleY = strTokens[1].trim().getFloatValue();  

  1265. 			  scaleY = scaleY/height;

  1266. 				}

  1267.             }

  1268. 			else if(identArray[indx].equalsIgnoreCase("bounds(")){

  1269. 				if(strTokens.size()<3){

  1270. 					debugMessage ="WARNING: Not enough paramters passed to bounds(): usage pos(top, left width, height\")";

  1271. 				}

  1272. 				else{

  1273. 				  left = strTokens[0].trim().getFloatValue();  

  1274. 				  top = strTokens[1].trim().getFloatValue();  

  1275. 				  width = strTokens[2].trim().getFloatValue();  

  1276. 				  if(strTokens.size()==3){

  1277. 					  height = width;

  1278. 					  cabbageIdentifiers.set(CabbageIDs::height, width);	

  1279. 				  }

  1280. 				  else{

  1281. 				  height = strTokens[3].trim().getFloatValue(); 

  1282. 				  boundsText = identArray.getReference(indx)+tstr+")";

  1283. 				  cabbageIdentifiers.set(CabbageIDs::left, strTokens[0].trim().getFloatValue());					

  1284. 				  cabbageIdentifiers.set(CabbageIDs::top, strTokens[1].trim().getFloatValue());

  1285. 				  cabbageIdentifiers.set(CabbageIDs::width, strTokens[2].trim().getFloatValue());					

  1286. 				  cabbageIdentifiers.set(CabbageIDs::height, strTokens[3].trim().getFloatValue());			  

  1287. 				  }

  1288. 				  

  1289. 				}

  1290.             }

  1291. 			//!!! This haven't been set for the generic data system

  1292.             else if(identArray[indx].equalsIgnoreCase("config(")){

  1293. 				vuConfig.clear();

  1294. 				 for(int i= 0;i<(int)strTokens.size();i++){

  1295. 					 vuConfig.add(strTokens[i].trim().getFloatValue());

  1296. 				 }

  1297. 				}

  1298. 

  1299.             else if(identArray[indx].equalsIgnoreCase("pos(")){

  1300. 				if(strTokens.size()<2){

  1301. 					debugMessage ="WARNING: Not enough paramters passed to pos(): usage pos(top, left\")";

  1302. 				}

  1303. 				else{

  1304. 				  left = strTokens[0].trim().getFloatValue(); 

  1305. 				  top = strTokens[1].trim().getFloatValue();

  1306. 				  posText = identArray.getReference(indx)+tstr+")";

  1307. 				  cabbageIdentifiers.set(CabbageIDs::left, strTokens[0].trim().getFloatValue());					

  1308. 				  cabbageIdentifiers.set(CabbageIDs::top, strTokens[1].trim().getFloatValue());

  1309. 				}

  1310.             }

  1311. 			else if(identArray[indx].equalsIgnoreCase(" range(") ||

  1312. 					identArray[indx].equalsIgnoreCase(",range(")){

  1313. 				if(strTokens.size()<3){

  1314. 					debugMessage ="WARNING: Not enough paramters passed to range(): usage range(minx, max, value, incr\")";

  1315. 				}

  1316. 				else{	

  1317. 				StringArray tempArray;

  1318. 				//showMessage(str);

  1319. 				//showMessage(strTokens[0]);

  1320. 				min = strTokens[0].trim().getDoubleValue();// getFloatValue(); 

  1321. 				max = strTokens[1].trim().getDoubleValue();//.getFloatValue(); 

  1322. 				cabbageIdentifiers.set(CabbageIDs::min, strTokens[0].trim().getDoubleValue());	

  1323. 				cabbageIdentifiers.set(CabbageIDs::max, strTokens[1].trim().getDoubleValue());	

  1324. 				tempArray.add(strTokens[0].trim());

  1325. 				tempArray.add(strTokens[1].trim());

  1326. 				if(strTokens.size()>2){

  1327. 				value = strTokens[2].trim().getDoubleValue();//.getFloatValue(); 

  1328. 				cabbageIdentifiers.set(CabbageIDs::value, strTokens[2].trim().getDoubleValue());	

  1329. 				tempArray.add(strTokens[2].trim());

  1330. 				}

  1331. 				else value = 0;				

  1332. 

  1333. 				if(strTokens.size()>3){

  1334. 				sliderSkew = strTokens[3].trim().getFloatValue();//.getFloatValue(); 

  1335. 				cabbageIdentifiers.set(CabbageIDs::sliderskew, strTokens[3].trim().getDoubleValue());

  1336. 				tempArray.add(strTokens[3].trim());

  1337. 				}

  1338. 				

  1339. 				if(strTokens.size()>4){  

  1340. 				sliderIncr = strTokens[4].trim().getDoubleValue();

  1341. 				tempArray.add(strTokens[4].trim());

  1342. 				cabbageIdentifiers.set(CabbageIDs::sliderincr, strTokens[4].trim().getDoubleValue());

  1343. 				}

  1344. 				

  1345. 				sliderRange = max-min;				

  1346. 				decimalPlaces = getNumberOfDecimalPlaces(tempArray);

  1347. 				if(decimalPlaces<1 && max<=1)

  1348. 					decimalPlaces = 2;

  1349. 				else

  1350. 					decimalPlaces = getNumberOfDecimalPlaces(tempArray);

  1351. 				cabbageIdentifiers.set(CabbageIDs::decimalplaces, decimalPlaces);

  1352. 				cabbageIdentifiers.set(CabbageIDs::range, sliderRange);

  1353. 

  1354. 				}

  1355. 

  1356. 			}

  1357. 			else if(identArray[indx].equalsIgnoreCase("rangex(")){

  1358. 				if(strTokens.size()<3){

  1359. 					debugMessage ="WARNING: Not enough paramters passed to range(): usage range(minx, max, value\")";

  1360. 				}

  1361. 				else{

  1362. 				minX = strTokens[0].removeCharacters("()").trim().getFloatValue();  				

  1363. 				maxX = strTokens[1].removeCharacters("()").trim().getFloatValue();  

  1364. 				valueX = strTokens[2].removeCharacters("()").trim().getFloatValue(); 

  1365. 				

  1366. 				cabbageIdentifiers.set(CabbageIDs::minx, strTokens[0].trim().getDoubleValue());			

  1367. 				cabbageIdentifiers.set(CabbageIDs::maxx, strTokens[1].getDoubleValue());

  1368. 				cabbageIdentifiers.set(CabbageIDs::valuex, strTokens[2].getDoubleValue());

  1369. 				cabbageIdentifiers.set(CabbageIDs::rangex, maxX-minX);

  1370. 				

  1371. 				if(strTokens.size()==4)

  1372. 				decimalPlaces = strTokens[3].trim().getFloatValue();

  1373. 				xypadRangeX = maxX-minX;

  1374. 				cabbageIdentifiers.set(CabbageIDs::decimalplaces, strTokens[3].trim().getDoubleValue());

  1375. 				}

  1376. 			}

  1377. 			else if(identArray[indx].equalsIgnoreCase("rangey(")){

  1378. 				if(strTokens.size()<3){

  1379. 					debugMessage ="WARNING: Not enough paramters passed to range(): usage range(minx, max, value\")";

  1380. 				}

  1381. 				else{

  1382. 				minY = strTokens[0].trim().getFloatValue();  

  1383. 				maxY = strTokens[1].trim().getFloatValue();  

  1384. 				valueY = strTokens[2].trim().getFloatValue();

  1385. 				

  1386. 

  1387. 				cabbageIdentifiers.set(CabbageIDs::miny, strTokens[0].trim().getDoubleValue());	

  1388. 				cabbageIdentifiers.set(CabbageIDs::maxy, strTokens[1].trim().getDoubleValue());

  1389. 				cabbageIdentifiers.set(CabbageIDs::valuey, strTokens[2].trim().getDoubleValue());

  1390. 				cabbageIdentifiers.set(CabbageIDs::rangey, maxY-minY);

  1391. 				

  1392. 

  1393. 				if(strTokens.size()==4)

  1394. 				decimalPlaces = strTokens[3].trim().getFloatValue();

  1395. 				xypadRangeY = maxY-minY;

  1396. 				cabbageIdentifiers.set(CabbageIDs::decimalplaces, strTokens[3].trim().getDoubleValue());

  1397. 				}

  1398. 			}

  1399. 			else if(identArray[indx].equalsIgnoreCase("min(")){

  1400. 				min = strTokens[0].removeCharacters("()").trim().getFloatValue();  

  1401. 				cabbageIdentifiers.set(CabbageIDs::min, strTokens[0].trim().getFloatValue());	

  1402. 			}

  1403. 			else if(identArray[indx].equalsIgnoreCase("midictrl(")){

  1404. 				if(strTokens.size()<2){

  1405. 					debugMessage ="WARNING: Not enough paramters passed to midiCtrl(): usage midiCtrl(midiChan, midiCtrl\")";

  1406. 				}

  1407. 				else{

  1408. 				midiChan = strTokens[0].trim().getFloatValue();  

  1409. 				midiCtrl = strTokens[1].trim().getFloatValue();  

  1410. 				cabbageIdentifiers.set(CabbageIDs::midichan, strTokens[0].trim().getFloatValue());	

  1411. 				cabbageIdentifiers.set(CabbageIDs::midictrl, strTokens[0].trim().getFloatValue());	

  1412. 			}

  1413. 			}

  1414.             else if(identArray[indx].equalsIgnoreCase("max(")){

  1415. 				max = strTokens[0].trim().getFloatValue();  

  1416. 				cabbageIdentifiers.set(CabbageIDs::max, strTokens[0].trim().getFloatValue());	

  1417. 			}

  1418. 

  1419. 

  1420.             else if(identArray[indx].equalsIgnoreCase("tab(")){

  1421. 				tabbed = strTokens[0].trim().getFloatValue();  

  1422. 				cabbageIdentifiers.set(CabbageIDs::tabbed, strTokens[0].trim().getFloatValue());	

  1423. 			}

  1424.             else if(identArray[indx].equalsIgnoreCase("latched(")){ 

  1425. 				cabbageIdentifiers.set(CabbageIDs::latched, strTokens[0].trim().getFloatValue());	

  1426. 			}

  1427.             else if(identArray[indx].equalsIgnoreCase("guirefresh(")){ 

  1428. 				cabbageIdentifiers.set(CabbageIDs::guirefresh, strTokens[0].trim().getFloatValue());	

  1429. 			}

  1430.             else if(identArray[indx].equalsIgnoreCase("textbox(")){

  1431. 				textBox = strTokens[0].trim().getFloatValue();  

  1432. 				cabbageIdentifiers.set(CabbageIDs::textbox, strTokens[0].trim().getFloatValue());				

  1433. 			}

  1434. 			

  1435.             else if(identArray[indx].equalsIgnoreCase("readonly(")){

  1436. 				cabbageIdentifiers.set(CabbageIDs::readonly, strTokens[0].trim().getFloatValue());		

  1437. 			}			

  1438. 			

  1439.             else if(identArray[indx].equalsIgnoreCase("tablenum(")||

  1440. 			(identArray[indx].equalsIgnoreCase("tablenumber("))||

  1441. 			identArray[indx].equalsIgnoreCase("tablenumbers(")||

  1442. 			identArray[indx].equalsIgnoreCase("tablenumbs(")){

  1443. 				tableNum = strTokens[0].trim().getFloatValue();  

  1444. 				var value;

  1445. 				value.append(tableNum);

  1446. 				tableNumbers.add(tableNum);

  1447. 				numTables++;

  1448. 				if(strTokens.size()>1)

  1449. 					for(int i=1;i<strTokens.size();i++){

  1450. 						tableNumbers.add(strTokens[i].trim().getFloatValue());

  1451. 						value.append(strTokens[i].trim().getFloatValue());

  1452. 						numTables++;						

  1453. 					}

  1454. 				cabbageIdentifiers.set(CabbageIDs::tablenumber, value);

  1455. 				//cabbageIdentifiers.set("tablenum", tableNum);

  1456. 			}

  1457.             else if(identArray[indx].equalsIgnoreCase("popup(")){

  1458. 				plantButton = strTokens[0].trim().getIntValue();

  1459. 				cabbageIdentifiers.set(CabbageIDs::popup, strTokens[0].trim().getIntValue());

  1460. 			}

  1461. 

  1462.             else if(identArray[indx].equalsIgnoreCase("drawmode(")){

  1463. 				var value;

  1464. 				if(strTokens.size()>0)

  1465. 					for(int i=0;i<strTokens.size();i++){

  1466. 						//add table modes to val array

  1467. 						value.append(strTokens[i].trim().getFloatValue());					

  1468. 					}

  1469. 				cabbageIdentifiers.set(CabbageIDs::drawmode, value);

  1470. 			}

  1471. 

  1472.             else if(identArray[indx].equalsIgnoreCase("resizemode(")){

  1473. 				var value;

  1474. 				if(strTokens.size()>0)

  1475. 					for(int i=0;i<strTokens.size();i++){

  1476. 						//add table modes to val array

  1477. 						value.append(strTokens[i].trim().getFloatValue());					

  1478. 					}

  1479. 				cabbageIdentifiers.set(CabbageIDs::resizemode, value);

  1480. 			}			

  1481. 			

  1482.             else if(identArray[indx].equalsIgnoreCase("amprange(")){

  1483. 				var value;

  1484. 				if(strTokens.size()>0)

  1485. 					for(int i=0;i<strTokens.size();i++){

  1486. 						//add table modes to val array

  1487. 						value.append(strTokens[i].trim().getFloatValue());					

  1488. 					}

  1489. 				cabbageIdentifiers.set(CabbageIDs::amprange, value);

  1490. 			}			

  1491. 

  1492. 			else if(identArray[indx].equalsIgnoreCase(",line(")||

  1493. 					identArray[indx].equalsIgnoreCase(" line(")){

  1494. 					cabbageIdentifiers.set("line", strTokens[0].trim().getFloatValue());	

  1495. 					cabbageIdentifiers.set(CabbageIDs::line, strTokens[0].trim().getFloatValue());  

  1496. 					}

  1497. 					

  1498.             else if(identArray[indx].equalsIgnoreCase("value(")){

  1499. 				value = strTokens[0].trim().getFloatValue();  

  1500. 				cabbageIdentifiers.set(CabbageIDs::value, strTokens[0].trim().getFloatValue());	

  1501. 			} 

  1502. 		

  1503. 			//!!! This haven't been set for the generic data system			

  1504. 			else if(identArray[indx].equalsIgnoreCase("rctrls(")){

  1505. 				if(strTokens[0].trim().getFloatValue()>5)

  1506. 				rCtrls = 5;

  1507. 				else

  1508. 				rCtrls = strTokens[0].trim().getFloatValue();  

  1509. 			}

  1510. 			else {

  1511. 			}

  1512. 			strTokens.clear();

  1513.           }

  1514.           else{

  1515.  

  1516.           }

  1517. 	}

  1518. 	return 1;//must add error checking to this...

  1519. 

  1520. }

  1521. //=========================================================================

  1522. //retrieve numerical attributes

  1523. float CabbageGUIClass::getNumProp(Identifier prop)

  1524. {	

  1525. 	return cabbageIdentifiers.getWithDefault(prop, -9999.f);

  1526. }

  1527. 

  1528. float CabbageGUIClass::getNumProp(Identifier prop, int index)

  1529. {

  1530. 	//this method should never be called...

  1531. 	jassert(1);	

  1532. }

  1533. 

  1534. 

  1535. 

  1536. //set numerical attributes

  1537. void CabbageGUIClass::setNumProp(Identifier prop, float val)

  1538. {

  1539. 	cabbageIdentifiers.set(prop, val);

  1540. }

  1541. 

  1542. 

  1543. float CabbageGUIClass::getTableChannelValues(int index)

  1544. {

  1545. if(index<tableChannelValues.size())

  1546. 	return tableChannelValues.getReference(index);

  1547. else

  1548. 	return 0.f;	

  1549. }

  1550. 

  1551. void CabbageGUIClass::addTableChannelValues()

  1552. {

  1553. tableChannelValues.add(-1.f);

  1554. }

  1555. 

  1556. void CabbageGUIClass::setTableChannelValues(int index, float val)

  1557. {

  1558. if(index<tableChannelValues.size())

  1559. tableChannelValues.set(index, val);		

  1560. }

  1561. 

  1562. 

  1563. String CabbageGUIClass::getPropsString()

  1564. {

  1565. 	return type << String(" bounds(") << String(left) << String(", ") << String(top) << String(", ") << String(width)

  1566. 				<< String(", ") << String(height) << String("), channel(\"") << channel << String("), xyChannel(\"") << xyChannel << String("\"), value(")

  1567. 				<< String(value) << String("), items(\"") << items[0].trim() << String("\", \"") << items[1].trim() << String("\")")

  1568. 				<< String("), range(\"") << String(min) << String(", ") << String(max) << String(", ") << String(value) << String("\")");

  1569. }

  1570. 

  1571. String CabbageGUIClass::getStringProp(Identifier prop, int index)

  1572. {

  1573. 	jassert(1);

  1574. /*

  1575. 		if(prop.equalsIgnoreCase("channel"))

  1576. 			return channels[index].trim();

  1577. 		else if(prop.equalsIgnoreCase("snapshotData"))

  1578. 			return snapshotData[index].trim();

  1579. 		else*/	

  1580. 		return "";

  1581. }

  1582. 

  1583. Rectangle<int> CabbageGUIClass::getComponentBounds()

  1584. {

  1585. Rectangle<int> rect;

  1586. rect.setBounds(getNumProp("left"), getNumProp("top"), getNumProp("width"), getNumProp("height"));

  1587. return rect;

  1588. }

  1589. 

  1590. String CabbageGUIClass::getStringProp(Identifier prop)

  1591. {

  1592. 	var strings = cabbageIdentifiers.getWithDefault(prop, "");

  1593. 	

  1594. 

  1595. 	if(strings.size()>0){

  1596. 		//Logger::writeToLog(prop+":"+strings[0].toString());

  1597. 		return strings[0].toString();

  1598. 	}

  1599. 	else{

  1600. 		//Logger::writeToLog(prop+":"+strings.toString());

  1601. 		//Logger::writeToLog(prop+":"+strings.toString());

  1602. 		return strings.toString();

  1603. 	}

  1604. }

  1605. 

  1606. 

  1607. 

  1608. StringArray CabbageGUIClass::getStringArrayProp(Identifier prop)

  1609. {

  1610. 	StringArray returnArray;

  1611. 	var strings = cabbageIdentifiers.getWithDefault(prop, "");

  1612. 	for(int i=0;i<strings.size();i++)

  1613. 		returnArray.add(strings[i].toString());

  1614. 	return returnArray;

  1615. }

  1616. 

  1617. String CabbageGUIClass::getStringArrayPropValue(Identifier prop, int index)

  1618. {

  1619. 	StringArray returnArray;

  1620. 	var strings = cabbageIdentifiers.getWithDefault(prop, "");

  1621. 	for(int i=0;i<strings.size();i++)

  1622. 		returnArray.add(strings[i].toString());

  1623. 	if(isPositiveAndBelow(index,strings.size()))

  1624. 	return returnArray[index];

  1625. 	else

  1626. 	return returnArray[strings.size()-1];

  1627. 		

  1628. 	

  1629. }

  1630. 

  1631. Array<int> CabbageGUIClass::getIntArrayProp(Identifier prop)

  1632. {

  1633. 	Array<int> returnArray;

  1634. 	var ints = cabbageIdentifiers.getWithDefault(prop, "");

  1635. 	for(int i=0;i<ints.size();i++)

  1636. 		returnArray.add(ints[i]);

  1637. 	return returnArray;

  1638. }

  1639. 

  1640. int CabbageGUIClass::getIntArrayPropValue(Identifier prop, int index)

  1641. {

  1642. 	Array<int> returnArray;

  1643. 	var ints = cabbageIdentifiers.getWithDefault(prop, "");

  1644. 	for(int i=0;i<ints.size();i++)

  1645. 		returnArray.add(ints[i]);

  1646. 	if(isPositiveAndBelow(index,ints.size()))

  1647. 	return returnArray[index];

  1648. 	else

  1649. 	return returnArray[ints.size()-1];

  1650. }

  1651. 

  1652. Array<float> CabbageGUIClass::getFloatArrayProp(Identifier prop)

  1653. {

  1654. 	Array<float> returnArray;

  1655. 	var ints = cabbageIdentifiers.getWithDefault(prop, "");

  1656. 	for(int i=0;i<ints.size();i++)

  1657. 		returnArray.add(ints[i]);

  1658. 	return returnArray;

  1659. }

  1660. 

  1661. float CabbageGUIClass::getFloatArrayPropValue(Identifier prop, int index)

  1662. {

  1663. 	Array<float> returnArray;

  1664. 	var ints = cabbageIdentifiers.getWithDefault(prop, "");

  1665. 	for(int i=0;i<ints.size();i++)

  1666. 		returnArray.add(ints[i]);

  1667. 	if(isPositiveAndBelow(index,ints.size()))

  1668. 	return returnArray[index];

  1669. 	else

  1670. 	return returnArray[ints.size()-1];

  1671. }

  1672. 

  1673. void CabbageGUIClass::setStringProp(Identifier prop, int index, String value)

  1674. {		

  1675. jassert(1);

  1676. }

  1677. 

  1678. void CabbageGUIClass::setStringProp(Identifier prop, String val)

  1679. {

  1680. 	//if(prop=="reltoplant")

  1681. 		if(val.length()>0){

  1682. 		cabbageIdentifiers.set(prop, val);

  1683. 		//Logger::writeToLog(prop+":"+val);

  1684. 		}

  1685. }

  1686. 

  1687. String CabbageGUIClass::getColourProp(Identifier prop)

  1688. {

  1689. jassert(1);

  1690. }

  1691. 

  1692. String CabbageGUIClass::getStringForIdentifier(var propsArray, String identifier, String type)

  1693. {

  1694. 	String str;

  1695. 	if(type=="number"){

  1696. 		if(propsArray.size()>0){

  1697. 			for(int p=0;p<propsArray.size();p++)

  1698. 			str += propsArray[p].toString()+",";						

  1699. 			str= identifier+str.dropLastCharacters(1)+"), ";

  1700. 			//Logger::writeToLog(str);

  1701. 		}

  1702. 		else

  1703. 			str = identifier+propsArray.toString()+"), ";

  1704. 

  1705. 	return str;

  1706. 	}

  1707. 

  1708. 	else if(type=="string"){

  1709. 		if(propsArray.size()>0){

  1710. 			for(int p=0;p<propsArray.size();p++)

  1711. 			str += "\""+propsArray[p].toString()+"\",";						

  1712. 			str = identifier+str.dropLastCharacters(1)+"), ";

  1713. 			//Logger::writeToLog(str);			

  1714. 		}

  1715. 		else

  1716. 			str = identifier+String("\"")+propsArray.toString()+"\"), ";		

  1717. 		

  1718. 	return str;

  1719. 	}

  1720. 	else

  1721. 	return "";

  1722. }

  1723. 

  1724. String CabbageGUIClass::getCabbageCodeFromIdentifiers(NamedValueSet props)

  1725. {

  1726. 	//Logger::writeToLog("::::getCabbageCodeFromIdentifiers::::");

  1727. 	String line;

  1728. 	var propsArray;

  1729. 	String temp="";

  1730. 	String type;

  1731. 	String colour, fontcolour;

  1732. 	String left, top, width, height, colR, colG, colB, colA, min, max, skew, drawmode, tablenumber,resizemode,

  1733. 	incr, slidervalue, value, maxx, maxy, minx, miny, valuex, valuey, channel, xchannel, ychannel,

  1734. 	amprange;

  1735. 	var rgbVals;

  1736. 	//run through the complete list of identifiers

  1737. 	for(int i=0;i<props.size();i++){

  1738. 		String identifier = props.getName(i).toString();

  1739. 		propsArray = props.getValueAt(i);

  1740. 		if(props.getValueAt(i).toString()!="")

  1741. 			{

  1742. 			if(props.getName(i).toString()=="top")

  1743. 				top = props.getValueAt(i).toString();

  1744. 			else if(props.getName(i).toString()=="left")

  1745. 				left = props.getValueAt(i).toString();

  1746. 			else if(props.getName(i).toString()=="width")

  1747. 				width = props.getValueAt(i).toString();

  1748. 			else if(props.getName(i).toString()=="height")

  1749. 				height = props.getValueAt(i).toString();

  1750. 			else if(identifier=="decimalplaces" ||

  1751. 					identifier=="range" ||

  1752. 					identifier=="name" ||

  1753. 					identifier=="scalex" ||

  1754. 					identifier=="scaley" ||

  1755. 					identifier=="basetype" ||

  1756. 					identifier=="kind" ||

  1757. 					identifier=="comborange")

  1758. 			{

  1759. 				//none of these identifiers need to be seen...

  1760. 			}

  1761. 			else if(props.getName(i).toString()=="colour" || props.getName(i).toString()=="fontcolour"

  1762. 					|| props.getName(i).toString()=="trackercolour" || props.getName(i).toString()=="fill" ||

  1763. 					props.getName(i).toString()=="outline")

  1764. 			{

  1765. 				if(propsArray.size()>0){

  1766. 				for(int y=0;y<propsArray.size();y++){

  1767. 					rgbVals.append(propsArray[y]);

  1768. 				}			

  1769. 				colour = colour << props.getName(i).toString() <<"("<<rgbVals[0].toString() << ", " << rgbVals[1].toString() << ", " << rgbVals[2].toString() << ", " << rgbVals[3].toString() << "), ";

  1770. 				}

  1771. 				else{

  1772. 					Colour col = Colour::fromString(props.getValueAt(i).toString());

  1773. 					colour = colour << props.getName(i).toString() << "(" << (float)col.getRed() << ", " << (float)col.getGreen() << ", " << (float)col.getBlue() << ", " << (float)col.getAlpha() << "), ";

  1774. 				}

  1775. 				rgbVals.resize(0);

  1776. 			}

  1777. 

  1778. 			else if((identifier=="popup") && (int(props.getValueAt(i))==0)){

  1779. 			//only show if not set to default		

  1780. 			}

  1781. 			else if((identifier=="midictrl") && (int(props.getValueAt(i))==-99)){

  1782. 			//only show if not set to default				

  1783. 			}

  1784. 			else if((identifier=="midichan") && (int(props.getValueAt(i))==-99)){

  1785. 			//only show if not set to default				

  1786. 			}

  1787. 			else if((identifier=="channel")){

  1788. 				channel = getStringForIdentifier(propsArray, "channel(", "string");

  1789. 			}

  1790. 			

  1791. 			else if(identifier=="drawmode"){

  1792. 				drawmode = getStringForIdentifier(propsArray, "drawmode(", "number");

  1793. 			}

  1794. 

  1795. 			else if((identifier=="amprange")){

  1796. 				amprange = getStringForIdentifier(propsArray, "amprange(", "number");

  1797. 			}

  1798. 		

  1799. 			else if((identifier=="tablenumber")){

  1800. 				tablenumber = getStringForIdentifier(propsArray, "tablenumber(", "number");

  1801. 			}					

  1802. 			

  1803. 			else if((identifier=="resizemode")){

  1804. 				resizemode = getStringForIdentifier(propsArray, "resizemode(", "number");

  1805. 			}	

  1806. 			

  1807. 			else if((identifier=="xchannel")){

  1808. 			xchannel = props.getValueAt(i).toString();		

  1809. 			}

  1810. 			else if((identifier=="ychannel")){

  1811. 			ychannel = props.getValueAt(i).toString();		

  1812. 			}					

  1813. 			

  1814. 			

  1815. 			//grab slider settings..

  1816. 			else if(identifier=="min")

  1817. 					min = props.getValueAt(i).toString();

  1818. 			else if(identifier=="max")

  1819. 					max = props.getValueAt(i).toString();

  1820. 			else if(identifier=="value"){

  1821. 					slidervalue = props.getValueAt(i).toString();

  1822. 					value = "value("+slidervalue+"), ";

  1823. 			}

  1824. 			else if(identifier=="sliderskew")

  1825. 					skew = props.getValueAt(i).toString();

  1826. 			else if(identifier=="sliderincr")

  1827. 					incr = props.getValueAt(i).toString();

  1828. 

  1829. 			//grab xypad x-ranges...

  1830. 			else if(identifier=="minx")

  1831. 					minx = props.getValueAt(i).toString();

  1832. 			else if(identifier=="maxx")

  1833. 					maxx = props.getValueAt(i).toString();	

  1834. 			else if(identifier=="valuex")

  1835. 					valuex = props.getValueAt(i).toString();	

  1836. 

  1837. 			//grab xypad y-ranges...

  1838. 			else if(identifier=="miny")

  1839. 					miny = props.getValueAt(i).toString();

  1840. 			else if(identifier=="maxy")

  1841. 					maxy = props.getValueAt(i).toString();	

  1842. 			else if(identifier=="valuey")

  1843. 					valuey = props.getValueAt(i).toString();

  1844. 

  1845. 			else if((identifier=="textbox") && (int(props.getValueAt(i))==0)){

  1846. 			//only show if not set to default				

  1847. 			}

  1848. 			else if(identifier=="type")

  1849. 				type = props.getValueAt(i).toString();

  1850. 			else{

  1851. 				//catch all other identifiers....

  1852. 				line = line + identifier+String("(");

  1853. 				

  1854. 				if(propsArray.size()>0)

  1855. 				for(int y=0;y<propsArray.size();y++){

  1856. 					if(propsArray[y].isString())

  1857. 					temp = temp+"\""+propsArray[y].toString()+"\", ";

  1858. 					else

  1859. 					temp = temp+propsArray[y].toString()+", ";

  1860. 					}

  1861. 				else	

  1862. 						if(props.getValueAt(i).isString())							

  1863. 						temp = temp+"\""+props.getValueAt(i).toString()+"\"";

  1864. 						else

  1865. 						temp = temp+props.getValueAt(i).toString();

  1866. 				

  1867. 				line = line + temp + "), ";

  1868. 				temp = "";

  1869. 				}

  1870. 			}

  1871. 	}

  1872. 

  1873. 	String completeLine;

  1874. 	String range = "range("+min+", "+max+", "+slidervalue+", "+skew+", "+incr+"), ";

  1875. 	String rangex = "rangex("+minx+", "+maxx+", "+valuex+"), ";

  1876. 	String rangey = "rangey("+miny+", "+maxy+", "+valuey+"), ";

  1877. 	String xypadChannels = "channel(\""+xchannel+"\", \""+ychannel+"\"), ";

  1878. 	if((type == "rslider") || (type=="hslider") || (type=="vslider"))

  1879. 	completeLine = type+" bounds("+left+", "+top+", "+width+", "+height+"), "+channel+range+line.replace(", )", ")")+ " "+colour;

  1880. 	else if(type=="xypad")

  1881. 	completeLine = type+" bounds("+left+", "+top+", "+width+", "+height+"), "+xypadChannels+rangex+rangey+line.replace(", )", ")")+ " "+colour;

  1882. 	else

  1883. 	completeLine = type+" bounds("+left+", "+top+", "+width+", "+height+"), "+channel+line.replace(", )", ")")+ " "+tablenumber+drawmode+amprange+colour+resizemode+value;

  1884. 	return completeLine;

  1885. 	

  1886. }