WebSVN - DIN Is Noise - Blame - Rev 2340

Rev	Author	Line No.	Line
964	jag	1	/*
		2	* menu.cc
2302	jag	3	* DIN Is Noise is copyright (c) 2006-2025 Jagannathan Sampath
1713	jag	4	* DIN Is Noise is released under GNU Public License 2.0
1479	jag	5	* For more information, please visit https://dinisnoise.org/
964	jag	6	*/
		7
		8	#include "main.h"
		9	#include "menu.h"
		10	#include "ui_list.h"
		11	#include "viewwin.h"
		12	#include "din.h"
		13	#include "keyboard_keyboard.h"
		14	#include "mondrian.h"
		15	#include "binaural_drones.h"
		16	#include "tcl_interp.h"
		17	#include "console.h"
		18	#include "recorder.h"
		19	#include "oscilloscope.h"
		20	#include "ball.h"
1037	jag	21	#include "mesh.h"
1387	jag	22	#include "noiser.h"
1463	jag	23	#include "log.h"
1551	jag	24	#include "fft.h"
1757	jag	25	#include "file-utils.h"
1778	jag	26	#include "drawrrow.h"
1833	jag	27	#include "autorotator.h"
		28	#include "autoflip.h"
		29	#include "defvelaccel.h"
1897	jag	30	#include "color.h"
964	jag	31	#include <string>
		32	#include <fstream>
1768	jag	33
2049	jag	34	#define DONT_MOUSE_WARP 0
		35
964	jag	36	using namespace std;
		37
		38	extern int mousex, mousey;
		39	extern beat2value octave_shift;
1473	jag	40
964	jag	41	extern std::string INSTRUMENT;
1450	jag	42	extern const char* INSTRUMENTS[];
1026	jag	43	extern int CURRENT_INSTRUMENT, LAST_INSTRUMENT, NUM_INSTRUMENTS;
1473	jag	44
964	jag	45	extern float VOICE_VOLUME;
		46	extern int NUM_OCTAVES;
		47	extern void setup_plugin_labels ();
		48	extern oscilloscope scope;
		49	extern const float PI_BY_180;
		50	extern char BUFFER [];
1485	jag	51	extern int wheely;
964	jag	52	extern int line_height;
1438	jag	53	extern const char *ol_fixed_lbls [];
1551	jag	54	extern plugin_browser plugin__browser;
1436	jag	55
1677	jag	56	#define SECONDS " seconds"
1836	jag	57	#define DEGREES " degrees"
1677	jag	58
1450	jag	59	menu::menu () :
1688	jag	60	diram (modulator::AM), dirfm (modulator::FM),
1450	jag	61	bm_zoom_in(16), pb_zoom_in (16), bm_zoom_out(16), mb_zoom_out (16),
		62	abm_left (12), abm_right(12), abm_up(12), abm_down(12),
		63	abe_left (12), abe_right(12), abe_up(12), abe_down(12),
		64	abl_left (12, arrow_button::left), abl_right (12, arrow_button::right),
		65	gater_style_lis (ol_gater_style, "gr", " Style = "),
		66	am_style_lis (ol_am_style, "am", " AM style = "),
		67	fm_style_lis (ol_fm_style, "fm", " FM style = "),
		68	s_phrase_position (256, 16),
1468	jag	69	td_tap_display (36),
		70	gc_top(0),
