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.
309 Commits
1 Branch
1.8MB
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/PoshSamplerPlugin/PoshSamplerPluginGUI.C

784 lines
24KB
Raw Permalink 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 "../GUI/WaveChooser.h"

  23. #include <FL/Fl_File_Chooser.H>

  24. 

  25. using namespace std;

  26. 

  27. ////////////////////////////////////////////

  28. 

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

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

  31. m_Sample(NULL),

  32. m_StartPos(1),

  33. m_EndPos(10),

  34. m_ViewStart(0),

  35. m_ViewEnd(INT_MAX),

  36. m_PlayPos(0),

  37. m_PlayStart(0),

  38. m_LoopStart(0),

  39. m_LoopEnd(INT_MAX),

  40. m_PosMarker(true)

  41. {

  42. }

  43. 

  44. Fl_WaveDisplay::~Fl_WaveDisplay()

  45. {

  46. }

  47. 

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

  49.      if (m_Sample) delete m_Sample;

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

  51. }

  52. 

  53. void Fl_WaveDisplay::ClearSample (void) {

  54.      if (m_Sample) delete m_Sample;

  55.      m_Sample = NULL;

  56. }

  57. 

  58. void Fl_WaveDisplay::draw()

  59. {

  60. 	int ho=h()/2;

  61. 	fl_color (m_BGColour);

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

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

  64. 

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

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

  67. 

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

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

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

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

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

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

  74. 

  75. 	float Value=0,NextValue=0;

  76. 	int pos=0;

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

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

  79. 

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

  81. 	{

  82. 		fl_font(fl_font(),10);

  83. 

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

  85. 		{

  86. 			fl_color (m_IndColour);

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

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

  89. 		}

  90. 

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

  92. 		{

  93. 			fl_color (m_MrkColour);

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

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

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

  97. 		}

  98. 

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

  100. 		{

  101. 			fl_color (m_MrkColour);

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

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

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

  105. 		}

  106. 

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

  108. 		{

  109. 			fl_color (m_MrkColour);

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

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

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

  113. 		}

  114. 

  115. 		if (n>m_StartPos && n<m_EndPos) fl_color (m_SelColour);

  116. 		else fl_color (m_FGColour);

  117. 

  118. 		Value = NextValue;

  119. 

  120. 		// get max

  121. 		float max=(*m_Sample)[n];

  122. 		float min=(*m_Sample)[n];

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

  124. 		{

  125. 			if (max<(*m_Sample)[m]) max=(*m_Sample)[m];

  126. 			if (min>(*m_Sample)[m]) min=(*m_Sample)[m];

  127. 		}

  128. 

  129. 		min*=ho; max*=ho;

  130. 

  131. 		fl_line(x()+pos-1, y()+ho-(int)min,

  132. 				x()+pos-1, y()+ho-(int)max);

  133. 		pos++;

  134. 	}

  135. }

  136. 

  137. int Fl_WaveDisplay::handle(int event)

  138. {

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

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

  141. 	static int DragX,DragY;

  142. 	static int Mousebutton=0;

  143. 	static int Holding=0;

  144. 	static int GrabDist=10;

  145. 

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

  147. 

  148. 	if (event==FL_PUSH)

  149. 	{

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

  151. 		Mousebutton=Fl::event_button();

  152. 		DragX=xx;

  153. 		DragY=yy;

  154. 

  155. 		if (Mousebutton==1)

  156. 		{

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

  158. 			Holding=0;

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

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

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

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

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

  164. 			else

  165. 			{

  166. 				m_StartPos=MousePos;

  167. 				m_EndPos=MousePos;

  168. 			}

  169. 		}

  170. 	}

  171. 	

  172. 	if (event==FL_DRAG)

  173. 	{

  174. 		if (Mousebutton==1)

  175. 		{	

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

  177. 

  178. 			switch (Holding)

  179. 			{

  180. 				case 0:

  181. 				{

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

  183. 					else m_StartPos=MousePos;					

  184. 				} break;

  185. 

  186. 				case 1:

  187. 				{

  188. 					m_StartPos=MousePos;

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

  190. 				} break;

  191. 				

  192. 

  193. 				case 2:

  194. 				{

  195. 					m_EndPos=MousePos;

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

  197. 				} break;

  198. 

  199. 				case 3: m_PlayStart=MousePos; break;

  200. 				case 4: m_LoopStart=MousePos; break;

  201. 				case 5: m_LoopEnd=MousePos; break;

  202. 			}

  203. 		}

  204. 

  205. 		if (Mousebutton==2)

  206. 		{

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

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

  209. 			{

  210. 				m_ViewStart+=Dist;

  211. 				m_ViewEnd+=Dist;

  212. 			}

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

  214. 			{

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

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

  217. 				{

  218. 					m_ViewStart+=Dist;

  219. 					m_ViewEnd+=Dist;

  220. 				}

  221. 			}

  222. 			DragX=xx;

  223. 			DragY=yy;

  224. 		}

  225. 

  226. 		if (Mousebutton==3)

  227. 		{

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

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

  230. 			{

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

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

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

  234. 				redraw();

  235. 			}

  236. 		}

  237. 

  238. 		do_callback();

  239. 		redraw();

  240. 	}

  241. 

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

  243. 

  244. 	return 1;

  245. }

  246. 

  247. void Fl_WaveDisplay::ZoomIn()

  248. {

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

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

  251. 	{

  252. 		m_ViewStart+=Zoom;

  253. 		m_ViewEnd-=Zoom;

  254. 	}

  255. 

  256. 	redraw();

  257. }

  258. 

  259. void Fl_WaveDisplay::ZoomOut()

  260. {

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

  262. 	m_ViewStart-=Zoom;

  263. 	m_ViewEnd+=Zoom;

  264. 	redraw();

  265. }

  266. 

  267. ////////////////////////////////////////////

  268. 

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

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

  271. m_UpdateMe(false)

  272. {

  273. 	int n=0;

  274. 

  275. 	m_Load = new Fl_Button(5, 20, 50, 20, "Load");

  276.         m_Load->labelsize(10);

  277.         m_Load->box (FL_PLASTIC_UP_BOX);

  278. 	m_Load->color (Info->GUI_COLOUR);

  279. 	m_Load->selection_color (Info->GUI_COLOUR);

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

  281. 	add(m_Load);

  282. 

  283. 	m_Save = new Fl_Button(55, 20, 50, 20, "Save");

  284.         m_Save->labelsize(10);

  285.         m_Save->box (FL_PLASTIC_UP_BOX);

  286. 	m_Save->color (Info->GUI_COLOUR);

  287. 	m_Save->selection_color (Info->GUI_COLOUR);

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

  289. 	add(m_Save);

  290. 

  291. 	m_Record = new Fl_Button(105, 20, 50, 20, "Record");

  292.         m_Record->type (FL_TOGGLE_BUTTON);

  293.         m_Record->box (FL_PLASTIC_UP_BOX);

  294. 	m_Record->color (FL_RED);

  295. 	m_Record->selection_color (FL_RED);

  296.         m_Record->labelsize (10);

  297.         //m_Record->labelcolor (FL_RED);

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

  299. 	add(m_Record);

  300. 

  301. 	m_Loop = new Fl_Button(5, 40, 75, 20, "Loop");

  302.         m_Loop->type (FL_TOGGLE_BUTTON);

  303.         m_Loop->labelsize(10);

  304.         m_Loop->box (FL_PLASTIC_UP_BOX);

  305. 	m_Loop->color (Info->GUI_COLOUR);

  306. 	m_Loop->selection_color (Info->GUI_COLOUR);

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

  308. 	add(m_Loop);

  309. 

  310. 	m_PingPong = new Fl_Button(80, 40, 75, 20, "PingPong");

  311. 	m_PingPong->type (FL_TOGGLE_BUTTON);

  312.         m_PingPong->labelsize(10);

  313.         m_PingPong->box (FL_PLASTIC_UP_BOX);

  314. 	m_PingPong->color (Info->GUI_COLOUR);

  315. 	m_PingPong->selection_color (Info->GUI_COLOUR);

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

  317. 	add(m_PingPong);

  318. 

  319. 	m_PosMarker = new Fl_Button(5, 60, 75, 20, "PosMarker");

  320. 	m_PosMarker->type (FL_TOGGLE_BUTTON);

  321.         m_PosMarker->labelsize(10);

  322.         m_PosMarker->box (FL_PLASTIC_UP_BOX);

  323. 	m_PosMarker->color (Info->GUI_COLOUR);

  324. 	m_PosMarker->selection_color (Info->GUI_COLOUR);

  325. 	m_PosMarker->value(1);

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

  327. 	add(m_PosMarker);

  328. 

  329. 	m_Retrig = new Fl_Button (80, 60, 75, 20, "Re-Trigger");

  330. 	m_Retrig->type (FL_TOGGLE_BUTTON);

  331.         m_Retrig->labelsize (10);

  332.         m_Retrig->box (FL_PLASTIC_UP_BOX);

  333. 	m_Retrig->color (Info->GUI_COLOUR);

  334. 	m_Retrig->selection_color (Info->GUI_COLOUR);

  335. 	m_Retrig->value (1);

  336. 	m_Retrig->callback ((Fl_Callback*)cb_Retrig);

  337. 	add (m_Retrig);

  338. 

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

  340.         m_Volume->color(Info->GUI_COLOUR);

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

  342.         m_Volume->labelsize(10);

  343.         m_Volume->maximum(2);

  344.         m_Volume->step(0.001);

  345.         m_Volume->value(1);

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

  347. 	add(m_Volume);

  348. 

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

  350.         m_Pitch->color(Info->GUI_COLOUR);

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

  352.         m_Pitch->labelsize(10);

  353.         m_Pitch->maximum(10);

  354.         m_Pitch->step(0.001);

  355.         m_Pitch->value(1);

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

  357. 	add(m_Pitch);

  358. 

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

  360.         m_Octave->color(Info->GUI_COLOUR);

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

  362.         m_Octave->labelsize(10);

  363.         m_Octave->maximum(12);

  364.         m_Octave->step(1);

  365.         m_Octave->value(6);

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

  367. 	add(m_Octave);

  368. 

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

  370.         m_SampleNum->labelsize(10);

  371. 	m_SampleNum->type(FL_SIMPLE_COUNTER);

  372.         m_SampleNum->box (FL_PLASTIC_UP_BOX);

  373. 	m_SampleNum->color (Info->GUI_COLOUR);

  374. 	m_SampleNum->selection_color (Info->GUI_COLOUR);

  375. 	m_SampleNum->step(1);

  376. 	m_SampleNum->value(n);

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

  378. 	add(m_SampleNum);

  379. 

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

  381.         m_Note->labelsize(10);

  382. 	m_Note->type(FL_SIMPLE_COUNTER);

  383.         m_Note->box (FL_PLASTIC_UP_BOX);

  384. 	m_Note->color (Info->GUI_COLOUR);

  385. 	m_Note->selection_color (Info->GUI_COLOUR);

  386. 	m_Note->step(1);

  387. 	m_Note->value(n);

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

  389. 	add(m_Note);

  390. 

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

  392.         m_Display->SetColours (Info->SCOPE_BG_COLOUR, Info->SCOPE_FG_COLOUR,

  393.                                Info->SCOPE_SEL_COLOUR, Info->SCOPE_IND_COLOUR, Info->SCOPE_MRK_COLOUR);

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

  395. 

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

  397. 	n=0;

  398. 

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

  400. 	m_Cut->labelsize(10);

  401.         m_Cut->box (FL_PLASTIC_UP_BOX);

  402. 	m_Cut->color (Info->GUI_COLOUR);

  403. 	m_Cut->selection_color (Info->GUI_COLOUR);

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

  405. 

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

  407. 	m_Copy->labelsize(10);

  408.         m_Copy->box (FL_PLASTIC_UP_BOX);

  409. 	m_Copy->color (Info->GUI_COLOUR);

  410. 	m_Copy->selection_color (Info->GUI_COLOUR);

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

  412. 

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

  414. 	m_Paste->labelsize(10);

  415.         m_Paste->box (FL_PLASTIC_UP_BOX);

  416. 	m_Paste->color (Info->GUI_COLOUR);

  417. 	m_Paste->selection_color (Info->GUI_COLOUR);

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

  419. 

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

  421. 	m_Mix->labelsize(10);

  422.         m_Mix->box (FL_PLASTIC_UP_BOX);

  423. 	m_Mix->color (Info->GUI_COLOUR);

  424. 	m_Mix->selection_color (Info->GUI_COLOUR);

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

  426. 

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

  428. 	m_Crop->labelsize(10);

  429.         m_Crop->box (FL_PLASTIC_UP_BOX);

  430. 	m_Crop->color (Info->GUI_COLOUR);

  431. 	m_Crop->selection_color (Info->GUI_COLOUR);

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

  433. 

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

  435. 	m_Reverse->labelsize(10);

  436.         m_Reverse->box (FL_PLASTIC_UP_BOX);

  437. 	m_Reverse->color (Info->GUI_COLOUR);

  438. 	m_Reverse->selection_color (Info->GUI_COLOUR);

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

  440. 

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

  442. 	m_Amp->labelsize(10);

  443.         m_Amp->box (FL_PLASTIC_UP_BOX);

  444. 	m_Amp->color (Info->GUI_COLOUR);

  445. 	m_Amp->selection_color (Info->GUI_COLOUR);

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

  447. 

  448. 	m_ZoomIn = new Fl_Button(bx+(n++*bs),by,bw,bh,"Zoom +");

  449. 	m_ZoomIn->labelsize(10);

  450.         m_ZoomIn->box (FL_PLASTIC_UP_BOX);

  451. 	m_ZoomIn->color (Info->GUI_COLOUR);

  452. 	m_ZoomIn->selection_color (Info->GUI_COLOUR);

  453. 	//m_ZoomIn->callback((Fl_Callback*)cb_ZoomIn);

  454. 

  455. 	m_ZoomOut = new Fl_Button(bx+(n++*bs),by,bw,bh,"Zoom -");

  456. 	m_ZoomOut->labelsize(10);

  457.         m_ZoomOut->box (FL_PLASTIC_UP_BOX);

  458. 	m_ZoomOut->color (Info->GUI_COLOUR);

  459. 	m_ZoomOut->selection_color (Info->GUI_COLOUR);

  460. 	//m_ZoomOut->callback((Fl_Callback*)cb_ZoomOut);

  461. 

  462. 	end();

  463. 	redraw();

  464. }

  465. 

  466. void PoshSamplerPluginGUI::UpdateSampleDisplay(int num) {

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

  468.      m_GUICH->Wait();

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

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

  471.      if (!SampleSize) m_Display->ClearSample();

  472.      else {

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

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

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

  476.         delete[] TempBuf;

  477.      }

  478. }

  479. 

  480. void PoshSamplerPluginGUI::Update() {

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

  482.      if (m_ZoomIn->value()) m_Display->ZoomIn();

  483.      if (m_ZoomOut->value()) m_Display->ZoomOut();

  484.      if (m_UpdateMe) {

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

  486.         m_Display->redraw();

  487.         m_UpdateMe=false;

  488.      }

  489.      // redraw();

  490. }

  491. 

  492. void PoshSamplerPluginGUI::UpdateValues (SpiralPlugin *o) {

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

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

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

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

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

  498.      m_Retrig->value (Plugin->GetReTrig ((int)m_SampleNum->value()));

  499.      m_UpdateMe = true;

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

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

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

  503.      m_Display->redraw();

  504. }

  505. 

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

  507. {

  508.         char *fn=WaveFileName ();

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

  510. 	{

  511. 		strcpy(m_TextBuf,fn);

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

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

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

  515. 

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

  517. 

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

  519. 		m_Display->redraw();

  520. 		redraw();

  521. 	}

  522. }

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

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

  525. 

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

  527. {

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

  529. 

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

  531. 	{

  532. 		strcpy(m_TextBuf,fn);

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

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

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

  536. 	}

  537. }

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

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

  540. 

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

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

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

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

  545. }

  546. 

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

  548.      ((PoshSamplerPluginGUI*)(o->parent()))->cb_Volume_i (o, v);

  549. }

  550. 

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

  552. {

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

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

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

  556. }

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

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

  559. 

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

  561. {

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

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

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

  565. }

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

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

  568. 

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

  570. {

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

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

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

  574. }

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

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

  577. 

  578. inline void PoshSamplerPluginGUI::cb_Retrig_i (Fl_Button *o, void *v) {

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

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

  581. 	m_GUICH->SetCommand(PoshSamplerPlugin::SETRETRIG);

  582. }

  583. void PoshSamplerPluginGUI::cb_Retrig (Fl_Button *o, void *v) {

  584.      ((PoshSamplerPluginGUI*)(o->parent()))->cb_Retrig_i (o, v);

  585. }

  586. 

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

  588. {

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

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

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

  592. }

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

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

  595. 

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

  597. {

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

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

  600. 	redraw();

  601. }

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

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

  604. 

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

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

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

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

  609. 

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

  611. {

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

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

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

  615. }

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

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

  618. 

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

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

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

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

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

  624.        m_GUICH->Wait();

  625.        m_GUICH->SetCommand (PoshSamplerPlugin::GETLOOP);

  626.        m_GUICH->Wait();

  627.        m_Loop->value (m_GUICH->GetBool ("BoolEcho"));

  628.        m_GUICH->SetCommand (PoshSamplerPlugin::GETPING);

  629.        m_GUICH->Wait();

  630.        m_PingPong->value (m_GUICH->GetBool ("BoolEcho"));

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

  632.        m_GUICH->Wait();

  633.        m_Retrig->value (m_GUICH->GetBool ("BoolEcho"));

  634.        m_GUICH->SetCommand (PoshSamplerPlugin::GETVOL);

  635.        m_GUICH->Wait();

  636.        m_Volume->value (m_GUICH->GetFloat ("ValEcho"));

  637.        m_GUICH->SetCommand (PoshSamplerPlugin::GETPITCH);

  638.        m_GUICH->Wait();

  639.        m_Pitch->value (m_GUICH->GetFloat ("ValEcho"));

  640.        m_GUICH->SetCommand (PoshSamplerPlugin::GETOCT);

  641.        m_GUICH->Wait();

  642.        m_Octave->value (m_GUICH->GetInt ("IntEcho"));

  643.        m_GUICH->SetCommand (PoshSamplerPlugin::GETNOTE);

  644.        m_GUICH->Wait();

  645.        m_Note->value (m_GUICH->GetInt ("IntEcho"));

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

  647. }

  648. 

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

  650.      ((PoshSamplerPluginGUI*)(o->parent()))->cb_SampleNum_i (o, v);

  651. }

  652. 

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

  654. {

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

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

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

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

  659. 	m_GUICH->Wait();

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

  661. 	m_Display->redraw();

  662. }

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

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

  665. 

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

  667. {

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

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

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

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

  672. }

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

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

  675. 

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

  677. {

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

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

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

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

  682. 	m_GUICH->Wait();

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

  684. 	m_Display->redraw();

  685. }

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

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

  688. 

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

  690. {

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

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

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

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

  695. 	m_GUICH->Wait();

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

  697. 	m_Display->redraw();

  698. }

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

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

  701. 

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

  703. {

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

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

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

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

  708. 	m_GUICH->Wait();

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

  710. 	m_Display->redraw();

  711. }

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

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

  714. 

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

  716. {

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

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

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

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

  721. 	m_GUICH->Wait();

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

  723. 	m_Display->redraw();

  724. }

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

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

  727. 

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

  729. {

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

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

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

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

  734. 	m_GUICH->Wait();

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

  736. 	m_Display->redraw();

  737. }

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

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

  740. 

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

  742. {

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

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

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

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

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

  748. }

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

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

  751. 

  752. inline void PoshSamplerPluginGUI::cb_ZoomIn_i(Fl_Button* o, void* v)

  753. {

  754. 	m_Display->ZoomIn();

  755. }

  756. void PoshSamplerPluginGUI::cb_ZoomIn(Fl_Button* o, void* v)

  757. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_ZoomIn_i(o,v);}

  758. 

  759. inline void PoshSamplerPluginGUI::cb_ZoomOut_i(Fl_Button* o, void* v)

  760. {

  761. 	m_Display->ZoomOut();

  762. }

  763. void PoshSamplerPluginGUI::cb_ZoomOut(Fl_Button* o, void* v)

  764. { ((PoshSamplerPluginGUI*)(o->parent()))->cb_ZoomOut_i(o,v);}

  765. 

  766. 

  767. const string PoshSamplerPluginGUI::GetHelpText(const string &loc){

  768.     return string("")

  769. 	+ "A sampler that allows simple sample editing (cut copy paste etc),\n"

  770. 	+ "dirty time stretching (by modulating the start pos + retriggering +\n"

  771. 	+ "modulating pitch) and loop start/end points with ping pong loop mode.\n"

  772. 	+ "Also implementations of controls, such as continuous pitch changing,\n"

  773. 	+ "so you can add portmento to samples, trigger velocity sets sample\n"

  774. 	+ "volume.\n\n"

  775. 	+ "Can records input data too.\n\n"

  776. 	+ "Controls:\n"

  777. 	+ "lmb: Select region\n"

  778. 	+ "mmb: Move view\n"

  779. 	+ "rmb: Draws samples at full zoom.\n\n"

  780. 	+ "Left mouse also drags loop points. The Loop end marker defaults to the\n"

  781. 	+ "end of the sample.\n\n"

  782. 	+ "Note: The loading and saving of samples is not yet realtime safe";

  783. }