linuxaudio
/
new-session-manager
mirror of https://github.com/linuxaudio/new-session-manager
1
0
Fork 0
Code Issues 0 Releases 17 Wiki Activity
Browse Source

Begin moving to custom track scrolling with 'virtual' region widgets.

tags/non-daw-v1.1.0
Jonathan Moore Liles 17 years ago
parent
80ec2b6e35
commit
76afaa5792
8 changed files with 453 additions and 472 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -1
      Makefile
  2. +237
    -227
      Region.C
  3. +15
    -10
      Region.H
  4. +151
    -0
      Track.C
  5. +5
    -116
      Track.H
  6. +24
    -50
      Waveform.C
  7. +1
    -55
      Waveform.H
  8. +19
    -13
      main.C

+ 1
- 1
Makefile View File

@@ -5,7 +5,7 @@ CXXFLAGS=-ggdb -Wall -O0
LIBS=-lsndfile `fltk-config --ldflags` LIBS=-lsndfile `fltk-config --ldflags`
# CXXFLAGS=`fltk-config -cxxflags` # CXXFLAGS=`fltk-config -cxxflags`


SRCS= Clip.C Waveform.C Region.C Peaks.C main.C
SRCS= Clip.C Waveform.C Region.C Peaks.C main.C Track.C


OBJS=$(SRCS:.C=.o) OBJS=$(SRCS:.C=.o)




+ 237
- 227
Region.C View File

@@ -20,256 +20,263 @@
#include "Track.H" #include "Track.H"
#include "Region.H" #include "Region.H"
#include "Timeline.H" #include "Timeline.H"
#include "Waveform.H"


#include <FL/fl_draw.H> #include <FL/fl_draw.H>
#include <FL/Fl.H> #include <FL/Fl.H>
#include <FL/Fl_Group.H> #include <FL/Fl_Group.H>
#include <FL/Fl_Widget.H> #include <FL/Fl_Widget.H>
#include <FL/Fl_Box.H>


#include <stdio.h> #include <stdio.h>


extern Timeline timeline;
#include <algorithm>
//using std::algorithm;
using namespace std;


Region::Region ( int X, int Y, int W, int H, const char *L ) : Waveform( X, Y, W, H, L )
{
init();
}
extern Timeline timeline;


void void
Region::init ( void ) Region::init ( void )
{ {
align( FL_ALIGN_INSIDE | FL_ALIGN_LEFT | FL_ALIGN_BOTTOM | FL_ALIGN_CLIP );
labeltype( FL_SHADOW_LABEL );
labelcolor( FL_WHITE );
box( FL_PLASTIC_UP_BOX );

/* align( FL_ALIGN_INSIDE | FL_ALIGN_LEFT | FL_ALIGN_BOTTOM | FL_ALIGN_CLIP ); */
/* labeltype( FL_SHADOW_LABEL ); */
/* labelcolor( FL_WHITE ); */
/* box( FL_PLASTIC_UP_BOX ); */


_track = NULL; _track = NULL;
// _offset = 0;
_offset = timeline.x_to_ts( x() );
_offset = 0;
_start = 0;
_end = 0;
_scale = 1.0f;
_clip = NULL;
} }


Region::Region ( const Region & rhs ) : Waveform( rhs )
Region::Region ( const Region & rhs )
{ {
box( rhs.box() );
align( rhs.align() );
color( rhs.color() );
selection_color( rhs.selection_color() );
labelcolor( rhs.labelcolor() );
labeltype( rhs.labeltype() );

_offset = rhs._offset; _offset = rhs._offset;
_track = rhs._track;
_track = rhs._track;
_clip = rhs._clip;
_start = rhs._start;
_end = rhs._end;
_scale = rhs._scale;
} }


Region::Region ( Clip *c ) : Waveform( c )
Region::Region ( Clip *c )
{ {
init(); init();
_clip = c;
_end = _clip->length();
} }