1472	jag	71	gc_bottom(1)
		72	{
964	jag	73	num_tabs = 0;
		74	am_depth = fm_depth = 0;
		75	dam_depth = dfm_depth = dam_bpm = dfm_bpm = 0;
1472	jag	76
964	jag	77	cnl.id = 0;
		78	cnl.name = "Left Note";
		79	cnl.orient = mouse_slider_listener::X;
1472	jag	80
964	jag	81	cnr.id = 1;
		82	cnr.name = "Right Note";
		83	cnr.orient = mouse_slider_listener::X;
1472	jag	84
964	jag	85	arl.name = "Range Left";
		86	arl.orient = mouse_slider_listener::X;
1472	jag	87
964	jag	88	arr.name = "Range Right";
		89	arr.orient = mouse_slider_listener::X;
1472	jag	90
964	jag	91	arb.name = "Range Left & Right";
		92	arb.orient = mouse_slider_listener::Y;
1472	jag	93
964	jag	94	rhl.name = "Range Height";
		95	rhl.orient = mouse_slider_listener::Y;
1461	jag	96
		97	s_phrase_position.sizer.visible = 1;
1680	jag	98
964	jag	99	}
		100
		101	void menu::setup_items () {
1450	jag	102
1489	jag	103	b_close.visible = 0;
		104
1449	jag	105	button* inst_ed [] = {
2338	jag	106	&b_keyboard_keyboard, // instruments
964	jag	107	&b_microtonal_keyboard,
		108	&b_mondrian,
		109	&b_binaural_drones,
1449	jag	110	&b_microtonal_keyboard_waveform, // editors
964	jag	111	&b_drone_waveform,
		112	&b_drone_modulation,
		113	&b_voice_modulation,
		114	&b_gater,
		115	&b_keyboard_keyboard_waveform,
		116	&b_attack,
		117	&b_decay,
		118	&b_midi_velocity,
		119	&b_delays,
		120	&b_octave_shift,
		121	&b_compressor,
		122	&b_morse_code,
		123	&b_mondrian_waveform,
		124	&b_mondrian_attack,
		125	&b_mondrian_decay,
		126	&b_binaural_drones_waveform,
		127	&b_range_modulation,
1026	jag	128	&b_range_width_height,
1104	jag	129	&b_range_pitch_vol,
1188	jag	130	&b_point_modulation,
1404	jag	131	&b_noise_interpolator,
1475	jag	132	&b_drone_pend,
1883	jag	133	&edlife2vel,
1449	jag	134	};
1472	jag	135
		136	// all other menu items
1449	jag	137	widget* mi [] = {
964	jag	138	&b_exit_din,
		139	&l_octave_shift,
		140	&ab_octave_down,
		141	&ab_octave_up,
		142	&sp_octave_shift_bpm,
		143	&sp_gater_bpm,
		144	&sp_voice_volume,
		145	&cb_show_anchors,
		146	&sp_change_drone_handle_size,
		147	&sp_change_drone_trail_length,
		148	&sp_am_depth,
		149	&sp_fm_depth,
		150	&sp_am_bpm,
		151	&sp_fm_bpm,
		152	&cb_instrument,
		153	&cb_editors,
1449	jag	154	&cb_mkb_drone_params,
964	jag	155	&cb_file,
		156	&ol_gater_style,
		157	&l_gater,
		158	&ol_am_style,
		159	&ol_fm_style,
		160	&cb_mkb_drone_tools,
1674	jag	161	&ol_add_wand,
1984	jag	162	&moverailstrafe,
964	jag	163	&b_delete_drones,
		164	&b_select_all_drones,
		165	&b_invert_drone_selection,
		166	&b_record_phrase,
		167	&b_clear_phrases,
		168	&l_phrase_position,
		169	&s_phrase_position,
		170	&ol_set_range,
		171	&b_default_to_selected,
1403	jag	172	&b_default_to_all,
		173	&b_selected_to_all,
964	jag	174	&b_key_to_pitch_at_cursor,
		175	&cb_scope,
		176	&sp_scope_height,
		177	&sp_scope_samples,
		178	&l_tap_bpm,
		179	&td_tap_display,
		180	&l_tap_bpm_value,
		181	&cb_am,
		182	&cb_fm,
		183	&cb_gater,
		184	&cb_octave_shift,
		185	&cb_auto_reset,
		186	&cb_ed_tools,
		187	&abe_left,
		188	&abe_right,
		189	&abe_up,
		190	&abe_down,
		191	&b_close,
1901	jag	192	&b_snapx,
		193	&b_snapy,
		194	&b_snapboth,
		195	&b_snapnone,
964	jag	196	&l_snap,
		197	&pb_zoom_in,
		198	&mb_zoom_out,
		199	&b_insert_vertex,
		200	&b_delete_vertex,
		201	&b_fold_tangents,
1128	jag	202	&ol_mirror,
964	jag	203	&ol_mirror_tangents,
1128	jag	204	&cb_selection_only,
964	jag	205	&b_undo,
		206	&b_redo,
		207	&b_copy,
2340	jag	208	&ol_paste,
964	jag	209	&b_draw_replacement_curve,
		210	&l_library,
		211	&abl_left,
		212	&abl_right,
		213	&lf_curve_name,
		214	&b_add_curve,
		215	&b_replace_curve,
		216	&b_delete_curve,
		217	&l_capture,
		218	&b_start_capture,
		219	&b_assign_capture,
		220	&cb_label_vertices,
		221	&cb_show_waveform_samples,
2039	jag	222	&crvwav.hz,
964	jag	223	&b_pick_curve,
		224	&sp_curve_limit,
2039	jag	225	&crvwav.periods,
964	jag	226	&ol_curve_style,
		227	&sp_curve_rpm,
		228	&b_stop_rotating,
		229	&cb_draw_curve,
		230	&cb_record,
		231	&b_clear_record,
		232	&lf_file,
		233	&b_save,
		234	&b_select_attractees,
		235	&b_select_attractors,
		236	&b_orbit_selected_drones,
		237	&cb_show_vel,
		238	&cb_show_accel,
		239	&sp_change_drone_vel,
		240	&sp_change_drone_accel,
		241	&cb_show_gravity,
1827	jag	242	&balloon,
964	jag	243	&sp_rotate_drone_vel,
		244	&sp_drones_per_min,
		245	&b_launch_drones,
		246	&b_stop_launching_drones,
1098	jag	247	&ol_create_this,
964	jag	248	&sp_mesh_rows,
		249	&sp_mesh_cols,
		250	&b_track_drones,
		251	&b_select_tracked_drones,
		252	&sp_bounces,
		253	&sp_rebound,
		254	&b_add_balls,
		255	&b_move_selected_balls,
		256	&b_delete_selected_targets,
		257	&b_delete_all_targets,
		258	&b_select_all_targets,
		259	&b_invert_selected_targets,
		260	&b_select_targets_in_box,
		261	&b_split_horizontal,
		262	&b_split_vertical,
		263	&b_delete_box,
		264	&sp_mondrian_min_voices,
		265	&sp_mondrian_change_attack_time,
		266	&sp_mondrian_change_decay_time,
		267	&sp_mondrian_change_speed,
		268	&b_freeze_balls,
		269	&b_thaw_balls,
		270	&abm_left,
		271	&abm_right,
		272	&abm_up,
		273	&abm_down,
		274	&bm_zoom_in,
		275	&bm_zoom_out,
		276	&b_turn_off_ui,
		277	&b_set_targets,
		278	&b_clear_targets,
		279	&sp_drone_lifetime,
		280	&sp_orbit_insertion_time,
		281	&b_clear_modulations,
		282	&b_modulate_balls_up,
		283	&b_modulate_balls_down,
		284	&cb_binaural_drones_tools,
		285	&lf_master_volume,
		286	&sp_bd_separation,
		287	&b_create_binaurals_on_notes,
		288	&b_create_binaurals_from_pitch,
		289	&lf_bd_start_pitch,
		290	&sp_bd_pairs,
		291	&lf_bd_spacing,
		292	&cb_close_octave,
		293	&lf_vol_fade_time,
		294	&sp_mondrian_change_dir,
		295	&sp_mondrian_change_trail_size,
		296	&sp_mondrian_change_note_poly_points,
		297	&sp_mondrian_change_note_poly_radius,
		298	&b_auto_change_direction_clockwise,
		299	&b_stop_auto_changing_direction,
		300	&b_auto_change_direction_anti_clockwise,
		301	&b_flip_direction,
		302	&b_make_random_color,
		303	&ol_justification,
		304	&cb_resize_separation,
		305	&ol_key_note,
		306	&b_add_remove_slits,
		307	&b_select_wreckers,
		308	&b_select_healers,
		309	&b_switch_ball_type,
		310	&b_toggle_wreckers,
		311	&b_toggle_healers,
		312	&b_toggle_bouncers,
		313	&sp_mondrian_change_slit_size,
		314	&b_remove_slits_on_edge,
		315	&b_toggle_slit_anim,
		316	&cb_mondrian_auto_adjust_voices,
		317	&sp_mondrian_change_vol,
		318	&cb_draw_boxes,
		319	&cb_fill_boxes,
		320	&cb_draw_notes,
		321	&cb_label_notes,
		322	&ol_ball_types,
		323	&ol_split_types_h,
		324	&ol_split_types_v,
		325	&sp_mondrian_num_boxes,
		326	&b_make_note_grid,
		327	&b_make_nxn_grid,
		328	&b_delete_all_boxes,
		329	&cb_mkb_voice,
		330	&cb_mkb_misc,
		331	&b_select_launchers,
1812	jag	332	&seloncre,
964	jag	333	&b_freeze_drones,
		334	&b_thaw_drones,
		335	&sp_dam_depth,
		336	&sp_dfm_depth,
		337	&sp_dam_bpm,
		338	&sp_dfm_bpm,
1430	jag	339	&b_scale_drones,
		340	&b_rotate_drones,
964	jag	341	&ol_selection_targets,
		342	&sp_mondrian_change_slit_anim_time,
		343	&cb_mark_segments,
		344	&cb_auto_split_box,
		345	&cb_auto_delete_box,
		346	&sp_auto_split_time,
		347	&sp_auto_delete_time,
		348	&ol_auto_pick_box_split,
		349	&ol_auto_split_at,
		350	&ol_auto_split_orient,
		351	&ol_auto_pick_box_delete,
		352	&sp_min_split_size,
		353	&cb_speed,
		354	&cb_turn,
		355	&cb_teleport,
		356	&sp_turn_every,
		357	&sp_turn_min,
		358	&sp_turn_max,
		359	&sp_speed_every,
		360	&sp_speed_min,
		361	&sp_speed_max,
		362	&sp_max_speed,
		363	&sp_tel_every,
		364	&sp_tel_radius,
		365	&cb_draw_ball_position,
		366	&cb_draw_ball_heading,
		367	&cb_draw_ball_trails,
		368	&l_draw_ball,
		369	&cb_turn_sync,
		370	&cb_speed_sync,
		371	&sp_clone_every,
		372	&sp_max_clones,
		373	&sp_clone_offset,
		374	&sp_max_balls,
		375	&cb_clone,
		376	&cb_clone_can_clone,
		377	&ol_browse_balls,
		378	&cb_mon_tools,
		379	&cb_mon_parameters,
		380	&cb_mon_ballops,
		381	&cb_mon_boxops,
		382	&cb_mon_misc,
		383	&cb_transform,
		384	&sp_transform_every,
		385	&ol_bouncer,
		386	&ol_healer,
		387	&ol_wrecker,
		388	&cb_label_hz_vol,
		389	&il_binaural_drones,
		390	&cb_binaural_drones_edit,
		391	&bbd_select_all,
		392	&bbd_select_none,
		393	&bbd_invert_select,
		394	&bbd_delete,
		395	&bbd_sync,
		396	&lf_pitch_fade_time,
		397	&lf_modulation_amount,
		398	&bd_modulate_up,
		399	&bd_modulate_down,
		400	&bbd_modulate,
		401	&bbd_select2,
		402	&ol_select_what,
		403	&ol_select_rule,
		404	&bdf_value,
		405	&lf_l,
		406	&lf_r,
		407	&lf_sep,
		408	&lf_vol,
		409	&ol_just,
		410	&bbd_flip,
		411	&b_adjust_board_height,
		412	&b_adjust_range_left,
		413	&b_adjust_range_right,
		414	&b_adjust_range_both,
		415	&sp_snap_left,
		416	&sp_snap_right,
		417	&ol_bounce_style,
		418	&cb_mod_ran,
		419	&sp_range,
		420	&sp_ran_mod_width,
		421	&sp_ran_mod_width_bpm,
		422	&cb_mark_ran,
		423	&l_ran_mod,
		424	&b_rm_pause_resume,
		425	&b_rm_start_all,
		426	&b_rm_stop_all,
		427	&b_rm_toggle,
		428	&b_get_cur_ran,
		429	&ol_snap_style,
		430	&sp_ran_mod_height,
		431	&sp_ran_mod_height_bpm,
		432	&cb_mkb_ranges,
		433	&l_adjust_range,
		434	&l_adjust_height,
		435	&b_adjust_range_height,
1768	jag	436	&dronearrow.shoulder.position,
		437	&dronearrow.shoulder.width,
964	jag	438	&l_drone_arrow,
		439	&sp_default_width,
		440	&sp_default_height,
		441	&b_change_note_left,
		442	&b_change_note_right,
		443	&ol_change_note_style,
		444	&ol_set_unset_toggle,
		445	&b_set,
		446	&b_unset,
		447	&b_toggle,
1037	jag	448	&sp_browse_drone,
		449	&ol_drone_order,
		450	&l_drone_order,
		451	&ol_mesh_point,
1040	jag	452	&f_mesh_xy,
		453	&cb_sync_rows_cols,
1049	jag	454	&sp_mesh_dur,
		455	&b_flip_rows_cols,
1551	jag	456	&cb_overlay,
1598	jag	457	&dp_numdrones,
1096	jag	458	&dp_bpm1,
1104	jag	459	&dp_orient,
1137	jag	460	&b_swap_curves,
		461	&cb_pitch_dis,
1140	jag	462	&cb_vol_dis,
1144	jag	463	&sp_lev_sz,
1397	jag	464	&ol_change_note,
1235	jag	465	&b_change_note_both,
1320	jag	466	&sp_drone_master_vol,
1321	jag	467	&l_use_drone_pend,
1320	jag	468	&sp_drones_per_pend,
		469	&l_apply_to,
		470	&cb_am_bpm,
		471	&cb_fm_bpm,
		472	&b_set_to_mesh_rows,
1323	jag	473	&b_set_to_mesh_cols,
1423	jag	474	&ol_drone_is,
1429	jag	475	&b_ball_trig,
1436	jag	476	&ol_fixed,
1438	jag	477	&cb_draw_mesh,
1467	jag	478	&lf_conn_steps,
1461	jag	479	&s_red_min,
		480	&s_green_min,
		481	&s_blue_min,
		482	&s_red_max,
		483	&s_green_max,
		484	&s_blue_max,
1463	jag	485	&cb_conn_wrap,
1465	jag	486	&separators.main,
1470	jag	487	&separators.dp0,
1465	jag	488	&cb_modulation,
		489	&cb_motion,
1467	jag	490	&cb_visual,
		491	&b_connect,
1468	jag	492	&b_disconnect,
1470	jag	493	&ol_color,
		494	&separators.dp1,
1498	jag	495	&b_abort_octave_shift,
1499	jag	496	&sp_stiff,
1514	jag	497	&b_arrow_reset,
1547	jag	498	&b_mute,
		499	&b_unmute,
1819	jag	500	&gabt,
1552	jag	501	&sp_drone_vol,
1557	jag	502	&drone2noise,
		503	&noise2drone,
1666	jag	504	&b_set_xform_center,
1772	jag	505	&autorotate.title,
		506	&autorotate.whichl,
		507	&autorotate.start,
		508	&autorotate.stop,
		509	&autorotate.toggle,
		510	&autorotate.clockwise,
		511	&autorotate.anticlockwise,
		512	&autorotate.rpm,
1675	jag	513	&cb_defaults,
		514	&sp_wand_dist,
		515	&ol_drones_are,
1828	jag	516	&riset,
		517	&fallt,
1677	jag	518	&lifetime,
		519	&mortalize,
		520	&reincarnate,
		521	&immortalize,
1688	jag	522	&diram.vert,
1682	jag	523	&diram.hor,
		524	&diram.vel,
		525	&diram.accel,
1688	jag	526	&dirfm.vert,
1682	jag	527	&dirfm.hor,
		528	&dirfm.vel,
		529	&dirfm.accel,
		530	&diram.lbl,
		531	&dirfm.lbl,
1695	jag	532	&cb_chuck,
		533	&chuck,
1697	jag	534	&chspeed,
1695	jag	535	&chflip,
1697	jag	536	&chtog,
1695	jag	537	&chlen,
1705	jag	538	&chapt,
1702	jag	539	&chtrail,
1708	jag	540	&handlesize,
1715	jag	541	&sva.lbl,
		542	&sva.whats,
1764	jag	543	&sva.neg,
		544	&sva.zero,
1715	jag	545	&sva.vert,
		546	&sva.hor,
		547	&sva.vel,
		548	&sva.accel,
1772	jag	549	&autorotate.autoflip.lbl,
		550	&autorotate.autoflip.angle,
		551	&autorotate.autoflip.set,
		552	&autorotate.autoflip.unset,
		553	&autorotate.autoflip.toggle,
1836	jag	554	&dva.whichl,\
1732	jag	555	&dva.ldir,\
		556	&dva.odir,\
		557	&dva.neg,\
		558	&dva.randomize,\
1738	jag	559	&dva.mag,\
1894	jag	560	&dva.anticlockwise,\
1738	jag	561	&dva.clockwise,\
1748	jag	562	&choutline,
		563	&chautoresettrails,
1753	jag	564	&anchored,
1756	jag	565	&trailsize,
1804	jag	566	&dronearrow.neck,
1768	jag	567	&dronearrow.cap,
1773	jag	568	&dronearrow.decap,
		569	&autorotate.deg,
		570	&autorotate.tps,
1807	jag	571	&autorotate.mov,
1774	jag	572	&autorotate.smooth,
		573	&autorotate.tick,
1776	jag	574	&dronearrowdefaults.lbl,
1804	jag	575	&dronearrowdefaults.neck,
1805	jag	576	&dronearrowdefaults.shoulder.position,
1776	jag	577	&dronearrowdefaults.shoulder.width,
		578	&dronearrowdefaults.cap,
1778	jag	579	&dronearrowdefaults.arrow,
1797	jag	580	&trackcon,
1806	jag	581	&dva.autorotate.cb,
		582	&dva.autorotate.mov,
		583	&dva.autorotate.dir,
		584	&dva.autorotate.rpm,
		585	&dva.autorotate.dps,
		586	&dva.autorotate.tps,
		587	&dva.autoflip.cb,
		588	&dva.autoflip.deg,
2032	jag	589	&vel0,
		590	&accel0,
1836	jag	591	&dva.sync,
1851	jag	592	&gens,
2106	jag	593	&ddpm,
1871	jag	594	&dva.autorotate.uet.deg,
		595	&dva.autorotate.uet.tps,
1892	jag	596	&ddpl,
1893	jag	597	&dpl,
1912	jag	598	&sp_dam_pos,
		599	&sp_dfm_pos,
1913	jag	600	&am2fm,
		601	&fm2am,
1920	jag	602	&scopacity,
1941	jag	603	&cb_ed_curves,
1950	jag	604	&ed_flip_rotation,
		605	&cb_ed_autoflip,
		606	&sp_curve_every,
		607	&ed_autoflip_reset,
1970	jag	608	&dva.autopause.cb,
		609	&dva.autopause.every,
		610	&dva.autopause.f0r,
1972	jag	611	&autorotate.autopause.lbl,
		612	&autorotate.autopause.set,
		613	&autorotate.autopause.unset,
		614	&autorotate.autopause.toggle,
1973	jag	615	&autorotate.autopause.every,
		616	&autorotate.autopause.f0r,
1976	jag	617	&autorotate.rndflipause.whichl,
		618	&autorotate.rndflipause.set,
		619	&autorotate.rndflipause.unset,
		620	&autorotate.rndflipause.toggle,
1998	jag	621	&damd0,
		622	&dfmd0,
2038	jag	623	&dva.autopause.tar,
		624	&masvol0,
2039	jag	625	&crvwav.time,
2049	jag	626	&texture,
		627	&texstep,
		628	&text_ure,
2060	jag	629	&revmod,
2076	jag	630	&sva.perp,
2077	jag	631	&rotaccel,
2078	jag	632	&rdvel,
		633	&rdaccel,
2125	jag	634	&size_tangent,
2126	jag	635	&draweditables,
2206	jag	636	&track_phrase_position,
2222	jag	637	&viewtoo,
		638	&drawsnaps,
		639	&drawcursor,
2219	jag	640	&pinunpin,
2273	jag	641	&sep_bin,
2276	jag	642	&sep0,
2306	jag	643	&ancopa,
1677	jag	644	// next item here
964	jag	645	};
		646
2078	jag	647
1449	jag	648	int ii = 0;
1450	jag	649	for (int i = 0; i < NUM_INSTRUMENTS; ++i) {
1449	jag	650	button* ei = inst_ed[i];
1450	jag	651	ei->id = i;
1645	jag	652	#ifndef __WIDGET_MOVE__
1472	jag	653	ei->set_listener (&insl);
1645	jag	654	#endif
1449	jag	655	items[ii++] = ei;
		656	}
1450	jag	657	for (int i = NUM_INSTRUMENTS; i < n_inst_ed; ++i) {
		658	button* ei = inst_ed[i];
1502	jag	659	ei->id = i + 1; // as 0 is instrument
1645	jag	660	#ifndef __WIDGET_MOVE__
1472	jag	661	ei->set_listener (&edl);
1645	jag	662	#endif
1450	jag	663	items[ii++] = ei;
		664	}
1472	jag	665
1757	jag	666	for (int i = n_inst_ed, j = 0; i < nitems; ++i) items[ii++] = mi[j++];
1449	jag	667
1568	jag	668	dlog << "+++ Items list setup +++ " << endl;
		669
1645	jag	670	#ifndef __WIDGET_MOVE__
1321	jag	671	{
1477	jag	672	button* btns [] = {&b_set_to_mesh_rows, &b_set_to_mesh_cols, &b_set, &b_unset, &b_toggle};
		673	click_listener* cl [] = {&stmrl, &stmcl, &sutl, &sutl, &sutl};
1321	jag	674	checkbutton* cbtns [] = {&cb_am_bpm, &cb_fm_bpm};
		675	state_listener* sl [] = {&abl, &fbl};
1477	jag	676	for (int i = 0; i < 5; ++i) btns[i]->set_listener (cl[i]);
1449	jag	677	for (int i = 0; i < 2; ++i) cbtns[i]->set_listener (sl[i]);
1323	jag	678
1321	jag	679	}
1645	jag	680	#endif
1321	jag	681
964	jag	682	// tabs
		683	num_tabs = 0;
1393	jag	684	last_tab = next_tab = cur_tab = 0;
1406	jag	685	next_tab_instr = 0;
1473	jag	686	checkbutton* cb_tabs [] = {
		687	&cb_file,
		688	&cb_instrument,
		689	&cb_editors,
		690	&cb_mkb_voice,
		691	&cb_mkb_drone_tools,
		692	&cb_mkb_drone_params,
		693	&cb_mkb_ranges,
		694	&cb_mkb_misc,
964	jag	695	&cb_ed_tools,
1473	jag	696	&cb_mon_tools,
		697	&cb_mon_parameters,
		698	&cb_mon_ballops,
		699	&cb_mon_boxops,
		700	&cb_mon_misc,
964	jag	701	&cb_binaural_drones_tools,
		702	&cb_binaural_drones_edit,
1941	jag	703	&cb_ed_curves,
964	jag	704	};
1319	jag	705
1473	jag	706	static const char* const cb_tab_lbls [] = {
		707	"File",
		708	"Instrument",
		709	"Editors",
		710	"Voice",
		711	"Drone Tools",
		712	"Drone Params",
		713	"Ranges",
		714	"Misc",
964	jag	715	"Tools",
1473	jag	716	"Tools",
		717	"Params",
		718	"Ball Ops",
		719	"Box Ops",
		720	"Misc",
964	jag	721	"Create",
1941	jag	722	"Edit",
		723	"Curves",
964	jag	724	};
1319	jag	725
1941	jag	726	for (int i = 0; i < 17; ++i) {
1473	jag	727	checkbutton* ci = cb_tabs[i];
		728	ci->set_text (cb_tab_lbls[i]);
		729	ci->set_listener (this);
964	jag	730	}
		731
		732	widget* wfile [] = {
1319	jag	733	&b_exit_din,
964	jag	734	&cb_record,
		735	&b_clear_record,
		736	&b_save,
1319	jag	737	&lf_file,
964	jag	738	&b_turn_off_ui,
		739	&cb_scope,
		740	&sp_scope_height,
1920	jag	741	&sp_scope_samples,
		742	&scopacity,
1319	jag	743	};
		744
1645	jag	745	#ifndef __WIDGET_MOVE__
964	jag	746	cb_record.set_listener (&recl);
		747	b_clear_record.set_listener (&recl);
		748	b_save.set_listener (&recl);
1319	jag	749	b_exit_din.set_listener (&miscl);
		750	b_turn_off_ui.set_listener (&miscl);
1645	jag	751	lf_file.fld.typing_lsnr = &recl;
		752	#endif
1319	jag	753
964	jag	754	lf_file.fld.set_text ("din.wav");
		755	lf_file.lbl.set_text ("File on Desktop?");
		756
		757	widget* winst [] = {
		758	&b_microtonal_keyboard,
		759	&b_keyboard_keyboard,
		760	&b_mondrian,
		761	&b_binaural_drones
		762	};
		763
		764	widget* weds [] = {
1931	jag	765	&b_keyboard_keyboard_waveform,
		766	&b_attack,
		767	&b_decay,
		768	&b_midi_velocity,
964	jag	769	&b_microtonal_keyboard_waveform,
		770	&b_drone_waveform,
		771	&b_drone_modulation,
		772	&b_voice_modulation,
		773	&b_range_modulation,
1026	jag	774	&b_range_width_height,
1104	jag	775	&b_range_pitch_vol,
964	jag	776	&b_gater,
1930	jag	777	&b_point_modulation,
		778	&b_drone_pend,
		779	&edlife2vel,
964	jag	780	&b_mondrian_waveform,
		781	&b_mondrian_attack,
		782	&b_mondrian_decay,
		783	&b_binaural_drones_waveform,
		784	&b_delays,
		785	&b_octave_shift,
		786	&b_compressor,
		787	&b_morse_code,
1941	jag	788	&b_noise_interpolator,
964	jag	789	};
		790
		791	widget* wvoice [] = {
		792	&sp_voice_volume,
		793	&b_record_phrase,
		794	&b_clear_phrases,
		795	&s_phrase_position,
		796	&l_phrase_position,
2206	jag	797	&track_phrase_position,
964	jag	798	&sp_am_depth,
		799	&sp_fm_depth,
		800	&sp_am_bpm,
		801	&sp_fm_bpm,
		802	&ol_am_style,
1438	jag	803	&ol_fm_style,
964	jag	804	};
		805
1645	jag	806	#ifndef __WIDGET_MOVE__
964	jag	807	for (int i = 1; i < 3; ++i) static_cast<button*>(wvoice[i])->set_listener (&pcl); // phrase commands listener
1645	jag	808	#endif
964	jag	809
		810	widget* wdrone_tools [] = {
1674	jag	811	&ol_add_wand,
964	jag	812	&b_delete_drones,
		813	&b_select_all_drones,
		814	&b_invert_drone_selection,
		815	&b_orbit_selected_drones,
		816	&b_select_attractees,
		817	&b_select_attractors,
		818	&b_launch_drones,
		819	&b_stop_launching_drones,
		820	&b_track_drones,
		821	&b_select_tracked_drones,
		822	&b_set_targets,
		823	&b_clear_targets,
		824	&b_select_launchers,
		825	&b_freeze_drones,
		826	&b_thaw_drones,
1049	jag	827	&b_flip_rows_cols,
1098	jag	828	&ol_create_this,
964	jag	829	&sp_mesh_rows,
		830	&sp_mesh_cols,
1037	jag	831	&sp_browse_drone,
		832	&ol_drone_order,
		833	&l_drone_order,
1046	jag	834	&cb_sync_rows_cols,
1049	jag	835	&sp_mesh_dur,
1598	jag	836	&dp_numdrones,
1096	jag	837	&dp_bpm1,
1320	jag	838	&dp_orient,
1321	jag	839	&l_use_drone_pend,
1320	jag	840	&cb_am_bpm,
		841	&cb_fm_bpm,
		842	&sp_drones_per_pend,
		843	&l_apply_to,
		844	&b_set_to_mesh_rows,
		845	&b_set_to_mesh_cols,
1984	jag	846	&moverailstrafe,
1496	jag	847	&b_scale_drones,
		848	&b_rotate_drones,
1512	jag	849	&b_connect,
		850	&b_disconnect,
		851	&lf_conn_steps,
		852	&cb_conn_wrap,
1547	jag	853	&b_mute,
		854	&b_unmute,
1819	jag	855	&gabt,
1557	jag	856	&drone2noise,
		857	&noise2drone,
1666	jag	858	&b_set_xform_center,
1677	jag	859	&mortalize,
		860	&reincarnate,
		861	&immortalize,
1797	jag	862	&chuck,
		863	&trackcon,
1827	jag	864	&balloon,
		865	&b_set,\
		866	&b_unset,\
		867	&b_toggle,\
		868	&ol_set_unset_toggle,\
964	jag	869	};
1320	jag	870
1686	jag	871	LISTEN(ol_add_wand,&awdl)
		872	LISTEN(ol_add_wand.option,&dcl)
		873	LISTEN(ol_drones_are, &darl)
1675	jag	874
1645	jag	875	#ifndef __WIDGET_MOVE__
1473	jag	876	LISTEN(b_scale_drones,&bsdl)
		877	LISTEN(b_rotate_drones,&brdl)
1984	jag	878	LISTEN(moverailstrafe, &mrsl)
		879	LISTEN(moverailstrafe.option, &bmdl)
1827	jag	880	LISTEN(balloon,&dugl)
1547	jag	881	LISTEN(b_mute,&mul)
		882	LISTEN(b_unmute,&umul)
1557	jag	883	LISTEN(drone2noise,&d2nl)
		884	LISTEN(noise2drone,&n2dl)
1812	jag	885	LISTEN(seloncre,&dcl);
1646	jag	886	LISTEN(cb_conn_wrap, &wrapl)
		887	LISTEN(b_connect, &bconl)
		888	LISTEN(b_disconnect, &bdconl)
1666	jag	889	LISTEN(b_set_xform_center, &xcl);
1677	jag	890	LISTEN(mortalize,&morl)
		891	LISTEN(immortalize,&immorl)
		892	LISTEN(reincarnate,&reinl)
1695	jag	893	LISTEN(chuck, &chl)
		894	LISTEN(chflip,&flpl)
1697	jag	895	LISTEN(chtog,&ctogl)
1749	jag	896	LISTEN(chautoresettrails,&aurl)
1645	jag	897	#endif
1646	jag	898
1986	jag	899	raill1.name = "Rail";
		900	strafel1.name = "Strafe";
		901
1619	jag	902	sp_stiff.set ("Connection stiffness", 0.001f, 0.0f, 1.0f, &stiffl);
2306	jag	903	ancopa.set ("Opacity", 0.01f, 0.0f, 1.0f, &anchl);
		904
1819	jag	905	gabt.set (0.1f, 0, MILLION, &gabtl);
		906	gabt.set_text ("In", SECONDS);
1485	jag	907	sp_drones_per_pend.set ("Drones Per Pendulum", 1, 2, MILLION, &dppl, 0);
1321	jag	908	l_use_drone_pend.set_text ("Drone Pendulum's parameters?");
1320	jag	909	l_apply_to.set_text ("Apply to");
		910
1686	jag	911	DECL_DRONE_PARAMS
1645	jag	912
1686	jag	913	ol_drone_is.set_listener (this);
		914	diram.setup ("Set AM direction to: ");
		915	dirfm.setup ("Set FM direction to: ");
2105	jag	916
2106	jag	917	sp_wand_dist.set ("Wand distance", 1, 0, MILLION, &wandl);
2105	jag	918	riset.set ("Rise time", 0.1f, 0, MILLION, &rl);
		919	fallt.set ("Fall time", 0.1f, 0, MILLION, &fl);
		920	lifetime.set ("Lifetime", 0.1f, 0, MILLION, &lifel);
2106	jag	921	handlesize.set ("Handle size", 1, 0, MILLION, &handl);
		922	trailsize.set ("Trail size", 1, 0, MILLION, &trll);
		923	ddpm.set ("Launches per minute", 1, 0, MILLION, &ddpml);
		924	ddpl.set ("Drones per launch", 1, 0, MILLION, &ddpll);
		925	gens.set ("Generations", 1, 1, MILLION, &gensl);
		926	gens.orient = mouse_slider_listener::NONE;
2105	jag	927
1772	jag	928	autorotate.setup ();
1715	jag	929	sva.setup ();
1732	jag	930	dva.setup ();
1807	jag	931
1753	jag	932	anchored.set_listener (&ancl);
1675	jag	933
2106	jag	934	// chuck
1760	jag	935	chspeed.set ("Speed", 1.0f, &spdl); chspeed.limits = 0;
1695	jag	936	chlen.set ("Length", 1.0f, &lenl);
1760	jag	937	chapt.set ("Angle per turn", 0.1f, &apfl); chapt.limits = 0;
1706	jag	938	chtrail.set ("Trail length", 10000, &chtll);
1695	jag	939
1645	jag	940	#ifndef __WIDGET_MOVE__
1750	jag	941	for (int i = 1; i < 17; ++i) dynamic_cast<button*>(wdrone_tools[i])->set_listener (&dcl);
1645	jag	942	for (int i = 0, j = DRONE_PARAMS_N - 1; i < 4; ++i) dynamic_cast<checkbutton*>(wdrone_params[j--])->set_listener (&dcl);
		943	#endif
		944
1686	jag	945	static const char* txt [] = {"AM Depth", "FM Depth", "AM BPM", "FM BPM"};
964	jag	946	spinner<float>* spn [] = {&sp_am_depth, &sp_fm_depth, &sp_am_bpm, &sp_fm_bpm};
1686	jag	947	change_listener<field>* vlis [] = {&amdl, &fmdl, &ambpml, &fmbpml};
964	jag	948	spinner<float>* dspn [] = {&sp_dam_depth, &sp_dfm_depth, &sp_dam_bpm, &sp_dfm_bpm};
1451	jag	949	change_listener<field>* dlis [] = {&damdl, &dfmdl, &dambpml, &dfmbpml};
964	jag	950
		951	for (int i = 0; i < 4; ++i) {
1686	jag	952	const char* txti = txt[i];
964	jag	953	spinner<float>* dspni = dspn[i];
1686	jag	954	dspni->set (txti, 1.0f, dlis[i]);
964	jag	955	spinner<float>* spni = spn[i];
1120	jag	956	spni->set_text (txti);
1452	jag	957	spni->set_listener (vlis[i]);
964	jag	958	}
		959
		960	for (int i = 1; i < 4; ++i) spn[i]->set_delta (1.0f);
2033	jag	961	sp_am_depth.set_delta (0.01f);
964	jag	962	sp_am_bpm.set_limits (0, MILLION);
		963	sp_fm_bpm.set_limits (0, MILLION);
		964
2016	jag	965	sp_dam_pos.set ("AM Position", 0.01f, &dampl);
		966	sp_dfm_pos.set ("FM Position", 0.01f, &dfmpl);
1912	jag	967
2027	jag	968	sp_dam_depth.lim = &damd0;
		969	sp_dfm_depth.lim = &dfmd0;
		970
2060	jag	971	LISTEN(revmod,&revl)
		972	LISTEN(revmod.option,&revcl)
		973
964	jag	974	widget* wranges [] = {
		975	&b_selected_to_all,
		976	&b_default_to_selected,
		977	&b_default_to_all,
		978	&b_adjust_range_left,
		979	&b_adjust_range_right,
		980	&b_adjust_range_both,
		981	&b_adjust_range_height,
		982	&b_adjust_board_height,
		983	&b_rm_start_all,
		984	&b_rm_stop_all,
		985	&b_rm_toggle,
		986	&b_rm_pause_resume,
		987	&b_get_cur_ran,
		988	&cb_mod_ran,
		989	&cb_mark_ran,
		990	&sp_ran_mod_width,
		991	&sp_ran_mod_width_bpm,
		992	&sp_ran_mod_height,
		993	&sp_ran_mod_height_bpm,
		994	&sp_range,
		995	&l_ran_mod,
		996	&l_adjust_height,
		997	&l_adjust_range,
		998	&ol_set_range,
		999	&sp_default_width,
		1000	&sp_default_height,
		1001	&b_change_note_left,
		1002	&b_change_note_right,
1235	jag	1003	&ol_change_note_style,
1397	jag	1004	&ol_change_note,
1235	jag	1005	&b_change_note_both,
1436	jag	1006	&ol_fixed,
1827	jag	1007	&sp_snap_left,
		1008	&sp_snap_right,
		1009	&ol_snap_style,
964	jag	1010	};
		1011
1645	jag	1012	#ifndef __WIDGET_MOVE__
964	jag	1013	for (int i = 0; i < 3; ++i) static_cast<button*>(wranges[i])->set_listener (&sral);
		1014	for (int i = 3; i < 6; ++i) static_cast<button*>(wranges[i])->set_listener (&rwl);
		1015	b_adjust_range_height.set_listener (&rhl);
		1016	b_adjust_board_height.set_listener (&bhl);
		1017	for (int i = 8; i < 13; ++i) static_cast<button*>(wranges[i])->set_listener (&rml);
		1018	cb_mod_ran.set_listener (&rml);
		1019	cb_mark_ran.set_listener (&rml);
		1020	b_change_note_left.set_listener (&cnl);
		1021	b_change_note_right.set_listener (&cnr);
1235	jag	1022	b_change_note_both.set_listener (&cnb);
1645	jag	1023	#endif
964	jag	1024
1675	jag	1025	ol_change_note.set_listener (&cnol);
		1026	ol_change_note_style.set_listener (&cnsl);
964	jag	1027
		1028	widget* wmisc [] = {
		1029	&l_octave_shift,
		1030	&ab_octave_down,
		1031	&ab_octave_up,
		1032	&sp_octave_shift_bpm,
		1033	&l_gater,
		1034	&sp_gater_bpm,
		1035	&ol_gater_style,
		1036	&b_key_to_pitch_at_cursor,
		1037	&l_tap_bpm,
		1038	&td_tap_display,
		1039	&l_tap_bpm_value,
		1040	&cb_am,
		1041	&cb_fm,
		1042	&cb_gater,
		1043	&cb_octave_shift,
		1044	&cb_auto_reset,
1137	jag	1045	&cb_pitch_dis,
1140	jag	1046	&cb_vol_dis,
1438	jag	1047	&sp_lev_sz,
1481	jag	1048	&b_abort_octave_shift,
964	jag	1049	};
1137	jag	1050
1645	jag	1051	#ifndef __WIDGET_MOVE__
1481	jag	1052	LISTEN(b_abort_octave_shift, &aosl)
1438	jag	1053	cb_draw_mesh.set_listener (&dml);
1137	jag	1054	cb_pitch_dis.set_listener (&pvdl);
		1055	cb_vol_dis.set_listener (&pvdl);
1645	jag	1056	#endif
1137	jag	1057
1645	jag	1058	sp_lev_sz.set ("Level size", 1, 1, MILLION, &pvdl);
964	jag	1059
1950	jag	1060	widget* wedtools [] = { // curve editors tools
964	jag	1061	&abe_left,
		1062	&abe_right,
		1063	&abe_up,
		1064	&abe_down,
		1065	&pb_zoom_in,
		1066	&mb_zoom_out,
1117	jag	1067	&l_snap,
1901	jag	1068	&b_snapx,
		1069	&b_snapy,
		1070	&b_snapboth,
		1071	&b_snapnone,
2222	jag	1072	&drawsnaps,
964	jag	1073	&b_pick_curve,
		1074	&b_insert_vertex,
		1075	&b_delete_vertex,
1117	jag	1076	&b_draw_replacement_curve,
		1077	&b_undo,
		1078	&b_redo,
2222	jag	1079	&viewtoo,
1117	jag	1080	&b_copy,
2340	jag	1081	&ol_paste,
1128	jag	1082	&b_swap_curves,
2239	jag	1083	&size_tangent,
1117	jag	1084	&b_fold_tangents,
2214	jag	1085	&cb_selection_only,
1128	jag	1086	&ol_mirror,
2219	jag	1087	&pinunpin,
1117	jag	1088	&ol_mirror_tangents,
		1089	&lf_curve_name,
		1090	&sp_curve_limit,
		1091	&ol_curve_style,
964	jag	1092	&l_library,
		1093	&abl_left,
		1094	&abl_right,
1117	jag	1095	&b_add_curve,
		1096	&b_replace_curve,
		1097	&b_delete_curve,
964	jag	1098	&l_capture,
		1099	&b_start_capture,
		1100	&b_assign_capture,
		1101	&cb_draw_curve,
2126	jag	1102	&draweditables,
		1103	&cb_mark_segments,
1117	jag	1104	&cb_label_vertices,
964	jag	1105	&cb_show_waveform_samples,
2039	jag	1106	&crvwav.hz,
		1107	&crvwav.periods,
		1108	&crvwav.time,
964	jag	1109	&sp_curve_rpm,
		1110	&b_stop_rotating,
1950	jag	1111	&ed_flip_rotation,
		1112	&cb_ed_autoflip,
2039	jag	1113	&ed_autoflip_reset,
1950	jag	1114	&sp_curve_every,
2039	jag	1115	&cb_overlay,
2222	jag	1116	&drawcursor,
2219	jag	1117	&pinunpin,
964	jag	1118	};
		1119
		1120	widget* wmon [] = { // mondrian tools
		1121	&b_add_balls,
		1122	&b_move_selected_balls,
		1123	&b_delete_selected_targets,
		1124	&b_delete_all_targets,
		1125	&b_select_all_targets,
		1126	&b_invert_selected_targets,
		1127	&b_split_horizontal,
		1128	&b_split_vertical,
		1129	&b_delete_box,
		1130	&b_select_targets_in_box,
		1131	&b_freeze_balls,
		1132	&b_thaw_balls,
		1133	&b_clear_modulations,
		1134	&b_modulate_balls_up,
		1135	&b_modulate_balls_down,
		1136	&b_auto_change_direction_clockwise,
		1137	&b_auto_change_direction_anti_clockwise,
		1138	&b_stop_auto_changing_direction,
		1139	&b_flip_direction,
		1140	&b_make_random_color,
		1141	&b_add_remove_slits,
		1142	&b_select_wreckers,
		1143	&b_select_healers,
		1144	&b_switch_ball_type,
		1145	&b_toggle_wreckers,
		1146	&b_toggle_healers,
		1147	&b_toggle_bouncers,
		1148	&b_remove_slits_on_edge,
		1149	&b_toggle_slit_anim,
		1150	&b_make_note_grid,
		1151	&b_make_nxn_grid,
		1152	&b_delete_all_boxes,
1423	jag	1153	&b_ball_trig,
964	jag	1154	&ol_ball_types,
		1155	&ol_split_types_h,
		1156	&ol_split_types_v,
		1157	&sp_mondrian_num_boxes,
1423	jag	1158	&ol_selection_targets,
964	jag	1159	};
		1160
		1161
		1162	arrow_button* mnav[] = {&abm_left, &abm_down, &abm_right, &abm_up};
		1163	int mdirs [] = {arrow_button::left, arrow_button::down, arrow_button::right, arrow_button::up};
		1164	for (int i = 0; i < 4; ++i) {
		1165	arrow_button* ab = mnav[i];
1015	jag	1166	ab->set_dir (mdirs[i]);
964	jag	1167	}
		1168
		1169	widget* wmon_pars [] = { // mondrian parameters
		1170	&l_octave_shift,
		1171	&ab_octave_down,
		1172	&ab_octave_up,
		1173	&sp_octave_shift_bpm,
1519	jag	1174	&b_abort_octave_shift,
964	jag	1175	&sp_mondrian_min_voices,
		1176	&sp_mondrian_change_attack_time,
		1177	&sp_mondrian_change_decay_time,
		1178	&sp_mondrian_change_speed,
		1179	&sp_mondrian_change_dir,
		1180	&sp_mondrian_change_trail_size,
		1181	&sp_mondrian_change_note_poly_points,
		1182	&sp_mondrian_change_note_poly_radius,
		1183	&sp_mondrian_change_slit_size,
		1184	&sp_mondrian_change_slit_anim_time,
		1185	&cb_mondrian_auto_adjust_voices,
		1186	&sp_mondrian_change_vol
		1187	};
		1188
		1189	widget* wmon_misc [] = { // mondrian misc
		1190	&l_draw_ball,
		1191	&abm_left,
		1192	&abm_right,
		1193	&abm_up,
		1194	&abm_down,
		1195	&bm_zoom_in,
		1196	&bm_zoom_out,
		1197	&cb_draw_boxes,
		1198	&cb_fill_boxes,
		1199	&cb_draw_notes,
		1200	&cb_label_notes,
		1201	&cb_label_hz_vol,
		1202	&cb_draw_ball_position,
		1203	&cb_draw_ball_heading,
2049	jag	1204	&cb_draw_ball_trails,
		1205	&texture,
		1206	&texstep,
		1207	&text_ure,
964	jag	1208	};
		1209
		1210	widget* wmon_boxops [] = {
		1211	&cb_auto_split_box,
		1212	&cb_auto_delete_box,
		1213	&sp_auto_split_time,
		1214	&sp_auto_delete_time,
		1215	&ol_auto_pick_box_split,
		1216	&ol_auto_split_at,
		1217	&ol_auto_split_orient,
		1218	&ol_auto_pick_box_delete,
		1219	&sp_min_split_size
		1220	};
		1221
		1222	widget* wmon_ballops [] = {
		1223	&cb_turn, &cb_speed, &cb_teleport, &cb_clone, &sp_turn_every, &sp_turn_min, &sp_turn_max,
		1224	&sp_speed_every, &sp_speed_min, &sp_speed_max, &sp_max_speed, &sp_tel_every, &sp_tel_radius,
		1225	&cb_turn_sync, &cb_speed_sync, &sp_clone_every, &sp_max_clones, &sp_clone_offset, &sp_max_balls,
		1226	&cb_clone_can_clone, &ol_browse_balls,
		1227	&cb_transform, &sp_transform_every, &ol_bouncer, &ol_healer, &ol_wrecker,
		1228	};
		1229
		1230	spinner<float>* bospn [] = {&sp_turn_every, &sp_speed_every, &sp_tel_every, &sp_clone_every, &sp_transform_every};
		1231	float bodta [] = {0.01f, 0.01f, 1.0f, 1.0f, 1.0f};
		1232	for (int i = 0; i < ball_op::NUM_OPS; ++i) {
		1233	spinner<float>* spni = bospn[i];
1677	jag	1234	spni->set_text ("Every", SECONDS);
1646	jag	1235	spni->set (bodta[i], 0.0f, MILLION, &bolis);
964	jag	1236	}
1836	jag	1237	sp_turn_min.set_text ("Clockwise Max", DEGREES);
1646	jag	1238	sp_turn_min.set (1, 0, MILLION, &bolis);
1836	jag	1239	sp_turn_max.set_text ("Anti-clockwise Max", DEGREES);
1646	jag	1240	sp_turn_max.set (1, 0, MILLION, &bolis);
		1241	sp_speed_min.set ("Brake", 0.1f, 0, MILLION, &bolis);
		1242	sp_speed_max.set ("Accelerate", 0.1f, 0, MILLION, &bolis);
		1243	sp_max_speed.set ("Max speed", 1, 0, MILLION, &bolis);
		1244	sp_tel_radius.set ("Max distance", 1, 0, MILLION, &bolis);
		1245	sp_clone_offset.set ("Offset", 1.0f, 0, MILLION, &bolis);
		1246	sp_max_clones.set ("Max clones", 1, 1, MILLION, &bolis);
		1247	sp_max_balls.set ("Max balls", 1, 0, MILLION,&bolis);
964	jag	1248
1646	jag	1249	#ifndef __WIDGET_MOVE__
2120	jag	1250
964	jag	1251	checkbutton* bocbn [] = {&cb_turn, &cb_speed, &cb_teleport, &cb_clone, &cb_transform};
		1252	for (int i = 0; i < ball_op::NUM_OPS; ++i) bocbn[i]->set_listener (&bolis);
		1253	for (int i = 1; i < 7; ++i) static_cast<button*>(wmon_misc[i])->set_listener (&monl);
		1254	for (int i = 7; i < 15; ++i) static_cast<checkbutton*>(wmon_misc[i])->set_listener (&monl);
1646	jag	1255	for (int i = 0; i < 33; ++i) static_cast<button*>(wmon[i])->set_listener (&monl);
2222	jag	1256
1950	jag	1257	for (int i = 0; i < 6; ++i) static_cast<button*>(wedtools[i])->set_listener (&pzl);
		1258	for (int i = 7; i < 11; ++i) static_cast<button*>(wedtools[i])->set_listener (&snl);
2222	jag	1259	drawsnaps.set_listener (&snl);
		1260	drawcursor.set_listener (&cursl);
		1261	viewtoo.set_listener (&urvl);
964	jag	1262
		1263	button* crvops [] = {
1646	jag	1264	&b_pick_curve,
964	jag	1265	&b_insert_vertex,
		1266	&b_delete_vertex,
1646	jag	1267	&b_draw_replacement_curve,
964	jag	1268	&b_fold_tangents,
1128	jag	1269	&ol_mirror.option,
964	jag	1270	&b_copy,
2340	jag	1271	&ol_paste.option,
1646	jag	1272	&b_swap_curves,
964	jag	1273	&b_undo,
		1274	&b_redo,
		1275	&abl_left,
		1276	&abl_right,
		1277	&b_add_curve,
		1278	&b_replace_curve,
		1279	&b_delete_curve,
		1280	&b_start_capture,
		1281	&b_assign_capture,
1948	jag	1282	&b_stop_rotating,
1950	jag	1283	&ed_flip_rotation,
1955	jag	1284	&ed_autoflip_reset,
2125	jag	1285	&size_tangent,
2219	jag	1286	&pinunpin,
964	jag	1287	};
1646	jag	1288
2238	jag	1289	for (int i = 0; i < 23; ++i) crvops[i]->set_listener (&col);
2131	jag	1290	col.name = "Tangent size"; // via mouse slider
964	jag	1291
1646	jag	1292	#endif
		1293
2340	jag	1294	options_list* oll [] = {
		1295	&ol_ball_types, &ol_split_types_h, &ol_split_types_v, &ol_selection_targets,
		1296	&ol_auto_pick_box_split, &ol_auto_split_at, &ol_auto_split_orient,
		1297	&ol_auto_pick_box_delete
		1298	};
1646	jag	1299	for (int i = 0; i < 8; ++i) {
		1300	options_list* oli = oll[i];
		1301	oli->set_listener (&monl);
		1302	}
		1303	ol_split_types_h.set_text (mondrian_listener::split_types[monl.hsplit]);
		1304	ol_split_types_v.set_text (mondrian_listener::split_types[monl.vsplit]);
		1305	ol_selection_targets.set_text (mondrian_listener::selection_targets[mondrian0.sel_tar]);
		1306	ol_browse_balls.set_listener (&bolis);
		1307
		1308	b_undo.click_repeat = b_redo.click_repeat = 1;
		1309	abl_left.click_repeat = abl_right.click_repeat = 1;
		1310
		1311	ol_mirror.set_listener (this);
2340	jag	1312
1646	jag	1313	lf_curve_name.set_listener (&col);
2340	jag	1314	ol_paste.set_listener (&pastl);
		1315
1646	jag	1316	#ifndef __WIDGET_MOVE__
2126	jag	1317	checkbutton* cbed [] = {&cb_label_vertices, &cb_mark_segments, &cb_overlay, &cb_draw_curve, &draweditables, &cb_ed_autoflip, &sp_curve_every.variance.cb, 0};
1950	jag	1318	checkbutton** cp = cbed;
		1319	while (*cp != 0) {
		1320	(*cp)->set_listener (&col);
		1321	cp++;
		1322	}
1646	jag	1323	#endif
964	jag	1324
		1325	widget* wbd [] = { // binaural drones
		1326	&b_create_binaurals_on_notes,
		1327	&b_create_binaurals_from_pitch,
		1328	&sp_bd_separation,
		1329	&sp_bd_pairs,
		1330	&lf_bd_start_pitch,
		1331	&lf_bd_spacing,
		1332	&ol_justification,
		1333	&ol_key_note,
		1334	&cb_resize_separation,
		1335	&cb_close_octave,
		1336	};
		1337
		1338	widget* wbde [] = {
		1339	&bbd_select_all,
		1340	&bbd_select_none,
		1341	&bbd_invert_select,
		1342	&bbd_delete,
		1343	&bbd_sync,
		1344	&bbd_select2,
		1345	&bd_modulate_up,
		1346	&bd_modulate_down,
		1347	&bbd_modulate,
		1348	&bbd_flip,
		1349	&il_binaural_drones,
		1350	&lf_vol_fade_time,
		1351	&lf_master_volume,
		1352	&lf_pitch_fade_time,
		1353	&lf_modulation_amount,
		1354	&ol_select_what,
		1355	&ol_select_rule,
		1356	&bdf_value,
		1357	&lf_l,
		1358	&lf_r,
		1359	&lf_sep,
		1360	&lf_vol,
		1361	&ol_just
		1362	};
		1363
		1364	il_binaural_drones.sel_lis = &bdl;
		1365	lf_sep.fld.set_text (0.0f);
		1366	ol_just.set_text (binaural_drones_listener::justs[binaural_drone::CENTER]);
		1367	ol_just.set_listener (&bdl);
		1368
		1369	bd_modulate_up.set_size (24);
		1370	bd_modulate_down.set_size (24);
1015	jag	1371	bd_modulate_down.set_dir (arrow_button::left);
964	jag	1372
1646	jag	1373	#ifndef __WIDGET_MOVE__
964	jag	1374	for (int i = 0; i < 10; ++i) static_cast<button*>(wbde[i])->set_listener (&bdl);
		1375	for (int i = 0; i < 2; ++i) static_cast<button*>(wbd[i])->set_listener (&bdl); // binaural drones commands
		1376	cb_close_octave.set_listener (&bdl);
		1377	cb_resize_separation.set_listener (&bdl);
1646	jag	1378	#endif
		1379
		1380	ol_select_what.set_listener (&bdl);
		1381	ol_select_rule.set_listener (&bdl);
964	jag	1382	ol_justification.set_listener (&bdl);
		1383	ol_key_note.set_listener (&bdl);
		1384
1646	jag	1385	label_field* lfb [] = {
		1386	&lf_bd_start_pitch, &lf_bd_spacing, &lf_master_volume, &lf_vol_fade_time,
		1387	&lf_pitch_fade_time, &lf_modulation_amount, &lf_l, &lf_r, &lf_sep, &lf_vol
		1388	};
		1389	string lfbs [] = {
		1390	"Start Pitch (Hz)", "Spacing (Hz)", "Master volume (%)", "Volume fade time (secs)",
		1391	"Pitch fade time (secs)", "Amount", "L (Hz)", "R (Hz)", "Separation (Hz)", "Volume (%)"
		1392	};
964	jag	1393	for (int i = 0; i < 10; ++i) {
		1394	label_field* li = lfb[i];
1144	jag	1395	li->set_label (lfbs[i]);
964	jag	1396	li->set_listener (&bdl);
		1397	}
1521	jag	1398
		1399	sp_bd_separation.set ("Separation (Hz)", 1.0f, 0.0f, MILLION, 0, 0);
964	jag	1400	sp_bd_separation.set_value (1.0f);
		1401	sp_bd_separation.orient = mouse_slider_listener::NONE;
		1402
1521	jag	1403	sp_bd_pairs.set ("Number of Pairs", 1, 1, MILLION, 0, 0);
964	jag	1404	sp_bd_pairs.set_value (1);
		1405	sp_bd_pairs.orient = mouse_slider_listener::NONE;
		1406
1883	jag	1407	for (int i = 0; i < 24; ++i) {
1026	jag	1408	editors.push_back (weds[i]);
		1409	//weds[i]->set_moveable(1);
		1410	}
964	jag	1411
1465	jag	1412	widget** wmap [] = {
		1413	wfile,
		1414	winst,
		1415	weds,
		1416	wvoice,
		1417	wdrone_tools,
		1418	wdrone_params,
		1419	wranges,
		1420	wmisc,
1950	jag	1421	wedtools,
1465	jag	1422	wmon,
		1423	wmon_pars,
		1424	wmon_ballops,
		1425	wmon_boxops,
		1426	wmon_misc,
		1427	wbd,
1941	jag	1428	wbde,
		1429
1465	jag	1430	};
		1431	int numw [] = {
1920	jag	1432	10,
1465	jag	1433	4,
1883	jag	1434	24,
2206	jag	1435	12,
1827	jag	1436	58,
1474	jag	1437	DRONE_PARAMS_N,
1827	jag	1438	35,
1481	jag	1439	20,
2238	jag	1440	57,
1465	jag	1441	38,
1519	jag	1442	17,
1465	jag	1443	26,
		1444	9,
2049	jag	1445	18,
1465	jag	1446	10,
1941	jag	1447	23,
		1448
1465	jag	1449	};
964	jag	1450
1467	jag	1451	lf_conn_steps.set_label ("Steps");
1512	jag	1452	LISTEN(lf_conn_steps, &stepsl)
		1453	lf_conn_steps.fld.typing_lsnr = &stepsl;
1467	jag	1454	lf_conn_steps.fld.expr = 0;
1460	jag	1455
1490	jag	1456	DECL_COLOR_SLIDERS
1489	jag	1457	color clrs [] = {color(1.0f, 0.0f, 0.0f), color(0.0f, 1.0f, 0.0f), color(0.0f, 0.0f, 1.0f),
1461	jag	1458	color(1.0f, 0.0f, 0.0f), color(0.0f, 1.0f, 0.0f), color(0.0f, 0.0f, 1.0f)};
1489	jag	1459
1490	jag	1460	for (int i = 0; i < COLOR_SLIDERS_M; ++i) {
		1461	slider<float>& si = dynamic_cast<slider<float>&>(*slrs [i]);
1468	jag	1462	si.set_width_height (128, si.extents.height);
1461	jag	1463	color& ci = clrs [i];
		1464	si.set_color (ci.r, ci.g, ci.b);
		1465	si.set_limits (0.0f, 1.0f);
1646	jag	1466	#ifndef __WIDGET_MOVE__
1489	jag	1467	si.set_listener (&cscl, &cssl);
1646	jag	1468	#endif
1461	jag	1469	}
		1470
1468	jag	1471	colorer.schemes[0]=&gc_top;
		1472	colorer.schemes[1]=&gc_bottom;
1463	jag	1473	colorer.schemes[2]=&gc_blend;
		1474	colorer.schemes[3]=&gc_rand;
1472	jag	1475	colorer.i = colorer_t::RANDOM;
1463	jag	1476
1473	jag	1477	LISTEN(ol_color,&ocoll)
1646	jag	1478	LISTEN(ol_fixed,&fxl)
		1479	LISTEN(ol_snap_style,&sdl);
1468	jag	1480
1470	jag	1481	separator* seps [] = {&separators.main, &separators.dp0, &separators.dp1};
		1482	const char* sepsn [] = {"main", "dp0", "dp1"};
		1483	for (int i = 0; i < 3; ++i) {
		1484	separator& si = *seps[i];
		1485	si.set_name (sepsn[i]);
		1486	}
1465	jag	1487
1941	jag	1488	for (int i = 0; i < 17; ++i) {
		1489	vector<widget*>& vw = tab_members[cb_tabs[i]];
964	jag	1490	int n = numw[i];
		1491	widget** wmi = wmap[i];
		1492	for (int m = 0; m < n; ++m) {
		1493	vw.push_back (wmi[m]);
1748	jag	1494	#ifdef __WIDGET_MOVE__
		1495	wmi[m]->set_moveable(1); // to move item
		1496	#endif
964	jag	1497	}
1465	jag	1498	vw.push_back (&separators.main);
964	jag	1499	}
1684	jag	1500
1619	jag	1501	sp_voice_volume.set ("Volume", 0.001f, -MILLION, MILLION, &vvl);
1695	jag	1502	sp_drone_master_vol.set ("Master volume", 0.001f, -MILLION, MILLION, &dmvol);
2039	jag	1503	masvol0.set_state (1);
2102	jag	1504	sp_drone_master_vol.lim = &masvol0;
		1505
1695	jag	1506	sp_drone_vol.set ("Volume", 0.01f, -MILLION, MILLION, &dvol);
1552	jag	1507	sp_drone_vol.set_value (0.0f);
964	jag	1508
		1509	l_octave_shift.set_text ("Octave Shift");
1015	jag	1510	ab_octave_down.set_dir (arrow_button::left);
1646	jag	1511	ab_octave_up.set_dir (arrow_button::right);
		1512
		1513	#ifndef __WIDGET_MOVE__
964	jag	1514	ab_octave_down.set_listener (&osl);
		1515	ab_octave_up.set_listener (&osl);
1646	jag	1516	#endif
964	jag	1517	int arrow_size = 24;
		1518	ab_octave_up.set_size (arrow_size);
		1519	ab_octave_down.set_size (arrow_size);
1472	jag	1520	sp_octave_shift_bpm.set ("BPM", 1, 0.0f, MILLION, &osl);
964	jag	1521
1472	jag	1522	sp_gater_bpm.set ("BPM", 1, 0, MILLION, &gbl);
964	jag	1523	ol_gater_style.set_text (" style = ");
		1524	ol_gater_style.set_listener (&gater_style_lis);
1472	jag	1525
2157	jag	1526	l_gater.set_text ("Beater");
964	jag	1527	l_gater.add_child (&sp_gater_bpm);
		1528	l_gater.add_child (&ol_gater_style);
		1529
1403	jag	1530	#ifdef __WIDGET_MOVE__
		1531
2239	jag	1532	int wek [] = {8, 14, 2, 3, 7, 3, 4, 4, 6};
1403	jag	1533	for (int i = 0, j = 4, k = 0; i < 9; ++i) {
		1534	k = wek[i];
1950	jag	1535	makehier (&wedtools[j], k);
1403	jag	1536	j += k;
		1537	}
		1538
1828	jag	1539	widget* osn [] = {&l_octave_shift, &ab_octave_down, &ab_octave_up, &b_abort_octave_shift, &sp_octave_shift_bpm, 0};
1682	jag	1540	makefam (osn, 5);
964	jag	1541
1828	jag	1542	widget* brs [] = {&ol_set_range, &b_default_to_selected, &b_default_to_all, &b_selected_to_all, 0};
		1543	makehier (brs);
964	jag	1544
1828	jag	1545	widget* aht [] = {&l_adjust_height, &b_adjust_range_height, &b_adjust_board_height, 0};
		1546	makehier (aht);
964	jag	1547
1828	jag	1548	widget* arb [] = {&l_adjust_range, &b_adjust_range_left, &b_adjust_range_right, &b_adjust_range_both, 0};
		1549	makehier (arb);
964	jag	1550
1828	jag	1551	widget* brm [] = {&l_ran_mod, &b_rm_pause_resume, &b_rm_start_all, &b_rm_stop_all, &b_rm_toggle, 0};
		1552	makehier (brm);
964	jag	1553
1828	jag	1554	widget* brc [] = {&ol_change_note, &b_change_note_left, &b_change_note_right, &b_change_note_both, &ol_change_note_style, 0};
		1555	makehier (brc);
964	jag	1556
1828	jag	1557	widget* wmmv [] = {&cb_modulation, &cb_visual, &cb_motion, &cb_chuck, &cb_defaults, 0};
		1558	makehier (wmmv);
1465	jag	1559
1828	jag	1560	widget* dpw0 [] = {&cb_show_vel, &cb_show_accel, &cb_show_gravity, &cb_show_anchors, 0};
		1561	makehier (dpw0);
964	jag	1562
2060	jag	1563	widget* dpw3 [] = {&sp_dam_depth, &sp_dfm_depth, &sp_dam_bpm, &sp_dfm_bpm, &damd0, &dfmd0, 0};
1828	jag	1564	makehier (dpw3);
964	jag	1565
1893	jag	1566	widget* dpw4 [] = { &sp_drones_per_min, &dpl, &sp_drone_lifetime, &sp_orbit_insertion_time, 0};
1828	jag	1567	makehier (dpw4);
964	jag	1568
1828	jag	1569	widget* dpw5 [] = {&sp_change_drone_trail_length, &sp_change_drone_handle_size, 0};
		1570	makehier (dpw5);
964	jag	1571
1828	jag	1572	widget* dpw6 [] = {&ol_set_unset_toggle, &b_toggle, &b_set, &b_unset, 0};
		1573	makehier (dpw6);
964	jag	1574
1827	jag	1575	widget* rmw [] = {&cb_mod_ran, &ol_fixed, &sp_ran_mod_width, &sp_ran_mod_width_bpm, &sp_ran_mod_height, &sp_ran_mod_height_bpm, 0};
		1576	makehier (rmw);
1403	jag	1577
1827	jag	1578	widget* dpw [] = {&ol_create_this,&dp_orient,&dp_numdrones,&dp_bpm1, 0};
		1579	makehier (dpw);
1403	jag	1580
1828	jag	1581	widget *rcw [] = {&ol_create_this, &sp_mesh_rows, &sp_mesh_cols, &cb_sync_rows_cols, &b_flip_rows_cols, 0};
1682	jag	1582	makehier (rcw, 5);
1828	jag	1583	widget* dow [] = {&l_drone_order, &ol_drone_order, &ol_mesh_point, &f_mesh_xy, 0};
1682	jag	1584	makehier (dow, 4);
1828	jag	1585	widget* mshw [] = {&sp_mesh_rows, &sp_mesh_dur, &l_use_drone_pend, 0,};
1682	jag	1586	makehier (mshw, 3);
1827	jag	1587	sp_mesh_rows.add_child (&l_drone_order);
1828	jag	1588	widget* dpp [] = {&sp_drones_per_pend, &b_set_to_mesh_rows, &b_set_to_mesh_cols, 0};
		1589	makehier (dpp);
		1590	widget* apt [] = {&l_apply_to, &cb_am_bpm, &cb_fm_bpm, 0};
		1591	makehier (apt);
		1592	widget* udp [] = {&l_use_drone_pend, &sp_drones_per_pend, &l_apply_to, 0};
		1593	makehier (udp);
		1594	widget* wsp [] = {&sp_snap_left, &sp_snap_right, &ol_snap_style, 0};
		1595	makehier (wsp);
		1596	widget* wda [] = {&l_drone_arrow, &b_arrow_reset, &dronearrow.neck, &dronearrow.shoulder.width, &dronearrow.shoulder.position, &dronearrow.cap, &dronearrow.decap, 0};
		1597	makehier (wda);
1778	jag	1598	widget* wda2 [] = {
		1599	&dronearrowdefaults.lbl,
		1600	&dronearrowdefaults.arrow,
1804	jag	1601	&dronearrowdefaults.neck,
1778	jag	1602	&dronearrowdefaults.shoulder.width,
		1603	&dronearrowdefaults.shoulder.position,
		1604	&dronearrowdefaults.cap,
1828	jag	1605	0,
1778	jag	1606	};
1828	jag	1607	makehier (wda2);
		1608	widget* wbo [] = {&sp_bounces, &sp_rebound, &ol_bounce_style, 0};
		1609	makehier (wbo);
1827	jag	1610	widget* wconn [] = {&b_disconnect, &b_connect, &lf_conn_steps, &cb_conn_wrap, &trackcon, 0};
		1611	makehier (wconn);
1828	jag	1612	widget* wsl [] = {&s_red_min, &s_red_max, &s_green_min, &s_green_max, &s_blue_min, &s_blue_max, &ol_color, 0};
		1613	makehier (wsl);
1465	jag	1614
1548	jag	1615	{
		1616	widget* w [] = {
		1617	&b_select_all_drones,
		1618	&b_invert_drone_selection,
		1619	&b_select_attractees,
		1620	&b_select_attractors,
1813	jag	1621	&b_select_launchers,
1548	jag	1622	&b_select_tracked_drones,
1828	jag	1623	&sp_browse_drone, 0,
1548	jag	1624	};
1828	jag	1625	makehier (w);
1548	jag	1626	}
		1627
		1628	{
		1629	widget* w[] = {
1674	jag	1630	&ol_add_wand,
1548	jag	1631	&b_delete_drones,
1984	jag	1632	&moverailstrafe,
2011	jag	1633	&b_rotate_drones,
1548	jag	1634	&b_scale_drones,
1666	jag	1635	&b_set_xform_center,
1548	jag	1636	&b_freeze_drones,
1828	jag	1637	&b_thaw_drones, 0,
1557	jag	1638	};
1828	jag	1639	makehier (w);
1557	jag	1640	}
		1641
		1642	{
		1643	widget* w[] = {
1548	jag	1644	&b_mute,
		1645	&b_unmute,
1557	jag	1646	&drone2noise,
		1647	&noise2drone,
1828	jag	1648	&gabt, 0,
1548	jag	1649	};
1828	jag	1650	makehier (w);
1548	jag	1651	}
		1652
1557	jag	1653	{
		1654	widget* w[] = {
		1655	&b_launch_drones,
		1656	&b_stop_launching_drones,
1983	jag	1657	&balloon,
		1658	&chuck,
1557	jag	1659	&b_orbit_selected_drones,
		1660	&b_track_drones,
		1661	&b_set_targets,
1828	jag	1662	&b_clear_targets, 0,
1557	jag	1663	};
1983	jag	1664	makehier(w);
1557	jag	1665	}
1552	jag	1666
1674	jag	1667	{
2106	jag	1668	widget* w[] = {&riset, &fallt, &lifetime, &ddpm, &ddpl, &gens, 0};
1828	jag	1669	makehier (w);
1676	jag	1670	}
		1671
1677	jag	1672	{
1851	jag	1673
		1674	widget* w[] = {&handlesize, &trailsize, 0};
		1675	makehier (w);
		1676	}
		1677
		1678	{
1828	jag	1679	widget* w[] = {&mortalize, &reincarnate, &immortalize, 0};
		1680	makehier (w);
1677	jag	1681	}
		1682
1760	jag	1683	{
1828	jag	1684	widget* w[] = {&chflip, &chtog, &chspeed, &chlen, &chtrail, &chapt, &choutline, &chautoresettrails, 0};
		1685	makehier (w);
1760	jag	1686	}
		1687
2049	jag	1688	{
		1689	widget* w[] = {
		1690	&l_draw_ball,
		1691	&cb_draw_ball_position,
		1692	&cb_draw_ball_heading,
		1693	&cb_draw_ball_trails,
		1694
		1695	};
		1696	makehier(w);
		1697	}
		1698
		1699	{
		1700	widget* w[] = {
		1701	&cb_draw_boxes,
		1702	&cb_fill_boxes,
		1703	&texture,
		1704	&text_ure,
		1705	&texstep,
		1706
		1707	};
		1708	makehier(w);
		1709	}
		1710	{
		1711	widget* w[] = {
		1712	&abm_left,
		1713	&abm_right,
		1714	&abm_up,
		1715	&abm_down,
		1716	&bm_zoom_in,
		1717	&bm_zoom_out,
		1718
		1719	};
		1720	makehier(w);
		1721	}
		1722	{
		1723	widget* w[] = {
		1724	&cb_draw_notes,
		1725	&cb_label_notes,
		1726	&cb_label_hz_vol,
		1727
		1728	};
		1729	makehier(w);
		1730	}
		1731
2060	jag	1732
		1733	{
		1734	widget* w[] = {
		1735	&am2fm,
		1736	&fm2am,
		1737	&sp_dam_pos,
		1738	&sp_dfm_pos,
		1739
		1740	};
		1741	makehier(w);
		1742	}
		1743
1557	jag	1744	/*
		1745	{
		1746	widget* w[] = {
		1747	};
2049	jag	1748	makehier(w);
1557	jag	1749	}
		1750	*/
		1751
1403	jag	1752	#endif
		1753
1452	jag	1754	sp_range.set ("Range", 1, &ranl);
1755	jag	1755	sp_range.draw_more = sp_range.variance.ui = 0;
964	jag	1756
		1757	const char* rms [] = {"Width", "BPM", "Height", "BPM"};
		1758	spinner<float>* srm [] = {&sp_ran_mod_width, &sp_ran_mod_width_bpm, &sp_ran_mod_height, &sp_ran_mod_height_bpm};
		1759	int srl [] = {-MILLION, 0, -MILLION, 0};
		1760	int sro[] = {mouse_slider_listener::X, mouse_slider_listener::X, mouse_slider_listener::Y, mouse_slider_listener::Y};
1452	jag	1761	change_listener<field>* rlis[] = {&rmwl, &rmwbl, &rmhl, &rmhbl};
964	jag	1762	for (int i = 0; i < 4; ++i) {
		1763	spinner<float>* sp = srm[i];
1452	jag	1764	sp->set (rms[i], 1.0f, srl[i], MILLION, rlis[i]);
964	jag	1765	sp->orient = sro[i];
		1766	}
		1767
		1768	const char* rde [] = {"Default width", "Default height"};
		1769	spinner<int>* sde [] = {&sp_default_width, &sp_default_height};
		1770	int msd [] = {mouse_slider_listener::X, mouse_slider_listener::Y};
		1771	for (int i = 0; i < 2; ++i) {
		1772	spinner<int>& si = *sde[i];
1452	jag	1773	si.set (rde[i], 1, 0, MILLION, &rdel);
964	jag	1774	si.orient = msd[i];
1755	jag	1775	si.draw_more = si.variance.ui = 0;
964	jag	1776	}
		1777
		1778	// drones
		1779	//
1472	jag	1780	sp_change_drone_trail_length.set ("Trail length", 1, &dtl);
1060	jag	1781	sp_change_drone_trail_length.set_value (0);
964	jag	1782
1472	jag	1783	sp_change_drone_handle_size.set ("Handle size", 1, &dhsl);
		1784	sp_change_drone_handle_size.set_value (0);
964	jag	1785
1472	jag	1786	sp_change_drone_vel.set ("Velocity", 0.1f, -MILLION, +MILLION, &dvl);
1634	jag	1787	sp_change_drone_accel.set ("Acceleration", 0.01f, -MILLION, +MILLION, &dal);
2032	jag	1788	sp_change_drone_vel.lim = &vel0;
		1789	sp_change_drone_accel.lim = &accel0;
964	jag	1790
1634	jag	1791	sp_rotate_drone_vel.set ("Rotate velocity", 1.0f, &rdvl);
2077	jag	1792	rotaccel.set ("Rotate acceleration", 1.0f, &rdvl);
		1793	sp_rotate_drone_vel.f_value.id = 0;
		1794	rotaccel.f_value.id = 1;
2078	jag	1795	static const int rotdirsize = 12;
		1796	rdvel.set_size (rotdirsize);
		1797	rdaccel.set_size (rotdirsize);
964	jag	1798
1892	jag	1799	sp_drones_per_min.set ("Launches per minute", 1.0f, &dpml);
1893	jag	1800	dpl.set ("Drones per launch", 1.0f, &dpll);
1634	jag	1801	sp_drone_lifetime.set ("Lifetime", 0.01f, &dlf);
964	jag	1802
1634	jag	1803	sp_orbit_insertion_time.set ("Orbit insert time", 0.01f, &oil);
964	jag	1804
1472	jag	1805	sp_browse_drone.set ("Browse drone", 1, &brwdl);
1755	jag	1806	sp_browse_drone.draw_more = sp_browse_drone.variance.ui = 0;
964	jag	1807
1098	jag	1808	ol_create_this.set_listener (this);
1096	jag	1809
		1810	dp_orient.set_listener (this);
1598	jag	1811	dp_numdrones.set ("Number of Drones", 1, 2, MILLION, this);
1477	jag	1812	dp_bpm1.set ("BPM", 1.0f, 0, MILLION, this);
1096	jag	1813
964	jag	1814	spinner<int>* msh [] = {&sp_mesh_rows, &sp_mesh_cols};
		1815	static const char* const mlb [] = {"Rows", "Columns"};
		1816	for (int i = 0; i < 2; ++i) {
		1817	spinner<int>* sp = msh[i];
1485	jag	1818	sp->set (mlb[i], 1, 2, MILLION, this, 0);
1040	jag	1819	sp->set_value (2);
964	jag	1820	sp->orient = mouse_slider_listener::NONE;
1755	jag	1821	sp->draw_more = sp->variance.ui = 0;
964	jag	1822	}
1472	jag	1823
1120	jag	1824	cb_sync_rows_cols.set_text ("Sync");
1472	jag	1825
1037	jag	1826	l_drone_order.set_text ("Create drones");
		1827	ol_drone_order.set_listener (this);
		1828	ol_mesh_point.set_listener (this);
1096	jag	1829
1037	jag	1830	f_mesh_xy.set_text ("0 0");
1052	jag	1831	f_mesh_xy.change_lsnr = this;
1037	jag	1832
1764	jag	1833	sp_mesh_dur.set (0.1f, 0, MILLION, this);
1557	jag	1834	sp_mesh_dur.set_value (1.0f);
1677	jag	1835	sp_mesh_dur.set_text ("In", SECONDS);
1046	jag	1836
964	jag	1837	ol_set_unset_toggle.set_listener (this);
		1838
		1839	ol_am_style.set_listener (&am_style_lis); // voice am
		1840	ol_fm_style.set_listener (&fm_style_lis); // voice fm
		1841
		1842	l_phrase_position.set_text ("Phrase position ");
		1843	s_phrase_position.set_limits (0.0f, 1.0f);
1646	jag	1844
		1845	#ifndef __WIDGET_MOVE__
		1846	ol_create_this.option.set_listener (&dcl);
		1847	cb_sync_rows_cols.set_listener (&dcl);
964	jag	1848	s_phrase_position.set_listener (this);
1646	jag	1849	b_key_to_pitch_at_cursor.set_listener (&miscl);
		1850	#endif
964	jag	1851
1400	jag	1852	const char* lrs [] = {"Adjust Height?", "Adjust?", "Modulation?", "Change Note"};
1397	jag	1853	label* lrm [] = {&l_adjust_height, &l_adjust_range, &l_ran_mod, &ol_change_note.option};
1235	jag	1854	for (int i = 0; i < 4; ++i) lrm[i]->set_text (lrs[i]);
964	jag	1855
		1856	ol_set_range.set_listener (&sral);
		1857
		1858	const char* snp [] = {"Snap left", "Snap right"};
		1859	spinner<float>* snsp [] = {&sp_snap_left, &sp_snap_right};
1804	jag	1860	float snv [] = {din0.dinfo.snap.left, din0.dinfo.snap.right};
964	jag	1861	for (int i = 0; i < 2; ++i) {
		1862	spinner<float>* si = snsp[i];
1472	jag	1863	si->set (snp[i], 0.01f, &sdl);
964	jag	1864	si->draw_more = 0;
1755	jag	1865	si->variance.ui = 0;
1804	jag	1866	si->set_value (snv[i]);
		1867	si->orient = mouse_slider_listener::X;
964	jag	1868	}
		1869
1512	jag	1870	l_drone_arrow.set_text ("Drone Arrow");
1776	jag	1871	dronearrowdefaults.lbl.set_text ("Drone Arrow");
1836	jag	1872	spinner<float>* das [] = {&dronearrow.shoulder.position, &dronearrow.neck, &dronearrow.shoulder.width};
		1873	spinner2<float>* das2 [] = {&dronearrowdefaults.shoulder.position, &dronearrowdefaults.neck, &dronearrowdefaults.shoulder.width};
		1874	const char* dasl [] = {"Shoulder Position", "Neck", "Shoulder Width"};
		1875	float vals [] = {drone::arrowt::U, drone::arrowt::K, drone::arrowt::V};
1766	jag	1876	for (int i = 0; i < 3; ++i) {
964	jag	1877	spinner<float>& si = *das[i];
1776	jag	1878	spinner2<float>& si2 = *das2[i];
1768	jag	1879	si.set (dasl[i], 0.1f, -MILLION, MILLION, &arrowl);
1778	jag	1880	si2.set (dasl[i], 0.1f, -MILLION, MILLION, &defarrowl, 0);
1776	jag	1881	si2.set_value (vals[i]);
1779	jag	1882	si2.orient = mouse_slider_listener::NONE;
964	jag	1883	}
1836	jag	1884	for (int i = 0; i < 2; ++i) {
		1885	spinner<float>& si = *das[i];
		1886	spinner2<float>& si2 = *das2[i];
		1887	si.updowndecinc ();
		1888	si2.updowndecinc ();
		1889	}
1778	jag	1890	dronearrowdefaults.cap.set_listener (&defarrowl);
		1891	dronearrowdefaults.arrow.calc ();
964	jag	1892
1120	jag	1893	cb_scope.set_text ("Show oscilloscope");
964	jag	1894	cb_scope.set_listener (&scol);
1472	jag	1895	sp_scope_height.set ("Height", 1, 0, MILLION, &scol);
1924	jag	1896	sp_scope_samples.set ("Samples", 1, 1, MILLION, &scol);
1921	jag	1897	scopacity.set ("Opacity", 0.01f, 0.0f, 1.0f, &scol);
964	jag	1898
		1899	l_tap_bpm.set_text ("Tap BPM");
		1900	checkbutton* cb_tars [] = {&cb_am, &cb_fm, &cb_gater, &cb_octave_shift, &cb_auto_reset};
2157	jag	1901	static const char* const cb_text [] = {"AM", "FM", "Beater", "Octave Shift", "Auto reset"};
964	jag	1902
		1903	cb_auto_reset.turn_on ();
		1904	for (int i = 0; i < 5; ++i) {
		1905	checkbutton* cbi = cb_tars[i];
1472	jag	1906	cbi->set (cb_text[i], &tbl);
964	jag	1907	l_tap_bpm.add_child (cbi);
		1908	}
1647	jag	1909	td_tap_display.set_listener (&tbl);
1472	jag	1910
964	jag	1911	l_tap_bpm.add_child (&td_tap_display);
		1912	l_tap_bpm.add_child (&l_tap_bpm_value);
		1913
		1914	const char* bpmstr [] = {"os", "fm", "am", "gr"};
		1915	spinner<float>* bpmspn [] = {&sp_octave_shift_bpm, &sp_fm_bpm, &sp_am_bpm, &sp_gater_bpm};
		1916	for (int i = 0; i < 4; ++i) bpm_map[bpmstr[i]] = bpmspn[i];
		1917
		1918	// editor tools
		1919	arrow_button* enav[] = {&abe_left, &abe_down, &abe_right, &abe_up};
		1920	int edirs [] = {arrow_button::left, arrow_button::down, arrow_button::right, arrow_button::up};
		1921	for (int i = 0; i < 4; ++i) {
		1922	arrow_button* ab = enav[i];
1015	jag	1923	ab->set_dir (edirs[i]);
964	jag	1924	}
		1925
		1926	l_snap.set_text ("Snap?");
		1927	l_library.set_text ("Library");
		1928	lf_curve_name.set_label ("Curve name");
1507	jag	1929	lf_curve_name.fld.expr = 0;
1117	jag	1930	l_capture.set_text ("Mouse capture");
1647	jag	1931
964	jag	1932	ol_mirror_tangents.set_listener (this);
		1933	ol_curve_style.set_listener (this);
		1934
1472	jag	1935	sp_curve_rpm.set ("RPM", 1.0f, 0.0f, MILLION, &col);
		1936	sp_curve_rpm.set_value (0.0f);
2103	jag	1937
1950	jag	1938	sp_curve_every.set (1.0f, 0, MILLION, &col);
1959	jag	1939	sp_curve_every.set_listener (&col, 2); // variance
1950	jag	1940	sp_curve_every.set_text ("Every", DEGREES);
1117	jag	1941
1647	jag	1942	#ifndef __WIDGET_MOVE__
964	jag	1943	cb_show_waveform_samples.set_listener (&col);
1647	jag	1944	#endif
1472	jag	1945
2039	jag	1946	crvwav.hz.set ("Hz", 1.0f, 0.01f, MILLION, &col);
		1947	crvwav.periods.set ("Cycles", 1, 1, MILLION, &col);
		1948	crvwav.time.set ("Time", 1.0f, 1, MILLION, &col);
		1949	crvwav.hz.orient = crvwav.periods.orient = crvwav.time.orient = mouse_slider_listener::NONE;
1472	jag	1950
		1951	sp_curve_limit.set ("Curve roughness", 0.001f, 0.001f, MILLION, &col);
964	jag	1952
		1953	// button labels
		1954	const char* labels [] = {
		1955	"Menu",
		1956	"Microtonal Keyboard",
1368	jag	1957	"Keyboard Keyboard",
964	jag	1958	"Mondrian",
		1959	"Binaural Drones",
		1960	"Waveform",
		1961	"Drone Waveform",
		1962	"Drone Modulation",
		1963	"Voice Modulation",
2157	jag	1964	"Beater",
964	jag	1965	"Waveform",
		1966	"Attack",
		1967	"Decay",
		1968	"MIDI Velocity",
		1969	"Delays",
		1970	"Octave Shift",
		1971	"Compressor",
		1972	"Morse Code",
		1973	"Exit DIN Is Noise",
		1974	"Show anchors",
1984	jag	1975	" Move",
964	jag	1976	"Delete",
		1977	"Select all",
		1978	"Invert selected",
		1979	"Record a phrase",
		1980	"Clear phrase",
		1981	"Default to Selected",
		1982	"Default to all",
1403	jag	1983	"Selected to all",
964	jag	1984	"Set key to pitch at cursor",
		1985	"Insert vertex",
		1986	"Delete vertex",
		1987	"Fold tangents",
		1988	"Undo",
		1989	"Redo",
		1990	"Copy",
2340	jag	1991	" Paste",
964	jag	1992	"Draw & replace curve",
		1993	"Add",
		1994	"Replace",
		1995	"Delete",
		1996	"Start",
		1997	"Assign",
		1998	"Label vertices",
2214	jag	1999	"Selection only",
964	jag	2000	"Show waveform",
		2001	"Pick curve",
		2002	"Stop",
2126	jag	2003	"Draw curve",
964	jag	2004	"Clear",
		2005	"Record",
		2006	"Select attractees",
		2007	"Select attractors",
		2008	"Orbit",
		2009	"Show velocity",
		2010	"Show acceleration",
1888	jag	2011	"Show gravity",
1827	jag	2012	"Balloon",
964	jag	2013	"Launch",
		2014	"Stop launch",
		2015	"Track",
		2016	"Select tracked",
		2017	"Waveform",
		2018	"Attack",
		2019	"Decay",
		2020	"Add ",
		2021	"Move balls",
		2022	"Delete selected balls",
		2023	"Delete all balls",
		2024	"Select all balls",
		2025	"Invert ball selection",
		2026	"Select balls in box",
		2027	"Split box horizontally",
		2028	"Split box vertically",
		2029	"Delete box",
		2030	"Freeze balls",
		2031	"Thaw balls",
		2032	"Turn Off UI",
		2033	"Set targets",
		2034	"Clear targets",
		2035	"Clear modulations",
		2036	"Modulate balls up",
		2037	"Modulate balls down",
		2038	"Create binaural drones on the notes of the scale",
		2039	"Create binaural drones using parameters above",
		2040	"Waveform",
		2041	"Close octave",
		2042	"Auto-change ball direction clockwise",
		2043	"Auto-change ball direction anti-clockwise",
		2044	"Stop auto-changing ball direction",
		2045	"Flip ball direction",
		2046	"Randomize box color",
		2047	"Resize separation",
		2048	"Add / Remove slits",
		2049	"Toggle wreckers",
		2050	"Toggle healers",
		2051	"Toggle bouncers",
		2052	"Healers <> Wreckers",
		2053	"Select wreckers",
		2054	"Select healers",
		2055	"Remove slits on edge",
		2056	"Toggle slit animation",
		2057	"Auto adjust voices",
		2058	"Draw boxes",
		2059	"Fill boxes",
		2060	"Draw notes",
		2061	"Label notes",
		2062	"Position",
		2063	"Make note grid",
		2064	"Make N x N grid",
		2065	"Delete all boxes",
		2066	"Select launchers",
1812	jag	2067	"Select on Creation",
964	jag	2068	"Freeze",
		2069	"Thaw",
		2070	"Mark segments",
		2071	"Auto split box",
		2072	"Auto delete box",
		2073	"Speed",
		2074	"Turn",
		2075	"Teleport",
		2076	"Heading",
		2077	"Trails",
		2078	"Draw ball:",
		2079	"Sync",
		2080	"Sync",
		2081	"Clone",
		2082	"Clone can clone too",
		2083	"Transform",
		2084	"Label pitch and volume",
		2085	"All",
		2086	"None",
		2087	"Invert",
		2088	"Delete",
		2089	"Sync",
		2090	"Modulate",
		2091	"Select",
		2092	"Flip",
		2093	"All",
		2094	"Left",
		2095	"Right",
		2096	"Both",
		2097	"Modulate",
		2098	"Mark",
		2099	"Pause/Resume",
		2100	"Start",
		2101	"Stop",
		2102	"Toggle",
1629	jag	2103	"Get",
964	jag	2104	"Range modulation",
		2105	"Selected",
1235	jag	2106	"Left",
		2107	"Right",
964	jag	2108	"Set",
		2109	"Unset",
1026	jag	2110	"Toggle",
1049	jag	2111	"Range Width & Height",
1071	jag	2112	"Flip",
1551	jag	2113	"Overlay Instrument/Editor",
1104	jag	2114	"Range Pitch & Volume",
1128	jag	2115	"Swap",
1137	jag	2116	"Overlay pitch distribution",
1188	jag	2117	"Overlay volume distributon",
		2118	"Point Modulation",
1320	jag	2119	"Both",
		2120	"AM BPM",
		2121	"FM BPM",
		2122	"Set to Rows",
1323	jag	2123	"Set to Columns",
1423	jag	2124	"Noise Interpolator",
		2125	"Ball triggers note <> Ball triggers noise",
1467	jag	2126	"Scale",
		2127	"Rotate",
		2128	"Draw mesh outline",
1465	jag	2129	"Modulation",
		2130	"Motion",
		2131	"Visual",
1467	jag	2132	"Connect",
1469	jag	2133	"Disconnect",
		2134	"Wrap",
1475	jag	2135	"Drone Pendulum",
1481	jag	2136	"Abort",
1499	jag	2137	"Close",
1547	jag	2138	"Reset",
		2139	"Mute",
1557	jag	2140	"Unmute",
		2141	"Drone > Noise",
		2142	"Noise > Drone",
1677	jag	2143	"Find center",
1675	jag	2144	"Defaults",
1677	jag	2145	"Mortalize",
		2146	"Reincarnate",
		2147	"Immortalize",
1695	jag	2148	"Chuck",
		2149	"Chuck",
		2150	"Flip",
1697	jag	2151	"Toggle",
1748	jag	2152	"Draw chuck outline",
		2153	"Auto reset trails",
1768	jag	2154	"Cap",
1776	jag	2155	"Decap",
		2156	"Cap",
1797	jag	2157	"Track",
1805	jag	2158	"Auto rotate",
		2159	"Auto flip",
1809	jag	2160	"-ve",
1818	jag	2161	"Randomize",
		2162	"0",
		2163	"0",
1836	jag	2164	"Sync",
1871	jag	2165	"Reset every tick",
		2166	"Reset every tick",
1883	jag	2167	"Drone velocity modulation",
1950	jag	2168	"X",
		2169	"Y",
		2170	"Both",
		2171	"None",
1948	jag	2172	"Set AM BPM to FM BPM",
		2173	"Set FM BPM to AM BPM",
		2174	"Flip",
1950	jag	2175	"Autoflip",
		2176	"Reset",
1970	jag	2177	"Auto pause",
1998	jag	2178	"0",
2038	jag	2179	"0",
		2180	"0",
2049	jag	2181	"Texture",
2124	jag	2182	"Size tangent",
2126	jag	2183	"Draw vertices & tangents",
2206	jag	2184	"Track",
2212	jag	2185	"View too",
2219	jag	2186	"Draw",
		2187	"Draw cursor",
		2188	"Pin / Unpin",
2276	jag	2189	"0",
1695	jag	2190	// next label
964	jag	2191	};
		2192
		2193	button* buttons [] = {
		2194	&b_menu,
		2195	&b_microtonal_keyboard,
		2196	&b_keyboard_keyboard,
		2197	&b_mondrian,
		2198	&b_binaural_drones,
		2199	&b_microtonal_keyboard_waveform,
		2200	&b_drone_waveform,
		2201	&b_drone_modulation,
		2202	&b_voice_modulation,
		2203	&b_gater,
		2204	&b_keyboard_keyboard_waveform,
		2205	&b_attack,
		2206	&b_decay,
		2207	&b_midi_velocity,
		2208	&b_delays,
		2209	&b_octave_shift,
		2210	&b_compressor,
		2211	&b_morse_code,
		2212	&b_exit_din,
		2213	&cb_show_anchors,
1984	jag	2214	&moverailstrafe.option,
964	jag	2215	&b_delete_drones,
		2216	&b_select_all_drones,
		2217	&b_invert_drone_selection,
		2218	&b_record_phrase,
		2219	&b_clear_phrases,
1403	jag	2220	&b_default_to_selected,
		2221	&b_default_to_all,
964	jag	2222	&b_selected_to_all,
		2223	&b_key_to_pitch_at_cursor,
		2224	&b_insert_vertex,
		2225	&b_delete_vertex,
		2226	&b_fold_tangents,
		2227	&b_undo,
		2228	&b_redo,
		2229	&b_copy,
2340	jag	2230	&ol_paste.option,
964	jag	2231	&b_draw_replacement_curve,
		2232	&b_add_curve,
		2233	&b_replace_curve,
		2234	&b_delete_curve,
		2235	&b_start_capture,
		2236	&b_assign_capture,
		2237	&cb_label_vertices,
1128	jag	2238	&cb_selection_only,
964	jag	2239	&cb_show_waveform_samples,
		2240	&b_pick_curve,
		2241	&b_stop_rotating,
		2242	&cb_draw_curve,
		2243	&b_clear_record,
		2244	&cb_record,
		2245	&b_select_attractees,
		2246	&b_select_attractors,
		2247	&b_orbit_selected_drones,
		2248	&cb_show_vel,
		2249	&cb_show_accel,
		2250	&cb_show_gravity,
1827	jag	2251	&balloon,
964	jag	2252	&b_launch_drones,
		2253	&b_stop_launching_drones,
		2254	&b_track_drones,
		2255	&b_select_tracked_drones,
		2256	&b_mondrian_waveform,
		2257	&b_mondrian_attack,
		2258	&b_mondrian_decay,
		2259	&b_add_balls,
		2260	&b_move_selected_balls,
		2261	&b_delete_selected_targets,
		2262	&b_delete_all_targets,
		2263	&b_select_all_targets,
		2264	&b_invert_selected_targets,
		2265	&b_select_targets_in_box,
		2266	&b_split_horizontal,
		2267	&b_split_vertical,
		2268	&b_delete_box,
		2269	&b_freeze_balls,
		2270	&b_thaw_balls,
		2271	&b_turn_off_ui,
		2272	&b_set_targets,
		2273	&b_clear_targets,
		2274	&b_clear_modulations,
		2275	&b_modulate_balls_up,
		2276	&b_modulate_balls_down,
		2277	&b_create_binaurals_on_notes,
		2278	&b_create_binaurals_from_pitch,
		2279	&b_binaural_drones_waveform,
		2280	&cb_close_octave,
		2281	&b_auto_change_direction_clockwise,
		2282	&b_auto_change_direction_anti_clockwise,
		2283	&b_stop_auto_changing_direction,
		2284	&b_flip_direction,
		2285	&b_make_random_color,
		2286	&cb_resize_separation,
		2287	&b_add_remove_slits,
		2288	&b_toggle_wreckers,
		2289	&b_toggle_healers,
		2290	&b_toggle_bouncers,
		2291	&b_switch_ball_type,
		2292	&b_select_wreckers,
		2293	&b_select_healers,
		2294	&b_remove_slits_on_edge,
		2295	&b_toggle_slit_anim,
		2296	&cb_mondrian_auto_adjust_voices,
		2297	&cb_draw_boxes,
		2298	&cb_fill_boxes,
		2299	&cb_draw_notes,
		2300	&cb_label_notes,
		2301	&cb_draw_ball_position,
		2302	&b_make_note_grid,
		2303	&b_make_nxn_grid,
		2304	&b_delete_all_boxes,
		2305	&b_select_launchers,
1812	jag	2306	&seloncre,
964	jag	2307	&b_freeze_drones,
		2308	&b_thaw_drones,
		2309	&cb_mark_segments,
		2310	&cb_auto_split_box,
		2311	&cb_auto_delete_box,
		2312	&cb_speed,
		2313	&cb_turn,
		2314	&cb_teleport,
		2315	&cb_draw_ball_heading,
		2316	&cb_draw_ball_trails,
		2317	&l_draw_ball,
		2318	&cb_turn_sync,
		2319	&cb_speed_sync,
		2320	&cb_clone,
		2321	&cb_clone_can_clone,
		2322	&cb_transform,
		2323	&cb_label_hz_vol,
		2324	&bbd_select_all,
		2325	&bbd_select_none,
		2326	&bbd_invert_select,
		2327	&bbd_delete,
		2328	&bbd_sync,
		2329	&bbd_modulate,
		2330	&bbd_select2,
		2331	&bbd_flip,
		2332	&b_adjust_board_height,
		2333	&b_adjust_range_left,
		2334	&b_adjust_range_right,
		2335	&b_adjust_range_both,
		2336	&cb_mod_ran,
		2337	&cb_mark_ran,
		2338	&b_rm_pause_resume,
		2339	&b_rm_start_all,
		2340	&b_rm_stop_all,
		2341	&b_rm_toggle,
		2342	&b_get_cur_ran,
		2343	&b_range_modulation,
		2344	&b_adjust_range_height,
		2345	&b_change_note_left,
		2346	&b_change_note_right,
		2347	&b_set,
		2348	&b_unset,
1026	jag	2349	&b_toggle,
1049	jag	2350	&b_range_width_height,
1071	jag	2351	&b_flip_rows_cols,
1551	jag	2352	&cb_overlay,
1104	jag	2353	&b_range_pitch_vol,
1128	jag	2354	&b_swap_curves,
1137	jag	2355	&cb_pitch_dis,
1140	jag	2356	&cb_vol_dis,
1235	jag	2357	&b_point_modulation,
1320	jag	2358	&b_change_note_both,
		2359	&cb_am_bpm,
		2360	&cb_fm_bpm,
		2361	&b_set_to_mesh_rows,
1323	jag	2362	&b_set_to_mesh_cols,
1423	jag	2363	&b_noise_interpolator,
		2364	&b_ball_trig,
1429	jag	2365	&b_scale_drones,
1430	jag	2366	&b_rotate_drones,
1438	jag	2367	&cb_draw_mesh,
1465	jag	2368	&cb_modulation,
		2369	&cb_motion,
1467	jag	2370	&cb_visual,
		2371	&b_connect,
1469	jag	2372	&b_disconnect,
		2373	&cb_conn_wrap,
1475	jag	2374	&b_drone_pend,
1485	jag	2375	&b_abort_octave_shift,
		2376	&b_close,
1514	jag	2377	&b_arrow_reset,
1547	jag	2378	&b_mute,
1557	jag	2379	&b_unmute,
		2380	&drone2noise,
		2381	&noise2drone,
1666	jag	2382	&b_set_xform_center,
1675	jag	2383	&cb_defaults,
1677	jag	2384	&mortalize,
		2385	&reincarnate,
		2386	&immortalize,
1695	jag	2387	&cb_chuck,
		2388	&chuck,
		2389	&chflip,
1697	jag	2390	&chtog,
1748	jag	2391	&choutline,
		2392	&chautoresettrails,
1768	jag	2393	&dronearrow.cap,
		2394	&dronearrow.decap,
1776	jag	2395	&dronearrowdefaults.cap,
1797	jag	2396	&trackcon,
1806	jag	2397	&dva.autorotate.cb,
		2398	&dva.autoflip.cb,
1809	jag	2399	&dva.neg,
		2400	&dva.randomize,
2032	jag	2401	&vel0,
		2402	&accel0,
1836	jag	2403	&dva.sync,
1871	jag	2404	&dva.autorotate.uet.deg,
		2405	&dva.autorotate.uet.tps,
1883	jag	2406	&edlife2vel,
1950	jag	2407	&b_snapx,
		2408	&b_snapy,
		2409	&b_snapboth,
		2410	&b_snapnone,
1948	jag	2411	&am2fm,
		2412	&fm2am,
1950	jag	2413	&ed_flip_rotation,
		2414	&cb_ed_autoflip,
		2415	&ed_autoflip_reset,
1970	jag	2416	&dva.autopause.cb,
1998	jag	2417	&damd0,
		2418	&dfmd0,
2038	jag	2419	&masvol0,
2049	jag	2420	&texture,
2125	jag	2421	&size_tangent,
2126	jag	2422	&draweditables,
2206	jag	2423	&track_phrase_position,
2222	jag	2424	&viewtoo,
		2425	&drawsnaps,
		2426	&drawcursor,
2219	jag	2427	&pinunpin,
2276	jag	2428	&sep0
1677	jag	2429	// next button
		2430	};
964	jag	2431
1970	jag	2432	dlog << "+++ Labeling buttons +++" << endl;
		2433
2276	jag	2434	for (int i = 0; i < 235; ++i) {
964	jag	2435	button* bi = buttons[i];
1120	jag	2436	bi->set_text (labels[i]);
964	jag	2437	}
		2438
1568	jag	2439	dlog << "+++ Labeled buttons +++" << endl;
		2440
1913	jag	2441	am2fm.id = modulator::AM;
		2442	fm2am.id = modulator::FM;
		2443	LISTEN(am2fm, &am2fm2aml)
		2444	LISTEN(fm2am, &am2fm2aml)
		2445
1465	jag	2446	LISTEN(cb_modulation,&cmod)
		2447	LISTEN(cb_motion,&cmot)
		2448	LISTEN(cb_visual,&cvis)
1675	jag	2449	LISTEN(cb_defaults,&cdef)
1695	jag	2450	LISTEN(cb_chuck,&cch)
1768	jag	2451	LISTEN(dronearrow.cap,&arrowl)
		2452	LISTEN(dronearrow.decap,&arrowl)
1647	jag	2453
1768	jag	2454
1647	jag	2455	#ifndef __WIDGET_MOVE__
		2456	LISTEN (b_arrow_reset,&awl)
		2457	#endif
1465	jag	2458
964	jag	2459	ol_select_what.set_text ("L");
		2460	ol_select_rule.set_text (" >= ");
		2461	bdf_value.change_lsnr = &bdl;
		2462	bdf_value.set_text (bdl.val[binaural_drones_listener::GREATER_THAN_EQUAL]);
		2463
1855	jag	2464	sp_bounces.set ("Bounces", 1, -1, MILLION, &bol);
964	jag	2465	ol_bounce_style.set_listener (this);
		2466
2273	jag	2467	sep_bin.set ("Binaural Separation (Hz)", 0.01f, -MILLION, MILLION, &sepbinl);
2272	jag	2468
1865	jag	2469	sp_rebound.set ("Rebound Speed %", 1, 0, MILLION, &rebl);
964	jag	2470
1647	jag	2471	sp_mondrian_min_voices.set ("Min Voices", 1, 1, MILLION, &monl);
964	jag	2472	sp_mondrian_min_voices.draw_more = 0;
1755	jag	2473	sp_mondrian_min_voices.variance.ui = 0;
1647	jag	2474
964	jag	2475	cb_mondrian_auto_adjust_voices.set_listener (&monl);
1647	jag	2476
		2477	sp_mondrian_change_attack_time.set ("Ball attack time", 0.01f, &batl);
		2478	sp_mondrian_change_decay_time.set ("Ball decay time", 0.01f, &bdtl);
		2479
1120	jag	2480	sp_mondrian_change_speed.set_text ("Ball speed");
964	jag	2481	sp_mondrian_change_speed.set_listener (&bsl);
		2482	sp_mondrian_change_speed.set_listener (&monl, 1);
1647	jag	2483
		2484	sp_mondrian_change_dir.set ("Ball direction", 1, &brl);
964	jag	2485	sp_mondrian_change_dir.orient = mouse_slider_listener::X;
1063	jag	2486	sp_mondrian_change_dir.draw_more = 0;
1755	jag	2487	sp_mondrian_change_dir.variance.ui = 0;
1551	jag	2488
1647	jag	2489	sp_mondrian_change_trail_size.set ("Ball trail length", 1, &tll);
		2490	sp_mondrian_change_note_poly_points.set ("Note polygon points", 1, 2, MILLION, &nppl);
		2491	sp_mondrian_change_note_poly_radius.set ("Note polygon radius", 1, 0, MILLION, &nprl);
		2492
		2493	sp_mondrian_change_slit_size.set ("Slit size", 1.0f, &ssl);
		2494
		2495	sp_mondrian_change_slit_anim_time.set ("Slit open/close time", 0.01f, &satl);
		2496	sp_mondrian_change_slit_anim_time.set_value (0.0f);
		2497
1551	jag	2498	sp_mondrian_change_vol.set ("Ball volume", 0.01f, -MILLION, MILLION, &bvl);
964	jag	2499	sp_mondrian_change_vol.set_value (0);
1551	jag	2500
		2501	sp_mondrian_num_boxes.set ("N", 1, 0, MILLION, &monl);
964	jag	2502	sp_mondrian_num_boxes.draw_more = 0;
1755	jag	2503	sp_mondrian_num_boxes.variance.ui = 0;
964	jag	2504
1647	jag	2505	sp_auto_split_time.set ("", 0.1f, 0.01f, MILLION, &monl);
1677	jag	2506	sp_auto_split_time.set_text ("Every", SECONDS);
964	jag	2507
1647	jag	2508	sp_auto_delete_time.set ("", 0.1f, 0.01f, MILLION, &monl);
1677	jag	2509	sp_auto_delete_time.set_text ("Every", SECONDS);
964	jag	2510
1647	jag	2511	sp_min_split_size.set ("Min split size", 1, 2, MILLION, &monl);
2049	jag	2512
		2513	texstep.set ("Step", 1, 1, 1023, &stepl, 0);
		2514	text_ure.set_text ("din is noise");
		2515	text_ure.typing_lsnr = &mondrian0;
		2516
964	jag	2517
1647	jag	2518	#ifndef __WIDGET_MOVE__
964	jag	2519	cb_auto_split_box.set_listener (&monl);
		2520	cb_auto_delete_box.set_listener (&monl);
1647	jag	2521	#endif
964	jag	2522
		2523	options_list* olt [] = {&ol_bouncer, &ol_wrecker, &ol_healer};
		2524	for (int i = 0; i < 3; ++i) olt[i]->set_listener (&bolis);
		2525
1015	jag	2526	button* pb[] = {&sp_mondrian_change_dir.inc, &sp_mondrian_change_dir.dec};
964	jag	2527	set_repeat (pb, 2, 0.005);
		2528
		2529	recl.typing (lf_file.fld);
1647	jag	2530
1686	jag	2531	{
		2532
		2533	nullt* sp [] = {
		2534	&sp_change_drone_handle_size,
		2535	&sp_change_drone_trail_length,
1772	jag	2536	&autorotate.rpm,
1776	jag	2537	&autorotate.deg,
		2538	&autorotate.tps,
1686	jag	2539	&sp_mondrian_change_vol,
		2540	&sp_mondrian_change_attack_time,
		2541	&sp_mondrian_change_decay_time,
		2542	&sp_mondrian_change_speed,
		2543	&sp_mondrian_change_slit_size,
		2544	&sp_mondrian_change_slit_anim_time,
		2545	&sp_change_drone_vel,
		2546	&sp_change_drone_accel,
		2547	&sp_dam_depth,
		2548	&sp_dfm_depth,
		2549	&sp_dam_bpm,
		2550	&sp_dfm_bpm,
1689	jag	2551	&sp_drone_vol,
1768	jag	2552	&dronearrow.shoulder.position,
		2553	&dronearrow.shoulder.width,
1689	jag	2554	&sp_rotate_drone_vel,
		2555	&sp_drones_per_min,
		2556	&sp_drone_lifetime,
		2557	&sp_orbit_insertion_time,
		2558	&sp_mondrian_change_attack_time,
		2559	&sp_mondrian_change_decay_time,
		2560	&sp_mondrian_change_speed,
		2561	&sp_mondrian_change_dir,
		2562	&sp_mondrian_change_trail_size,
		2563	&sp_mondrian_change_vol,
		2564	&sp_mondrian_change_slit_size,
		2565	&sp_mondrian_change_slit_anim_time,
1695	jag	2566	&chspeed,
		2567	&chlen,
1705	jag	2568	&chtrail,
1772	jag	2569	&autorotate.autoflip.angle,
1804	jag	2570	&dronearrow.neck,
1776	jag	2571	&dronearrow.shoulder.width,
		2572	&dronearrow.shoulder.position,
1894	jag	2573	&dpl,
1686	jag	2574
		2575	};
		2576
		2577	int i = 0;
		2578	while (sp[i] != 0) sp[i++]->null = 1;
		2579
		2580	}
		2581
		2582
		2583
964	jag	2584	}
		2585
		2586	void menu::update () {
		2587	position_menu_items ();
		2588	position_tabs ();
		2589	}
		2590
		2591	void menu::position_menu_items () {
		2592	static const int lines = 4;
		2593	int targety = view.ymax - lines * line_height;
		2594	int dy = targety - cb_file.extents.bottom;
2311	jag	2595	for (int p = 0; p < nitems; ++p) items[p]->move (0, dy, 0);
964	jag	2596	}
		2597
