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

1153 lines
32KB
Raw Blame History 

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

  2. version 1.0110 

  3. header_name {.H} 

  4. code_name {.C}

  5. comment {//

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

  7. //

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

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

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

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

  12. //

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

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

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

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

  17. //

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

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

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

  21. //

  22. } {in_source in_header

  23. } 

  24. 

  25. decl {const float STATUS_UPDATE_FREQ = 0.5f;} {} 

  26. 

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

  28. 

  29. decl {\#include "Fl_Menu_Settings.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 "Track.H" // for capture_format} {} 

  43. 

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

  45. 

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

  47. 

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

  49. 

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

  51. 

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

  53. 

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

  55. 

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

  57. 

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

  59. 

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

  61. 

  62. decl {class About_Dialog;} {} 

  63. 

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

  65. } 

  66. 

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

  68. } 

  69. 

  70. decl {extern LASH_Engine *lash;} {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. Fl::get_system_colors();

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

  155. 

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

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

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

  159. 

  160. // constrain window to size of screen.

  161. {

  162.         int sx, sy, sw, sh;

  163. 

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

  165. 

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

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

  168. 

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

  170.              main_window->h() > sh )

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

  172. }

  173. 

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

  175. 

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

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

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

  179. fl_message_font( FL_HELVETICA, 18 );

  180. 

  181. 

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

  183. 

  184. Audio_File::all_supported_formats( formats );

  185. 

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

  187. {

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

  189. //;

  190. 	char pat[256];

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

  192. 

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

  194. }

  195. 

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

  197. 

  198. char *path;

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

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

  201. free( path );

  202. 

  203. 

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

  205. 

  206. 

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

  208. {

  209. 	char path[512];

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

  211. 

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

  213. }

  214. 

  215. 

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

  217.   }

  218.   Function {make_window()} {open

  219.   } {

  220.     Fl_Window main_window {

  221.       label Timeline

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

  223. 	o->hide();} open

  224.       private xywh {102 111 1025 770} type Double resizable xclass Non_DAW visible

  225.     } {

  226.       Fl_Menu_Bar menubar {open

  227.         private xywh {0 0 1024 25}

  228.       } {

  229.         Submenu {} {

  230.           label {&Project} open

  231.           xywh {0 0 74 25}

  232.         } {

  233.           MenuItem {} {

  234.             label {&Info}

  235.             callback {Project_Info_Dialog pi;

  236. 

  237. pi.run();}

  238.             xywh {0 0 40 25} deactivate

  239.           }

  240.           Submenu {} {

  241.             label {Se&ttings} open

  242.             xywh {20 20 74 25}

  243.           } {

  244.             MenuItem {} {

  245.               label {&Follow Playhead}

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

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

  248.             }

  249.             MenuItem {} {

  250.               label {&Center Playhead}

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

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

  253.             }

  254.             Submenu {} {

  255.               label {&Snap to} open

  256.               xywh {20 20 74 25}

  257.             } {

  258.               MenuItem {} {

  259.                 label Bars

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

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

  262.               }

  263.               MenuItem {} {

  264.                 label Beats

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

  266.                 xywh {30 30 40 25} type Radio

  267.               }

  268.               MenuItem {} {

  269.                 label Off

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

  271.                 xywh {40 40 40 25} type Radio

  272.               }

  273.             }

  274.             MenuItem {} {

  275.               label {Magnetic snap}

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

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

  278.             }

  279.             Submenu {} {

  280.               label {Capture Format} open

  281.               xywh {20 20 74 25}

  282.             } {}

  283.           }

  284.           MenuItem {} {

  285.             label {&New}

  286.             callback {save_timeline_settings();

  287. 

  288. new_project_chooser();

  289. 

  290. load_timeline_settings();

  291. 

  292. update_menu();

  293. 

  294. main_window->redraw();}

  295.             xywh {0 0 40 25}

  296.           }

  297.           MenuItem {} {

  298.             label {&Open}

  299.             callback {char *path;

  300. 

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

  302. 

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

  304. 

  305. free( path );

  306. 

  307. open( name );}

  308.             xywh {10 10 40 25}

  309.           }

  310.           MenuItem {} {

  311.             label {&Compact}

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

  313. 

  314. if ( n != 2 )

  315. 	return;

  316. 	

  317. Project::compact();}

  318.             xywh {20 20 40 25}

  319.           }

  320.           Submenu {} {

  321.             label {&Export} open

  322.             xywh {0 0 74 25} deactivate

  323.           } {

  324.             MenuItem {} {

  325.               label Project

  326.               xywh {0 0 40 25}

  327.             }

  328.             MenuItem {} {

  329.               label Range

  330.               xywh {10 10 40 25}

  331.             }

  332.           }

  333.           MenuItem {} {

  334.             label {&Quit}

  335.             callback {quit()}

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

  337.           }

  338.         }

  339.         Submenu {} {

  340.           label {&Edit} open

  341.           xywh {0 0 74 25}

  342.         } {

  343.           MenuItem {} {

  344.             label Undo

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

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

  347.           }

  348.           MenuItem {} {

  349.             label {Select None}

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

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

  352.           }

  353.           MenuItem {} {

  354.             label {Delete  Selected}

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

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

  357.           }

  358.         }

  359.         Submenu {} {

  360.           label T&ransport open

  361.           xywh {0 0 74 25}

  362.         } {

  363.           MenuItem {} {

  364.             label Start

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

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

  367.           }

  368.           MenuItem {} {

  369.             label End

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

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

  372.           }

  373.           MenuItem {} {

  374.             label {Play/Stop}

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

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

  377.           }

  378.           MenuItem {} {

  379.             label Record

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

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

  382.           }

  383.         }

  384.         MenuItem {} {

  385.           label {&Timeline}

  386.           xywh {0 0 40 25}

  387.         }

  388.         Submenu {} {

  389.           label {&View} open

  390.           xywh {0 0 74 25}

  391.         } {

  392.           Submenu {} {

  393.             label {&Zoom} open

  394.             xywh {0 0 74 25}

  395.           } {

  396.             MenuItem {} {

  397.               label {&In}

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

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

  400.             }

  401.             MenuItem {} {

  402.               label {&Out}

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

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

  405.             }

  406.             MenuItem {} {

  407.               label {&Fit}

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

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

  410.             }

  411.             MenuItem {} {

  412.               label {1 sec.}

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

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

  415.             }

  416.             MenuItem {} {

  417.               label {1 min.}

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

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

  420.             }

  421.             MenuItem {} {

  422.               label {1 hour.}

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

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

  425.             }

  426.           }

  427.         }

  428.         Submenu {} {

  429.           label {&Options} open

  430.           xywh {0 0 74 25} divider

  431.         } {

  432.           Submenu {} {

  433.             label {&Display} open

  434.             xywh {10 10 74 25}

  435.           } {

  436.             Submenu {} {

  437.               label {&Timeline} open

  438.               xywh {10 10 74 25}

  439.             } {

  440.               MenuItem {} {

  441.                 label {&Measure lines}

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

  443. 

  444. timeline->redraw();}

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

  446.               }

  447.             }

  448.             Submenu {} {

  449.               label {&Waveform} open

  450.               xywh {10 10 74 25}

  451.             } {

  452.               MenuItem {} {

  453.                 label Fill

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

  455. 

  456. timeline->redraw();}

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

  458.               }

  459.               MenuItem {} {

  460.                 label Outline

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

  462. 

  463. timeline->redraw();}

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

  465.               }

  466.               MenuItem {} {

  467.                 label {Vary color}

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

  469. 

  470. timeline->redraw();}

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

  472.               }

  473.             }

  474.             Submenu {} {

  475.               label {&Region} open

  476.               xywh {10 10 74 25}

  477.             } {

  478.               MenuItem {} {

  479.                 label {Filled fades}

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

  481.               }

  482.               MenuItem {} {

  483.                 label {Inherit track color}

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

  485. 

  486. timeline->redraw();}

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

  488.               }

  489.             }

  490.             Submenu {} {

  491.               label {&Control Sequence} open

  492.               xywh {10 10 74 25}

  493.             } {

  494.               MenuItem {} {

  495.                 label Polygon

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

  497. 

  498. timeline->redraw();}

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

  500.               }

  501.               MenuItem {} {

  502.                 label Graded

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

  504. 

  505. timeline->redraw();}

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

  507.               }

  508.               MenuItem {} {

  509.                 label Ruled

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

  511. 

  512. timeline->redraw();}

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

  514.               }

  515.             }

  516.             Submenu {} {

  517.               label {&Style} open

  518.               xywh {10 10 74 25}

  519.             } {

  520.               MenuItem {} {

  521.                 label Default

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

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

  524.               }

  525.               MenuItem {} {

  526.                 label Flat

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

  528.                 xywh {20 20 40 25} type Radio

  529.               }

  530.             }

  531.             Submenu {} {

  532.               label {C&olors} open

  533.               xywh {10 10 74 25}

  534.             } {

  535.               MenuItem {} {

  536.                 label System

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

  538. 

  539. unsigned char r, g, b;

  540. 

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

  542. 

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

  544. 

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

  546. 

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

  548. 

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

  550. 

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

  552. 

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

  554.                 xywh {10 10 40 25} type Radio

  555.               }

  556.               MenuItem {} {

  557.                 label Dark

  558.                 callback {Fl::background2( 100, 100, 100 );

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

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

  561. 

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

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

  564.               }

  565.               MenuItem {} {

  566.                 label Light

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

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

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

  570. 

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

  572.                 xywh {30 30 40 25} type Radio

  573.               }

  574.             }

  575.           }

  576.           Submenu {} {

  577.             label {&Behavior} open

  578.             xywh {0 0 74 25}

  579.           } {

  580.             Submenu {} {

  581.               label {&Transport} open

  582.               xywh {0 0 74 25}

  583.             } {

  584.               MenuItem {} {

  585.                 label {Stop Disables Record}

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

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

  588.               }

  589.             }

  590.           }

  591.         }

  592.         Submenu {} {

  593.           label {&Help} open

  594.           xywh {0 0 74 25}

  595.         } {

  596.           MenuItem {} {

  597.             label {&Manual}

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

  599.             xywh {10 10 40 25} divider

  600.           }

  601.           MenuItem {} {

  602.             label {&About}

  603.             callback {About_Dialog ab;

  604. 

  605. ab.run();}

  606.             xywh {0 0 40 25}

  607.           }

  608.         }

  609.       }

  610.       Fl_Group {} {open

  611.         xywh {0 1 1025 73}

  612.       } {

  613.         Fl_Pack {} {open

  614.           xywh {0 23 483 46} type HORIZONTAL

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

  616.         } {

  617.           Fl_Box {} {

  618.             label {<Transport>}

  619.             xywh {5 23 189 46} color 30

  620.             code0 {transport = o;}

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

  622.             class Transport

  623.           }

  624.           Fl_Pack clocks_pack {

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

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

  627.           } {

  628.             Fl_Box {} {

  629.               label PLAYHEAD

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

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

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

  633.               class Clock

  634.             }

  635.             Fl_Box {} {

  636.               label PLAYHEAD

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

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

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

  640.               class Clock

  641.             }

  642.           }

  643.         }

  644.         Fl_Box {} {

  645.           label {<empty>}

  646.           xywh {487 27 203 42} resizable

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

  648.         }

  649.         Fl_Group {} {open

  650.           xywh {745 26 280 44}

  651.         } {

  652.           Fl_Box {} {

  653.             label {capture:}

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

  655.           }

  656.           Fl_Box {} {

  657.             label {playback:}

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

  659.           }

  660.           Fl_Box {} {

  661.             label {DSP:}

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

  663.           }

  664.           Fl_Progress capture_buffer_progress {

  665.             label {50%}

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

  667.           }

  668.           Fl_Progress cpu_load_progress {

  669.             label {50%}

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

  671.           }

  672.           Fl_Progress playback_buffer_progress {

  673.             label {50%}

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

  675.           }

  676.           Fl_Box {} {

  677.             label {disk:}

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

  679.           }

  680.           Fl_Progress disk_usage_progress {

  681.             label {50%}

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

  683.           }

  684.         }

  685.         Fl_Button solo_blinker {

  686.           label SOLO

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

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

  689.           class Fl_Blinker

  690.         }

  691.         Fl_Button rec_blinker {

  692.           label REC

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

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

  695.           class Fl_Blinker

  696.         }

  697.         Fl_Button lash_blinker {

  698.           label LASH

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

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

  701.           class Fl_Blinker

  702.         }

  703.         Fl_Button selected_blinker {

  704.           label SEL

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

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

  707.           class Fl_Blinker

  708.         }

  709.         Fl_Box stats_box {

  710.           label {<stats>}

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

  712.         }

  713.       }

  714.       Fl_Progress progress {

  715.         label {0%}

  716.         private xywh {15 394 995 41} hide

  717.       }

  718.       Fl_Box {} {

  719.         label {<Timeline>}

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

  721.         code0 {timeline = o;}

  722.         class Timeline

  723.       }

  724.       Fl_Box project_name {

  725.         label {<project name>}

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

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

  728.       }

  729.     }

  730.   }

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

  732.   } {

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

  734.   }

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

  736.   } {

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

  738.   }

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

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

  741.   Function {update_menu()} {private

  742.   } {

  743.     code {Fl_Menu_Bar *m = menubar;

  744. 

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

  746. {

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

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

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

  750. 	

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

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

  753. 

  754. 	timeline->deactivate();

  755. 	transport->deactivate();

  756. }

  757. else

  758. {

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

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

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

  762. 

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

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

  765. 	

  766. 	timeline->activate();

  767. 	transport->activate();	

  768. }

  769. 

  770. m->redraw();

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

  772.   }

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

  774.   } {

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

  776. 

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

  778. 

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

  780.   }

  781.   Function {update_status()} {open private

  782.   } {

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

  784. 

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

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

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

  788. 

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

  790. 

  791. if ( timeline->total_capture_xruns() )

  792. 	capture_buffer_progress->selection_color( FL_RED );

  793. 

  794. if ( timeline->total_playback_xruns() )

  795. 	playback_buffer_progress->selection_color( FL_RED );

  796. 

  797. static char stats[100];

  798. 

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

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

  801. 	engine->xruns() );

  802. 

  803. stats_box->label( stats );

  804. 

  805. static bool zombie = false;

  806. 

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

  808. {

  809. 	zombie = true;

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

  811. }

  812. 

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

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

  815. lash_blinker->value( lash->enabled() );

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

  817.   }

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

  819.   } {

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

  821. 

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

  823.   }

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

  825.   } {

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

  827.   }

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

  829.   } {

  830.     code {Fl_Menu_ *o = menubar;

  831. 

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

  833.   }

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

  835.   } {

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

  837.   }

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

  839.   } {

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

  841. {

  842. 	timeline->hide();

  843. 	progress->show();

  844. }

  845. else if ( 0 == p )

  846. {

  847. 	timeline->show();

  848. 	progress->hide();

  849. }

  850. 

  851. static char pat[10];

  852. 

  853. update_progress( progress, pat, p );

  854. 

  855. progress->redraw();

  856. 

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

  858.   }

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

  860.   } {

  861.     code {char pat[256];

  862. 

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

  864. 

  865. open_url( pat );} {}

  866.   }

  867. } 

  868. 

  869. class New_Project_Dialog {open

  870. } {

  871.   Function {New_Project_Dialog()} {open

  872.   } {

  873.     code {make_window();} {}

  874.   }

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

  876.   } {

  877.     code {_window->show();

  878. 

  879. while ( _window->shown() )

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

  881.   }

  882.   Function {make_window()} {open

  883.   } {

  884.     Fl_Window _window {

  885.       label {New Project} open

  886.       xywh {615 414 550 195} type Double modal xclass Non_DAW visible

  887.     } {

  888.       Fl_File_Input _name {

  889.         label {Named:}

  890.         xywh {75 140 375 35}

  891.       }

  892.       Fl_Button {} {

  893.         label Browse

  894.         callback {_directory->value( fl_dir_chooser( "Directory for new project", NULL, 0 ) );}

  895.         xywh {455 100 80 35}

  896.       }

  897.       Fl_Return_Button {} {

  898.         label Create

  899.         callback {if ( strlen( _directory->value() ) && strlen( _name->value() ) )

  900. {

  901. 	char pat[512];

  902. 	

  903. 	snprintf( pat, sizeof( pat ), "%s/%s", _directory->value(), _name->value() );

  904. 

  905. 	if ( ! Project::create( pat, _template->text( _template->value() ) ) )

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

  907. 

  908. 	_window->hide();

  909. }}

  910.         xywh {455 140 80 35}

  911.       }

  912.       Fl_File_Input _directory {

  913.         label {Where:}

  914.         callback {if ( ! fl_filename_isdir( o->value() ) )

  915. {

  916. 	fl_alert( "Must be a directory" );

  917. 	o->value( "" );

  918. 	return;

  919. }

  920. 

  921. write_line( user_config_dir, "default_path", o->value() );}

  922.         xywh {75 100 375 35}

  923.         code0 {\#include <FL/filename.H>}

  924.         code1 {char *v;}

  925.         code2 {read_line( user_config_dir, "default_path", &v );}

  926.         code3 {o->value( v );}

  927.       }

  928.       Fl_Box {} {

  929.         label {New Project}

  930.         xywh {15 8 520 33} box RSHADOW_BOX color 133 labelsize 20 labelcolor 32

  931.       }

  932.       Fl_Choice _template {

  933.         label {Template:}

  934.         private xywh {310 60 225 25} down_box BORDER_BOX

  935.       } {

  936.         MenuItem {} {

  937.           label Default

  938.           xywh {0 0 40 25}

  939.         }

  940.       }

  941.     }

  942.   }

  943. } 

  944. 

  945. Function {new_project_chooser()} {C return_type void

  946. } {

  947.   code {New_Project_Dialog nsd;

  948. 

  949. nsd.run();} {}

  950. } 

  951. 

  952. class Project_Info_Dialog {open

  953. } {

  954.   Function {Project_Info_Dialog()} {open

  955.   } {

  956.     code {make_window();} {}

  957.   }

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

  959.   } {

  960.     code {window->show();

  961. 

  962. while ( window->shown() )

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

  964.   }

  965.   Function {make_window()} {open

  966.   } {

  967.     Fl_Window window {

  968.       label {Project info}

  969.       callback {o->hide();

  970. 

  971. if ( logo_box->image() )

  972. {

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

  974. 	logo_box->image( NULL );

  975. }} open

  976.       private xywh {649 226 520 740} type Double modal visible

  977.     } {

  978.       Fl_Value_Output {} {

  979.         label {Sample Rate}

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

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

  982.       }

  983.       Fl_Output {} {

  984.         label {Size of Journal}

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

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

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

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

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

  990.       }

  991.       Fl_Output {} {

  992.         label {Created On}

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

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

  995.       }

  996.       Fl_Output {} {

  997.         label Length

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

  999.         code0 {char pat[40];}

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

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

  1002.       }

  1003.       Fl_Value_Output {} {

  1004.         label Tracks

  1005.         xywh {200 130 55 25} align 1

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

  1007.       }

  1008.       Fl_Box logo_box {

  1009.         label {<LOGO>}

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

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

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

  1013.       }

  1014.       Fl_Text_Editor notes_field {

  1015.         label {Notes:}

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

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

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

  1019.       }

  1020.       Fl_Button {} {

  1021.         label {&Save}

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

  1023. 

  1024. window->do_callback();}

  1025.         xywh {425 700 74 25}

  1026.       }

  1027.       Fl_Box {} {

  1028.         label {Project Info}

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

  1030.       }

  1031.       Fl_Box {} {

  1032.         label {Project Info}

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

  1034.       }

  1035.       Fl_Button {} {

  1036.         label {&Discard}

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

  1038.         xywh {330 700 74 25}

  1039.       }

  1040.       Fl_Output {} {

  1041.         label {Last Modified On}

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

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

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

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

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

  1047.       }

  1048.     }

  1049.   }

  1050. } 

  1051. 

  1052. class About_Dialog {open

  1053. } {

  1054.   Function {About_Dialog()} {open

  1055.   } {

  1056.     code {make_window();} {}

  1057.   }

  1058.   Function {run()} {return_type void

  1059.   } {

  1060.     code {window->show();

  1061. 

  1062. while ( window->shown() )

  1063. 	Fl::wait();

  1064. 	

  1065. delete window;} {}

  1066.   }

  1067.   Function {make_window()} {open private

  1068.   } {

  1069.     Fl_Window window {

  1070.       label About

  1071.       callback {o->hide();

  1072. 

  1073. if ( logo_box->image() )

  1074. {

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

  1076. 	logo_box->image( NULL );

  1077. }} open

  1078.       private xywh {349 201 495 655} type Double xclass {Non-DAW} visible

  1079.     } {

  1080.       Fl_Tabs {} {open

  1081.         xywh {0 264 497 392}

  1082.       } {

  1083.         Fl_Group {} {

  1084.           label Credits open

  1085.           xywh {2 293 492 362}

  1086.         } {

  1087.           Fl_Box {} {

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

  1089.  Jonathan Moore Liles for his own use

  1090.  (see the manual).

  1091. 

  1092. Nobody planned. Nobody helped.

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

  1094. and/or replacing the rest of Linux Audio

  1095. with fast, light, reliable alternatives.}

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

  1097.           }

  1098.         }

  1099.         Fl_Group {} {

  1100.           label License open

  1101.           xywh {2 288 492 311} hide

  1102.         } {

  1103.           Fl_Box {} {

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

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

  1106.           }

  1107.           Fl_Box {} {

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

  1109. 

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

  1111. 

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

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

  1114.           }

  1115.         }

  1116.       }

  1117.       Fl_Box logo_box {

  1118.         label VERSION

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

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

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

  1122.       }

  1123.       Fl_Return_Button {} {

  1124.         label Rock

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

  1126.         xywh {400 614 76 30}

  1127.       }

  1128.       Fl_Button {} {

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

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

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

  1132.       }

  1133.       Fl_Box {} {

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

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

  1136.       }

  1137.     }

  1138.   }

  1139. } 

  1140. 

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

  1142. } {

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

  1144. 	

  1145. 	// FIXME: got a better idea?

  1146. 	char cmd[256];

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

  1148. 	system( cmd );

  1149. \#else

  1150. 	fl_open_uri( url );

  1151. \#endif} {}

  1152. }