void
Region::trim ( enum trim_e t, int X )
{
switch ( t )
{
case LEFT:
{
int d = X - x();


long td = timeline.x_to_ts( d );


if ( td < 0 && _start < 0 - td )
td = 0 - _start;
/* void */
/* Region::trim ( enum trim_e t, int X ) */
/* { */
/* switch ( t ) */
/* { */
/* case LEFT: */
/* { */
/* int d = X - x(); */


_start += td;
/* long td = timeline.x_to_ts( d ); */


_offset += td;
/* if ( td < 0 && _start < 0 - td ) */
/* td = 0 - _start; */


resize();
// Fl_Widget::resize( x() + d, y(), w() - d, h() );
/* _start += td; */


// _offset = timeline.x_to_ts( x() );
/* _offset += td; */


break;
}
case RIGHT:
{
int d = (x() + w()) - X;
long td = timeline.x_to_ts( d );
/* resize(); */
/* // Fl_Widget::resize( x() + d, y(), w() - d, h() ); */


_end -= td;
/* // _offset = timeline.x_to_ts( x() ); */


resize();
/* break; */
/* } */
/* case RIGHT: */
/* { */
/* int d = (x() + w()) - X; */
/* long td = timeline.x_to_ts( d ); */


// _end = _start + timeline.x_to_ts( w() - d );
/* _end -= td; */


// Fl_Widget::resize( x(), y(), w() - d, h() );
break;
}
default:
return;
/* resize(); */


}
/* // _end = _start + timeline.x_to_ts( w() - d ); */


redraw();
parent()->redraw();
/* // Fl_Widget::resize( x(), y(), w() - d, h() ); */
/* break; */
/* } */
/* default: */
/* return; */


}
/* } */


int
Region::handle ( int m )
{
/* redraw(); */
/* parent()->redraw(); */


if ( Fl_Widget::handle( m ) )
return 1;

static int ox, oy;
static enum trim_e trimming;

static bool copied = false;
static nframes_t os;

int X = Fl::event_x();
int Y = Fl::event_y();

switch ( m )
{
case FL_PUSH:
{

if ( Fl::event_state() & FL_SHIFT &&
! ( Fl::event_state() & FL_CTRL ))
{
switch ( Fl::event_button() )
{
case 1:
trim( trimming = LEFT, X );
break;
case 3:
trim( trimming = RIGHT, X );
break;
default:
return 0;
}
fl_cursor( FL_CURSOR_WE );
return 1;
}
else
{
ox = x() - X;
oy = y() - Y;

if ( Fl::event_state() && FL_CTRL )
{
os = _start;
// Fl::local_grab( this );
}

if ( Fl::event_button() == 2 )
normalize();


return 1;
}
return 0;
break;
}
case FL_RELEASE:
fl_cursor( FL_CURSOR_DEFAULT );
copied = false;
trimming = NO;
// Fl::release();
return 1;
case FL_DRAG:

if ( Fl::event_state() & FL_SHIFT &&
Fl::event_state() & FL_CTRL )
{
int d = (ox + X) - x();
long td = timeline.x_to_ts( d );

if ( td > 0 && os < td )
_start = 0;
else
_start = os - td;

redraw();
return 1;
}

if ( Fl::event_state() & FL_SHIFT )
if ( trimming )
{
trim( trimming, X );
return 1;
}
else
return 0;

if ( Fl::event_state() & FL_CTRL )
{
if ( ! copied )
{
_track->add( new Region( *this ) );
copied = true;
return 1;
}
}

if ( ox + X >= _track->x() )
{
int nx = ox + X;

// nx = _track->snap( this, nx );

// _offset = timeline.x_to_ts( nx );

position( nx, y() );

_track->snap( this );
}

if ( Y > y() + h() )
{
if ( _track->next() )
_track->next()->add( this );
}
else
if ( Y < y() )
{
if ( _track->prev() )
_track->prev()->add( this );
}

parent()->redraw();

fl_cursor( FL_CURSOR_MOVE );

if ( X >= timeline.scroll->x() + timeline.scroll->w() ||
X <= timeline.scroll->x() )
{
/* this drag needs to scroll */

long pos = timeline.scroll->xposition();

if ( X <= timeline.scroll->x() )
pos -= 100;
else
pos += 100;

if ( pos < 0 )
pos = 0;

timeline.scroll->position( pos, timeline.scroll->yposition() );
}

// _offset = timeline.x_to_ts( x() );

return 1;
default:
return 0;
break;
}
}
/* } */