1757	jag	2598	void menu::loadspinners () {
		2599	file_in fi ("spinners");
		2600	ifstream& f = fi ();
1804	jag	2601	f >> handlesize >> trailsize >> dva.mag >> lifetime >> dronearrowdefaults.neck >> dronearrowdefaults.shoulder.width >> dronearrowdefaults.shoulder.position;
1906	jag	2602	f >> dva.autorotate.rpm >> dva.autorotate.dps >> dva.autorotate.tps >> dva.autoflip.deg >> gabt;
1828	jag	2603	f >> riset >> fallt;
		2604	f >> sp_bounces >> sp_rebound;
2106	jag	2605	f >> gens >> ddpm >> ddpl >> sp_curve_every >> dva.autopause.every >> dva.autopause.f0r;
2286	jag	2606	f >> uis.settings_scr.binaural.sep;
1757	jag	2607	}
		2608
		2609	void menu::savespinners () {
		2610	file_out fo ("spinners");
		2611	ofstream& f = fo ();
1805	jag	2612	f << handlesize << trailsize << dva.mag << lifetime << dronearrowdefaults.neck << dronearrowdefaults.shoulder.width << dronearrowdefaults.shoulder.position;
1906	jag	2613	f << dva.autorotate.rpm << dva.autorotate.dps << dva.autorotate.tps << dva.autoflip.deg << gabt;
2286	jag	2614	f << riset << fallt << sp_bounces << sp_rebound << gens << ddpm << ddpl << sp_curve_every << dva.autopause.every << dva.autopause.f0r << uis.settings_scr.binaural.sep << endl;
1757	jag	2615	}
		2616
