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.
911 Commits
1 Branch
18MB
Tree: e8eae16fa1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e8eae16fa1'
${ noResults }
new-session-manager/Timeline/TLE.fl

1095 lines
31KB
Raw Blame History 

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

  2. version 1.0110 

  3. header_name {.H} 

  4. code_name {.C}

  5. comment {//

  6. // Copyright (C) 2008-2010 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 {const float STATUS_UPDATE_FREQ = 0.5f;} {} 

  26. 

  27. decl {\#include "Fl_Menu_Settings.H"} {} 

  28. 

  29. decl {\#include "Timeline.H"} {} 

  30. 

  31. decl {\#include "Transport.H"} {} 

  32. 

  33. decl {\#include "Loggable.H"} {} 

  34. 

  35. decl {\#include "Project.H"} {} 

  36. 

  37. decl {\#include "Clock.H"} {public

  38. } 

  39. 

  40. decl {\#include "New_Project_Dialog.H"} {} 

  41. 

  42. decl {\#include "Track.H" // for capture_format} {} 

  43. 

  44. decl {\#include "Waveform.H" // for options} {} 

  45. 

  46. decl {\#include "Audio_Region.H" // for options} {} 

  47. 

  48. decl {\#include "Control_Sequence.H" // for options} {} 

  49. 

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

  51. 

  52. decl {\#include <Fl/Fl_Shared_Image.H>} {} 

  53. 

  54. decl {\#include <FL/Fl.H>} {} 

  55. 

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

  57. 

  58. decl {\#include "Engine/Engine.H"} {} 

  59. 

  60. decl {\#include "Engine/Audio_File.H" // for supported formats} {} 

  61. 

  62. decl {class About_Dialog;} {} 

  63. 

  64. decl {extern char project_display_name[256];} {global

  65. } 

  66. 

  67. decl {extern char *user_config_dir;} {global

  68. } 

  69. 

  70. class TLE {open

  71. } {

  72.   decl {Fl_Color system_colors[3];} {}

  73.   Function {save()} {open

  74.   } {

  75.     code {const char options_filename[] = "options";

  76. // const char state_filename[] = "state";

  77. 

  78. // save options

  79. 

  80. char *path;

  81. asprintf( &path, "%s/%s", user_config_dir, options_filename );

  82. ((Fl_Menu_Settings*)menubar)->dump( menubar->find_item( "&Options" ), path );

  83. free( path );} {}

  84.   }

  85.   Function {quit()} {} {

  86.     code {Project::close();

  87. 

  88. save();

  89. 

  90. while ( Fl::first_window() ) Fl::first_window()->hide();} {}

  91.   }

  92.   Function {open( const char *name )} {} {

  93.     code {if ( ! name )

  94. 	return;

  95. 

  96. int r =	Project::open( name );

  97. 

  98. if ( r < 0 )

  99. {

  100. 	const char *s = Project::errstr( r );

  101. 	

  102. 	fl_alert( "Could not open project \\"%s\\":\\n\\n\\t%s", name, s );

  103. }} {}

  104.   }

  105.   Function {save_timeline_settings()} {open

  106.   } {

  107.     code {if ( ! Project::open() )

  108. 	return;

  109. 	

  110. 

  111. // save project local options (Timeline menu)

  112. ((Fl_Menu_Settings*)menubar)->dump( menubar->find_item( "&Project/Se&ttings" ), "options" );} {}

  113.   }

  114.   Function {reset_timeline_settings( void )} {open private return_type void

  115.   } {

  116.     code {char path[256];

  117. snprintf( path, sizeof( path ), "%s/%s", user_config_dir, ".default_project_settings" );

  118. 

  119. ((Fl_Menu_Settings*)menubar)->load( menubar->find_item( "&Project/Se&ttings" ), path );} {}

  120.   }

  121.   Function {load_timeline_settings()} {open

  122.   } {

  123.     code {reset_timeline_settings();

  124. 

  125. 

  126. if ( Project::open() )

  127. 	((Fl_Menu_Settings*)menubar)->load( menubar->find_item( "&Project/Se&ttings" ), "options" );

  128. 

  129. update_menu();

  130. 

  131. project_name->redraw();} {}

  132.   }

  133.   Function {run()} {} {

  134.     code {update_menu();

  135. 

  136. main_window->show();

  137. 

  138. Fl::lock();

  139. 

  140. // Fl::run();} {}

  141.   }

  142.   Function {TLE()} {open

  143.   } {

  144.     code {Fl::visual( FL_DOUBLE | FL_RGB8 );

  145. 

  146. make_window();

  147. 	

  148. Fl::visible_focus( 0 );

  149. 

  150. Fl::get_system_colors();

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

  152. 

  153. system_colors[ 0 ] = (Fl_Color)Fl::get_color( FL_BACKGROUND_COLOR );

  154. system_colors[ 1 ] = (Fl_Color)Fl::get_color( FL_FOREGROUND_COLOR  );

  155. system_colors[ 2 ] = (Fl_Color)Fl::get_color( FL_BACKGROUND2_COLOR  );

  156. 

  157. set_theme_dark();

  158. 

  159. // constrain window to size of screen.

  160. {

  161.         int sx, sy, sw, sh;

  162. 

  163.         Fl::screen_xywh( sx, sy, sw, sh );

  164. 

  165.         main_window->size( 947, 600 );

  166.         main_window->size_range( 947, 600 );

  167. 

  168.         if ( main_window->w() > sw ||

  169.              main_window->h() > sh )

  170.                 main_window->resize( sx, sy, sw, sh );

  171. }

  172. 

  173. Fl::add_timeout( STATUS_UPDATE_FREQ, update_cb, this );

  174. 

  175. fl_message_icon()->box( FL_RSHADOW_BOX );

  176. fl_message_icon()->labelcolor( FL_BLACK );

  177. fl_message_icon()->color( FL_RED );

  178. fl_message_font( FL_HELVETICA, 18 );

  179. 

  180. 

  181. std::list <const char *> formats;

  182. 

  183. Audio_File::all_supported_formats( formats );

  184. 

  185. for ( std::list <const char *>::const_iterator f = formats.begin(); f != formats.end(); ++f )

  186. {

  187. //	capture_format_menu->add( *f, FL_MENU_RADIO, 0, 0, 0 );

  188. //;

  189. 	char pat[256];

  190. 	snprintf( pat, sizeof( pat ), "&Project/Se&ttings/Capture Format/%s", *f );	

  191. 

  192. 	menubar->add( pat, 0, &TLE::capture_format_cb, this, FL_MENU_RADIO );

  193. }

  194. 

  195. menubar->picked( menubar->find_item( "&Project/Se&ttings/Capture Format/Wav 24" ) );

  196. 

  197. char *path;

  198. asprintf( &path, "%s/options", user_config_dir );

  199. ((Fl_Menu_Settings*)menubar)->load( menubar->find_item( "&Options" ), path );

  200. free( path );

  201. 

  202. 

  203. menubar->add( "&Timeline", 0, 0, const_cast< Fl_Menu_Item *>( timeline->menu->menu() ), FL_SUBMENU_POINTER );

  204. 

  205. 

  206. // save a copy of the project settings menu so that we can restore the defaults later

  207. {

  208. 	char path[512];

  209. 	snprintf( path, sizeof( path ), "%s/%s", user_config_dir, ".default_project_settings" );

  210. 

  211. 	((Fl_Menu_Settings*)menubar)->dump( menubar->find_item( "&Project/Se&ttings" ), path );

  212. }

  213. 

  214. 

  215. Loggable::progress_callback( &TLE::progress_cb, this );} {}

  216.   }

  217.   Function {make_window()} {open

  218.   } {

  219.     Fl_Window main_window {

  220.       label Timeline

  221.       callback {if ( Fl::event_key() != FL_Escape )

  222. 	o->hide();} open

  223.       private xywh {701 103 1025 770} type Double resizable xclass Non_DAW visible

  224.     } {

  225.       Fl_Menu_Bar menubar {open

  226.         private xywh {0 0 1024 25}

  227.       } {

  228.         Submenu {} {

  229.           label {&Project} open

  230.           xywh {0 0 74 25}

  231.         } {

  232.           MenuItem {} {

  233.             label {&Info}

  234.             callback {Project_Info_Dialog pi;

  235. 

  236. pi.run();}

  237.             xywh {0 0 40 25} deactivate

  238.           }

  239.           Submenu {} {

  240.             label {Se&ttings} open

  241.             xywh {20 20 74 25}

  242.           } {

  243.             MenuItem {} {

  244.               label {&Follow Playhead}

  245.               callback {Timeline::follow_playhead = menu_picked_value( o );}

  246.               xywh {40 40 40 25} type Toggle value 1

  247.             }

  248.             MenuItem {} {

  249.               label {&Center Playhead}

  250.               callback {Timeline::center_playhead = menu_picked_value( o );}

  251.               xywh {50 50 40 25} type Toggle value 1

  252.             }

  253.             Submenu {} {

  254.               label {&Snap to} open

  255.               xywh {20 20 74 25}

  256.             } {

  257.               MenuItem {} {

  258.                 label Bars

  259.                 callback {Timeline::snap_to = Timeline::Bars;}

  260.                 xywh {20 20 40 25} type Radio value 1

  261.               }

  262.               MenuItem {} {

  263.                 label Beats

  264.                 callback {Timeline::snap_to = Timeline::Beats;}

  265.                 xywh {30 30 40 25} type Radio

  266.               }

  267.               MenuItem {} {

  268.                 label Off

  269.                 callback {Timeline::snap_to = Timeline::None;}

  270.                 xywh {40 40 40 25} type Radio

  271.               }

  272.             }

  273.             MenuItem {} {

  274.               label {Magnetic snap}

  275.               callback {Timeline::snap_magnetic = menu_picked_value( o );}

  276.               xywh {30 30 40 25} type Toggle value 1

  277.             }

  278.             Submenu {} {

  279.               label {Capture Format} open

  280.               xywh {20 20 74 25}

  281.             } {}

  282.           }

  283.           MenuItem {} {

  284.             label {&New}

  285.             callback {save_timeline_settings();

  286. 

  287. const char *templates[] = { "Default", NULL };

  288. 

  289. char *default_path;

  290. char *selected_template;

  291. 

  292. read_line( user_config_dir, "default_path", &default_path );

  293. 

  294. char *path = new_project_chooser( templates, &default_path, &selected_template );

  295. 

  296. if ( ! Project::create( path, selected_template ) )

  297. 	fl_alert( "Error creating project!" );

  298. 

  299. free( path );

  300. free( selected_template );

  301. free( default_path );

  302. 

  303. 

  304. write_line( user_config_dir, "default_path", default_path );

  305. 

  306. load_timeline_settings();

  307. 

  308. update_menu();

  309. 

  310. main_window->redraw();}

  311.             xywh {0 0 40 25}

  312.           }

  313.           MenuItem {} {

  314.             label {&Open}

  315.             callback {char *path;

  316. 

  317. read_line( user_config_dir, "default_path", &path );

  318. 

  319. const char *name = fl_dir_chooser( "Open Project", path, NULL );

  320. 

  321. free( path );

  322. 

  323. open( name );}

  324.             xywh {10 10 40 25}

  325.           }

  326.           MenuItem {} {

  327.             label {&Compact}

  328.             callback {int n = fl_choice( "Compacting will replace the project history with a snapshot of the current state.\\nYou will not be able to use Undo to go back beyond this point.\\n\\nThis operation is irreversible!", NULL, "&Cancel", "Pr&ocede with compaction" );

  329. 

  330. if ( n != 2 )

  331. 	return;

  332. 	

  333. Project::compact();}

  334.             xywh {20 20 40 25}

  335.           }

  336.           Submenu {} {

  337.             label {&Export} open

  338.             xywh {0 0 74 25} deactivate

  339.           } {

  340.             MenuItem {} {

  341.               label Project

  342.               xywh {0 0 40 25}

  343.             }

  344.             MenuItem {} {

  345.               label Range

  346.               xywh {10 10 40 25}

  347.             }

  348.           }

  349.           MenuItem {} {

  350.             label {&Quit}

  351.             callback {quit()}

  352.             xywh {40 40 40 25} shortcut 0x40071

  353.           }

  354.         }

  355.         Submenu {} {

  356.           label {&Edit} open

  357.           xywh {0 0 74 25}

  358.         } {

  359.           MenuItem {} {

  360.             label Undo

  361.             callback {Loggable::undo();}

  362.             xywh {0 0 40 25} shortcut 0x4007a divider

  363.           }

  364.           MenuItem {} {

  365.             label {Select None}

  366.             callback {timeline->select_none();}

  367.             xywh {10 10 40 25} shortcut 0x50061

  368.           }

  369.           MenuItem {} {

  370.             label {Delete  Selected}

  371.             callback {timeline->delete_selected();}

  372.             xywh {20 20 40 25} shortcut 0xffff

  373.           }

  374.         }

  375.         Submenu {} {

  376.           label T&ransport open

  377.           xywh {0 0 74 25}

  378.         } {

  379.           MenuItem {} {

  380.             label Start

  381.             callback {transport->locate( 0 );}

  382.             xywh {0 0 40 25} shortcut 0xff50

  383.           }

  384.           MenuItem {} {

  385.             label End

  386.             callback {transport->locate( timeline->length() );}

  387.             xywh {10 10 40 25} shortcut 0xff57

  388.           }

  389.           MenuItem {} {

  390.             label {Play/Stop}

  391.             callback {transport->toggle();}

  392.             xywh {20 20 40 25} shortcut 0x20

  393.           }

  394.           MenuItem {} {

  395.             label Record

  396.             callback {transport->toggle_record();}

  397.             xywh {40 40 40 25} shortcut 0x10072

  398.           }

  399.         }

  400.         MenuItem {} {

  401.           label {&Timeline}

  402.           xywh {0 0 40 25}

  403.         }

  404.         Submenu {} {

  405.           label {&View} open

  406.           xywh {0 0 74 25}

  407.         } {

  408.           Submenu {} {

  409.             label {&Zoom} open

  410.             xywh {0 0 74 25}

  411.           } {

  412.             MenuItem {} {

  413.               label {&In}

  414.               callback {timeline->zoom_in();}

  415.               xywh {20 20 40 25} shortcut 0x2b

  416.             }

  417.             MenuItem {} {

  418.               label {&Out}

  419.               callback {timeline->zoom_out();}

  420.               xywh {30 30 40 25} shortcut 0x5f

  421.             }

  422.             MenuItem {} {

  423.               label {&Fit}

  424.               callback {timeline->zoom_fit();}

  425.               xywh {10 10 40 25} shortcut 0x3d divider

  426.             }

  427.             MenuItem {} {

  428.               label {1 sec.}

  429.               callback {timeline->zoom( 1 );}

  430.               xywh {10 10 40 25} shortcut 0x31

  431.             }

  432.             MenuItem {} {

  433.               label {1 min.}

  434.               callback {timeline->zoom( 60 );}

  435.               xywh {20 20 40 25} shortcut 0x32

  436.             }

  437.             MenuItem {} {

  438.               label {1 hour.}

  439.               callback {timeline->zoom( 60 * 60 );}

  440.               xywh {30 30 40 25} shortcut 0x33

  441.             }

  442.           }

  443.         }

  444.         Submenu {} {

  445.           label {&Options} open

  446.           xywh {0 0 74 25} divider

  447.         } {

  448.           Submenu {} {

  449.             label {&Display} open

  450.             xywh {10 10 74 25}

  451.           } {

  452.             Submenu {} {

  453.               label {&Timeline} open

  454.               xywh {10 10 74 25}

  455.             } {

  456.               MenuItem {} {

  457.                 label {&Measure lines}

  458.                 callback {Timeline::draw_with_measure_lines = menu_picked_value( o );

  459. 

  460. timeline->redraw();}

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

  462.               }

  463.             }

  464.             Submenu {} {

  465.               label {&Waveform} open

  466.               xywh {10 10 74 25}

  467.             } {

  468.               MenuItem {} {

  469.                 label Fill

  470.                 callback {Waveform::fill = menu_picked_value( o );

  471. 

  472. timeline->redraw();}

  473.                 xywh {20 20 40 25} type Toggle value 1

  474.               }

  475.               MenuItem {} {

  476.                 label Outline

  477.                 callback {Waveform::outline = menu_picked_value( o );

  478. 

  479. timeline->redraw();}

  480.                 xywh {40 40 40 25} type Toggle value 1

  481.               }

  482.               MenuItem {} {

  483.                 label {Vary color}

  484.                 callback {Waveform::vary_color = menu_picked_value( o );

  485. 

  486. timeline->redraw();}

  487.                 xywh {30 30 40 25} type Toggle value 1

  488.               }

  489.             }

  490.             Submenu {} {

  491.               label {&Region} open

  492.               xywh {10 10 74 25}

  493.             } {

  494.               MenuItem {} {

  495.                 label {Filled fades}

  496.                 xywh {40 40 40 25} type Toggle value 1

  497.               }

  498.               MenuItem {} {

  499.                 label {Inherit track color}

  500.                 callback {Audio_Region::inherit_track_color = menu_picked_value( o );

  501. 

  502. timeline->redraw();}

  503.                 xywh {50 50 40 25} type Toggle value 1

  504.               }

  505.             }

  506.             Submenu {} {

  507.               label {&Control Sequence} open

  508.               xywh {10 10 74 25}

  509.             } {

  510.               MenuItem {} {

  511.                 label Polygon

  512.                 callback {Control_Sequence::draw_with_polygon = menu_picked_value( o );

  513. 

  514. timeline->redraw();}

  515.                 xywh {30 30 40 25} type Toggle value 1

  516.               }

  517.               MenuItem {} {

  518.                 label Graded

  519.                 callback {Control_Sequence::draw_with_gradient = menu_picked_value( o );

  520. 

  521. timeline->redraw();}

  522.                 xywh {40 40 40 25} type Toggle value 1

  523.               }

  524.               MenuItem {} {

  525.                 label Ruled

  526.                 callback {Control_Sequence::draw_with_grid = menu_picked_value( o );

  527. 

  528. timeline->redraw();}

  529.                 xywh {50 50 40 25} type Toggle value 1

  530.               }

  531.             }

  532.             Submenu {} {

  533.               label {&Style} open

  534.               xywh {10 10 74 25}

  535.             } {

  536.               MenuItem {} {

  537.                 label Default

  538.                 callback {Fl::scheme( "plastic" );}

  539.                 xywh {10 10 40 25} type Radio value 1

  540.               }

  541.               MenuItem {} {

  542.                 label Flat

  543.                 callback {Fl::scheme( "gtk+" );}

  544.                 xywh {20 20 40 25} type Radio

  545.               }

  546.             }

  547.             Submenu {} {

  548.               label {C&olors} open

  549.               xywh {10 10 74 25}

  550.             } {

  551.               MenuItem {} {

  552.                 label System

  553.                 callback {//Fl::get_system_colors();

  554. 

  555. unsigned char r, g, b;

  556. 

  557. Fl::get_color( system_colors[ 0 ], r, g, b );

  558. 

  559. Fl::background( r, g, b );

  560. 

  561. Fl::get_color( system_colors[ 1 ], r, g, b );

  562. 

  563. Fl::foreground( r, g, b );

  564. 

  565. Fl::get_color( system_colors[ 2 ], r, g, b );

  566. 

  567. Fl::background2( r, g, b );

  568. 

  569. Fl::scheme( Fl::scheme() );}

  570.                 xywh {10 10 40 25} type Radio

  571.               }

  572.               MenuItem {} {

  573.                 label Dark

  574.                 callback {

  575. 

  576.                 set_theme_dark(); }

  577.                 xywh {20 20 40 25} type Radio value 1

  578.               }

  579.               MenuItem {} {

  580.                 label Light

  581.                 callback {Fl::background2( 192, 192, 192 );

  582. Fl::background( 220, 220, 220 );

  583. Fl::foreground( 0, 0, 0 );

  584. 

  585. Fl::scheme( Fl::scheme() );}

  586.                 xywh {30 30 40 25} type Radio

  587.               }

  588.             }

  589.           }

  590.           Submenu {} {

  591.             label {&Behavior} open

  592.             xywh {0 0 74 25}

  593.           } {

  594.             Submenu {} {

  595.               label {&Transport} open

  596.               xywh {0 0 74 25}

  597.             } {

  598.               MenuItem {} {

  599.                 label {Stop Disables Record}

  600.                 callback {transport->stop_disables_record( ((Fl_Menu_*)o)->mvalue()->flags & FL_MENU_VALUE );} selected

  601.                 xywh {5 5 40 25} type Toggle value 1

  602.               }

  603.             }

  604.           }

  605.         }

  606.         Submenu {} {

  607.           label {&Help} open

  608.           xywh {0 0 74 25}

  609.         } {

  610.           MenuItem {} {

  611.             label {&Manual}

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

  613.             xywh {10 10 40 25} divider

  614.           }

  615.           MenuItem {} {

  616.             label {&About}

  617.             callback {About_Dialog ab;

  618. 

  619. ab.run();}

  620.             xywh {0 0 40 25}

  621.           }

  622.         }

  623.       }

  624.       Fl_Group {} {open

  625.         xywh {0 1 1025 73}

  626.       } {

  627.         Fl_Pack {} {open

  628.           xywh {0 23 483 46} type HORIZONTAL

  629.           code0 {o->spacing( 10 );}

  630.         } {

  631.           Fl_Box {} {

  632.             label {<Transport>}

  633.             xywh {5 23 189 46} color 30

  634.             code0 {transport = o;}

  635.             code1 {o->labeltype( FL_NO_LABEL );}

  636.             class Transport

  637.           }

  638.           Fl_Pack clocks_pack {

  639.             private xywh {195 23 288 46} type HORIZONTAL

  640.             code0 {o->spacing( 2 );}

  641.           } {

  642.             Fl_Box {} {

  643.               label PLAYHEAD

  644.               private xywh {195 29 137 40} box BORDER_BOX color 40

  645.               code0 {o->type( Clock::HMS );}

  646.               code1 {o->run( &transport->frame );}

  647.               class Clock

  648.             }

  649.             Fl_Box {} {

  650.               label PLAYHEAD

  651.               xywh {335 29 142 40} box BORDER_BOX color 40

  652.               code0 {o->type( Clock::BBT );}

  653.               code1 {o->run( &transport->frame );}

  654.               class Clock

  655.             }

  656.           }

  657.         }

  658.         Fl_Box {} {

  659.           label {<empty>}

  660.           xywh {487 27 203 42} resizable

  661.           code0 {o->labeltype( FL_NO_LABEL );}

  662.         }

  663.         Fl_Group {} {open

  664.           xywh {745 26 280 44}

  665.         } {

  666.           Fl_Box {} {

  667.             label {capture:}

  668.             xywh {865 26 56 14} labelsize 10 align 24

  669.           }

  670.           Fl_Box {} {

  671.             label {playback:}

  672.             xywh {865 42 56 14} labelsize 10 align 24

  673.           }

  674.           Fl_Box {} {

  675.             label {DSP:}

  676.             xywh {865 56 56 14} labelsize 10 align 24

  677.           }

  678.           Fl_Progress capture_buffer_progress {

  679.             label {50%}

  680.             private xywh {921 26 104 14} labelsize 10

  681.           }

  682.           Fl_Progress cpu_load_progress {

  683.             label {50%}

  684.             private xywh {921 56 104 14} labelsize 9

  685.           }

  686.           Fl_Progress playback_buffer_progress {

  687.             label {50%}

  688.             private xywh {921 41 104 14} labelsize 10

  689.           }

  690.           Fl_Box {} {

  691.             label {disk:}

  692.             xywh {810 27 55 18} labelsize 10 align 16

  693.           }

  694.           Fl_Progress disk_usage_progress {

  695.             label {50%}

  696.             private xywh {810 43 55 26} labelsize 10

  697.           }

  698.         }

  699.         Fl_Button solo_blinker {

  700.           label SOLO

  701.           xywh {750 30 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 74 selection_color 92 labelfont 2 labelcolor 39 deactivate

  702.           code0 {\#include "FL/Fl_Blinker.H"}

  703.           class Fl_Blinker

  704.         }

  705.         Fl_Button rec_blinker {

  706.           label REC

  707.           xywh {750 50 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 72 selection_color 88 labelfont 2 labelcolor 39 deactivate

  708.           code0 {\#include "FL/Fl_Blinker.H"}

  709.           class Fl_Blinker

  710.         }

  711.         Fl_Button sm_blinker {

  712.           label SM

  713.           xywh {695 30 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 75 selection_color 86 labelfont 2 labelcolor 39 deactivate

  714.           code0 {\#include "FL/Fl_Blinker.H"}

  715.           class Fl_Blinker

  716.         }

  717.         Fl_Button selected_blinker {

  718.           label SEL

  719.           xywh {695 50 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 13 selection_color 5 labelfont 2 labelcolor 39 deactivate

  720.           code0 {\#include "FL/Fl_Blinker.H"}

  721.           class Fl_Blinker

  722.         }

  723.         Fl_Box stats_box {

  724.           label {<stats>}

  725.           xywh {810 1 215 21} labelsize 13 labelcolor 53 align 88

  726.         }

  727.       }

  728.       Fl_Progress progress {

  729.         label {0%}

  730.         private xywh {15 394 995 41} hide

  731.       }

  732.       Fl_Box {} {

  733.         label {<Timeline>}

  734.         xywh {0 72 1024 695} box FLAT_BOX color 47 labelsize 100 resizable

  735.         code0 {timeline = o;}

  736.         class Timeline

  737.       }

  738.       Fl_Box project_name {

  739.         label {<project name>}

  740.         private xywh {450 0 365 22} labeltype SHADOW_LABEL labelfont 2

  741.         code0 {o->label( Project::name() );}

  742.       }

  743.     }

  744.   }

  745.   Function {menu_picked_value( const Fl_Menu_ *m )} {private return_type {static int}

  746.   } {

  747.     code {return m->menu()[ m->value() ].flags & FL_MENU_VALUE;} {}

  748.   }

  749.   Function {find_item( Fl_Menu_ *menu, const char *path )} {private return_type {static Fl_Menu_Item *}

  750.   } {

  751.     code {return const_cast<Fl_Menu_Item*>(menu->find_item( path ));} {}

  752.   }

  753.   decl {static void menubar_cb ( void *v )} {}

  754.   decl {void menubar_cb ( void )} {}

  755.   Function {update_menu()} {private

  756.   } {

  757.     code {Fl_Menu_Bar *m = menubar;

  758. 

  759. if ( ! Project::open() )

  760. {

  761. 	find_item( m, "&Project/&Export" )->deactivate();

  762. 	find_item( m, "&Project/&Compact" )->deactivate();

  763. 	find_item( m, "&Project/&Info" )->deactivate();

  764. 	

  765.  	find_item( m, "&Project/Se&ttings" )->deactivate();

  766.  	find_item( m, "&Timeline" )->deactivate();

  767. 

  768. 	timeline->deactivate();

  769. 	transport->deactivate();

  770. }

  771. else

  772. {

  773. 	find_item( m, "&Project/&Export" )->activate();

  774. 	find_item( m, "&Project/&Compact" )->activate();

  775. 	find_item( m, "&Project/&Info" )->activate();

  776. 

  777.  	find_item( m, "&Project/Se&ttings" )->activate();

  778.  	find_item( m, "&Timeline" )->activate();

  779. 	

  780. 	timeline->activate();

  781. 	transport->activate();	

  782. }

  783. 

  784. m->redraw();

  785. project_name->redraw();} {}

  786.   }

  787.   Function {update_progress( Fl_Progress *p, char *s, float v )} {private return_type {static void}

  788.   } {

  789.     code {p->value( v );

  790. 

  791. snprintf( s, 5, "%d%%", (int)v );

  792. 

  793. p->label( s );} {}

  794.   }

  795.   Function {update_status()} {open private

  796.   } {

  797.     code {static char cbp[5], pbp[5], clp[5], dup[5];

  798. 

  799. update_progress( capture_buffer_progress, cbp, timeline->total_input_buffer_percent() );

  800. update_progress( playback_buffer_progress, pbp, timeline->total_output_buffer_percent() );

  801. update_progress( cpu_load_progress, clp, engine->cpu_load() );

  802. 

  803. update_progress( disk_usage_progress, dup, percent_used( "." ) );

  804. 

  805. if ( timeline->total_capture_xruns() )

  806. 	capture_buffer_progress->selection_color( FL_RED );

  807. 

  808. if ( timeline->total_playback_xruns() )

  809. 	playback_buffer_progress->selection_color( FL_RED );

  810. 

  811. static char stats[100];

  812. 

  813. snprintf( stats, sizeof( stats ), "latency: %.1fms, xruns: %d",

  814. 	engine->frames_to_milliseconds( timeline->total_output_latency() ),

  815. 	engine->xruns() );

  816. 

  817. stats_box->label( stats );

  818. 

  819. static bool zombie = false;

  820. 

  821. if ( engine->zombified() && ! zombie )

  822. {

  823. 	zombie = true;

  824. 	fl_alert( "Disconnected from JACK!" );

  825. }

  826. 

  827. solo_blinker->value( Track::soloing() );

  828. rec_blinker->value( transport->rolling && transport->rec_enabled() );

  829. sm_blinker->value( timeline->session_manager_name() != NULL );

  830. sm_blinker->tooltip( timeline->session_manager_name() );

  831. selected_blinker->value( timeline->nselected() );} {selected

  832.     }

  833.   }

  834.   Function {update_cb( void *v )} {open private return_type {static void}

  835.   } {

  836.     code {Fl::repeat_timeout( STATUS_UPDATE_FREQ, update_cb, v );

  837. 

  838. ((TLE*)v)->update_status();} {}

  839.   }

  840.   Function {capture_format_cb( Fl_Widget *w, void *v )} {private return_type {static void}

  841.   } {

  842.     code {((TLE*)v)->capture_format_cb();} {}

  843.   }

  844.   Function {capture_format_cb()} {private return_type void

  845.   } {

  846.     code {Fl_Menu_ *o = menubar;

  847. 

  848. Track::capture_format = o->menu()[ o->value() ].label();} {}

  849.   }

  850.   Function {progress_cb( int p, void *arg )} {private return_type {static void}

  851.   } {

  852.     code {((TLE*)arg)->progress_cb( p );} {}

  853.   }

  854.   Function {progress_cb( int p )} {private return_type void

  855.   } {

  856.     code {if ( ! progress->visible() )

  857. {

  858. 	timeline->hide();

  859. 	progress->show();

  860. }

  861. else if ( 0 == p )

  862. {

  863. 	timeline->show();

  864. 	progress->hide();

  865. }

  866. 

  867. static char pat[10];

  868. 

  869. update_progress( progress, pat, p );

  870. 

  871. progress->redraw();

  872. 

  873. Fl::check();} {}

  874.   }

  875.   Function {show_help_dialog( const char *file )} {open private return_type {static void}

  876.   } {

  877.     code {char pat[256];

  878. 

  879. snprintf( pat, 256, "file://%s%s.html", DOCUMENT_PATH, file );

  880. 

  881. open_url( pat );} {}

  882.   }

  883. } 

  884. 

  885. 

  886. 

  887. Function {set_theme_dark()} {C return_type void

  888. } {

  889.         code { Fl::background2( 100, 100, 100 );

  890.         Fl::background( 50, 50, 50 );

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

  892. 

  893.         Fl::scheme( Fl::scheme() ); } {}

  894. }

  895. 

  896. class Project_Info_Dialog {open

  897. } {

  898.   Function {Project_Info_Dialog()} {open

  899.   } {

  900.     code {make_window();} {}

  901.   }

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

  903.   } {

  904.     code {window->show();

  905. 

  906. while ( window->shown() )

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

  908.   }

  909.   Function {make_window()} {open

  910.   } {

  911.     Fl_Window window {

  912.       label {Project info}

  913.       callback {o->hide();

  914. 

  915. if ( logo_box->image() )

  916. {

  917. 	((Fl_Shared_Image*)logo_box->image())->release();

  918. 	logo_box->image( NULL );

  919. }} open

  920.       private xywh {653 248 520 740} type Double modal visible

  921.     } {

  922.       Fl_Value_Output {} {

  923.         label {Sample Rate}

  924.         xywh {40 80 90 25} labeltype SHADOW_LABEL align 1

  925.         code0 {o->value( timeline->sample_rate() );}

  926.       }

  927.       Fl_Output {} {

  928.         label {Size of Journal}

  929.         xywh {180 80 100 25} box UP_BOX labeltype SHADOW_LABEL align 1

  930.         code0 {static char pat[40];}

  931.         code1 {snprintf( pat, sizeof( pat ), "%.1fK", size( "history" ) / (float)1024 );}

  932.         code2 {o->value( pat );}

  933.         code3 {\#include "util/file.h"}

  934.       }

  935.       Fl_Output {} {

  936.         label {Created On}

  937.         xywh {320 80 180 25} box UP_BOX labeltype SHADOW_LABEL align 1 textfont 11 textsize 12

  938.         code0 {o->value( Project::created_on() );}

  939.       }

  940.       Fl_Output {} {

  941.         label Length

  942.         xywh {30 130 115 25} box BORDER_BOX color 47 align 1 textcolor 71

  943.         code0 {char pat[40];}

  944.         code1 {Clock::frame_to_HMS( pat, sizeof( pat ), timeline->length() );}

  945.         code2 {o->value( pat );}

  946.       }

  947.       Fl_Value_Output {} {

  948.         label Tracks

  949.         xywh {200 130 55 25} align 1

  950.         code0 {o->value( timeline->ntracks() );}

  951.       }

  952.       Fl_Box logo_box {

  953.         label {<LOGO>}

  954.         private xywh {51 180 418 235} box ROUNDED_BOX color 53 labelfont 1 labelsize 18 align 16

  955.         code0 {o->image( Fl_Shared_Image::get( INSTALL_PREFIX "/share/pixmaps/non-daw/logo2.png" ) );}

  956.         code1 {o->label( NULL );}

  957.       }

  958.       Fl_Text_Editor notes_field {

  959.         label {Notes:}

  960.         private xywh {20 445 480 245} color 47 selection_color 31 textsize 18 textcolor 92

  961.         code0 {o->buffer( new Fl_Text_Buffer() );}

  962.         code1 {o->buffer()->loadfile( "notes" );}

  963.       }

  964.       Fl_Button {} {

  965.         label {&Save}

  966.         callback {notes_field->buffer()->savefile( "notes" );

  967. 

  968. window->do_callback();}

  969.         xywh {425 700 74 25}

  970.       }

  971.       Fl_Box {} {

  972.         label {Project Info}

  973.         xywh {40 18 405 27} box RSHADOW_BOX color 95 labeltype SHADOW_LABEL labelsize 18

  974.       }

  975.       Fl_Box {} {

  976.         label {Project Info}

  977.         xywh {25 18 470 33} box RSHADOW_BOX color 133 labelsize 20 labelcolor 32

  978.       }

  979.       Fl_Button {} {

  980.         label {&Discard}

  981.         callback {window->do_callback();}

  982.         xywh {330 700 74 25}

  983.       }

  984.       Fl_Output {} {

  985.         label {Last Modified On}

  986.         xywh {320 130 180 25} box UP_BOX labeltype SHADOW_LABEL align 1 textfont 11 textsize 12

  987.         code0 {time_t t = modification_time( "history" );}

  988.         code1 {static char s[40];}

  989.         code2 {ctime_r( &t, s ); s[ strlen( s ) - 1 ] = 0;}

  990.         code3 {o->value( s );}

  991.       }

  992.     }

  993.   }

  994. } 

  995. 

  996. class About_Dialog {} {

  997.   Function {About_Dialog()} {} {

  998.     code {make_window();} {}

  999.   }

  1000.   Function {run()} {return_type void

  1001.   } {

  1002.     code {window->show();

  1003. 

  1004. while ( window->shown() )

  1005. 	Fl::wait();

  1006. 	

  1007. delete window;} {}

  1008.   }

  1009.   Function {make_window()} {open private

  1010.   } {

  1011.     Fl_Window window {

  1012.       label About

  1013.       callback {o->hide();

  1014. 

  1015. if ( logo_box->image() )

  1016. {

  1017. 	((Fl_Shared_Image*)logo_box->image())->release();

  1018. 	logo_box->image( NULL );

  1019. }} open

  1020.       private xywh {1344 87 495 655} type Double xclass {Non-DAW} visible

  1021.     } {

  1022.       Fl_Tabs {} {open

  1023.         xywh {0 264 497 392}

  1024.       } {

  1025.         Fl_Group {} {

  1026.           label Credits open

  1027.           xywh {2 293 492 362}

  1028.         } {

  1029.           Fl_Box {} {

  1030.             label {Non-DAW was written from scratch by

  1031.  Jonathan Moore Liles for his own use

  1032.  (see the manual).

  1033. 

  1034. Nobody planned. Nobody helped.

  1035.  You can help now by donating time, money,

  1036. and/or replacing the rest of Linux Audio

  1037. with fast, light, reliable alternatives.}

  1038.             xywh {39 322 418 262} box ROUNDED_BOX color 46 labelsize 18

  1039.           }

  1040.         }

  1041.         Fl_Group {} {

  1042.           label License open

  1043.           xywh {2 288 492 311} hide

  1044.         } {

  1045.           Fl_Box {} {

  1046.             label {Copyright (C) 2008-2010 Jonathan Moore Liles}

  1047.             xywh {43 302 410 37} labeltype SHADOW_LABEL labelfont 1 labelsize 18

  1048.           }

  1049.           Fl_Box {} {

  1050.             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.

  1051. 

  1052. 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.

  1053. 

  1054. 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.}

  1055.             xywh {10 351 475 233} box ROUNDED_BOX color 46 labelfont 1 labelsize 12 labelcolor 53 align 144

  1056.           }

  1057.         }

  1058.       }

  1059.       Fl_Box logo_box {

  1060.         label VERSION

  1061.         private xywh {25 20 445 180} box ROUNDED_BOX color 48 labelfont 1 labelsize 18 align 16

  1062.         code0 {o->image( Fl_Shared_Image::get( INSTALL_PREFIX "/share/pixmaps/non-daw/logo.png" ) );}

  1063.         code1 {o->label( VERSION );}

  1064.       }

  1065.       Fl_Return_Button {} {

  1066.         label Rock

  1067.         callback {o->window()->do_callback();}

  1068.         xywh {400 614 76 30}

  1069.       }

  1070.       Fl_Button {} {

  1071.         label {http://non-daw.tuxfamily.org}

  1072.         callback {open_url( o->label() );}

  1073.         xywh {125 614 245 30} color 14 labeltype SHADOW_LABEL labelcolor 6

  1074.       }

  1075.       Fl_Box {} {

  1076.         label {The Non DAW (Digital Audio Workstation)}

  1077.         xywh {32 221 430 29} labeltype SHADOW_LABEL labelfont 3 labelsize 17

  1078.       }

  1079.     }

  1080.   }

  1081. } 

  1082. 

  1083. Function {open_url( const char *url )} {open return_type void

  1084. } {

  1085.   code {\#if ! ( FL_MAJOR_VERSION >= 1 && FL_MINOR_VERSION >= 1 && FL_PATCH_VERSION >= 8 )

  1086. 	

  1087. 	// FIXME: got a better idea?

  1088. 	char cmd[256];

  1089. 	snprintf( cmd, sizeof( cmd ), "x-www-browser '%s' &", url );

  1090. 	system( cmd );

  1091. \#else

  1092. 	fl_open_uri( url );

  1093. \#endif} {}

  1094. }