int
Region::handle ( int m ) { return 0; }

/* { */

/* /\* if ( Fl_Widget::handle( m ) ) *\/ */
/* /\* return 1; *\/ */

/* static int ox, oy; */
/* static enum trim_e trimming; */

/* static bool copied = false; */
/* static nframes_t os; */

/* int X = Fl::event_x(); */
/* int Y = Fl::event_y(); */

/* switch ( m ) */
/* { */
/* case FL_PUSH: */
/* { */

/* if ( Fl::event_state() & FL_SHIFT && */
/* ! ( Fl::event_state() & FL_CTRL )) */
/* { */
/* switch ( Fl::event_button() ) */
/* { */
/* case 1: */
/* trim( trimming = LEFT, X ); */
/* break; */
/* case 3: */
/* trim( trimming = RIGHT, X ); */
/* break; */
/* default: */
/* return 0; */
/* } */
/* fl_cursor( FL_CURSOR_WE ); */
/* return 1; */
/* } */
/* else */
/* { */
/* ox = x() - X; */
/* oy = y() - Y; */

/* if ( Fl::event_state() && FL_CTRL ) */
/* { */
/* os = _start; */
/* // Fl::local_grab( this ); */
/* } */

/* if ( Fl::event_button() == 2 ) */
/* normalize(); */


/* return 1; */
/* } */
/* return 0; */
/* break; */
/* } */
/* case FL_RELEASE: */
/* fl_cursor( FL_CURSOR_DEFAULT ); */
/* copied = false; */
/* trimming = NO; */
/* // Fl::release(); */
/* return 1; */
/* case FL_DRAG: */

/* if ( Fl::event_state() & FL_SHIFT && */
/* Fl::event_state() & FL_CTRL ) */
/* { */
/* int d = (ox + X) - x(); */
/* long td = timeline.x_to_ts( d ); */

/* if ( td > 0 && os < td ) */
/* _start = 0; */
/* else */
/* _start = os - td; */

/* redraw(); */
/* return 1; */
/* } */

/* if ( Fl::event_state() & FL_SHIFT ) */
/* if ( trimming ) */
/* { */
/* trim( trimming, X ); */
/* return 1; */
/* } */
/* else */
/* return 0; */

/* if ( Fl::event_state() & FL_CTRL ) */
/* { */
/* if ( ! copied ) */
/* { */
/* _track->add( new Region( *this ) ); */
/* copied = true; */
/* return 1; */
/* } */
/* } */

/* if ( ox + X >= _track->x() ) */
/* { */
/* int nx = ox + X; */

/* // nx = _track->snap( this, nx ); */

/* // _offset = timeline.x_to_ts( nx ); */

/* position( nx, y() ); */

/* _track->snap( this ); */
/* } */

/* if ( Y > y() + h() ) */
/* { */
/* if ( _track->next() ) */
/* _track->next()->add( this ); */
/* } */
/* else */
/* if ( Y < y() ) */
/* { */
/* if ( _track->prev() ) */
/* _track->prev()->add( this ); */
/* } */

/* parent()->redraw(); */

/* fl_cursor( FL_CURSOR_MOVE ); */

/* if ( X >= timeline.scroll->x() + timeline.scroll->w() || */
/* X <= timeline.scroll->x() ) */
/* { */
/* /\* this drag needs to scroll *\/ */

/* long pos = timeline.scroll->xposition(); */

/* if ( X <= timeline.scroll->x() ) */
/* pos -= 100; */
/* else */
/* pos += 100; */

/* if ( pos < 0 ) */
/* pos = 0; */

/* timeline.scroll->position( pos, timeline.scroll->yposition() ); */
/* } */

/* // _offset = timeline.x_to_ts( x() ); */