1828	jag	2617
964	jag	2618	void menu::setup () {
		2619	dlog << "* setting up menu *" << endl;
1757	jag	2620	show = screen_mousex = screen_mousey = 0;
964	jag	2621	setup_items ();
1757	jag	2622	widget_load ("d_menu", items, nitems);
		2623	loadspinners ();
1897	jag	2624	initcolorsliders ();
1450	jag	2625	b_menu.set_listener (&mbl);
964	jag	2626	dlog << "+++ menu setup complete +++" << endl;
		2627	}
		2628
		2629	void menu::set_pos (int x, int y) {
		2630	b_menu.set_pos (x, y);
		2631	}
		2632
		2633	void menu::draw () {
1494	jag	2634
964	jag	2635	b_menu.draw ();
1494	jag	2636
964	jag	2637	if (show) {
1486	jag	2638
1519	jag	2639	// draw bg
964	jag	2640	glEnable (GL_BLEND);
		2641	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1483	jag	2642	glColor4f (0.0f, 0.0f, 0.0f, opacity);
964	jag	2643	glRecti (bg_extents.left, bg_extents.bottom, bg_extents.right, bg_extents.top);
1483	jag	2644	glDisable (GL_BLEND);
964	jag	2645
		2646	glPolygonMode (GL_FRONT, GL_LINE);
1476	jag	2647	glColor3f (0.5f, 0.5f, 0.5f);
964	jag	2648	glRecti (bg_extents.left, bg_extents.bottom, bg_extents.right, bg_extents.top);
		2649	glPolygonMode (GL_FRONT, GL_FILL);
		2650
		2651	// draw items
		2652	for (int i = 0; i < num_tabs; ++i) tabs[i]->draw ();
		2653	if (cur_tab) {
		2654	vector<widget*>& ti = tab_members [cur_tab];
1040	jag	2655	for (int i = 0, j = ti.size (); i < j; ++i) ti[i]->draw ();
964	jag	2656	if (cur_tab == &cb_mkb_voice && din0.phrasor0.state == phrasor::playing) s_phrase_position.set_val (din0.phrasor0.amount);
		2657	}
		2658	}
		2659	}
		2660
		2661	void menu::setup_tabs (ui* scr) {
1941	jag	2662	checkbutton* com [] = {&cb_file, &cb_instrument, &cb_editors, 0};
		2663	checkbutton* mkb [] = {&cb_mkb_voice, &cb_mkb_drone_tools, &cb_mkb_drone_params, &cb_mkb_ranges, &cb_mkb_misc, 0};
		2664	checkbutton* eds [] = {&cb_ed_tools, &cb_ed_curves, 0};
		2665	checkbutton* mon [] = {&cb_mon_tools, &cb_mon_parameters, &cb_mon_ballops, &cb_mon_boxops, &cb_mon_misc, 0};
		2666	checkbutton* bd [] = {&cb_binaural_drones_tools, &cb_binaural_drones_edit, 0};
964	jag	2667	int clear_existing_tabs = 1;
1941	jag	2668	setup_tabs (com, clear_existing_tabs);
964	jag	2669	if (scr == &din0) { // microtonal keyboard
1941	jag	2670	setup_tabs (mkb);
964	jag	2671	} else if (scr == &keybd2) { // keyboard-keyboard
		2672	} else if (scr == &mondrian0) { // mondrian
1941	jag	2673	setup_tabs (mon);
964	jag	2674	} else if (scr == &binaural_drones0) { // binaural drones
1941	jag	2675	setup_tabs (bd);
964	jag	2676	} else { // is an editor
1941	jag	2677	setup_tabs (com, clear_existing_tabs);
		2678	setup_tabs (eds);
1439	jag	2679	next_tab = &cb_ed_tools;
		2680	next_tab_instr = get_current_instrument ();
964	jag	2681	}
		2682	position_tabs ();
		2683	}
		2684
1941	jag	2685	void menu::setup_tabs (checkbutton** tlist, int clear) {
964	jag	2686	if (clear) tabs.clear ();
1941	jag	2687	int i = 0;
		2688	checkbutton* ci = tlist[i];
		2689	while (ci) {
		2690	tabs.push_back (ci);
		2691	ci = tlist[++i];
		2692	}
964	jag	2693	num_tabs = tabs.size ();
		2694	}
		2695
		2696	void menu::position_tabs () {
1470	jag	2697
964	jag	2698	if (num_tabs) {
1470	jag	2699
2311	jag	2700	int x = cb_file.posx, y = cb_file.posy, spacing = 2 * fnt.spacing.word;
964	jag	2701	int i = 1, j = 0;
1408	jag	2702	for (; i < num_tabs;) {
1095	jag	2703	x = x + get_char_width (tabs[j]->text) + spacing;
964	jag	2704	tabs[i]->set_pos (x, y);
1408	jag	2705	++i;
		2706	j = i - 1;
964	jag	2707	}
		2708
1465	jag	2709	int ss = x + get_char_width (tabs[j]->text) - cb_file.posx;
		2710	separators.main.set_extents (ss);
1470	jag	2711	separators.dp0.set_extents (ss);
		2712	separators.dp1.set_extents (ss);
2311	jag	2713
964	jag	2714	calc_bg ();
		2715
		2716	checkbutton* lt = tabs[num_tabs - 1];
		2717	menu_mousex = lt->extents.right + 1;
		2718	menu_mousey = view.ymax - lt->posy;
1470	jag	2719
964	jag	2720	}
		2721	}
		2722
		2723	void menu::remove_from_tab (checkbutton* cb, widget* w) {
		2724	vector<widget*>& tw = tab_members [cb];
		2725	vector<widget*>::iterator end = tw.end (), i = find (tw.begin(), end, w);
		2726	if (i != end) tw.erase (i);
		2727	}
		2728
		2729	void menu::add_to_tab (checkbutton* cb, widget* w) {
		2730	vector<widget*>& tw = tab_members[cb];
		2731	vector<widget*>::iterator end = tw.end (), i = find (tw.begin(), end, w);
		2732	if (i == end) tw.push_back (w);
		2733	}
		2734
1941	jag	2735	void menu::populatecurvestab (curve_editor* ed) {
		2736	destroycurvestab ();
		2737	vector<curve_info>& cis = ed->curveinfo;
		2738	vector<widget*>& tc = tab_members [&cb_ed_curves];
		2739	int lh = line_height, x = cb_file.extents.left, y = separators.main.extents.bottom - lh;
1955	jag	2740	for (int i = 0, j = ed->curves; i < j; ++i) {
1941	jag	2741	curve_info& ci = cis[i];
		2742	checkbutton* cb = new checkbutton;
		2743	tc.push_back (cb);
		2744	cb->id = i;
		2745	cb->set_text (ci.curve->name);
		2746	cb->set_state (ci.visible, 0);
		2747	cb->set_pos (x, y);
		2748	cb->set_listener (&curvesl);
		2749	y -= lh;
		2750	}
		2751	}
		2752
		2753	void menu::destroycurvestab () {
		2754	vector<widget*>& tw = tab_members [&cb_ed_curves];
		2755	for (int i = 1, j = tw.size (); i < j; ++i) {
		2756	widget* wi = tw[i];
		2757	delete wi;
		2758	}
		2759	tw.clear ();
		2760	tw.push_back (&separators.main);
		2761	}
		2762
1465	jag	2763	void menu::set_drone_params_items (int s, int e) {
		2764	vector<widget*>& tw = tab_members[&cb_mkb_drone_params];
		2765	tw.clear ();
		2766	tw.push_back (&separators.main);
		2767	DECL_DRONE_PARAMS
2038	jag	2768	for (int i = 0; i < 10; ++i) {
1465	jag	2769	add_to_tab (&cb_mkb_drone_params, wdrone_params[i]);
		2770	}
		2771	for (int i = s; i < e; ++i) {
		2772	add_to_tab (&cb_mkb_drone_params, wdrone_params[i]);
		2773	}
		2774	calc_bg ();
		2775	}
		2776
964	jag	2777	int menu::handle_input () {
		2778
1368	jag	2779	if (b_menu.handle_input ()) return 1;
964	jag	2780
		2781	if (show) {
		2782
1804	jag	2783	if (wheel && !widget::HOVER) move_items (0, wheel * wheely);
		2784
1368	jag	2785	// find current tab
964	jag	2786	for (int i = 0; i < num_tabs; ++i) tabs[i]->handle_input ();
		2787
		2788	if (cur_tab) { // handle tab's items
		2789	vector<widget*>& tm = tab_members [cur_tab];
1040	jag	2790	for (int i = 0, j = tm.size (); i < j; ++i) if (tm[i]->handle_input ()) return 1;
964	jag	2791	}
		2792
		2793	}
1368	jag	2794
964	jag	2795	return 0;
1368	jag	2796
964	jag	2797	}
		2798
1485	jag	2799	void menu::toggle (int mouse_warp) {
964	jag	2800
1640	jag	2801	static int removedpluginbrowser;
		2802
964	jag	2803	show = !show;
1945	jag	2804
964	jag	2805	if (show) {
		2806
1120	jag	2807	b_menu.set_text ("Close menu");
1485	jag	2808
1568	jag	2809	if (b_close.visible) b_close.call_listener ();
1489	jag	2810
1551	jag	2811	if (uis.current->inst) {
1576	jag	2812	if (uis.current == &din0) {
2201	jag	2813	din0.dinfo.gravity.hide ();
1551	jag	2814	uis.remove (&mkb_selector);
1576	jag	2815	}
1551	jag	2816	else if (uis.current == &mondrian0)
		2817	uis.remove (&mon_selector);
		2818	} else {
		2819	uis.remove (&CRVED->capturer);
		2820	uis.remove (&CRVED->pomo);
1640	jag	2821	removedpluginbrowser = uis.remove (&uis.plugin__browser);
1551	jag	2822	if (CRVED->fft_enabled) uis.remove (&fft0);
1945	jag	2823	if (CRVED->curcrvchgd) CRVED->setup_tools_menu ();
1551	jag	2824	}
		2825
964	jag	2826	style_listener* sl [] = {&gater_style_lis, &am_style_lis, &fm_style_lis};
		2827	for (int i = 0; i < 3; ++i) sl[i]->get_style ();
		2828
		2829	screen_mousex = mousex;
		2830	screen_mousey = mousey;
		2831	::warp_mouse (menu_mousex, menu_mousey);
		2832
1406	jag	2833	if (next_tab && (next_tab_instr == get_current_instrument())) {
1393	jag	2834	changed (*next_tab);
		2835	cur_tab = next_tab;
		2836	next_tab = 0;
1439	jag	2837	next_tab_instr = 0;
1393	jag	2838	}
964	jag	2839
		2840	} else {
1120	jag	2841	b_menu.set_text ("Menu");
964	jag	2842	menu_mousex = mousex;
		2843	menu_mousey = mousey;
1551	jag	2844	if (uis.current->inst) {
1760	jag	2845	if (uis.current == &din0 ) {
2201	jag	2846	if (MENU.cb_show_gravity.state) din0.dinfo.gravity.show ();
1760	jag	2847	if (!din0.adding && !b_close.visible) uis.add (&din0, &mkb_selector);
1576	jag	2848	}
1568	jag	2849	else if (uis.current == &mondrian0)
1551	jag	2850	uis.widgets_of [&mondrian0].push_back (&mon_selector);
		2851	} else {
		2852	uis.widgets_of[CRVED].push_back (&CRVED->capturer);
		2853	uis.widgets_of[CRVED].push_back (&CRVED->pomo);
1640	jag	2854	if (removedpluginbrowser) uis.widgets_of[CRVED].push_back (&uis.plugin__browser);
1551	jag	2855	if (CRVED->fft_enabled) uis.widgets_of[CRVED].push_back (&fft0);
1489	jag	2856	}
1485	jag	2857	if (mouse_warp) warp_mouse (screen_mousex, screen_mousey);
964	jag	2858	}
		2859
		2860	uis.update_bottom_line ();
		2861
		2862	}
		2863
		2864	void menu::set_ball_ops (ball* b) {
		2865
		2866	ball_op* ops [ball_op::NUM_OPS] = {&b->op_turn, &b->op_speed, &b->op_teleport, &b->op_clone, &b->op_transform};
		2867	checkbutton* cbn [ball_op::NUM_OPS] = {&cb_turn, &cb_speed, &cb_teleport, &cb_clone, &cb_transform};
		2868	for (int i = 0; i < ball_op::NUM_OPS; ++i) cbn[i]->set_state (ops[i]->alarm.active, 0);
		2869
		2870	turn& trn = b->op_turn;
		2871	sp_turn_min.set_value (-trn.rd.min);
		2872	sp_turn_max.set_value (trn.rd.max);
		2873
		2874	speed& spd = b->op_speed;
		2875	sp_speed_min.set_value (-spd.rd.min);
		2876	sp_speed_max.set_value (spd.rd.max);
		2877	sp_max_speed.set_value (spd.max);
		2878
		2879	teleport& tel = b->op_teleport;
		2880	sp_tel_radius.set_value (tel.radius);
		2881
		2882	Clone& clo = b->op_clone;
		2883	sp_clone_offset.set_value (clo.offset);
		2884	sp_max_clones.set_value (clo.max);
		2885	sp_max_balls.set_value (Clone::max_balls);
		2886	cb_clone_can_clone.set_state (clo.clone_can_clone);
		2887
		2888	Transform& tf = b->op_transform;
		2889
		2890	ball_op* bpa [] = {&trn, &spd, &tel, &clo, &tf};
		2891	spinner<float>* spa [] = {&sp_turn_every, &sp_speed_every, &sp_tel_every, &sp_clone_every, &sp_transform_every};
		2892	for (int i = 0; i < ball_op::NUM_OPS; ++i) spa[i]->set_value (bpa[i]->alarm.triggert);
		2893
		2894	}
		2895
		2896	void menu::clear_ball_ops () {
		2897	checkbutton* cbn [ball_op::NUM_OPS] = {&cb_turn, &cb_speed, &cb_teleport, &cb_clone, &cb_transform};
		2898	for (int i = 0; i < ball_op::NUM_OPS; ++i) cbn[i]->set_state (0, 0);
		2899	}
		2900
1450	jag	2901	CLICKED_BUTTON(menu, b_menu_lis) {
		2902	cons << YELLOW << "You can use right click to open / close the menu and mouse wheel to scroll" << eol;
1784	jag	2903	TOGGLEMENU
1450	jag	2904	}
		2905
		2906	CLICKED_BUTTON(menu, b_inst_lis) {
		2907	int i = b.id;
		2908	scope.save_current_instrument ();
		2909	CURRENT_INSTRUMENT = i;
		2910	INSTRUMENT = INSTRUMENTS[i];
		2911	load_instrument ();
		2912	}
		2913
		2914	CLICKED_BUTTON(menu, b_ed_lis) {
1502	jag	2915	int i = b.id;
1450	jag	2916	ui* ed = uis.uis[i];
1517	jag	2917	uis.load_editor (ed);
1450	jag	2918	setup_plugin_labels ();
		2919	if (curve_picker.visible) curve_picker.hide();
		2920	}
		2921
964	jag	2922	void misc_listener::clicked (button& b) {
1450	jag	2923	if (&b == MENUP.b_exit_din)
964	jag	2924	try_quit ();
		2925	else if (&b == MENUP.b_turn_off_ui) {
		2926	turn_off_ui ();
		2927	return;
1475	jag	2928	} else
		2929	din0.set_key_to_pitch_at_cursor ();
1828	jag	2930	TOGGLEMENU
964	jag	2931	}
		2932
		2933	void menu::move_items (int dx, int dy) {
1757	jag	2934	for (int i = 0; i < nitems; ++i) {
964	jag	2935	widget* wi = items[i];
		2936	wi->move (dx, dy, 0);
		2937	}
1942	jag	2938
		2939	if (CRVED) {
		2940	vector<widget*>& vc = tab_members[&cb_ed_curves];
		2941	int n = vc.size ();
		2942	for (int i = 1; i < n; ++i) vc[i]->move (dx, dy, 0);
		2943	}
		2944
964	jag	2945	calc_bg ();
		2946	}
		2947
		2948	void menu::changed (checkbutton& tb) { // current tab has changed
		2949
		2950	cur_tab = &tb;
1687	jag	2951	tb.turn_on (DONT_CALL_LISTENER); // must be always on
964	jag	2952
		2953	if (cur_tab == last_tab) return;
		2954
1687	jag	2955	if (last_tab) last_tab->turn_off (DONT_CALL_LISTENER);
964	jag	2956
		2957	last_tab = cur_tab;
		2958
		2959	calc_bg ();
		2960
1495	jag	2961	opacity = 0.9f;
		2962	if (&tb == &cb_mon_ballops \|\| &tb == &cb_mon_boxops \|\| &tb == &cb_mon_misc) opacity = 0.5f;
1447	jag	2963
964	jag	2964	// save last tab to reload when loading new instrument
		2965	extern checkbutton* LAST_TABS [];
1941	jag	2966	checkbutton* com [] = {&cb_file, &cb_instrument, &cb_editors, &cb_ed_tools, &cb_ed_curves}; // ignore these tabs
		2967	for (int i = 0; i < 5; ++i) if (com[i] == cur_tab) return;
964	jag	2968	LAST_TABS [CURRENT_INSTRUMENT] = cur_tab;
		2969
		2970	}
		2971
2306	jag	2972
		2973	VALUE_CHANGED(menu,ancopalis) {
		2974	drone::anchoropacity = MENU.ancopa.value;
		2975	cons << "Drone anchor opacity = " << drone::anchoropacity << eol;
		2976	}
		2977
1498	jag	2978	VALUE_CHANGED(menu,sp_stiff_lis) {
2104	jag	2979	drone::STIFFNESS = MENU.sp_stiff.value;
1709	jag	2980	clamp (0.0f, drone::STIFFNESS, 1.0f);
		2981	cons << "Connection stiffness = " << drone::STIFFNESS << eol;
1498	jag	2982	}
		2983
1819	jag	2984	VALUE_CHANGED(menu,gabt_lis) {
2107	jag	2985	drone::gabt = MENU.gabt.value;
1559	jag	2986	din0.gab.setgabt ();
1677	jag	2987	cons << YELLOW << "Mute/unmute and Drone <> Noise time = " << drone::gabt << SECONDS << eol;
1547	jag	2988	}
		2989
1452	jag	2990	VALUE_CHANGED(menu,sp_dam_depth_lis) {
1451	jag	2991	din0.change_drone_depth (modulator::AM, MENU.sp_dam_depth);
		2992	}
		2993
1452	jag	2994	VALUE_CHANGED(menu,sp_dfm_depth_lis) {
1451	jag	2995	din0.change_drone_depth (modulator::FM, MENU.sp_dfm_depth);
		2996	}
		2997
1912	jag	2998	VALUE_CHANGED(menu,sp_dam_pos_lis) {
2110	jag	2999	MENU.sp_dam_pos.set_value (f);
1912	jag	3000	din0.change_drone_modpos (modulator::AM, MENU.sp_dam_pos);
		3001	}
		3002
		3003	VALUE_CHANGED(menu,sp_dfm_pos_lis) {
2110	jag	3004	MENU.sp_dfm_pos.set_value (f);
1912	jag	3005	din0.change_drone_modpos (modulator::FM, MENU.sp_dfm_pos);
		3006	}
		3007
1452	jag	3008	VALUE_CHANGED(menu,sp_dam_bpm_lis) {
		3009	din0.change_drone_bpm (modulator::AM, MENU.sp_dam_bpm);
1451	jag	3010	}
		3011
1452	jag	3012	VALUE_CHANGED(menu,sp_dfm_bpm_lis) {
		3013	din0.change_drone_bpm (modulator::FM, MENU.sp_dfm_bpm);
1451	jag	3014	}
		3015
1452	jag	3016	VALUE_CHANGED(menu,sp_am_depth_lis) {
		3017	din0.change_depth (din::AM, MENU.sp_am_depth());
		3018	}
		3019
		3020	VALUE_CHANGED(menu,sp_fm_depth_lis) {
		3021	din0.change_depth (din::FM, MENU.sp_fm_depth());
		3022	}
		3023
		3024	VALUE_CHANGED(menu,sp_am_bpm_lis) {
2107	jag	3025	float v = MENU.sp_am_bpm.value;
1452	jag	3026	v = din0.am.set_bpm (v);
2334	jag	3027	cons << YELLOW << "Voice AM bpm = " << v << " or " << v / 60.0f << " hz" << eol;
1452	jag	3028	}
		3029
		3030	VALUE_CHANGED(menu,sp_fm_bpm_lis) {
2107	jag	3031	float v = MENU.sp_fm_bpm.value;
1452	jag	3032	v = din0.fm.set_bpm (v);
2334	jag	3033	cons << YELLOW << "Voice FM bpm = " << v << " or " << v / 60.0f << " hz" << eol;
1452	jag	3034	}
		3035
1686	jag	3036	VALUE_CHANGED(menu,sp_browse_drone_lis) {
2107	jag	3037	din0.browsed_drone = MENU.sp_browse_drone.value;
1686	jag	3038	din0.browse_drone (0);
		3039	}
		3040
1827	jag	3041	VALUE_CHANGED (menu,sp_bounces_lis) {
1855	jag	3042	int& n = din0.dinfo.bounce.n;
2107	jag	3043	n = MENU.sp_bounces.value;
1894	jag	3044	if (n == -1) {
		3045	cons << RED << "Drones will not bounce from bottom of the microtonal keyboard!" << eol;
		3046	checkbutton& cb = MENU.sp_bounces.variance.cb;
		3047	cb.set_state (0, 0);
		3048	} else cons << GREEN << "Max bounces = " << n << eol;
1452	jag	3049	}
		3050
		3051	VALUE_CHANGED(menu,sp_rebound_lis) {
2107	jag	3052	din0.dinfo.bounce.speed = MENU.sp_rebound.value;
1865	jag	3053	cons << GREEN << "Rebound Max Speed % = " << din0.dinfo.bounce.speed << eol;
1452	jag	3054	}
		3055
