void InsertLines_notes(
void *tonote,
struct ListHeader3 *l,
int line,
int toinsert
){
struct Notes *note=(struct Notes *)l;
struct Blocks *block=blocktobelongtoforinsertlines_notes_a_terrible_hack;
Place p2;
PlaceSetLastPos(block,&p2);
// p2.line-=toinsert;
// printf("toinsert: %d, note->end.line: %d, p2->line: %d\n",toinsert,note->end.line,p2.line);
if(note->end.line>=line){
// printf("block: %d, note->end.line: %d, p2->line: %d\n",block->l.num,note->end.line,p2.line);
if(PlaceGreaterOrEqual(¬e->end,&p2) && note->l.p.line<line){
PlaceSetLastPos(block,&p2);
PlaceCopy(¬e->end,&p2);
note->noend=1;
}else{
note->end.line+=toinsert;
note->end.line=R_MAX(note->end.line,line);
}
List_InsertLines3(¬e->velocities,¬e->velocities->l,line,toinsert,NULL);
List_InsertLines3(¬e->pitches,¬e->pitches->l,line,toinsert,NULL);
}
}
static void STP_Constructor(STimePlace *stp,struct Blocks *block){
/* Misc */
PlaceSetFirstPos(&stp->firstplace);
PlaceSetLastPos(block,&stp->lastplace);
stp->btempo=false;
stp->blpb=false;
stp->breltempo=false;
/* Times */
stp->times = talloc(sizeof(struct STimes)*(block->num_lines+1));
/* Tempos */
stp->tempo=root->tempo;
stp->stempo= block->tempos;
if(stp->stempo!=NULL && PlaceEqual(&stp->firstplace,&stp->stempo->l.p)){
stp->tempo=stp->stempo->tempo;
stp->stempo=NextTempo(stp->stempo);
}
/* LBPs */
stp->lpb=root->lpb;
stp->slpb=block->lpbs;
if(stp->slpb!=NULL && PlaceEqual(&stp->firstplace,&stp->slpb->l.p)){
stp->lpb=stp->slpb->lpb;
stp->slpb=NextLPB(stp->slpb);
}
/* TempoNodes */
stp->temponode=block->temponodes;
stp->relp1=GetDoubleFromPlace(&stp->temponode->l.p); // first temponode is allways at firstplace (just try dragging down the highest temponode).
stp->reltempo1=stp->temponode->reltempo;
stp->temponode=NextTempoNode(stp->temponode);
stp->relp2=GetDoubleFromPlace(&stp->temponode->l.p); // There is allways at least two temponode objects for each block.
stp->reltempo2=stp->temponode->reltempo;
/* Placements */
stp->p1= &stp->firstplace;
stp->p2=&stp->temponode->l.p;
if(stp->stempo!=NULL){
stp->p2=PlaceMin(stp->p2,&stp->stempo->l.p);
}
if(stp->slpb!=NULL){
stp->p2=PlaceMin(stp->p2,&stp->slpb->l.p);
}
/* bools */
if(stp->stempo!=NULL && PlaceEqual(stp->p2,&stp->stempo->l.p)) stp->btempo=true;
if(stp->slpb!=NULL && PlaceEqual(stp->p2,&stp->slpb->l.p)) stp->blpb=true;
if(PlaceEqual(stp->p2,&stp->temponode->l.p)) stp->breltempo=true;
/* time */
stp->nexttime=0;
}
static void AddFXNodeLineCurrPosInternal(struct Tracker_Windows *window, struct WBlocks *wblock, struct WTracks *wtrack, struct FX *fx, const Place *place, float val){
Undo_FXs_CurrPos(window);
struct FXs *fxs=ListFindElement1_r0(&wtrack->track->fxs->l,fx->num);
if (fxs==NULL){
Place p2;
int realline=FindRealLineFor(wblock,0,place);
if(realline>=wblock->num_reallines-5){
PlaceSetLastPos(wblock->block,&p2);
}else{
PlaceCopy(&p2,&wblock->reallines[wblock->curr_realline+3]->l.p);
}
AddNewTypeOfFxNodeLine(wblock, wtrack, fx, &p2, val);
}
AddFXNodeLine(
window,wblock,wtrack,
fx->num,
val,
place
);
#if !USE_OPENGL
UpdateFXNodeLines(window,wblock,wtrack);
ClearTrack(window,wblock,wtrack,wblock->top_realline,wblock->bot_realline);
UpdateWTrack(window,wblock,wtrack,wblock->top_realline,wblock->bot_realline);
#endif
}
static bool co_CB_PasteTrackFX(
struct WBlocks *wblock,
struct WTracks *wtrack,
struct WTracks *towtrack
){
struct Tracks *totrack;
struct Tracks *track;
Place *p1,p2;
R_ASSERT_RETURN_IF_FALSE2(towtrack!=NULL, false);
totrack=towtrack->track;
track=wtrack->track;
make_patches_usable(track);
if (totrack->patch == NULL)
totrack->patch = track->patch;
if(track->midi_instrumentdata!=NULL){
totrack->midi_instrumentdata=MIDI_CopyInstrumentData(track);
}
VECTOR_clean(&totrack->fxs);
p1=PlaceGetFirstPos();
PlaceSetLastPos(wblock->block,&p2);
CopyRange_fxs(&totrack->fxs,&track->fxs,p1,&p2);
LegalizeFXlines(wblock->block,totrack);
return true;
}
void RA_addNote_FloatPlace(
int blocknum,
int tracknum,
float start,
int notenum,
float volume,
float end)
{
struct Blocks *block=SWIG_getBlock(blocknum);
struct Tracks *track=SWIG_getTrack(blocknum,tracknum);
struct Notes *note;
Place p2;
if(track==NULL) return;
note=NewNote();
Float2Placement(start,¬e->l.p);
Float2Placement(end,¬e->end);
PlaceSetLastPos(block,&p2);
if(PlaceGreaterOrEqual(¬e->l.p,&p2)) return;
if(PlaceGreaterOrEqual(¬e->end,&p2)){
PlaceCopy(¬e->end,&p2);
}
note->note=notenum;
note->velocity=boundaries(
volume*(*track->instrument->getMaxVelocity)(track),
0,
(*track->instrument->getMaxVelocity)(track)
);
ListAddElement3(&track->notes,¬e->l);
}
Place STime2Place(
const struct Blocks *block,
STime time
)
{
Place place;
Place *firstplace = PlaceGetFirstPos();
Place lastplace;
PlaceSetLastPos(block, &lastplace);
if (time < 0) {
return *firstplace;
}
if (time >= getBlockSTimeLength(block)){
PlaceTilLimit(&place,&lastplace);
return place;
}
double place_f = STime2Place_f(block,time);
Double2Placement(place_f, &place);
if (PlaceGreaterOrEqual(&place, &lastplace))
PlaceTilLimit(&place,&lastplace);
else if (PlaceLessThan(&place,firstplace))
place = *firstplace;
//if (place.line==64)
// abort();
return place;
}
void InvertTrack(
struct Blocks *block,
struct Tracks *track
){
Place p1,p2;
PlaceSetFirstPos(&p1);
PlaceSetLastPos(block,&p2);
Invert_notes(track->notes,&p1,&p2,true,0);
}
bool CB_PasteTrack(
struct WBlocks *wblock,
struct WTracks *wtrack,
struct WTracks *towtrack
){
struct Tracks *totrack;
struct Tracks *track;
Place *p1,p2;
if(towtrack==NULL){
RError("Error in function CB_PasteTrack in file clipboard_track_paste.c; towtrack=NULL\n");
return false;
}
totrack=towtrack->track;
track=wtrack->track;
towtrack->notelength=wtrack->notelength;
towtrack->fxwidth=wtrack->fxwidth;
totrack->patch=track->patch;
totrack->onoff=track->onoff;
totrack->pan=track->pan;
totrack->volume=track->volume;
totrack->panonoff=track->panonoff;
totrack->volumeonoff=track->volumeonoff;
if(track->midi_instrumentdata!=NULL){
totrack->midi_instrumentdata=MIDI_CopyInstrumentData(track);
}
totrack->trackname=talloc_strdup(track->trackname);
totrack->notes=NULL;
totrack->stops=NULL;
totrack->fxs=NULL;
p1=PlaceGetFirstPos();
PlaceSetLastPos(wblock->block,&p2);
CopyRange_notes(&totrack->notes,track->notes,p1,&p2);
CopyRange_stops(&totrack->stops,track->stops,p1,&p2);
CopyRange_fxs(&totrack->fxs,track->fxs,p1,&p2);
LegalizeFXlines(wblock->block,totrack);
LegalizeNotes(wblock->block,totrack);
return true;
}
static bool paste_track(
struct WBlocks *wblock,
struct WTracks *wtrack,
struct WTracks *towtrack
)
{
struct Tracks *totrack = towtrack->track;
struct Tracks *track = wtrack->track;
Place *p1,p2;
towtrack->notelength=wtrack->notelength;
towtrack->fxwidth=wtrack->fxwidth;
totrack->onoff=track->onoff;
totrack->pan=track->pan;
totrack->volume=track->volume;
totrack->panonoff=track->panonoff;
totrack->volumeonoff=track->volumeonoff;
ATOMIC_SET(totrack->midi_channel, ATOMIC_GET(track->midi_channel));
if(track->midi_instrumentdata!=NULL){
totrack->midi_instrumentdata=MIDI_CopyInstrumentData(track);
}
totrack->trackname=talloc_strdup(track->trackname);
totrack->notes=NULL;
totrack->stops=NULL;
VECTOR_clean(&totrack->fxs);
p1=PlaceGetFirstPos();
PlaceSetLastPos(wblock->block,&p2);
CopyRange_notes(&totrack->notes,track->notes,p1,&p2);
CopyRange_stops(&totrack->stops,track->stops,p1,&p2);
if (totrack->patch != NULL)
CopyRange_fxs(&totrack->fxs,&track->fxs,p1,&p2);
LegalizeFXlines(wblock->block,totrack);
LegalizeNotes(wblock->block,totrack);
return true;
}
/**************************************************************
FUNCTION
Set the _end attributes for note 'note'.
Finds next note to stop at, or block length.
**************************************************************/
void SetEndAttributes(
const struct Blocks *block,
const struct Tracks *track,
struct Notes *note
){
Place *place;
Place *p1=NULL,*p2=NULL;
bool endSetEarlier = PlaceGreaterThan(¬e->end, ¬e->l.p);
Place *earliest = endSetEarlier ? ¬e->end : ¬e->l.p;
struct ListHeader3 *nextnote=note->l.next;
while(nextnote!=NULL){
if(PlaceGreaterThan(&nextnote->p, earliest)){
p1 = &nextnote->p;
break;
}
nextnote=nextnote->next;
}
struct ListHeader3 *stop= &track->stops->l;
while(stop!=NULL){
if(PlaceGreaterThan(&stop->p, earliest)){
p2 = &stop->p;
break;
}
stop=stop->next;
}
place=PlaceMin(p1,p2);
if(place!=NULL){
note->end.line=place->line;
note->end.counter=place->counter;
note->end.dividor=place->dividor;
}else{
PlaceSetLastPos(block, ¬e->end);
note->noend=1;
}
ValidatePlace(¬e->end);
}
void Undo_Range(
struct Tracker_Windows *window,
struct Blocks *block,
NInt starttrack,
NInt endtrack,
int realline
){
Place *p1=PlaceGetFirstPos();
Place p2;
struct Range *undo_range;
NInt num_tracks;
NInt lokke;
struct Tracks *track;
NInt num_tracks_in_block=block->num_tracks;
if(endtrack>=num_tracks_in_block){
num_tracks=num_tracks_in_block-1;
}else{
num_tracks=endtrack-starttrack+1;
}
undo_range=talloc(sizeof(struct Range));
undo_range->notes=talloc((size_t)(sizeof(struct Notes *)*num_tracks));
undo_range->stops=talloc((size_t)(sizeof(struct Stops *)*num_tracks));
undo_range->num_tracks=num_tracks;
PlaceSetLastPos(block,&p2);
for(lokke=0;lokke<num_tracks;lokke++){
track=ListFindElement1(&block->tracks->l,lokke+starttrack);
CopyRange_stops(&undo_range->stops[lokke],track->stops,p1,&p2);
CopyRange_notes(&undo_range->notes[lokke],track->notes,p1,&p2);
}
Undo_Add(window->l.num,block->l.num,starttrack,realline,
undo_range,Undo_Do_Range,
"Range",
LOC()
);
}
bool CB_PasteTrackFX(
struct WBlocks *wblock,
struct WTracks *wtrack,
struct WTracks *towtrack
){
struct Tracks *totrack;
struct Tracks *track;
Place *p1,p2;
if(towtrack==NULL){
RError("Error in function CB_PasteTrack in file clipboard_track_paste.c; towtrack=NULL\n");
return false;
}
totrack=towtrack->track;
track=wtrack->track;
if(totrack->patch==NULL){
totrack->patch=track->patch;
}
totrack->patch=track->patch;
if(track->midi_instrumentdata!=NULL){
totrack->midi_instrumentdata=MIDI_CopyInstrumentData(track);
}
totrack->fxs=NULL;
p1=PlaceGetFirstPos();
PlaceSetLastPos(wblock->block,&p2);
CopyRange_fxs(&totrack->fxs,track->fxs,p1,&p2);
LegalizeFXlines(wblock->block,totrack);
return true;
}
void Undo_Notes(
struct Tracker_Windows *window,
struct Blocks *block,
struct Tracks *track,
int realline
){
Place *p1=PlaceGetFirstPos();
Place p2;
struct Undo_Notes *undo_notes=talloc(sizeof(struct Undo_Notes));
PlaceSetLastPos(block,&p2);
CopyRange_stops(&undo_notes->stops,track->stops,p1,&p2);
CopyRange_notes(&undo_notes->notes,track->notes,p1,&p2);
Undo_Add(
window->l.num,
block->l.num,
track->l.num,
realline,
undo_notes,
Undo_Do_Notes);
}
void CB_PasteTrack_CurrPos(struct Tracker_Windows *window){
struct WBlocks *wblock=window->wblock;
struct Blocks *block=wblock->block;
struct WTracks *wtrack=wblock->wtrack;
Place lastplace;
PlaceSetLastPos(wblock->block,&lastplace);
PC_Pause();
switch(window->curr_track){
case SIGNATURETRACK:
if(cb_signature==NULL) goto exit;
ADD_UNDO(Signatures_CurrPos(window));
block->signatures=CB_CopySignatures(cb_signature);
CutListAt_a(&block->signatures,&lastplace);
UpdateWBlockWidths(window, wblock);
UpdateBeats(block);
//UpdateSTimes(block);
//UpdateWLPBs(window,wblock);
break;
case LPBTRACK:
if(cb_lpb==NULL) goto exit;
ADD_UNDO(LPBs_CurrPos(window));
block->lpbs=CB_CopyLPBs(cb_lpb);
CutListAt_a(&block->lpbs,&lastplace);
UpdateSTimes(block);
//UpdateWLPBs(window,wblock);
UpdateBeats(block);
#if !USE_OPENGL
DrawUpLPBs(window,wblock);
#endif
break;
case TEMPOTRACK:
if(cb_tempo==NULL) goto exit;
ADD_UNDO(Tempos_CurrPos(window));
block->tempos=CB_CopyTempos(cb_tempo);
CutListAt_a(&block->tempos,&lastplace);
//UpdateWTempos(window,wblock);
#if !USE_OPENGL
DrawUpTempos(window,wblock);
#endif
UpdateSTimes(block);
break;
case TEMPONODETRACK:
if(cb_temponode==NULL) goto exit;
ADD_UNDO(TempoNodes_CurrPos(window));
block->temponodes=CB_CopyTempoNodes(cb_temponode);
CutListAt_a(&block->temponodes,&lastplace);
LegalizeTempoNodes(block);
#if !USE_OPENGL
///UpdateWTempoNodes(window,wblock);
DrawUpWTempoNodes(window,wblock);
#endif
UpdateSTimes(block);
break;
default:
if(cb_wtrack==NULL) goto exit;
Undo_Open_rec();{
printf("curr_track_sub: %d\n",window->curr_track_sub);
ADD_UNDO(Track_CurrPos(window));
if(window->curr_track_sub==-1 && cb_wtrack_only_contains_one_fxs==false){
// copy all
printf("aaa\n");
if(co_CB_PasteTrack(wblock,cb_wtrack,wtrack)){
#if !USE_OPENGL
UpdateFXNodeLines(window,wblock,wtrack);
#endif
window->must_redraw = true;
}else{
#if !USE_OPENGL
UpdateAndClearSomeTrackReallinesAndGfxWTracks(
window,
wblock,
window->curr_track,
window->curr_track
);
#endif
}
}else{
printf("bbb\n");
// only copy fx
struct WTracks *fromwtrack = cb_wtrack;
if (cb_wtrack_only_contains_one_fxs==true){
// only copy one fx
R_ASSERT(cb_wtrack->track->fxs.num_elements==1);
struct FXs *fxs = cb_wtrack->track->fxs.elements[0];
vector_t *fxss = VECTOR_copy(&wtrack->track->fxs);
remove_fxs_from_fxss(fxss, fxs);
VECTOR_push_back(fxss, fxs);
fromwtrack = CB_CopyTrack(wblock, cb_wtrack);
fromwtrack->track->fxs = *VECTOR_copy(fxss);
}
if(co_CB_PasteTrackFX(wblock,fromwtrack,wtrack)){
#if !USE_OPENGL
UpdateFXNodeLines(window,wblock,wtrack);
#endif
window->must_redraw = true;
}else{
#if !USE_OPENGL
UpdateAndClearSomeTrackReallinesAndGfxWTracks(
window,
wblock,
window->curr_track,
window->curr_track
);
#endif
}
}
}Undo_Close();
break;
}
SetNotePolyphonyAttributes(wtrack->track);
ValidateCursorPos(window);
exit:
PC_StopPause(window);
}
static void set_legal_start_and_end_pos(const struct Blocks *block, struct Tracks *track, struct Notes *note){
Place *start = ¬e->l.p;
Place *end = ¬e->end;
Place endplace;
PlaceSetLastPos(block,&endplace);
if(PlaceGreaterOrEqual(start,&endplace)) {
RError("note is placed after block end. start: %f, end: %f", GetfloatFromPlace(¬e->l.p), GetfloatFromPlace(¬e->end));
set_new_position(track, note, PlaceCreate(block->num_lines - 2, 0, 1), NULL);
start = ¬e->l.p;
}
if (start->line < 0) {
RError("note is placed before block start. start: %f, end: %f", GetfloatFromPlace(¬e->l.p), GetfloatFromPlace(¬e->end));
set_new_position(track, note, PlaceCreate(0,1,1), NULL);
start = ¬e->l.p;
}
if(PlaceGreaterThan(end,&endplace)) {
RError("note end is placed after block end. start: %f, end: %f. block end: %f", GetfloatFromPlace(¬e->l.p), GetfloatFromPlace(¬e->end), GetfloatFromPlace(&endplace));
set_new_position(track, note, NULL, &endplace);
end = ¬e->end;
}
if (note->velocities != NULL) {
{
struct Velocities *first_velocity = note->velocities;
if(PlaceGreaterThan(start, &first_velocity->l.p)){
RError("note start is placed after first velocity. start: %f, first: %f, end: %f", GetfloatFromPlace(¬e->l.p), GetfloatFromPlace(&first_velocity->l.p), GetfloatFromPlace(¬e->end));
float e = p_float(first_velocity->l.p);
e -= 0.01;
e = R_MAX(0.0, e);
Place new_start;
Float2Placement(e, &new_start);
set_new_position(track, note, &new_start, NULL);
start = ¬e->l.p;
}
}
struct Velocities *last_velocity = (struct Velocities*)ListLast3(¬e->velocities->l);
if(PlaceLessThan(end, &last_velocity->l.p)){
RError("note end is placed before last velocity. start: %f, last: %f, end: %f", GetfloatFromPlace(¬e->l.p), GetfloatFromPlace(&last_velocity->l.p), GetfloatFromPlace(¬e->end));
float e = p_float(last_velocity->l.p);
e += 0.01;
Place new_end;
Float2Placement(e, &new_end);
set_new_position(track, note, NULL, &new_end);
end = ¬e->end;
}
}
if (note->pitches != NULL) {
{
struct Pitches *first_pitch = note->pitches;
if(PlaceGreaterThan(start, &first_pitch->l.p)){
RError("note start is placed after first pitch. start: %f, first: %f, end: %f", GetfloatFromPlace(¬e->l.p), GetfloatFromPlace(&first_pitch->l.p), GetfloatFromPlace(¬e->end));
float e = p_float(first_pitch->l.p);
e -= 0.01;
e = R_MAX(0.0, e);
Place new_start;
Float2Placement(e, &new_start);
set_new_position(track, note, &new_start, NULL);
start = ¬e->l.p;
}
}
struct Pitches *last_pitch = (struct Pitches*)ListLast3(¬e->pitches->l);
if(PlaceLessThan(end, &last_pitch->l.p)){
RError("note end is placed before last pitch. start: %f, last: %f, end: %f", GetfloatFromPlace(¬e->l.p), GetfloatFromPlace(&last_pitch->l.p), GetfloatFromPlace(¬e->end));
float e = p_float(last_pitch->l.p);
e += 0.01;
Place new_end;
Float2Placement(e, &new_end);
set_new_position(track, note, NULL, &new_end);
end = ¬e->end;
}
}
if(PlaceLessOrEqual(end,start)) {
RError("note end is placed before (or on) note start. start: %f, end: %f", GetfloatFromPlace(¬e->l.p), GetfloatFromPlace(¬e->end));
float e = p_float(*start);
e += 0.01;
Place new_end;
Float2Placement(e, &new_end);
set_new_position(track, note, NULL, &new_end);
}
}
void CB_PasteTrack_CurrPos(struct Tracker_Windows *window){
struct WBlocks *wblock=window->wblock;
struct Blocks *block=wblock->block;
struct WTracks *wtrack=wblock->wtrack;
Place lastplace;
PlayStop();
PlaceSetLastPos(wblock->block,&lastplace);
switch(window->curr_track){
case LPBTRACK:
if(cb_lpb==NULL) return;
Undo_LPBs_CurrPos(window);
block->lpbs=CB_CopyLPBs(cb_lpb);
CutListAt_a(&block->lpbs,&lastplace);
UpdateSTimes(block);
UpdateBeats(block);
UpdateWLPBs(window,wblock);
#if !USE_OPENGL
DrawUpLPBs(window,wblock);
#endif
break;
case TEMPOTRACK:
if(cb_tempo==NULL) return;
Undo_Tempos_CurrPos(window);
block->tempos=CB_CopyTempos(cb_tempo);
CutListAt_a(&block->tempos,&lastplace);
//UpdateWTempos(window,wblock);
#if !USE_OPENGL
DrawUpTempos(window,wblock);
#endif
UpdateSTimes(block);
break;
case TEMPONODETRACK:
if(cb_temponode==NULL) return;
Undo_TempoNodes_CurrPos(window);
block->temponodes=CB_CopyTempoNodes(cb_temponode);
CutListAt_a(&block->temponodes,&lastplace);
LegalizeTempoNodes(block);
#if !USE_OPENGL
UpdateWTempoNodes(window,wblock);
DrawUpWTempoNodes(window,wblock);
#endif
UpdateSTimes(block);
break;
default:
if(cb_wtrack==NULL) return;
Undo_Track_CurrPos(window);
if(window->curr_track_sub==-1){
if(CB_PasteTrack(wblock,cb_wtrack,wtrack)){
#if !USE_OPENGL
UpdateFXNodeLines(window,wblock,wtrack);
#endif
window->must_redraw = true;
}else{
#if !USE_OPENGL
UpdateAndClearSomeTrackReallinesAndGfxWTracks(
window,
wblock,
window->curr_track,
window->curr_track
);
#endif
}
}else{
if(CB_PasteTrackFX(wblock,cb_wtrack,wtrack)){
#if !USE_OPENGL
UpdateFXNodeLines(window,wblock,wtrack);
#endif
window->must_redraw = true;
}else{
#if !USE_OPENGL
UpdateAndClearSomeTrackReallinesAndGfxWTracks(
window,
wblock,
window->curr_track,
window->curr_track
);
#endif
}
}
break;
}
SetNoteSubtrackAttributes(wtrack->track);
ValidateCursorPos(window);
}
void Block_Set_num_lines(
struct Blocks *block,
int num_lines
){
Place lastplace1,lastplace;
struct Tracker_Windows *window=root->song->tracker_windows;
struct WBlocks *wblock;
struct LocalZooms *localzoom;
struct Tracks *track=block->tracks;
struct Notes *note;
struct FXs *fxs;
int org_num_lines=block->num_lines;
int lokke;
if(org_num_lines==num_lines || num_lines<2) return;
PlaceSetLastPos(block,&lastplace1);
block->num_lines=num_lines;
PlaceSetLastPos(block,&lastplace);
if(num_lines<org_num_lines){
CutListAt_a(&block->lpbs,&lastplace);
CutListAt_a(&block->tempos,&lastplace);
CutListAt_a(&block->temponodes,&lastplace);
PlaceSetLastPos(block,&block->lasttemponode->l.p);
ListAddElement3(&block->temponodes,&block->lasttemponode->l);
while(track!=NULL){
CutListAt_a(&track->notes,&lastplace);
note=track->notes;
while(note!=NULL){
CutListAt(¬e->velocities,&lastplace);
CutListAt(¬e->pitches,&lastplace);
if(PlaceEqual(¬e->end,&lastplace1) && note->noend==1){
PlaceCopy(¬e->end,&lastplace);
}
note=NextNote(note);
}
LegalizeNotes(block,track);
CutListAt_a(&track->stops,&lastplace);
fxs=track->fxs;
while(fxs!=NULL){
CutListAt_a(&fxs->fxnodelines,&lastplace);
fxs=NextFX(fxs);
}
LegalizeFXlines(block,track);
track=NextTrack(track);
}
while(window!=NULL){
wblock=ListFindElement1(&window->wblocks->l,block->l.num);
CutListAt_a(&wblock->localzooms,&lastplace);
window=NextWindow(window);
}
}else{
PlaceSetLastPos(block,&block->lasttemponode->l.p);
while(track!=NULL){
note=track->notes;
while(note!=NULL){
if(PlaceEqual(¬e->end,&lastplace1) && note->noend==1){
PlaceSetLastPos(block,¬e->end);
}
note=NextNote(note);
}
LegalizeNotes(block,track);
track=NextTrack(track);
}
while(window!=NULL){
wblock=ListFindElement1(&window->wblocks->l,block->l.num);
for(lokke=org_num_lines;lokke<num_lines;lokke++){
localzoom=talloc(sizeof(struct LocalZooms));
localzoom->Tline=lokke;
localzoom->Tdividor=1;
localzoom->zoomline=lokke;
ListAddElement3(&wblock->localzooms,&localzoom->l);
}
window=NextWindow(window);
}
}
window=root->song->tracker_windows;
while(window!=NULL){
wblock=ListFindElement1(&window->wblocks->l,block->l.num);
UpdateWBlockWidths(window,wblock);
UpdateRealLines(window,wblock);
window=NextWindow(window);
}
UpdateSTimes(block);
UpdateBeats(block);
}