linuxaudio
/
new-session-manager
mirror of https://github.com/linuxaudio/new-session-manager
1
0
Fork 0
Code Issues 0 Releases 17 Wiki Activity
Assists music production by grouping standalone programs into sessions. Community version of "Non Session Manager".
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
24 Commits
1 Branch
15MB
Tree: 81fe5efb53
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '81fe5efb53'
${ noResults }
new-session-manager/gui/ui.fl

1770 lines
44KB
Raw Blame History 

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

  2. version 1.0107 

  3. header_name {.H} 

  4. code_name {.C}

  5. comment {//

  6. // Copyright (C) 2008 Jonathan Moore Liles

  7. //

  8. // This program is free software; you can redistribute it and/or

  9. // modify it under the terms of the GNU General Public License

  10. // as published by the Free Software Foundation; either version 2

  11. // of the License, or (at your option) any later version.

  12. //

  13. // This program is distributed in the hope that it will be useful,

  14. // but WITHOUT ANY WARRANTY; without even the implied warranty of

  15. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  16. // GNU General Public License for more details.

  17. //

  18. // You should have received a copy of the GNU General Public License

  19. // along with this program; if not, write to the Free Software

  20. // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

  21. //

  22. } {in_source in_header

  23. } 

  24. 

  25. decl {\#include <Fl/Fl_Dial.H>} {public

  26. } 

  27. 

  28. decl {\#include <Fl/Fl_Help_Dialog.H>} {} 

  29. 

  30. decl {\#include "widgets.H"} {} 

  31. 

  32. decl {\#include "event_edit.H"} {} 

  33. 

  34. decl {\#include "../jack.H"} {} 

  35. 

  36. decl {\#include "../lash.H"} {} 

  37. 

  38. decl {extern UI *ui;} {} 

  39. 

  40. decl {class O_Canvas;} {} 

  41. 

  42. decl {class Triggers;} {public

  43. } 

  44. 

  45. decl {class Instrument_Editor;} {} 

  46. 

  47. decl {Fl_Color canvas_background_color;} {public

  48. } 

  49. 

  50. decl {extern Fl_Color velocity_colors[];} {} 

  51. 

  52. Function {update_transport( void * )} {open return_type void

  53. } {

  54.   code {// transport_poll();

  55. 

  56. handle_midi_input();

  57. 

  58. lash.process();

  59. 

  60. ui->progress_group->do_callback();

  61. 

  62. ui->vmetro_widget->update();	

  63. 

  64. if ( transport.rolling )

  65. 	ui->triggers_widget->update();

  66. 

  67. Fl::repeat_timeout( TRANSPORT_POLL_INTERVAL, update_transport );

  68. 

  69. static int oldstate = -1;

  70. 

  71. if ( transport.rolling != oldstate )

  72. {

  73. 	ui->play_button->label( transport.rolling ? "@square" : "@>" );

  74. 	oldstate = transport.rolling;

  75. 	

  76. 	if ( transport.rolling )

  77. 	{

  78. 		ui->menu_new->deactivate();

  79. 		ui->menu_open->deactivate();

  80. 	}

  81. 	else

  82. 	{

  83. 		ui->menu_new->activate();

  84. 		ui->menu_open->activate();

  85. 	}

  86. }

  87. 

  88. // JUST A TEST

  89. if ( transport.rolling )

  90. {

  91. 	if ( ui->tabs->value() == ui->pattern_tab )

  92. 		ui->pattern_canvas_widget->draw_playhead();

  93. 	else

  94. 	if ( ui->tabs->value() == ui->phrase_tab )

  95. 		ui->phrase_canvas_widget->draw_playhead();

  96. 

  97. }} {}

  98. } 

  99. 

  100. class UI {open

  101. } {

  102.   decl {Fl_Text_Buffer *sequence_notes_buffer;} {}

  103.   decl {Fl_Text_Buffer *pattern_notes_buffer;} {}

  104.   decl {Fl_Text_Buffer *phrase_notes_buffer} {}

  105.   Function {UI()} {open

  106.   } {

  107.     code {// Make her pretty

  108. Fl::background( 32, 32, 32 );

  109. Fl::background2( 36, 36, 36 );

  110. Fl::foreground( 255, 255, 255 );

  111. Fl::scheme( "plastic" );

  112. 

  113. canvas_background_color = FL_GREEN;

  114. 

  115. main_window = make_main_window();

  116. seq_window = make_seq_window();

  117. 

  118. make_randomization_dialog();

  119. 

  120. // make_instrument_edit_dialog();

  121. 

  122. Fl::add_handler( shortcut_handler );

  123. 

  124. // use old focus behavior

  125. Fl::visible_focus( 0 );

  126. 

  127. main_window->show();

  128. 

  129. Fl::add_timeout( TRANSPORT_POLL_INTERVAL, update_transport );

  130. 

  131. 

  132. playlist->signal_new_song.connect( sigc::mem_fun( this, &UI::update_sequence_widgets ) );} {}

  133.   }

  134.   Function {~UI()} {open

  135.   } {

  136.     code {delete seq_window;

  137. delete main_window;} {}

  138.   }

  139.   Function {run()} {open

  140.   } {

  141.     code {Fl::run();} {}

  142.   }

  143.   Function {make_main_window()} {open

  144.   } {

  145.     Fl_Window main_window {

  146.       label {Non Sequencer}

  147.       callback {// Ignore escape

  148. if ( Fl::event() == FL_SHORTCUT && Fl::event_key() == FL_Escape )

  149. 	return;

  150. 	 

  151. if ( maybe_save_song() )

  152. 	quit();} open

  153.       xywh {694 168 869 801} type Double box PLASTIC_UP_BOX color 37 resizable xclass non size_range {869 801 0 0} visible

  154.     } {

  155.       Fl_Menu_Bar menu_bar {open

  156.         xywh {0 0 869 30} color 37

  157.       } {

  158.         Submenu {} {

  159.           label {&File} open

  160.           xywh {0 0 100 20} color 37

  161.         } {

  162.           MenuItem menu_new {

  163.             label {&New}

  164.             callback {if ( maybe_save_song() )

  165. {

  166. 	init_song();

  167. 

  168. 	// Sync the GUI.

  169. 	update_pattern_widgets();

  170. 	update_sequence_widgets();

  171. 	update_phrase_widgets();

  172. 	

  173. 	

  174. 	gui_status( "New song." );

  175. }}

  176.             xywh {0 0 40 25}

  177.           }

  178.           MenuItem menu_open {

  179.             label {&Open}

  180.             callback {char *name = fl_file_chooser( "Open File", "Non Files (*.non)", NULL, 0 );

  181. 

  182. if ( name )

  183. {

  184. 	if ( ! load_song( name ) )

  185. 		fl_alert( "Could not load song!" );

  186. 	else

  187. 		gui_status( "Song opened." );

  188. 	

  189. 	update_sequence_widgets();

  190. 	update_pattern_widgets();

  191. 	update_phrase_widgets();

  192. 

  193. 	playback_mode_menu->value( song.play_mode );

  194. 	playback_mode_menu->redraw();

  195. }}

  196.             xywh {0 0 40 25} shortcut 0x4006f color 37

  197.           }

  198.           MenuItem menu_save {

  199.             label {&Save}

  200.             callback {save_dialog( song.filename );}

  201.             xywh {0 0 40 25} shortcut 0x40073 color 37 deactivate

  202.             code0 {song.signal_dirty.connect( sigc::mem_fun( o, &Fl_Menu_Item::activate ) );}

  203.             code1 {song.signal_clean.connect( sigc::mem_fun( o, &Fl_Menu_Item::deactivate ) );}

  204.           }

  205.           MenuItem {} {

  206.             label {Save &As}

  207.             callback {save_dialog( NULL );}

  208.             xywh {0 0 40 25}

  209.           }

  210.           MenuItem {} {

  211.             label {&Import}

  212.             callback {char *name = fl_file_chooser( "MIDI Import", "MIDI Files (*.mid)", NULL, 0 );

  213. 

  214. if ( ! name )

  215. 	return;

  216. 

  217. smf f;

  218. 

  219. if ( ! f.open( name, smf::READ ) )

  220. {

  221. 	fl_message( "could not open file" );

  222. 	return;

  223. }

  224. 

  225. f.read_header();

  226. 

  227. switch ( f.format() )

  228. {

  229. 	case 0:

  230. 		if ( ! pattern::import( &f, 0 ) )

  231. 			fl_message( "Error importing MIDI" );

  232. 		break;

  233. 	case 1: case 2:

  234. 		{

  235. 			char **sa = f.track_listing();

  236. 

  237. 			if ( sa && *sa )

  238. 			{

  239. 				List_Chooser tc( "Select tracks to import:", "Import" );

  240. 

  241. 			 	char *s;

  242. 				for ( int i = 0; (s = sa[i]); ++i )

  243. 				{

  244. 					tc.add( s );

  245. 					free( s );

  246. 				}

  247. 

  248. 				free( sa );

  249. 

  250. 				tc.show();

  251. 

  252. 				while( tc.shown() )

  253. 					Fl::wait();

  254. 

  255. 				int n = 0;

  256. 				for ( int i = 1; i <= tc.browser->size(); ++i )

  257. 				{

  258. 					if ( tc.browser->selected( i ) )

  259. 					{

  260. 						if ( pattern::import( &f , i - 1 ) )

  261. 							++n;

  262. 						else

  263. 							WARNING( "error importing track %d", i - 1 );

  264. 					}

  265. 

  266. 				}

  267. 				// fl_message( "%d patterns imported.", n );

  268. 				gui_status( "Imported %d tracks as patterns", n );

  269. 			}

  270. 

  271. 			break;

  272. 		}

  273. }}

  274.             xywh {0 0 40 25}

  275.             code0 {\#include "../smf.H"}

  276.           }

  277.           MenuItem {} {

  278.             label {&Export}

  279.             callback {// Fl_File_Chooser::custom_filter_label = "*.mid";

  280. 

  281. Fl_File_Chooser *fc = new Fl_File_Chooser( ".", "MIDI Files (*.mid)", Fl_File_Chooser::CREATE, "MIDI Export" );

  282. 

  283. fc->show();

  284. 

  285. // wait for user to make a choice

  286. while( fc->shown() )

  287.       Fl::wait();

  288. 

  289. if ( ! fc->value() )

  290. 	return;

  291. 

  292. if ( tabs->value() == pattern_tab )

  293. 	((pattern*)pattern_c->grid())->save( fc->value() );}

  294.             xywh {0 0 40 25}

  295.             code0 {\#include <Fl/Fl_File_Chooser.H>}

  296.           }

  297.           MenuItem {} {

  298.             label {&Quit}

  299.             callback {main_window->do_callback();}

  300.             xywh {0 0 40 25} shortcut 0x40071 color 37

  301.           }

  302.         }

  303.         Submenu edit_menu {

  304.           label {&Edit} open

  305.           xywh {0 0 74 25} color 37

  306.         } {

  307.           MenuItem {} {

  308.             label {&Events}

  309.             callback {event_editor( pattern_c->grid() );}

  310.             xywh {0 0 40 25}

  311.           }

  312.           MenuItem {} {

  313.             label {&Randomization Settings}

  314.             callback {randomization_dialog->show();}

  315.             xywh {0 0 40 25}

  316.           }

  317.         }

  318.         Submenu {} {

  319.           label {&View} open

  320.           xywh {10 10 74 25} color 37

  321.         } {

  322.           MenuItem {} {

  323.             label {&Metronome}

  324.             callback {int val = o->menu()[ o->value() ].value();

  325. 

  326. if ( val )

  327. 	vmetro_widget->show();

  328. else

  329. 	vmetro_widget->hide();}

  330.             xywh {0 0 40 25} type Toggle value 1

  331.           }

  332.           MenuItem {} {

  333.             label {&Compacted}

  334.             callback {int val = o->menu()[ o->value() ].value();

  335. 

  336. pattern_c->row_compact( val ? Canvas::ON : Canvas::OFF );}

  337.             xywh {10 10 40 25} type Toggle value 1

  338.           }

  339.           MenuItem {} {

  340.             label {&Follow Playhead}

  341.             callback {int val = o->menu()[ o->value() ].value();

  342. 

  343. config.follow_playhead = val ? true : false;}

  344.             xywh {10 10 40 25} type Toggle value 1

  345.           }

  346.         }

  347.         Submenu {} {

  348.           label {&Help} open

  349.           xywh {100 0 74 25} color 37

  350.         } {

  351.           MenuItem {} {

  352.             label {&Keys}

  353.             callback {show_help_dialog( "KEYS" );}

  354.             xywh {0 0 40 25}

  355.           }

  356.           MenuItem {} {

  357.             label {&Manual}

  358.             callback {show_help_dialog( "MANUAL" );}

  359.             xywh {10 10 40 25} divider

  360.           }

  361.           MenuItem {} {

  362.             label {&About}

  363.             callback {make_about_popup();

  364. about_popup->show();}

  365.             xywh {0 0 40 25} color 37

  366.             code0 {\#include "../non.H"}

  367.           }

  368.         }

  369.       }

  370.       Fl_Tabs tabs {

  371.         callback {((Fl_Group*)o->value())->child( 0 )->take_focus();

  372. 

  373. if ( o->value() != pattern_tab )

  374. 	edit_menu->deactivate();

  375. else

  376. 	edit_menu->activate();

  377. 

  378. menu_bar->redraw();} open

  379.         xywh {0 76 868 701} color 37 labeltype SHADOW_LABEL labelsize 19 when 1

  380.         code0 {canvas_background_color = fl_rgb_color( 18, 18, 18 );}

  381.       } {

  382.         Fl_Group sequence_tab {

  383.           label Sequence open

  384.           xywh {0 98 868 674} color 37 hide resizable

  385.           code0 {update_sequence_widgets();}

  386.         } {

  387.           Fl_Group {} {open

  388.             xywh {10 125 233 502} labelsize 12

  389.           } {

  390.             Fl_Browser playlist_browser {

  391.               label Playlist

  392.               xywh {10 125 233 435} type Hold box EMBOSSED_BOX color 39 selection_color 30 labelcolor 55 align 1 when 4 textsize 18 textcolor 95 resizable

  393.               code0 {static int widths[] = { 40, 30, 0 };}

  394.               code1 {o->column_widths( widths ); o->column_char( '\\t' );}

  395.               code2 {o->value( 1 );}

  396.             }

  397.             Fl_Button sequence_phrase_delete_button {

  398.               label Delete

  399.               callback {int val = playlist_browser->value();

  400. 

  401. if ( val > 1 )

  402. {

  403. //	playlist_browser->value( playlist_browser->value() + 1 );

  404. 

  405. 	playlist->remove( val - 2 );

  406. 

  407. 	update_sequence_widgets();

  408. 	

  409. 	if ( ! playlist_browser->value() )

  410. 		playlist_browser->value( playlist_browser->size() );

  411. }}

  412.               xywh {14 566 73 25} shortcut 0xffff color 88 labelcolor 23

  413.             }

  414.             Fl_Button sequence_phrase_up_button {

  415.               label Up

  416.               callback {if ( playlist_browser->value() > 2 )

  417. {

  418. 	playlist->move( playlist_browser->value() - 2, UP );

  419. 	playlist_browser->value( playlist_browser->value() - 1 );

  420. 	update_sequence_widgets();

  421. }}

  422.               xywh {97 566 65 25} shortcut 0xffbf

  423.             }

  424.             Fl_Button sequence_phrase_down_button {

  425.               label Down

  426.               callback {if ( playlist_browser->value() > 1 )

  427. {

  428. 	playlist->move( playlist_browser->value() - 2, DOWN );

  429. 	playlist_browser->value( playlist_browser->value() + 1 );

  430. 	update_sequence_widgets();

  431. }}

  432.               xywh {169 566 74 25} shortcut 0xffc0

  433.             }

  434.             Fl_Menu_Button sequence_phrase_choice {

  435.               label {Insert Phrase}

  436.               callback {playlist->insert( playlist_browser->value() - 1, o->value() + 1 );

  437. 

  438. update_sequence_widgets();

  439. 

  440. int val = playlist_browser->value();

  441. 

  442. if ( val )

  443. 	playlist_browser->value( playlist_browser->value() + 1 );

  444. else

  445. 	playlist_browser->value( playlist_browser->size() );} open

  446.               xywh {11 597 232 30} color 63

  447.             } {}

  448.           }

  449.           Fl_Input sequence_name_field {

  450.             label {name:}

  451.             callback {playlist->name( o->value() );}

  452.             xywh {91 740 158 26} color 36 align 20 when 1 textcolor 32

  453.           }

  454.           Fl_Light_Button detach_button {

  455.             label Detach

  456.             callback {if ( o->value() )

  457. {

  458. 	Fl_Group *g = seq_detached_group;

  459. 	g->add( sequence_tab );

  460. 	sequence_tab->resize( g->x(), g->y(), g->w(), g->h() );

  461. 	seq_window->show();

  462. }

  463. else

  464. {

  465. 	seq_window->hide();

  466. 	tabs->insert( (Fl_Widget&)*sequence_tab, 0 );

  467. 	sequence_tab->resize( pattern_tab->x(), pattern_tab->y(), pattern_tab->w(), pattern_tab->h() );

  468. }}

  469.             xywh {7 740 78 26}

  470.           }

  471.           Fl_Text_Editor sequence_notes_edit {

  472.             label {Notes:}

  473.             callback {playlist->notes( o->buffer()->text() );}

  474.             xywh {254 691 606 73} selection_color 48 labelsize 12 align 5 textcolor 94

  475.             code0 {o->buffer( sequence_notes_buffer = new Fl_Text_Buffer );}

  476.           }

  477.           Fl_Box triggers_widget {

  478.             label Patterns

  479.             xywh {253 125 607 549} box UP_BOX color 72 align 1 resizable

  480.             code0 {o->box( FL_NO_BOX );}

  481.             class Triggers

  482.           }

  483.           Fl_Group progress_group {

  484.             callback {if ( ! o->visible_r() )

  485. 	return;

  486. 

  487. phrase *p = phrase::phrase_by_number( playlist->playing() );

  488. 

  489. if ( p )

  490. 	phrase_progress->value( p->index() / (double)p->length() );

  491. 	

  492. if ( playlist->length() )

  493. 	sequence_progress->value( playlist->index() / (double)playlist->length() );} open

  494.             xywh {10 656 233 66}

  495.           } {

  496.             Fl_Slider phrase_progress {

  497.               label Phrase

  498.               xywh {10 656 233 24} type Horizontal labelsize 12 align 1

  499.             }

  500.             Fl_Slider sequence_progress {

  501.               label Sequence

  502.               callback {transport.locate( (tick_t)((double)playlist->length() * o->value()) );}

  503.               xywh {10 698 233 24} type Horizontal labelsize 12 align 1

  504.             }

  505.           }

  506.         }

  507.         Fl_Group phrase_tab {

  508.           label Phrase open

  509.           xywh {0 98 868 674} color 37 hide

  510.           code0 {update_phrase_widgets();}

  511.         } {

  512.           Fl_Box phrase_canvas_widget {

  513.             label Phrase

  514.             xywh {4 102 860 590} box FLAT_BOX color 37 labelsize 100 align 16 resizable

  515.             code0 {o->set_canvas( phrase_c );}

  516.             code1 {o->box( FL_NO_BOX );}

  517.             class O_Canvas

  518.           }

  519.           Fl_Group {} {open

  520.             xywh {10 703 854 60}

  521.           } {

  522.             Fl_Input phrase_name_field {

  523.               label {name:}

  524.               callback {phrase_c->grid()->name( strdup( o->value() ) );

  525. 

  526. // if the name changed..

  527. update_sequence_widgets();}

  528.               xywh {10 703 144 25} color 36 align 20 textcolor 32

  529.             }

  530.             Fl_Spinner phrase_number_spinner {

  531.               callback {phrase *p = ((phrase *)phrase_c->grid())->by_number( o->value() );

  532. 

  533. if ( p )

  534.     phrase_c->grid( p );

  535. 

  536. o->maximum( phrase::phrases() );}

  537.               xywh {164 703 40 25} color 36 labeltype NO_LABEL when 1

  538.             }

  539.             Fl_Light_Button phrase_mute_button {

  540.               label Mute

  541.               xywh {10 740 88 23} color 37 hide

  542.             }

  543.             Fl_Light_Button phrase_solo_button {

  544.               label Solo

  545.               xywh {111 740 87 23} color 37 hide

  546.             }

  547.             Fl_Text_Editor phrase_notes_edit {

  548.               label {Notes:}

  549.               callback {phrase_c->grid()->notes( o->buffer()->text() );}

  550.               xywh {211 713 653 46} selection_color 48 labelsize 12 textcolor 94 resizable

  551.               code0 {o->buffer( phrase_notes_buffer = new Fl_Text_Buffer );}

  552.             }

  553.           }

  554.         }

  555.         Fl_Group pattern_tab {

  556.           label Pattern open

  557.           xywh {0 98 868 674} color 37

  558.           code0 {update_pattern_widgets();}

  559.         } {

  560.           Fl_Box pattern_canvas_widget {

  561.             label Pattern

  562.             xywh {4 102 860 590} box FLAT_BOX color 37 labelsize 100 align 16 resizable

  563.             code0 {\#include "draw.H"}

  564.             code1 {o->set_canvas( pattern_c );}

  565.             code2 {\#include "input.H"}

  566.             code3 {// o->box( FL_NO_BOX );}

  567.             class O_Canvas

  568.           }

  569.           Fl_Group {} {open

  570.             xywh {4 694 858 77}

  571.           } {

  572.             Fl_Input pattern_name_field {

  573.               label {name:}

  574.               callback {pattern_c->grid()->name( strdup( o->value() ) );}

  575.               xywh {10 703 144 25} color 36 align 20 when 1 textcolor 32

  576.             }

  577.             Fl_Spinner pattern_number_spinner {

  578.               callback {pattern *p = ((pattern *)pattern_c->grid())->by_number( o->value() );

  579. 

  580. if ( p )

  581.     pattern_c->grid( p );

  582. 

  583. o->maximum( pattern::patterns() );}

  584.               xywh {164 703 40 25} color 36 labeltype NO_LABEL when 1

  585.               code0 {o->maximum( 1 );}

  586.               code1 {// pattern::signal_create_destroy.connect( sigc::mem_fun( o, static_cast<void (Fl_Spinner::*)(double)>(&Fl_Spinner::maximum) ) );}

  587.             }

  588.             Fl_Light_Button pattern_mute_button {

  589.               label Mute

  590.               callback {Grid *g = pattern_c->grid();

  591. 

  592. g->mode( g->mode() == MUTE ? PLAY : MUTE );

  593. 

  594. o->value( g->mode() == MUTE );

  595. 

  596. pattern_solo_button->value( 0 );}

  597.               xywh {10 738 90 23} type Normal color 37

  598.               code0 {// o->type(FL_RADIO_BUTTON);}

  599.             }

  600.             Fl_Light_Button pattern_solo_button {

  601.               label Solo

  602.               callback {Grid *g = pattern_c->grid();

  603. 

  604. g->mode( g->mode() == SOLO ? PLAY : SOLO );

  605. 

  606. o->value( g->mode() == SOLO );

  607. 

  608. pattern_mute_button->value( 0 );}

  609.               xywh {110 738 91 23} type Normal color 37

  610.               code0 {// o->type( FL_RADIO_BUTTON );}

  611.             }

  612.             Fl_Text_Editor pattern_notes_edit {

  613.               label {Notes:}

  614.               callback {pattern_c->grid()->notes( o->buffer()->text() );}

  615.               xywh {214 713 243 48} selection_color 48 labelsize 12 textcolor 94 resizable

  616.               code0 {o->buffer( pattern_notes_buffer = new Fl_Text_Buffer );}

  617.             }

  618.             Fl_Group pattern_settings_group {open

  619.               xywh {458 694 400 77}

  620.             } {

  621.               Fl_Spinner pattern_channel_spinner {

  622.                 label Channel

  623.                 callback {((pattern *)pattern_c->grid())->channel( o->value() - 1 );}

  624.                 xywh {815 700 40 24} color 36 when 1

  625.                 code0 {\#include "../pattern.H"}

  626.                 code1 {o->maximum( 16 );}

  627.               }

  628.               Fl_Spinner pattern_port_spinner {

  629.                 label Port

  630.                 callback {((pattern *)pattern_c->grid())->port( o->value() - 1 );}

  631.                 xywh {815 734 40 24} color 36 when 1

  632.                 code0 {o->maximum( 16 );}

  633.               }

  634.               Fl_Output mapping_text {

  635.                 label Mapping

  636.                 xywh {464 734 145 24} align 20

  637.               }

  638.               Fl_Menu_Button mapping_menu {

  639.                 label {@>}

  640.                 callback {mapping_text->value( o->text() );

  641. 

  642. 

  643. char picked[80];

  644. mapping_menu->item_pathname(picked, sizeof(picked)-1 );

  645. 

  646. if ( 0 == strncmp( picked, "Instrument", strlen( "Instrument" ) ) )

  647. {

  648. 	((pattern*)pattern_c->grid())->mapping.open( Mapping::INSTRUMENT, o->text() );

  649. 

  650. 	pattern_c->changed_mapping();

  651. 

  652. 	pattern_key_combo->deactivate();

  653. }

  654. else

  655. if ( 0 == strncmp( picked, "Scale", strlen( "Scale" ) ) )

  656. {

  657. 	((pattern*)pattern_c->grid())->mapping.open( Mapping::SCALE, o->text() );

  658. 

  659. 	pattern_c->changed_mapping();

  660. 

  661. 	pattern_key_combo->activate();

  662. }} open

  663.                 xywh {609 734 30 24} labeltype NO_LABEL

  664.                 code0 {update_mapping_menu();}

  665.               } {

  666.                 Submenu mapping_scale_menu {

  667.                   label Scale open

  668.                   xywh {25 25 74 25}

  669.                 } {}

  670.                 Submenu mapping_instrument_menu {

  671.                   label Instrument open

  672.                   xywh {10 10 74 25}

  673.                 } {}

  674.               }

  675.               Fl_Choice pattern_key_combo {

  676.                 label {&Key}

  677.                 callback {((pattern*)pattern_c->grid())->mapping.key( o->value() );

  678. 

  679. pattern_c->changed_mapping();}

  680.                 xywh {674 734 75 24} down_box BORDER_BOX when 1

  681.               } {

  682.                 MenuItem {} {

  683.                   label C

  684.                   xywh {30 30 40 25}

  685.                 }

  686.                 MenuItem {} {

  687.                   label {C\#/Db}

  688.                   xywh {40 40 40 25}

  689.                 }

  690.                 MenuItem {} {

  691.                   label D

  692.                   xywh {50 50 40 25}

  693.                 }

  694.                 MenuItem {} {

  695.                   label {D\#/Eb}

  696.                   xywh {60 60 40 25}

  697.                 }

  698.                 MenuItem {} {

  699.                   label E

  700.                   xywh {70 70 40 25}

  701.                 }

  702.                 MenuItem {} {

  703.                   label F

  704.                   xywh {80 80 40 25}

  705.                 }

  706.                 MenuItem {} {

  707.                   label {F\#/Gb}

  708.                   xywh {90 90 40 25}

  709.                 }

  710.                 MenuItem {} {

  711.                   label G

  712.                   xywh {100 100 40 25}

  713.                 }

  714.                 MenuItem {} {

  715.                   label {G\#}

  716.                   xywh {110 110 40 25}

  717.                 }

  718.                 MenuItem {} {

  719.                   label A

  720.                   xywh {0 0 40 25}

  721.                 }

  722.                 MenuItem {} {

  723.                   label {A\#/Bb}

  724.                   xywh {10 10 40 25}

  725.                 }

  726.                 MenuItem {} {

  727.                   label B

  728.                   xywh {20 20 40 25}

  729.                 }

  730.               }

  731.               Fl_Choice pattern_note_combo {

  732.                 label {&Note 1/}

  733.                 callback {((pattern*)pattern_c->grid())->note( atoi( o->menu()[ o->value() ].text ));}

  734.                 xywh {704 700 45 24} down_box BORDER_BOX when 1

  735.               } {

  736.                 MenuItem {} {

  737.                   label 1

  738.                   xywh {0 0 40 25}

  739.                 }

  740.                 MenuItem {} {

  741.                   label 2

  742.                   xywh {10 10 40 25}

  743.                 }

  744.                 MenuItem {} {

  745.                   label 4

  746.                   xywh {20 20 40 25}

  747.                 }

  748.                 MenuItem {} {

  749.                   label 8

  750.                   xywh {30 30 40 25}

  751.                 }

  752.                 MenuItem {} {

  753.                   label 16

  754.                   xywh {40 40 40 25}

  755.                 }

  756.                 MenuItem {} {

  757.                   label 32

  758.                   xywh {50 50 40 25}

  759.                 }

  760.                 MenuItem {} {

  761.                   label 64

  762.                   xywh {60 60 40 25} divider

  763.                 }

  764.                 MenuItem {} {

  765.                   label 3

  766.                   xywh {60 60 40 25}

  767.                 }

  768.                 MenuItem {} {

  769.                   label 6

  770.                   xywh {70 70 40 25}

  771.                 }

  772.                 MenuItem {} {

  773.                   label 12

  774.                   xywh {80 80 40 25}

  775.                 }

  776.                 MenuItem {} {

  777.                   label 24

  778.                   xywh {90 90 40 25}

  779.                 }

  780.               }

  781.               Fl_Choice pattern_res_combo {

  782.                 label {&Resolution 1/}

  783.                 callback {pattern_c->grid()->resolution( atoi( o->menu()[ o->value() ].text ));}

  784.                 xywh {584 700 55 24} down_box BORDER_BOX when 1

  785.               } {

  786.                 MenuItem {} {

  787.                   label 4

  788.                   xywh {30 30 40 25}

  789.                 }

  790.                 MenuItem {} {

  791.                   label 8

  792.                   xywh {40 40 40 25}

  793.                 }

  794.                 MenuItem {} {

  795.                   label 16

  796.                   xywh {50 50 40 25}

  797.                 }

  798.                 MenuItem {} {

  799.                   label 32

  800.                   xywh {60 60 40 25}

  801.                 }

  802.                 MenuItem {} {

  803.                   label 64

  804.                   xywh {80 80 40 25}

  805.                 }

  806.                 MenuItem {} {

  807.                   label 128

  808.                   xywh {90 90 40 25} divider

  809.                 }

  810.                 MenuItem {} {

  811.                   label 3

  812.                   xywh {70 70 40 25}

  813.                 }

  814.                 MenuItem {} {

  815.                   label 6

  816.                   xywh {80 80 40 25}

  817.                 }

  818.                 MenuItem {} {

  819.                   label 12

  820.                   xywh {90 90 40 25}

  821.                 }

  822.                 MenuItem {} {

  823.                   label 24

  824.                   xywh {100 100 40 25}

  825.                 }

  826.               }

  827.             }

  828.           }

  829.         }

  830.       }

  831.       Fl_Group {} {open

  832.         xywh {5 33 853 52}

  833.       } {

  834.         Fl_Choice playback_mode_menu {

  835.           label {Playback &Mode} open

  836.           xywh {751 54 107 30} box PLASTIC_DOWN_BOX down_box BORDER_BOX color 37 align 1

  837.         } {

  838.           MenuItem {} {

  839.             label Pattern

  840.             callback {song.play_mode = PATTERN;}

  841.             xywh {0 0 40 25}

  842.           }

  843.           MenuItem {} {

  844.             label Sequence

  845.             callback {song.play_mode = SEQUENCE;}

  846.             xywh {10 10 40 25}

  847.           }

  848.           MenuItem {} {

  849.             label Trigger

  850.             callback {song.play_mode = TRIGGER;}

  851.             xywh {20 20 40 25}

  852.           }

  853.         }

  854.         Fl_Choice record_mode_menu {

  855.           label {&Record Mode}

  856.           callback {if ( ! transport.recording )

  857. 	config.record_mode = (record_mode_e)o->value();

  858. else

  859. 	o->value( config.record_mode );} open

  860.           xywh {634 54 107 30} box PLASTIC_DOWN_BOX down_box BORDER_BOX color 37 align 1

  861.         } {

  862.           MenuItem {} {

  863.             label Merge

  864.             xywh {10 10 40 25}

  865.           }

  866.           MenuItem {} {

  867.             label Overwrite

  868.             xywh {20 20 40 25}

  869.           }

  870.           MenuItem {} {

  871.             label Layer

  872.             xywh {30 30 40 25}

  873.           }

  874.           MenuItem {} {

  875.             label New

  876.             xywh {40 40 40 25}

  877.           }

  878.         }

  879.         Fl_Pack vmetro_widget {

  880.           label Metronome open

  881.           xywh {226 37 245 48} type HORIZONTAL box UP_BOX color 40 selection_color 48 labelsize 33 align 0 resizable

  882.           code0 {\#include "widgets.H"}

  883.           code1 {o->box( FL_NO_BOX );}

  884.           class Visual_Metronome

  885.         } {}

  886.         Fl_Group transport_controls_group {

  887.           xywh {481 37 143 48}

  888.         } {

  889.           Fl_Button play_button {

  890.             label {@>}

  891.             callback {transport.toggle();}

  892.             xywh {531 43 34 35} shortcut 0x20 labeltype ENGRAVED_LABEL

  893.           }

  894.           Fl_Button rec_button {

  895.             label {@circle}

  896.             callback {transport.recording = o->value();

  897. 

  898. 

  899. if ( o->value() )

  900. {

  901. 	if ( config.record_mode == NEW )

  902. 	{

  903. 		pattern *p = new pattern;

  904. 		p->length( -1 );

  905. 		

  906. 		pattern_c->grid( p );

  907. 	}

  908. 	

  909. 	((pattern*)pattern_c->grid())->record( 0 );

  910. 	

  911. 	o->labelcolor( FL_RED );

  912. }

  913. else

  914. {

  915. 	pattern::recording()->record_stop();

  916. 	

  917. 	o->labelcolor( FL_WHITE );

  918. }}

  919.             xywh {575 43 49 35} type Toggle shortcut 0x80072 selection_color 47 labeltype ENGRAVED_LABEL when 1

  920.           }

  921.           Fl_Button home_button {

  922.             label {@|<}

  923.             callback {transport.locate( 0 );}

  924.             xywh {481 43 40 35} shortcut 0xff50 labeltype ENGRAVED_LABEL

  925.           }

  926.         }

  927.         Fl_Group {} {open

  928.           xywh {5 33 208 38}

  929.         } {

  930.           Fl_Box {} {

  931.             label {BPM:}

  932.             xywh {5 37 35 34}

  933.           }

  934.           Fl_Counter {} {

  935.             callback {transport.set_beats_per_minute( o->value() );}

  936.             xywh {43 41 97 24} labeltype NO_LABEL align 4

  937.             code1 {transport.signal_tempo_change.connect( sigc::mem_fun( o, static_cast<int (Fl_Counter::*)(double)>(&Fl_Counter::value) ) );}

  938.             code2 {o->value( transport.beats_per_minute );}

  939.           }

  940.           Fl_Value_Input {} {

  941.             callback {transport.set_beats_per_bar( o->value() );}

  942.             xywh {149 41 26 24}

  943.             code0 {transport.signal_bpb_change.connect( sigc::mem_fun( o, static_cast<int (Fl_Valuator::*)(double)>(&Fl_Valuator::value) ) );}

  944.             code1 {o->value( transport.beats_per_bar );}

  945.           }

  946.           Fl_Value_Input {} {

  947.             callback {transport.set_beat_type( o->value() );}

  948.             xywh {189 41 24 24}

  949.             code0 {transport.signal_beat_change.connect( sigc::mem_fun( o, static_cast<int (Fl_Valuator::*)(double)>(&Fl_Valuator::value) ) );}

  950.             code1 {o->value( transport.beat_type );}

  951.           }

  952.           Fl_Box {} {

  953.             label {/}

  954.             xywh {170 41 19 24}

  955.           }

  956.         }

  957.       }

  958.       Fl_Output status {

  959.         xywh {0 776 869 25} box UP_BOX color 32 labeltype NO_LABEL textcolor 55

  960.       }

  961.     }

  962.   }

  963.   Function {make_seq_window()} {open

  964.   } {

  965.     Fl_Window seq_window {

  966.       label {Non Sequencer - Sequence}

  967.       callback {sequence_tab->activate();

  968. o->hide();

  969. detach_button->value( 0 );} open

  970.       xywh {681 189 876 675} type Double resizable visible

  971.     } {

  972.       Fl_Group seq_detached_group {open selected

  973.         xywh {0 0 876 675} resizable

  974.       } {}

  975.     }

  976.   }

  977.   Function {make_about_popup()} {} {

  978.     Fl_Window about_popup {

  979.       label About open

  980.       xywh {944 405 539 608} type Single non_modal size_range {539 608 539 608} visible

  981.     } {

  982.       Fl_Box {} {

  983.         label VERSION

  984.         image {../logo.xpm} xywh {10 29 525 209}

  985.         code0 {o->label( VERSION );}

  986.       }

  987.       Fl_Group {} {open

  988.         xywh {26 272 488 272} box ROUNDED_BOX color 51

  989.       } {

  990.         Fl_Box {} {

  991.           label {Copyright (C) 2007-2008 Jonathan Moore Liles}

  992.           xywh {26 272 488 32} labeltype SHADOW_LABEL labelfont 1 labelsize 18

  993.         }

  994.         Fl_Box {} {

  995.           label {This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

  996. 

  997. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  998. 

  999. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.}

  1000.           xywh {41 311 463 233} labelfont 1 labelsize 12 align 144

  1001.         }

  1002.       }

  1003.       Fl_Button {} {

  1004.         label {http://non.tuxfamily.org}

  1005.         callback {system( "x-www-browser http://non.tuxfamily.org &" );}

  1006.         xywh {178 554 188 30} color 14 labeltype SHADOW_LABEL labelcolor 6

  1007.       }

  1008.       Fl_Return_Button {} {

  1009.         label rock

  1010.         callback {about_popup->hide();}

  1011.         xywh {453 570 78 31}

  1012.       }

  1013.     }

  1014.   }

  1015.   Function {make_randomization_dialog()} {} {

  1016.     Fl_Window randomization_dialog {

  1017.       label {Randomization Settings} open

  1018.       xywh {656 39 342 98} type Double

  1019.       code0 {// feel->value( )}

  1020.       code1 {probability->value( song.random.probability );} non_modal visible

  1021.     } {

  1022.       Fl_Choice feel {

  1023.         label {Feel: 1/}

  1024.         callback {song.random.feel = atoi( o->menu()[ find_numeric_menu_item( o->menu(), o->value() ) ].text );} open

  1025.         xywh {67 55 50 24} down_box BORDER_BOX

  1026.       } {

  1027.         MenuItem {} {

  1028.           label 4

  1029.           xywh {10 10 40 25}

  1030.         }

  1031.         MenuItem {} {

  1032.           label 8

  1033.           xywh {0 0 40 25}

  1034.         }

  1035.         MenuItem {} {

  1036.           label 16

  1037.           xywh {10 10 40 25}

  1038.         }

  1039.       }

  1040.       Fl_Box {} {

  1041.         label {Randomization Settings}

  1042.         xywh {10 15 321 28} box ROUNDED_BOX color 94 labelsize 22 labelcolor 39

  1043.       }

  1044.       Fl_Counter probability {

  1045.         label Probability

  1046.         callback {song.random.probability = o->value();}

  1047.         xywh {216 53 112 26} type Simple align 4 when 4 minimum 0 maximum 1 step 0.01

  1048.       }

  1049.     }

  1050.   }

  1051.   Function {update_pattern_widgets()} {open

  1052.   } {

  1053.     code {if ( ! pattern_settings_group )

  1054. 	return;

  1055. 	

  1056. pattern *g = (pattern *)pattern_c->grid();

  1057. 

  1058. pattern_number_spinner->value( g->number() );

  1059. pattern_name_field->value( g->name() );

  1060. pattern_channel_spinner->value( 1 + g->channel() );

  1061. pattern_port_spinner->value( 1 + g->port() );

  1062. pattern_solo_button->value( g->mode() == SOLO );

  1063. pattern_mute_button->value( g->mode() == MUTE );

  1064. 

  1065. if ( g->mapping.key() == -1 )

  1066. 	pattern_key_combo->deactivate();

  1067. else

  1068. {

  1069. 	pattern_key_combo->activate();

  1070. 	pattern_key_combo->value( g->mapping.key() );

  1071. }

  1072. 

  1073. mapping_text->value( g->mapping.name() );

  1074. 

  1075. 

  1076. 

  1077. pattern_note_combo->value( find_numeric_menu_item( menu_pattern_note_combo, g->note() ));

  1078. pattern_res_combo->value( find_numeric_menu_item( menu_pattern_res_combo, g->resolution() ));

  1079. 

  1080. if ( g->notes() )

  1081. 	pattern_notes_buffer->text( g->notes() );

  1082. else

  1083. 	pattern_notes_buffer->text( strdup( "" ) );} {}

  1084.   }

  1085.   Function {update_phrase_widgets()} {} {

  1086.     code {phrase *g = (phrase *)phrase_c->grid();

  1087. 

  1088. if ( ! g )

  1089. 	return;

  1090. 	

  1091. phrase_number_spinner->value( g->number() );

  1092. phrase_name_field->value( g->name() );

  1093. phrase_solo_button->value( g->mode() == SOLO );

  1094. phrase_mute_button->value( g->mode() == MUTE );

  1095. 

  1096. if ( g->notes() )

  1097. 	phrase_notes_buffer->text( g->notes() );

  1098. else

  1099. 	phrase_notes_buffer->text( strdup( "" ) );} {}

  1100.   }

  1101.   Function {update_sequence_widgets()} {open

  1102.   } {

  1103.     code {if ( playlist->notes() )

  1104. 	sequence_notes_buffer->text( playlist->notes() );

  1105. else

  1106. 	sequence_notes_buffer->text( strdup( "" ) );

  1107. 	

  1108. sequence_name_field->value( playlist->name() );

  1109. 

  1110. sequence_phrase_choice->clear();

  1111. 

  1112. for ( int i = 1; i <= phrase::phrases(); i++ )

  1113. {

  1114. 	phrase *p = phrase::phrase_by_number( i );

  1115. 

  1116. 	if ( p )

  1117. 		sequence_phrase_choice->add( p->name() );

  1118. }

  1119. 

  1120. 

  1121. Fl_Browser *o = playlist_browser;

  1122. 

  1123. int val = o->value();

  1124. 

  1125. o->clear();

  1126. 

  1127. char *s = playlist->dump();

  1128. 

  1129. char *l = strtok( s, "\\n" );

  1130. 

  1131. o->add( "@b@C2Bar\\t@b@C2\#\\t@b@C2Name" );

  1132. 

  1133. if ( ! l )

  1134. 	return;

  1135. 

  1136. o->add( l );

  1137. 

  1138. while ( ( l = strtok( NULL, "\\n" ) ) )

  1139. {

  1140. 	o->add( l );

  1141. }

  1142. 

  1143. o->value( val );

  1144. 

  1145. free( s );

  1146. 

  1147. 

  1148. if ( playback_mode_menu )

  1149. 	playback_mode_menu->value( song.play_mode );} {}

  1150.   }

  1151.   Function {update_mapping_menu()} {open

  1152.   } {

  1153.     code {char **sa = Instrument::listing();

  1154. 

  1155. if ( sa )

  1156. {

  1157. 

  1158. 	for ( int i = 0; sa[i]; i++ )

  1159. 	{

  1160. 		char pat[512];

  1161. 		snprintf( pat, 512, "Instrument/%s", sa[i] );

  1162. 		mapping_menu->add( pat, 0, 0, 0, 0 );

  1163. 		free( sa[i] );

  1164. 	}

  1165. 	free( sa );

  1166. }

  1167. 

  1168. sa = Scale::listing();

  1169. for ( int i = 0; sa[i]; i++ )

  1170. {

  1171. 	char pat[512];

  1172. 	snprintf( pat, 512, "Scale/%s", sa[i] );

  1173. 	mapping_menu->add( pat, 0, 0, 0, 0 );

  1174. 	free( sa[i] );

  1175. }

  1176. free( sa );} {}

  1177.   }

  1178.   Function {update_canvas_widgets()} {return_type {static void}

  1179.   } {

  1180.     code {if ( pattern_c->grid() )

  1181. 	ui->update_pattern_widgets();

  1182. 

  1183. if ( phrase_c->grid() )

  1184. 	ui->update_phrase_widgets();} {}

  1185.   }

  1186.   Function {find_numeric_menu_item( const Fl_Menu_Item *menu, int n )} {return_type {static int}

  1187.   } {

  1188.     code {for ( unsigned int i = 0; menu[i].text; i++ )

  1189. {

  1190. 	if ( atoi( menu[i].text ) == n )

  1191. 		return i;

  1192. }

  1193. 

  1194. return 0;} {}

  1195.   }

  1196.   Function {save_dialog( const char *name )} {open return_type void

  1197.   } {

  1198.     code {if ( ! name )

  1199. {

  1200. 

  1201. 	Fl_File_Chooser *fc = new Fl_File_Chooser( ".", "Non Sequences (*.non)", Fl_File_Chooser::CREATE, "Save sequence" );

  1202. 

  1203. 	fc->show();

  1204. 

  1205. 	// wait for user to make a choice

  1206. 	while( fc->shown() )

  1207.      		 Fl::wait();

  1208. 

  1209. 	if ( ! fc->value() )

  1210. 		return;

  1211. 	

  1212. 	name = fc->value();	

  1213. }

  1214. 

  1215. if ( ! save_song( name ) )

  1216. 	fl_alert( "Could not save song" );

  1217. else

  1218. 	gui_status( "Saved." );} {}

  1219.   }

  1220.   Function {show_help_dialog( const char *file )} {return_type void

  1221.   } {

  1222.     code {char pat[256];

  1223. 

  1224. snprintf( pat, 256, "%s%s.html", DOCUMENT_PATH, file );

  1225. 

  1226. Fl_Help_Dialog        *help;          // Help dialog

  1227. 

  1228. help = new Fl_Help_Dialog;

  1229. 

  1230. help->load( pat );

  1231. 

  1232. help->show();

  1233. 

  1234. // FIXME: need to delete it somehow.

  1235. //  help->show(1, argv);} {}

  1236.   }

  1237.   Function {maybe_save_song()} {open return_type bool

  1238.   } {

  1239.     code {if ( song.dirty() )

  1240. {

  1241. 	int c = fl_choice( "Song has been modified since last save. What shall I do?", "Cancel", "Save", "Discard" );

  1242. 

  1243. 	switch ( c )

  1244. 	{

  1245. 		case 0:

  1246. 			return false;

  1247. 		case 1:

  1248. 			/* SAVE */

  1249. 			save_dialog( song.filename );

  1250. 			break;

  1251. 		case 2:

  1252. 			break;

  1253. 	}	

  1254. }

  1255. 

  1256. return true;} {}

  1257.   }

  1258.   Function {switch_to_pattern( int n )} {return_type void

  1259.   } {

  1260.     code {pattern *p = pattern::pattern_by_number( n );

  1261. 

  1262. if ( p )

  1263. {

  1264. 

  1265. 

  1266. 	

  1267. 	tabs->value( pattern_tab );

  1268. 	

  1269. 	pattern_canvas_widget->take_focus();

  1270. 	

  1271. 	pattern_c->grid( p );

  1272. 	

  1273. //	update_pattern_widgets();

  1274. }} {}

  1275.   }

  1276.   Function {edit_instrument_row( Instrument *i, int n )} {open return_type void

  1277.   } {

  1278.     code {Instrument_Editor ie;

  1279. 

  1280. ie.set( i, n );

  1281. 

  1282. ie.run();} {}

  1283.   }

  1284. } 

  1285. 

  1286. Function {shortcut_handler( int e )} {return_type int

  1287. } {

  1288.   code {if ( e != FL_SHORTCUT )

  1289. 	return 0;

  1290. 

  1291. 

  1292. // this is for mainwindow shortcuts only, ignore all other windows.

  1293. if ( Fl::first_window() != ui->main_window )

  1294. 	return 0;

  1295. 

  1296. int processed = 0;

  1297. 

  1298. // shortcuts that don't fit anywhere else (widgets that don't take shortcuts, etc.)

  1299. 

  1300. \#define KEY(key) ((Fl::test_shortcut( (key) )))

  1301. 

  1302. 	processed = 1;

  1303. 	if KEY( FL_ALT + 's' )

  1304. 	{

  1305. 		ui->tabs->value( ui->sequence_tab );

  1306. 		ui->tabs->do_callback();

  1307. 	}

  1308. 	else

  1309. 	if KEY( FL_ALT + 'a' )

  1310. 	{

  1311. 		ui->tabs->value( ui->phrase_tab );

  1312. 		ui->tabs->do_callback();

  1313. 	}

  1314. 	else

  1315. 	if KEY( FL_ALT + 'p' )

  1316. 	{

  1317. 		ui->tabs->value( ui->pattern_tab );

  1318. 		ui->tabs->do_callback();

  1319. 	}

  1320. 	else

  1321. 	if KEY( FL_ALT + 'c' )

  1322. 		ui->pattern_channel_spinner->take_focus();

  1323. 	else

  1324. 	if KEY( FL_ALT + 'o' )

  1325. 		ui->pattern_port_spinner->take_focus();

  1326. 	else

  1327. 	if KEY( FL_ALT + 'i' )

  1328. 		ui->mapping_menu->take_focus();

  1329. 	else

  1330. 		processed = 0;

  1331. 

  1332. return processed;} {}

  1333. } 

  1334. 

  1335. decl {\#include <FL/Fl_Single_Window.H>} {public

  1336. } 

  1337. 

  1338. class O_Canvas {open : {public Fl_Double_Window}

  1339. } {

  1340.   decl {Canvas *_c;} {}

  1341.   decl {bool _border_drawn;} {}

  1342.   decl {uint _flags;} {}

  1343.   Function {O_Canvas( int X, int Y, int W, int H, const char*L=0) : Fl_Double_Window(X,Y,W,H,L)} {open

  1344.   } {

  1345.     code {_c = NULL;

  1346. _border_drawn = false;

  1347. _flags = 0;

  1348. 

  1349. end();} {}

  1350.   }

  1351.   Function {handle( int m )} {open return_type int

  1352.   } {

  1353.     code {// Accept focus if offered.

  1354. if ( m == FL_FOCUS || m == FL_UNFOCUS )

  1355. {

  1356. 	_border_drawn = false;

  1357. 	draw_playhead();

  1358. 	return 1;

  1359. }

  1360. 

  1361. // Hack in click-to-focus

  1362. if ( m == FL_PUSH )

  1363. 	if ( Fl::event_inside( this ) )

  1364. 		take_focus();

  1365. 

  1366. 

  1367. if ( Fl_Window::handle( m ) )

  1368. 	return 1;

  1369. 

  1370. // Ignore events unless we have the focus.

  1371. if ( this != Fl::focus() )

  1372. 	return 0;

  1373. 

  1374. // MESSAGE( "got event %i for canvas %p", m, _c );

  1375. 

  1376. int p = 0;

  1377. 

  1378. if ( _c )

  1379. 	{

  1380. 		p = canvas_input_callback( this, _c, m );

  1381. 	}

  1382. 

  1383. return p;} {}

  1384.   }

  1385.   Function {resize( int x, int y, int w, int h )} {open

  1386.   } {

  1387.     code {Fl_Double_Window::resize( x, y, w, h );

  1388. 

  1389. if ( _c )

  1390. {

  1391. 	DEBUG( "Resizing canvas." );

  1392. 	_c->resize( 0 + 1, 0 + 1, w - 1, h - 1 );

  1393. }

  1394. 

  1395. 

  1396. // Fl_Window::resize( x, y, w, h );} {}

  1397.   }

  1398.   Function {draw()} {open return_type void

  1399.   } {

  1400.     code {draw_border();

  1401. 

  1402. //if ( ! takesevents() )

  1403. //	return;

  1404. 

  1405. if ( _c )

  1406. {

  1407. 

  1408. 	damage( _flags );

  1409. 	_flags = 0;

  1410. 	

  1411. 	/*

  1412. 	if ( damage() & FL_DAMAGE_ALL ) printf( " damage_all" );

  1413. 	if ( damage() & FL_DAMAGE_SCROLL ) printf( " damage_scroll" );

  1414. 	if ( damage() & FL_DAMAGE_USER1 ) printf( " damage_user1" );

  1415. 	if ( damage() & FL_DAMAGE_USER2 ) printf( " damage_user2" );

  1416. 	if ( damage() & FL_DAMAGE_EXPOSE ) printf(  " damage_expose" );

  1417. 	printf("\\n");

  1418. 	*/

  1419. 

  1420. 	if ( damage() & FL_DAMAGE_EXPOSE )

  1421. 	{

  1422. 		draw_box( FL_FLAT_BOX, 0, 0, w(), h(), canvas_background_color );

  1423. 		_c->redraw();

  1424. 		return;

  1425. 	}

  1426. 	

  1427. 	if ( damage() & (FL_DAMAGE_ALL | FL_DAMAGE_USER2) )

  1428. 	{

  1429. 		draw_box( FL_FLAT_BOX, 0, 0, w(), h(), canvas_background_color );

  1430. 		_c->redraw();

  1431. 	}

  1432. 	

  1433. 	

  1434. 	if ( damage() & (FL_DAMAGE_ALL | FL_DAMAGE_SCROLL) )

  1435. 	{

  1436. 		// optimized draw

  1437. 		_c->draw();

  1438. 	}

  1439. 	else

  1440. 	if ( damage() & (FL_DAMAGE_ALL | FL_DAMAGE_USER1) )

  1441. 	{

  1442. 		// playhead

  1443. 		_c->draw_playhead();

  1444. 	}

  1445. 	else

  1446. 	if ( damage() & FL_DAMAGE_ALL )

  1447. 	{

  1448. 		draw_box( FL_FLAT_BOX, 0, 0, w(), h(), canvas_background_color );

  1449. 		_border_drawn = false;

  1450. 		draw_border();

  1451. 		_c->redraw();

  1452. 		

  1453. 	}

  1454. }

  1455. else

  1456. {

  1457. 	WARNING( "No canvas set for widget." );

  1458. }} {}

  1459.   }

  1460.   Function {set_canvas( Canvas *c )} {open

  1461.   } {

  1462.     code {_c = c;

  1463. 

  1464. _c->resize( x(), y(), w(), h() );

  1465. 

  1466. _c->signal_draw.connect( sigc::mem_fun( this, &O_Canvas::draw_notes ) );

  1467. _c->signal_resize.connect( sigc::mem_fun( this, &O_Canvas::clear ) );

  1468. 

  1469. _c->signal_settings_change.connect( sigc::ptr_fun( &UI::update_canvas_widgets ) );} {}

  1470.   }

  1471.   Function {click_to_focus()} {open return_type bool

  1472.   } {

  1473.     code {return true;} {}

  1474.   }

  1475.   Function {clear( void )} {open return_type void

  1476.   } {

  1477.     code {// parent()->parent()->damage( FL_DAMAGE_ALL, x(), y(), w(), h() );

  1478. damage( FL_DAMAGE_USER2 );

  1479. 

  1480. _flags |= FL_DAMAGE_USER2;} {}

  1481.   }

  1482.   Function {draw_notes( void )} {open return_type void

  1483.   } {

  1484.     code {damage( FL_DAMAGE_SCROLL );

  1485. 

  1486. // this might be called from within draw(), in which case the above does nothing.

  1487. 

  1488. _flags |= FL_DAMAGE_SCROLL;} {}

  1489.   }

  1490.   Function {draw_playhead( void )} {open return_type void

  1491.   } {

  1492.     code {damage( FL_DAMAGE_USER1 );} {}

  1493.   }

  1494.   Function {draw_border()} {open return_type void

  1495.   } {

  1496.     code {if ( _border_drawn )

  1497. 	return;

  1498. 

  1499. if ( this != Fl::focus() )

  1500. 	fl_color( FL_RED );

  1501. else

  1502. 	fl_color( FL_BLACK );

  1503. 	

  1504. fl_line_style( FL_DASH );

  1505. fl_rect( 0, 0, w(), h() );

  1506. fl_line_style( FL_SOLID );

  1507. 

  1508. _border_drawn = true;} {}

  1509.   }

  1510. } 

  1511. 

  1512. class Instrument_Editor {} {

  1513.   Function {Instrument_Editor()} {open return_type void

  1514.   } {

  1515.     code {make_window();} {}

  1516.   }

  1517.   decl {Instrument *_inst;} {}

  1518.   decl {int _note;} {}

  1519.   Function {make_window()} {open

  1520.   } {

  1521.     Fl_Window window {

  1522.       label {Instrument Editor}

  1523.       callback {done->do_callback();} open

  1524.       xywh {670 458 339 191} type Double visible

  1525.     } {

  1526.       Fl_Box {} {

  1527.         label {Instrument Row}

  1528.         xywh {8 15 321 28} box ROUNDED_BOX color 94 labelsize 22 labelcolor 39

  1529.       }

  1530.       Fl_Input name_field {

  1531.         label Name

  1532.         callback {_inst->note_name( _note, strdup( o->value() ) );}

  1533.         xywh {10 70 321 25} selection_color 48 align 1 when 1 textcolor 32

  1534.       }

  1535.       Fl_Value_Slider volume_slider {

  1536.         label {Volume %}

  1537.         callback {_inst->velocity( _note, o->value() );}

  1538.         xywh {10 112 321 27} type Horizontal align 1 maximum 100 step 1 textsize 14

  1539.       }

  1540.       Fl_Value_Output note_field {

  1541.         label {Note:}

  1542.         xywh {52 158 43 24}

  1543.       }

  1544.       Fl_Return_Button done {

  1545.         label Done

  1546.         callback {if ( _inst )

  1547. 	_inst->save();

  1548. 	

  1549. window->hide();}

  1550.         xywh {255 157 76 25}

  1551.       }

  1552.     }

  1553.   }

  1554.   Function {set( Instrument *i, int n )} {open return_type void

  1555.   } {

  1556.     code {_inst = i;

  1557. _note = n;

  1558. 

  1559. volume_slider->value( i->velocity( n ) );

  1560. name_field->value( i->note_name( n ) );

  1561. note_field->value( n );} {}

  1562.   }

  1563.   Function {run()} {open return_type void

  1564.   } {

  1565.     code {window->show();

  1566. 

  1567. while ( window->shown() )

  1568. 	Fl::wait();} {}

  1569.   }

  1570. } 

  1571. 

  1572. class Trigger {: {public Fl_Dial}

  1573. } {

  1574.   Function {Trigger( int X, int Y, int W, int H, const char *L = 0 ) : Fl_Dial( X, Y, W, H, L )} {open

  1575.   } {}

  1576.   Function {handle( int m )} {open return_type int

  1577.   } {

  1578.     code {int r = 0;

  1579. 

  1580. switch ( m )

  1581. {

  1582. 	case FL_PUSH:

  1583. 	{

  1584. 		switch ( Fl::event_button() )

  1585. 		{

  1586. 			case 1:

  1587. 			{

  1588.  				pattern *p = pattern::pattern_by_number( atoi( label() ) );

  1589. 				

  1590. 				if ( p )

  1591. 				{

  1592. 					if ( p->mode() == MUTE )

  1593. 						p->mode( PLAY );

  1594. 					else

  1595. 						p->mode( MUTE );

  1596. 				}

  1597. 				

  1598. 				break;

  1599. 			}

  1600. 			case 2:

  1601. 			{

  1602.  				pattern *p = pattern::pattern_by_number( atoi( label() ) );

  1603. 				

  1604. 				if ( p )

  1605. 				{

  1606. 					if ( p->mode() != SOLO )

  1607. 						p->mode( SOLO );

  1608. 					else

  1609. 						p->mode( PLAY );

  1610. 				}

  1611. 				

  1612. 				break;

  1613. 			}

  1614. 			case 3:

  1615. 			{

  1616. 				ui->switch_to_pattern( atoi( label() ) );

  1617. 			}

  1618. 				break;

  1619. 		}

  1620. 		r = 1;

  1621. 		break;

  1622. 	}

  1623. 	case FL_RELEASE:

  1624. 		MESSAGE("doing callback");

  1625. 		do_callback();

  1626. 		r = 1;

  1627. 		break;

  1628. 	case FL_DRAG:

  1629. 		r = 1;

  1630. 		break;

  1631. 	default:

  1632. 		r = Fl_Widget::handle( m );

  1633. 		break;

  1634. }

  1635. 

  1636. 

  1637. return r;} {}

  1638.   }

  1639. } 

  1640. 

  1641. widget_class Triggers {open

  1642.   xywh {121 31 1278 1003} type Double hide resizable

  1643.   code0 {populate();}

  1644.   code1 {\#include <Fl/Fl_Dial.H>}

  1645.   class Fl_Group

  1646. } {

  1647.   Fl_Pack rows {open

  1648.     xywh {25 25 15 15}

  1649.     code0 {// o->position( x(), y() );}

  1650.   } {}

  1651.   Function {populate( void )} {open private return_type void

  1652.   } {

  1653.     code {int bw = (w() / 16);

  1654. int bh = h() / (128/ 16);

  1655. 

  1656. begin();

  1657. 

  1658. for ( int n = 0; n < 128 ; n += 16 )

  1659. {

  1660. 	Fl_Pack *p = new Fl_Pack( 0, 0, 25, 25 );

  1661. 	

  1662. 	p->type( Fl_Pack::HORIZONTAL );

  1663. 	

  1664. 	for ( int i = 0; i < 16; i++ )

  1665. 	{

  1666. 		

  1667. 		Trigger *b = new Trigger( 0, 0, bw, 50, "Num" );

  1668. 		

  1669. 		char pat[4];

  1670. 		

  1671. 		sprintf( pat, "%d", n + i + 1 );

  1672. 		

  1673. 		b->label( strdup( pat ) );

  1674. 		b->minimum( 0 );

  1675. 		b->maximum( 1 );

  1676. 		b->angles( 0, 360 );

  1677. 		b->type( FL_FILL_DIAL );

  1678. //		b->box( FL_ROUNDED_BOX );

  1679. //		b->down_box( FL_ROUNDED_BOX );

  1680. 		b->selection_color( FL_GREEN );

  1681. 		b->color( FL_BLACK );

  1682. 		b->align( FL_ALIGN_CENTER );

  1683. 				

  1684. 		p->add( b );

  1685. 	}

  1686. 		

  1687. 	p->end(); 

  1688. 	

  1689. 	p->resize( 0, 0, w(), bh );

  1690. 	rows->add( p );

  1691. }

  1692. 

  1693. 

  1694. end();

  1695. 

  1696. rows->resize( x(), y(), w(), h() );

  1697. 

  1698. redraw();} {}

  1699.   }

  1700.   Function {update( void )} {open return_type void

  1701.   } {

  1702.     code {if ( ! takesevents() )

  1703. 	return;

  1704. 

  1705. int i;

  1706. for ( i = 0; i < MAX_PATTERN; i++ )

  1707. {

  1708. 

  1709. 	Trigger *b = (Trigger*)(((Fl_Pack*)rows->child( i / 16 ))->child( i % 16 ));

  1710. 

  1711. 	if ( i >= pattern::patterns() )

  1712. 	{

  1713. 		b->color( FL_BLACK );

  1714. 		b->value( 0 );

  1715. 		continue;

  1716. 	}

  1717. 	

  1718. 	pattern *p = pattern::pattern_by_number( i + 1 );

  1719. 			

  1720. 	if ( p->playing() )

  1721. 	{

  1722. 		b->color( fl_lighter( FL_GRAY ) );

  1723. 		

  1724. 		Fl_Color c = FL_BLUE;

  1725. 		

  1726. 		switch ( p->mode() )

  1727. 		{

  1728. 			case MUTE:

  1729. 				c = FL_GRAY;

  1730. 				break;

  1731. 			case SOLO:

  1732. 				c = FL_RED;

  1733. 				break;

  1734. 			case PLAY:

  1735. 				c = FL_GREEN;

  1736. 				break;

  1737. 		}

  1738. 		

  1739. 		b->selection_color( c );

  1740. 		

  1741. 		b->value( (double)p->index() / p->length() );

  1742. 	}

  1743. 	else

  1744. 	{

  1745. 		b->value( 0 );

  1746. 	}

  1747. 		

  1748. }} {}

  1749.   }

  1750.   Function {resize( int X, int Y, int W, int H )} {open return_type void

  1751.   } {

  1752.     code {for ( int i = rows->children(); i--; )

  1753. {

  1754. 	Fl_Pack *p = (Fl_Pack*) rows->child( i );

  1755. 	

  1756. 	for ( int j = p->children(); j--; )

  1757. 	{

  1758. 		int bw = W / p->children();

  1759. 		p->child( j )->resize( 0, 0, bw, 25 );;

  1760. 	}

  1761. 

  1762. 	p->resize( 0, 0, W, H / rows->children() );

  1763. 			

  1764. 	p->redraw();

  1765. }

  1766. 

  1767. Fl_Group::resize( X, Y, W, H );} {}

  1768.   }

  1769. }