964	jag	3056	void menu::changed (field& f) {
1451	jag	3057
1452	jag	3058	if (&f == &sp_mesh_rows.f_value) {
2104	jag	3059	din0.dinfo.rows = sp_mesh_rows.value;
1040	jag	3060	if (cb_sync_rows_cols.state) {
1370	jag	3061	din0.dinfo.cols = din0.dinfo.mesh_vars.dpp = din0.dinfo.rows;
1040	jag	3062	sp_mesh_cols.set_value (din0.dinfo.cols);
1370	jag	3063	sp_drones_per_pend.set_value (din0.dinfo.mesh_vars.dpp);
1040	jag	3064	}
1438	jag	3065	mkb_selector.set_mesh (din0.meshh.create, din0.dinfo.rows, din0.dinfo.cols);
1049	jag	3066	picked (ol_mesh_point.option, 0);
964	jag	3067	} else if (&f == &sp_mesh_cols.f_value) {
2104	jag	3068	din0.dinfo.cols = sp_mesh_cols.value;
1040	jag	3069	if (cb_sync_rows_cols.state) {
1370	jag	3070	din0.dinfo.rows = din0.dinfo.mesh_vars.dpp = din0.dinfo.cols;
1040	jag	3071	sp_mesh_rows.set_value (din0.dinfo.rows);
1370	jag	3072	sp_drones_per_pend.set_value (din0.dinfo.mesh_vars.dpp);
1040	jag	3073	}
1438	jag	3074	mkb_selector.set_mesh (din0.meshh.create, din0.dinfo.rows, din0.dinfo.cols);
1049	jag	3075	picked (ol_mesh_point.option, 0);
1046	jag	3076	} else if (&f == &sp_mesh_dur.f_value) {
2104	jag	3077	float t = sp_mesh_dur.value;
1094	jag	3078	din0.dinfo.mesh_vars.duration = t;
1677	jag	3079	cons << "Make mesh in " << t << SECONDS << eol;
1052	jag	3080	} else if (&f == &f_mesh_xy) {
		3081	int r, c;
		3082	tokenizer z (f.text);
		3083	z >> r >> c;
		3084	if (clamp (0, r, din0.dinfo.rows-1) \|\| clamp (0, c, din0.dinfo.cols-1) ) {
		3085	sprintf (BUFFER, "%d %d", r, c);
		3086	f_mesh_xy.set_text(BUFFER);
		3087	}
		3088	proximity_orderer::ROW = r;
		3089	proximity_orderer::COL = c;
1598	jag	3090	} else if (&f == &dp_numdrones.f_value) {
2108	jag	3091	din0.dinfo.drone_pend.n = MENU.dp_numdrones.value;
1598	jag	3092	cons << YELLOW << "Number of Drones = " << din0.dinfo.drone_pend.n << eol;
1096	jag	3093	} else if (&f == &dp_bpm1.f_value) {
2108	jag	3094	din0.dinfo.drone_pend.bpm = MENU.dp_bpm1.value;
1477	jag	3095	cons << YELLOW << "Drone Pendulum BPM = " << din0.dinfo.drone_pend.bpm << eol;
		3096	}
964	jag	3097	}
		3098
		3099	void menu::changed (slider<float>& s) {
1461	jag	3100	din0.phrasor0.set_cur (s());
964	jag	3101	}
		3102
		3103	void menu::picked (label& lbl, int dir) {
		3104	const static char* mit [] = {" Tangents are not mirrored", " Tangents are mirrored"};
1829	jag	3105	const static char* bbs [] = {" Drones bounce ahead", " Drones bounce back", " Drones bounce ahead or back"};
2077	jag	3106	const static char *sut [] = {" Snap drones to notes", " Position affects vectors"};
1049	jag	3107	const static char *ofl [] = {" in ascending rows", " in descending rows"," in ascending columns", " in descending columns", " randomly", " nearest to", " farthest from" };
1052	jag	3108	const static char *wpt [] = {"bottom left", "bottom right", "top left", "top right", "center", "random point", "custom point"};
1320	jag	3109	const static char *cwt [] = {" Create Drone Mesh", " Create Drone Pendulum"};
1096	jag	3110	const static char *ort [] = {" Orientation = Horizontal", " Orientation = Vertical"};
2214	jag	3111	const static char *mir [] = {" Horizontal Flip ", " Vertical Flip ", " Horizontal Flip (Local) ", " Vertical Flip (Local) " };
2287	jag	3112	const static char *dris [] = {" Drone is Drone", " Drone is Noise", " Drone is Drone or Noise"};
1096	jag	3113
1052	jag	3114	static const int npt = 7, npt_1 = npt-1;
1096	jag	3115	static widget* mshw [] = {
		3116	&sp_mesh_rows,
		3117	&sp_mesh_cols,
		3118	&cb_sync_rows_cols,
		3119	&l_drone_order,
1101	jag	3120	&sp_mesh_dur,
		3121	&b_flip_rows_cols,
1096	jag	3122	&ol_drone_order,
1322	jag	3123	&l_use_drone_pend,
		3124	&sp_drones_per_pend,
		3125	&l_apply_to,
		3126	&cb_am_bpm,
		3127	&cb_fm_bpm,
		3128	&b_set_to_mesh_rows,
		3129	&b_set_to_mesh_cols,
1096	jag	3130	&ol_mesh_point,
		3131	&f_mesh_xy,
		3132	};
		3133	static widget* dpw [] = {
		3134	&dp_orient,
1598	jag	3135	&dp_numdrones,
1096	jag	3136	&dp_bpm1,
		3137	};
1044	jag	3138
2217	jag	3139	if (&lbl == &ol_mirror_tangents.option) {
1128	jag	3140	CRVED->mirror_tangents = !CRVED->mirror_tangents;
		3141	lbl.set_text (mit[CRVED->mirror_tangents]);
964	jag	3142	} else if (&lbl == &ol_curve_style.option) {
1128	jag	3143	CRVED->toggle_curve_style ();
964	jag	3144	} else if (&lbl == &ol_bounce_style.option) {
		3145	din0.dinfo.bounce.style += dir;
1829	jag	3146	wrap<int> (din_info::bouncet::AHEAD, din0.dinfo.bounce.style, din_info::bouncet::RANDOM);
964	jag	3147	lbl.set_text (bbs[din0.dinfo.bounce.style]);
		3148	} else if (&lbl == &ol_set_unset_toggle.option) {
		3149	din0.dinfo.set_unset_toggle = !din0.dinfo.set_unset_toggle;
		3150	lbl.set_text (sut[din0.dinfo.set_unset_toggle]);
1545	jag	3151	b_toggle.set_pos (lbl.extents.right + 20, b_toggle.posy);
		3152	b_set.set_pos (b_toggle.extents.right + 10, b_toggle.posy);
		3153	b_unset.set_pos (b_set.extents.right + 10, b_toggle.posy);
1037	jag	3154	} else if (&lbl == &ol_drone_order.option) {
1094	jag	3155	din0.dinfo.mesh_vars.order += dir;
		3156	wrap (0, din0.dinfo.mesh_vars.order, LAST_ORDERER);
		3157	lbl.set_text (ofl[din0.dinfo.mesh_vars.order]);
		3158	if (din0.dinfo.mesh_vars.order > 4) {
1040	jag	3159	add_to_tab (&cb_mkb_drone_tools, &ol_mesh_point);
		3160	add_to_tab (&cb_mkb_drone_tools, &f_mesh_xy);
1408	jag	3161	ol_mesh_point.set_pos (lbl.extents.right + 10, lbl.extents.bottom);
		3162	f_mesh_xy.set_pos (ol_mesh_point.option.extents.right + 10, f_mesh_xy.extents.bottom);
1040	jag	3163	} else {
		3164	remove_from_tab (&cb_mkb_drone_tools, &ol_mesh_point);
		3165	remove_from_tab (&cb_mkb_drone_tools, &f_mesh_xy);
		3166	}
1037	jag	3167	} else if (&lbl == &ol_mesh_point.option) {
1094	jag	3168	din0.dinfo.mesh_vars.point += dir;
		3169	wrap (0, din0.dinfo.mesh_vars.point, npt_1);
		3170	sprintf (BUFFER, " %s @ ", wpt[din0.dinfo.mesh_vars.point]);
1037	jag	3171	lbl.set_text (BUFFER);
1044	jag	3172	int cols_1 = din0.dinfo.cols - 1;
		3173	int rows_1 = din0.dinfo.rows - 1;
		3174	rnd<int> rdr (0, rows_1), rdc (0, cols_1);
1052	jag	3175	int ROW [] = {0, 0, rows_1, rows_1, din0.dinfo.rows / 2, rdr(), proximity_orderer::ROW};
		3176	int COL [] = {0, cols_1, 0, cols_1, din0.dinfo.cols / 2, rdc(), proximity_orderer::COL};
1094	jag	3177	proximity_orderer::ROW = ROW [din0.dinfo.mesh_vars.point];
		3178	proximity_orderer::COL = COL [din0.dinfo.mesh_vars.point];
1049	jag	3179	sprintf (BUFFER, "%d %d", proximity_orderer::ROW, proximity_orderer::COL);
1044	jag	3180	f_mesh_xy.set_text (BUFFER);
1408	jag	3181	f_mesh_xy.set_pos (lbl.extents.right + 10, f_mesh_xy.extents.bottom);
1098	jag	3182	} else if (&lbl == &ol_create_this.option) {
		3183	din0.dinfo.create_this += dir;
		3184	wrap (0, din0.dinfo.create_this, 1);
		3185	int cw = din0.dinfo.create_this;
1096	jag	3186	lbl.set_text (cwt[cw]);
1101	jag	3187	if (cw) { // drone pendulum
1322	jag	3188	for (int i = 0; i < 16; ++i) remove_from_tab (&cb_mkb_drone_tools, mshw[i]);
1477	jag	3189	for (int i = 0; i < 3; ++i) add_to_tab (&cb_mkb_drone_tools, dpw[i]);
1101	jag	3190	} else { // mesh
1477	jag	3191	for (int i = 0; i < 3; ++i) remove_from_tab (&cb_mkb_drone_tools, dpw[i]);
1322	jag	3192	int j = 14; if (din0.dinfo.mesh_vars.order > 4) j = 16;
1101	jag	3193	for (int i = 0; i < j; ++i) add_to_tab (&cb_mkb_drone_tools, mshw[i]);
1096	jag	3194	}
1495	jag	3195	calc_bg ();
1096	jag	3196	} else if (&lbl == &dp_orient.option) {
		3197	din0.dinfo.drone_pend.orient += dir;
		3198	wrap (0, din0.dinfo.drone_pend.orient, 1);
		3199	int o = din0.dinfo.drone_pend.orient;
		3200	lbl.set_text (ort[o]);
1128	jag	3201	} else if (&lbl == &ol_mirror.option) {
		3202	CRVED->axis += dir;
1453	jag	3203	wrap<int> (curve_editor::MIRROR_X, CRVED->axis, curve_editor::MIRROR_BBY);
1128	jag	3204	lbl.set_text (mir[CRVED->axis]);
1453	jag	3205	calc_bg ();
1387	jag	3206	} else if (&lbl == &ol_drone_is.option) {
1813	jag	3207	drone::IS += dir;
2287	jag	3208	wrap<int> (drone::DRONE, drone::IS, drone::RANDOM);
1687	jag	3209	const char* di = dris [drone::IS];
1398	jag	3210	lbl.set_text (di);
2286	jag	3211	}
964	jag	3212	}
		3213
		3214	void menu::calc_bg () {
		3215	if (cur_tab && num_tabs) {
		3216	vector<widget*>& v = tab_members [cur_tab];
		3217	if (v.size () == 0) return;
		3218	widget* w0 = v[0];
		3219	bg_extents.left = cb_file.extents.left;
		3220	bg_extents.right = bg_extents.left;
		3221	bg_extents.bottom = w0->extents.bottom;
		3222	bg_extents.top = tabs[0]->extents.top;
		3223	for (int i = 0, j = v.size (); i < j; ++i) {
		3224	widget* wi = v[i];
		3225	if (wi->extents.left < bg_extents.left) bg_extents.left = wi->extents.left;
		3226	if (wi->extents.right > bg_extents.right) bg_extents.right = wi->extents.right;
		3227	if (wi->extents.bottom < bg_extents.bottom) bg_extents.bottom = wi->extents.bottom;
		3228	if (wi->extents.top > bg_extents.top) bg_extents.top = wi->extents.top;
		3229	}
		3230	static const int GUTTER = 5;
		3231	bg_extents.resize (GUTTER, GUTTER);
		3232	}
1319	jag	3233
964	jag	3234	}
		3235
		3236	void menu::show_editors (ui* inst) {
1935	jag	3237	// refer to weds
1941	jag	3238	int starts [] = {0, 4, 15, 18};
		3239	int ends [] = {4, 15, 18, 19};
964	jag	3240	int starti = starts[CURRENT_INSTRUMENT], endi = ends[CURRENT_INSTRUMENT];
		3241	vector<widget*>& tw = tab_members [&cb_editors];
		3242	for (int i = starti; i < endi; ++i) {
		3243	widget* ei = editors[i];
		3244	tw.push_back (ei);
		3245	}
		3246	}
		3247
		3248	void menu::hide_editors () {
		3249	vector<widget*>& tw = tab_members [&cb_editors];
1941	jag	3250	for (int i = 0; i < 19; ++i) {
964	jag	3251	widget* ei = editors[i];
		3252	vector<widget*>::iterator itr = find (tw.begin(), tw.end(), ei);
		3253	if (itr != tw.end()) tw.erase (itr);
		3254	}
		3255	}
		3256
		3257	void menu::update_bpm (const string& name, float value) {
		3258	spinner<float>* psp = bpm_map [name];
		3259	if (psp) psp->set_value (value);
		3260	}
		3261
		3262	void menu::mark_tap_target () {
		3263	interpreter ("set taptarget");
		3264	tokenizer tz (interpreter.result);
		3265	while (1) {
		3266	string target; tz >> target;
		3267	if (target == "") break;
1687	jag	3268	if (target == "gr") cb_gater.turn_on (DONT_CALL_LISTENER);
		3269	else if (target == "am") cb_am.turn_on (DONT_CALL_LISTENER);
		3270	else if (target == "fm") cb_fm.turn_on (DONT_CALL_LISTENER);
		3271	else if (target == "os") cb_octave_shift.turn_on (DONT_CALL_LISTENER);
964	jag	3272	}
		3273	}
		3274
		3275	menu::~menu () {
		3276	dlog << "--- destroying menu ---" << endl;
2039	jag	3277
		3278	#ifdef __WIDGET_MOVE__
1757	jag	3279	widget_save ("d_menu", items, nitems);
2039	jag	3280	#endif
1757	jag	3281	savespinners ();
1897	jag	3282	savecolorsliders ();
1941	jag	3283	destroycurvestab ();
2039	jag	3284
964	jag	3285	dlog << "--- destroyed menu ---" << endl;
		3286	}
		3287
		3288	void octave_shift_listener::clicked (button& b) {
		3289	if (&b == MENUP.ab_octave_up \|\| &b == &uis.ab_octave_up) modulate_up (); else modulate_down ();
		3290	}
		3291
		3292	void octave_shift_listener::changed (field& f) {
2233	jag	3293	float v = 0.0f;
		3294	if (&f == MENUP.sp_octave_shift_bpm.f_value) {
		3295	v = MENU.sp_octave_shift_bpm.value;
		3296	uis.sp_octave_shift_bpm.set_value (v);
		3297	}
		3298	else {
		3299	v = uis.sp_octave_shift_bpm.value;
		3300	MENU.sp_octave_shift_bpm.set_value (v);
		3301	}
		3302	v = octave_shift.set_bpm (v);
964	jag	3303	static const string los = "Octave shift BPM = ";
1368	jag	3304	cons << YELLOW << los << v << eol;
964	jag	3305	}
		3306
		3307	void voice_volume_listener::changed (field& f) {
2108	jag	3308	VOICE_VOLUME = MENU.sp_voice_volume.value;
1441	jag	3309	static const string vv ("Volume = ");
964	jag	3310	cons << YELLOW << vv << VOICE_VOLUME << eol;
		3311	}
		3312
1241	jag	3313	void drone_master_volume_listener::changed (field& f) {
2102	jag	3314	din0.setdronemastervolume (MENU.sp_drone_master_vol.value);
1241	jag	3315	}
		3316
964	jag	3317	void gater_bpm_listener::changed (field& f) {
2108	jag	3318	float v = MENU.sp_gater_bpm.value;
964	jag	3319	v = din0.gatr.set_bpm (v);
2157	jag	3320	static const string gt = "Beater BPM = ";
964	jag	3321	cons << YELLOW << gt << v << eol;
		3322	}
		3323
		3324	void drone_handle_size_listener::changed (field& f) {
1060	jag	3325	din0.change_drone_handle_size (MENU.sp_change_drone_handle_size);
964	jag	3326	}
		3327
		3328	void drone_trail_length_listener::changed (field& f) {
1060	jag	3329	din0.change_drone_trail_points (MENU.sp_change_drone_trail_length);
964	jag	3330	}
		3331
		3332	void change_drone_vel_listener::changed (field& f) {
1019	jag	3333	din0.change_drone_vel (MENU.sp_change_drone_vel);
964	jag	3334	}
		3335
		3336	void change_drone_accel_listener::changed (field& f) {
1058	jag	3337	din0.change_drone_accel (MENU.sp_change_drone_accel);
964	jag	3338	}
		3339
2077	jag	3340	void rotate_drone_vec_listener::changed (field& f) {
		3341	int id = f.id;
		3342	spinner<float>* sp [] = {MENUP.sp_rotate_drone_vel, MENUP.rotaccel};
2078	jag	3343	rotdir* rd [] = {MENUP.rdvel, MENUP.rdaccel};
		3344	din0.rotate_drone_vec (id, *sp[id], rd[id]->val);
964	jag	3345	}
		3346
		3347	void drones_per_min_listener::changed (field& f) {
1058	jag	3348	din0.change_drones_per_min (MENU.sp_drones_per_min);
964	jag	3349	}
		3350
1893	jag	3351	void menu::dpllis::changed (field& f) {
		3352	din0.change_drones_per_launch (MENU.dpl);
		3353	}
		3354
964	jag	3355	void drone_lifetime_listener::changed (field& f) {
1058	jag	3356	din0.change_drone_lifetime (MENU.sp_drone_lifetime);
964	jag	3357	}
		3358
		3359	void orbit_insertion_time_listener::changed (field& f) {
1058	jag	3360	din0.change_orbit_insertion_time (MENU.sp_orbit_insertion_time);
964	jag	3361	}
		3362
		3363	void style_listener::set_style (const string& style) {
		3364	for (int i = 0; i < num_styles; ++i) {
		3365	if (styles[i] == style) {
		3366	id = i;
		3367	string command ("set-style " + what + " " + style);
		3368	interpreter (command);
		3369	oplist.set_text (prefix + style);
		3370	}
		3371	}
		3372	}
		3373
		3374	void style_listener::get_style () {
		3375	string command ("get-style " + what);
		3376	interpreter (command);
		3377	oplist.set_text (prefix + interpreter.result);
		3378	}
		3379
		3380	void style_listener::next_style (int dir) {
		3381	id += dir;
		3382	if (id < 0) id = last_style; else if (id >= num_styles) id = 0;
		3383	set_style (styles[id]);
		3384	}
		3385
		3386	void style_listener::picked (label& lbl, int dir) {
		3387	next_style (dir);
		3388	}
		3389
		3390	void drone_commands_listener::changed (checkbutton& cb) {
		3391	int state = cb.state;
		3392	if (&cb == MENUP.cb_show_vel) din0.dinfo.vel = state; else
		3393	if (&cb == MENUP.cb_show_accel) din0.dinfo.accel = state; else
1868	jag	3394	if (&cb == MENUP.cb_show_gravity) {
		3395	gravity_t& gr = din0.dinfo.gravity;
2201	jag	3396	if (state) uis.add (&din0, &gr); else uis.remove (&gr);
1868	jag	3397	} else
964	jag	3398	if (&cb == MENUP.cb_show_anchors) din0.dinfo.anchor = state; else
1812	jag	3399	if (&cb == MENUP.seloncre) din0.dinfo.seloncre = state;
1094	jag	3400	else din0.dinfo.mesh_vars.sync = cb.state;
964	jag	3401	}
		3402
		3403	void phrase_commands_listener::clicked (button& b) {
1784	jag	3404	TOGGLEMENU
964	jag	3405	if (&b == MENUP.b_record_phrase) din0.do_phrase_recording ();
		3406	else if (&b == MENUP.b_clear_phrases) din0.clear_all_phrases ();
		3407	}
		3408
		3409	void range_data::read_mod () {
		3410	int& a = din0.ranges[din0.dinfo.sel_range].mod.active;
		3411	mod = a;
		3412	a = 0;
		3413	}
		3414
		3415	void range_data::write_mod () {
		3416	din0.ranges[din0.dinfo.sel_range].mod.active = mod;
		3417	}
		3418
		3419	void range_height_listener::clicked (button& b) {
		3420	mouse_slider0.add (MENUP.rhl);
		3421	MENU.rhl.read_mod ();
		3422	activate_mouse_slider ();
		3423	}
		3424
1566	jag	3425	void range_height_listener::moused (int dh, double scl) {
964	jag	3426	din0.height_changed (din0.dinfo.sel_range, dh);
		3427	}
		3428
		3429	void range_height_listener::after_slide () {
		3430	MENU.rhl.write_mod ();
		3431	}
		3432
		3433	void board_height_listener::read_mod () {
		3434	int n = din0.num_ranges;
		3435	moda.resize (n);
		3436	for (int i = 0; i < n; ++i) {
		3437	int& a = din0.ranges[i].mod.active;
		3438	moda[i]=a;
		3439	a = 0;
		3440	}
		3441	}
		3442
		3443	void board_height_listener::write_mod () {
		3444	int n = din0.num_ranges;
		3445	for (int i = 0; i < n; ++i) din0.ranges[i].mod.active = moda[i];
		3446	}
		3447
1566	jag	3448	void board_height_listener::moused (int dh, double scl) {
964	jag	3449	din0.height_changed (-1, dh);
		3450	}
		3451
		3452	void board_height_listener::clicked (button& b) {
		3453	MENU.bhl.name = "Board height";
		3454	MENU.bhl.orient = mouse_slider_listener::Y;
		3455	mouse_slider0.add (MENUP.bhl);
		3456	MENU.bhl.read_mod ();
		3457	activate_mouse_slider ();
		3458	}
		3459
		3460	void board_height_listener::after_slide () {
		3461	MENU.bhl.write_mod ();
		3462	}
		3463
		3464	void set_range_listener::clicked (button& b) {
		3465	if (&b == MENUP.b_selected_to_all) {
		3466	din0.selected_range_to_all (i);
		3467	} else if (&b == MENUP.b_default_to_selected) {
		3468	din0.default_range_to_selected (i);
		3469	} else if (&b == MENUP.b_default_to_all) {
		3470	din0.default_range_to_all (i);
		3471	}
		3472	}
		3473
		3474	void set_range_listener::picked (label& lbl, int dir) {
		3475	i = !i;
		3476	static const char* opts [] = {" Set Width?", " Set Height?"};
		3477	lbl.set_text (opts[i]);
		3478	}
		3479
		3480	void range_width_listener::clicked (button& b) {
		3481	if (&b == MENUP.b_adjust_range_left) {
		3482	MENU.arl.range = din0.dinfo.sel_range;
		3483	MENU.arl.read_mod ();
		3484	mouse_slider0.add (MENUP.arl);
		3485	activate_mouse_slider ();
		3486	} else if (&b == MENUP.b_adjust_range_right) {
		3487	MENU.arr.range = din0.dinfo.sel_range;
		3488	MENU.arr.read_mod ();
		3489	mouse_slider0.add (MENUP.arr);
		3490	activate_mouse_slider ();
		3491	} else {
		3492	MENU.arb.range = din0.dinfo.sel_range;
		3493	MENU.arb.read_mod ();
		3494	mouse_slider0.add (MENUP.arb);
		3495	activate_mouse_slider ();
		3496	}
1605	jag	3497	din0.adjustranges.set ();
964	jag	3498	}
		3499
1566	jag	3500	void adjust_range_left_listener::moused (int dir, double scl) {
964	jag	3501	if (din0.range_left_changed (range, dir, 1)) {
1402	jag	3502	din0.refresh_drones (0, range);
964	jag	3503	din0.find_visible_ranges ();
		3504	}
		3505	}
		3506
		3507	void adjust_range_left_listener::after_slide () {
		3508	MENU.arl.write_mod ();
1605	jag	3509	din0.adjustranges.unset ();
964	jag	3510	}
		3511
1566	jag	3512	void adjust_range_right_listener::moused (int dir, double scl) {
964	jag	3513	if (din0.range_right_changed (range, dir, 1)) {
1402	jag	3514	din0.refresh_drones (range, din0.last_range);
964	jag	3515	din0.find_visible_ranges ();
		3516	}
		3517	}
		3518
		3519	void adjust_range_right_listener::after_slide () {
		3520	MENU.arr.write_mod ();
1605	jag	3521	din0.adjustranges.unset ();
964	jag	3522	}
		3523
1566	jag	3524	void adjust_range_both_listener::moused (int dir, double scl) {
964	jag	3525	int rl = din0.range_left_changed (range, -dir, 1);
		3526	int rr = din0.range_right_changed (range, dir, 1);
		3527	if (rl \|\| rr) {
1402	jag	3528	din0.refresh_all_drones ();
964	jag	3529	din0.find_visible_ranges ();
		3530	}
		3531	}
		3532
		3533	void adjust_range_both_listener::after_slide () {
		3534	MENU.arb.write_mod ();
1605	jag	3535	din0.adjustranges.unset ();
964	jag	3536	}
1452	jag	3537
		3538	VALUE_CHANGED(menu, sp_range_lis) {
2108	jag	3539	din0.dinfo.sel_range = MENU.sp_range.value;
1764	jag	3540	MENU.load_range_mod (din0.dinfo.sel_range);
1452	jag	3541	}
		3542
		3543	VALUE_CHANGED(menu, sp_ran_mod_width_lis) {
2108	jag	3544	float v = MENU.sp_ran_mod_width.value;
		3545	din0.ranges [din0.dinfo.sel_range].mod.fm.depth = v;
1764	jag	3546	sprintf (BUFFER, "Range %d, Modulation Width = %0.3f", din0.dinfo.sel_range, v);
		3547	cons << BUFFER << eol;
1452	jag	3548	}
		3549
		3550	VALUE_CHANGED(menu, sp_ran_mod_width_bpm_lis) {
2108	jag	3551	float v = MENU.sp_ran_mod_width_bpm.value;
1764	jag	3552	din0.ranges[din0.dinfo.sel_range].mod.fm.bv.set_bpm (v);
		3553	sprintf (BUFFER, "Range %d, Modulation Width BPM = %0.3f", din0.dinfo.sel_range, v);
		3554	cons << BUFFER << eol;
1452	jag	3555	}
		3556
		3557	VALUE_CHANGED(menu, sp_ran_mod_height_lis) {
2108	jag	3558	float v = MENU.sp_ran_mod_height.value;
1764	jag	3559	din0.ranges[din0.dinfo.sel_range].mod.am.depth = v;
		3560	sprintf (BUFFER, "Range %d, Modulation Height = %0.3f", din0.dinfo.sel_range, v);
		3561	cons << BUFFER << eol;
1452	jag	3562	}
		3563
		3564	VALUE_CHANGED(menu, sp_ran_mod_height_bpm_lis) {
2108	jag	3565	float v = MENU.sp_ran_mod_height_bpm.value;
1764	jag	3566	din0.ranges[din0.dinfo.sel_range].mod.am.bv.set_bpm (v);
		3567	sprintf (BUFFER, "Range %d, Modulation Height BPM = %0.3f", din0.dinfo.sel_range, v);
		3568	cons << BUFFER << eol;
964	jag	3569	}
		3570
		3571	void range_mod_lis::edited (curve_editor* ed, int i) {
		3572	din0.update_range_mod_solvers (i, ed->mix);
		3573	curve_listener::edited (ed, i);
		3574	}
		3575
		3576	void menu::load_range (int r) {
		3577	sp_range.set_value (r);
1308	jag	3578	load_range_mod (r);
964	jag	3579	}
		3580
1308	jag	3581	void menu::load_range_mod (int r) {
		3582	range& ri = din0.ranges [r];
1760	jag	3583	cb_mod_ran.set_state (ri.mod.active, 0);
964	jag	3584	sp_ran_mod_width.set_value (ri.mod.fm.depth);
		3585	sp_ran_mod_width_bpm.set_value (ri.mod.fm.bv.bpm);
		3586	sp_ran_mod_height.set_value (ri.mod.am.depth);
		3587	sp_ran_mod_height_bpm.set_value (ri.mod.am.bv.bpm);
1436	jag	3588	ol_fixed.set_text (ol_fixed_lbls [ri.fixed]);
1401	jag	3589	print_range_info (ri);
964	jag	3590	}
		3591
		3592	void snap_drones_listener::picked (label& l, int dir) {
		3593	din0.dinfo.snap.style += dir;
1012	jag	3594	static const char* ss [] = {" Free", " Slide", " Lock", " Mirror"};
964	jag	3595	wrap<int> (din_info::snap_t::FREE, din0.dinfo.snap.style, din_info::snap_t::MIRROR);
		3596	l.set_text (ss[din0.dinfo.snap.style]);
		3597	}
		3598
		3599	void snap_drones_listener::changed (field& f) {
2108	jag	3600	float v;
964	jag	3601	if (&f == MENUP.sp_snap_left.f_value) {
2108	jag	3602	v = MENU.sp_snap_left.value;
1804	jag	3603	float dl = v - din0.dinfo.snap.left;
		3604	din0.dinfo.snap.left = v;
964	jag	3605	if (din0.dinfo.snap.style > din_info::snap_t::FREE) {
1012	jag	3606	if (din0.dinfo.snap.style == din_info::snap_t::SLIDE) {
		3607	din0.dinfo.snap.right += dl;
		3608	}
		3609	else if (din0.dinfo.snap.style == din_info::snap_t::LOCK) {
964	jag	3610	din0.dinfo.snap.right = din0.dinfo.snap.left;
1012	jag	3611	}
		3612	else {
		3613	din0.dinfo.snap.right = 1.0f - din0.dinfo.snap.left;
964	jag	3614	}
		3615	MENU.sp_snap_right.set_value (din0.dinfo.snap.right);
1804	jag	3616	}
1012	jag	3617	} else if (&f == MENUP.sp_snap_right.f_value) {
2108	jag	3618	v = MENU.sp_snap_right.value;
1804	jag	3619	float dr = v - din0.dinfo.snap.right;
		3620	din0.dinfo.snap.right = v;
964	jag	3621	if (din0.dinfo.snap.style > din_info::snap_t::FREE) {
		3622	if (din0.dinfo.snap.style == din_info::snap_t::LOCK) {
		3623	din0.dinfo.snap.left = din0.dinfo.snap.right;
1012	jag	3624	} else if (din0.dinfo.snap.style == din_info::snap_t::SLIDE) {
		3625	din0.dinfo.snap.left += dr;
964	jag	3626	} else {
		3627	din0.dinfo.snap.left = 1.0f - din0.dinfo.snap.right; // mirror
		3628	}
		3629	MENU.sp_snap_left.set_value (din0.dinfo.snap.left);
		3630	}
		3631	}
		3632
1804	jag	3633	if (din0.dinfo.snap.left > din0.dinfo.snap.right \|\| din0.dinfo.snap.left < 0.0f \|\| din0.dinfo.snap.right > 1.0f)
		3634	cons << RED;
		3635	else
		3636	cons << GREEN;
964	jag	3637	sprintf (BUFFER, "Snap left = %0.3f, Snap right = %0.3f", din0.dinfo.snap.left, din0.dinfo.snap.right);
		3638	cons << BUFFER << eol;
		3639	}
		3640
		3641	void scope_listener::changed (field& f) {
2109	jag	3642	int n = 0;
964	jag	3643	if (&f == MENUP.sp_scope_height.f_value) {
2109	jag	3644	n = MENU.sp_scope_height.value;
		3645	scope.set_height (n);
964	jag	3646	static const string ht = "Height = ";
		3647	cons << YELLOW << ht << n << eol;
1920	jag	3648	} else if (&f == MENUP.sp_scope_samples.f_value) {
2109	jag	3649	n = MENU.sp_scope_samples.value;
2113	jag	3650	n = scope.set_num_samples (n);
964	jag	3651	static const string ns = "Samples = ";
		3652	cons << YELLOW << ns << n << eol;
1920	jag	3653	} else {
2109	jag	3654	float o = MENU.scopacity.value;
		3655	scope.setopacity (o);
1920	jag	3656	static const string op = "Opacity = ";
1921	jag	3657	cons << YELLOW << op << o << eol;
964	jag	3658	}
		3659	}
		3660
		3661	void scope_listener::changed (checkbutton& cb) {
		3662	scope.visible = cb.state;
		3663	}
		3664
		3665	void scope_listener::setup () {
		3666	if (scope.visible) MENU.cb_scope.turn_on (0); else MENU.cb_scope.turn_off (0);
		3667	MENU.sp_scope_height.set_value (scope.height);
		3668	MENU.sp_scope_samples.set_value (scope.num_samples);
1921	jag	3669	MENU.scopacity.set_value (scope.opacity);
964	jag	3670	}
		3671
		3672	void tap_bpm_listener::changed (tap_display& td) {
		3673	sprintf (BUFFER, "%.3f", td.bpm);
		3674	MENU.l_tap_bpm_value.set_text (BUFFER);
		3675	extern double TAP_BPM; TAP_BPM = td.bpm;
		3676	Tcl_UpdateLinkedVar (interpreter.interp, "tapbpm");
		3677	}
		3678
		3679	void tap_bpm_listener::changed (checkbutton& cb) {
		3680	checkbutton* cbs [] = {MENUP.cb_am, MENUP.cb_fm, MENUP.cb_gater, MENUP.cb_octave_shift};
		3681	const char* targets [] = {"am", "fm", "gr", "os"};
		3682	for (int i = 0; i < 4; ++i) {
		3683	checkbutton* cbi = cbs[i];
		3684	if (&cb == cbi) {
		3685	if (cbi->state)
		3686	sprintf (BUFFER, "add-tap-target %s", targets[i]);
		3687	else
		3688	sprintf (BUFFER, "remove-tap-target %s", targets[i]);
		3689	interpreter (BUFFER);
		3690	return;
		3691	}
		3692	}
		3693	if (&cb == MENUP.cb_auto_reset) {
		3694	if (MENU.cb_auto_reset.state) interpreter ("set resetbeat 1"); else interpreter ("set resetbeat 0");
		3695	}
		3696	}
		3697
		3698	void pan_zoom_listener::clicked (button& b) {
1128	jag	3699	if (&b == MENUP.abe_left) {CRVED->do_panx (1); cons << YELLOW << "You can press a to move curves left" << eol;}
		3700	else if (&b == MENUP.abe_right) {CRVED->do_panx (-1); cons << YELLOW << "You can press d to move curves right"<< eol;}
		3701	else if (&b == MENUP.abe_up) {CRVED->do_pany (-1); cons << YELLOW << "You can press w to move curves up" << eol;}
		3702	else if (&b == MENUP.abe_down) {CRVED->do_pany (+1); cons << YELLOW << "You can press s to move curves down" << eol;}
		3703	else if (&b == MENUP.pb_zoom_in) {CRVED->do_zoom (-1); cons << YELLOW << "You can press e to zoom in" << eol;}
		3704	else {CRVED->do_zoom (+1);cons << YELLOW << "You can press q to zoom out" << eol;}
964	jag	3705	}
		3706
1901	jag	3707	void snap_listener::clicked (button& b) {
		3708	static int xs [] = {0, 1, 0, 1};
		3709	static int ys [] = {0, 0, 1, 1};
		3710	static const char* mesgs [] = {
		3711	"You can press n to turn off snapping", "You can press x to snap X",
		3712	"You can press y to snap Y", "You can press b to snap both X and Y"
		3713	};
		3714	button* snaps [] = {MENUP.b_snapnone, MENUP.b_snapx, MENUP.b_snapy, MENUP.b_snapboth};
1225	jag	3715	for (int i = 0; i < 4; ++i) {
1901	jag	3716	if (&b == snaps[i]) {
1900	jag	3717	CRVED->set_snap (xs[i], ys[i]);
964	jag	3718	cons << YELLOW << mesgs[i] << eol;
1225	jag	3719	break;
964	jag	3720	}
		3721	}
		3722	}
		3723
2222	jag	3724	void snap_listener::changed (checkbutton& cb) {
		3725	toggle (CRVED->draww.snaps, basic_editor::drawt::snapss);
		3726	}
		3727
		3728	void menu::undoredoviewlis::changed (checkbutton& cb) {
2223	jag	3729	int& urw = CRVED->undo_redo_win;
		3730	urw = !urw;
		3731	static const char* urws[] = {"Wont", "Will"};
		3732	cons << YELLOW << urws[urw] << " change view on undo or redo" << eol;
2222	jag	3733	}
		3734
		3735	void menu::drawcursorlis::changed (checkbutton& cb) {
		3736	::toggle (CRVED->draww.guide, basic_editor::drawt::guides);
		3737	}
		3738
964	jag	3739	void menu::set_mirror_tangents (int i) {
		3740	const static char* mit [] = {" Tangents are not mirrored", " Tangents are mirrored"};
		3741	ol_mirror_tangents.option.set_text (mit[i]);
		3742	}
		3743
		3744	void menu::set_repeat (button** B, int n, double dt) {
		3745	for (int i = 0; i < n; ++i) {
		3746	button* bi = B[i];
		3747	bi->click_repeat = 1;
		3748	bi->first_repeat_time = bi->subsequent_repeat_time = dt;
		3749	}
		3750	}
		3751
		3752	void menu::set_pan_repeat (double dt) {
		3753	button* ab [] = {&abe_left, &abe_right, &abe_up, &abe_down, &abm_left, &abm_right, &abm_up, &abm_down};
		3754	set_repeat (ab, 8, dt);
		3755	}
		3756
		3757	void menu::set_zoom_repeat (double dt) {
		3758	button* zb [] = {&pb_zoom_in, &mb_zoom_out, &bm_zoom_in, &bm_zoom_out};
		3759	set_repeat (zb, 4, dt);
		3760	}
		3761