/* return 1; */
/* default: */
/* return 0; */
/* break; */
/* } */
/* } */




/** must be called whenever zoom is adjusted */ /** must be called whenever zoom is adjusted */
@@ -284,39 +291,42 @@ Region::resize ( void )


printf( "%dx%d\n", X, W ); printf( "%dx%d\n", X, W );


if ( W > 5000 )
W = 5000;

if ( W )
Fl_Widget::resize( X, y(), W, h() );
// if ( W )
// Fl_Widget::resize( X, y(), W, h() );
} }



/* X is the timeline offset, W is the width of the track */
void void
Region::draw ( void )
Region::draw ( int X, int Y, int W, int H )
{ {
int rx = timeline.ts_to_x( _offset ) - X;
int rw = min( timeline.ts_to_x( _end - _start ), W );


draw_box();
fl_draw_box( FL_PLASTIC_UP_BOX, rx, Y, rw, H, FL_CYAN );


// fl_push_clip( x() + Fl::box_dx( box() ), y(), w() - Fl::box_dw( box() ), h() ); // fl_push_clip( x() + Fl::box_dx( box() ), y(), w() - Fl::box_dw( box() ), h() );



Waveform::draw();
draw_waveform( rx, Y, rw, H, _clip, _start, _end, _scale, FL_GREEN );


// fl_pop_clip(); // fl_pop_clip();




/* fl_color( FL_RED ); */
/* int sx = x() - timeline.ts_to_x( _start ); */
/* fl_line( sx, y(), sx, y() + h() ); */
/* int ex = x() + timeline.ts_to_x( _end - _start ); */
/* fl_line( ex, y(), ex, y() + h() ); */
fl_font( FL_HELVETICA, 14 );
fl_color( FL_BLACK );


draw_label();
int bx = Fl::box_dx( FL_PLASTIC_UP_BOX );
int by = Fl::box_dy( FL_PLASTIC_UP_BOX );
int bw = Fl::box_dw( FL_PLASTIC_UP_BOX );
int bh = Fl::box_dh( FL_PLASTIC_UP_BOX );


/* static char pat[200]; */
Fl_Align align = (Fl_Align)(FL_ALIGN_LEFT | FL_ALIGN_BOTTOM | FL_ALIGN_CLIP);
fl_draw( _clip->name(), bx + rx + 1, Y + 1 + by, rw - bw, H - bh, align );
fl_color( FL_WHITE );
fl_draw( _clip->name(), bx + rx, Y + by , rw - bw, H - bh, align );


/* sprintf( pat, "start %lu, end %lu", _start, _end ); */


/* fl_draw( pat, x(), y() + h() / 2 ); */
// fl_draw( _clip->name(), X, Y );


//(Fl_Align)FL_ALIGN_LEFT | FL_ALIGN_BOTTOM );
} }

+ 15
- 10
Region.H View File

@@ -21,36 +21,41 @@


class Track; class Track;


#include "Waveform.H"
// #include "Waveform.H"


class Region : public Waveform
#include "Clip.H"

class Region
{ {


Track *_track;
Track *_track; /* track this region belongs to */


nframes_t _offset;
Clip *_clip; /* clip this region represents */


enum trim_e { NO, LEFT, RIGHT };
nframes_t _offset; /* where on the timeline */
nframes_t _start; /* first sample from clip */
nframes_t _end; /* last sample from clip */


void trim ( enum trim_e t, int X );
float _scale; /* amplitude adjustment */


enum trim_e { NO, LEFT, RIGHT };
void trim ( enum trim_e t, int X );
void init ( void ); void init ( void );


public: public:


Region ( int X, int Y, int W, int H, const char *L=0 );

Region ( const Region & rhs ); Region ( const Region & rhs );
Region ( Clip *c ); Region ( Clip *c );


int handle ( int m ); int handle ( int m );
void draw ( void );
void draw ( int X, int Y, int W, int H );
void resize ( void ); void resize ( void );



Track * track ( void ) const { return _track; } Track * track ( void ) const { return _track; }
void track ( Track *t ) { _track = t; } void track ( Track *t ) { _track = t; }


nframes_t offset ( void ) const { return _offset; } nframes_t offset ( void ) const { return _offset; }
void offset ( nframes_t o ) { _offset = o; } void offset ( nframes_t o ) { _offset = o; }

void end ( nframes_t v ) { _end = v; }
}; };

