non
/
spiralsynthmodular
mirror of https://github.com/original-male/spiralsynthmodular
1
0
Fork 0
Code Releases 0 Activity
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.
16 Commits
1 Branch
1.8MB
Tree: 36118dbaf5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '36118dbaf5'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/PoshSamplerPlugin/PoshSamplerPluginGUI.C

649 lines
18KB
Raw Blame History 

  1. /*  SpiralPlugin

  2.  *  Copyleft (C) 2000 David Griffiths <dave@pawfal.org>

  3.  *

  4.  *  This program is free software; you can redistribute it and/or modify

  5.  *  it under the terms of the GNU General Public License as published by

  6.  *  the Free Software Foundation; either version 2 of the License, or

  7.  *  (at your option) any later version.

  8.  *

  9.  *  This program 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 General Public License for more details.

  13.  *

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

  15.  *  along with this program; if not, write to the Free Software

  16.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

  17. */ 

  18. 

  19. #include "PoshSamplerPluginGUI.h"

  20. #include <FL/fl_draw.h>

  21. #include <FL/fl_draw.H>

  22. #include <FL/fl_file_chooser.h>

  23. 

  24. static const int GUI_COLOUR = 179;

  25. static const int GUIBG_COLOUR = 144;

  26. static const int GUIBG2_COLOUR = 145;

  27. 

  28. ////////////////////////////////////////////

  29. 

  30. Fl_WaveDisplay::Fl_WaveDisplay(int x,int y,int w,int h, char *Name) :

  31. Fl_Widget(x,y,w,h,Name),

  32. m_Sample(NULL),

  33. m_StartPos(1),

  34. m_EndPos(10),

  35. m_ViewStart(0),

  36. m_ViewEnd(INT_MAX),

  37. m_PlayPos(0),

  38. m_PlayStart(0),

  39. m_LoopStart(0),

  40. m_LoopEnd(INT_MAX),

  41. m_PosMarker(true)

  42. {

  43. }

  44. 

  45. Fl_WaveDisplay::~Fl_WaveDisplay()	

  46. {

  47. }

  48. 

  49. void Fl_WaveDisplay::SetSample(const float* s, long len) 

  50. { 

  51. 	if (m_Sample) delete m_Sample;

  52. 	m_Sample = new Sample(s,len);

  53. }

  54. 

  55. void Fl_WaveDisplay::draw()

  56. {

  57. 	int ho=h()/2;

  58. 	fl_color(GUIBG_COLOUR);

  59. 	fl_rectf(x(), y(), w(), h());

  60. 	if (!m_Sample || m_Sample->GetLength()==0) return;

  61. 	

  62. 	if (m_ViewStart<0) m_ViewStart=0;

  63. 	if (m_ViewEnd>m_Sample->GetLength()-1) m_ViewEnd=m_Sample->GetLength()-1;

  64. 

  65. 	if (m_PlayStart<0) m_PlayStart=0;

  66. 	if (m_PlayStart>m_Sample->GetLength()-1) m_PlayStart=m_Sample->GetLength()-1;

  67. 	if (m_LoopStart<0) m_LoopStart=0;

  68. 	if (m_LoopStart>m_Sample->GetLength()-1) m_LoopStart=m_Sample->GetLength()-1;	

  69. 	if (m_LoopEnd<0) m_LoopEnd=0;

  70. 	if (m_LoopEnd>m_Sample->GetLength()-1) m_LoopEnd=m_Sample->GetLength()-1;

  71. 	

  72. 	float Value=0,NextValue=0;	

  73. 	int pos=0;

  74. 	int Jump=(m_ViewEnd-m_ViewStart)/w();

  75. 	if (Jump==0) Jump=1;

  76. 		

  77. 	for(int n=m_ViewStart; n<m_ViewEnd-Jump; n+=Jump)

  78. 	{		

  79. 		fl_font(fl_font(),10);

  80. 			

  81. 		if (m_PlayPos>=n && m_PlayPos<n+Jump)

  82. 		{

  83. 			fl_color(FL_YELLOW);

  84. 			fl_line(x()+pos, y(),

  85. 				    x()+pos, y()+h());	

  86. 		}

  87. 		

  88. 		if (m_PlayStart>=n && m_PlayStart<n+Jump)

  89. 		{

  90. 			fl_color(FL_GREEN);

  91. 			fl_draw("S",x()+pos+2,y()+h());

  92. 			fl_line(x()+pos, y(),

  93. 				    x()+pos, y()+h());	

  94. 		}

  95. 

  96. 		if (m_LoopStart>=n && m_LoopStart<n+Jump)

  97. 		{			

  98. 			fl_color(FL_GREEN);

  99. 			fl_draw("LS",x()+pos+2,y()+h());

  100. 			fl_line(x()+pos, y(),

  101. 				    x()+pos, y()+h());	

  102. 		}

  103. 		

  104. 		if (m_LoopEnd>=n && m_LoopEnd<n+Jump)

  105. 		{

  106. 			fl_color(FL_GREEN);

  107. 			fl_draw("LE",x()+pos+2,y()+h());

  108. 			fl_line(x()+pos, y(),

  109. 				    x()+pos, y()+h());	

  110. 		}

  111. 		

  112. 		if (n>m_StartPos && n<m_EndPos) fl_color(FL_RED);

  113. 		else fl_color(FL_WHITE);

  114. 				

  115. 		Value = NextValue;

  116. 		

  117. 		// get average

  118. 		NextValue=0;

  119. 		for (int m=n; m<n+Jump; m++)

  120. 		{	

  121. 			NextValue+=(*m_Sample)[m];

  122. 		}

  123. 		NextValue=(NextValue*ho)/Jump;

  124. 		

  125. 		fl_line(x()+pos-2, y()+ho-(int)Value,

  126. 				x()+pos-1, y()+ho-(int)NextValue);				

  127. 		pos++;

  128. 	}	

  129. }

  130. 

  131. int Fl_WaveDisplay::handle(int event)		

  132. {

  133. 	int xx=Fl::event_x();

  134. 	int yy=Fl::event_y();

  135. 	static int DragX,DragY;

  136. 	static int Mousebutton=0;

  137. 	static int Holding=0;

  138. 	static int GrabDist=10;

  139. 	

  140. 	if (!m_Sample || m_Sample->GetLength()==0) return 1;

  141. 

  142. 	if (event==FL_PUSH) 

  143. 	{

  144. 		GrabDist=(int)((m_ViewEnd-m_ViewStart)*0.03f);

  145. 		Mousebutton=Fl::event_button();

  146. 		DragX=xx;

  147. 		DragY=yy;

  148. 		

  149. 		if (Mousebutton==1)

  150. 		{	

  151. 			int MousePos=(xx-x())*((m_ViewEnd-m_ViewStart)/w())+m_ViewStart;

  152. 			Holding=0;	

  153. 			if (abs(MousePos-m_StartPos)<GrabDist)    Holding=1;

  154. 			else if (abs(MousePos-m_EndPos)<GrabDist) Holding=2;

  155. 			else if (abs(MousePos-m_PlayStart)<GrabDist) Holding=3;			

  156. 			else if (abs(MousePos-m_LoopStart)<GrabDist) Holding=4;			

  157. 			else if (abs(MousePos-m_LoopEnd)<GrabDist) Holding=5;			

  158. 			else 

  159. 			{

  160. 				m_StartPos=MousePos;

  161. 				m_EndPos=MousePos;		

  162. 			}

  163. 		}

  164. 	}

  165. 	

  166. 	if (event==FL_DRAG)

  167. 	{

  168. 		if (Mousebutton==1)

  169. 		{	

  170. 			int MousePos=(xx-x())*((m_ViewEnd-m_ViewStart)/w())+m_ViewStart;				

  171. 

  172. 			switch (Holding)

  173. 			{

  174. 				case 0:

  175. 				{

  176. 					if (MousePos>m_EndPos) m_EndPos=MousePos;

  177. 					else m_StartPos=MousePos;					

  178. 				} break;

  179. 					

  180. 				case 1:

  181. 				{

  182. 					m_StartPos=MousePos;

  183. 					if (m_StartPos>m_EndPos) Holding=2; // swap

  184. 				} break;

  185. 				

  186. 			

  187. 				case 2:

  188. 				{

  189. 					m_EndPos=MousePos;

  190. 					if (m_StartPos>m_EndPos) Holding=1; // swap

  191. 				} break;

  192. 			

  193. 				case 3: m_PlayStart=MousePos; break;

  194. 				case 4: m_LoopStart=MousePos; break;

  195. 				case 5: m_LoopEnd=MousePos; break;

  196. 			}

  197. 		}

  198. 		

  199. 		if (Mousebutton==2)

  200. 		{

  201. 			int Dist=(DragX-xx)*((m_ViewEnd-m_ViewStart)/w());

  202. 			if (m_ViewStart>0 && m_ViewEnd<m_Sample->GetLength()-1)

  203. 			{			

  204. 				m_ViewStart+=Dist; 				

  205. 				m_ViewEnd+=Dist;

  206. 			}

  207. 			else // stop it sticking when at end/beginning

  208. 			{

  209. 				if ((Dist>0 && m_ViewStart<=0) ||

  210. 				    (Dist<0 && m_ViewEnd>=m_Sample->GetLength()-1)) 

  211. 				{

  212. 					m_ViewStart+=Dist; 				

  213. 					m_ViewEnd+=Dist;

  214. 				}

  215. 			}

  216. 			DragX=xx;

  217. 			DragY=yy;

  218. 		}	

  219. 		

  220. 		if (Mousebutton==3)

  221. 		{

  222. 			// only draw wave at 1 pixel = 1 sample

  223. 			if ((m_ViewEnd-m_ViewStart)/w()==1)

  224. 			{

  225. 				int MousePos=(xx-x())*((m_ViewEnd-m_ViewStart)/w())+m_ViewStart;				

  226. 				float Value=-(yy-y())/((float)h()/2.0f)+1.0f;			

  227. 				m_Sample->Set(MousePos,Value);

  228. 				redraw();

  229. 			}

  230. 		}

  231. 		

  232. 		do_callback();

  233. 		redraw();		

  234. 	}

  235. 	

  236. 	if (event==FL_KEYBOARD || event==FL_SHORTCUT)

  237. 	{

  238. 		if (Fl::event_key('+'))	

  239. 		{

  240. 			int Zoom=(int)((m_ViewEnd-m_ViewStart)*0.03f);

  241. 			if ((m_ViewEnd-m_ViewStart)/w()>1)

  242. 			{

  243. 				m_ViewStart+=Zoom; 

  244. 				m_ViewEnd-=Zoom;

  245. 			}

  246. 			

  247. 			redraw();

  248. 		}

  249. 		

  250. 		if (Fl::event_key('-'))	

  251. 		{

  252. 			int Zoom=(int)((m_ViewEnd-m_ViewStart)*0.03f);

  253. 			m_ViewStart-=Zoom; 

  254. 			m_ViewEnd+=Zoom;

  255. 			redraw();

  256. 		}					

  257. 	}

  258. 	

  259. 	if (m_EndPos>=m_Sample->GetLength()) m_EndPos=m_Sample->GetLength()-1;

  260. 	

  261. 	return 1;

  262. }

  263. 

  264. ////////////////////////////////////////////

  265. 

  266. PoshSamplerPluginGUI::PoshSamplerPluginGUI(int w, int h,PoshSamplerPlugin *o,ChannelHandler *ch,const HostInfo *Info) :

  267. SpiralPluginGUI(w,h,o,ch)

  268. {	

  269. 	int n=0; 

  270. 			

  271. 	m_Load = new Fl_Button(5, 20, 70, 20, "Load");

  272.     m_Load->labelsize(10);

  273. 	m_Load->callback((Fl_Callback*)cb_Load);

  274. 	add(m_Load);

  275. 

  276. 	m_Save = new Fl_Button(5, 40, 70, 20, "Save");

  277.     m_Save->labelsize(10);

  278. 	m_Save->callback((Fl_Callback*)cb_Save);

  279. 	add(m_Save);

  280. 		

  281. 	m_Record = new Fl_Button(5, 60, 70, 20, "Record");

  282.     m_Record->type(1);	

  283.     m_Record->labelsize(10);

  284.     m_Record->labelcolor(FL_RED);

  285. 	m_Record->callback((Fl_Callback*)cb_Record);

  286. 	add(m_Record);

  287. 

  288. 	m_Loop = new Fl_Button(80, 20, 70, 20, "Loop");

  289.     m_Loop->labelsize(10);

  290. 	m_Loop->type(1);

  291. 	m_Loop->callback((Fl_Callback*)cb_Loop);

  292. 	add(m_Loop);

  293. 

  294. 	m_PingPong = new Fl_Button(80, 40, 70, 20, "PingPong");

  295.     m_PingPong->labelsize(10);

  296. 	m_PingPong->type(1);

  297. 	m_PingPong->callback((Fl_Callback*)cb_PingPong);

  298. 	add(m_PingPong);

  299. 

  300. 	m_PosMarker = new Fl_Button(80, 60, 70, 20, "PosMarker");

  301.     m_PosMarker->labelsize(10);

  302. 	m_PosMarker->type(1);

  303. 	m_PosMarker->value(1);

  304. 	m_PosMarker->callback((Fl_Callback*)cb_PosMarker);

  305. 	add(m_PosMarker);

  306. 	

  307. 

  308. 	m_Volume = new Fl_Knob(160, 20, 50, 50, "Volume");

  309.     m_Volume->color(GUI_COLOUR);

  310. 	m_Volume->type(Fl_Knob::LINELIN);

  311.     m_Volume->labelsize(10);

  312.     m_Volume->maximum(2);

  313.     m_Volume->step(0.001);

  314.     m_Volume->value(1);   

  315. 	m_Volume->callback((Fl_Callback*)cb_Volume);

  316. 	add(m_Volume);

  317. 	

  318. 	m_Pitch = new Fl_Knob(220, 20, 50, 50, "Pitch");

  319.     m_Pitch->color(GUI_COLOUR);

  320. 	m_Pitch->type(Fl_Knob::LINELIN);

  321.     m_Pitch->labelsize(10);

  322.     m_Pitch->maximum(10);

  323.     m_Pitch->step(0.001);

  324.     m_Pitch->value(1);   

  325. 	m_Pitch->callback((Fl_Callback*)cb_Pitch);

  326. 	add(m_Pitch);

  327. 

  328. 	m_Octave = new Fl_Knob(280, 20, 50, 50, "Octave");

  329.     m_Octave->color(GUI_COLOUR);

  330. 	m_Octave->type(Fl_Knob::LINELIN);

  331.     m_Octave->labelsize(10);

  332.     m_Octave->maximum(12);

  333.     m_Octave->step(1);

  334.     m_Octave->value(6);   

  335. 	m_Octave->callback((Fl_Callback*)cb_Octave);

  336. 	add(m_Octave);

  337. 		

  338. 	m_Note = new Fl_Counter(w-45, 50, 30, 20, "Trig Note");

  339.     m_Note->labelsize(10);

  340. 	m_Note->type(FL_SIMPLE_COUNTER);

  341. 	m_Note->step(1);

  342. 	m_Note->value(n);

  343. 	m_Note->callback((Fl_Callback*)cb_Note);

  344. 	add(m_Note);

  345. 	

  346. 	m_SampleNum = new Fl_Counter(w-45, 15, 30, 20, "Sample");

  347.     m_SampleNum->labelsize(10);

  348. 	m_SampleNum->type(FL_SIMPLE_COUNTER);

  349. 	m_SampleNum->step(1);

  350. 	m_SampleNum->value(n);

  351. 	m_SampleNum->callback((Fl_Callback*)cb_SampleNum);

  352. 	add(m_SampleNum);

  353. 	

  354. 	m_Display = new Fl_WaveDisplay(5,85,w-10,100,"");

  355. 	m_Display->callback((Fl_Callback*)cb_WaveDisplay);

  356. 	

  357. 	int bx=5,by=190,bw=w/7-2,bh=20,bs=w/7-2;

  358. 	n=0;

  359. 	

  360. 	m_Cut = new Fl_Button(bx+(n++*bs),by,bw,bh,"Cut");

  361. 	m_Cut->labelsize(10);

  362. 	m_Cut->callback((Fl_Callback*)cb_Cut);

  363. 	

  364. 	m_Copy = new Fl_Button(bx+(n++*bs),by,bw,bh,"Copy");

  365. 	m_Copy->labelsize(10);

  366. 	m_Copy->callback((Fl_Callback*)cb_Copy);

  367. 

  368. 	m_Paste = new Fl_Button(bx+(n++*bs),by,bw,bh,"Paste");

  369. 	m_Paste->labelsize(10);

  370. 	m_Paste->callback((Fl_Callback*)cb_Paste);

  371. 

  372. 	m_Mix = new Fl_Button(bx+(n++*bs),by,bw,bh,"Mix");

  373. 	m_Mix->labelsize(10);

  374. 	m_Mix->callback((Fl_Callback*)cb_Mix);

  375. 

  376. 	m_Crop = new Fl_Button(bx+(n++*bs),by,bw,bh,"Crop");

  377. 	m_Crop->labelsize(10);

  378. 	m_Crop->callback((Fl_Callback*)cb_Crop);

  379. 

  380. 	m_Reverse = new Fl_Button(bx+(n++*bs),by,bw,bh,"Reverse");

  381. 	m_Reverse->labelsize(10);

  382. 	m_Reverse->callback((Fl_Callback*)cb_Reverse);

  383. 

  384. 	m_Amp = new Fl_Button(bx+(n++*bs),by,bw,bh,"Amp");

  385. 	m_Amp->labelsize(10);

  386. 	m_Amp->callback((Fl_Callback*)cb_Amp);

  387. 

  388. 	end();

  389. 	

  390. 	redraw();

  391. }

  392. 

  393. void PoshSamplerPluginGUI::UpdateSampleDisplay(int num)

  394. {

  395. 	m_GUICH->SetCommand(PoshSamplerPlugin::GETSAMPLE);

  396. 	m_GUICH->Wait();

  397. 	m_GUICH->RequestChannelAndWait("SampleSize");

  398. 	long SampleSize=m_GUICH->GetLong("SampleSize");

  399. 	

  400. 	if (SampleSize)

  401. 	{

  402. 		char *TempBuf = new char[SampleSize];

  403. 		m_GUICH->BulkTransfer("SampleBuffer",(void*)TempBuf,SampleSize);

  404. 		m_Display->SetSample((float*)TempBuf,SampleSize/sizeof(float));

  405. 		delete[] TempBuf;

  406. 	}

  407. }

  408. 

  409. void PoshSamplerPluginGUI::draw()

  410. {

  411. 	SpiralPluginGUI::draw();

  412. 	SetPlayPos(m_GUICH->GetLong("PlayPos"));

  413. }

  414. 

  415. void PoshSamplerPluginGUI::UpdateValues(SpiralPlugin *o)

  416. {

  417. 	PoshSamplerPlugin *Plugin = (PoshSamplerPlugin*)o;

  418. 

  419. 	m_Volume->value(Plugin->GetVolume((int)m_SampleNum->value()));

  420. 	m_Pitch->value(Plugin->GetPitch((int)m_SampleNum->value()));

  421. 	m_Note->value(Plugin->GetNote((int)m_SampleNum->value()));	

  422. 	m_Loop->value(Plugin->GetLoop((int)m_SampleNum->value()));	

  423. 	Sample *sample = Plugin->GetSample((int)m_SampleNum->value());

  424. 	if (sample->GetLength())

  425. 	{

  426. 		m_Display->SetSample(sample->GetBuffer(),sample->GetLength());	

  427. 	}

  428. 	m_Display->SetPlayStart(Plugin->GetPlayStart((int)m_SampleNum->value()));	

  429. 	m_Display->SetLoopStart(Plugin->GetLoopStart((int)m_SampleNum->value()));	

  430. 	m_Display->SetLoopEnd(Plugin->GetLoopEnd((int)m_SampleNum->value()));	

  431. 	m_Display->redraw();

  432. }

  433. 	

  434. inline void PoshSamplerPluginGUI::cb_Load_i(Fl_Button* o, void* v)

  435. { 

  436. 	char *fn=fl_file_chooser("Load a sample", "{*.wav,*.WAV}", NULL);

  437. 		

  438. 	if (fn && fn!='\0')

  439. 	{

  440. 		strcpy(m_TextBuf,fn);

  441. 		m_GUICH->SetData("Name",m_TextBuf);

  442. 		m_GUICH->Set("Num",(int)m_SampleNum->value());

  443. 		m_GUICH->SetCommand(PoshSamplerPlugin::LOAD);

  444. 		

  445. 		m_GUICH->Wait(); // wait for the sample to load

  446. 				

  447. 		UpdateSampleDisplay((int)m_SampleNum->value());

  448. 		m_Display->redraw();

  449. 		redraw();

  450. 	}

  451. }

  452. void PoshSamplerPluginGUI::cb_Load(Fl_Button* o, void* v)

  453. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Load_i(o,v);}

  454. 

  455. inline void PoshSamplerPluginGUI::cb_Save_i(Fl_Button* o, void* v)

  456. {

  457. 	char *fn=fl_file_chooser("Save sample", "{*.wav,*.WAV}", NULL);

  458. 		

  459. 	if (fn && fn!='\0')

  460. 	{		

  461. 		strcpy(m_TextBuf,fn);

  462. 		m_GUICH->Set("Name",m_TextBuf);

  463. 		m_GUICH->Set("Num",(int)m_SampleNum->value());

  464. 		m_GUICH->SetCommand(PoshSamplerPlugin::SAVE);

  465. 	}

  466. }

  467. void PoshSamplerPluginGUI::cb_Save(Fl_Button* o, void* v)

  468. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Save_i(o,v);}

  469. 

  470. inline void PoshSamplerPluginGUI::cb_Volume_i(Fl_Knob* o, void* v)

  471. { 		

  472. 	m_GUICH->Set("Value",(float)o->value());

  473. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  474. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETVOL);

  475. }

  476. void PoshSamplerPluginGUI::cb_Volume(Fl_Knob* o, void* v)

  477. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Volume_i(o,v);}

  478. 

  479. inline void PoshSamplerPluginGUI::cb_Pitch_i(Fl_Knob* o, void* v)

  480. { 	

  481. 	m_GUICH->Set("Value",(float)o->value());

  482. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  483. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETPITCH);

  484. }

  485. void PoshSamplerPluginGUI::cb_Pitch(Fl_Knob* o, void* v)

  486. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Pitch_i(o,v);}

  487. 

  488. inline void PoshSamplerPluginGUI::cb_Octave_i(Fl_Knob* o, void* v)

  489. { 

  490. 	m_GUICH->Set("Int",(int)o->value());

  491. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  492. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETOCT);

  493. }

  494. void PoshSamplerPluginGUI::cb_Octave(Fl_Knob* o, void* v)

  495. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Octave_i(o,v);}

  496. 

  497. inline void PoshSamplerPluginGUI::cb_Loop_i(Fl_Button* o, void* v)

  498. { 	

  499. 	m_GUICH->Set("Bool",(bool)o->value());

  500. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  501. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETLOOP);

  502. }

  503. void PoshSamplerPluginGUI::cb_Loop(Fl_Button* o, void* v)

  504. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Loop_i(o,v);}

  505. 

  506. inline void PoshSamplerPluginGUI::cb_PingPong_i(Fl_Button* o, void* v)

  507. { 	

  508. 	m_GUICH->Set("Bool",(bool)o->value());

  509. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  510. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETPING);

  511. }

  512. void PoshSamplerPluginGUI::cb_PingPong(Fl_Button* o, void* v)

  513. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_PingPong_i(o,v);}

  514. 

  515. inline void PoshSamplerPluginGUI::cb_Record_i(Fl_Button* o, void* v)

  516. {

  517. 	m_GUICH->Set("Bool",(bool)o->value());

  518. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETREC);

  519. 	redraw();

  520. }

  521. void PoshSamplerPluginGUI::cb_Record(Fl_Button* o, void* v)

  522. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Record_i(o,v);}

  523. 

  524. inline void PoshSamplerPluginGUI::cb_PosMarker_i(Fl_Button* o, void* v)

  525. { m_Display->SetPosMarker(o->value()); }

  526. void PoshSamplerPluginGUI::cb_PosMarker(Fl_Button* o, void* v)

  527. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_PosMarker_i(o,v);}

  528. 

  529. inline void PoshSamplerPluginGUI::cb_Note_i(Fl_Counter* o, void* v)

  530. { 

  531. 	m_GUICH->Set("Int",(int)o->value());

  532. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  533. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETNOTE);

  534. }

  535. void PoshSamplerPluginGUI::cb_Note(Fl_Counter* o, void* v)

  536. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Note_i(o,v);}

  537. 

  538. inline void PoshSamplerPluginGUI::cb_SampleNum_i(Fl_Counter* o, void* v)

  539. { 

  540. 	if (m_SampleNum->value()<0) m_SampleNum->value(0);

  541. 	if (m_SampleNum->value()>7) m_SampleNum->value(7);

  542. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  543. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETCURRENT);

  544. 	m_GUICH->Wait(); 

  545. 	UpdateSampleDisplay((int)m_SampleNum->value());

  546. }

  547. void PoshSamplerPluginGUI::cb_SampleNum(Fl_Counter* o, void* v)

  548. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_SampleNum_i(o,v);}

  549. 

  550. 

  551. inline void PoshSamplerPluginGUI::cb_Cut_i(Fl_Button* o, void* v)

  552. {	

  553. 	m_GUICH->Set("Start",(long)m_Display->GetRangeStart());

  554. 	m_GUICH->Set("End",(long)m_Display->GetRangeEnd());

  555. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  556. 	m_GUICH->SetCommand(PoshSamplerPlugin::CUT);

  557. 	m_GUICH->Wait(); 

  558. 	UpdateSampleDisplay((int)m_SampleNum->value());

  559. 	m_Display->redraw();

  560. }

  561. void PoshSamplerPluginGUI::cb_Cut(Fl_Button* o, void* v)

  562. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Cut_i(o,v);}

  563. 	

  564. inline void PoshSamplerPluginGUI::cb_Copy_i(Fl_Button* o, void* v)

  565. {	

  566. 	m_GUICH->Set("Start",(long)m_Display->GetRangeStart());

  567. 	m_GUICH->Set("End",(long)m_Display->GetRangeEnd());

  568. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  569. 	m_GUICH->SetCommand(PoshSamplerPlugin::COPY);

  570. }

  571. void PoshSamplerPluginGUI::cb_Copy(Fl_Button* o, void* v)

  572. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Copy_i(o,v);}

  573. 	

  574. inline void PoshSamplerPluginGUI::cb_Paste_i(Fl_Button* o, void* v)

  575. {

  576. 	m_GUICH->Set("Start",(long)m_Display->GetRangeStart());

  577. 	m_GUICH->Set("End",(long)m_Display->GetRangeEnd());

  578. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  579. 	m_GUICH->SetCommand(PoshSamplerPlugin::PASTE);

  580. 	m_GUICH->Wait(); 

  581. 	UpdateSampleDisplay((int)m_SampleNum->value());

  582. 	m_Display->redraw();

  583. }

  584. void PoshSamplerPluginGUI::cb_Paste(Fl_Button* o, void* v)

  585. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Paste_i(o,v);}

  586. 	

  587. inline void PoshSamplerPluginGUI::cb_Mix_i(Fl_Button* o, void* v)

  588. {

  589. 	m_GUICH->Set("Start",(long)m_Display->GetRangeStart());

  590. 	m_GUICH->Set("End",(long)m_Display->GetRangeEnd());

  591. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  592. 	m_GUICH->SetCommand(PoshSamplerPlugin::MIX);

  593. 	m_GUICH->Wait(); 

  594. 	UpdateSampleDisplay((int)m_SampleNum->value());

  595. 	m_Display->redraw();

  596. }

  597. void PoshSamplerPluginGUI::cb_Mix(Fl_Button* o, void* v)

  598. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Mix_i(o,v);}

  599. 

  600. inline void PoshSamplerPluginGUI::cb_Crop_i(Fl_Button* o, void* v)

  601. {

  602. 	m_GUICH->Set("Start",(long)m_Display->GetRangeStart());

  603. 	m_GUICH->Set("End",(long)m_Display->GetRangeEnd());

  604. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  605. 	m_GUICH->SetCommand(PoshSamplerPlugin::CROP);

  606. 	m_GUICH->Wait(); 

  607. 	UpdateSampleDisplay((int)m_SampleNum->value());

  608. 	m_Display->redraw();

  609. }

  610. void PoshSamplerPluginGUI::cb_Crop(Fl_Button* o, void* v)

  611. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Crop_i(o,v);}

  612. 

  613. inline void PoshSamplerPluginGUI::cb_Reverse_i(Fl_Button* o, void* v)

  614. {	

  615. 	m_GUICH->Set("Start",(long)m_Display->GetRangeStart());

  616. 	m_GUICH->Set("End",(long)m_Display->GetRangeEnd());

  617. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  618. 	m_GUICH->SetCommand(PoshSamplerPlugin::REV);

  619. 	m_GUICH->Wait(); 

  620. 	UpdateSampleDisplay((int)m_SampleNum->value());

  621. 	m_Display->redraw();

  622. }

  623. void PoshSamplerPluginGUI::cb_Reverse(Fl_Button* o, void* v)

  624. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Reverse_i(o,v);}

  625. 

  626. inline void PoshSamplerPluginGUI::cb_Amp_i(Fl_Button* o, void* v)

  627. {

  628. 	m_GUICH->Set("Start",(long)m_Display->GetRangeStart());

  629. 	m_GUICH->Set("End",(long)m_Display->GetRangeEnd());

  630. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  631. 	m_GUICH->SetCommand(PoshSamplerPlugin::AMP);

  632. 	m_GUICH->Wait(); 

  633. 	UpdateSampleDisplay((int)m_SampleNum->value());

  634. 	m_Display->redraw();

  635. }

  636. void PoshSamplerPluginGUI::cb_Amp(Fl_Button* o, void* v)

  637. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_Amp_i(o,v);}

  638. 

  639. inline void PoshSamplerPluginGUI::cb_WaveDisplay_i(Fl_WaveDisplay* o, void* v)

  640. {

  641. 	m_GUICH->Set("Start",(long)o->GetPlayStart());

  642. 	m_GUICH->Set("End",(long)o->GetLoopEnd());

  643. 	m_GUICH->Set("LoopStart",(long)o->GetLoopStart());	

  644. 	m_GUICH->Set("Num",(int)m_SampleNum->value());

  645. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETPLAYPOINTS);

  646. }

  647. void PoshSamplerPluginGUI::cb_WaveDisplay(Fl_WaveDisplay* o, void* v)

  648. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_WaveDisplay_i(o,v);}