1685	jag	3762	void menu::curve_ops_listener::clicked (button& b) {
964	jag	3763	int toggle = 1;
		3764	if (&b == MENUP.b_undo) {
		3765	cons << YELLOW << "You can press z to undo!" << eol;
1128	jag	3766	CRVED->do_undo ();
964	jag	3767	toggle = 0;
		3768	} else
		3769	if (&b == MENUP.b_redo) {
		3770	cons << YELLOW << "You can press LSHIFT + z to redo!" << eol;
1128	jag	3771	CRVED->do_redo ();
964	jag	3772	toggle = 0;
		3773	} else
		3774	if (&b == MENUP.abl_left) {
1117	jag	3775	cons << YELLOW << "You can press 9 to load previous curve from library" << eol;
1128	jag	3776	CRVED->do_load_curve (-1);
964	jag	3777	toggle = 0;
		3778	} else
		3779	if (&b == MENUP.abl_right) {
1117	jag	3780	cons << YELLOW << "You can press 0 to load next curve from library" << eol;
1128	jag	3781	CRVED->do_load_curve (+1);
964	jag	3782	toggle = 0;
		3783	}
		3784	if (&b == MENUP.b_insert_vertex) {
1128	jag	3785	CRVED->insert_using_menu ();
964	jag	3786	} else if (&b == MENUP.b_delete_vertex) {
1128	jag	3787	CRVED->remove_using_menu ();
1950	jag	3788	} else if (&b == MENUP.b_stop_rotating) {
		3789	MENU.sp_curve_rpm.set_value (0);
		3790	CRVED->set_rpm (0);
		3791	cons << "Stopped rotating curve" << eol;
		3792	} else if (&b == MENUP.ed_flip_rotation) {
1955	jag	3793	int& dir = CRVED->curveinfo[CRVED->curcrv].dir;
		3794	dir *= -1;
1950	jag	3795	static const char* cac [] = {"clockwise", "", "anti-clockwise"};
1955	jag	3796	cons << "Curve rotation is " << cac[dir+1] << eol;
1950	jag	3797	} else if (&b == MENUP.ed_autoflip_reset) {
1955	jag	3798	CRVED->curveinfo[CRVED->curcrv].totang = 0.0f;
1950	jag	3799	cons << "Autoflip reset on curve rotation" << eol;
964	jag	3800	} else if (&b == MENUP.b_fold_tangents) {
1128	jag	3801	CRVED->fold_tangents_using_menu ();
		3802	} else if (&b == MENUP.ol_mirror.option) {
		3803	CRVED->mirror_using_menu ();
964	jag	3804	} else if (&b == MENUP.b_copy) {
1128	jag	3805	CRVED->copy_using_menu ();
2340	jag	3806	} else if (&b == MENUP.ol_paste.option) {
1128	jag	3807	CRVED->paste_using_menu ();
		3808	} else if (&b == MENUP.b_swap_curves) {
		3809	CRVED->swap ();
		3810	} else if (&b == MENUP.b_pick_curve) {
		3811	CRVED->do_pick_curve ();
964	jag	3812	}
		3813	// to library
		3814	else if (&b == MENUP.b_add_curve) {
1128	jag	3815	CRVED->add_curve ();
964	jag	3816	} else if (&b == MENUP.b_replace_curve) {
1128	jag	3817	CRVED->replace_curve ();
964	jag	3818	} else if (&b == MENUP.b_delete_curve) {
1128	jag	3819	CRVED->delete_curve ();
964	jag	3820	} else if (&b == MENUP.b_draw_replacement_curve) {
1128	jag	3821	CRVED->draw_replacement_curve_using_menu ();
964	jag	3822	} else if (&b == MENUP.b_start_capture) {
1128	jag	3823	CRVED->start_mouse_capture_from_menu ();
964	jag	3824	} else if (&b == MENUP.b_assign_capture) {
1128	jag	3825	CRVED->assign_mouse_capture_from_menu ();
2125	jag	3826	} else if (&b == MENUP.size_tangent) {
		3827	CRVED->try_sizing_tangent ();
2219	jag	3828	} else if (&b == MENUP.pinunpin) {
		3829	CRVED->pinunpin_using_menu ();
964	jag	3830	}
1784	jag	3831	if (toggle) TOGGLEMENU
964	jag	3832	}
		3833
2122	jag	3834	void menu::curve_ops_listener::moused (int dir, double scl) {
2125	jag	3835	CRVED->size_tangent (dir * scl);
2122	jag	3836	}
		3837
1685	jag	3838	void menu::curve_ops_listener::changed (checkbutton& cb) {
1117	jag	3839	int tog = 0;
1950	jag	3840	int cbstate = cb.state;
		3841	if (&cb == MENUP.cb_ed_autoflip) {
1955	jag	3842	curve_info& ci = CRVED->curveinfo[CRVED->curcrv];
		3843	ci.autoflip = cbstate;
		3844	ci.totang = 0.0f;
1957	jag	3845	} else if (&cb == MENUP.sp_curve_every.variance.cb) {
		3846	curve_info& ci = CRVED->curveinfo[CRVED->curcrv];
1958	jag	3847	ci.randoflip = cbstate;
1950	jag	3848	} else if (&cb == MENUP.cb_mark_segments) {
2126	jag	3849	CRVED->marksegments = cbstate;
964	jag	3850	} else if (&cb == MENUP.cb_label_vertices) {
1950	jag	3851	CRVED->label_vertices = cbstate;
964	jag	3852	} else if (&cb == MENUP.cb_show_waveform_samples) {
1128	jag	3853	CRVED->toggle_waveform_samples_display ();
964	jag	3854	} else if (&cb == MENUP.cb_draw_curve) {
2126	jag	3855	CRVED->drawcurve = cbstate;
		3856	} else if (&cb == MENUP.draweditables) {
		3857	CRVED->draweditables = cbstate;
1071	jag	3858	} else {
1950	jag	3859	CRVED->overlay = cbstate;
1117	jag	3860	string n (get_current_instrument()->name);
1950	jag	3861	if (cbstate)
1117	jag	3862	cons << GREEN << "Overlaid the " << n << eol;
		3863	else
		3864	cons << RED << "Removed " << n << " from overlay." << eol;
		3865	tog = 1;
1071	jag	3866	}
1784	jag	3867	if (tog) TOGGLEMENU
964	jag	3868	}
		3869
1685	jag	3870	void menu::curve_ops_listener::changed (field& f) {
1959	jag	3871	if (&f == MENUP.sp_curve_rpm.f_value) {
2103	jag	3872	CRVED->set_rpm (MENU.sp_curve_rpm.value);
1950	jag	3873	} else if (&f == MENUP.sp_curve_every.f_value) {
1955	jag	3874	curve_info& ci = CRVED->curveinfo[CRVED->curcrv];
2103	jag	3875	ci.every0 = MENU.sp_curve_every.value;
1958	jag	3876	ci.every = ci.every0.deg;
1950	jag	3877	static const char* ae = "Autoflip every ", *deg = DEGREES;
1958	jag	3878	cons << ae << ci.every0.deg << deg << eol;
1959	jag	3879	} else if (&f == MENUP.sp_curve_every.variance.fld) {
		3880	curve_info& ci = CRVED->curveinfo[CRVED->curcrv];
		3881	ci.rd = MENU.sp_curve_every.variance.rd;
2039	jag	3882	} else if (&f == MENUP.crvwav.hz.f_value) {
2106	jag	3883	CRVED->set_hz (MENU.crvwav.hz.value);
2039	jag	3884	} else if (&f == MENUP.crvwav.periods.f_value) {
2106	jag	3885	CRVED->set_periods (MENU.crvwav.periods.value);
2039	jag	3886	} else if (&f == MENUP.crvwav.time.f_value) {
2106	jag	3887	curve_samples::nsec = MENU.crvwav.time.value;
964	jag	3888	} else if (&f == MENUP.sp_curve_limit.f_value) {
2106	jag	3889	CRVED->set_limit (MENU.sp_curve_limit.value);
964	jag	3890	} else {
		3891	if (f.text == "") f.set_text ("nameless");
1128	jag	3892	CRVED->set_picked_curve_name (f.text);
1945	jag	3893	vector<widget*>& tc = MENU.tab_members [MENUP.cb_ed_curves];
		3894	widget* wcc = tc [1 + CRVED->curcrv]; // 0 = separator
		3895	checkbutton* cb = dynamic_cast<checkbutton*>(wcc);
		3896	cb->set_text (f.text);
964	jag	3897	}
		3898	}
		3899
2121	jag	3900	void menu::curve_ops_listener::after_slide () {
2122	jag	3901	CRVED->quick_nothing ();
2121	jag	3902	}
964	jag	3903
		3904	void recording_listener::typing (field& f) {
		3905	string fname (recorder0.folder + f.text);
		3906	string cmd ("file exists " + fname);
		3907	interpreter (cmd); int result; stringstream ss; ss << interpreter.result; ss >> result;
1120	jag	3908	if (result) MENU.b_save.set_text ("Overwrite"); else MENU.b_save.set_text ("Save");
964	jag	3909	recorder0.fname = f.text;
		3910	}
		3911
		3912	void recording_listener::changed (checkbutton& cb) {
		3913	int state = cb.state;
		3914	if (state == 0) { // show recording save section of file menu
		3915	MENU.changed (MENU.cb_file);
1784	jag	3916	if (MENU.show == 0) TOGGLEMENU
964	jag	3917	} else { // close file menu
1784	jag	3918	if (MENU.show == 1) TOGGLEMENU
964	jag	3919	}
2146	jag	3920	justset (uis.cb_record, state);
		3921	justset (MENU.cb_record, state);
964	jag	3922	}
		3923
		3924	void mondrian_listener::handle_split (int& var, int dir, float t) {
		3925	switch (var) {
		3926	case 0: // into 2 boxes
		3927	mondrian0.split_rect (dir, t);
		3928	break;
		3929	case 1: // into notes
		3930	mondrian0.multi_split_rect (dir);
		3931	break;
		3932	case 2: // into n x n grid
		3933	mondrian0.multi_split_rect (mondrian0.num_boxes, dir);
		3934	}
		3935	}
		3936
		3937	void mondrian_listener::clicked (button& b) {
		3938	int toggle = 1;
		3939	if (&b == MENUP.b_split_horizontal) handle_split (hsplit, split::HORIZONTAL, mondrian0.win.mousey);
		3940	else if (&b == MENUP.b_split_vertical) handle_split (vsplit, split::VERTICAL, mondrian0.win.mousex);
		3941	else if (&b == MENUP.b_add_balls) mondrian0.do_add_balls (mondrian0.added_ball_type);
		3942	else if (&b == MENUP.b_add_remove_slits) mondrian0.start_slitting ();
		3943	else if (&b == MENUP.b_modulate_balls_up) {if (!mondrian0.modulate_balls (+1)) cons << RED << "Please select some balls!" << eol;}
		3944	else if (&b == MENUP.b_modulate_balls_down) {if (!mondrian0.modulate_balls (-1)) cons << RED << "Please select some balls!" << eol;}
		3945	else if (&b == MENUP.b_select_all_targets) {mondrian0.select_all_targets ();toggle=0;}
		3946	else if (&b == MENUP.b_invert_selected_targets) {mondrian0.invert_selected_targets ();toggle=0;}
		3947	else if (&b == MENUP.b_select_targets_in_box) {mondrian0.select_box_targets ();toggle=0;}
		3948	else if (&b == MENUP.b_delete_box) mondrian0.delete_current_rect ();
		3949	else if (&b == MENUP.b_delete_all_boxes) mondrian0.delete_all_rects = 1;
		3950	else if (&b == MENUP.b_freeze_balls) mondrian0.freeze_balls (mondrian0.get_balls());
		3951	else if (&b == MENUP.b_thaw_balls) mondrian0.thaw_balls (mondrian0.get_balls());
		3952	else if (&b == MENUP.b_delete_all_targets) mondrian0.delete_all_targets ();
		3953	else if (&b == MENUP.b_delete_selected_targets) mondrian0.delete_selected_targets ();
		3954	else if (&b == MENUP.b_move_selected_balls) mondrian0.do_move_balls ();
		3955	else if (&b == MENUP.b_toggle_wreckers) mondrian0.toggle_balls_type (ball::WRECKER);
		3956	else if (&b == MENUP.b_toggle_healers) mondrian0.toggle_balls_type (ball::HEALER);
		3957	else if (&b == MENUP.b_toggle_bouncers) mondrian0.toggle_balls_type (ball::BOUNCER);
		3958	else if (&b == MENUP.b_switch_ball_type) mondrian0.switch_balls_type ();
		3959	else if (&b == MENUP.b_select_wreckers) mondrian0.select_type (ball::WRECKER);
		3960	else if (&b == MENUP.b_select_healers) mondrian0.select_type (ball::HEALER);
		3961	else if (&b == MENUP.b_remove_slits_on_edge) mondrian0.remove_slits_on_current_edge ();
		3962	else if (&b == MENUP.b_toggle_slit_anim) mondrian0.toggle_slit_anim ();
		3963	else if (&b == MENUP.b_clear_modulations) mondrian0.clear_modulations (mondrian0.get_balls());
		3964	else if (&b == MENUP.b_auto_change_direction_clockwise) {mondrian0.set_auto_rotate (-1);}
		3965	else if (&b == MENUP.b_auto_change_direction_anti_clockwise) {mondrian0.set_auto_rotate (1);}
		3966	else if (&b == MENUP.b_stop_auto_changing_direction) {mondrian0.set_auto_rotate (0);}
		3967	else if (&b == MENUP.b_flip_direction) {mondrian0.flip_velocity();}
		3968	else if (&b == MENUP.b_make_random_color) mondrian0.randomise_box_color();
		3969	else if (&b == MENUP.b_make_note_grid) mondrian0.make_note_grid ();
		3970	else if (&b == MENUP.b_make_nxn_grid) mondrian0.make_nxn_grid ();
1423	jag	3971	else if (&b == MENUP.b_ball_trig) mondrian0.toggle_triggered_sound ();
964	jag	3972	else if (&b == MENUP.abm_left) {mondrian0.do_panx (1); toggle=0;}
		3973	else if (&b == MENUP.abm_right) {mondrian0.do_panx (-1); toggle=0;}
		3974	else if (&b == MENUP.abm_up) {mondrian0.do_pany (+1);toggle=0;}
		3975	else if (&b == MENUP.abm_down) {mondrian0.do_pany (-1); toggle=0;}
		3976	else if (&b == MENUP.bm_zoom_in) {mondrian0.do_zoom(-1); toggle=0;}
		3977	else if (&b == MENUP.bm_zoom_out) {mondrian0.do_zoom(+1); toggle=0;}
1784	jag	3978	if (toggle) TOGGLEMENU
964	jag	3979	}
		3980
		3981	void mondrian_listener::changed (checkbutton& cb) {
		3982	if (&cb == MENUP.cb_auto_split_box) {
		3983	mondrian0.auto_split_rect.active = cb.state;
1887	jag	3984	if (cb.state) mondrian0.auto_split_rect.start ();
964	jag	3985	} else if (&cb == MENUP.cb_auto_delete_box) {
		3986	mondrian0.auto_del_rect.active = cb.state;
1887	jag	3987	if (cb.state) mondrian0.auto_del_rect.start ();
964	jag	3988	} else if (&cb == MENUP.cb_draw_boxes) {
		3989	mondrian0.draw__boxes = cb.state;
		3990	} else if (&cb == MENUP.cb_fill_boxes) {
		3991	mondrian0.fill_boxes = cb.state;
		3992	} else if (&cb == MENUP.cb_draw_notes) {
		3993	mondrian0.draw__notes = cb.state;
		3994	} else if (&cb == MENUP.cb_label_notes) {
		3995	mondrian0.label_notes = cb.state;
		3996	} else if (&cb == MENUP.cb_label_hz_vol) {
		3997	mondrian0.label_hz_vol = cb.state;
		3998	} else if (&cb == MENUP.cb_draw_ball_position) {
		3999	mondrian0.draw_ball.position = cb.state;
		4000	} else if (&cb == MENUP.cb_draw_ball_heading) {
		4001	mondrian0.draw_ball.heading = cb.state;
		4002	} else if (&cb == MENUP.cb_draw_ball_trails) {
		4003	mondrian0.draw_ball.trails = cb.state;
		4004	} else if (&cb == MENUP.cb_mondrian_auto_adjust_voices) {
		4005	mondrian0.auto_adjust_voices = cb.state;
		4006	}
		4007	}
		4008
		4009	void ball_speed_listener::changed (field& f) {
1063	jag	4010	mondrian0.change_speed (MENU.sp_mondrian_change_speed, MENU.sp_mondrian_change_speed.dir_delta ());
964	jag	4011	}
		4012
		4013	void ball_direction_listener::changed (field& f) {
1063	jag	4014	mondrian0.rotate_velocity (MENU.sp_mondrian_change_dir.dir);
964	jag	4015	}
		4016
		4017	void ball_volume_listener::changed (field& f) {
1069	jag	4018	mondrian0.change_ball_vol_mult (MENU.sp_mondrian_change_vol);
964	jag	4019	}
		4020
		4021	void trail_length_listener:: changed (field& f) {
1063	jag	4022	mondrian0.change_trail_size (MENU.sp_mondrian_change_trail_size);
964	jag	4023	}
		4024
1063	jag	4025	void ball_attack_time_listener:: changed (field& f) {
		4026	mondrian0.change_attack_time_kb (MENU.sp_mondrian_change_attack_time);
964	jag	4027	}
		4028
1063	jag	4029	void ball_decay_time_listener:: changed (field& f) {
		4030	mondrian0.change_decay_time_kb (MENU.sp_mondrian_change_decay_time);
964	jag	4031	}
		4032
		4033	void slit_size_listener:: changed (field& f) {
1063	jag	4034	mondrian0.change_slit_size (MENU.sp_mondrian_change_slit_size);
964	jag	4035	}
		4036
		4037	void slit_anim_time_listener:: changed (field& f) {
1063	jag	4038	mondrian0.change_slit_anim_time (MENU.sp_mondrian_change_slit_anim_time);
964	jag	4039	}
		4040
		4041	void note_poly_radius_listener::changed (field& f) {
2109	jag	4042	mondrian0.set_note_poly_radius (MENU.sp_mondrian_change_note_poly_radius.value);
964	jag	4043	}
		4044
		4045	void note_poly_points_listener::changed (field& f) {
2109	jag	4046	mondrian0.set_note_poly_points (MENU.sp_mondrian_change_note_poly_points.value);
964	jag	4047	}
		4048
		4049	void mondrian_listener::changed (field& f) {
2109	jag	4050
		4051	if (&f == MENUP.sp_mondrian_change_speed.f_delta) {
		4052	float ds = MENU.sp_mondrian_change_speed.value;
		4053	mondrian0.delta_speed = ds;
		4054	} else if (&f == MENUP.sp_mondrian_min_voices.f_value) {
		4055	int v = MENU.sp_mondrian_min_voices.value;
		4056	mondrian0.min_voices = v;
964	jag	4057	uis.update_bottom_line ();
		4058	cons << YELLOW << "Min voices = " << mondrian0.min_voices << eol;
		4059	} else if (&f == MENUP.sp_mondrian_num_boxes.f_value) {
2109	jag	4060	mondrian0.num_boxes = MENU.sp_mondrian_num_boxes.value;
964	jag	4061	cons << YELLOW << "Number of boxes = " << mondrian0.num_boxes << eol;
		4062	} else if (&f == MENUP.sp_auto_split_time.f_value) {
2109	jag	4063	float t = MENU.sp_auto_split_time.value;
		4064	mondrian0.auto_split_rect.triggert = t;
		4065	cons << YELLOW << "Split box every = " << t << " secs" << eol;
964	jag	4066	} else if (&f == MENUP.sp_auto_delete_time.f_value) {
2109	jag	4067	float t = MENU.sp_auto_delete_time.value;
		4068	mondrian0.auto_del_rect.triggert = t;
		4069	cons << YELLOW << "Delete box every = " << t << " secs" << eol;
964	jag	4070	} else {
2109	jag	4071	int mss = MENU.sp_min_split_size.value;
		4072	mondrian::min_split_size = mss;
		4073	cons << YELLOW << "Min split size = " << mss << eol;
964	jag	4074	}
		4075	}
		4076
		4077	void mondrian_listener::handle_auto_pick_box (options_list& ol, int dir, int& v) {
		4078	v += dir;
		4079	wrap<int> (rect::EARLIEST, v, rect::BALLED);
		4080	ol.set_text (pick_box_types[v]);
		4081	}
		4082
		4083	void mondrian_listener::picked (label& lbl, int dir) {
		4084	if (&lbl == MENUP.ol_auto_pick_box_split.option) {
		4085	handle_auto_pick_box (MENU.ol_auto_pick_box_split, dir, mondrian0.split_leaf);
		4086	} else if (&lbl == MENUP.ol_auto_pick_box_delete.option) {
		4087	handle_auto_pick_box (MENU.ol_auto_pick_box_delete, dir, mondrian0.delete_leaf);
		4088	} else if (&lbl == MENUP.ol_auto_split_at.option) {
		4089	mondrian0.auto_split_at += dir;
		4090	if (mondrian0.auto_split_at < split::NOTES) mondrian0.auto_split_at = split::ANYWHERE;
		4091	else if (mondrian0.auto_split_at > split::ANYWHERE) mondrian0.auto_split_at = split::NOTES;
		4092	MENU.ol_auto_split_at.set_text (auto_split_at_types [mondrian0.auto_split_at]);
		4093	} else if (&lbl == MENUP.ol_auto_split_orient.option) {
		4094	mondrian0.auto_split_orient += dir;
		4095	if (mondrian0.auto_split_orient < split::HORIZONTAL) mondrian0.auto_split_orient = split::BOTH;
		4096	else if (mondrian0.auto_split_orient > split::BOTH) mondrian0.auto_split_orient = split::HORIZONTAL;
		4097	MENU.ol_auto_split_orient.set_text (auto_split_orient_types [mondrian0.auto_split_orient]);
		4098	} else if (&lbl == MENUP.ol_ball_types.option) {
		4099	mondrian0.added_ball_type += dir;
		4100	if (mondrian0.added_ball_type < ball::BOUNCER)
		4101	mondrian0.added_ball_type = ball::HEALER;
		4102	else if (mondrian0.added_ball_type > ball::HEALER)
		4103	mondrian0.added_ball_type = ball::BOUNCER;
		4104	MENU.ol_ball_types.set_text (ball::types_str[mondrian0.added_ball_type]);
		4105	} else if (&lbl == MENUP.ol_split_types_h.option) {
		4106	hsplit += dir;
		4107	check_split_type (MENU.ol_split_types_h, hsplit);
		4108	} else if (&lbl == MENUP.ol_split_types_v.option) {
		4109	vsplit += dir;
		4110	check_split_type (MENU.ol_split_types_v, vsplit);
		4111	} else if (&lbl == MENUP.ol_selection_targets.option) {
		4112	mondrian0.clear_selected_targets ();
		4113	mondrian0.sel_tar = !mondrian0.sel_tar;
		4114	MENU.ol_selection_targets.set_text (selection_targets[mondrian0.sel_tar]);
		4115	static const char* bb [] = {"Select all balls", "Select balls in box", "Invert selected balls", "Delete all balls", "Delete selected balls"};
		4116	static const char* bs [] = {"Select all slits", "Select slits in box", "Invert selected slits", "Remove all slits", "Remove selected slits"};
		4117	const char** pb [] = {bs, bb};
		4118	button* bt [] = {
		4119	MENUP.b_select_all_targets, MENUP.b_select_targets_in_box,
		4120	MENUP.b_invert_selected_targets, MENUP.b_delete_all_targets,
		4121	MENUP.b_delete_selected_targets
		4122	};
		4123	const char** cb = pb[mondrian0.sel_tar];
1120	jag	4124	for (int i = 0; i < 5; ++i) bt[i]->set_text (cb[i]);
964	jag	4125	}
		4126	}
		4127
		4128	void mondrian_listener::check_split_type (options_list& ol, int& o) {
		4129	if (o < 0) o = MAX_SPLIT_TYPES; else if (o > MAX_SPLIT_TYPES) o = 0;
		4130	ol.set_text (split_types[o]);
		4131	}
		4132
		4133
		4134	binaural_drones_listener::binaural_drones_listener () : select_rule (GREATER_THAN_EQUAL), select_what (0) {
		4135	val[EQUAL] = "0";
		4136	val[GREATER_THAN_EQUAL] = val[LESSER_THAN_EQUAL]= "100";
		4137	val[ID] = "1 2 1";
		4138	val[RANGE] = "100 200";
		4139	just = binaural_drone::CENTER;
		4140	}
		4141
		4142	void binaural_drones_listener::changed (field& f) {
2110	jag	4143	float v = float (f);
964	jag	4144	if (&f == MENUP.lf_bd_start_pitch.fld) {
		4145	binaural_drones0.starting_pitch = v;
		4146	} else if (&f == MENUP.lf_master_volume.fld) {
		4147	float ov = binaural_drones0.master_volume * 100.0f;
		4148	float mv = v / 100.0f;
		4149	binaural_drones0.master_volume = mv;
		4150	stringstream cmd;
		4151	cmd << "set-all-binaurals-volume " << mv;
		4152	interpreter (cmd.str());
		4153	sprintf (BUFFER, "Master Volume from %0.2f%% to %0.2f%% : please wait or ESC to abort", ov, v);
		4154	cons << YELLOW << BUFFER << eol;
		4155	} else if (&f == MENUP.lf_vol_fade_time.fld) {
		4156	binaural_drones0.vol_fader.set_duration (v);
		4157	} else if (&f == MENUP.lf_pitch_fade_time.fld) {
		4158	binaural_drones0.pitch_fader.set_duration (v);
		4159	} else if (&f == MENUP.lf_modulation_amount.fld) {
		4160	if (v < 1.0f) {
		4161	v = 1.0f;
		4162	MENU.lf_modulation_amount.fld.set_text (v);
		4163	}
		4164	binaural_drones0.modulation_amount = v;
		4165	} else if (&f == MENUP.lf_bd_spacing.fld) {
		4166	binaural_drones0.spacing = v;
		4167	} else if (&f == MENUP.bdf_value) {
		4168	val[select_rule] = MENU.bdf_value.text;
		4169	MENU.bdl.clicked (MENU.bbd_select2);
		4170	} else if (&f == MENUP.lf_vol.fld) {
		4171	float vp = v / 100.0f;
		4172	sprintf (BUFFER, "set-selected-binaurals-volume %f", vp);
		4173	interpreter (BUFFER);
		4174	} else if (&f == MENUP.lf_l.fld) {
		4175	set_hz (binaural_drone::LEFT, v);
		4176	} else if (&f == MENUP.lf_r.fld) {
		4177	set_hz (binaural_drone::RIGHT, v);
		4178	} else if (&f == MENUP.lf_sep.fld) {
		4179	int j = 0;
		4180	for (int i = 0; i < MENU.il_binaural_drones.n; ++i) {
1532	jag	4181	if (MENU.il_binaural_drones.items[i].sel) {
964	jag	4182	binaural_drone* bi = binaural_drones0.binaural_drones[i];
		4183	bi->set_sep (v);
		4184	++j;
		4185	}
		4186	}
		4187	if (j)
		4188	binaural_drones0.pitch_fader.start ("Separation Hz set");
		4189	else
		4190	cons << RED << "Please select some binaural drone pairs" << eol;
		4191	}
		4192	}
		4193
		4194	void binaural_drones_listener::set_hz (int w, float v) {
		4195
		4196	int n = MENU.il_binaural_drones.num_selected ();
		4197	if (n == 0) {
		4198	cons << RED << "Please select some binaural drone pairs" << eol;
		4199	return;
		4200	}
		4201
		4202	if (n == 1) {
		4203	int i = MENU.il_binaural_drones.get_first ();
		4204	binaural_drone* bi = binaural_drones0.binaural_drones[i];
		4205	bi->set_hz (w, v); // v is absolute
		4206	binaural_drones0.pitch_fader.start ("Hz set");
		4207	} else {
		4208	for (int i = 0; i < MENU.il_binaural_drones.n; ++i) {
1532	jag	4209	if (MENU.il_binaural_drones.items[i].sel) {
964	jag	4210	binaural_drone* bi = binaural_drones0.binaural_drones[i];
		4211	float ohz [] = {bi->l_hz, bi->r_hz};
		4212	bi->set_hz (w, ohz[w] + v); // v is relative
		4213	}
		4214	}
		4215	binaural_drones0.pitch_fader.start ("Hz change");
		4216	}
		4217	}
		4218
		4219	void binaural_drones_listener::picked (label& lbl, int dir) {
		4220	if (&lbl == MENUP.ol_justification.option) {
		4221	int j = binaural_drones0.change_justification (dir);
		4222	MENU.ol_justification.set_text (justs[j]);
		4223	} else if (&lbl == MENUP.ol_key_note.option) {
		4224	int k = binaural_drones0.change_key_note (dir);
		4225	const string kn [] = {"start pitch", "from scale"};
		4226	MENU.ol_key_note.set_text (" Key note is " + kn[k]);
		4227	} else if (&lbl == MENUP.ol_select_what.option) {
		4228	select_what += dir;
		4229	wrap<int> (binaural_drone::LEFT, select_what, binaural_drone::VOLUME);
		4230	const string sc [] = {"L ", "R ", "Separation ", "Volume "};
		4231	MENU.ol_select_what.set_text (sc[select_what]);
		4232	MENU.ol_select_rule.set_pos (MENU.ol_select_what.extents.right, MENU.ol_select_rule.posy);
		4233	MENU.bdf_value.set_pos (MENU.ol_select_rule.extents.right, MENU.bdf_value.posy);
		4234	} else if (&lbl == MENUP.ol_select_rule.option) {
		4235	select_rule += dir;
		4236	wrap<int> (EQUAL, select_rule, ID);
		4237	const string sr [] = {" = ", " >= ", " <= ", " <> ", " id "};
		4238	MENU.ol_select_rule.set_text (sr[select_rule]);
		4239	MENU.bdf_value.set_text (val[select_rule]);
		4240	MENU.bdf_value.set_pos (MENU.ol_select_rule.extents.right, MENU.bdf_value.posy);
		4241	} else if (&lbl == MENUP.ol_just.option) {
		4242	just += dir;
		4243	wrap<int> (binaural_drone::LEFT, just, binaural_drone::CENTER);
		4244	MENU.ol_just.set_text (justs[just]);
		4245	for (int i = 0; i < MENU.il_binaural_drones.n; ++i) {
1532	jag	4246	if (MENU.il_binaural_drones.items[i].sel) {
964	jag	4247	binaural_drone* bi = binaural_drones0.binaural_drones[i];
		4248	bi->set_just (just);
		4249	}
		4250	}
		4251	}
		4252	}
		4253
		4254	void binaural_drones_listener::selected (item_list& il, int s) {
		4255	int ns = il.num_selected ();
		4256	if (ns == 1) {
1301	jag	4257	binaural_drone* bs = binaural_drones0.binaural_drones[il.get_first()];
964	jag	4258	bs->sel = 1;
		4259	sprintf (BUFFER, "%0.3f", bs->vol*100.0);
		4260	MENU.lf_vol.set_text (BUFFER);
		4261	sprintf (BUFFER, "%0.3f", bs->l_hz);
		4262	MENU.lf_l.set_text (BUFFER);
		4263	sprintf (BUFFER, "%0.3f", bs->r_hz);
		4264	MENU.lf_r.set_text (BUFFER);
		4265	sprintf (BUFFER, "%0.3f", bs->sep);
		4266	MENU.lf_sep.set_text (BUFFER);
		4267	MENU.lf_l.set_label ("L (Hz) ");
		4268	MENU.lf_r.set_label ("R (Hz) ");
		4269	just = bs->just;
		4270	MENU.ol_just.set_text (justs[just]);
		4271	} else {
		4272	if (ns) {
		4273	MENU.lf_l.set_label ("dL (Hz) ");
		4274	MENU.lf_r.set_label ("dR (Hz) ");
		4275	}
		4276	MENU.lf_vol.fld.set_text (0.0f);
		4277	MENU.lf_l.fld.set_text (0.0f);
		4278	MENU.lf_r.fld.set_text (0.0f);
		4279	MENU.lf_sep.fld.set_text (0.0f);
		4280	just = binaural_drone::CENTER;
		4281	MENU.ol_just.set_text (justs[just]);
		4282	for (int i = 0, n = il.n; i < n; ++i) {
		4283	binaural_drone* bi = binaural_drones0.binaural_drones[i];
1532	jag	4284	bi->sel = il.items[i].sel;
964	jag	4285	}
		4286	}
		4287	cons << GREEN << "Selected " << ns << " binaural drone pairs" << eol;
		4288	}
		4289
		4290	void binaural_drones_listener::changed (checkbutton& cb) {
		4291	binaural_drones0.close_octave = MENU.cb_close_octave.state;
		4292	}
		4293
		4294	void menu::update_binaurals_list () {
1532	jag	4295	il_binaural_drones.set_pos (cb_file.extents.left, bbd_select_all.extents.bottom);
964	jag	4296	calc_bg ();
		4297	}
		4298
		4299	ball_ops_listener::ball_ops_listener () {
		4300	op_id = 0;
		4301	}
		4302
		4303	void ball_ops_listener::picked (label& lbl, int dir) {
1302	jag	4304	if (&lbl == MENUP.ol_browse_balls.option) {
		4305	mondrian0.browse_ball (dir);
		4306	return;
		4307	} else {
		4308	label* olt [] = {MENUP.ol_bouncer.option, MENUP.ol_wrecker.option, MENUP.ol_healer.option};
		4309	for (int i = 0; i < 3; ++i) {
		4310	if (&lbl == olt[i]) {
		4311	int& t = Transform::rules [i];
		4312	t += dir;
		4313	if (t < ball::BOUNCER) t = ball::INVALID;
		4314	else if (t > ball::INVALID) t = ball::BOUNCER;
		4315	sprintf (BUFFER, "%s becomes %s", ball::types_str[i], ball::types_str[t]);
		4316	olt[i]->set_text (BUFFER);
		4317	return;
		4318	}
964	jag	4319	}
		4320	}
		4321	}
		4322
		4323	void ball_ops_listener::clicked (button& b) {
		4324	}
		4325
		4326	void ball_ops_listener::changed (checkbutton& cb) {
		4327	ball* b = mondrian0.get_one_selected_ball ();
		4328	if (b) {
		4329	ball_op* ops [] = {&b->op_turn, &b->op_speed, &b->op_teleport, &b->op_clone, &b->op_transform};
		4330	checkbutton* cbn [] = {MENUP.cb_turn, MENUP.cb_speed, MENUP.cb_teleport, MENUP.cb_clone, MENUP.cb_transform};
		4331	for (int i = 0; i < ball_op::NUM_OPS; ++i) {
		4332	if (&cb == cbn[i]) {
		4333	ball_op* opi = ops[i];
1310	jag	4334	// if (cb.state) opi->alarm.start (); else opi->alarm.stop ();
		4335	if (cb.state) opi->start (b); else opi->alarm.stop ();
		4336
964	jag	4337	break;
		4338	}
		4339	}
		4340
1302	jag	4341	/*if (cb.state && (&cb == MENUP.cb_speed)) {
964	jag	4342	MENU.sp_max_speed.set_value (b->V);
		4343	b->op_speed.max = b->V;
1302	jag	4344	}*/
964	jag	4345
		4346	b->op_clone.clone_can_clone = MENU.cb_clone_can_clone.state;
		4347
		4348	} else {
		4349	cons << RED << "Please select a ball!" << eol;
		4350	}
		4351	}
		4352
		4353	void ball_ops_listener::changed (field& f) {
		4354	if (&f == MENUP.sp_max_balls.f_value) {
2110	jag	4355	int i = MENU.sp_max_balls.value;
964	jag	4356	Clone::max_balls = i;
		4357	cons << YELLOW << "Max balls = " << Clone::max_balls << eol;
		4358	} else {
		4359	ball* b = mondrian0.get_one_selected_ball ();
		4360	if (b) {
		4361	if (&f == MENUP.sp_turn_every.f_value) {
2110	jag	4362	float t = MENU.sp_turn_every.value;
964	jag	4363	b->op_turn.alarm.triggert = t;
		4364	sprintf (BUFFER, "Turn every %0.3f seconds", t);
		4365	cons << YELLOW << BUFFER << eol;
		4366	} else
		4367	if (&f == MENUP.sp_turn_min.f_value) {
2110	jag	4368	float minn = MENU.sp_turn_min.value, maxx;
964	jag	4369	if (MENU.cb_turn_sync.state) {
		4370	maxx = minn;
		4371	MENU.sp_turn_max.set_value (maxx);
		4372	} else maxx = b->op_turn.rd.max;
		4373	b->op_turn.rd.set (-minn, maxx);
		4374	sprintf (BUFFER, "Turn Clockwise upto %0.3f degrees \| Anti-clockwise upto %0.3f degrees", minn, maxx);
		4375	cons << YELLOW << BUFFER << eol;
		4376	} else
		4377	if (&f == MENUP.sp_turn_max.f_value) {
2110	jag	4378	float minn, maxx = MENU.sp_turn_max.value;
964	jag	4379	if (MENU.cb_turn_sync.state) {
		4380	MENU.sp_turn_min.set_value (maxx);
		4381	minn = -maxx;
		4382	} else minn = b->op_turn.rd.min;
		4383	b->op_turn.rd.set (minn, maxx);
		4384	sprintf (BUFFER, "Turn Clockwise upto %0.3f degrees \| Anti-clockwise upto %0.3f degrees", -minn, maxx);
		4385	cons << YELLOW << BUFFER << eol;
		4386	} else
		4387	if (&f == MENUP.sp_speed_min.f_value) {
2110	jag	4388	float minn = MENU.sp_speed_min.value, maxx;
964	jag	4389	if (MENU.cb_speed_sync.state) {
		4390	maxx = minn;
		4391	MENU.sp_speed_max.set_value (maxx);
		4392	} else maxx = b->op_speed.rd.max;
		4393	b->op_speed.rd.set (-minn, maxx);
1310	jag	4394	sprintf (BUFFER, "Accelerate = %0.3f \| Brake = %0.3f", maxx, minn);
964	jag	4395	cons << YELLOW << BUFFER << eol;
		4396	} else
		4397	if (&f == MENUP.sp_speed_max.f_value) {
2110	jag	4398	float minn, maxx = MENU.sp_speed_max.value;
964	jag	4399	if (MENU.cb_speed_sync.state) {
		4400	MENU.sp_speed_min.set_value (maxx);
		4401	minn = -maxx;
		4402	} else minn = b->op_speed.rd.min;
		4403	b->op_speed.rd.set (minn, maxx);
		4404	sprintf (BUFFER, "Accelerate = %0.3f \| Brake = %0.3f", maxx, -minn);
		4405	cons << YELLOW << BUFFER << eol;
		4406	} else
		4407	if (&f == MENUP.sp_speed_every.f_value) {
2110	jag	4408	float m = MENU.sp_speed_every.value;
964	jag	4409	b->op_speed.alarm.triggert = m;
		4410	sprintf (BUFFER, "Speed every %0.3f seconds", m);
		4411	cons << YELLOW << BUFFER << eol;
		4412	} else
		4413	if (&f == MENUP.sp_max_speed.f_value) {
2110	jag	4414	float m = MENU.sp_max_speed.value;
964	jag	4415	b->op_speed.max = m;
		4416	sprintf (BUFFER, "Max speed = %0.3f", m);
		4417	cons << YELLOW << BUFFER << eol;
		4418	} else
		4419	if (&f == MENUP.sp_tel_every.f_value) {
2110	jag	4420	float s = MENU.sp_tel_every.value;
964	jag	4421	b->op_teleport.alarm.triggert = s;
		4422	sprintf (BUFFER, "Teleport every %0.3f seconds", s);
		4423	cons << YELLOW << BUFFER << eol;
		4424	} else
		4425	if (&f == MENUP.sp_tel_radius.f_value) {
2110	jag	4426	float r = MENU.sp_tel_radius.value;
964	jag	4427	b->op_teleport.radius = r;
		4428	sprintf (BUFFER, "Max Teleport distance = %0.3f", r);
		4429	cons << YELLOW << BUFFER << eol;
		4430	} else
		4431	if (&f == MENUP.sp_clone_every.f_value) {
2110	jag	4432	float m = MENU.sp_clone_every.value;
964	jag	4433	b->op_clone.alarm.triggert = m;
		4434	sprintf (BUFFER, "Clone every %0.3f seconds", m);
		4435	cons << YELLOW << BUFFER << eol;
		4436	} else
		4437	if (&f == MENUP.sp_max_clones.f_value) {
2110	jag	4438	int i = MENU.sp_max_clones.value;
964	jag	4439	b->op_clone.n = b->op_clone.max = i;
		4440	cons << "Max clones = " << i << eol;
		4441	} else
		4442	if (&f == MENUP.sp_clone_offset.f_value) {
2110	jag	4443	float m = MENU.sp_clone_offset.value;
964	jag	4444	b->op_clone.offset = m;
		4445	cons << YELLOW << "Clone offset = " << m << eol;
		4446	} else
		4447	if (&f == MENUP.sp_transform_every.f_value) {
2110	jag	4448	float m = MENU.sp_transform_every.value;
964	jag	4449	b->op_transform.alarm.triggert = m;
		4450	sprintf (BUFFER, "Transform every %0.3f seconds", m);
		4451	cons << YELLOW << BUFFER << eol;
		4452	}
		4453	} else {
		4454	cons << RED << "Please select a ball! " << eol;
		4455	}
		4456	}
		4457	}
		4458
