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.
1836 Commits
1 Branch
15MB
Tree: 9fdf3a6ae3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9fdf3a6ae3'
${ noResults }
new-session-manager/timeline/src/TLE.fl

1133 lines
33KB
Raw Blame History 

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

  2. version 1.0300 

  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;} {private local

  26. } 

  27. 

  28. decl {class Fl_Flowpack;} {public global

  29. } 

  30. 

  31. decl {\#include <unistd.h>} {private local

  32. } 

  33. 

  34. decl {\#include <sys/types.h>} {private local

  35. } 

  36. 

  37. decl {\#include <sys/wait.h>} {private local

  38. } 

  39. 

  40. decl {\#include <FL/Fl_Overlay_Window.H>} {private local

  41. } 

  42. 

  43. decl {\#include <FL/Fl_Menu_Settings.H>} {private local

  44. } 

  45. 

  46. decl {\#include "Timeline.H"} {private local

  47. } 

  48. 

  49. decl {\#include "Transport.H"} {private local

  50. } 

  51. 

  52. decl {\#include "Loggable.H"} {private local

  53. } 

  54. 

  55. decl {\#include "Project.H"} {private local

  56. } 

  57. 

  58. decl {\#include "Clock.H"} {public local

  59. } 

  60. 

  61. decl {\#include <FL/Fl_Flowpack.H>} {private local

  62. } 

  63. 

  64. decl {\#include <FL/New_Project_Dialog.H>} {private local

  65. } 

  66. 

  67. decl {\#include "Track.H" // for capture_format} {private local

  68. } 

  69. 

  70. decl {\#include "Waveform.H" // for options} {private local

  71. } 

  72. 

  73. decl {\#include "Audio_Region.H" // for options} {private local

  74. } 

  75. 

  76. decl {\#include "Control_Sequence.H" // for options} {private local

  77. } 

  78. 

  79. decl {\#include <FL/Fl_File_Chooser.H>} {private local

  80. } 

  81. 

  82. decl {\#include <FL/Fl_Shared_Image.H>} {private local

  83. } 

  84. 

  85. decl {\#include <FL/Fl.H>} {private local

  86. } 

  87. 

  88. decl {\#include <FL/fl_ask.H>} {private local

  89. } 

  90. 

  91. decl {\#include "Engine/Engine.H"} {private local

  92. } 

  93. 

  94. decl {\#include "Engine/Audio_File.H" // for supported formats} {private local

  95. } 

  96. 

  97. decl {\#include <FL/About_Dialog.H>} {private local

  98. } 

  99. 

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

  101. } 

  102. 

  103. decl {\#include <nsm.h>} {private local

  104. } 

  105. 

  106. decl {extern nsm_client_t *nsm;} {private global

  107. } 

  108. 

  109. decl {extern char *user_config_dir;} {private global

  110. } 

  111. 

  112. decl {extern char *APP_NAME;} {private global

  113. } 

  114. 

  115. class TLE_Window {open : {public Fl_Overlay_Window}

  116. } {

  117.   Function {TLE_Window(int W, int H, const char *L = 0) : Fl_Overlay_Window( W, H, L )} {open

  118.   } {

  119.     code {} {}

  120.   }

  121.   Function {draw_overlay(void)} {open return_type void

  122.   } {

  123.     code {timeline->draw_overlay();} {}

  124.   }

  125.   Function {~TLE_Window()} {open return_type virtual

  126.   } {

  127.     code {} {}

  128.   }

  129. } 

  130. 

  131. class TLE {open

  132. } {

  133.   decl {Fl_Color system_colors[3];} {private local

  134.   }

  135.   Function {save_options()} {open

  136.   } {

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

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

  139.   

  140.   // save options

  141.   

  142.   char *path;

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

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

  145.   free( path );} {}

  146.   }

  147.   Function {save()} {open

  148.   } {

  149.     code {timeline->command_save();} {}

  150.   }

  151.   Function {quit()} {} {

  152.     code {timeline->command_quit();} {}

  153.   }

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

  155.     code {timeline->command_load( name, NULL );} {}

  156.   }

  157.   Function {save_timeline_settings()} {open

  158.   } {

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

  160. 	return;

  161. 	

  162. 

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

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

  165.   }

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

  167.   } {

  168.     code {char path[256];

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

  170. 

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

  172.   }

  173.   Function {load_timeline_settings()} {open

  174.   } {

  175.     code {reset_timeline_settings();

  176. 

  177. 

  178. if ( Project::open() )

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

  180. 

  181. update_menu();

  182. 

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

  184.   }

  185.   Function {run()} {} {

  186.     code {update_menu();

  187. 

  188. // main_window->show();

  189. 

  190. Fl::lock();

  191. 

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

  193.   }

  194.   Function {TLE()} {open

  195.   } {

  196.     code {make_window();

  197. 	

  198. Fl::visible_focus( 0 );

  199. 

  200. // constrain window to size of screen.

  201. {

  202.         int sx, sy, sw, sh;

  203. 

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

  205. 

  206.         main_window->size_range( 947, 500 );

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

  208. 

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

  210.              main_window->h() > sh )

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

  212. }

  213. 

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

  215. 

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

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

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

  219. fl_message_font( FL_HELVETICA, 18 );

  220. 

  221. 

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

  223. 

  224. Audio_File::all_supported_formats( formats );

  225. 

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

  227. {

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

  229. //;

  230. 	char pat[256];

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

  232. 

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

  234. }

  235. 

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

  237. 

  238. char *path;

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

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

  241. free( path );

  242. 

  243. 

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

  245. 

  246. 

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

  248. {

  249. 	char path[512];

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

  251. 

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

  253. }

  254. 

  255. 

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

  257.   }

  258.   Function {make_window()} {open

  259.   } {

  260.     Fl_Window main_window {

  261.       label {Non Timeline}

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

  263. 	timeline->command_quit();} open

  264.       xywh {204 266 1025 770} type Double resizable

  265.       code0 {o->xclass( APP_NAME );}

  266.       class TLE_Window size_range {947 300 0 0} visible

  267.     } {

  268.       Fl_Group {} {open

  269.         xywh {0 -53 1025 126} box FLAT_BOX

  270.       } {

  271.         Fl_Menu_Bar menubar {open

  272.           private xywh {0 0 1025 25}

  273.         } {

  274.           Submenu {} {

  275.             label {&Project} open

  276.             xywh {5 5 74 25}

  277.           } {

  278.             MenuItem {} {

  279.               label {&Info}

  280.               callback {Project_Info_Dialog pi;

  281. 

  282. pi.run();}

  283.               xywh {5 5 40 25} deactivate

  284.             }

  285.             Submenu {} {

  286.               label {Se&ttings} open

  287.               xywh {25 25 74 25}

  288.             } {

  289.               MenuItem {} {

  290.                 label {&Follow Playhead}

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

  292.                 xywh {45 45 40 25} type Toggle value 1

  293.               }

  294.               MenuItem {} {

  295.                 label {&Center Playhead}

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

  297.                 xywh {55 55 40 25} type Toggle value 1

  298.               }

  299.               Submenu {} {

  300.                 label {&Snap to} open

  301.                 xywh {25 25 74 25}

  302.               } {

  303.                 MenuItem {} {

  304.                   label Bars

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

  306.                   xywh {25 25 40 25} type Radio value 1

  307.                 }

  308.                 MenuItem {} {

  309.                   label Beats

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

  311.                   xywh {35 35 40 25} type Radio

  312.                 }

  313.                 MenuItem {} {

  314.                   label Off

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

  316.                   xywh {45 45 40 25} type Radio

  317.                 }

  318.               }

  319.               MenuItem {} {

  320.                 label {Magnetic snap}

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

  322.                 xywh {35 35 40 25} type Toggle value 1

  323.               }

  324.               Submenu {} {

  325.                 label {Capture Format} open

  326.                 xywh {25 25 74 25}

  327.               } {}

  328.               MenuItem {} {

  329.                 label {Playback Latency Compensation}

  330.                 callback {Timeline::playback_latency_compensation = menu_picked_value( o );} selected

  331.                 xywh {55 55 40 25} type Toggle

  332.               }

  333.             }

  334.             MenuItem {} {

  335.               label {&New}

  336.               callback {save_timeline_settings();

  337. 

  338.               

  339.         char *result_path;    

  340. 

  341.         char *default_path = read_line( user_config_dir, "default_path" );

  342.         result_path = default_path;

  343. 

  344.         char *path = new_project_chooser( &result_path );

  345. 

  346.         if ( path )

  347.         {

  348.             if ( ! Project::create( path, NULL ) )

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

  350.             free( path );

  351.         }

  352. 

  353.         if ( result_path != default_path )

  354.             free(default_path);

  355. 

  356.         if ( result_path )

  357.         {

  358.             write_line( user_config_dir, "default_path", result_path );

  359.             free( result_path );

  360.         }

  361. 

  362. 

  363. load_timeline_settings();

  364. 

  365. update_menu();

  366. 

  367. main_window->redraw();}

  368.               xywh {5 5 40 25}

  369.             }

  370.             MenuItem {} {

  371.               label {&Open}

  372.               callback {char *path = read_line( user_config_dir, "default_path" );

  373. 

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

  375. 

  376. free( path );

  377. 

  378. open( name );}

  379.               xywh {15 15 40 25}

  380.             }

  381.             MenuItem {} {

  382.               label {&Compact}

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

  384. 

  385. if ( n != 2 )

  386. 	return;

  387. 	

  388. Project::compact();}

  389.               xywh {25 25 40 25}

  390.             }

  391.             Submenu {} {

  392.               label {I&mport} open

  393.               xywh {20 20 74 25}

  394.             } {

  395.               MenuItem {} {

  396.                 label {Import Ardour Session}

  397.                 callback {if ( !Project::open() )

  398. {

  399. 	fl_alert( "You must create a new project before importing" );

  400. 	return;

  401. }

  402. 

  403. if ( timeline->ntracks() )

  404. {

  405. 	fl_alert( "You can only import into an empty session!" );

  406. 	return;

  407. }

  408. 

  409. 

  410. pid_t pid;

  411. if ( ! (pid = fork()) )

  412. {

  413. 	exit( system( "import-ardour-session_gui" ) );

  414. }

  415. 

  416. char *path = strdup( Project::path() );

  417. 

  418. Project::close();

  419. 

  420. int status;

  421. 

  422. while ( 0 == waitpid( pid, &status, WNOHANG ) )

  423. {

  424. 	Fl::wait(0.2);

  425. }

  426. 

  427. Project::open(path);

  428. 

  429. free(path);}

  430.                 xywh {20 20 40 25}

  431.               }

  432.             }

  433.             Submenu {} {

  434.               label {&Export} open

  435.               xywh {5 5 74 25} hide deactivate

  436.             } {

  437.               MenuItem {} {

  438.                 label Project

  439.                 xywh {5 5 40 25}

  440.               }

  441.               MenuItem {} {

  442.                 label Range

  443.                 xywh {15 15 40 25}

  444.               }

  445.             }

  446.             MenuItem {} {

  447.               label {&Quit}

  448.               callback {quit()}

  449.               xywh {45 45 40 25} shortcut 0x40071

  450.             }

  451.           }

  452.           Submenu {} {

  453.             label {&Edit} open

  454.             xywh {5 5 74 25}

  455.           } {

  456.             MenuItem {} {

  457.               label Undo

  458.               callback {timeline->command_undo();}

  459.               xywh {5 5 40 25} shortcut 0x4007a divider

  460.             }

  461.             MenuItem {} {

  462.               label {Select None}

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

  464.               xywh {15 15 40 25} shortcut 0x50061

  465.             }

  466.             MenuItem {} {

  467.               label {Delete  Selected}

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

  469.               xywh {25 25 40 25} shortcut 0xffff

  470.             }

  471.           }

  472.           Submenu {} {

  473.             label {T&ransport} open

  474.             xywh {5 5 74 25}

  475.           } {

  476.             MenuItem {} {

  477.               label Start

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

  479.               xywh {5 5 40 25} shortcut 0xff50

  480.             }

  481.             MenuItem {} {

  482.               label End

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

  484.               xywh {15 15 40 25} shortcut 0xff57

  485.             }

  486.             MenuItem {} {

  487.               label {Play/Stop}

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

  489.               xywh {25 25 40 25} shortcut 0x20

  490.             }

  491.             MenuItem {} {

  492.               label Record

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

  494.               xywh {45 45 40 25} shortcut 0x10072

  495.             }

  496.           }

  497.           MenuItem {} {

  498.             label {&Timeline}

  499.             xywh {5 5 40 25}

  500.           }

  501.           Submenu {} {

  502.             label {&View} open

  503.             xywh {5 5 74 25}

  504.           } {

  505.             Submenu {} {

  506.               label {&Zoom} open

  507.               xywh {5 5 74 25}

  508.             } {

  509.               MenuItem {} {

  510.                 label {&In}

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

  512.                 xywh {25 25 40 25} shortcut 0x2b

  513.               }

  514.               MenuItem {} {

  515.                 label {&Out}

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

  517.                 xywh {35 35 40 25} shortcut 0x5f

  518.               }

  519.               MenuItem {} {

  520.                 label {&Fit}

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

  522.                 xywh {15 15 40 25} shortcut 0x3d divider

  523.               }

  524.               MenuItem {} {

  525.                 label {1 sec.}

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

  527.                 xywh {15 15 40 25} shortcut 0x31

  528.               }

  529.               MenuItem {} {

  530.                 label {1 min.}

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

  532.                 xywh {25 25 40 25} shortcut 0x32

  533.               }

  534.               MenuItem {} {

  535.                 label {1 hour.}

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

  537.                 xywh {35 35 40 25} shortcut 0x33

  538.               }

  539.             }

  540.             MenuItem {} {

  541.               label {&Theme}

  542.               callback {fl_theme_chooser();}

  543.               xywh {15 15 40 24}

  544.               code0 {\#include "FL/Fl_Theme_Chooser.H"}

  545.             }

  546.           }

  547.           Submenu {} {

  548.             label {&Options} open

  549.             xywh {5 5 74 25} divider

  550.           } {

  551.             Submenu {} {

  552.               label {&Display} open

  553.               xywh {15 15 74 25}

  554.             } {

  555.               Submenu {} {

  556.                 label {&Timeline} open

  557.                 xywh {15 15 74 25}

  558.               } {

  559.                 MenuItem {} {

  560.                   label {&Measure lines}

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

  562. 

  563. timeline->redraw();}

  564.                   xywh {15 15 40 25} type Toggle value 1

  565.                 }

  566.                 MenuItem {} {

  567.                   label {&Cursor Overlay}

  568.                   callback {Timeline::draw_with_cursor_overlay = menu_picked_value( o );

  569. 

  570. timeline->redraw();}

  571.                   xywh {15 14 40 25} type Toggle value 1

  572.                 }

  573.               }

  574.               Submenu {} {

  575.                 label {&Waveform} open

  576.                 xywh {15 15 74 25}

  577.               } {

  578.                 MenuItem {} {

  579.                   label Fill

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

  581. 

  582. timeline->redraw();}

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

  584.                 }

  585.                 MenuItem {} {

  586.                   label Outline

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

  588. 

  589. timeline->redraw();}

  590.                   xywh {45 45 40 25} type Toggle value 1

  591.                 }

  592.                 MenuItem {} {

  593.                   label {Vary color}

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

  595. 

  596. timeline->redraw();}

  597.                   xywh {35 35 40 25} type Toggle value 1

  598.                 }

  599.               }

  600.               Submenu {} {

  601.                 label {&Region} open

  602.                 xywh {15 15 74 25}

  603.               } {

  604.                 MenuItem {} {

  605.                   label {Filled fades}

  606.                   xywh {45 45 40 25} type Toggle value 1

  607.                 }

  608.                 MenuItem {} {

  609.                   label {Inherit track color}

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

  611. 

  612. timeline->redraw();}

  613.                   xywh {55 55 40 25} type Toggle value 1

  614.                 }

  615.                 MenuItem {} {

  616.                   label {Show box}

  617.                   callback {Audio_Region::show_box = menu_picked_value( o );

  618. 

  619. timeline->redraw();}

  620.                   xywh {55 55 40 25} type Toggle value 1

  621.                 }

  622.               }

  623.               Submenu {} {

  624.                 label {&Control Sequence} open

  625.                 xywh {15 15 74 25}

  626.               } {

  627.                 MenuItem {} {

  628.                   label Ruled

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

  630. 

  631. timeline->redraw();}

  632.                   xywh {55 55 40 25} type Toggle value 1

  633.                 }

  634.               }

  635.               Submenu {} {

  636.                 label {&Track} open

  637.                 xywh {15 15 74 25}

  638.               } {

  639.                 MenuItem {} {

  640.                   label {Colored tracks}

  641.                   callback {Track::colored_tracks = menu_picked_value( o );

  642. 

  643. timeline->redraw();}

  644.                   xywh {45 45 40 25} type Toggle value 1

  645.                 }

  646.               }

  647.             }

  648.             Submenu {} {

  649.               label {&Behavior} open

  650.               xywh {5 5 74 25}

  651.             } {

  652.               Submenu {} {

  653.                 label {&Transport} open

  654.                 xywh {5 5 74 25}

  655.               } {

  656.                 MenuItem {} {

  657.                   label {Stop Disables Record}

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

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

  660.                 }

  661.                 MenuItem {} {

  662.                   label {Loop Playback}

  663.                   callback {transport->loop_enabled( ( ((Fl_Menu_*)o)->mvalue()->flags & FL_MENU_VALUE )) ;}

  664.                   xywh {10 10 40 25} type Toggle

  665.                 }

  666.                 MenuItem {} {

  667.                   label {Automatically Create Takes}

  668.                   callback {transport->automatically_create_takes( ( ((Fl_Menu_*)o)->mvalue()->flags & FL_MENU_VALUE ));}

  669.                   xywh {10 10 40 25} type Toggle

  670.                 }

  671.               }

  672.             }

  673.           }

  674.           Submenu {} {

  675.             label {&Help} open

  676.             xywh {5 5 74 25}

  677.           } {

  678.             MenuItem {} {

  679.               label {&Manual}

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

  681.               xywh {15 15 40 25} divider

  682.             }

  683.             MenuItem {} {

  684.               label {&About}

  685.               callback {About_Dialog ab( PIXMAP_PATH "/non-timeline/icon-256x256.png" );

  686. 

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

  688. 

  689.         ab.title->label( "Non Timeline" );

  690. 

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

  692.         ab.credits->label( "Non Timeline 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" );

  693. 

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

  695. 

  696. ab.run();}

  697.               xywh {5 5 40 25}

  698.             }

  699.           }

  700.         }

  701.         Fl_Pack {} {open

  702.           xywh {1 27 584 46} type HORIZONTAL

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

  704.         } {

  705.           Fl_Box {} {

  706.             label {<Transport>}

  707.             xywh {5 28 290 44} color 30

  708.             code0 {transport = o;}

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

  710.             class Transport

  711.           }

  712.           Fl_Pack clocks_pack {open

  713.             private xywh {295 30 290 41} type HORIZONTAL

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

  715.           } {

  716.             Fl_Box {} {

  717.               label PLAYHEAD

  718.               private xywh {301 30 137 41} box FLAT_BOX color 47

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

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

  721.               class Clock

  722.             }

  723.             Fl_Box {} {

  724.               label PLAYHEAD

  725.               xywh {440 30 137 41} box FLAT_BOX color 47

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

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

  728.               class Clock

  729.             }

  730.           }

  731.         }

  732.         Fl_Box {} {

  733.           label {<empty>}

  734.           xywh {585 32 155 40} resizable

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

  736.         }

  737.         Fl_Group {} {open

  738.           xywh {850 23 175 50}

  739.         } {

  740.           Fl_Box {} {

  741.             label {capture:}

  742.             xywh {910 27 56 14} labelsize 10 align 24

  743.           }

  744.           Fl_Box {} {

  745.             label {playback:}

  746.             xywh {910 43 56 14} labelsize 10 align 24

  747.           }

  748.           Fl_Box {} {

  749.             label {DSP:}

  750.             xywh {910 57 56 14} labelsize 10 align 24

  751.           }

  752.           Fl_Box {} {

  753.             label filesystem

  754.             xywh {855 28 55 18} labelsize 10 align 16

  755.           }

  756.           Fl_Progress capture_buffer_progress {

  757.             label {50%}

  758.             private xywh {965 27 60 14} selection_color 0 labelsize 10

  759.           }

  760.           Fl_Progress cpu_load_progress {

  761.             label {50%}

  762.             private xywh {965 57 60 14} selection_color 0 labelsize 9

  763.           }

  764.           Fl_Progress playback_buffer_progress {

  765.             label {50%}

  766.             private xywh {965 42 60 14} selection_color 0 labelsize 10

  767.           }

  768.           Fl_Progress disk_usage_progress {

  769.             label {50%}

  770.             private xywh {855 43 55 28} selection_color 0 labelsize 10

  771.             code0 {o->type( FL_VERTICAL );}

  772.           }

  773.         }

  774.         Fl_Group {} {open

  775.           xywh {740 31 115 40}

  776.         } {

  777.           Fl_Button solo_blinker {

  778.             label SOLO

  779.             xywh {800 33 50 15} box BORDER_BOX down_box BORDER_BOX color 74 selection_color 92 labelfont 1 labelsize 11 labelcolor 32

  780.             code0 {\#include "FL/Fl_Blink_Button.H"}

  781.             code1 {o->box( FL_ASYM_BOX );}

  782.             code2 {o->down_box( FL_ASYM_BOX );}

  783.             code3 {o->ignore_input( true );}

  784.             class Fl_Blink_Button

  785.           }

  786.           Fl_Button rec_blinker {

  787.             label REC

  788.             xywh {800 53 50 15} box BORDER_BOX down_box BORDER_BOX color 72 selection_color 88 labelfont 1 labelsize 11 labelcolor 32

  789.             code0 {\#include "FL/Fl_Blink_Button.H"}

  790.             code1 {o->box( FL_ASYM_BOX );}

  791.             code2 {o->down_box( FL_ASYM_BOX );}

  792.             code3 {o->ignore_input( true );}

  793.             class Fl_Blink_Button

  794.           }

  795.           Fl_Button selected_blinker {

  796.             label SEL

  797.             xywh {745 53 50 15} box BORDER_BOX down_box BORDER_BOX color 13 selection_color 5 labelfont 1 labelsize 11 labelcolor 32

  798.             code0 {\#include "FL/Fl_Blink_Button.H"}

  799.             code1 {o->box( FL_ASYM_BOX );}

  800.             code2 {o->down_box( FL_ASYM_BOX );}

  801.             code3 {o->ignore_input( true );}

  802.             class Fl_Blink_Button

  803.           }

  804.           Fl_Button seek_blinker {

  805.             label SEEK

  806.             xywh {745 33 50 15} box BORDER_BOX down_box BORDER_BOX color 10 selection_color 2 labelfont 1 labelsize 11 labelcolor 32

  807.             code0 {\#include "FL/Fl_Blink_Button.H"}

  808.             code1 {o->box( FL_ASYM_BOX );}

  809.             code2 {o->down_box( FL_ASYM_BOX );}

  810.             code3 {o->ignore_input( true );}

  811.             class Fl_Blink_Button

  812.           }

  813.         }

  814.         Fl_Box stats_box {

  815.           label {<stats>}

  816.           xywh {745 0 235 25} labelsize 13 labelcolor 53 align 88

  817.         }

  818.         Fl_Button sm_blinker {

  819.           label SM

  820.           xywh {985 6 35 15} box ROUNDED_BOX down_box ROUNDED_BOX color 45 selection_color 93 labelfont 3 labelcolor 39 deactivate

  821.           class Fl_Button

  822.         }

  823.       }

  824.       Fl_Group progress_group {open

  825.         xywh {295 352 450 79} hide

  826.       } {

  827.         Fl_Progress progress {

  828.           label {0%}

  829.           private xywh {295 394 450 37} box ROUNDED_BOX selection_color 55 labelfont 1 labelsize 22

  830.         }

  831.         Fl_Box {} {

  832.           label {Loading...}

  833.           xywh {295 362 450 31} labelfont 1 labelsize 17 align 18

  834.         }

  835.       }

  836.       Fl_Box {} {

  837.         label {<Timeline>}

  838.         xywh {0 75 1025 692} box FLAT_BOX color 47 labeltype NO_LABEL labelsize 100 resizable

  839.         code0 {timeline = o;}

  840.         class Timeline

  841.       }

  842.       Fl_Box project_name {

  843.         label {<project name>}

  844.         private xywh {440 0 305 24} labeltype SHADOW_LABEL labelfont 2

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

  846.       }

  847.     }

  848.   }

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

  850.   } {

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

  852.   }

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

  854.   } {

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

  856.   }

  857.   decl {static void menubar_cb ( void *v )} {private local

  858.   }

  859.   decl {void menubar_cb ( void )} {private local

  860.   }

  861.   Function {update_menu()} {private

  862.   } {

  863.     code {Fl_Menu_Bar *m = menubar;

  864. 

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

  866. {

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

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

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

  870. 	

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

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

  873. 

  874. 	timeline->deactivate();

  875. 	transport->deactivate();

  876. }

  877. else

  878. {

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

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

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

  882. 

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

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

  885. 	

  886. 	timeline->activate();

  887. 	transport->activate();	

  888. }

  889. 

  890. m->redraw();

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

  892.   }

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

  894.   } {

  895.     code {if ( p->value() != v )

  896. {

  897. p->value( v );

  898. 

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

  900. 

  901. p->label( s );

  902. 

  903. }} {}

  904.   }

  905.   Function {update_status()} {open private

  906.   } {

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

  908. 

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

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

  911. update_progress( cpu_load_progress, clp, engine ? engine->cpu_load() : 0 );

  912. 

  913. if ( Project::open() )

  914.    update_progress( disk_usage_progress, dup, percent_used( Project::path() ) );

  915. else

  916.    update_progress( disk_usage_progress, dup, 0 );

  917. 

  918. if ( timeline->total_capture_xruns() )

  919. 	capture_buffer_progress->selection_color( FL_RED );

  920. 

  921. if ( timeline->total_playback_xruns() )

  922. 	playback_buffer_progress->selection_color( FL_RED );

  923. 

  924. static char stats[100];

  925. 

  926. if ( engine && ! engine->zombified() )

  927. {

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

  929. 	engine->frames_to_milliseconds( engine->system_latency() ),

  930. 	engine->xruns() );

  931. }

  932. else

  933. {

  934.         snprintf( stats, sizeof( stats ), "%s", "DISCONNECTED" );

  935. }

  936. 

  937. stats_box->label( stats );

  938. 

  939. static bool zombie = false;

  940. 

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

  942. {

  943. 	zombie = true;

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

  945. }

  946. 

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

  948. 

  949. if ( transport->punch_enabled() && timeline->range_start() != timeline->range_end() )

  950.         rec_blinker->value( transport->rolling &&

  951.                             transport->rec_enabled() &&

  952.                             transport->frame >= timeline->range_start() &&

  953.                             transport->frame <= timeline->range_end() );

  954. else

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

  956. 

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

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

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

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

  961. 

  962. if ( timeline->session_manager_name() != NULL )

  963. {

  964. 	find_item( menubar, "&Project/&New" )->deactivate();

  965. 	find_item( menubar, "&Project/&Open" )->deactivate();

  966. }

  967. 

  968. // project_name->redraw();} {}

  969.   }

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

  971.   } {

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

  973. 

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

  975.   }

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

  977.   } {

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

  979.   }

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

  981.   } {

  982.     code {Fl_Menu_ *o = menubar;

  983. 

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

  985.   }

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

  987.   } {

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

  989.   }

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

  991.   } {

  992.     code {if ( ! progress_group->visible() )

  993. {

  994. 	timeline->hide();

  995. 	progress_group->show();

  996. }

  997. else if ( 0 == p )

  998. {

  999. 	timeline->show();

  1000. 	progress_group->hide();

  1001. }

  1002. 

  1003. // never allow drawing timeline while loading, as this would cause lock recursion.

  1004. if ( timeline->visible() )

  1005.    return;

  1006. 

  1007. static int oldp;

  1008. static char pat[10];

  1009. 

  1010. if ( p != oldp )

  1011. {

  1012.         oldp = p;

  1013.         nsm_send_progress( nsm, p / 100.0f );

  1014.         update_progress( progress, pat, p );

  1015. 

  1016.         progress->redraw();

  1017. 

  1018.         Fl::check();

  1019. }} {}

  1020.   }

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

  1022.   } {

  1023.     code {char pat[256];

  1024. 

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

  1026. 

  1027. open_url( pat );} {}

  1028.   }

  1029. } 

  1030. 

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

  1032. } {

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

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

  1035.         Fl::foreground( 255, 255, 255 );} {}

  1036. } 

  1037. 

  1038. class Project_Info_Dialog {open

  1039. } {

  1040.   Function {Project_Info_Dialog()} {open

  1041.   } {

  1042.     code {make_window();} {}

  1043.   }

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

  1045.   } {

  1046.     code {window->show();

  1047. 

  1048. while ( window->shown() )

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

  1050.   }

  1051.   Function {make_window()} {open

  1052.   } {

  1053.     Fl_Window window {

  1054.       label {Project info}

  1055.       callback {o->hide();

  1056. 

  1057. if ( logo_box->image() )

  1058. {

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

  1060. 	logo_box->image( NULL );

  1061. }} open

  1062.       private xywh {1195 197 520 710} type Double modal visible

  1063.     } {

  1064.       Fl_Group {} {open

  1065.         xywh {25 30 470 75}

  1066.       } {

  1067.         Fl_Value_Output {} {

  1068.           label {Sample Rate}

  1069.           xywh {35 30 90 25} labeltype SHADOW_LABEL align 1

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

  1071.         }

  1072.         Fl_Output {} {

  1073.           label {Size of Journal}

  1074.           xywh {175 30 100 25} box UP_BOX labeltype SHADOW_LABEL align 1

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

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

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

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

  1079.         }

  1080.         Fl_Output {} {

  1081.           label {Created On}

  1082.           xywh {315 30 180 25} box UP_BOX labeltype SHADOW_LABEL align 1 textfont 11 textsize 12

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

  1084.         }

  1085.         Fl_Output {} {

  1086.           label Length

  1087.           xywh {25 80 115 25} box BORDER_BOX color 47 align 1 textcolor 71

  1088.           code0 {char pat[40];}

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

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

  1091.         }

  1092.         Fl_Value_Output {} {

  1093.           label Tracks

  1094.           xywh {195 80 55 25} align 1

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

  1096.         }

  1097.         Fl_Output {} {

  1098.           label {Last Modified On}

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

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

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

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

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

  1104.         }

  1105.       }

  1106.       Fl_Box logo_box {

  1107.         label {<LOGO>}

  1108.         private xywh {18 117 485 268} color 53 labelfont 1 labelsize 18 align 16

  1109.         code0 {o->image( Fl_Shared_Image::get( PIXMAP_PATH "/non-timeline/icon-256x256.png" ) );}

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

  1111.       }

  1112.       Fl_Text_Editor notes_field {

  1113.         label {Notes:}

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

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

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

  1117.       }

  1118.       Fl_Button {} {

  1119.         label {&Save}

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

  1121. 

  1122. window->do_callback();}

  1123.         xywh {422 676 74 25}

  1124.       }

  1125.       Fl_Button {} {

  1126.         label {&Discard}

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

  1128.         xywh {332 676 74 25}

  1129.       }

  1130.     }

  1131.   }

  1132. }