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

1031 lines
29KB
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 <FL/Fl_Overlay_Window.H>} {private local

  32. } 

  33. 

  34. decl {\#include "Fl_Menu_Settings.H"} {private local

  35. } 

  36. 

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

  38. } 

  39. 

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

  41. } 

  42. 

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

  44. } 

  45. 

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

  47. } 

  48. 

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

  50. } 

  51. 

  52. decl {\#include "FL/Fl_Flowpack.H"} {private local

  53. } 

  54. 

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

  56. } 

  57. 

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

  59. } 

  60. 

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

  62. } 

  63. 

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

  65. } 

  66. 

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

  68. } 

  69. 

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

  71. } 

  72. 

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

  74. } 

  75. 

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

  77. } 

  78. 

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

  80. } 

  81. 

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

  83. } 

  84. 

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

  86. } 

  87. 

  88. decl {\#include "FL/About_Dialog.H"} {private local

  89. } 

  90. 

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

  92. } 

  93. 

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

  95. } 

  96. 

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

  98. } 

  99. 

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

  101. } 

  102. 

  103. class TLE_Window {open : {public Fl_Overlay_Window}

  104. } {

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

  106.   } {

  107.     code {} {}

  108.   }

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

  110.   } {

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

  112.   }

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

  114.   } {

  115.     code {} {selected

  116.     }

  117.   }

  118. } 

  119. 

  120. class TLE {open

  121. } {

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

  123.   }

  124.   Function {save_options()} {open

  125.   } {

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

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

  128.   

  129.   // save options

  130.   

  131.   char *path;

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

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

  134.   free( path );} {}

  135.   }

  136.   Function {save()} {open

  137.   } {

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

  139.   }

  140.   Function {quit()} {} {

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

  142.   }

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

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

  145.   }

  146.   Function {save_timeline_settings()} {open

  147.   } {

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

  149. 	return;

  150. 	

  151. 

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

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

  154.   }

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

  156.   } {

  157.     code {char path[256];

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

  159. 

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

  161.   }

  162.   Function {load_timeline_settings()} {open

  163.   } {

  164.     code {reset_timeline_settings();

  165. 

  166. 

  167. if ( Project::open() )

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

  169. 

  170. update_menu();

  171. 

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

  173.   }

  174.   Function {run()} {} {

  175.     code {update_menu();

  176. 

  177. // main_window->show();

  178. 

  179. Fl::lock();

  180. 

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

  182.   }

  183.   Function {TLE()} {open

  184.   } {

  185.     code {make_window();

  186. 	

  187. Fl::visible_focus( 0 );

  188. 

  189. // constrain window to size of screen.

  190. {

  191.         int sx, sy, sw, sh;

  192. 

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

  194. 

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

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

  197. 

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

  199.              main_window->h() > sh )

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

  201. }

  202. 

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

  204. 

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

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

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

  208. fl_message_font( FL_HELVETICA, 18 );

  209. 

  210. 

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

  212. 

  213. Audio_File::all_supported_formats( formats );

  214. 

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

  216. {

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

  218. //;

  219. 	char pat[256];

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

  221. 

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

  223. }

  224. 

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

  226. 

  227. char *path;

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

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

  230. free( path );

  231. 

  232. 

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

  234. 

  235. 

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

  237. {

  238. 	char path[512];

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

  240. 

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

  242. }

  243. 

  244. 

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

  246.   }

  247.   Function {make_window()} {open

  248.   } {

  249.     Fl_Window main_window {

  250.       label {Non DAW : Timeline}

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

  252. 	timeline->command_quit();} open

  253.       xywh {485 131 1025 770} type Double resizable

  254.       class TLE_Window xclass Non_DAW size_range {900 300 0 0} visible

  255.     } {

  256.       Fl_Menu_Bar menubar {open

  257.         private xywh {0 0 1025 25}

  258.       } {

  259.         Submenu {} {

  260.           label {&Project} open

  261.           xywh {0 0 74 25}

  262.         } {

  263.           MenuItem {} {

  264.             label {&Info}

  265.             callback {Project_Info_Dialog pi;

  266. 

  267. pi.run();}

  268.             xywh {0 0 40 25} deactivate

  269.           }

  270.           Submenu {} {

  271.             label {Se&ttings} open

  272.             xywh {20 20 74 25}

  273.           } {

  274.             MenuItem {} {

  275.               label {&Follow Playhead}

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

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

  278.             }

  279.             MenuItem {} {

  280.               label {&Center Playhead}

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

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

  283.             }

  284.             Submenu {} {

  285.               label {&Snap to} open

  286.               xywh {20 20 74 25}

  287.             } {

  288.               MenuItem {} {

  289.                 label Bars

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

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

  292.               }

  293.               MenuItem {} {

  294.                 label Beats

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

  296.                 xywh {30 30 40 25} type Radio

  297.               }

  298.               MenuItem {} {

  299.                 label Off

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

  301.                 xywh {40 40 40 25} type Radio

  302.               }

  303.             }

  304.             MenuItem {} {

  305.               label {Magnetic snap}

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

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

  308.             }

  309.             Submenu {} {

  310.               label {Capture Format} open

  311.               xywh {20 20 74 25}

  312.             } {}

  313.           }

  314.           MenuItem {} {

  315.             label {&New}

  316.             callback {save_timeline_settings();

  317. 

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

  319. 

  320. char *default_path;

  321. char *selected_template;

  322. 

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

  324. 

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

  326. 

  327.         if ( path )

  328.         {

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

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

  331.             free( path );

  332.             free( selected_template );

  333.         }

  334. 

  335.         if ( default_path )

  336.         {

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

  338.             free( default_path );

  339.         }

  340. 

  341. 

  342. load_timeline_settings();

  343. 

  344. update_menu();

  345. 

  346. main_window->redraw();}

  347.             xywh {0 0 40 25}

  348.           }

  349.           MenuItem {} {

  350.             label {&Open}

  351.             callback {char *path;

  352. 

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

  354. 

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

  356. 

  357. free( path );

  358. 

  359. open( name );}

  360.             xywh {10 10 40 25}

  361.           }

  362.           MenuItem {} {

  363.             label {&Compact}

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

  365. 

  366. if ( n != 2 )

  367. 	return;

  368. 	

  369. Project::compact();}

  370.             xywh {20 20 40 25}

  371.           }

  372.           Submenu {} {

  373.             label {&Export} open

  374.             xywh {0 0 74 25} deactivate

  375.           } {

  376.             MenuItem {} {

  377.               label Project

  378.               xywh {0 0 40 25}

  379.             }

  380.             MenuItem {} {

  381.               label Range

  382.               xywh {10 10 40 25}

  383.             }

  384.           }

  385.           MenuItem {} {

  386.             label {&Quit}

  387.             callback {quit()}

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

  389.           }

  390.         }

  391.         Submenu {} {

  392.           label {&Edit} open

  393.           xywh {0 0 74 25}

  394.         } {

  395.           MenuItem {} {

  396.             label Undo

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

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

  399.           }

  400.           MenuItem {} {

  401.             label {Select None}

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

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

  404.           }

  405.           MenuItem {} {

  406.             label {Delete  Selected}

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

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

  409.           }

  410.         }

  411.         Submenu {} {

  412.           label {T&ransport} open

  413.           xywh {0 0 74 25}

  414.         } {

  415.           MenuItem {} {

  416.             label Start

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

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

  419.           }

  420.           MenuItem {} {

  421.             label End

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

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

  424.           }

  425.           MenuItem {} {

  426.             label {Play/Stop}

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

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

  429.           }

  430.           MenuItem {} {

  431.             label Record

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

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

  434.           }

  435.         }

  436.         MenuItem {} {

  437.           label {&Timeline}

  438.           xywh {0 0 40 25}

  439.         }

  440.         Submenu {} {

  441.           label {&View} open

  442.           xywh {0 0 74 25}

  443.         } {

  444.           Submenu {} {

  445.             label {&Zoom} open

  446.             xywh {0 0 74 25}

  447.           } {

  448.             MenuItem {} {

  449.               label {&In}

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

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

  452.             }

  453.             MenuItem {} {

  454.               label {&Out}

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

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

  457.             }

  458.             MenuItem {} {

  459.               label {&Fit}

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

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

  462.             }

  463.             MenuItem {} {

  464.               label {1 sec.}

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

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

  467.             }

  468.             MenuItem {} {

  469.               label {1 min.}

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

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

  472.             }

  473.             MenuItem {} {

  474.               label {1 hour.}

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

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

  477.             }

  478.           }

  479.           MenuItem {} {

  480.             label {&Theme}

  481.             callback {fl_theme_chooser();}

  482.             xywh {10 10 40 24}

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

  484.           }

  485.         }

  486.         Submenu {} {

  487.           label {&Options} open

  488.           xywh {0 0 74 25} divider

  489.         } {

  490.           Submenu {} {

  491.             label {&Display} open

  492.             xywh {10 10 74 25}

  493.           } {

  494.             Submenu {} {

  495.               label {&Timeline} open

  496.               xywh {10 10 74 25}

  497.             } {

  498.               MenuItem {} {

  499.                 label {&Measure lines}

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

  501. 

  502. timeline->redraw();}

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

  504.               }

  505.             }

  506.             Submenu {} {

  507.               label {&Waveform} open

  508.               xywh {10 10 74 25}

  509.             } {

  510.               MenuItem {} {

  511.                 label Fill

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

  513. 

  514. timeline->redraw();}

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

  516.               }

  517.               MenuItem {} {

  518.                 label Outline

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

  520. 

  521. timeline->redraw();}

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

  523.               }

  524.               MenuItem {} {

  525.                 label {Vary color}

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

  527. 

  528. timeline->redraw();}

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

  530.               }

  531.             }

  532.             Submenu {} {

  533.               label {&Region} open

  534.               xywh {10 10 74 25}

  535.             } {

  536.               MenuItem {} {

  537.                 label {Filled fades}

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

  539.               }

  540.               MenuItem {} {

  541.                 label {Inherit track color}

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

  543. 

  544. timeline->redraw();}

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

  546.               }

  547.               MenuItem {} {

  548.                 label {Show box}

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

  550. 

  551. timeline->redraw();}

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

  553.               }

  554.             }

  555.             Submenu {} {

  556.               label {&Control Sequence} open

  557.               xywh {10 10 74 25}

  558.             } {

  559.               MenuItem {} {

  560.                 label Polygon

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

  562. 

  563. timeline->redraw();}

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

  565.               }

  566.               MenuItem {} {

  567.                 label Graded

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

  569. 

  570. timeline->redraw();}

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

  572.               }

  573.               MenuItem {} {

  574.                 label Ruled

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

  576. 

  577. timeline->redraw();}

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

  579.               }

  580.             }

  581.           }

  582.           Submenu {} {

  583.             label {&Behavior} open

  584.             xywh {0 0 74 25}

  585.           } {

  586.             Submenu {} {

  587.               label {&Transport} open

  588.               xywh {0 0 74 25}

  589.             } {

  590.               MenuItem {} {

  591.                 label {Stop Disables Record}

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

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

  594.               }

  595.             }

  596.           }

  597.         }

  598.         Submenu {} {

  599.           label {&Help} open

  600.           xywh {0 0 74 25}

  601.         } {

  602.           MenuItem {} {

  603.             label {&Manual}

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

  605.             xywh {10 10 40 25} divider

  606.           }

  607.           MenuItem {} {

  608.             label {&About}

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

  610. 

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

  612. 

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

  614. 

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

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

  617. 

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

  619. 

  620. 

  621. ab.run();}

  622.             xywh {0 0 40 25}

  623.           }

  624.         }

  625.       }

  626.       Fl_Group {} {open

  627.         xywh {0 -1 1025 76}

  628.       } {

  629.         Fl_Pack {} {open

  630.           xywh {3 27 477 44} type HORIZONTAL

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

  632.         } {

  633.           Fl_Box {} {

  634.             label {<Transport>}

  635.             xywh {5 29 185 37} color 30

  636.             code0 {transport = o;}

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

  638.             code2 {o->spacing( 1 );}

  639.             class Transport

  640.           }

  641.           Fl_Pack clocks_pack {open

  642.             private xywh {195 27 285 44} type HORIZONTAL

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

  644.           } {

  645.             Fl_Box {} {

  646.               label PLAYHEAD

  647.               private xywh {196 27 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 31 137 37} 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 {475 31 265 40} resizable

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

  665.         }

  666.         Fl_Group {} {open

  667.           xywh {850 22 175 50}

  668.         } {

  669.           Fl_Box {} {

  670.             label {capture:}

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

  672.           }

  673.           Fl_Box {} {

  674.             label {playback:}

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

  676.           }

  677.           Fl_Box {} {

  678.             label {DSP:}

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

  680.           }

  681.           Fl_Box {} {

  682.             label filesystem

  683.             xywh {855 27 55 18} labelsize 10 align 16

  684.           }

  685.           Fl_Progress capture_buffer_progress {

  686.             label {50%}

  687.             private xywh {965 26 60 14} labelsize 10

  688.           }

  689.           Fl_Progress cpu_load_progress {

  690.             label {50%}

  691.             private xywh {965 56 60 14} labelsize 9

  692.           }

  693.           Fl_Progress playback_buffer_progress {

  694.             label {50%}

  695.             private xywh {965 41 60 14} labelsize 10

  696.           }

  697.           Fl_Progress disk_usage_progress {

  698.             label {50%}

  699.             private xywh {855 42 55 28} labelsize 10

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

  701.           }

  702.         }

  703.         Fl_Group {} {open

  704.           xywh {740 30 115 40}

  705.         } {

  706.           Fl_Button solo_blinker {

  707.             label SOLO

  708.             xywh {800 32 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 74 selection_color 92 labelfont 2 labelcolor 39 deactivate

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

  710.             class Fl_Blink_Button

  711.           }

  712.           Fl_Button rec_blinker {

  713.             label REC

  714.             xywh {800 52 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 72 selection_color 88 labelfont 2 labelcolor 39 deactivate

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

  716.             class Fl_Blink_Button

  717.           }

  718.           Fl_Button selected_blinker {

  719.             label SEL

  720.             xywh {745 52 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 13 selection_color 5 labelfont 2 labelcolor 39 deactivate

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

  722.             code1 {o->blink( false );}

  723.             class Fl_Blink_Button

  724.           }

  725.           Fl_Button seek_blinker {

  726.             label SEEK

  727.             xywh {745 32 50 15} box ROUNDED_BOX down_box ROUNDED_BOX color 10 selection_color 2 labelfont 2 labelcolor 39 deactivate

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

  729.             code1 {o->blink_interval( Fl_Blink_Button::FAST );}

  730.             class Fl_Blink_Button

  731.           }

  732.         }

  733.         Fl_Box stats_box {

  734.           label {<stats>}

  735.           xywh {745 0 235 24} labelsize 13 labelcolor 53 align 88

  736.         }

  737.         Fl_Button sm_blinker {

  738.           label SM

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

  740.           class Fl_Button

  741.         }

  742.       }

  743.       Fl_Progress progress {

  744.         label {0%}

  745.         private xywh {15 394 995 41} hide

  746.       }

  747.       Fl_Box {} {

  748.         label {<Timeline>}

  749.         xywh {0 75 1025 692} box FLAT_BOX color 47 labelsize 100 resizable

  750.         code0 {timeline = o;}

  751.         class Timeline

  752.       }

  753.       Fl_Box project_name {

  754.         label {<project name>}

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

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

  757.       }

  758.     }

  759.   }

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

  761.   } {

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

  763.   }

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

  765.   } {

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

  767.   }

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

  769.   }

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

  771.   }

  772.   Function {update_menu()} {private

  773.   } {

  774.     code {Fl_Menu_Bar *m = menubar;

  775. 

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

  777. {

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

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

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

  781. 	

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

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

  784. 

  785. 	timeline->deactivate();

  786. 	transport->deactivate();

  787. }

  788. else

  789. {

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

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

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

  793. 

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

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

  796. 	

  797. 	timeline->activate();

  798. 	transport->activate();	

  799. }

  800. 

  801. m->redraw();

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

  803.   }

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

  805.   } {

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

  807. {

  808. p->value( v );

  809. 

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

  811. 

  812. p->label( s );

  813. 

  814. }} {}

  815.   }

  816.   Function {update_status()} {open private

  817.   } {

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

  819. 

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

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

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

  823. 

  824. if ( Project::open() )

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

  826. else

  827.    update_progress( disk_usage_progress, dup, 0 );

  828. 

  829. if ( timeline->total_capture_xruns() )

  830. 	capture_buffer_progress->selection_color( FL_RED );

  831. 

  832. if ( timeline->total_playback_xruns() )

  833. 	playback_buffer_progress->selection_color( FL_RED );

  834. 

  835. static char stats[100];

  836. 

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

  838. {

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

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

  841. 	engine->xruns() );

  842. }

  843. else

  844. {

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

  846. }

  847. 

  848. stats_box->label( stats );

  849. 

  850. static bool zombie = false;

  851. 

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

  853. {

  854. 	zombie = true;

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

  856. }

  857. 

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

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

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

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

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

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

  864. 

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

  866. {

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

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

  869. }

  870. 

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

  872.   }

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

  874.   } {

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

  876. 

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

  878.   }

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

  880.   } {

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

  882.   }

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

  884.   } {

  885.     code {Fl_Menu_ *o = menubar;

  886. 

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

  888.   }

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

  890.   } {

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

  892.   }

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

  894.   } {

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

  896. {

  897. 	timeline->hide();

  898. 	progress->show();

  899. }

  900. else if ( 0 == p )

  901. {

  902. 	timeline->show();

  903. 	progress->hide();

  904. }

  905. 

  906. static char pat[10];

  907. 

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

  909. update_progress( progress, pat, p );

  910. 

  911. progress->redraw();

  912. 

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

  914.   }

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

  916.   } {

  917.     code {char pat[256];

  918. 

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

  920. 

  921. open_url( pat );} {}

  922.   }

  923. } 

  924. 

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

  926. } {

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

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

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

  930. } 

  931. 

  932. class Project_Info_Dialog {open

  933. } {

  934.   Function {Project_Info_Dialog()} {open

  935.   } {

  936.     code {make_window();} {}

  937.   }

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

  939.   } {

  940.     code {window->show();

  941. 

  942. while ( window->shown() )

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

  944.   }

  945.   Function {make_window()} {open

  946.   } {

  947.     Fl_Window window {

  948.       label {Project info}

  949.       callback {o->hide();

  950. 

  951. if ( logo_box->image() )

  952. {

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

  954. 	logo_box->image( NULL );

  955. }} open

  956.       private xywh {761 214 520 775} type Double modal visible

  957.     } {

  958.       Fl_Value_Output {} {

  959.         label {Sample Rate}

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

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

  962.       }

  963.       Fl_Output {} {

  964.         label {Size of Journal}

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

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

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

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

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

  970.       }

  971.       Fl_Output {} {

  972.         label {Created On}

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

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

  975.       }

  976.       Fl_Output {} {

  977.         label Length

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

  979.         code0 {char pat[40];}

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

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

  982.       }

  983.       Fl_Value_Output {} {

  984.         label Tracks

  985.         xywh {200 130 55 25} align 1

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

  987.       }

  988.       Fl_Box logo_box {

  989.         label {<LOGO>}

  990.         private xywh {20 173 485 268} color 53 labelfont 1 labelsize 18 align 16

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

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

  993.       }

  994.       Fl_Text_Editor notes_field {

  995.         label {Notes:}

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

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

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

  999.       }

  1000.       Fl_Button {} {

  1001.         label {&Save}

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

  1003. 

  1004. window->do_callback();}

  1005.         xywh {420 735 74 25}

  1006.       }

  1007.       Fl_Box {} {

  1008.         label {Project Info}

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

  1010.       }

  1011.       Fl_Box {} {

  1012.         label {Project Info}

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

  1014.       }

  1015.       Fl_Button {} {

  1016.         label {&Discard}

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

  1018.         xywh {330 735 74 25}

  1019.       }

  1020.       Fl_Output {} {

  1021.         label {Last Modified On}

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

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

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

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

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

  1027.       }

  1028.     }

  1029.   }

  1030. }