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.
1013 Commits
1 Branch
2.1GB
Tree: 63c4296d7b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '63c4296d7b'
${ noResults }
new-session-manager/timeline/src/TLE.fl

1006 lines
29KB
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.1f;} {}

  26. 

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

  28. 

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

  30. 

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

  32. 

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

  34. 

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

  36. 

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

  38. 

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

  40. } 

  41. 

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

  43. 

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

  45. 

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

  47. 

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

  49. 

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

  51. 

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

  53. 

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

  55. 

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

  57. } 

  58. 

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

  60. 

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

  62. 

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

  64. 

  65. decl {\#include "FL/About_Dialog.H"} {} 

  66. 

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

  68. } 

  69. 

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

  71. } 

  72. 

  73. class TLE {open

  74. } {

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

  76.   Function {save()} {open

  77.   } {

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

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

  80. 

  81. // save options

  82. 

  83. char *path;

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

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

  86. free( path );} {}

  87.   }

  88.   Function {quit()} {} {

  89.     code {Project::close();

  90. 

  91. save();

  92. 

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

  94.   }

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

  96.     code {if ( ! name )

  97. 	return;

  98. 

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

  100. 

  101. if ( r < 0 )

  102. {

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

  104. 	

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

  106. }} {}

  107.   }

  108.   Function {save_timeline_settings()} {open

  109.   } {

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

  111. 	return;

  112. 	

  113. 

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

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

  116.   }

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

  118.   } {

  119.     code {char path[256];

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

  121. 

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

  123.   }

  124.   Function {load_timeline_settings()} {open

  125.   } {

  126.     code {reset_timeline_settings();

  127. 

  128. 

  129. if ( Project::open() )

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

  131. 

  132. update_menu();

  133. 

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

  135.   }

  136.   Function {run()} {} {

  137.     code {update_menu();

  138. 

  139. main_window->show();

  140. 

  141. Fl::lock();

  142. 

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

  144.   }

  145.   Function {TLE()} {open

  146.   } {

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

  148. 

  149. make_window();

  150. 	

  151. Fl::visible_focus( 0 );

  152. 

  153. get_system_colors();

  154. 

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

  156. 

  157. color_scheme( "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 {Non DAW : Timeline}

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

  222. 	o->hide();} open

  223.       private xywh {705 125 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 ( path )

  297.         {

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

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

  300.             free( path );

  301.             free( selected_template );

  302.         }

  303. 

  304.         if ( default_path )

  305.         {

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

  307.             free( default_path );

  308.         }

  309. 

  310. 

  311. load_timeline_settings();

  312. 

  313. update_menu();

  314. 

  315. main_window->redraw();}

  316.             xywh {0 0 40 25}

  317.           }

  318.           MenuItem {} {

  319.             label {&Open}

  320.             callback {char *path;

  321. 

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

  323. 

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

  325. 

  326. free( path );

  327. 

  328. open( name );}

  329.             xywh {10 10 40 25}

  330.           }

  331.           MenuItem {} {

  332.             label {&Compact}

  333.             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" );

  334. 

  335. if ( n != 2 )

  336. 	return;

  337. 	

  338. Project::compact();}

  339.             xywh {20 20 40 25}

  340.           }

  341.           Submenu {} {

  342.             label {&Export} open

  343.             xywh {0 0 74 25} deactivate

  344.           } {

  345.             MenuItem {} {

  346.               label Project

  347.               xywh {0 0 40 25}

  348.             }

  349.             MenuItem {} {

  350.               label Range

  351.               xywh {10 10 40 25}

  352.             }

  353.           }

  354.           MenuItem {} {

  355.             label {&Quit}

  356.             callback {quit()}

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

  358.           }

  359.         }

  360.         Submenu {} {

  361.           label {&Edit} open

  362.           xywh {0 0 74 25}

  363.         } {

  364.           MenuItem {} {

  365.             label Undo

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

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

  368.           }

  369.           MenuItem {} {

  370.             label {Select None}

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

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

  373.           }

  374.           MenuItem {} {

  375.             label {Delete  Selected}

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

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

  378.           }

  379.         }

  380.         Submenu {} {

  381.           label T&ransport open

  382.           xywh {0 0 74 25}

  383.         } {

  384.           MenuItem {} {

  385.             label Start

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

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

  388.           }

  389.           MenuItem {} {

  390.             label End

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

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

  393.           }

  394.           MenuItem {} {

  395.             label {Play/Stop}

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

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

  398.           }

  399.           MenuItem {} {

  400.             label Record

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

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

  403.           }

  404.         }

  405.         MenuItem {} {

  406.           label {&Timeline}

  407.           xywh {0 0 40 25}

  408.         }

  409.         Submenu {} {

  410.           label {&View} open

  411.           xywh {0 0 74 25}

  412.         } {

  413.           Submenu {} {

  414.             label {&Zoom} open

  415.             xywh {0 0 74 25}

  416.           } {

  417.             MenuItem {} {

  418.               label {&In}

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

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

  421.             }

  422.             MenuItem {} {

  423.               label {&Out}

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

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

  426.             }

  427.             MenuItem {} {

  428.               label {&Fit}

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

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

  431.             }

  432.             MenuItem {} {

  433.               label {1 sec.}

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

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

  436.             }

  437.             MenuItem {} {

  438.               label {1 min.}

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

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

  441.             }

  442.             MenuItem {} {

  443.               label {1 hour.}

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

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

  446.             }

  447.           }

  448.         }

  449.         Submenu {} {

  450.           label {&Options} open

  451.           xywh {0 0 74 25} divider

  452.         } {

  453.           Submenu {} {

  454.             label {&Display} open

  455.             xywh {10 10 74 25}

  456.           } {

  457.             Submenu {} {

  458.               label {&Timeline} open

  459.               xywh {10 10 74 25}

  460.             } {

  461.               MenuItem {} {

  462.                 label {&Measure lines}

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

  464. 

  465. timeline->redraw();}

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

  467.               }

  468.             }

  469.             Submenu {} {

  470.               label {&Waveform} open

  471.               xywh {10 10 74 25}

  472.             } {

  473.               MenuItem {} {

  474.                 label Fill

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

  476. 

  477. timeline->redraw();}

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

  479.               }

  480.               MenuItem {} {

  481.                 label Outline

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

  483. 

  484. timeline->redraw();}

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

  486.               }

  487.               MenuItem {} {

  488.                 label {Vary color}

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

  490. 

  491. timeline->redraw();}

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

  493.               }

  494.             }

  495.             Submenu {} {

  496.               label {&Region} open

  497.               xywh {10 10 74 25}

  498.             } {

  499.               MenuItem {} {

  500.                 label {Filled fades}

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

  502.               }

  503.               MenuItem {} {

  504.                 label {Inherit track color}

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

  506. 

  507. timeline->redraw();}

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

  509.               }

  510.             }

  511.             Submenu {} {

  512.               label {&Control Sequence} open

  513.               xywh {10 10 74 25}

  514.             } {

  515.               MenuItem {} {

  516.                 label Polygon

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

  518. 

  519. timeline->redraw();}

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

  521.               }

  522.               MenuItem {} {

  523.                 label Graded

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

  525. 

  526. timeline->redraw();}

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

  528.               }

  529.               MenuItem {} {

  530.                 label Ruled

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

  532. 

  533. timeline->redraw();}

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

  535.               }

  536.             }

  537.             Submenu {} {

  538.               label {&Style} open

  539.               xywh {10 10 74 25}

  540.             } {

  541.               MenuItem {} {

  542.                 label Default

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

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

  545.               }

  546.               MenuItem {} {

  547.                 label Flat

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

  549.                 xywh {20 20 40 25} type Radio

  550.               }

  551.             }

  552.             Submenu {} {

  553.               label {C&olors} open

  554.               xywh {10 10 74 25}

  555.             } {

  556.               MenuItem {} {

  557.                 label Dark

  558.                 callback {

  559.                 color_scheme( "dark" ); } 

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

  561.               }

  562.               MenuItem {} {

  563.                 label {Very Dark}

  564.                 callback {

  565.                 color_scheme( "very dark" ); }

  566.                 xywh {20 20 40 25} type Radio

  567.               }

  568.               MenuItem {} {

  569.                 label Light

  570.                 callback {

  571.                 color_scheme( "light" ); }

  572.                 xywh {30 30 40 25} type Radio

  573.               }

  574.               MenuItem {} {

  575.                 label System

  576.                 callback {

  577.                 color_scheme( "system" ); }

  578.                 xywh {10 10 40 25} type Radio

  579.               }

  580. 

  581.             }

  582.           }

  583.           Submenu {} {

  584.             label {&Behavior} open

  585.             xywh {0 0 74 25}

  586.           } {

  587.             Submenu {} {

  588.               label {&Transport} open

  589.               xywh {0 0 74 25}

  590.             } {

  591.               MenuItem {} {

  592.                 label {Stop Disables Record}

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

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

  595.               }

  596.             }

  597.           }

  598.         }

  599.         Submenu {} {

  600.           label {&Help} open

  601.           xywh {0 0 74 25}

  602.         } {

  603.           MenuItem {} {

  604.             label {&Manual}

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

  606.             xywh {10 10 40 25} divider

  607.           }

  608.           MenuItem {} {

  609.             label {&About}

  610.             callback {About_Dialog ab( PIXMAP_PATH "/non-daw/logo.png" );

  611. 

  612.             ab.logo_box->label( VERSION );

  613. 

  614.         ab.title->label( "The Non DAW (Digital Audio Workstation)" );

  615. 

  616.         ab.copyright->label( "Copyright (C) 2008-2010 Jonathan Moore Liles" );

  617.         ab.credits->label( "Non-DAW was written from scratch by\\nJonathan Moore Liles for his own use\\n(see the manual).\\n\\nNobody planned. Nobody helped.\\nYou can help now by donating time, money,\\nand/or replacing the rest of Linux Audio\\nwith fast, light, reliable alternatives.\\n" );

  618. 

  619.         ab.website_url->label( "http://non-daw.tuxfamily.org" );

  620. 

  621. 

  622. ab.run();}

  623.             xywh {0 0 40 25}

  624.           }

  625.         }

  626.       }

  627.       Fl_Group {} {open

  628.         xywh {0 1 1025 73}

  629.       } {

  630.         Fl_Pack {} {open

  631.           xywh {0 23 483 46} type HORIZONTAL

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

  633.         } {

  634.           Fl_Box {} {

  635.             label {<Transport>}

  636.             xywh {5 23 189 46} color 30

  637.             code0 {transport = o;}

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

  639.             class Transport

  640.           }

  641.           Fl_Pack clocks_pack {

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

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

  644.           } {

  645.             Fl_Box {} {

  646.               label PLAYHEAD

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

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

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

  650.               class Clock

  651.             }

  652.             Fl_Box {} {

  653.               label PLAYHEAD

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

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

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

  657.               class Clock

  658.             }

  659.           }

  660.         }

  661.         Fl_Box {} {

  662.           label {<empty>}

  663.           xywh {487 27 148 42} resizable

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

  665.         }

  666.         Fl_Group {} {open

  667.           xywh {745 26 280 44}

  668.         } {

  669.           Fl_Box {} {

  670.             label {capture:}

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

  672.           }

  673.           Fl_Box {} {

  674.             label {playback:}

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

  676.           }

  677.           Fl_Box {} {

  678.             label {DSP:}

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

  680.           }

  681.           Fl_Progress capture_buffer_progress {

  682.             label {50%}

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

  684.           }

  685.           Fl_Progress cpu_load_progress {

  686.             label {50%}

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

  688.           }

  689.           Fl_Progress playback_buffer_progress {

  690.             label {50%}

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

  692.           }

  693.           Fl_Box {} {

  694.             label {disk:}

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

  696.           }

  697.           Fl_Progress disk_usage_progress {

  698.             label {50%}

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

  700.           }

  701.         }

  702.         Fl_Button solo_blinker {

  703.           label SOLO

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

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

  706.           class Fl_Blinker

  707.         }

  708.         Fl_Button rec_blinker {

  709.           label REC

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

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

  712.           class Fl_Blinker

  713.         }

  714.         Fl_Button sm_blinker {

  715.           label SM

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

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

  718.           class Fl_Blinker

  719.         }

  720.         Fl_Button selected_blinker {

  721.           label SEL

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

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

  724.           class Fl_Blinker

  725.         }

  726.         Fl_Button seek_blinker {

  727.           label SEEK

  728.           xywh {640 50 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 10 selection_color 2 labelfont 2 labelcolor 39 deactivate hide

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

  730.           code1 {o->interval( Fl_Blinker::FAST );}

  731.           class Fl_Blinker

  732.         }

  733.         Fl_Box stats_box {

  734.           label {<stats>}

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

  736.         }

  737.       }

  738.       Fl_Progress progress {

  739.         label {0%}

  740.         private xywh {15 394 995 41} hide

  741.       }

  742.       Fl_Box {} {

  743.         label {<Timeline>}

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

  745.         code0 {timeline = o;}

  746.         class Timeline

  747.       }

  748.       Fl_Box project_name {

  749.         label {<project name>}

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

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

  752.       }

  753.     }

  754.   }

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

  756.   } {

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

  758.   }

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

  760.   } {

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

  762.   }

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

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

  765.   Function {update_menu()} {private

  766.   } {

  767.     code {Fl_Menu_Bar *m = menubar;

  768. 

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

  770. {

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

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

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

  774. 	

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

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

  777. 

  778. 	timeline->deactivate();

  779. 	transport->deactivate();

  780. }

  781. else

  782. {

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

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

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

  786. 

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

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

  789. 	

  790. 	timeline->activate();

  791. 	transport->activate();	

  792. }

  793. 

  794. m->redraw();

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

  796.   }

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

  798.   } {

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

  800. 

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

  802. 

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

  804.   }

  805.   Function {update_status()} {open private

  806.   } {

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

  808. 

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

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

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

  812. 

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

  814. 

  815. if ( timeline->total_capture_xruns() )

  816. 	capture_buffer_progress->selection_color( FL_RED );

  817. 

  818. if ( timeline->total_playback_xruns() )

  819. 	playback_buffer_progress->selection_color( FL_RED );

  820. 

  821. static char stats[100];

  822. 

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

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

  825. 	engine->xruns() );

  826. 

  827. stats_box->label( stats );

  828. 

  829. static bool zombie = false;

  830. 

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

  832. {

  833. 	zombie = true;

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

  835. }

  836. 

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

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

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

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

  841. selected_blinker->value( timeline->nselected() );

  842. seek_blinker->value( timeline->seek_pending() );

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

  844.   }

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

  846.   } {

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

  848. 

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

  850.   }

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

  852.   } {

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

  854.   }

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

  856.   } {

  857.     code {Fl_Menu_ *o = menubar;

  858. 

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

  860.   }

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

  862.   } {

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

  864.   }

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

  866.   } {

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

  868. {

  869. 	timeline->hide();

  870. 	progress->show();

  871. }

  872. else if ( 0 == p )

  873. {

  874. 	timeline->show();

  875. 	progress->hide();

  876. }

  877. 

  878. static char pat[10];

  879. 

  880. update_progress( progress, pat, p );

  881. 

  882. progress->redraw();

  883. 

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

  885.   }

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

  887.   } {

  888.     code {char pat[256];

  889. 

  890. snprintf( pat, 256, "file://%s/non-daw/%s.html", DOCUMENT_PATH, file );

  891. 

  892. open_url( pat );} {}

  893.   }

  894. } 

  895. 

  896. 

  897. 

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

  899. } {

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

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

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

  903. 

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

  905. }

  906. 

  907. class Project_Info_Dialog {open

  908. } {

  909.   Function {Project_Info_Dialog()} {open

  910.   } {

  911.     code {make_window();} {}

  912.   }

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

  914.   } {

  915.     code {window->show();

  916. 

  917. while ( window->shown() )

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

  919.   }

  920.   Function {make_window()} {open

  921.   } {

  922.     Fl_Window window {

  923.       label {Project info}

  924.       callback {o->hide();

  925. 

  926. if ( logo_box->image() )

  927. {

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

  929. 	logo_box->image( NULL );

  930. }} open

  931.       private xywh {761 214 520 740} type Double modal visible

  932.     } {

  933.       Fl_Value_Output {} {

  934.         label {Sample Rate}

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

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

  937.       }

  938.       Fl_Output {} {

  939.         label {Size of Journal}

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

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

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

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

  944.         code3 {\#include "file.h"}

  945.       }

  946.       Fl_Output {} {

  947.         label {Created On}

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

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

  950.       }

  951.       Fl_Output {} {

  952.         label Length

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

  954.         code0 {char pat[40];}

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

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

  957.       }

  958.       Fl_Value_Output {} {

  959.         label Tracks

  960.         xywh {200 130 55 25} align 1

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

  962.       }

  963.       Fl_Box logo_box {

  964.         label {<LOGO>}

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

  966.         code0 {o->image( Fl_Shared_Image::get( PIXMAP_PATH "non-daw/logo2.png" ) );}

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

  968.       }

  969.       Fl_Text_Editor notes_field {

  970.         label {Notes:}

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

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

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

  974.       }

  975.       Fl_Button {} {

  976.         label {&Save}

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

  978. 

  979. window->do_callback();}

  980.         xywh {425 700 74 25}

  981.       }

  982.       Fl_Box {} {

  983.         label {Project Info}

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

  985.       }

  986.       Fl_Box {} {

  987.         label {Project Info}

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

  989.       }

  990.       Fl_Button {} {

  991.         label {&Discard}

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

  993.         xywh {330 700 74 25}

  994.       }

  995.       Fl_Output {} {

  996.         label {Last Modified On}

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

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

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

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

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

  1002.       }

  1003.     }

  1004.   }

  1005. }