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.
115 Commits
1 Branch
1.8MB
Tree: e92be7cc72
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e92be7cc72'
${ noResults }
spiralsynthmodular/SpiralSound/Plugins/SpiralLoopPlugin/GUI/Widgets/Fl_Knob.fld

281 lines
6.4KB
Raw Blame History 

  1. # data file for the Fltk User Interface Designer (fluid)

  2. version 2.00 

  3. header_name {.H} 

  4. code_name {.cxx} 

  5. gridx 5 

  6. gridy 5 

  7. snap 3

  8. decl {\#include <FL/Fl_Valuator.H>} {public

  9. } 

  10. 

  11. decl {\#include <FL/fl_draw.H>} {} 

  12. 

  13. decl {\#include <math.h>} {} 

  14. 

  15. class Fl_Knob {open : {public Fl_Valuator}

  16. } {

  17.   decl {enum Fl_Knobtype {DOTLIN=0,DOTLOG_1,DOTLOG_2,DOTLOG_3,LINELIN,LINELOG_1,LINELOG_2,LINELOG_3};} {public

  18.   }

  19.   decl {int _type;} {}

  20.   decl {float _percent;} {}

  21.   decl {int _scaleticks;} {}

  22.   decl {short a1,a2;} {}

  23.   Function {Fl_Knob(int xx,int yy,int ww,int hh,const char *l=0): Fl_Valuator(xx,yy,ww,hh,l)} {} {

  24.     code {a1 = 35;

  25. 	a2 = 325;

  26. 	_type = DOTLIN;

  27. 	_percent = 0.3;

  28. 	_scaleticks = 10;} {}

  29.   }

  30.   Function {~Fl_Knob()} {} {}

  31.   Function {draw()} {open private

  32.   } {

  33.     code {int ox,oy,ww,hh,side;

  34. float sa,ca,a_r;

  35. unsigned char rr,gg,bb;

  36. 

  37. 	ox = x();

  38. 	oy = y();

  39. 	ww = w();

  40. 	hh = h();

  41. 	draw_label();

  42. 	fl_clip(ox,oy,ww,hh);

  43. 	if (ww > hh)

  44. 	{

  45. 		side = hh;

  46. 		ox = ox + (ww - side) / 2; 

  47. 	}

  48. 	else

  49. 	{

  50. 		side = ww;

  51. 		oy = oy + (hh - side) / 2; 

  52. 	}

  53. 	side = w() > h () ? hh:ww;

  54. 	int dam = damage();

  55. 	if (dam & FL_DAMAGE_ALL)

  56. 	{

  57. 		int col = parent()->color();

  58. 		fl_color(col);

  59. 		fl_rectf(ox,oy,side,side);

  60. 		Fl::get_color((Fl_Color)col,rr,gg,bb);

  61. 		shadow(-60,rr,gg,bb);

  62. 		fl_pie(ox+9,oy+9,side-12,side-12,0,360);

  63. 		draw_scale(ox,oy,side);

  64. 		col = color();

  65. 		Fl::get_color((Fl_Color)col,rr,gg,bb);

  66. 		shadow(15,rr,gg,bb);

  67. 		fl_pie(ox+6,oy+6,side-12,side-12,40,80);

  68. 		shadow(30,rr,gg,bb);

  69. 		fl_pie(ox+6,oy+6,side-12,side-12,80,220);

  70. 		shadow(-15,rr,gg,bb);

  71. 		fl_pie(ox+6,oy+6,side-12,side-12,220,260);

  72. 		shadow(-30,rr,gg,bb);

  73. 		fl_pie(ox+6,oy+6,side-12,side-12,260,400);

  74. 		fl_color(FL_BLACK);

  75. 		fl_arc(ox+6,oy+6,side-11,side-11,0,360);

  76. 		fl_color(col);

  77. 		fl_pie(ox+10,oy+10,side-20,side-20,0,360);

  78. 	}

  79. 	else

  80. 	{

  81. 		fl_color(color());

  82. 		fl_pie(ox+10,oy+10,side-20,side-20,0,360);

  83. 	}

  84. 	Fl::get_color((Fl_Color)color(),rr,gg,bb);

  85. 	shadow(10,rr,gg,bb);

  86. 	fl_pie(ox+10,oy+10,side-20,side-20,110,150);

  87. 	fl_pie(ox+10,oy+10,side-20,side-20,290,330);

  88. 	shadow(17,rr,gg,bb);

  89. 	fl_pie(ox+10,oy+10,side-20,side-20,120,140);

  90. 	fl_pie(ox+10,oy+10,side-20,side-20,300,320);

  91. 	shadow(25,rr,gg,bb);

  92. 	fl_pie(ox+10,oy+10,side-20,side-20,127,133);

  93. 	fl_pie(ox+10,oy+10,side-20,side-20,307,313);

  94. 	draw_cursor(ox,oy,side);

  95. 	fl_pop_clip();} {selected

  96.     }

  97.   }

  98.   Function {handle(int  event)} {private return_type int

  99.   } {

  100.     code {int ox,oy,ww,hh;

  101. 

  102. 	ox = x() + 10; oy = y() + 10;

  103. 	ww = w() - 20;

  104. 	hh = h()-20;

  105. 	switch (event) 

  106. 	{

  107.   		case FL_PUSH:

  108.     			handle_push();

  109.   		case FL_DRAG:

  110. 			{

  111. 				int mx = Fl::event_x()-ox-ww/2;

  112. 				int my = Fl::event_y()-oy-hh/2;

  113. 				if (!mx && !my) return 1;

  114.     				double angle = 270-atan2((float)-my, (float)mx)*180/M_PI;

  115. 				double oldangle = (a2-a1)*(value()-minimum())/(maximum()-minimum()) + a1;

  116. 				while (angle < oldangle-180) angle += 360;

  117. 				while (angle > oldangle+180) angle -= 360;

  118. 				double val;

  119. 				if ((a1<a2) ? (angle <= a1) : (angle >= a1))

  120. 				{

  121. 					val = minimum();

  122. 				} 

  123. 				else 

  124. 				if ((a1<a2) ? (angle >= a2) : (angle <= a2)) 

  125. 				{

  126.       				val = maximum();

  127.     			} 

  128. 				else

  129. 				{

  130. 					val = minimum() + (maximum()-minimum())*(angle-a1)/(a2-a1);

  131. 				}

  132. 				handle_drag(clamp(round(val)));

  133. 			} 

  134. 			return 1;

  135. 		case FL_RELEASE:

  136. 			handle_release();

  137. 			return 1;

  138. 		default:

  139. 			return 0;

  140.   	}

  141. 	return 0;} {}

  142.   }

  143.   Function {type(int ty)} {} {

  144.     code {_type = ty;} {}

  145.   }

  146.   Function {shadow(const int offs,const uchar r,uchar g,uchar b)} {private

  147.   } {

  148.     code {int rr,gg,bb;

  149. 

  150. 	rr = r + offs; 

  151. 	rr = rr > 255 ? 255:rr;

  152. 	rr = rr < 0 ? 0:rr;

  153. 	gg = g + offs; 

  154. 	gg = gg > 255 ? 255:gg;

  155. 	gg = gg < 0 ? 0:gg;

  156. 	bb = b + offs; 

  157. 	bb = bb > 255 ? 255:bb;

  158. 	bb = bb < 0 ? 0:bb;

  159. 	fl_color((uchar)rr,(uchar)gg,(uchar)bb);} {}

  160.   }

  161.   Function {draw_scale(const int ox,const int oy,const int side)} {private

  162.   } {

  163.     code {float x1,y1,x2,y2,rds,cx,cy,ca,sa;

  164. 

  165. 	rds = side / 2;

  166. 	cx = ox + side / 2;

  167. 	cy = oy + side / 2;

  168. 	if (!(_type & DOTLOG_3))		

  169. 	{

  170. 		if (_scaleticks == 0) return;

  171. 		double a_step = (10.0*3.14159/6.0) / _scaleticks;

  172. 		double a_orig = -(3.14159/3.0);

  173. 		for (int a = 0; a <= _scaleticks; a++)

  174. 		{

  175. 			double na = a_orig + a * a_step;

  176. 			ca = cos(na);

  177. 			sa = sin(na);

  178. 			x1 = cx + rds * ca;

  179. 			y1 = cy - rds * sa;

  180. 			x2 = cx + (rds-6) * ca;

  181. 			y2 = cy - (rds-6) * sa;

  182. 			fl_color(FL_BLACK);

  183. 			fl_line(x1,y1,x2,y2);

  184. 			fl_color(FL_WHITE);

  185. 			if (sa*ca >=0)

  186. 				fl_line(x1+1,y1+1,x2+1,y2+1);

  187. 			else

  188. 				fl_line(x1+1,y1-1,x2+1,y2-1);

  189. 		}

  190. 	}

  191. 	else

  192. 	{

  193. 		int nb_dec = (_type & DOTLOG_3);

  194. 		for (int k = 0; k < nb_dec; k++)

  195. 		{

  196. 			double a_step = (10.0*3.14159/6.0) / nb_dec;

  197. 			double a_orig = -(3.14159/3.0) + k * a_step;

  198. 			for (int a = (k) ? 2:1; a <= 10; )

  199. 			{

  200. 				double na = a_orig + log10((double)a) * a_step;

  201. 				ca = cos(na);

  202. 				sa = sin(na);

  203. 				x1 = cx - rds * ca;

  204. 				y1 = cy - rds * sa;

  205. 				x2 = cx - (rds-6) * ca;

  206. 				y2 = cy - (rds-6) * sa;

  207. 				fl_color(FL_BLACK);

  208. 				fl_line(x1,y1,x2,y2);

  209. 				fl_color(FL_WHITE);

  210. 				if (sa*ca <0)

  211. 					fl_line(x1+1,y1+1,x2+1,y2+1);

  212. 				else

  213. 					fl_line(x1+1,y1-1,x2+1,y2-1);

  214. 				if ((a == 1) || (nb_dec == 1))

  215. 					a += 1;

  216. 				else

  217. 					a += 2;

  218. 			}

  219. 		}

  220. 	}} {}

  221.   }

  222.   Function {draw_cursor(const int ox,const int oy,const int side)} {private

  223.   } {

  224.     code {float rds,cur,cx,cy;

  225. double angle;

  226. 	

  227. 	rds = (side - 20) / 2.0;

  228. 	cur = _percent * rds / 2;

  229. 	cx = ox + side / 2;

  230. 	cy = oy + side / 2;

  231. 	angle = (a2-a1)*(value()-minimum())/(maximum()-minimum()) + a1;	

  232. 	fl_push_matrix();

  233. 	fl_scale(1,1);

  234. 	fl_translate(cx,cy);

  235. 	fl_rotate(-angle);

  236. 	fl_translate(0,rds-cur-2.0);

  237. 	if (_type<LINELIN)

  238. 	{		

  239. 		fl_begin_polygon();

  240. 		fl_color(selection_color());

  241. 		fl_circle(0.0,0.0,cur);

  242. 		fl_end_polygon();

  243. 		fl_begin_loop();

  244. 		fl_color(FL_BLACK);

  245. 		fl_circle(0.0,0.0,cur);

  246. 		fl_end_loop();

  247. 	}

  248. 	else

  249. 	{

  250. 		fl_begin_polygon();

  251. 		fl_color(selection_color());

  252. 		fl_vertex(-1.5,-cur);

  253. 		fl_vertex(-1.5,cur);

  254. 		fl_vertex(1.5,cur);

  255. 		fl_vertex(1.5,-cur);

  256. 		fl_end_polygon();

  257. 		fl_begin_loop();

  258. 		fl_color(FL_BLACK);

  259. 		fl_vertex(-1.5,-cur);

  260. 		fl_vertex(-1.5,cur);

  261. 		fl_vertex(1.5,cur);

  262. 		fl_vertex(1.5,-cur);

  263. 		fl_end_loop();

  264. 	}

  265. 	fl_pop_matrix();} {}

  266.   }

  267.   Function {cursor(const int pc)} {} {

  268.     code {_percent = (float)pc/100.0;

  269. 

  270. 	if (_percent < 0.05) _percent = 0.05;

  271. 	if (_percent > 1.0) _percent = 1.0;

  272. 	if (visible()) damage(FL_DAMAGE_CHILD);} {}

  273.   }

  274.   Function {scaleticks(const int tck)} {} {

  275.     code {_scaleticks = tck;

  276. 	if (_scaleticks < 0) _scaleticks = 0;

  277. 	if (_scaleticks > 31) _scaleticks = 31;

  278. 	if (visible()) damage(FL_DAMAGE_ALL);} {}

  279.   }

  280. }