non/Timeline/TLE.fl

# data file for the Fltk User Interface Designer (fluid)
version 1.0108 
header_name {.H} 
code_name {.C}
decl {const float STATUS_UPDATE_FREQ = 0.5f;} {} 

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

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

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

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

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

decl {\#include "Session.H"} {} 

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

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

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

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

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

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

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

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

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

decl {extern char session_display_name[256];} {global
} 

decl {extern char *user_config_dir;} {global
} 

class TLE {open
} {
  decl {Fl_Color system_colors[3];} {public
  }
  decl {static void menubar_cb ( void *v )} {}
  decl {void menubar_cb ( void )} {}
  Function {menu_picked_value( const Fl_Menu_ *m )} {open return_type {static int}
  } {
    code {return m->menu()[ m->value() ].flags & FL_MENU_VALUE;} {}
  }
  Function {save()} {open
  } {
    code {const char options_filename[] = "options";
// const char state_filename[] = "state";

// save options

char *path;
asprintf( &path, "%s/%s", user_config_dir, options_filename );
((Fl_Menu_Settings*)menubar)->dump( menubar->find_item( "&Options" ), path );
free( path );

// save unjournaled state

// Loggable::save_unjournaled( state_filename );} {}
  }
  Function {capture_format_cb( Fl_Widget *w, void *v )} {open private return_type {static void}
  } {
    code {((TLE*)v)->capture_format_cb();} {}
  }
  Function {capture_format_cb()} {open private return_type void
  } {
    code {Fl_Menu_ *o = menubar;

Track::capture_format = o->menu()[ o->value() ].label();} {}
  }
  Function {TLE()} {open
  } {
    code {make_window();

// Fl::visual( RGB8 );
Fl::visible_focus( 0 );

Fl::get_system_colors();
Fl::scheme( "plastic" );

system_colors[ 0 ] = (Fl_Color)Fl::get_color( FL_BACKGROUND_COLOR );
system_colors[ 1 ] = (Fl_Color)Fl::get_color( FL_FOREGROUND_COLOR  );
system_colors[ 2 ] = (Fl_Color)Fl::get_color( FL_BACKGROUND2_COLOR  );

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



std::list <const char *> formats;

Audio_File::all_supported_formats( formats );

for ( std::list <const char *>::const_iterator f = formats.begin(); f != formats.end(); ++f )
{
//	capture_format_menu->add( *f, FL_MENU_RADIO, 0, 0, 0 );
//;
	char pat[256];
	snprintf( pat, sizeof( pat ), "Timeline/Capture Format/%s", *f );	

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


char *path;
asprintf( &path, "%s/options", user_config_dir );
((Fl_Menu_Settings*)menubar)->load( menubar->find_item( "&Options" ), path );
free( path );} {}
  }
  Function {make_window()} {open
  } {
    Fl_Window main_window {
      label {Non-DAW - Timeline} open
      xywh {174 178 1020 765} type Double resizable xclass {Non-DAW} visible
    } {
      Fl_Menu_Bar menubar {open
        xywh {0 0 1024 25}
      } {
        Submenu {} {
          label {&Session} open
          xywh {0 0 74 25}
        } {
          MenuItem {} {
            label {&Info}
            xywh {0 0 40 25} deactivate
          }
          MenuItem {} {
            label {&New}
            callback {const char *name = new_session_chooser();

if ( ! name )
	return;
	
// Loggable::close();
// timeline->reset();
main_window->redraw();}
            xywh {0 0 40 25}
          }
          MenuItem {} {
            label {&Open}
            xywh {10 10 40 25} deactivate
          }
          MenuItem {} {
            label {&Compact}
            callback {int n = fl_choice( "Compacting will replace the session history with a snapshot of the current state.\\n You will not be able to use Undo to go back beyond this point.\\n This operation is irreversible!", NULL, "Abort", "Procede with compaction" );

if ( n != 2 )
	return;
	
Loggable::compact();}
            xywh {20 20 40 25}
          }
          Submenu {} {
            label Export open
            xywh {0 0 74 25} deactivate
          } {
            MenuItem {} {
              label Session
              xywh {0 0 40 25}
            }
            MenuItem {} {
              label Range
              xywh {10 10 40 25}
            }
          }
          MenuItem {} {
            label {&Quit}
            callback {save();

printf( "dropped %d buffers\\n", engine->dropped() );

exit( 0 );}
            xywh {40 40 40 25} shortcut 0x40071
          }
        }
        Submenu {} {
          label {&Edit} open
          xywh {0 0 74 25}
        } {
          MenuItem {} {
            label Undo
            callback {Loggable::undo();}
            xywh {0 0 40 25} shortcut 0x4007a divider
          }
          MenuItem {} {
            label {Select None}
            callback {timeline->select_none();}
            xywh {10 10 40 25} shortcut 0x50061
          }
          MenuItem {} {
            label {Delete  Selected}
            callback {timeline->delete_selected();}
            xywh {20 20 40 25} shortcut 0xffff
          }
        }
        Submenu {} {
          label Transport open
          xywh {0 0 74 25}
        } {
          MenuItem {} {
            label Start
            callback {transport->locate( 0 );}
            xywh {0 0 40 25} shortcut 0xff50
          }
          MenuItem {} {
            label End
            callback {transport->locate( timeline->length() );}
            xywh {10 10 40 25} shortcut 0xff57
          }
          MenuItem {} {
            label {Play/Stop}
            callback {transport->toggle();}
            xywh {20 20 40 25} shortcut 0x20
          }
          MenuItem {} {
            label Record
            callback {transport->toggle_record();}
            xywh {40 40 40 25} shortcut 0x10072
          }
        }
        Submenu {} {
          label {&View} open
          xywh {0 0 74 25}
        } {
          Submenu {} {
            label {&Zoom} open
            xywh {0 0 74 25}
          } {
            MenuItem {} {
              label {&In}
              callback {timeline->zoom_in();}
              xywh {20 20 40 25}
            }
            MenuItem {} {
              label {&Out}
              callback {timeline->zoom_out();}
              xywh {30 30 40 25}
            }
            MenuItem {} {
              label {&Fit}
              callback {timeline->zoom_fit();}
              xywh {10 10 40 25} divider
            }
            MenuItem {} {
              label {1 sec.}
              callback {timeline->zoom( 1 );}
              xywh {10 10 40 25} shortcut 0x31
            }
            MenuItem {} {
              label {1 min.}
              callback {timeline->zoom( 60 );}
              xywh {20 20 40 25} shortcut 0x32
            }
            MenuItem {} {
              label {1 hour.}
              callback {timeline->zoom( 60 * 60 );}
              xywh {30 30 40 25} shortcut 0x33
            }
          }
        }
        Submenu timeline_menu {
          label {&Timeline}
          xywh {0 0 74 25}
        } {
          MenuItem {} {
            label {&Follow Playhead}
            callback {Timeline::follow_playhead = menu_picked_value( o );}
            xywh {20 20 40 25} type Toggle value 1
          }
          MenuItem {} {
            label {&Center Playhead}
            callback {Timeline::center_playhead = menu_picked_value( o );}
            xywh {30 30 40 25} type Toggle value 1
          }
          Submenu {} {
            label {&Snap to} open
            xywh {0 0 74 25}
          } {
            MenuItem {} {
              label Bars
              callback {Timeline::snap_to = Timeline::Bars;}
              xywh {0 0 40 25} type Radio value 1
            }
            MenuItem {} {
              label Beats
              callback {Timeline::snap_to = Timeline::Beats;}
              xywh {10 10 40 25} type Radio
            }
            MenuItem {} {
              label Off
              callback {Timeline::snap_to = Timeline::None;}
              xywh {20 20 40 25} type Radio
            }
          }
          MenuItem {} {
            label {Magnetic snap}
            callback {Timeline::snap_magnetic = menu_picked_value( o );}
            xywh {10 10 40 25} type Toggle value 1
          }
          Submenu {} {
            label {Capture Format} open
            xywh {0 0 74 25}
          } {}
        }
        Submenu {} {
          label {&Options} open
          xywh {0 0 74 25} divider
        } {
          Submenu {} {
            label {&Display} open
            xywh {0 0 74 25}
          } {
            Submenu {} {
              label {&Timeline} open
              xywh {0 0 74 25}
            } {
              MenuItem {} {
                label {&Measure lines}
                callback {Timeline::draw_with_measure_lines = menu_picked_value( o );

timeline->redraw();}
                xywh {0 0 40 25} type Toggle value 1
              }
            }
            Submenu {} {
              label {&Waveforms} open
              xywh {0 0 74 25}
            } {
              MenuItem {} {
                label Fill
                callback {Waveform::fill = menu_picked_value( o );

timeline->redraw();}
                xywh {10 10 40 25} type Toggle value 1
              }
              MenuItem {} {
                label Outline
                callback {Waveform::outline = menu_picked_value( o );

timeline->redraw();}
                xywh {30 30 40 25} type Toggle value 1
              }
              MenuItem {} {
                label {Vary color}
                callback {Waveform::vary_color = menu_picked_value( o );

timeline->redraw();}
                xywh {20 20 40 25} type Toggle value 1
              }
            }
            Submenu {} {
              label {&Audio_Region} open
              xywh {0 0 74 25}
            } {
              MenuItem {} {
                label {Filled fades}
                xywh {30 30 40 25} type Toggle value 1
              }
              MenuItem {} {
                label {Inherit track color}
                callback {Audio_Region::inherit_track_color = menu_picked_value( o );

timeline->redraw();}
                xywh {40 40 40 25} type Toggle value 1
              }
            }
            Submenu {} {
              label {&Control Sequence} open
              xywh {0 0 74 25}
            } {
              MenuItem {} {
                label Polygon
                callback {Control_Sequence::draw_with_polygon = menu_picked_value( o );

timeline->redraw();}
                xywh {20 20 40 25} type Toggle value 1
              }
              MenuItem {} {
                label Graded
                callback {Control_Sequence::draw_with_gradient = menu_picked_value( o );

timeline->redraw();}
                xywh {30 30 40 25} type Toggle value 1
              }
              MenuItem {} {
                label Ruled
                callback {Control_Sequence::draw_with_grid = menu_picked_value( o );

timeline->redraw();}
                xywh {40 40 40 25} type Toggle value 1
              }
            }
            Submenu {} {
              label {&Style} open
              xywh {0 0 74 25}
            } {
              MenuItem {} {
                label Default
                callback {Fl::scheme( "plastic" );}
                xywh {0 0 40 25} type Radio value 1
              }
              MenuItem {} {
                label Flat
                callback {Fl::scheme( "gtk+" );}
                xywh {10 10 40 25} type Radio
              }
            }
            Submenu {} {
              label {C&olors} open
              xywh {0 0 74 25}
            } {
              MenuItem {} {
                label System
                callback {//Fl::get_system_colors();

unsigned char r, g, b;

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

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

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

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

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

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

Fl::scheme( Fl::scheme() );}
                xywh {0 0 40 25} type Radio
              }
              MenuItem {} {
                label Dark
                callback {Fl::background2( 100, 100, 100 );
Fl::background( 50, 50, 50 );
Fl::foreground( 255, 255, 255 );

Fl::scheme( Fl::scheme() );}
                xywh {10 10 40 25} type Radio value 1
              }
              MenuItem {} {
                label Light
                callback {Fl::background2( 192, 192, 192 );
Fl::background( 220, 220, 220 );
Fl::foreground( 0, 0, 0 );

Fl::scheme( Fl::scheme() );}
                xywh {20 20 40 25} type Radio
              }
            }
          }
        }
        Submenu {} {
          label {&Help} open
          xywh {0 0 74 25}
        } {
          MenuItem {} {
            label {&About}
            callback {Fl_Window *win = make_about_dialog();

win->show();

while ( win->shown() )
	Fl::wait();
	
delete win;}
            xywh {0 0 40 25}
          }
        }
      }
      Fl_Group {} {open
        xywh {0 23 1024 48}
      } {
        Fl_Pack {} {open
          xywh {0 23 473 46} type HORIZONTAL
          code0 {o->spacing( 10 );}
        } {
          Fl_Box {} {
            label {<Transport>}
            xywh {0 23 184 46} color 30
            code0 {transport = o;}
            code1 {o->labeltype( FL_NO_LABEL );}
            class Transport
          }
          Fl_Pack clocks_pack {open
            xywh {185 23 288 46} type HORIZONTAL
            code0 {o->spacing( 2 );}
          } {
            Fl_Box playhead_clock {
              label PLAYHEAD
              xywh {185 29 137 40} box BORDER_BOX color 40
              code0 {o->type( Clock::HMS );}
              code1 {o->run( &transport->frame );}
              class Clock
            }
            Fl_Box {} {
              label PLAYHEAD
              xywh {325 29 142 40} box BORDER_BOX color 40
              code0 {o->type( Clock::BBT );}
              code1 {o->run( &transport->frame );}
              class Clock
            }
          }
        }
        Fl_Box {} {
          label {<empty>}
          xywh {477 27 387 42} resizable
          code0 {o->labeltype( FL_NO_LABEL );}
        }
        Fl_Group {} {
          xywh {869 25 155 44}
        } {
          Fl_Box {} {
            label {capture:}
            xywh {869 25 56 14} labelsize 10 align 24
          }
          Fl_Box {} {
            label {playback:}
            xywh {869 41 56 14} labelsize 10 align 24
          }
          Fl_Box {} {
            label {DSP:}
            xywh {869 55 56 14} labelsize 10 align 24
          }
          Fl_Progress capture_buffer_progress {
            label {50%}
            xywh {925 25 99 14} labelsize 10
          }
          Fl_Progress cpu_load_progress {
            label {50%}
            xywh {925 55 99 14} labelsize 9
          }
          Fl_Progress playback_buffer_progress {
            label {50%}
            xywh {925 40 99 14} labelsize 10
          }
        }
      }
      Fl_Box {} {
        label {<Timeline>}
        xywh {0 72 1024 695} box FLAT_BOX color 47 labelsize 100 resizable
        code0 {timeline = o;}
        class Timeline
      }
      Fl_Box {} {
        label {<session name>}
        xywh {450 0 475 22} labeltype SHADOW_LABEL labelfont 2
        code0 {o->label( Session::name() );}
      }
      Fl_Value_Output xruns_output {
        label {xruns:}
        xywh {980 2 44 20} maximum 40000 step 1
      }
    }
  }
  Function {update_progress( Fl_Progress *p, char *s, float v )} {open private return_type {static void}
  } {
    code {p->value( v );

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

p->label( s );} {}
  }
  Function {update_status()} {open
  } {
    code {static char cbp[5], pbp[5], clp[5];

update_progress( capture_buffer_progress, cbp, timeline->total_input_buffer_percent() );
update_progress( playback_buffer_progress, pbp, timeline->total_output_buffer_percent() );
update_progress( cpu_load_progress, clp, engine->cpu_load() );


if ( timeline->total_capture_xruns() )
	capture_buffer_progress->selection_color( FL_RED );

if ( timeline->total_playback_xruns() )
	playback_buffer_progress->selection_color( FL_RED );



xruns_output->value( engine->xruns() );} {}
  }
  Function {update_cb( void *v )} {return_type {static void}
  } {
    code {Fl::repeat_timeout( STATUS_UPDATE_FREQ, update_cb, v );

((TLE*)v)->update_status();} {}
  }
  Function {make_about_dialog()} {open
  } {
    Fl_Window {} {
      label About open
      xywh {677 145 495 525} type Double visible
    } {
      Fl_Tabs {} {open
        xywh {-4 122 507 419}
      } {
        Fl_Group {} {
          label Credits open
          xywh {-4 147 507 394}
        } {
          Fl_Box {} {
            label {Non-DAW was written from scratch by
 Jonathan Moore Liles for his own use
 (see the manual).

Nobody planned. Nobody helped.
 You can help now by donating time, money,
and/or replacing the rest of Linux Audio
with fast, light, reliable alternatives.}
            xywh {42 203 416 260} labelsize 17
          }
        }
        Fl_Group {} {
          label License open
          xywh {-1 157 504 384} hide
        } {
          Fl_Box {} {
            label {Copyright (C) 2008 Jonathan Moore Liles

 This software is released under version 3
 of the GNU General Public License (GPLv3).}
            xywh {45 213 403 83} labelsize 17
          }
        }
      }
      Fl_Box {} {
        label {the Non-DAW (Digital Audio Workstation)}
        image {../logo-small.png} xywh {-1 1 499 115} align 16
      }
    }
  }
} 

class New_Session_Dialog {open
} {
  Function {New_Session_Dialog()} {open
  } {
    code {make_window();} {}
  }
  Function {run()} {open return_type {const char *}
  } {
    code {_window->show();

while ( _window->shown() )
	Fl::wait();} {}
  }
  Function {make_window()} {open
  } {
    Fl_Window _window {
      label {New Session} open
      xywh {576 340 550 195} type Double modal visible
    } {
      Fl_File_Input _name {
        label {Named:}
        xywh {75 140 375 35}
      }
      Fl_Button {} {
        label Browse
        callback {_directory->value( fl_dir_chooser( "Directory for new session", NULL, 0 ) );}
        xywh {455 100 80 35}
      }
      Fl_Return_Button {} {
        label Create
        callback {if ( strlen( _directory->value() ) && strlen( _name->value() ) )
{
	char pat[512];
	
	snprintf( pat, sizeof( pat ), "%s/%s", _directory->value(), _name->value() );

//	if ( ! fl_filename_exists( pat ) )
	{

		if ( ! Session::create( pat,  _template->text( _template->value() ) ) )
			fl_alert( "Error opening session!" );

		_window->hide();
	}
//	else
//	{
//		fl_alert( "A file already exists at that location. Choose a differnt name." );
//		
//	}
}} selected
        xywh {455 140 80 35}
      }
      Fl_File_Input _directory {
        label {Where:}
        callback {if ( ! fl_filename_isdir( o->value() ) )
{
	fl_alert( "Must be a directory" );
	o->value( "" );
}}
        xywh {75 100 375 35}
        code0 {\#include <FL/filename.H>}
      }
      Fl_Box {} {
        label {New Session}
        xywh {15 8 520 33} box RSHADOW_BOX color 133 labelsize 20 labelcolor 32
      }
      Fl_Choice _template {
        label {Template:}
        private xywh {310 60 225 25} down_box BORDER_BOX
      } {
        MenuItem {} {
          label Default
          xywh {0 0 40 25}
        }
      }
    }
  }
} 

Function {new_session_chooser()} {open C return_type {const char *}
} {
  code {New_Session_Dialog nsd;

return nsd.run();} {}
}