+ 151
- 0
Track.C View File

@@ -0,0 +1,151 @@

/*******************************************************************************/
/* Copyright (C) 2008 Jonathan Moore Liles */
/* */
/* 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. */
/* */
/* 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. */
/* */
/* You should have received a copy of the GNU General Public License along */
/* with This program; see the file COPYING. If not,write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/*******************************************************************************/

#include "Track.H"
#include "Timeline.H"

void
Track::draw ( void )
{
for ( list <Region *>::iterator r = _regions.begin(); r != _regions.end(); r++ )
{
(*r)->draw( x(), y(), w(), h() );
}
}

void
Track::remove_region ( Region *r )
{
_regions.remove( r );
}

void
Track::add ( Region *r )
{
if ( r->track() )
{
r->track()->remove_region( r );
r->track()->redraw();
}

_regions.push_back( r );

r->track( this );

// Fl_Group::add( r );
// add( r );

// r->position( r->x(), y() );
// r->redraw();
}

/** snap /r/ to nearest edge */
/* void */
/* Track::snap ( Region *r ) */
/* { */
/* const int snap_pixels = 10; */

/* int rx1 = r->x(); */
/* int rx2 = r->x() + r->w(); */

/* for ( int i = children(); i-- ; ) */
/* { */
/* const Region *w = (Region*)child( i ); */

/* if ( w == r ) */
/* continue; */

/* int wx1 = w->x(); */
/* int wx2 = w->x() + w->w(); */

/* if ( abs( rx1 - wx2 ) < snap_pixels ) */
/* { */
/* r->offset( w->offset() + w->length() + 1 ); */

/* printf( "snap: %lu | %lu\n", w->offset() + w->length(), r->offset() ); */

/* goto done; */
/* } */

/* if ( abs( rx2 - wx1 ) < snap_pixels ) */
/* { */
/* r->offset( ( w->offset() - r->length() ) - 1 ); */

/* printf( "snap: %lu | %lu\n", r->offset() + r->length(), w->offset() ); */

/* goto done; */
/* } */
/* } */

/* r->offset( timeline.x_to_ts( r->x() ) ); */

/* done: */

/* r->resize(); */
/* // r->position( rx1, y() ); */
/* } */

int
Track::handle ( int m )
{
switch ( m )
{
case FL_DND_DRAG:
case FL_DND_ENTER:
case FL_ENTER:
return 1;
case FL_DND_LEAVE:
case FL_DND_RELEASE:
return 1;
case FL_PASTE:
{
const char *text = Fl::event_text();

char *file;

if ( ! sscanf( text, "file://%a[^\r\n]\n", &file ) )
{
printf( "invalid drop \"%s\"\n", text );
return 0;
}

printf( "pasted file \"%s\"\n", file );

Clip *c = Clip::from_file( file );

if ( ! c )
{
free( file );
return 0;
}


Region *r = new Region( c );

r->offset( timeline.x_to_ts( Fl::event_x() ) );
// r->position( Fl::event_x(), r->y() );

this->add( r );

return 1;
}
default:
return Fl_Group::handle( m );
}
}

+ 5
- 116
Track.H View File

@@ -56,121 +56,10 @@ public:
void prev ( Track *t ) { _prev = t; } void prev ( Track *t ) { _prev = t; }
void next ( Track *t ) { _next = t; } void next ( Track *t ) { _next = t; }


void remove_region ( Region *r )
{
_regions.remove( r );
}

void add ( Region *r )
{
if ( r->track() )
{
r->track()->remove_region( r );
r->track()->redraw();
}

_regions.push_back( r );

r->track( this );

Fl_Group::add( r );
// add( r );

r->position( r->x(), y() );
r->redraw();
}

