WebSVN - DIN Is Noise - Blame - Rev 2338

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

Subversion Repositories DIN Is Noise

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