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

1099 lines
30KB
Raw Blame History 

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

  2. version 1.0108 

  3. header_name {.H} 

  4. code_name {.C}

  5. comment {//

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

  7. //

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

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

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

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

  12. //

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

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

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

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

  17. //

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

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

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

  21. //

  22. } {in_source in_header

  23. } 

  24. 

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

  26. 

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

  28. 

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

  30. 

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

  32. 

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

  34. 

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

  36. 

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

  38. } 

  39. 

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

  41. 

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

  43. 

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

  45. 

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

  47. 

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

  49. 

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

  51. 

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

  53. 

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

  55. 

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

  57. 

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

  59. 

  60. decl {class About_Dialog;} {} 

  61. 

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

  63. } 

  64. 

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

  66. } 

  67. 

  68. class TLE {open

  69. } {

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

  71.   Function {save()} {} {

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

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

  74. 

  75. // save options

  76. 

  77. char *path;

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

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

  80. free( path );} {}

  81.   }

  82.   Function {quit()} {} {

  83.     code {Project::close();

  84. 

  85. save();

  86. 

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

  88.   }

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

  90.     code {if ( ! name )

  91. 	return;

  92. 

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

  94. 

  95. if ( r < 0 )

  96. {

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

  98. 	

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

  100. }} {}

  101.   }

  102.   Function {save_timeline_settings()} {open

  103.   } {

  104.     code {if ( Project::open() )

  105. {

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

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

  108. 	

  109. 

  110. 	char path[256];

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

  112. 

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

  114. }} {}

  115.   }

  116.   Function {load_timeline_settings()} {open

  117.   } {

  118.     code {if ( Project::open() )

  119. {

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

  121. }

  122. 

  123. 

  124. update_menu();

  125. 

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

  127.   }

  128.   Function {run()} {} {

  129.     code {update_menu();

  130. 

  131. main_window->show();

  132. 

  133. Fl::lock();

  134. 

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

  136.   }

  137.   Function {TLE()} {open

  138.   } {

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

  140. 

  141. make_window();

  142. 

  143. 	

  144. Fl::visible_focus( 0 );

  145. 

  146. Fl::get_system_colors();

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

  148. 

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

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

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

  152. 

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

  154. 

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

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

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

  158. fl_message_font( FL_HELVETICA, 18 );

  159. 

  160. 

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

  162. 

  163. Audio_File::all_supported_formats( formats );

  164. 

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

  166. {

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

  168. //;

  169. 	char pat[256];

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

  171. 

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

  173. }

  174. 

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

  176. 

  177. char *path;

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

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

  180. free( path );

  181. 

  182. 

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

  184. 

  185. 

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

  187. {

  188. 	char path[512];

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

  190. 

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

  192. }

  193. 

  194. 

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

  196.   }

  197.   Function {make_window()} {open

  198.   } {

  199.     Fl_Window main_window {

  200.       label Timeline

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

  202. 	o->hide();} open

  203.       private xywh {133 113 1025 770} type Double resizable xclass Non_DAW visible

  204.     } {

  205.       Fl_Menu_Bar menubar {open

  206.         private xywh {0 0 1024 25}

  207.       } {

  208.         Submenu {} {

  209.           label {&Project} open

  210.           xywh {0 0 74 25}

  211.         } {

  212.           MenuItem {} {

  213.             label {&Info}

  214.             callback {Project_Info_Dialog pi;

  215. 

  216. pi.run();}

  217.             xywh {0 0 40 25} deactivate

  218.           }

  219.           Submenu {} {

  220.             label {Se&ttings} open

  221.             xywh {20 20 74 25}

  222.           } {

  223.             MenuItem {} {

  224.               label {&Follow Playhead}

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

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

  227.             }

  228.             MenuItem {} {

  229.               label {&Center Playhead}

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

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

  232.             }

  233.             Submenu {} {

  234.               label {&Snap to} open

  235.               xywh {20 20 74 25}

  236.             } {

  237.               MenuItem {} {

  238.                 label Bars

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

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

  241.               }

  242.               MenuItem {} {

  243.                 label Beats

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

  245.                 xywh {30 30 40 25} type Radio

  246.               }

  247.               MenuItem {} {

  248.                 label Off

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

  250.                 xywh {40 40 40 25} type Radio

  251.               }

  252.             }

  253.             MenuItem {} {

  254.               label {Magnetic snap}

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

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

  257.             }

  258.             Submenu {} {

  259.               label {Capture Format} open

  260.               xywh {20 20 74 25}

  261.             } {}

  262.           }

  263.           MenuItem {} {

  264.             label {&New}

  265.             callback {save_timeline_settings();

  266. 

  267. new_project_chooser();

  268. 

  269. load_timeline_settings();

  270. 

  271. update_menu();

  272. 

  273. main_window->redraw();}

  274.             xywh {0 0 40 25}

  275.           }

  276.           MenuItem {} {

  277.             label {&Open}

  278.             callback {char *path;

  279. 

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

  281. 

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

  283. 

  284. free( path );

  285. 

  286. open( name );}

  287.             xywh {10 10 40 25}

  288.           }

  289.           MenuItem {} {

  290.             label {&Compact}

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

  292. 

  293. if ( n != 2 )

  294. 	return;

  295. 	

  296. Project::compact();}

  297.             xywh {20 20 40 25}

  298.           }

  299.           Submenu {} {

  300.             label {&Export} open

  301.             xywh {0 0 74 25} deactivate

  302.           } {

  303.             MenuItem {} {

  304.               label Project

  305.               xywh {0 0 40 25}

  306.             }

  307.             MenuItem {} {

  308.               label Range

  309.               xywh {10 10 40 25}

  310.             }

  311.           }

  312.           MenuItem {} {

  313.             label {&Quit}

  314.             callback {quit()}

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

  316.           }

  317.         }

  318.         Submenu {} {

  319.           label {&Edit} open

  320.           xywh {0 0 74 25}

  321.         } {

  322.           MenuItem {} {

  323.             label Undo

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

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

  326.           }

  327.           MenuItem {} {

  328.             label {Select None}

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

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

  331.           }

  332.           MenuItem {} {

  333.             label {Delete  Selected}

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

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

  336.           }

  337.         }

  338.         Submenu {} {

  339.           label Transport open

  340.           xywh {0 0 74 25}

  341.         } {

  342.           MenuItem {} {

  343.             label Start

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

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

  346.           }

  347.           MenuItem {} {

  348.             label End

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

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

  351.           }

  352.           MenuItem {} {

  353.             label {Play/Stop}

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

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

  356.           }

  357.           MenuItem {} {

  358.             label Record

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

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

  361.           }

  362.         }

  363.         MenuItem {} {

  364.           label {&Timeline}

  365.           xywh {0 0 40 25}

  366.         }

  367.         Submenu {} {

  368.           label {&View} open

  369.           xywh {0 0 74 25}

  370.         } {

  371.           Submenu {} {

  372.             label {&Zoom} open

  373.             xywh {0 0 74 25}

  374.           } {

  375.             MenuItem {} {

  376.               label {&In}

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

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

  379.             }

  380.             MenuItem {} {

  381.               label {&Out}

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

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

  384.             }

  385.             MenuItem {} {

  386.               label {&Fit}

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

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

  389.             }

  390.             MenuItem {} {

  391.               label {1 sec.}

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

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

  394.             }

  395.             MenuItem {} {

  396.               label {1 min.}

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

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

  399.             }

  400.             MenuItem {} {

  401.               label {1 hour.}

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

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

  404.             }

  405.           }

  406.         }

  407.         Submenu {} {

  408.           label {&Options} open

  409.           xywh {0 0 74 25} divider

  410.         } {

  411.           Submenu {} {

  412.             label {&Display} open

  413.             xywh {10 10 74 25}

  414.           } {

  415.             Submenu {} {

  416.               label {&Timeline} open

  417.               xywh {10 10 74 25}

  418.             } {

  419.               MenuItem {} {

  420.                 label {&Measure lines}

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

  422. 

  423. timeline->redraw();}

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

  425.               }

  426.             }

  427.             Submenu {} {

  428.               label {&Waveform} open

  429.               xywh {10 10 74 25}

  430.             } {

  431.               MenuItem {} {

  432.                 label Fill

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

  434. 

  435. timeline->redraw();}

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

  437.               }

  438.               MenuItem {} {

  439.                 label Outline

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

  441. 

  442. timeline->redraw();}

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

  444.               }

  445.               MenuItem {} {

  446.                 label {Vary color}

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

  448. 

  449. timeline->redraw();}

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

  451.               }

  452.             }

  453.             Submenu {} {

  454.               label {&Region} open

  455.               xywh {10 10 74 25}

  456.             } {

  457.               MenuItem {} {

  458.                 label {Filled fades}

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

  460.               }

  461.               MenuItem {} {

  462.                 label {Inherit track color}

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

  464. 

  465. timeline->redraw();}

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

  467.               }

  468.             }

  469.             Submenu {} {

  470.               label {&Control Sequence} open

  471.               xywh {10 10 74 25}

  472.             } {

  473.               MenuItem {} {

  474.                 label Polygon

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

  476. 

  477. timeline->redraw();}

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

  479.               }

  480.               MenuItem {} {

  481.                 label Graded

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

  483. 

  484. timeline->redraw();}

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

  486.               }

  487.               MenuItem {} {

  488.                 label Ruled

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

  490. 

  491. timeline->redraw();}

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

  493.               }

  494.             }

  495.             Submenu {} {

  496.               label {&Style} open

  497.               xywh {10 10 74 25}

  498.             } {

  499.               MenuItem {} {

  500.                 label Default

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

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

  503.               }

  504.               MenuItem {} {

  505.                 label Flat

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

  507.                 xywh {20 20 40 25} type Radio

  508.               }

  509.             }

  510.             Submenu {} {

  511.               label {C&olors} open

  512.               xywh {10 10 74 25}

  513.             } {

  514.               MenuItem {} {

  515.                 label System

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

  517. 

  518. unsigned char r, g, b;

  519. 

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

  521. 

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

  523. 

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

  525. 

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

  527. 

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

  529. 

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

  531. 

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

  533.                 xywh {10 10 40 25} type Radio

  534.               }

  535.               MenuItem {} {

  536.                 label Dark

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

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

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

  540. 

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

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

  543.               }

  544.               MenuItem {} {

  545.                 label Light

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

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

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

  549. 

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

  551.                 xywh {30 30 40 25} type Radio

  552.               }

  553.             }

  554.           }

  555.         }

  556.         Submenu {} {

  557.           label {&Help} open

  558.           xywh {0 0 74 25}

  559.         } {

  560.           MenuItem {} {

  561.             label {&Manual}

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

  563.             xywh {10 10 40 25} divider

  564.           }

  565.           MenuItem {} {

  566.             label {&About}

  567.             callback {About_Dialog ab;

  568. 

  569. ab.run();}

  570.             xywh {0 0 40 25}

  571.           }

  572.         }

  573.       }

  574.       Fl_Group {} {open

  575.         xywh {0 23 1025 51}

  576.       } {

  577.         Fl_Pack {} {open

  578.           xywh {0 23 483 46} type HORIZONTAL

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

  580.         } {

  581.           Fl_Box {} {

  582.             label {<Transport>}

  583.             xywh {5 23 189 46} color 30

  584.             code0 {transport = o;}

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

  586.             class Transport

  587.           }

  588.           Fl_Pack clocks_pack {

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

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

  591.           } {

  592.             Fl_Box {} {

  593.               label PLAYHEAD

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

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

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

  597.               class Clock

  598.             }

  599.             Fl_Box {} {

  600.               label PLAYHEAD

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

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

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

  604.               class Clock

  605.             }

  606.           }

  607.         }

  608.         Fl_Box {} {

  609.           label {<empty>} selected

  610.           xywh {487 27 258 42} resizable

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

  612.         }

  613.         Fl_Group {} {open

  614.           xywh {745 26 280 44}

  615.         } {

  616.           Fl_Box {} {

  617.             label {capture:}

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

  619.           }

  620.           Fl_Box {} {

  621.             label {playback:}

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

  623.           }

  624.           Fl_Box {} {

  625.             label {DSP:}

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

  627.           }

  628.           Fl_Progress capture_buffer_progress {

  629.             label {50%}

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

  631.           }

  632.           Fl_Progress cpu_load_progress {

  633.             label {50%}

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

  635.           }

  636.           Fl_Progress playback_buffer_progress {

  637.             label {50%}

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

  639.           }

  640.           Fl_Box {} {

  641.             label {disk:}

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

  643.           }

  644.           Fl_Progress disk_usage_progress {

  645.             label {50%}

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

  647.           }

  648.         }

  649.         Fl_Button solo_blinker {

  650.           label SOLO

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

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

  653.           class Fl_Blinker

  654.         }

  655.         Fl_Button rec_blinker {

  656.           label REC

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

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

  659.           class Fl_Blinker

  660.         }

  661.       }

  662.       Fl_Progress progress {

  663.         label {0%}

  664.         private xywh {15 394 995 41} hide

  665.       }

  666.       Fl_Box {} {

  667.         label {<Timeline>}

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

  669.         code0 {timeline = o;}

  670.         class Timeline

  671.       }

  672.       Fl_Box project_name {

  673.         label {<project name>}

  674.         private xywh {450 0 475 22} labeltype SHADOW_LABEL labelfont 2

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

  676.       }

  677.       Fl_Value_Output xruns_output {

  678.         label {xruns:}

  679.         private xywh {980 2 44 20} maximum 40000 step 1

  680.       }

  681.     }

  682.   }

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

  684.   } {

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

  686.   }

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

  688.   } {

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

  690.   }

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

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

  693.   Function {update_menu()} {private

  694.   } {

  695.     code {Fl_Menu_Bar *m = menubar;

  696. 

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

  698. {

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

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

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

  702. 	

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

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

  705. 

  706. 	timeline->deactivate();

  707. 	transport->deactivate();

  708. }

  709. else

  710. {

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

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

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

  714. 

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

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

  717. 	

  718. 	timeline->activate();

  719. 	transport->activate();	

  720. }

  721. 

  722. m->redraw();

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

  724.   }

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

  726.   } {

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

  728. 

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

  730. 

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

  732.   }

  733.   Function {update_status()} {open private

  734.   } {

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

  736. 

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

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

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

  740. 

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

  742. 

  743. if ( timeline->total_capture_xruns() )

  744. 	capture_buffer_progress->selection_color( FL_RED );

  745. 

  746. if ( timeline->total_playback_xruns() )

  747. 	playback_buffer_progress->selection_color( FL_RED );

  748. 

  749. 

  750. 

  751. xruns_output->value( engine->xruns() );

  752. 

  753. static bool zombie = false;

  754. 

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

  756. {

  757. 	zombie = true;

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

  759. }

  760. 

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

  762. rec_blinker->value( transport->rolling && transport->rec_enabled() );} {}

  763.   }

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

  765.   } {

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

  767. 

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

  769.   }

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

  771.   } {

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

  773.   }

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

  775.   } {

  776.     code {Fl_Menu_ *o = menubar;

  777. 

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

  779.   }

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

  781.   } {

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

  783.   }

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

  785.   } {

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

  787. {

  788. 	timeline->hide();

  789. 	progress->show();

  790. }

  791. else if ( 0 == p )

  792. {

  793. 	timeline->show();

  794. 	progress->hide();

  795. }

  796. 

  797. static char pat[10];

  798. 

  799. update_progress( progress, pat, p );

  800. 

  801. progress->redraw();

  802. 

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

  804.   }

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

  806.   } {

  807.     code {char pat[256];

  808. 

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

  810. 

  811. open_url( pat );} {}

  812.   }

  813. } 

  814. 

  815. class New_Project_Dialog {open

  816. } {

  817.   Function {New_Project_Dialog()} {open

  818.   } {

  819.     code {make_window();} {}

  820.   }

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

  822.   } {

  823.     code {_window->show();

  824. 

  825. while ( _window->shown() )

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

  827.   }

  828.   Function {make_window()} {open

  829.   } {

  830.     Fl_Window _window {

  831.       label {New Project} open

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

  833.     } {

  834.       Fl_File_Input _name {

  835.         label {Named:}

  836.         xywh {75 140 375 35}

  837.       }

  838.       Fl_Button {} {

  839.         label Browse

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

  841.         xywh {455 100 80 35}

  842.       }

  843.       Fl_Return_Button {} {

  844.         label Create

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

  846. {

  847. 	char pat[512];

  848. 	

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

  850. 

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

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

  853. 

  854. 	_window->hide();

  855. }}

  856.         xywh {455 140 80 35}

  857.       }

  858.       Fl_File_Input _directory {

  859.         label {Where:}

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

  861. {

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

  863. 	o->value( "" );

  864. 	return;

  865. }

  866. 

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

  868.         xywh {75 100 375 35}

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

  870.         code1 {char *v;}

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

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

  873.       }

  874.       Fl_Box {} {

  875.         label {New Project}

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

  877.       }

  878.       Fl_Choice _template {

  879.         label {Template:}

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

  881.       } {

  882.         MenuItem {} {

  883.           label Default

  884.           xywh {0 0 40 25}

  885.         }

  886.       }

  887.     }

  888.   }

  889. } 

  890. 

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

  892. } {

  893.   code {New_Project_Dialog nsd;

  894. 

  895. nsd.run();} {}

  896. } 

  897. 

  898. class Project_Info_Dialog {open

  899. } {

  900.   Function {Project_Info_Dialog()} {open

  901.   } {

  902.     code {make_window();} {}

  903.   }

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

  905.   } {

  906.     code {window->show();

  907. 

  908. while ( window->shown() )

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

  910.   }

  911.   Function {make_window()} {open

  912.   } {

  913.     Fl_Window window {

  914.       label {Project info}

  915.       callback {o->hide();

  916. 

  917. if ( logo_box->image() )

  918. {

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

  920. 	logo_box->image( NULL );

  921. }} open

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

  923.     } {

  924.       Fl_Value_Output {} {

  925.         label {Sample Rate}

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

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

  928.       }

  929.       Fl_Output {} {

  930.         label {Size of Journal}

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

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

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

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

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

  936.       }

  937.       Fl_Output {} {

  938.         label {Created On}

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

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

  941.       }

  942.       Fl_Output {} {

  943.         label Length

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

  945.         code0 {char pat[40];}

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

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

  948.       }

  949.       Fl_Value_Output {} {

  950.         label Tracks

  951.         xywh {200 130 55 25} align 1

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

  953.       }

  954.       Fl_Box logo_box {

  955.         label {<LOGO>}

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

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

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

  959.       }

  960.       Fl_Text_Editor notes_field {

  961.         label {Notes:}

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

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

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

  965.       }

  966.       Fl_Button {} {

  967.         label {&Save}

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

  969. 

  970. window->do_callback();}

  971.         xywh {425 700 74 25}

  972.       }

  973.       Fl_Box {} {

  974.         label {Project Info}

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

  976.       }

  977.       Fl_Box {} {

  978.         label {Project Info}

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

  980.       }

  981.       Fl_Button {} {

  982.         label {&Discard}

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

  984.         xywh {330 700 74 25}

  985.       }

  986.       Fl_Output {} {

  987.         label {Last Modified On}

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

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

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

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

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

  993.       }

  994.     }

  995.   }

  996. } 

  997. 

  998. class About_Dialog {open

  999. } {

  1000.   Function {About_Dialog()} {open

  1001.   } {

  1002.     code {make_window();} {}

  1003.   }

  1004.   Function {run()} {return_type void

  1005.   } {

  1006.     code {window->show();

  1007. 

  1008. while ( window->shown() )

  1009. 	Fl::wait();

  1010. 	

  1011. delete window;} {}

  1012.   }

  1013.   Function {make_window()} {open private

  1014.   } {

  1015.     Fl_Window window {

  1016.       label About

  1017.       callback {o->hide();

  1018. 

  1019. if ( logo_box->image() )

  1020. {

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

  1022. 	logo_box->image( NULL );

  1023. }} open

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

  1025.     } {

  1026.       Fl_Tabs {} {open

  1027.         xywh {0 264 497 392}

  1028.       } {

  1029.         Fl_Group {} {

  1030.           label Credits open

  1031.           xywh {2 293 492 362}

  1032.         } {

  1033.           Fl_Box {} {

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

  1035.  Jonathan Moore Liles for his own use

  1036.  (see the manual).

  1037. 

  1038. Nobody planned. Nobody helped.

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

  1040. and/or replacing the rest of Linux Audio

  1041. with fast, light, reliable alternatives.}

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

  1043.           }

  1044.         }

  1045.         Fl_Group {} {

  1046.           label License open

  1047.           xywh {2 288 492 311} hide

  1048.         } {

  1049.           Fl_Box {} {

  1050.             label {Copyright (C) 2008 Jonathan Moore Liles}

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

  1052.           }

  1053.           Fl_Box {} {

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

  1055. 

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

  1057. 

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

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

  1060.           }

  1061.         }

  1062.       }

  1063.       Fl_Box logo_box {

  1064.         label VERSION

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

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

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

  1068.       }

  1069.       Fl_Return_Button {} {

  1070.         label Rock

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

  1072.         xywh {400 614 76 30}

  1073.       }

  1074.       Fl_Button {} {

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

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

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

  1078.       }

  1079.       Fl_Box {} {

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

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

  1082.       }

  1083.     }

  1084.   }

  1085. } 

  1086. 

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

  1088. } {

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

  1090. 	

  1091. 	// FIXME: got a better idea?

  1092. 	char cmd[256];

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

  1094. 	system( cmd );

  1095. \#else

  1096. 	fl_open_uri( url );

  1097. \#endif} {}

  1098. }