/** snap /r/ to nearest edge */
void
snap ( Region *r )
{
const int snap_pixels = 10;

int rx1 = r->x();
int rx2 = r->x() + r->w();

for ( int i = children(); i-- ; )
{
const Region *w = (Region*)child( i );

if ( w == r )
continue;
void draw ( void );
void remove_region ( Region *r );
void add ( Region *r );
void snap ( Region *r );
int handle ( int m );


int wx1 = w->x();
int wx2 = w->x() + w->w();

if ( abs( rx1 - wx2 ) < snap_pixels )
{
r->offset( w->offset() + w->length() + 1 );

printf( "snap: %lu | %lu\n", w->offset() + w->length(), r->offset() );

goto done;
}

if ( abs( rx2 - wx1 ) < snap_pixels )
{
r->offset( ( w->offset() - r->length() ) - 1 );

printf( "snap: %lu | %lu\n", r->offset() + r->length(), w->offset() );

goto done;
}
}

r->offset( timeline.x_to_ts( r->x() ) );

done:

r->resize();
// r->position( rx1, y() );
}

int handle ( int m )
{
switch ( m )
{
case FL_DND_DRAG:
case FL_DND_ENTER:
case FL_ENTER:
return 1;
case FL_DND_LEAVE:
case FL_DND_RELEASE:
return 1;
case FL_PASTE:
{
const char *text = Fl::event_text();

char *file;

if ( ! sscanf( text, "file://%a[^\r\n]\n", &file ) )
{
printf( "invalid drop \"%s\"\n", text );
return 0;
}

printf( "pasted file \"%s\"\n", file );

Clip *c = Clip::from_file( file );

if ( ! c )
{
free( file );
return 0;
}


Region *r = new Region( c );

r->offset( timeline.x_to_ts( Fl::event_x() ) );
r->position( Fl::event_x(), r->y() );

this->add( r );

return 1;
}
default:
return Fl_Group::handle( m );
}
}
}; };

+ 24
- 50
Waveform.C View File

@@ -21,8 +21,10 @@


#include <FL/Enumerations.H> #include <FL/Enumerations.H>
#include <FL/Fl.H> #include <FL/Fl.H>
#include <FL/fl_draw.H>


#include "Waveform.H"
#include "Timeline.H"
// #include "Waveform.H"
#include "Clip.H" #include "Clip.H"


// extern Timeline timeline; // extern Timeline timeline;
@@ -30,66 +32,40 @@


#include <math.h> #include <math.h>


extern Fl_Color velocity_colors[];
/* void */
/* Waveform::draw ( void ) */
/* { */
/* int X, Y, W, H; */


Waveform::Waveform ( int X, int Y, int W, int H, const char *L ) : Fl_Widget( X, Y, W, H, L )
{
_scale = 1;
_clip = NULL;

_start = _end = 0;
}

int measure = 50;

void
Waveform::draw ( void )
{
// draw_box( FL_PLASTIC_UP_BOX, x(), y(), w(), h(), color() );

/* fl_color( fl_lighter( color() ) ); */

/* for ( int nx = x(); nx < x() + w(); ++nx ) */
/* if ( ! (nx % measure) ) */
/* fl_line( nx, y(), nx, y() + h() ); */
/* fl_clip_box( x(), y(), w(), h(), X, Y, W, H ); */


int X, Y, W, H;

fl_clip_box( x(), y(), w(), h(), X, Y, W, H );

draw( X, y(), W, h() );
}
/* draw( X, y(), W, h() ); */
/* } */