1768	jag	4459	void arrowlis::changed (field& f) {
		4460	if (&f == MENUP.dronearrow.shoulder.position.f_value) {
		4461	din0.change_drone_arrow (MENU.dronearrow.shoulder.position, 0);
		4462	} else if (&f == MENUP.dronearrow.shoulder.width.f_value) {
		4463	din0.change_drone_arrow (MENU.dronearrow.shoulder.width, 1);
1499	jag	4464	} else {
1804	jag	4465	din0.change_drone_arrow (MENU.dronearrow.neck, 2);
1766	jag	4466	}
964	jag	4467	}
		4468
1778	jag	4469	void defarrowlis::changed (field& f) {
1792	jag	4470	drone::arrowt::U = MENU.dronearrowdefaults.shoulder.position.value;
		4471	drone::arrowt::V = MENU.dronearrowdefaults.shoulder.width.value;
1804	jag	4472	drone::arrowt::K = MENU.dronearrowdefaults.neck.value;
2106	jag	4473	/*cons << GREEN <<
1804	jag	4474	"Drone arrow defaults: Neck = " << drone::arrowt::K <<
1792	jag	4475	", Shoulder pos = " << drone::arrowt::U <<
2106	jag	4476	", Shoulder width = " << drone::arrowt::V << eol;*/
1778	jag	4477	MENU.dronearrowdefaults.arrow.calc ();
		4478	}
		4479
		4480	void defarrowlis::changed (checkbutton& cb) {
		4481	MENU.dronearrowdefaults.arrow.calc ();
		4482	}
		4483
		4484	void drawrrow::calc () {
		4485	int cap = MENU.dronearrowdefaults.cap.state;
		4486	int n = 12;
		4487	make_arrow (pts, 0, cap, n, x, y, ux, uy, vx, vy,
		4488	MENU.dronearrowdefaults.shoulder.position.value,
		4489	MENU.dronearrowdefaults.shoulder.width.value,
1804	jag	4490	MENU.dronearrowdefaults.neck.value);
1778	jag	4491	npts = n / 2;
		4492	}
		4493
		4494	void drone::arrowt::reset () {
		4495	u = MENU.dronearrowdefaults.shoulder.position ();
		4496	v = MENU.dronearrowdefaults.shoulder.width ();
1804	jag	4497	t = MENU.dronearrowdefaults.neck ();
1778	jag	4498	cap = MENU.dronearrowdefaults.cap.state;
		4499	}
		4500
1768	jag	4501	void arrowlis::clicked (button& b) {
		4502	if (&b == MENUP.dronearrow.cap)
		4503	din0.capdronearrows (1);
		4504	else
		4505	din0.capdronearrows (0);
1784	jag	4506	TOGGLEMENU
1768	jag	4507	}
		4508
1778	jag	4509
		4510
964	jag	4511	void range_defaults_lis::changed (field& f) {
		4512	if (&f == MENUP.sp_default_width.f_value) {
		4513	extern int WIDTH;
2110	jag	4514	WIDTH = MENU.sp_default_width.value;
964	jag	4515	cons << "Default Range Width = " << WIDTH << eol;
		4516	} else {
		4517	extern int HEIGHT;
2110	jag	4518	HEIGHT = MENU.sp_default_height.value;
964	jag	4519	cons << "Default Range Height = " << HEIGHT << eol;
		4520	}
		4521	}
		4522
1566	jag	4523	void change_note_listener::moused (int dx, double scl) {
1607	jag	4524	int dir = sign (dx);
		4525	din0.change_range_note (id, dir * scl * delta0);
964	jag	4526	}
		4527
		4528	void change_note_listener::clicked (button& b) {
		4529	if (&b == MENUP.b_change_note_left) {
		4530	mouse_slider0.add (MENUP.cnl);
		4531	} else {
		4532	mouse_slider0.add (MENUP.cnr);
		4533	}
1742	jag	4534	activate_mouse_slider (0, 0);
964	jag	4535	}
		4536
1235	jag	4537	void change_note_both_listener::clicked (button& b) {
		4538	mouse_slider0.add (MENUP.cnl);
		4539	mouse_slider0.add (MENUP.cnr);
1742	jag	4540	activate_mouse_slider (0, 0);
1235	jag	4541	}
		4542
1397	jag	4543	void change_note_options_listener::picked (label& lbl, int dir) {
		4544	if (&lbl == MENUP.ol_change_note.option) {
1400	jag	4545	static const string chg (" Change "), nte ("Note > ");
1399	jag	4546	din0.dinfo.change_note = !din0.dinfo.change_note;
1400	jag	4547	if (din0.dinfo.change_note)
1401	jag	4548	MENU.add_to_tab (MENUP.cb_mkb_ranges, MENUP.ol_change_note_style);
		4549	else
1400	jag	4550	MENU.remove_from_tab (MENUP.cb_mkb_ranges, MENUP.ol_change_note_style);
1402	jag	4551	string cn (din_info::cnno[din0.dinfo.change_note]);
1400	jag	4552	lbl.set_text (chg+cn);
1401	jag	4553	print_range_info (din0.ranges[din0.dinfo.sel_range]);
1397	jag	4554	} else {
		4555	din0.dinfo.change_note_style = !din0.dinfo.change_note_style;
		4556	set (lbl, din0.dinfo.change_note_style);
		4557	}
964	jag	4558	}
		4559
1397	jag	4560	void change_note_options_listener::set (label& lbl, int v) {
1402	jag	4561	lbl.set_text (din_info::cnn_opts[v]);
964	jag	4562	extern scale_info all_notes;
		4563	scale_info* ptr_si [] = {&din0.scaleinfo, &all_notes};
		4564	din0.ptr_scaleinfo = ptr_si[v];
		4565	}
		4566
1685	jag	4567	void menu::pitch_vol_dis_pix_lis::changed (checkbutton& cb) {
1137	jag	4568	if (&cb == MENUP.cb_pitch_dis) {
		4569	din0.dinfo.dist.pitch = cb.state;
		4570	} else {
		4571	din0.dinfo.dist.vol = cb.state;
		4572	}
		4573	}
1140	jag	4574
1685	jag	4575	void menu::pitch_vol_dis_pix_lis::changed (field& f) {
2110	jag	4576	din0.dinfo.dist.pix = MENU.sp_lev_sz.value;
1140	jag	4577	cons << "Pixels per level = " << din0.dinfo.dist.pix << eol;
		4578	}
1320	jag	4579
1742	jag	4580	void prep_drone_xform (mouse_slider_listener* L, int shift = 0, int scalestyle = mouse_slider::scalet::CHANGING) {
1429	jag	4581	din0.freeze_orbiters ();
1430	jag	4582	mouse_slider0.add (L);
1742	jag	4583	activate_mouse_slider (shift, scalestyle);
1429	jag	4584	}
		4585
1984	jag	4586	CLICKED_BUTTON (menu, movlis) {
1679	jag	4587	din0.start_moving_drones ();
1986	jag	4588	TOGGLEMENU
1473	jag	4589	}
		4590
1984	jag	4591	CLICKED_BUTTON (menu, raillis) {
1985	jag	4592	_SELECTED_DRONES_EXIST_
1984	jag	4593	mouse_slider0.add (MENUP.raill1);
		4594	activate_mouse_slider ();
		4595	}
		4596
		4597	MOUSED (menu, raillis1) {
		4598	din0.rail (dir, scl);
		4599	}
		4600
		4601	AFTER_SLIDE(menu, raillis1) {}
		4602
		4603	CLICKED_BUTTON (menu, strafelis) {
1985	jag	4604	_SELECTED_DRONES_EXIST_
1984	jag	4605	mouse_slider0.add (MENUP.strafel1);
		4606	activate_mouse_slider ();
		4607	}
		4608
		4609	MOUSED (menu, strafelis1) {
		4610	din0.strafe (dir, scl);
		4611	}
		4612
		4613	AFTER_SLIDE(menu, strafelis1) {}
		4614
1666	jag	4615	CLICKED_BUTTON (menu, b_set_xform_center_lis) {
		4616	din0.calc_drones_centroid ();
1784	jag	4617	TOGGLEMENU
1611	jag	4618	}
		4619
1473	jag	4620	CLICKED_BUTTON (menu, b_move_drones_under_gravity_lis) {
		4621	din0.set_drones_under_gravity ();
1784	jag	4622	TOGGLEMENU
1473	jag	4623	}
		4624
1477	jag	4625	CLICKED_BUTTON (menu,b_scale_drones_lis) {
		4626	MENU.ms_sdl.name = "Scale";
1628	jag	4627	if (din0.prep_scale_drones ()) {
		4628	int shift = -2; // for 0.01f scaling, assuming base = 10 on mouse slider
1742	jag	4629	prep_drone_xform (MENUP.ms_sdl, shift, mouse_slider::scalet::CHANGING);
1628	jag	4630	} else cons << RED_PSD << eol;
1477	jag	4631	}
		4632
1429	jag	4633	AFTER_SLIDE (menu,ms_scale_drones_lis) {
		4634	din0.thaw_orbiters ();
		4635	}
		4636
		4637	MOUSED (menu,ms_scale_drones_lis) {
1628	jag	4638	din0.scale_drones (dir * scl);
1429	jag	4639	din0.scale_drones ();
		4640	}
		4641
1430	jag	4642	CLICKED_BUTTON (menu,b_rotate_drones_lis) {
1477	jag	4643	MENU.ms_rdl.name = "Rotate";
1430	jag	4644	if (din0.prep_rotate_drones ()) prep_drone_xform (MENUP.ms_rdl); else cons << RED << "Please select some drones!" << eol;
		4645	}
		4646
		4647	AFTER_SLIDE (menu,ms_rotate_drones_lis) {
		4648	din0.thaw_orbiters ();
		4649	}
		4650
		4651	MOUSED (menu,ms_rotate_drones_lis) {
1628	jag	4652	din0.angle += (dir * scl * PI_BY_180);
1430	jag	4653	din0.rotate_drones ();
		4654	}
		4655
1328	jag	4656	CLICKED_BUTTON (menu,set_to_mesh_rows_lis) {
1320	jag	4657	MENU.sp_drones_per_pend.set_value (din0.dinfo.rows);
		4658	MENU.dppl.changed (MENU.sp_drones_per_pend.f_value);
		4659	}
		4660
1328	jag	4661	CLICKED_BUTTON (menu,set_to_mesh_cols_lis) {
1320	jag	4662	MENU.sp_drones_per_pend.set_value (din0.dinfo.cols);
		4663	MENU.dppl.changed (MENU.sp_drones_per_pend.f_value);
		4664	}
		4665
1328	jag	4666	CLICKED_CHECKBUTTON (menu,cb_am_bpm_lis) {
1438	jag	4667	din0.dinfo.mesh_vars.apply_to.am = cb.state;
1321	jag	4668	din0.dinfo.mesh_vars.apply_to.calc_active ();
		4669	}
		4670
1328	jag	4671	CLICKED_CHECKBUTTON (menu,cb_fm_bpm_lis) {
1438	jag	4672	din0.dinfo.mesh_vars.apply_to.fm = cb.state;
1321	jag	4673	din0.dinfo.mesh_vars.apply_to.calc_active ();
		4674	}
1323	jag	4675
1328	jag	4676	CLICKED_BUTTON(menu,b_set_unset_toggle_lis) {
1326	jag	4677	if (&b == MENUP.b_toggle) {
1619	jag	4678	if (din0.dinfo.set_unset_toggle) din0.pos_afx_vel (-1); else din0.snap_drones (-1);
1326	jag	4679	} else if (&b == MENUP.b_set) {
1619	jag	4680	if (din0.dinfo.set_unset_toggle) din0.pos_afx_vel (1); else din0.snap_drones (1);
1326	jag	4681	} else {
1619	jag	4682	if (din0.dinfo.set_unset_toggle) din0.pos_afx_vel (0); else din0.snap_drones (0);
1326	jag	4683	}
1827	jag	4684	TOGGLEMENU
1326	jag	4685	}
		4686
1452	jag	4687	VALUE_CHANGED (menu,drones_per_pend_lis) {
2110	jag	4688	din0.dinfo.mesh_vars.dpp = MENU.sp_drones_per_pend.value;
1326	jag	4689	cons << "Drones per pendulum = " << din0.dinfo.mesh_vars.dpp << eol;
		4690	}
1402	jag	4691
1436	jag	4692	PICKED_OPTION (menu, ol_fixed_lis) {
		4693	range& rs = din0.ranges [din0.dinfo.sel_range];
		4694	rs.fixed += dir;
1802	jag	4695	wrap<int> (range::LEFT, rs.fixed, range::RIGHT);
1436	jag	4696	MENU.ol_fixed.set_text (ol_fixed_lbls[rs.fixed]);
		4697	}
		4698
1438	jag	4699	CLICKED_CHECKBUTTON (menu,cb_draw_mesh_lis) {
		4700	din0.meshh.draw = cb.state;
1784	jag	4701	TOGGLEMENU
1438	jag	4702	}
		4703
1469	jag	4704	VALUE_CHANGED (menu,lf_conn_steps_lis) {
1511	jag	4705	din0.calc_stepz (f.text);
		4706	cons << YELLOW << "Click connect to connect drones" << eol;
1460	jag	4707	}
		4708
1512	jag	4709	void menu::lf_conn_steps_lis::typing (field& f) {
		4710	static const int d = 12;
		4711	MENU.cb_conn_wrap.set_pos (f.extents.right + d, MENU.cb_conn_wrap.posy);
1797	jag	4712	MENU.trackcon.set_pos (MENU.cb_conn_wrap.extents.right + d, MENU.trackcon.posy);
1512	jag	4713	}
		4714
1469	jag	4715	CLICKED_CHECKBUTTON (menu, cb_conn_wrap_lis) {
1511	jag	4716	cons << YELLOW << "Click connect to connect drones" << eol;
1469	jag	4717	}
		4718
		4719	CLICKED_BUTTON (menu, b_connect_lis) {
1784	jag	4720	if (din0.connect_drones ()) TOGGLEMENU
1469	jag	4721	}
		4722
		4723	CLICKED_BUTTON (menu, b_disconnect_lis) {
1784	jag	4724	if (din0.disconnect_drones ()) TOGGLEMENU
1469	jag	4725	}
		4726
1468	jag	4727	void get_color::update_data () {
		4728	data.clr[0] = color (MENU.s_red_min(), MENU.s_green_min(), MENU.s_blue_min());
		4729	data.clr[1] = color (MENU.s_red_max(), MENU.s_green_max(), MENU.s_blue_max());
		4730	}
		4731
1489	jag	4732	SLIDER_CHANGED(menu,sc_color_lis) {
1468	jag	4733	get_color::update_data ();
1461	jag	4734	din0.color_selected_drones ();
1490	jag	4735	MENU.b_close.set_pos (mousex, MENU.b_close.posy);
1461	jag	4736	}
		4737
1489	jag	4738	START_SLIDE(menu, ss_color_lis, slider<float>) {
		4739	if (MENU.b_close.visible == 0) {
1490	jag	4740	DECL_COLOR_SLIDERS
1489	jag	4741	button& b_close = detach_from_menu (slrs, COLOR_SLIDERS_N, MENU.s_red_max.posx, MENU.s_red_max.posy);
		4742	LISTEN (b_close, MENUP.cscll)
		4743	}
		4744	}
		4745
		4746	CLICKED_BUTTON(menu, sc_close_lis) {
1490	jag	4747	DECL_COLOR_SLIDERS
1489	jag	4748	attach_to_menu (slrs, COLOR_SLIDERS_N);
		4749	}
		4750
1468	jag	4751	PICKED_OPTION(menu,ol_color_lis) {
		4752	colorer_t& colorer = MENU.colorer;
		4753	colorer += dir;
1472	jag	4754	l.set_text (colorer_t::s_schemes[colorer.i]);
1468	jag	4755	din0.color_selected_drones ();
		4756	}
		4757
2340	jag	4758	PICKED_OPTION(menu,ol_paste_lis) {
		4759	static const char* types [] = {" Paste", " Paste Append"};
		4760	int& id = MENU.ol_paste.id;
		4761	id = !id;
		4762	MENU.ol_paste.set_text (types[id]);
		4763	}
1998	jag	4764
		4765	void menu::initdroneparamtabs (checkbutton& cb) {
		4766	MENU.cb_modulation.set_state (0,0);
1695	jag	4767	MENU.cb_visual.set_state (0,0);
1675	jag	4768	MENU.cb_motion.set_state (0,0);
1695	jag	4769	MENU.cb_chuck.set_state (0,0);
1675	jag	4770	MENU.cb_defaults.set_state (0,0);
1998	jag	4771	cb.set_state (1, 0);
1465	jag	4772	}
1468	jag	4773
2027	jag	4774	//
		4775	// drone params ui
		4776	//
		4777
1998	jag	4778	CLICKED_CHECKBUTTON (menu,cb_modulation_lis) {
		4779	MENU.initdroneparamtabs (cb);
2276	jag	4780	MENU.set_drone_params_items (9, 33);
1998	jag	4781	}
		4782
1465	jag	4783	CLICKED_CHECKBUTTON (menu,cb_motion_lis) {
1998	jag	4784	MENU.initdroneparamtabs (cb);
2276	jag	4785	MENU.set_drone_params_items (33, 82);
1465	jag	4786	}
1468	jag	4787
1675	jag	4788	CLICKED_CHECKBUTTON (menu,cb_defaults_lis) {
1998	jag	4789	MENU.initdroneparamtabs (cb);
2286	jag	4790	MENU.set_drone_params_items (82, 127);
1675	jag	4791	}
		4792
1695	jag	4793	CLICKED_CHECKBUTTON (menu,cb_chuck_lis) {
1998	jag	4794	MENU.initdroneparamtabs (cb);
2286	jag	4795	MENU.set_drone_params_items (127, 135);
1695	jag	4796	}
		4797
1465	jag	4798	CLICKED_CHECKBUTTON (menu,cb_visual_lis) {
1998	jag	4799	MENU.initdroneparamtabs (cb);
2286	jag	4800	MENU.set_drone_params_items (135, DRONE_PARAMS_N);
1465	jag	4801	}
		4802
1481	jag	4803	CLICKED_BUTTON (menu, b_abort_octave_shift_lis) {
		4804	abort_octave_shift (get_current_instrument());
		4805	}
		4806
1514	jag	4807	CLICKED_BUTTON (menu, b_arrow_reset_lis) {
		4808	din0.reset_drone_arrows ();
1499	jag	4809	}
		4810
1441	jag	4811	void menu::handle_voice_tab_items (const char* viv) {
		4812
		4813	cb_mkb_voice.set_text (viv);
		4814
		4815	widget* wvoice [] = {
		4816	&sp_am_depth,
		4817	&sp_fm_depth,
		4818	&sp_am_bpm,
		4819	&sp_fm_bpm,
		4820	&ol_am_style,
		4821	&ol_fm_style,
		4822	};
		4823
		4824	if (din0.dinfo.voice_is_voice) {
		4825	for (int i = 0; i < 6; ++i) add_to_tab (&cb_mkb_voice, wvoice[i]);
		4826	} else {
		4827	for (int i = 0; i < 6; ++i) remove_from_tab (&cb_mkb_voice, wvoice[i]);
		4828	}
		4829
		4830	calc_bg ();
		4831
		4832	}
		4833
1402	jag	4834	void print_range_info (range& ri) {
		4835	note& L = ri.notes[0];
		4836	note& R = ri.notes[1];
		4837	sprintf (BUFFER, "Note > %s \| Left = %s @ %0.3f Hz, Right = %s @ %0.3f Hz \| Range %d", din_info::cnno[din0.dinfo.change_note], L.name.c_str(), L.hz, R.name.c_str(), R.hz, din0.dinfo.sel_range);
		4838	cons << CYAN << BUFFER << eol;
		4839	}
1436	jag	4840
1489	jag	4841	button& detach_from_menu (widget** wa, int n, int posx, int posy) {
		4842
1485	jag	4843	button& close = MENU.b_close;
1489	jag	4844	close.set_pos (posx, posy - line_height);
1485	jag	4845	close.show ();
1489	jag	4846
2049	jag	4847	if (MENU.show) MENU.toggle (DONT_MOUSE_WARP);
1489	jag	4848
1485	jag	4849	vector<widget*>& vw = uis.widgets_of [uis.current];
		4850	vw.insert (vw.begin(), &close);
1489	jag	4851
		4852	if (n == 1)
		4853	vw.insert (vw.begin(), wa[0]);
		4854	else
		4855	for (int i = 0; i < n; ++i) vw.insert (vw.begin(), wa[i]);
		4856
1485	jag	4857	warp_mouse (MENU.menu_mousex, MENU.menu_mousey);
1489	jag	4858
1485	jag	4859	return close;
1489	jag	4860
1485	jag	4861	}
		4862
1489	jag	4863	void attach_to_menu (widget** wa, int n) {
1485	jag	4864	uis.remove (MENUP.b_close);
2049	jag	4865	MENU.b_close.hide ();
1489	jag	4866	if (n == 1) uis.remove (wa[0]); else for (int i = 0; i < n; ++i) uis.remove (wa[i]);
2049	jag	4867	if (uis.current == &din0) uis.add (&din0, &mkb_selector);
1485	jag	4868	}
1547	jag	4869
		4870	CLICKED_BUTTON (menu, b_mute_lis) {
1819	jag	4871	din0.gab.set (&din0, 0.0f, "muting drones");
1784	jag	4872	TOGGLEMENU
1547	jag	4873	}
		4874
		4875	CLICKED_BUTTON (menu, b_unmute_lis) {
1819	jag	4876	din0.gab.set (&din0, 1.0f, "unmuting drones");
1784	jag	4877	TOGGLEMENU
1547	jag	4878	}
1552	jag	4879
		4880	VALUE_CHANGED (menu, sp_drone_vol_lis) {
		4881	din0.setdronevol (MENU.sp_drone_vol);
		4882	}
1557	jag	4883
		4884	CLICKED_BUTTON (menu, drone2noiselis) {
		4885	din0.drone2noise ();
1784	jag	4886	TOGGLEMENU
1557	jag	4887	}
		4888
		4889	CLICKED_BUTTON (menu, noise2dronelis) {
		4890	din0.noise2drone ();
1784	jag	4891	TOGGLEMENU
1557	jag	4892	}
1564	jag	4893
1732	jag	4894	void menu::setvelaccel::setup () {
1715	jag	4895	lbl.set_text ("Set");
		4896	whats.option.set_text (" Velocity");
		4897	whats.set_listener (this);
2076	jag	4898	button* b[] = {&zero, &vert, &hor, &vel, &accel, &zero};
		4899	const char* l[] = {"0", "Vertical", "Horizontal", "Velocity", "Acceleration"};
1764	jag	4900	for (int i = 0; i < 5; ++i) {
1715	jag	4901	button& bi = *b[i];
		4902	bi.id = i;
2076	jag	4903	#ifndef __WIDGET_MOVE__
1717	jag	4904	bi.set_listener (this);
2076	jag	4905	#endif
1715	jag	4906	bi.set_text (l[i]);
		4907	}
1739	jag	4908	neg.set_text ("-ve");
2076	jag	4909	perp.set_size (line_height / 2);
1728	jag	4910	#ifdef __WIDGET_MOVE__
2076	jag	4911	widget* w[] = {&lbl, &whats, &neg, &perp, &zero, &vert, &hor, &vel, &accel};
		4912	makehier (w, 9);
		4913	for (int i = 0; i < 9; ++i) w[i]->set_moveable(1);
1728	jag	4914	#endif
1715	jag	4915	}
		4916
1732	jag	4917	void menu::setvelaccel::clicked (button& b) {
2076	jag	4918	din0.setvelaccel (what, b.id, neg.state, perp.state);
1784	jag	4919	TOGGLEMENU
1715	jag	4920	}
		4921
1732	jag	4922	void menu::setvelaccel::picked (label& l, int dir) {
1728	jag	4923	static const char* lbl [] = {" Velocity", " Acceleration", " Both"};
		4924	what += dir;
		4925	wrap<int> (menu::autorott::VELOCITY, what, menu::autorott::BOTH);
1715	jag	4926	l.set_text (lbl[what]);
		4927	}
		4928
1976	jag	4929
		4930	void menu::autorott::clicked (button& b) {
		4931	if (&b == &smooth) {
		4932	mov.id = autorotator::SMOOTH;
		4933	din0.setautorotparam (MENU.autorotate.which, autorott::MOVEMENT);
		4934	} else {
		4935	mov.id = autorotator::TICK;
		4936	din0.setautorotparam (MENU.autorotate.which, autorott::MOVEMENT);
		4937	}
		4938	TOGGLEMENU
		4939	}
		4940
		4941	void menu::autorott::picked (label& lbl, int dir) {
		4942	static const char* strs [] = {" Velocity", " Acceleration", " Both"};
		4943	which += dir;
		4944	wrap<int> (menu::autorott::VELOCITY, which, menu::autorott::BOTH);
		4945	lbl.set_text (strs[which]);
		4946	}
		4947
		4948	void menu::defvelaccelui::checksync (float v, anglet& t, spinner<float>& sp) {
		4949	if (sync.state) {
		4950	t = v;
		4951	sp.set_value (v);
		4952	}
		4953	}
		4954
		4955
1666	jag	4956	void menu::autorott::setup () {
1805	jag	4957
1666	jag	4958	title.set_text ("Auto rotate");
1802	jag	4959	which = VELOCITY;
1771	jag	4960	whichl.option.set_text (" Velocity");
1861	jag	4961	mov.set_text ("Movement?");
1771	jag	4962	whichl.set_listener (this);
1972	jag	4963	{
		4964	button* b[] = {&start, &stop, &toggle, &clockwise, &anticlockwise, &smooth, &tick};
		4965	static const char* l [] = {"Start", "Stop", "Toggle", "Clockwise", "Anti-clockwise", "Smooth", "Ticked"};
1982	jag	4966	click_listener* clk [] = {&startl, &stopl, &togl, &clkl, &aclkl, this, this};
1972	jag	4967	for (int i = 0; i < 7; ++i) {
		4968	button& bi = *b[i];
		4969	bi.set_text (l[i]);
1941	jag	4970	#ifndef __WIDGET_MOVE__
1972	jag	4971	bi.set_listener (clk[i]);
1941	jag	4972	#endif
1972	jag	4973	}
1666	jag	4974	}
1972	jag	4975	{
1982	jag	4976	widget* af [] = {&autoflip.lbl, &autoflip.unset, &autoflip.set, &autoflip.toggle, &autoflip.angle, 0};
		4977	widget* ap [] = {&autopause.lbl, &autopause.unset, &autopause.set, &autopause.toggle, &autopause.every, &autopause.f0r, 0};
		4978	widget* rfp [] = {&rndflipause.whichl.option, &rndflipause.unset, &rndflipause.set, &rndflipause.toggle, 0};
		4979	static const char* l [] = {"Unset", "Set", "Toggle"};
1972	jag	4980	for (int i = 0, j = 1; i < 3; ++i, ++j) {
		4981	button& bf = (button&) *af[j];
		4982	button& bp = (button&) *ap[j];
1976	jag	4983	button& brfp = (button&) *rfp[j];
1972	jag	4984	bf.set_text (l[i]);
		4985	bp.set_text (l[i]);
1976	jag	4986	brfp.set_text (l[i]);
1972	jag	4987	#ifndef __WIDGET_MOVE__
1982	jag	4988	bf.id = bp.id = brfp.id = i;
		4989	bf.set_listener (&autoflip.sutl);
		4990	bp.set_listener (&autopause.sutl);
		4991	brfp.set_listener (&rndflipause.sutl);
1972	jag	4992	#endif
		4993	}
		4994	#ifdef __WIDGET_MOVE__
		4995	makehier (af);
		4996	makehier (ap);
1976	jag	4997	makehier (rfp);
1972	jag	4998	#endif
1982	jag	4999	rndflipause.optl.picked (rndflipause.whichl.option, 0);
1976	jag	5000	rndflipause.whichl.set_listener (&rndflipause.optl);
1972	jag	5001	}
		5002
1732	jag	5003	rpm.set ("RPM", 1.0f, 0.0f, MILLIONF, &rpml);
1856	jag	5004	deg.set ("Degrees per Tick", 1.0f, -MILLIONF, MILLIONF, &degl);
1773	jag	5005	tps.set ("Ticks per Second", 1.0f, -MILLIONF, MILLIONF, &tpsl);
1972	jag	5006	autoflip.lbl.set_text ("Auto flip");
1732	jag	5007	autoflip.angle.set (1.0f, 0.0f, MILLIONF, &autoflip.angl);
1836	jag	5008	autoflip.angle.set_text ("Every", DEGREES);
1972	jag	5009	autopause.lbl.set_text ("Auto pause");
1974	jag	5010	autopause.every.set (0.1f, 0.0f, MILLIONF, &autopause.everyl);
		5011	autopause.f0r.set (0.1f, 0.0f, MILLIONF, &autopause.f0rl);
1973	jag	5012	autopause.every.set_text ("Every", SECONDS);
		5013	autopause.f0r.set_text ("For", SECONDS);
1730	jag	5014
1668	jag	5015	#ifdef __WIDGET_MOVE__
1828	jag	5016	widget* w[] = {
1861	jag	5017	&title, &whichl,
		5018	&start, &stop, &toggle,
1973	jag	5019	&mov,
		5020	&smooth, &tick, &clockwise, &anticlockwise,
		5021	&rpm, &deg, &tps,
1828	jag	5022
		5023	};
		5024	makehier (w);
1668	jag	5025	#endif
1666	jag	5026	}
		5027
