non
/
paulstretch_cpp
mirror of https://github.com/original-male/paulstretch_cpp
1
0
Fork 0
Code Issues 0 Releases 0 Wiki 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.
24 Commits
1 Branch
119KB
Tree: a22886288a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a22886288a'
${ noResults }
paulstretch_cpp/FreeEditUI.fl

592 lines
16KB
Raw Blame History 

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

  2. version 1.0110 

  3. header_name {.h} 

  4. code_name {.cxx}

  5. decl {\#include <FL/Fl_File_Chooser.H>} {} 

  6. 

  7. decl {\#include <FL/Fl_Box.H>} {public

  8. } 

  9. 

  10. decl {\#include <FL/Fl_Group.H>} {public

  11. } 

  12. 

  13. decl {\#include <FL/Fl_Box.H>} {public

  14. } 

  15. 

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

  17. } 

  18. 

  19. decl {\#include <FL/Fl_Value_Input.H>} {public

  20. } 

  21. 

  22. decl {\#include <FL/fl_ask.H>} {public

  23. } 

  24. 

  25. decl {\#include<sys/stat.h>} {} 

  26. 

  27. decl {\#include <stdio.h>} {} 

  28. 

  29. decl {\#include <string>} {} 

  30. 

  31. decl {\#include "Control.h"} {public

  32. } 

  33. 

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

  35. 

  36. decl {\#include "FreeEdit.h"} {public

  37. } 

  38. 

  39. decl {\#include <FL/Fl_Group.H>} {public

  40. } 

  41. 

  42. class FreeEditUI {open : {public Fl_Box}

  43. } {

  44.   Function {FreeEditUI(int x,int y, int w, int h, const char *label=0):Fl_Box(x,y,w,h,label)} {} {

  45.     code {max_value_fl=min_value_fl=value_fl=position_fl=NULL;

  46. free_edit=NULL;

  47. control=NULL;

  48. 

  49. current_point=-1;

  50. selected_point=-1;

  51. 

  52. default_value=1.0;} {}

  53.   }

  54.   Function {~FreeEditUI()} {} {

  55.     code {} {}

  56.   }

  57.   Function {init(FreeEdit *free_edit_,Control *control_)} {open

  58.   } {

  59.     code {free_edit=free_edit_;

  60. control=control_;

  61. free_edit->update_curve();} {}

  62.   }

  63.   Function {init_value_io(Fl_Value_Input *value_fl_,Fl_Value_Input *position_fl_,Fl_Value_Input *min_value_fl_,Fl_Value_Input *max_value_fl_)} {} {

  64.     code {value_fl=value_fl_;

  65. position_fl=position_fl_;

  66. min_value_fl=min_value_fl_;

  67. max_value_fl=max_value_fl_;

  68. 

  69. if (free_edit){

  70. 	free_edit->extreme_y.set_min(min_value_fl->value());

  71. 	free_edit->extreme_y.set_max(max_value_fl->value());

  72. };} {}

  73.   }

  74.   Function {get_color(Fl_Color c)} {return_type Fl_Color

  75.   } {

  76.     code {if (free_edit->get_enabled()) return c;

  77. 

  78. return fl_color_average(c,fl_rgb_color(178,178,178),0.1);} {}

  79.   }

  80.   Function {draw()} {open

  81.   } {

  82.     code {int ox=x(),oy=y(),lx=w(),ly=h();

  83. 

  84. //fl_color(FL_WHITE);

  85. fl_color(get_color(color()));

  86. fl_rectf(ox,oy,lx,ly);

  87. 

  88. //fl_color(FL_GRAY);

  89. fl_color(fl_color_add_alpha( get_color(labelcolor()), 100 ));

  90. //draw grid

  91. fl_line_style(FL_SOLID);

  92. for (int ncoord=0;ncoord<2;ncoord++){

  93. 	FreeEditExtremes *extreme=(ncoord==0)?&free_edit->extreme_x:&free_edit->extreme_y;

  94. 	if (extreme->get_scale()==FE_LOG){//logarithmic scale

  95. 		float p10=pow(10,floor(log10(extreme->get_min())));

  96. 		int psteps=(int)(floor(log10(extreme->get_max()/extreme->get_min())))+1;

  97. 		for (int k=1;k<=psteps;k++){

  98. 			for (int i=1;i<10;i++){

  99. 			 fl_line_style(FL_SOLID);

  100. 				float fpos=extreme->real_value_to_coord(p10*i);

  101. 				if ((fpos>0.0)&&(fpos<1.0)){

  102. 					if (ncoord==0){

  103. 						int pos=(int)(fpos*lx);

  104. 						fl_line(ox+pos,oy,ox+pos,oy+ly);

  105. 					}else{

  106. 						int pos=(int)(ly-1-fpos*ly);

  107. 						fl_line(ox,oy+pos,ox+lx,oy+pos);

  108. 					};

  109. 				};

  110. 			};

  111. 			p10*=10.0;

  112. 		};

  113. 	}else{//linear scale

  114. 		float diff=extreme->get_max()-extreme->get_min();

  115. 		float stepsize=pow(10,floor(log10( fabs(diff))))*0.1;

  116. 		if (stepsize>=1e-6){

  117. 			int nsteps=(int)(fabs(diff)/stepsize)+1;

  118. 			if (nsteps>25) {

  119. 				nsteps/=5;

  120. 				stepsize*=5.0;

  121. 			};

  122. 			float min=extreme->get_min();

  123. 			float max=extreme->get_max();

  124. 			float min1=(min<max)?min:max;

  125. 			int kstep=(int)(floor(min1/stepsize));

  126. 			min1=kstep*stepsize;

  127. 			for (int i=0;i<nsteps;i++){

  128. 				float fpos=extreme->real_value_to_coord(min1+i*stepsize);

  129. 				int ks=(i+kstep)%10; if (ks<0) ks+=10;

  130. 				fl_line_style(FL_SOLID);

  131. 				if ((fpos>0.0)&&(fpos<1.0)){

  132. 					if (ncoord==0){

  133. 						int pos=(int)(fpos*lx);

  134. 						fl_line(ox+pos,oy,ox+pos,oy+ly);

  135. 					}else{

  136. 						int pos=(int)(ly-1-fpos*ly);

  137. 						fl_line(ox,oy+pos,ox+lx,oy+pos);

  138. 					};

  139. 				};

  140. 			};

  141. 		};

  142. 	};

  143. };

  144. 

  145. 

  146. 

  147. //draw the line

  148. fl_line_style(FL_SOLID,3);

  149. fl_color(get_color(labelcolor()));

  150. float *data=new float[lx];

  151. 

  152. 

  153. free_edit->get_curve(lx,data,false);

  154. int oldy=0;

  155. for (int i=0;i<lx;i++){

  156. 	int newy=(int)((1.0-data[i])*ly);

  157. 	if (i) fl_line(ox+i-1,oy+oldy,ox+i,oy+newy);

  158. 	oldy=newy;

  159. };

  160. 

  161. delete[]data;

  162. 

  163. //draw points

  164. fl_line_style(FL_SOLID,2);

  165. for (int i=0;i<free_edit->get_npoints();i++){

  166. 	if (!free_edit->is_enabled(i)) continue;

  167. 	fl_color(FL_BLACK);

  168. 	int x=(int)(free_edit->get_posx(i)*lx);

  169. 	int y=(int)((1.0-free_edit->get_posy(i))*ly);

  170. 	fl_circle(ox+x,oy+y,3);

  171. 	if (i==selected_point){

  172. 		fl_color(get_color(FL_RED));

  173. 		fl_circle(ox+x,oy+y,4);

  174. 		fl_circle(ox+x,oy+y,5);

  175. 	};

  176. };

  177. 

  178. 

  179. /*

  180. //test

  181. {

  182. fl_color(FL_RED);

  183. fl_line_style(FL_SOLID);

  184. 

  185. free_edit->update_curve();

  186. 

  187. int oldy=0;

  188. //printf("draw %g\\n",free_edit->get_value(8000.0));

  189. //printf("d %g\\n",free_edit->curve.data[1000]);

  190. 

  191. for (int i=0;i<lx;i++){

  192. 	//int m=(int)(((float)i/(float)lx)*(free_edit->curve.size-1));

  193. 	//REALTYPE y=free_edit->curve.data[m];

  194. 	REALTYPE freq=i/(float)lx*25000.0;

  195. 	REALTYPE y=free_edit->get_value(freq);

  196. 	//if (i<20) printf("%d %g\\n",i,y);

  197. 	//printf("%g %g\\n",freq,y);

  198. 

  199. 

  200. 	int newy=(int)((1.0-y)*ly);

  201. 

  202. 	if (i) fl_line(ox+i-1,oy+oldy,ox+i,oy+newy);

  203. 	oldy=newy;

  204. };

  205. };

  206. */

  207. 

  208. 

  209. 

  210. 

  211. /*

  212. 

  213. 

  214. fl_color(FL_RED);

  215. fl_line_style(FL_SOLID);

  216. 

  217. 

  218. 	int samplerate=44100;

  219. 	

  220. 

  221. 	int nfreq=lx;

  222. 	float *freq1=new float [nfreq];

  223. 	float *freq2=new float [nfreq];	

  224. 	float *tmpfreq1=new float [nfreq*2];

  225. 

  226.                 for (int i=0;i<nfreq;i++) tmpfreq1[i]=0.0;

  227. 

  228. 	for (int i=0;i<nfreq;i++) freq1[i]=data[i];

  229. 

  230.         //convert to log spectrum

  231.         

  232.         float minfreq=20.0;

  233.         float maxfreq=0.5*samplerate;

  234.        for (int i=0;i<nfreq;i++){

  235.         	float freqx=i/(float) nfreq;

  236.         	float x=exp(log(minfreq)+freqx*(log(maxfreq)-log(minfreq)))/maxfreq*nfreq;

  237.         	float y=0.0;

  238.         	int x0=(int)floor(x); if (x0>=nfreq) x0=nfreq-1;

  239.         	int x1=x0+1; if (x1>=nfreq) x1=nfreq-1;

  240.         	float xp=x-x0;

  241.         	if (x<nfreq){

  242.         		y=freq1[x0]*(1.0-xp)+freq1[x1]*xp;

  243.         	};

  244.         	tmpfreq1[i]=y;

  245.         };

  246.     

  247.     

  248.        //increase bandwidth of each harmonic

  249.         int n=2;

  250. 	float bandwidth=free_edit->get_posy(0);

  251. 	float a=1.0-exp(-bandwidth*bandwidth*nfreq*0.002);

  252. 	a=pow(a,n);

  253. 	printf("%g\\n",a);

  254. 

  255.         for (int k=0;k<n;k++){                                                  

  256.                 tmpfreq1[0]=0.0;

  257.                 for (int i=1;i<nfreq;i++){                                       

  258.                         tmpfreq1[i]=tmpfreq1[i-1]*a+tmpfreq1[i]*(1.0-a);

  259.                 };                                                              

  260.                 tmpfreq1[nfreq-1]=0.0;                                               

  261.                 for (int i=nfreq-2;i>0;i--){                                     

  262.                         tmpfreq1[i]=tmpfreq1[i+1]*a+tmpfreq1[i]*(1.0-a);                    

  263.                 };                                                              

  264.         };                                                                      

  265. 

  266.         //convert back to linear spectrum

  267. //        for (int i=0;i<nfreq;i++) freq2[i]=0.0;

  268. //        for (int i=0;i<nfreq;i++) freq2[i]=tmpfreq1[i];

  269. 

  270. 	freq2[0]=0;

  271.         for (int i=1;i<nfreq;i++){

  272.         	float freqx=i/(float) nfreq;

  273.         	float x=log((freqx*maxfreq)/minfreq)/log(maxfreq/minfreq)*nfreq;

  274. //        	printf("%g\\n",x);

  275.         	float y=0.0;

  276.         	int x0=(int)floor(x); if (x0>=nfreq) x0=nfreq-1;

  277.         	int x1=x0+1; if (x1>=nfreq) x1=nfreq-1;

  278.         	float xp=x-x0;

  279.         	if (x<nfreq){

  280.         		y=tmpfreq1[x0]*(1.0-xp)+tmpfreq1[x1]*xp;

  281.         	};

  282.         	freq2[i]=y;

  283.         };

  284. 

  285.         

  286. 

  287. 

  288.         

  289. for (int i=0;i<lx;i++){

  290. 	

  291. 	REALTYPE y=freq2[i];

  292. 

  293. 	int newy=(int)((1.0-y)*ly);

  294. 

  295. 

  296. 	if (i) fl_line(ox+i-1,oy+oldy,ox+i,oy+newy);

  297. 	oldy=newy;

  298. };

  299.        

  300.         delete [] freq1;

  301.         delete [] freq2;

  302.         delete [] tmpfreq1;

  303. //        delete [] tmpfreq2;

  304. */} {}

  305.   }

  306.   Function {handle(int event)} {return_type int

  307.   } {

  308.     code {if (!free_edit->get_enabled()) return Fl_Box::handle(event);

  309. 

  310. int ox=x(),oy=y(),lx=w(),ly=h();

  311. float px=(Fl::event_x()-ox)/(float)lx;

  312. float py=1.0-(Fl::event_y()-oy)/(float)ly;

  313. if (px<0) px=0;

  314. 	else if (px>1.0) px=1.0;

  315. if (py<0) py=0;

  316. 	else if (py>1.0) py=1.0;

  317. 

  318. int closest=-1;

  319. float xyrap=(float)ly/(float)lx;

  320. for (int i=0;i<free_edit->get_npoints();i++){

  321. 	if (!free_edit->is_enabled(i)) continue;

  322. 	float d=pow(px-free_edit->get_posx(i),2)+pow(py-free_edit->get_posy(i),2)*xyrap;

  323. 	if (d<0.0005) {

  324. 		closest=i;

  325. 		break;

  326. 		

  327. 	};

  328. };

  329. 

  330. 

  331. if (event==FL_PUSH){

  332. 	if (closest>=0) {

  333. 		if (Fl::event_button()==1) selected_point=current_point=closest;

  334. 		if ((Fl::event_button()==3)&&(closest>=2)) {

  335. 			free_edit->set_enabled(closest,false);

  336. 			current_point=selected_point=-1;

  337. 		};

  338. 	}else{

  339. 		for (int i=0;i<free_edit->get_npoints();i++){

  340. 			if (!free_edit->is_enabled(i)){

  341. 				selected_point=closest=current_point=i;

  342. 				free_edit->set_posx(current_point,px);

  343. 				free_edit->set_posy(current_point,py);

  344. 				free_edit->set_enabled(i,true);				

  345. 				break;

  346. 			};

  347. 		};		

  348. 	};

  349. 	refresh_value();

  350. 	redraw();

  351. 	update_curve();

  352. 	return true;

  353. };

  354. if (event==FL_RELEASE){

  355. 	current_point=-1;

  356. 	refresh_value();

  357. 	update_curve();

  358. 	if (control) control->update_process_parameters();

  359. 	return true;

  360. };

  361. 

  362. if (event==FL_DRAG){

  363. 	if (current_point>=0){

  364. 		if (current_point>=2) free_edit->set_posx(current_point,px);

  365. 		free_edit->set_posy(current_point,py);

  366. 		redraw();

  367. 	};

  368. 	refresh_value();

  369. 	update_curve();

  370. 	return true;

  371. };

  372. 

  373. return Fl_Box::handle(event);} {}

  374.   }

  375.   Function {refresh_value()} {} {

  376.     code {if (!value_fl) return;

  377. value_fl->deactivate();

  378. position_fl->deactivate();

  379. if (selected_point<0) return;

  380. if (!free_edit->is_enabled(selected_point)) return;

  381. value_fl->activate();

  382. position_fl->activate();

  383. 

  384. float val=free_edit->extreme_y.coord_to_real_value(free_edit->get_posy(selected_point));

  385. val=((int)(val*10000.0))/10000.0;

  386. value_fl->value(val);

  387. 

  388. 

  389. float pos=free_edit->extreme_x.coord_to_real_value(free_edit->get_posx(selected_point));

  390. pos=((int)(pos*1000.0))/1000.0;

  391. position_fl->value(pos);} {}

  392.   }

  393.   Function {set_selected_value(float val)} {} {

  394.     code {if (!value_fl) return;

  395. if (selected_point<0) return;

  396. if (!free_edit->is_enabled(selected_point)) return;

  397. 

  398. free_edit->set_posy(selected_point,free_edit->extreme_y.real_value_to_coord(val));

  399. redraw();

  400. update_curve();} {}

  401.   }

  402.   Function {set_selected_position(float pos)} {} {

  403.     code {if (!value_fl) return;

  404. if (selected_point<0) return;

  405. if (!free_edit->is_enabled(selected_point)) return;

  406. 

  407. free_edit->set_posx(selected_point,free_edit->extreme_x.real_value_to_coord(pos));

  408. redraw();

  409. update_curve();} {}

  410.   }

  411.   Function {set_min_value(float val)} {open

  412.   } {

  413.     code {unselect();

  414. 

  415. free_edit->extreme_y.set_min(val);

  416. redraw();

  417. update_curve();} {}

  418.   }

  419.   Function {set_max_value(float val)} {open

  420.   } {

  421.     code {unselect();

  422. 

  423. free_edit->extreme_y.set_max(val);

  424. redraw();

  425. update_curve();} {}

  426.   }

  427.   Function {unselect()} {} {

  428.     code {selected_point=-1;

  429. refresh_value();

  430. redraw();} {}

  431.   }

  432.   Function {set_smooth(float smooth)} {} {

  433.     code {free_edit->set_smooth(smooth);

  434. redraw();

  435. update_curve();} {}

  436.   }

  437.   Function {set_interp_mode(int interp_mode)} {} {

  438.     code {free_edit->set_interp_mode((FreeEdit::INTERP_MODE)interp_mode);

  439. redraw();

  440. update_curve();} {}

  441.   }

  442.   Function {clear()} {} {

  443.     code {for (int i=2;i<free_edit->get_npoints();i++) free_edit->set_enabled(i,false);

  444. free_edit->set_all_values(default_value);

  445. redraw();

  446. update_curve();} {}

  447.   }

  448.   Function {update_curve()} {} {

  449.     code {free_edit->update_curve();} {}

  450.   }

  451.   decl {int current_point,selected_point;} {public

  452.   }

  453.   decl {Fl_Value_Input *value_fl,*position_fl,*min_value_fl,*max_value_fl;} {public

  454.   }

  455.   decl {FreeEdit *free_edit;} {public

  456.   }

  457.   decl {float default_value;} {public

  458.   }

  459.   decl {Control *control;} {public

  460.   }

  461. } 

  462. 

  463. class FreeEditControls {open : {public Fl_Group}

  464. } {

  465.   Function {FreeEditControls(int x,int y, int w, int h, const char *label=0):Fl_Group(x,y,w,h,label)} {} {

  466.     code {free_edit_ui=NULL;} {}

  467.   }

  468.   Function {~FreeEditControls()} {} {

  469.     code {hide();} {}

  470.   }

  471.   Function {init(FreeEditUI *free_edit_ui_,FREE_EDIT_EXTREME_SCALE scale_x=FE_LINEAR,float min_x=0.0,float max_x=1.0,FREE_EDIT_EXTREME_SCALE scale_val=FE_LINEAR,float min_val=0.0,float max_val=1.0,float default_value=1.0)} {open

  472.   } {

  473.     code {free_edit_ui=free_edit_ui_;

  474. 

  475. make_window();

  476. end();

  477. 

  478. free_edit_ui->init_value_io(free_edit_value_fl,free_edit_position_fl,free_edit_min_value_fl,free_edit_max_value_fl);

  479. feui->resize(this->x(),this->y(),this->w(),this->h());

  480. 

  481. FreeEdit *fe=free_edit_ui->free_edit;

  482. 

  483. fe->extreme_x.set_min(min_x);

  484. fe->extreme_x.set_max(max_x);

  485. fe->extreme_x.set_scale(scale_x);

  486. 

  487. fe->extreme_y.set_min(min_val);

  488. fe->extreme_y.set_max(max_val);

  489. fe->extreme_y.set_scale(scale_val);

  490. 

  491. free_edit_min_value_fl->value(min_val);

  492. free_edit_max_value_fl->value(max_val);

  493. free_edit_ui->default_value=default_value;

  494. fe->set_all_values(default_value);

  495. 

  496. enabled_check->value(fe->get_enabled());} {}

  497.   }

  498.   Function {update_parameters()} {open

  499.   } {

  500.     code {if (free_edit_ui->control) free_edit_ui->control->update_process_parameters();} {}

  501.   }

  502.   Function {make_window()} {open

  503.   } {

  504.     Fl_Window feui {open

  505.       xywh {245 395 85 210} type Double color 50 labelfont 1

  506.       class Fl_Group visible

  507.     } {

  508.       Fl_Group {} {open

  509.         xywh {0 0 85 210} box PLASTIC_THIN_UP_BOX color 52 labeltype ENGRAVED_LABEL labelsize 10 align 0

  510.       } {

  511.         Fl_Value_Input free_edit_min_value_fl {

  512.           label {Val.Min}

  513.           callback {free_edit_ui->unselect();

  514. free_edit_ui->set_min_value(o->value());

  515. update_parameters();}

  516.           xywh {5 110 50 15} labelsize 10 align 5 minimum -10000 maximum 10000 textfont 1 textsize 10

  517.         }

  518.         Fl_Value_Input free_edit_max_value_fl {

  519.           label {Val.Max}

  520.           callback {free_edit_ui->unselect();

  521. free_edit_ui->set_max_value(o->value());

  522. update_parameters();}

  523.           xywh {5 140 50 15} labelsize 10 align 5 minimum -10000 maximum 10000 value 1 textfont 1 textsize 10

  524.         }

  525.         Fl_Value_Input free_edit_value_fl {

  526.           label Value

  527.           callback {free_edit_ui->set_selected_value(o->value());

  528. update_parameters();}

  529.           xywh {5 75 70 15} labelfont 1 labelsize 10 align 5 minimum 0.03 maximum 100 value 0.5 textfont 1 textsize 10 deactivate

  530.         }

  531.         Fl_Roller free_edit_smooth {

  532.           label Sm

  533.           callback {free_edit_ui->set_smooth(o->value());

  534. update_parameters();}

  535.           tooltip {Smooth function} xywh {60 110 15 45} labelsize 10 align 1 when 4 minimum 1 maximum 0 step 0.01

  536.         }

  537.         Fl_Choice free_edit_interpolate {

  538.           label Interpolate

  539.           callback {free_edit_ui->set_interp_mode(o->value());

  540. update_parameters();}

  541.           xywh {5 170 70 15} down_box BORDER_BOX labelsize 11 align 5 textfont 1 textsize 10

  542.         } {

  543.           MenuItem {} {

  544.             label Linear

  545.             xywh {10 10 36 21} labelfont 1 labelsize 10

  546.           }

  547.           MenuItem {} {

  548.             label Cosine

  549.             xywh {10 10 36 21} labelfont 1 labelsize 10

  550.           }

  551.         }

  552.         Fl_Button {} {

  553.           label clear

  554.           callback {if (!fl_choice("Delete all points?","No","Yes",NULL)) return;

  555. free_edit_ui->clear();

  556. update_parameters();}

  557.           xywh {5 190 75 15} labelsize 12

  558.         }

  559.         Fl_Light_Button enabled_check {

  560.           label Enable

  561.           callback {free_edit_ui->free_edit->set_enabled(o->value());

  562. free_edit_ui->update_curve();

  563. free_edit_ui->redraw();

  564. update_parameters();}

  565.           xywh {5 5 75 20} color 7 selection_color 88 labelfont 1

  566.         }

  567.         Fl_Value_Input free_edit_position_fl {

  568.           label Position

  569.           callback {free_edit_ui->set_selected_position(o->value());

  570. update_parameters();}

  571.           xywh {5 45 70 15} labelsize 10 align 5 minimum 0.0001 maximum 10000 value 1 textfont 1 textsize 10 deactivate

  572.         }

  573.       }

  574.     }

  575.   }

  576.   Function {refresh()} {open

  577.   } {

  578.     code {enabled_check->value(free_edit_ui->free_edit->get_enabled());

  579. 

  580. free_edit_min_value_fl->value(free_edit_ui->free_edit->extreme_y.get_min());

  581. free_edit_max_value_fl->value(free_edit_ui->free_edit->extreme_y.get_max());

  582. free_edit_interpolate->value(free_edit_ui->free_edit->get_interp_mode());

  583. free_edit_smooth->value(free_edit_ui->free_edit->get_smooth());

  584. 

  585. free_edit_ui->update_curve();

  586. free_edit_ui->redraw();

  587. update_parameters();} {selected

  588.     }

  589.   }

  590.   decl {FreeEditUI *free_edit_ui;} {}

  591. }