/** draw a portion of /clip/'s waveform. coordinates are the portion to draw */
void void
Waveform::draw ( int X, int Y, int W, int H )
draw_waveform ( int X, int Y, int W, int H, Clip *_clip, nframes_t _start, nframes_t _end, float _scale, Fl_Color color )
{ {
fl_push_clip( X, Y, W, H ); fl_push_clip( X, Y, W, H );


// fl_push_matrix();

int j; int j;


// int start = (_start + (X - x())) * 2;

int start = timeline.ts_to_x( _start ) + (X - x() );
int start = timeline.ts_to_x( _start );


{ {
nframes_t start = timeline.x_to_ts( X - x() ) + _start;
_clip->peaks()->fill_buffer( start,
start + timeline.x_to_ts( W ) );
_clip->peaks()->fill_buffer( _start,
_start + timeline.x_to_ts( W ) );
} }


j = start; j = start;
for ( int x = X; x < X + W; ++x, ++j ) for ( int x = X; x < X + W; ++x, ++j )
{ {
// read_peaks( x, &hi, &lo );
Peak p = (*_clip->peaks())[ j ]; Peak p = (*_clip->peaks())[ j ];


int mid = Y + (H / 2); int mid = Y + (H / 2);


// FIXME: cache this stuff. // FIXME: cache this stuff.
// fl_color( fl_color_average( selection_color(), fl_contrast( fl_darker( FL_BLUE ), selection_color() ), fabs( hi - lo ) ) );
fl_color( fl_color_average( FL_RED, selection_color(), fabs( p.max - p.min ) ) );
fl_color( fl_color_average( FL_RED, color, fabs( p.max - p.min ) ) );


p.max *= _scale; p.max *= _scale;
p.min *= _scale; p.min *= _scale;
@@ -101,7 +77,7 @@ Waveform::draw ( int X, int Y, int W, int H )


} }


fl_color( fl_darker( fl_darker( selection_color() ) ) );
fl_color( fl_darker( fl_darker( color ) ) );




fl_line_style( FL_SOLID, 2 ); fl_line_style( FL_SOLID, 2 );
@@ -136,17 +112,15 @@ Waveform::draw ( int X, int Y, int W, int H )


fl_line_style( FL_SOLID, 0 ); fl_line_style( FL_SOLID, 0 );


// fl_pop_matrix();

fl_pop_clip(); fl_pop_clip();
} }


void
Waveform::normalize ( void )
{
printf( "normalize: start=%lu end=%lu\n", _start, _end );
/* void */
/* Waveform::normalize ( void ) */
/* { */
/* printf( "normalize: start=%lu end=%lu\n", _start, _end ); */


_scale = _clip->peaks()->normalization_factor( _start, _end );
/* _scale = _clip->peaks()->normalization_factor( _start, _end ); */


redraw();
}
/* redraw(); */
/* } */

+ 1
- 55
Waveform.H View File

@@ -26,58 +26,4 @@


#include "Clip.H" #include "Clip.H"


class Waveform : public Fl_Widget
{

protected:

Clip *_clip; /* clip this waveform represents */

nframes_t _start;
nframes_t _end;

float _scale; /* vertical scaling */
float _zoom; /* horizontal zoom */

public:

Waveform ( int X, int Y, int W, int H, const char *L=0 );

Waveform ( Clip *c ) : Fl_Widget( 0, 0, 500, 100, "" )
{
_clip = c;
_scale = 1;
label( _clip->name() );

_start = 0;
_end = _clip->length();

size( timeline.ts_to_x( _end ), h() );
}

Waveform ( const Waveform & rhs ) : Fl_Widget( rhs.x(), rhs.y(), rhs.w(), rhs.h(), rhs.label() )
{
_clip = rhs._clip;
_start = rhs._start;
_end = rhs._end;
_scale = rhs._scale;
}


void draw ( void );
void draw ( int X, int Y, int W, int H );

void start ( nframes_t s ) { _start = s; }
nframes_t start ( void ) const { return _start; }
void end ( nframes_t e ) { _end = e; }
nframes_t end ( void ) const { return _end; }
nframes_t length ( void ) const { return _end - _start; }
void scale ( float s ) { _scale = s; }
float scale ( void ) const { return _scale; }

// void peaks ( float *p ) { _peaks = p; }
void normalize ( void );

void read_peaks ( int X, float *hi, float *lo );

};
void draw_waveform ( int X, int Y, int W, int H, Clip *_clip, nframes_t _start, nframes_t _end, float _scale, Fl_Color color );