1806	jag	5028	void menu::defvelaccelui::setup () {
1732	jag	5029
1836	jag	5030	whichl.set_listener (this);
1732	jag	5031
1809	jag	5032	spinner2<float>* sp [] = {
		5033	&mag,
		5034	&autorotate.rpm,
		5035	&autorotate.dps,
		5036	&autorotate.tps,
		5037	&autoflip.deg,
1970	jag	5038	&autopause.every,
		5039	&autopause.f0r,
1809	jag	5040	};
		5041
		5042	const char* nam [] = {
		5043	"Magnitude",
		5044	"RPM",
1858	jag	5045	"Degrees per Tick",
1809	jag	5046	"Ticks Per Second",
1976	jag	5047	"Every", // autoflip (degrees)
		5048	"Every", // autopause (seconds)
1970	jag	5049	"For",
1809	jag	5050	};
		5051
		5052	change_listener<field>* chgl [] = {
		5053	&magl,
		5054	&rpml,
		5055	&dpsl,
		5056	&tpsl,
1970	jag	5057	&degl,
1971	jag	5058	&everyl,
		5059	&f0rl
1809	jag	5060	};
		5061
1970	jag	5062	float mins [] = {0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f};
1976	jag	5063	float dels [] = {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.01f, 0.01f};
1864	jag	5064
1970	jag	5065	int nsp = 7;
1809	jag	5066	for (int i = 0; i < nsp; ++i) {
		5067	spinner2<float>& spi = *sp[i];
1976	jag	5068	spi.set (nam[i], dels[i], mins[i], MILLIONF, chgl[i]);
1809	jag	5069	spi.lis[2] = &varl;
		5070	spi.variance.cb.id = i;
		5071	spi.variance.fld.id = i;
		5072	spi.variance.cb.set_listener (&chkl);
		5073	}
		5074
1836	jag	5075	clockwise.set (1.0f, 0.0f, MILLIONF, &clockl);
		5076	anticlockwise.set (1.0f, 0.0f, MILLIONF, &aclockl);
		5077	clockwise.set_text ("Clockwise", DEGREES);
		5078	anticlockwise.set_text ("Anti-clockwise", DEGREES);
2106	jag	5079
1836	jag	5080	autoflip.deg.set_text ("Every", DEGREES);
2106	jag	5081
1970	jag	5082	autopause.every.set_text ("Every", SECONDS);
		5083	autopause.f0r.set_text ("For", SECONDS);
2027	jag	5084	autopause.tar.set_listener (&tarl);
1732	jag	5085
		5086	ldir.set_text ("Direction");
1735	jag	5087	odir.set_listener (&dirl);
		5088
1809	jag	5089	checkbutton* cb [] = {
		5090	&neg,
		5091	&randomize,
		5092	&autorotate.cb,
1871	jag	5093	&autorotate.uet.deg,
		5094	&autorotate.uet.tps,
1970	jag	5095	&autoflip.cb,
		5096	&autopause.cb,
1809	jag	5097	};
1735	jag	5098
1971	jag	5099	for (int i = 0, j = 7; i < 7; ++i, ++j) {
1809	jag	5100	checkbutton& cbi = *cb[i];
		5101	cbi.id = j;
		5102	cbi.set_listener (&chkl);
		5103	}
1732	jag	5104
1807	jag	5105	autorotate.setup ();
		5106
1732	jag	5107	#ifdef __WIDGET_MOVE__
1828	jag	5108	autoflip.setup ();
1971	jag	5109	autopause.setup ();
1732	jag	5110	widget* w[] = {
1836	jag	5111	&whichl,
1756	jag	5112	&mag,
1732	jag	5113	&ldir, &neg, &odir,
1836	jag	5114	&randomize, &clockwise, &anticlockwise, &sync,
1828	jag	5115
1732	jag	5116	};
1828	jag	5117	makehier (w);
1732	jag	5118	#endif
1808	jag	5119
1732	jag	5120	}
		5121
1806	jag	5122	void menu::defvelaccelui::load () {
1810	jag	5123
1806	jag	5124	defvelaccel* dval [] = {&drone::v0, &drone::a0};
1836	jag	5125	cur = dval [which];
		5126	whichl.set_text (cur->name);
1810	jag	5127
1836	jag	5128	neg.set_state (cur->neg, 0);
1810	jag	5129	static const char* s [] = {" Horizontal", " Vertical", " Mouse"};
1836	jag	5130	odir.set_text (s[cur->dir]);
1837	jag	5131	MENU.dva.idir = cur->dir;
		5132
1836	jag	5133	randomize.set_state (cur->rndrot, 0);
		5134	clockwise.set_value (cur->clock.deg);
		5135	anticlockwise.set_value (cur->anticlock.deg);
		5136	sync.set_state (cur->sync, 0);
1810	jag	5137
		5138	spinner2<float>* sp [] = {
1971	jag	5139	MENUP.dva.mag,
		5140	MENUP.dva.autorotate.rpm,
		5141	MENUP.dva.autorotate.dps,
		5142	MENUP.dva.autorotate.tps,
		5143	MENUP.dva.autoflip.deg,
		5144	MENUP.dva.autopause.every,
		5145	MENUP.dva.autopause.f0r,
1810	jag	5146	};
		5147
		5148	valt* vt [] = {
1836	jag	5149	&cur->mag,
		5150	&cur->autos.rot.rpm,
		5151	&cur->autos.rot.dps,
		5152	&cur->autos.rot.tps,
		5153	&cur->autos.flip.deg,
1971	jag	5154	&cur->autos.pause.every,
		5155	&cur->autos.pause.f0r,
1810	jag	5156	};
		5157
1971	jag	5158	for (int i = 0; i < 7; ++i) {
1810	jag	5159	spinner2<float>& spi = *sp[i];
		5160	valt& vti = *vt[i];
		5161	spi.set_value (vti.val);
		5162	spi.variance.rd = vti.rd;
		5163	spi.variance.setfld ();
		5164	spi.variance.cb.set_state (vti.rndrd, 0);
		5165	}
		5166
1836	jag	5167	autorotate.load ();
1971	jag	5168
1836	jag	5169	autoflip.cb.set_state (cur->autos.flip.yes);
1810	jag	5170
1971	jag	5171	autopause.cb.set_state (cur->autos.pause.yes);
2027	jag	5172	autopause.tar.set_text (autopauset::tars[cur->autos.pause.tar]);
1810	jag	5173
1732	jag	5174	}
		5175
1806	jag	5176	void menu::defvelaccelui::picked (label& lbl, int p) {
1836	jag	5177	which = !which;
1758	jag	5178	load ();
		5179	}
1732	jag	5180
1806	jag	5181	VALUE_CHANGED (menu::defvelaccelui, varlis) {
1809	jag	5182	spinner2<float>* sp [] = {
1971	jag	5183	MENUP.dva.mag,
		5184	MENUP.dva.autorotate.rpm,
		5185	MENUP.dva.autorotate.dps,
		5186	MENUP.dva.autorotate.tps,
		5187	MENUP.dva.autoflip.deg,
		5188	MENUP.dva.autopause.every,
		5189	MENUP.dva.autopause.f0r,
1809	jag	5190	};
		5191
1836	jag	5192	defvelaccel& dva = *MENU.dva.cur;
1809	jag	5193	valt* vt [] = {
		5194	&dva.mag,
		5195	&dva.autos.rot.rpm,
		5196	&dva.autos.rot.dps,
		5197	&dva.autos.rot.tps,
		5198	&dva.autos.flip.deg,
1971	jag	5199	&dva.autos.pause.every,
		5200	&dva.autos.pause.f0r,
1809	jag	5201	};
		5202
		5203	int id = f.id;
		5204	vt[id]->rd = sp[id]->variance.rd;
1732	jag	5205	}
		5206
1809	jag	5207	defvelaccel& getdva () {
		5208	defvelaccel* dval [] = {&drone::v0, &drone::a0};
1836	jag	5209	return *dval [MENU.dva.which];
1809	jag	5210	}
		5211
2106	jag	5212	VALUE_CHANGED (menu::defvelaccelui, maglis) {
		5213	float v = MENU.dva.mag.value;
		5214	MENU.dva.cur->mag.val = v;
		5215	cons << "Magnitude of " << MENU.dva.cur->name << " = " << v << eol;
		5216	}
		5217
1809	jag	5218	VALUE_CHANGED (menu::defvelaccelui, rpmlis) {
		5219	defvelaccel& dva = getdva ();
2106	jag	5220	float v = MENU.dva.autorotate.rpm.value;
1809	jag	5221	dva.autos.rot.rpm = v;
		5222	cons << dva.name << " Auto rotate RPM = " << v << eol;
		5223	}
		5224
		5225	VALUE_CHANGED (menu::defvelaccelui, dpslis) {
		5226	defvelaccel& dva = getdva ();
2106	jag	5227	float v = MENU.dva.autorotate.dps.value;
1809	jag	5228	dva.autos.rot.dps = v;
1856	jag	5229	cons << dva.name << " Degrees per Tick = " << v << eol;
1809	jag	5230	}
		5231	VALUE_CHANGED (menu::defvelaccelui, tpslis) {
		5232	defvelaccel& dva = getdva ();
2106	jag	5233	float v = MENU.dva.autorotate.tps.value;
1809	jag	5234	dva.autos.rot.tps = v;
		5235	cons << dva.name << " Ticks per Second = " << v << eol;
		5236	}
		5237
		5238	VALUE_CHANGED (menu::defvelaccelui, deglis) {
		5239	defvelaccel& dva = getdva ();
2106	jag	5240	float v = MENU.dva.autoflip.deg.value;
1809	jag	5241	dva.autos.flip.deg = v;
1836	jag	5242	cons << dva.name << " Auto flip every " << v << DEGREES << eol;
1809	jag	5243	}
		5244
1971	jag	5245	VALUE_CHANGED (menu::defvelaccelui, everylis) {
		5246	defvelaccel& dva = getdva ();
2106	jag	5247	float v = MENU.dva.autopause.every.value;
1971	jag	5248	dva.autos.pause.every = v;
		5249	cons << dva.name << " Auto pause every " << v << SECONDS << eol;
		5250	}
		5251
		5252	VALUE_CHANGED (menu::defvelaccelui, f0rlis) {
		5253	defvelaccel& dva = getdva ();
2106	jag	5254	float v = MENU.dva.autopause.f0r.value;
1971	jag	5255	dva.autos.pause.f0r = v;
		5256	cons << dva.name << " Auto pause for " << v << SECONDS << eol;
		5257	}
		5258
1806	jag	5259	VALUE_CHANGED (menu::defvelaccelui, clocklis) {
2106	jag	5260	float v = MENU.dva.clockwise.value;
1836	jag	5261	MENU.dva.cur->clock = v;
		5262	MENU.dva.checksync (v, MENU.dva.cur->anticlock, MENU.dva.anticlockwise);
		5263	MENU.dva.cur->setrotrd ();
2106	jag	5264	cons << MENU.dva.cur->name << " Clockwise Rotation = " << v << DEGREES << eol;
1736	jag	5265	}
		5266
1806	jag	5267	VALUE_CHANGED (menu::defvelaccelui, anticlocklis) {
2106	jag	5268	float v = MENU.dva.anticlockwise.value;
1836	jag	5269	MENU.dva.cur->anticlock = v;
		5270	MENU.dva.checksync (v, MENU.dva.cur->clock, MENU.dva.clockwise);
		5271	MENU.dva.cur->setrotrd ();
2106	jag	5272	cons << MENU.dva.cur->name << " Anti-clockwise Rotation = " << v << DEGREES << eol;
1736	jag	5273	}
		5274
2106	jag	5275	PICKED_OPTION (menu::defvelaccelui, tarlis) {
		5276	defvelaccel& dva = getdva ();
		5277	int& tar = dva.autos.pause.tar;
		5278	tar = !tar;
		5279	l.set_text (menu::defvelaccelui::autopauset::tars[tar]);
		5280	}
		5281
1806	jag	5282	PICKED_OPTION (menu::defvelaccelui, dirlis) {
1738	jag	5283	int& idir = MENU.dva.idir;
		5284	idir += dir;
1806	jag	5285	wrap<int> (menu::defvelaccelui::HORIZONTAL, idir, menu::defvelaccelui::MOUSE);
1836	jag	5286	MENU.dva.cur->dir = idir;
1738	jag	5287	static const char* s [] = {" Horizontal", " Vertical", " Mouse"};
2027	jag	5288	l.set_text (s[idir]);
1738	jag	5289	}
		5290
1858	jag	5291	int gethandlesize () { return MENU.handlesize(); }
1892	jag	5292
1858	jag	5293	int gettrailsize () {return MENU.trailsize(); }
1892	jag	5294
		5295	void initlaunch (drone* pd) {
1877	jag	5296	drone& d = *pd;
2106	jag	5297	d.lpm = MENU.ddpm ();
1892	jag	5298	d.launch_every.triggert = ppm2t (d.lpm);
		5299	d.dpl = MENU.ddpl ();
1877	jag	5300	}
1858	jag	5301
1806	jag	5302	void get (float& g, float& ux, float& uy, defvelaccel& dva) {
1758	jag	5303	g = dva.mag ();
1750	jag	5304	point<int> mous (din0.delta_mousex, din0.delta_mousey);
		5305	if (mous.x == 0 && mous.y == 0) {
		5306	ux = 0;
		5307	uy = 1;
		5308	} else {
		5309	unit_vector<float> (ux, uy, mous.x, -mous.y);
		5310	}
1736	jag	5311	float dirxa [] = {1, 0, ux};
		5312	float dirya [] = {0, 1, uy};
		5313	float nega [] = {1, -1};
		5314	float neg = nega [dva.neg];
		5315	ux = neg * dirxa [dva.dir];
		5316	uy = neg * dirya [dva.dir];
1737	jag	5317	if (dva.rndrot) rotate_vector (ux, uy, dva.rotrd());
1736	jag	5318	}
		5319
1755	jag	5320
1806	jag	5321	CLICKED_CHECKBUTTON (menu::defvelaccelui, chklis) {
1836	jag	5322	defvelaccel& dva = *MENU.dva.cur;
1809	jag	5323	int* val [] = {
		5324	&dva.mag.rndrd,
		5325	&dva.autos.rot.rpm.rndrd,
		5326	&dva.autos.rot.dps.rndrd,
		5327	&dva.autos.rot.tps.rndrd,
		5328	&dva.autos.flip.deg.rndrd,
1971	jag	5329	&dva.autos.pause.every.rndrd,
		5330	&dva.autos.pause.f0r.rndrd,
1809	jag	5331	&dva.neg,
		5332	&dva.rndrot,
		5333	&dva.autos.rot.yes,
1871	jag	5334	&dva.autos.rot.uet.deg,
		5335	&dva.autos.rot.uet.tps,
1809	jag	5336	&dva.autos.flip.yes,
1971	jag	5337	&dva.autos.pause.yes,
1809	jag	5338	};
1735	jag	5339	*val[cb.id] = cb.state;
		5340	}
		5341
1666	jag	5342	CLICKED_BUTTON (menu::autorott, startlis) {
1772	jag	5343	din0.setautorot (MENU.autorotate.which, 1);
1666	jag	5344	}
		5345
		5346	CLICKED_BUTTON (menu::autorott, stoplis) {
1772	jag	5347	din0.setautorot (MENU.autorotate.which, 0);
1666	jag	5348	}
		5349
		5350	CLICKED_BUTTON (menu::autorott, togglis) {
1772	jag	5351	din0.setautorot (MENU.autorotate.which, 0, 1);
1666	jag	5352	}
		5353
		5354	CLICKED_BUTTON (menu::autorott, clockwiselis) {
1772	jag	5355	din0.setautorotdir (MENU.autorotate.which, -1);
1666	jag	5356	}
		5357
		5358	CLICKED_BUTTON (menu::autorott, anticlockwiselis) {
1772	jag	5359	din0.setautorotdir (MENU.autorotate.which, 1);
1666	jag	5360	}
1668	jag	5361
1730	jag	5362	VALUE_CHANGED (menu::autorott, rpmlis) {
1773	jag	5363	din0.setautorotparam (MENU.autorotate.which, menu::autorott::RPM);
1730	jag	5364	}
		5365
1773	jag	5366	VALUE_CHANGED (menu::autorott, deglis) {
		5367	din0.setautorotparam (MENU.autorotate.which, menu::autorott::DEG);
		5368	}
		5369
		5370	VALUE_CHANGED (menu::autorott, tpslis) {
		5371	din0.setautorotparam (MENU.autorotate.which, menu::autorott::TPS);
		5372	}
		5373
1982	jag	5374	CLICKED_BUTTON (menu::autorott::autoflipt, sutlis) {
		5375	static int togs [] = {0, 0, 1};
		5376	din0.setautoflip (MENU.autorotate.which, b.id, togs[b.id]);
1730	jag	5377	}
		5378
1771	jag	5379	VALUE_CHANGED (menu::autorott::autoflipt, anglis) {
1772	jag	5380	din0.setautoflipangle (MENU.autorotate.which);
1771	jag	5381	}
		5382
1974	jag	5383	VALUE_CHANGED (menu::autorott::autopauset, everylis) {
		5384	din0.setautopauseparam (MENU.autorotate.which, 0);
		5385	}
		5386
		5387	VALUE_CHANGED (menu::autorott::autopauset, f0rlis) {
		5388	din0.setautopauseparam (MENU.autorotate.which, 1);
		5389	}
		5390
1982	jag	5391	CLICKED_BUTTON (menu::autorott::autopauset, sutlis) {
		5392	static int togs[] = {0, 0, 1};
		5393	din0.setautopause (MENU.autorotate.which, b.id, togs[b.id]);
1972	jag	5394	}
		5395
1982	jag	5396	CLICKED_BUTTON (menu::autorott::rndflipauset, sutlis) {
		5397	static int togs[] = {0, 0, 1};
1976	jag	5398	menu::autorott& ar = MENU.autorotate;
1982	jag	5399	din0.setrndflipause (ar.which, ar.rndflipause.which, b.id, togs[b.id]);
1976	jag	5400	}
1972	jag	5401
1976	jag	5402	PICKED_OPTION (menu::autorott::rndflipauset, rndflipauselis) {
		5403	static const char* opts [] = {
1981	jag	5404	" Randomize Auto Flip Degrees",
		5405	" Randomize Auto Pause : Every",
		5406	" Randomize Auto Pause : For"
1976	jag	5407	};
		5408	int& which = MENU.autorotate.rndflipause.which;
		5409	which += dir;
		5410	wrap (0, which, 2);
		5411	MENU.autorotate.rndflipause.whichl.set_text (opts[which]);
		5412	}
		5413
1674	jag	5414	PICKED_OPTION (menu, ol_add_wand_lis) {
1675	jag	5415	static const char* aws [] = {" Add", " Wand"};
1690	jag	5416	din0.dinfo.wand = !din0.dinfo.wand;
		5417	MENU.ol_add_wand.set_text (aws[din0.dinfo.wand]);
1674	jag	5418	}
1675	jag	5419
		5420	PICKED_OPTION (menu, ol_drones_are_lis) {
1677	jag	5421	static const char* das [] = {"are immortal", "are mortal", "reincarnate"};
1731	jag	5422	drone::ARE += dir;
		5423	wrap<int> (drone::IMMORTAL, drone::ARE, drone::REINCARNATE);
		5424	sprintf (BUFFER, " Drones %s", das[drone::ARE]);
1675	jag	5425	MENU.ol_drones_are.set_text (BUFFER);
		5426	}
1676	jag	5427
1828	jag	5428	VALUE_CHANGED (menu,risel) {
2105	jag	5429	din0.dinfo.drone_rise_time = MENU.riset.value;
1829	jag	5430	cons << "Drone rise time = " << din0.dinfo.drone_rise_time << eol;
1676	jag	5431	}
		5432
1828	jag	5433	VALUE_CHANGED (menu,falll) {
2105	jag	5434	din0.dinfo.drone_fall_time = MENU.fallt.value;
1829	jag	5435	cons << "Drone fall time = " << din0.dinfo.drone_fall_time << eol;
1676	jag	5436	}
		5437
1677	jag	5438	VALUE_CHANGED(menu,lifetimel) {
2105	jag	5439	drone::LIFETIME = MENU.lifetime.value;
1687	jag	5440	cons << "Drone life time = " << drone::LIFETIME << SECONDS << eol;
1677	jag	5441	}
		5442
2106	jag	5443	VALUE_CHANGED(menu,handlesizel) {
		5444	drone::HANDLESIZE = MENU.handlesize.value;
		5445	cons << GREEN << "Default drone handle size = " << drone::HANDLESIZE << eol;
		5446	}
		5447
		5448	VALUE_CHANGED(menu,trailsizel) {
		5449	TRAILSIZE = MENU.trailsize.value;
		5450	cons << GREEN << "Default Drone / Ball trail size = " << TRAILSIZE << eol;
		5451	}
		5452
		5453	VALUE_CHANGED(menu,ddpmlis) {
		5454	int& ddpm = din0.dinfo.dpm;
		5455	ddpm = MENU.ddpm.value;
		5456	cons << GREEN << "Default drone launches per minute = " << ddpm << eol;
		5457	}
		5458
		5459	VALUE_CHANGED(menu,ddpllis) {
		5460	int& ddpl = din0.dinfo.dpl;
		5461	ddpl = MENU.ddpl.value;
		5462	cons << GREEN << "Default drones per launch = " << ddpl << eol;
		5463	}
		5464
		5465	VALUE_CHANGED (menu,sp_wand_dist_lis) {
		5466	int d = MENU.sp_wand_dist.value;
		5467	drone::wand.set (d);
		5468	cons << YELLOW << "Wand distance = " << d << eol;
		5469	}
		5470
1695	jag	5471	VALUE_CHANGED(menu,speedl) {
		5472	din0.changechuckspeed (MENU.chspeed);
		5473	}
		5474
		5475	VALUE_CHANGED(menu,lengthl) {
		5476	din0.changechucklength (MENU.chlen);
		5477	}
		5478
1702	jag	5479	VALUE_CHANGED(menu,traill) {
		5480	din0.change_drone_trail_points (MENU.chtrail);
		5481	}
		5482
2105	jag	5483	VALUE_CHANGED(menu,angleperframel) {
		5484	drone::chuckt::apt += MENU.chapt();
		5485	RESETALLCHUCKTRAILS
		5486	cons << YELLOW << "Angle per turn = " << drone::chuckt::apt.deg << DEGREES << eol;
		5487	}
		5488
1708	jag	5489
1677	jag	5490	CLICKED_BUTTON(menu,mortalizel) {
		5491	din0.mortalize_drones ();
1784	jag	5492	TOGGLEMENU
1677	jag	5493	}
		5494
1731	jag	5495	CLICKED_BUTTON(menu,reincarnatel) {
		5496	#define REINCARNATE 1
		5497	din0.mortalize_drones (REINCARNATE);
1784	jag	5498	TOGGLEMENU
1677	jag	5499	}
		5500
1731	jag	5501	CLICKED_BUTTON(menu,immortalizel) {
		5502	din0.immortalize_drones ();
1784	jag	5503	TOGGLEMENU
1677	jag	5504	}
1680	jag	5505
1695	jag	5506	CLICKED_BUTTON(menu,chuckl) {
		5507	din0.chuck ();
1784	jag	5508	TOGGLEMENU
1695	jag	5509	}
		5510
		5511	CLICKED_BUTTON(menu,chflipl) {
		5512	din0.flipchuckspeed ();
1784	jag	5513	TOGGLEMENU
1695	jag	5514	}
		5515
1697	jag	5516	CLICKED_BUTTON(menu,chtogl) {
		5517	din0.togchuckspeed ();
1784	jag	5518	TOGGLEMENU
1697	jag	5519	}
		5520
1749	jag	5521	CLICKED_CHECKBUTTON(menu,autoresettrailslis) {
		5522	drone::chuckt::autoresettrails = cb.state;
		5523	RESETALLCHUCKTRAILS
		5524	}
		5525
1753	jag	5526	PICKED_OPTION(menu,anchoredl) {
		5527	drone::anchored = !drone::anchored;
		5528	static const char* lbl [] = {" Drone is launched", " Drone is anchored"};
		5529	MENU.anchored.set_text (lbl[drone::anchored]);
		5530	}
		5531
1682	jag	5532	void menu::moddirs::clicked (button& cb) {
		5533	DECL_BUTTONS
1693	jag	5534	for (int i = 0; i < 4; ++i) {
1687	jag	5535	if (&cb == b[i]) {
		5536	din0.setmoddir (what, i);
		5537	break;
		5538	}
1693	jag	5539	}
1784	jag	5540	TOGGLEMENU
1682	jag	5541	}
		5542
		5543	void menu::moddirs::setup (const string& l) {
		5544	DECL_BUTTONS
		5545	lbl.set_text (l);
2060	jag	5546	const char* txt [] = {"Vertical", "Horizontal", "Velocity", "Acceleration"};
		5547	for (int i = 0; i < 4; ++i) b[i]->set_text (txt[i]);
1682	jag	5548	#ifdef __WIDGET_MOVE__
2060	jag	5549	widget* u[] = {&lbl, &vert, &hor, &vel, &accel, 0};
		5550	makefam (u);
1682	jag	5551	#endif
		5552	}
1769	jag	5553
1806	jag	5554	void menu::defvelaccelui::autorotatet::setup () {
1808	jag	5555	dir.set_listener (&dirl);
		5556	mov.set_listener (&movl);
1828	jag	5557	#ifdef __WIDGET_MOVE__
		5558	widget* w[] = {
		5559	&cb,
		5560	&dir,
		5561	&mov,
		5562	&rpm,
		5563	&dps,
1892	jag	5564	&uet.deg,
1828	jag	5565	&tps,
1892	jag	5566	&uet.tps,
1828	jag	5567
		5568	};
		5569	makehier (w);
		5570	#endif
1805	jag	5571	}
1778	jag	5572
1836	jag	5573	void menu::defvelaccelui::autorotatet::load () {
		5574	defvelaccel& dva = getdva ();
		5575	defvelaccel::autost::rott& rot = dva.autos.rot;
		5576	cb.set_state (rot.yes, 0);
1871	jag	5577	uet.deg.set_state (rot.uet.deg, 0);
		5578	uet.tps.set_state (rot.uet.tps, 0);
1980	jag	5579	static const char* diropts [] = {" Clockwise", " Anti clockwise", " Clockwise or Anti-clockwise"};
		5580	static const char* movopts [] = {" Smooth", " Ticked", " Smooth or Ticked"};
1836	jag	5581	dir.set_text (diropts[rot.dir]);
		5582	mov.set_text (movopts[rot.mov]);
		5583	}
		5584
1828	jag	5585	#ifdef __WIDGET_MOVE__
		5586	void menu::defvelaccelui::autoflipt::setup () {
		5587	widget* w[] = {
		5588	&cb,
		5589	&deg,
		5590
		5591	};
		5592	makehier (w);
		5593	}
1971	jag	5594
		5595	void menu::defvelaccelui::autopauset::setup () {
		5596	widget* w[] = {
		5597	&cb,
		5598	&every,
		5599	&f0r,
2027	jag	5600	&tar,
1971	jag	5601
		5602	};
		5603	makehier (w);
		5604	}
1828	jag	5605	#endif
		5606
1806	jag	5607	PICKED_OPTION (menu::defvelaccelui::autorotatet, dirlis) {
1807	jag	5608	defvelaccel& dva = getdva ();
1805	jag	5609	dva.autos.rot.dir += dir;
1807	jag	5610	wrap<int> (autorotator::CLOCKWISE, dva.autos.rot.dir, autorotator::RANDOM);
1805	jag	5611	static const char* opts [] = {" Clockwise", " Anti clockwise", " Clockwise or Anti-clockwise"};
		5612	l.set_text (opts[dva.autos.rot.dir]);
		5613	}
		5614
1806	jag	5615	PICKED_OPTION (menu::defvelaccelui::autorotatet, movlis) {
1807	jag	5616	defvelaccel& dva = getdva ();
1805	jag	5617	dva.autos.rot.mov += dir;
1980	jag	5618	wrap<int> (autorotator::SMOOTH, dva.autos.rot.mov, autorotator::RANDOM);
		5619	static const char* opts [] = {" Smooth", " Ticked", " Smooth or Ticked"};
1805	jag	5620	l.set_text (opts[dva.autos.rot.mov]);
		5621	}
		5622
1807	jag	5623	CLICKED_CHECKBUTTON (menu::defvelaccelui::autorotatet, chklis) {
		5624	defvelaccel& dva = getdva ();
		5625	dva.autos.rot.yes = cb.state;
		5626	}
		5627
1828	jag	5628	drone::bouncet::bouncet () {
		5629	n = 0;
1855	jag	5630	max = -1;
1828	jag	5631	}
1852	jag	5632
		5633	drone::genn::genn () {
		5634	n = 0;
		5635	max = MENU.gens ();
		5636	}
		5637
1897	jag	5638	std::ostream& operator<< (std::ostream& f, colorer_t& clr) {
		5639	color_data_t& cd = clr.schemes[clr.i]->data;
		5640	color &c0 = cd.clr[0], &c1 = cd.clr[1];
		5641	f << c0.r << spc << c0.g << spc << c0.b << spc << c1.r << spc << c1.g << spc << c1.b;
		5642	return f;
		5643	}
		5644
		5645
		5646	std::istream& operator>> (std::istream& f, colorer_t& clr) {
		5647	color_data_t& cd = clr.schemes[0]->data;
		5648	color &c0 = cd.clr[0], &c1 = cd.clr[1];
		5649	f >> c0.r >> c0.g >> c0.b >> c1.r >> c1.g >> c1.b;
		5650	return f;
		5651	}
		5652
		5653	void menu::initcolorsliders () {
		5654	file_in fi ("color-sliders");
		5655	ifstream& f = fi ();
		5656	f >> colorer;
		5657	color_data_t& cd = colorer.schemes[0]->data;
		5658	color &c0 = cd.clr[0], &c1 = cd.clr[1];
		5659	float c [] = {c0.r, c0.g, c0.b, c1.r, c1.g, c1.b};
		5660	slider<float>* s [] = {&s_red_min, &s_green_min, &s_blue_min, &s_red_max, &s_green_max, &s_blue_max};
		5661	for (int i = 0; i < COLOR_SLIDERS_M; ++i) s[i]->set_val (c[i]);
		5662	}
		5663	void menu::savecolorsliders () {
		5664	file_out fo ("color-sliders");
		5665	ofstream& f = fo ();
		5666	f << colorer << endl;
		5667	}
1913	jag	5668
		5669	CLICKED_BUTTON (menu, am2fm2amlis) {
		5670	din0.set_drone_am2fm2am_bpm (b.id);
		5671	}
1941	jag	5672
		5673
		5674	CLICKED_CHECKBUTTON (menu, curveslistl) {
1942	jag	5675	if (!CRVED->setcrvvis (cb.id, cb.state)) cb.turn_on (DONT_CALL_LISTENER);
1941	jag	5676	}
		5677
1945	jag	5678	void curve_editor::setup_tools_menu () {
1955	jag	5679	curve_info& ci = curveinfo [curcrv];
		5680	multi_curve* crv = ci.curve;
		5681	MENU.sp_curve_rpm.set_value (ci.lastrpm);
1958	jag	5682	MENU.sp_curve_every.variance.cb.set_state (ci.randoflip);
1959	jag	5683	MENU.sp_curve_every.variance.rd = ci.rd;
		5684	MENU.sp_curve_every.variance.setfld ();
1958	jag	5685	MENU.sp_curve_every.set_value (ci.every0.deg);
1955	jag	5686	MENU.cb_ed_autoflip.set_state (ci.autoflip);
1945	jag	5687	MENU.lf_curve_name.set_text (crv->name);
		5688	MENU.sp_curve_limit.set_value (crv->limit);
		5689	MENU.picked (MENU.ol_mirror.option, 0);
		5690	set_curve_style (crv);
		5691	curcrvchgd = 0;
		5692	}
1984	jag	5693
		5694
		5695	PICKED_OPTION (menu, moverailstrafelis) {
		5696	static const char* opts [] = {" Move", " Rail", " Strafe"};
		5697	click_listener* clk [] = {MENUP.bmdl, MENUP.raill, MENUP.strafel};
		5698	int& id = MENU.moverailstrafe.id;
		5699	button& option = MENU.moverailstrafe.option;
		5700	id += dir;
		5701	wrap (0, id, 2);
		5702	option.set_text (opts[id]);
		5703	LISTEN(option, clk[id]);
		5704	}
1990	jag	5705
		5706	float getlifetime () {
		5707	return MENU.lifetime ();
		5708	}
2049	jag	5709
		5710	VALUE_CHANGED (menu,texsteplis) {
		5711	mondrian0.patstep = MENU.texstep();
		5712	mondrian0.fillpatbuf ();
		5713	cons << GREEN << "Texture step = " << mondrian0.patstep << eol;
		5714	}
2060	jag	5715
		5716	PICKED_OPTION (menu, revmodl) {
		5717	static const char* opts [] = {"Both", "AM", "FM"};
		5718	int& revmod = din0.dinfo.revmod;
		5719	revmod += dir;
		5720	wrap (0, revmod, 2);
		5721	sprintf (BUFFER, " Reverse %s", opts[revmod]);
		5722	l.set_text (BUFFER);
		5723	}
		5724
		5725	CLICKED_BUTTON (menu, revclkl) {
		5726	din0.reverse_drone_modulation ();
		5727	}
2272	jag	5728
2273	jag	5729	VALUE_CHANGED (menu,sep_bin_lis) {
		5730	din0.change_drone_sep (MENU.sep_bin);
		5731	}

Subversion Repositories DIN Is Noise

(root)/wip/src/menu.cc - Rev 2340