+ 19
- 13
main.C View File

@@ -26,7 +26,7 @@
#include <FL/Fl_Group.H> #include <FL/Fl_Group.H>
#include <FL/Fl_Slider.H> #include <FL/Fl_Slider.H>


#include "Waveform.H"
// #include "Waveform.H"
#include "Region.H" #include "Region.H"


#include <stdio.h> #include <stdio.h>
@@ -57,12 +57,12 @@ cb_zoom ( Fl_Widget *w, void *v )
timeline.fpp = ((Fl_Slider*)w)->value(); timeline.fpp = ((Fl_Slider*)w)->value();




for ( int i = timeline.tracks->children(); i-- ; )
{
Fl_Group *track = (Fl_Group*)timeline.tracks->child( i );
for ( int j = track->children(); j-- ; )
((Region*)(track->child( j )))->resize();
}
/* for ( int i = timeline.tracks->children(); i-- ; ) */
/* { */
/* Fl_Group *track = (Fl_Group*)timeline.tracks->child( i ); */
/* for ( int j = track->children(); j-- ; ) */
/* ((Region*)(track->child( j )))->resize(); */
/* } */


timeline.scroll->redraw(); timeline.scroll->redraw();


@@ -83,12 +83,13 @@ main ( int argc, char **argv )
Fl_Double_Window *main_window = new Fl_Double_Window( 0, 0, 800, 600 ); Fl_Double_Window *main_window = new Fl_Double_Window( 0, 0, 800, 600 );


timeline.scroll = new Fl_Scroll( 0, 24, 800, 600 - 24 ); timeline.scroll = new Fl_Scroll( 0, 24, 800, 600 - 24 );
timeline.scroll->type( Fl_Scroll::VERTICAL );
timeline.fpp = 256; timeline.fpp = 256;




timeline.sample_rate = 44100; timeline.sample_rate = 44100;


timeline.tracks = new Fl_Pack( 0, 0, 32767, 5000 );
timeline.tracks = new Fl_Pack( 0, 0, 800, 5000 );
timeline.tracks->type( Fl_Pack::VERTICAL ); timeline.tracks->type( Fl_Pack::VERTICAL );
timeline.tracks->spacing( 20 ); timeline.tracks->spacing( 20 );


@@ -97,7 +98,7 @@ main ( int argc, char **argv )


// Fl_Group *pack = new Fl_Group( 0, 0, 5000, 600 ); // Fl_Group *pack = new Fl_Group( 0, 0, 5000, 600 );


Track *track1 = new Track( 40, 0, 32768, 100 );
Track *track1 = new Track( 40, 0, 800, 100 );


// pack->type( Fl_Pack::VERTICAL ); // pack->type( Fl_Pack::VERTICAL );
// pack->box( FL_DOWN_BOX ); // pack->box( FL_DOWN_BOX );
@@ -109,13 +110,18 @@ main ( int argc, char **argv )
// wave->resize( 0, 0, 500, 100 ); // wave->resize( 0, 0, 500, 100 );


wave->offset( 1024 ); wave->offset( 1024 );
wave->end( 3000 );


wave->color( FL_CYAN );
wave->selection_color( fl_darker( FL_GRAY ) );
wave->selection_color( FL_GREEN );
/* wave->color( FL_CYAN ); */
/* wave->selection_color( fl_darker( FL_GRAY ) ); */
/* wave->selection_color( FL_GREEN ); */


track1->add( wave ); track1->add( wave );


Region *wave3 = new Region( *wave );
wave3->offset( 4000 );
track1->add( wave3 );

track1->end(); track1->end();


Track *track2 = new Track( 40, 0, 5000, 100 ); Track *track2 = new Track( 40, 0, 5000, 100 );
@@ -148,7 +154,7 @@ main ( int argc, char **argv )
main_window->end(); main_window->end();
main_window->show(); main_window->show();


wave->redraw();
/* wave->redraw(); */


Fl::run(); Fl::run();
} }

Write Preview
Loading…
Cancel
Save