void Block_Properties(
struct Blocks *block,
NInt num_tracks,
int num_lines
){
if(num_tracks!=block->num_tracks){
struct Tracker_Windows *window=root->song->tracker_windows;
while(window!=NULL){
struct WBlocks *wblock=(struct WBlocks *)ListFindElement1(&window->wblocks->l,block->l.num);
SetCursorPosConcrete(window,wblock,0,-1);
window=NextWindow(window);
}
Block_Set_num_tracks(block,num_tracks);
}
if(num_lines!=block->num_lines){
Block_Set_num_lines(block,num_lines);
}
struct Tracker_Windows *window=root->song->tracker_windows;
while(window!=NULL){
struct WBlocks *wblock=ListFindElement1(&window->wblocks->l,block->l.num);
if(wblock->curr_realline>=wblock->num_reallines){
wblock->curr_realline = wblock->num_reallines-1;
}
UpdateReallinesDependens(window,wblock);
window=NextWindow(window);
}
}
static void DrawAllWTrackOnOffs(
struct Tracker_Windows *window,
struct WBlocks *wblock
)
{
struct WTracks *wtrack=(struct WTracks *)ListFindElement1(&wblock->wtracks->l,wblock->left_track);
while(wtrack!=NULL && wtrack->l.num<=wblock->right_track){
if(wtrack->track->onoff==0){
GFX_T_Line(window,WAVEFORM_COLOR_NUM,
wtrack->x+2,wtrack->y+1,
wtrack->x2-2,wtrack->y+(window->org_fontheight*2)-1,
PAINT_BUFFER
);
GFX_T_Line(window,WAVEFORM_COLOR_NUM,
wtrack->x2-2,wtrack->y+1,
wtrack->x+2,wtrack->y+(window->org_fontheight*2)-1,
PAINT_BUFFER
);
}
wtrack=NextWTrack(wtrack);
}
}
void *Undo_Do_Range(
struct Tracker_Windows *window,
struct WBlocks *wblock,
struct WTracks *wtrack,
int realline,
void *pointer
){
struct Range *undo_range=(struct Range *)pointer;
struct WTracks *mywtrack;
struct Tracks *track;
struct Notes *notetemp;
struct Stops *stoptemp;
NInt num_tracks=undo_range->num_tracks;
NInt lokke;
for(lokke=0;lokke<num_tracks;lokke++){
mywtrack=ListFindElement1(&wblock->wtracks->l,lokke+wtrack->l.num);
track=mywtrack->track;
notetemp=track->notes;
stoptemp=track->stops;
track->notes=undo_range->notes[lokke];
track->stops=undo_range->stops[lokke];
undo_range->notes[lokke]=notetemp;
undo_range->stops[lokke]=stoptemp;
}
return undo_range;
}
void SetMouseActionWTrackBorder(
struct Tracker_Windows *window,
struct MouseAction *action,
int x
){
struct WBlocks *wblock=window->wblock;
NInt wtracknum=wblock->left_track;
NInt rwtracknum=wblock->right_track;
struct WTracks *wtrack=ListFindElement1(&wblock->wtracks->l,wtracknum);
struct WTracks *next=NextWTrack(wtrack);
if(x<=wtrack->fxarea.x){
SetMouseActionTempoNodeBorder(window,action,x);
return;
}
for(;;){
if(wtrack->l.num==rwtracknum) break;
if(x>=wtrack->x2 && x<=next->fxarea.x) break;
wtrack=next;
next=NextWTrack(wtrack);
}
if(wtrack->x < wblock->t.x1) return; // Changing trackwidth of a partly shown track doesnt work quite well.
action->eint1=wtrack->l.num;
action->action=TRACKBORDER;
action->MouseUpFunction= &MoveWTrackBorder_Mouse;
}
void InsertTracks(
struct Tracker_Windows *window,
struct WBlocks *wblock,
NInt tracknum,
NInt toinsert
){
NInt lokke;
NInt num_tracks;
struct Blocks *block=wblock->block;
struct WTracks *wtrack;
struct Tracks *track;
if(tracknum>=block->num_tracks+1 || tracknum<0) return;
if(toinsert<=0){
if(toinsert<0) DeleteTracks(window,wblock,tracknum,-toinsert);
return;
}
num_tracks=block->num_tracks+toinsert;
PC_Pause();{
Block_Set_num_tracks(block,num_tracks);
for(lokke=num_tracks-1;lokke>=tracknum+toinsert;lokke--){
wtrack=CB_CopyTrack(
wblock,
ListFindElement1(&wblock->wtracks->l,lokke-toinsert)
);
co_CB_PasteTrack(
wblock,
wtrack,
ListFindElement1(&wblock->wtracks->l,lokke)
);
}
for(lokke=tracknum;lokke<tracknum+toinsert;lokke++){
wtrack=ListFindElement1(&wblock->wtracks->l,lokke);
track=wtrack->track;
track->notes=NULL;
track->stops=NULL;
VECTOR_clean(&track->fxs);
track->patch=NULL;
}
}PC_StopPause(NULL);
}
void DeleteTracks(
struct Tracker_Windows *window,
struct WBlocks *wblock,
NInt tracknum,
NInt todelete
)
{
NInt lokke;
NInt num_tracks;
struct Blocks *block=wblock->block;
struct WTracks *wtrack;
if(tracknum>=block->num_tracks+1 || tracknum<0) return;
if(tracknum-todelete>=block->num_tracks){
todelete=block->num_tracks-tracknum;
}
PC_Pause();
if(block->num_tracks==1){
CB_CutTrack_CurrPos(window);
goto exit;
}
num_tracks=block->num_tracks-todelete;
fprintf(stderr,"delete track. Curr: %d, num_tracks: %d, todelete: %d\n",tracknum,num_tracks,todelete);
for(lokke=tracknum ; lokke<num_tracks-1+todelete;lokke++){
wtrack=CB_CopyTrack(
wblock,
ListFindElement1(&wblock->wtracks->l,lokke+todelete)
);
co_CB_PasteTrack(
wblock,
wtrack,
ListFindElement1(&wblock->wtracks->l,lokke)
);
}
Block_Set_num_tracks(block,num_tracks);
exit:
PC_StopPause(NULL);
}
int CursorLeft(struct Tracker_Windows *window,struct WBlocks *wblock){
if(window->curr_track>0 || (0==window->curr_track && window->curr_track_sub>=0)){
window->curr_track_sub--;
if(window->curr_track_sub==-2){
do{
ATOMIC_INC(window->curr_track, -1);
R_ASSERT_RETURN_IF_FALSE2(window->curr_track >= 0, 0);
ATOMIC_WRITE(wblock->wtrack, ListFindElement1(&wblock->wtracks->l,window->curr_track));
}while(wblock->wtrack==NULL);
int num_subtracks = GetNumSubtracks(wblock->wtrack);
window->curr_track_sub=num_subtracks-1;
}
if(
window->curr_track<wblock->left_track ||
(window->curr_track==wblock->left_track && window->curr_track_sub<wblock->left_subtrack)
){
wblock->left_subtrack=-1;//window->curr_track_sub;
wblock->left_track=window->curr_track;
printf(" left_track: %d, left_subtrack: %d. curr_track: %d\n",wblock->left_track, wblock->left_subtrack,window->curr_track);
//UpdateAllWTracksCoordinates(window,wblock);
UpdateWBlockCoordinates(window,wblock);
return 2;
}else{
printf(" left_track: %d, left_subtrack: %d, curr_track: %d\n",wblock->left_track, wblock->left_subtrack,window->curr_track);
return 1;
}
}else{
if (window->curr_track==TEMPOTRACK)
return 0;
ATOMIC_INC(window->curr_track, -1);
if (window->curr_track==TEMPONODETRACK && window->show_reltempo_track==false)
ATOMIC_INC(window->curr_track, -1);
if (window->curr_track==LINENUMBTRACK)
ATOMIC_INC(window->curr_track, -1);
if (window->curr_track==SIGNATURETRACK && window->show_signature_track==false)
ATOMIC_INC(window->curr_track, -1);
if (window->curr_track==LPBTRACK && window->show_lpb_track==false)
ATOMIC_INC(window->curr_track, -1);
if (window->curr_track==TEMPOTRACK && window->show_bpm_track==false)
set_curr_track_to_leftmost_legal_track(window);
return 1;
}
}
// Simpler version when using opengl
void P2MUpdateSongPosCallBack(void){
bool setfirstpos=ATOMIC_GET(root->setfirstpos);
NInt curr_block_num = ATOMIC_GET(root->curr_blocknum);
struct Tracker_Windows *window=root->song->tracker_windows;
struct WBlocks *wblock = ListFindElement1(&window->wblocks->l,curr_block_num);
int old_curr_realline = wblock->curr_realline;
int till_curr_realline = R_BOUNDARIES(0, ATOMIC_GET(wblock->till_curr_realline), wblock->num_reallines-1); // till_curr_realline can be set from any thread, at any time, to any value.
if (!ATOMIC_GET(root->play_cursor_onoff)){
//printf("P2MUpdateSongPosCallBack: Setting to %d\n",till_curr_realline);
wblock->curr_realline = till_curr_realline;
wblock->top_realline += till_curr_realline - old_curr_realline;
wblock->bot_realline += till_curr_realline - old_curr_realline;
}
if(pc->playtype==PLAYSONG)
BS_SelectPlaylistPos(ATOMIC_GET2(root->curr_playlist));
if(window->curr_block!=curr_block_num){
//printf("Bef. w: %d, r: %d\n",window->curr_block,root->curr_block);
if(setfirstpos){
wblock->curr_realline=0;
SetWBlock_Top_And_Bot_Realline(window,wblock);
GE_set_curr_realline(0);
}
SelectWBlock(
window,
wblock
);
//printf("Aft. w: %d, r: %d\n",window->curr_block,root->curr_block);
}
// make sure "Rec" is updated
{
static struct Tracks *current_track = NULL;
static bool current_track_recording = false;
struct Tracks *track = wblock->wtrack->track;
if (track != current_track || (current_track!=NULL && track->is_recording != current_track_recording)){
current_track = track;
current_track_recording = current_track->is_recording;
GL_create(window, wblock);
}
}
//GE_set_curr_realline(wblock->curr_realline);
// printf("till_curr_realline: %d\n",wblock->till_curr_realline);
//ScrollEditorToRealLine(window,wblock,wblock->curr_realline);
}
void PlaySongCurrPos(struct Tracker_Windows *window){
struct Blocks *block;
struct WBlocks *wblock;
Place *place;
int playpos;
bool changeblock=false;
wblock=window->wblock;
PlayStopReally(false);
root->setfirstpos=false;
playpos=root->curr_playlist;
block=BL_GetBlockFromPos(playpos);
if(block==NULL) return;
if(wblock->l.num!=block->l.num){
wblock=ListFindElement1(&window->wblocks->l,block->l.num);
changeblock=true;
root->setfirstpos=true;
}
if(
! changeblock &&
playpos==root->song->length-1 &&
wblock->curr_realline==wblock->num_reallines // ??. Never supposed to happen.
){
return;
}
if(wblock->curr_realline==0) root->setfirstpos=true;
debug("contsong, playpos: %d , root->curr_block: %d\n",playpos,root->curr_block);
if(changeblock){
place=PlaceGetFirstPos();
pc->seqtime=0;
}else{
place=&wblock->reallines[wblock->curr_realline]->l.p;
pc->seqtime=-Place2STime(wblock->block,place);
}
debug("contsong, time: %d, playpos: %d , root->curr_block: %d\n",pc->seqtime,playpos,root->curr_block);
place->line++;
debug("nextline: %d\n",Place2STime(wblock->block,place));
place->line--;
PlaySong(place,playpos);
}
void Block_Set_num_tracks(
struct Blocks *block,
NInt num_tracks
){
struct Tracker_Windows *window=root->song->tracker_windows;
struct WBlocks *wblock;
NInt org_num_tracks=block->num_tracks;
NInt lokke;
if(num_tracks==0){
RError("Error in function 'Block_Set_num_tracks' in file 'block_properties.c'. num_tracks=0.\n");
return;
}
if(num_tracks==org_num_tracks) return;
block->num_tracks=num_tracks;
if(num_tracks<org_num_tracks){
CutListAt1(&block->tracks,num_tracks);
while(window!=NULL){
wblock=(struct WBlocks *)ListFindElement1(&window->wblocks->l,block->l.num);
CutListAt1(&wblock->wtracks,num_tracks);
window=NextWindow(window);
}
}else{
for(lokke=org_num_tracks;lokke<num_tracks;lokke++){
AppendTrack(block);
}
window=root->song->tracker_windows;
while(window!=NULL){
wblock=(struct WBlocks *)ListFindElement1(&window->wblocks->l,block->l.num);
UpdateWTracks(window,wblock);
window=NextWindow(window);
}
}
}
static void DrawAllPianoRollHeaders_old(
struct Tracker_Windows *window,
struct WBlocks *wblock
)
{
struct WTracks *wtrack=(struct WTracks *)ListFindElement1(&wblock->wtracks->l,wblock->left_track);
while(wtrack!=NULL && wtrack->l.num<=wblock->right_track){
//struct Tracks *track = wtrack->track;
int x1 = wtrack->x + 2;
int x2 = wtrack->panonoff.x1;
int y1 = wtrack->panonoff.y1;
//int y2 = wtrack->panonoff.y2;
// Text
// GFX_SetClipRect(window,x1, 0, x2, wblock->t.y1, PAINT_BUFFER);
{
//static char temp[500];
//sprintf(temp,"%d->%d:", wtrack1->l.num, wtrack2->l.num);
int midpos1 = scale(1,0,3,x1,x2);
int midpos2 = scale(2,0,3,x1,x2);
//printf("_________ T_TEXT %d: %s %d %d %d. midpos: %d, x1: %d, x2: %d\n",wtrack->l.num,NotesTexts3[wtrack->pianoroll_lowkey],x1,y1,midpos-x1,midpos,x1,x2);
GFX_T_Text(
window, 8, NotesTexts3[wtrack->pianoroll_lowkey],
x1,
y1+3,
midpos1 - x1,
TEXT_CLIPRECT|TEXT_SCALE|TEXT_CENTER|TEXT_BOLD,
PAINT_BUFFER
);
printf("%d:, x1: %d, midpos1: %d, midpos2: %d, x2: %d\n",wtrack->l.num,x1, midpos1, midpos2, x2);
GFX_T_Text(
window, 8, NotesTexts3[wtrack->pianoroll_highkey],
midpos2,
y1+3,
x2 - midpos2,
TEXT_CLIPRECT|TEXT_SCALE|TEXT_CENTER|TEXT_BOLD,
PAINT_BUFFER
);
}
//GFX_CancelClipRect(window,PAINT_BUFFER);
wtrack=NextWTrack(wtrack);
}
}
void DLoadWTracks(
struct Root *newroot,
struct Tracker_Windows *window,
struct WBlocks *wblock,
struct WTracks *wtrack
){
if(wtrack==NULL) return;
wtrack->fxonoff=1;
wtrack->track=(struct Tracks *)ListFindElement1(&wblock->block->tracks->l,wtrack->l.num);
DLoadWTracks(newroot,window,wblock,NextWTrack(wtrack));
}
bool SetCursorPosConcrete(
struct Tracker_Windows *window,
struct WBlocks *wblock,
NInt tracknum,
int subtrack
){
struct WTracks *wtrack;
int ret=0,tempret;
if(tracknum>=wblock->block->num_tracks || tracknum<TEMPOTRACK) return false;
if(tracknum<0){
if(tracknum==window->curr_track) return true;
if(tracknum>window->curr_track){
while(window->curr_track!=tracknum){
tempret=CursorRight(window,wblock);
ret=R_MAX(tempret,ret);
}
}else{
while(window->curr_track!=tracknum){
tempret=CursorLeft(window,wblock);
ret=R_MAX(tempret,ret);
}
}
}else{
wtrack=ListFindElement1(&wblock->wtracks->l,tracknum);
int num_subtracks = GetNumSubtracks(wtrack);
subtrack=R_MIN(num_subtracks-1,subtrack);
if(tracknum==window->curr_track && subtrack==window->curr_track_sub)
return 0;
if(tracknum>window->curr_track || (tracknum==window->curr_track && subtrack>window->curr_track_sub)){
while(window->curr_track!=tracknum || window->curr_track_sub!=subtrack){
tempret=CursorRight(window,wblock);
//printf("wtrack->num: %d, curr_track: %d, num_tracks: %d\n",wtrack->l.num, window->curr_track,wblock->block->num_tracks);
ret=R_MAX(tempret,ret);
}
}else{
while(window->curr_track!=tracknum || window->curr_track_sub!=subtrack){
tempret=CursorLeft(window,wblock);
ret=R_MAX(tempret,ret);
}
}
}
return true;
}
int CursorLeft(struct Tracker_Windows *window,struct WBlocks *wblock){
struct WTracks *wtrack=wblock->wtrack;
if(window->curr_track>0 || (0==window->curr_track && window->curr_track_sub>=0)){
window->curr_track_sub--;
if(window->curr_track_sub==-2){
wblock->wtrack=ListFindElement1(&wblock->wtracks->l,wtrack->l.num-1);
int num_subtracks = GetNumSubtracks(wblock->wtrack->track);
window->curr_track_sub=num_subtracks-1;
window->curr_track--;
}
if(
window->curr_track<wblock->left_track ||
(window->curr_track==wblock->left_track && window->curr_track_sub<wblock->left_subtrack)
){
wblock->left_subtrack=window->curr_track_sub;
wblock->left_track=window->curr_track;
UpdateAllWTracksCoordinates(window,wblock);
return 2;
}else{
return 1;
}
}else{
if (window->curr_track==TEMPOTRACK)
return 0;
window->curr_track--;
if (window->curr_track==TEMPONODETRACK && window->show_reltempo_track==false)
window->curr_track--;
if (window->curr_track==LINENUMBTRACK)
window->curr_track--;
if (window->curr_track==SIGNATURETRACK && window->show_signature_track==false)
window->curr_track--;
if (window->curr_track==LPBTRACK && window->show_lpb_track==false)
window->curr_track--;
if (window->curr_track==TEMPOTRACK && window->show_bpm_track==false)
set_curr_track_to_leftmost_legal_track(window);
return 1;
}
}
void DeleteBlock(
NInt blockpos
){
struct Tracker_Windows *window=root->song->tracker_windows;
struct WBlocks *wblock;
struct Blocks *removed_block=ListFindElement1(&root->song->blocks->l,blockpos);
struct Blocks *nextblock=NextBlock(removed_block);
ListRemoveElement1(&root->song->blocks,&removed_block->l);
{
struct Blocks *block = nextblock;
while(block!=NULL){
block->l.num--;
block=NextBlock(block);
}
}
root->song->num_blocks--;
while(window!=NULL){
wblock=ListFindElement1(&window->wblocks->l,blockpos);
ListRemoveElement1(
&window->wblocks,
&wblock->l
);
wblock=NextWBlock(wblock);
while(wblock!=NULL){
wblock->l.num--;
wblock=NextWBlock(wblock);
}
window=NextWindow(window);
}
// Call BL_removeBlockFromPlaylist after blocklist is updated.
BL_removeBlockFromPlaylist(removed_block);
}
int CloseTrackerWindow(NInt place){
struct Tracker_Windows *temp;
temp=(struct Tracker_Windows *)ListFindElement1(&root->song->tracker_windows->l,place);
if(temp==NULL) return 1;
GFX_ShutDownVisual(temp);
// temp->wblock=NULL;
ListRemoveElement1(&root->song->tracker_windows,&temp->l);
return 0;
}
void UpdateSomeFXNodeLines(
struct Tracker_Windows *window,
struct WBlocks *wblock,
NInt starttrack,
NInt endtrack
){
NInt lokke;
struct WTracks *wtrack=ListFindElement1(&wblock->wtracks->l,starttrack);
if(wtrack==NULL) return;
for(lokke=0;lokke<=endtrack-starttrack;lokke++){
UpdateFXNodeLines(window,wblock,wtrack);
wtrack=NextWTrack(wtrack);
if(wtrack==NULL) break;
}
}
static void DrawAllWTrackSliders(
struct Tracker_Windows *window,
struct WBlocks *wblock
)
{
struct WTracks *wtrack=(struct WTracks *)ListFindElement1(&wblock->wtracks->l,wblock->left_track);
while(wtrack!=NULL && wtrack->l.num<=wblock->right_track){
if(wtrack->x >= wblock->a.x2){
break;
}
UpdatePanSlider(window,wblock,wtrack);
UpdateVolumeSlider(window,wblock,wtrack);
wtrack=NextWTrack(wtrack);
}
}
void ADD_UNDO_FUNC(Block_Delete(NInt blockpos)){
struct Tracker_Windows *window=root->song->tracker_windows;
struct WBlocks *wblock=window->wblock;
struct Undo_Block_InsertDelete *ubi=talloc(sizeof(struct Undo_Block_InsertDelete));
ubi->blockpos=blockpos;
ubi->wblock=(struct WBlocks *)ListFindElement1(&window->wblocks->l,blockpos);
ubi->sequencer_state=SEQUENCER_get_state();
Undo_Add(
window->l.num,
wblock->l.num,
window->curr_track,
wblock->curr_realline,
ubi,
Undo_Do_Block_Delete,
"Block delete"
);
}
void Undo_Block_Delete(
NInt blockpos
){
struct Tracker_Windows *window=root->song->tracker_windows;
struct WBlocks *wblock=window->wblock;
struct Undo_Block_InsertDelete *ubi=talloc(sizeof(struct Undo_Block_InsertDelete));
ubi->blockpos=blockpos;
ubi->wblock=(struct WBlocks *)ListFindElement1(&window->wblocks->l,blockpos);
ubi->playlist=BL_copy();
Undo_Add(
window->l.num,
wblock->l.num,
window->curr_track,
wblock->curr_realline,
ubi,
Undo_Do_Block_Delete
);
}
void InvertRange(
struct WBlocks *wblock
){
struct Tracks *track;
int lokke;
Place *p1,*p2;
if( ! wblock->isranged) return;
p1=getRangeStartPlace(wblock);
p2=getRangeEndPlace(wblock);
track=ListFindElement1(&wblock->block->tracks->l,wblock->rangex1);
for(lokke=0;lokke<=wblock->rangex2-wblock->rangex1;lokke++){
Invert_notes(track->notes,p1,p2,true,0);
track=NextTrack(track);
}
}
void CutRange(
struct Blocks *block,
NInt starttrack,
NInt endtrack,
Place *p1,
Place *p2
){
struct Tracks *track;
int lokke;
endtrack = R_MIN(block->num_tracks-1, endtrack);
if (endtrack < starttrack)
return;
track=ListFindElement1(&block->tracks->l,starttrack);
PC_Pause();{
for(lokke=0;lokke<=endtrack-starttrack;lokke++){
CutRange_notes(&track->notes,track->notes,p1,p2);
CutRange_stops(&track->stops,track->stops,p1,p2);
track=NextTrack(track);
if(track==NULL) break;
}
Place *startplace = p1;
Place *endplace = p2;
SCHEME_eval(
talloc_format("(cut-fx-range! %d %d %d (+ %d (/ %d %d)) (+ %d (/ %d %d)))",
block->l.num,
starttrack,
endtrack,
startplace->line, startplace->counter, startplace->dividor,
endplace->line, endplace->counter, endplace->dividor
)
);
}PC_StopPause(NULL);
}
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()
);
}
void *Undo_Do_Block_Insert(
struct Tracker_Windows *window,
struct WBlocks *wblock,
struct WTracks *wtrack,
int realline,
void *pointer
){
struct Undo_Block_InsertDelete *ubi=(struct Undo_Block_InsertDelete *)pointer;
if(ubi->wblock!=NULL){
return Undo_Do_Block_Delete(window,wblock,wtrack,realline,pointer);
}
ubi->wblock=(struct WBlocks *)ListFindElement1(&window->wblocks->l,ubi->blockpos);
DeleteBlock(ubi->blockpos);
SEQUENCER_create_from_state(ubi->sequencer_state);
BS_UpdateBlockList();
BS_UpdatePlayList();
return ubi;
}
struct Blocks *InsertBlock_CurrPos(
struct Tracker_Windows *window
)
{
struct WBlocks *wblock=window->wblock;
NInt blockpos=wblock->l.num;
ADD_UNDO(Block_Insert(blockpos));
struct Blocks *ret;
PC_Pause();{
ret = InsertBlock(blockpos,wblock->block->num_tracks,wblock->block->num_lines,"NN");
SelectWBlock(window,(struct WBlocks *)ListFindElement1(&window->wblocks->l,blockpos));
BS_UpdateBlockList();
BS_UpdatePlayList();
}PC_StopPause(window);
return ret;
}
static void handleDirtyBlock(int blocknum){
struct Tracker_Windows *window = root->song->tracker_windows;
while(window!=NULL){
struct WBlocks *wblock=ListFindElement1(&window->wblocks->l,blocknum);
UpdateAllWTracksCoordinates(window,wblock);
UpdateAndClearSomeTrackReallinesAndGfxWTracks(
window,
wblock,
0,
window->wblock->block->num_tracks-1
);
if(wblock->curr_realline>=wblock->num_reallines){
wblock->curr_realline=wblock->num_reallines-1;
}
UpdateReallinesDependens(window,wblock);
window=NextWindow(window);
}
}
/************************************************************************
FUNCTION
These two functions works just like GetXSubTrack1 and 2, except
that they also accept the tracks that contains to the block. Which
is the signature-track, lpb-track, tempo-track, and the temponode-track.
************************************************************************/
int GetXSubTrack_B1(
const struct WBlocks *wblock,
NInt track,
int subtrack
){
if(track>=0) return GetXSubTrack1(ListFindElement1(&wblock->wtracks->l,track),subtrack);
switch(track){
case SIGNATURETRACK:
return wblock->signaturearea.x;
break;
case LPBTRACK:
return wblock->lpbarea.x;
break;
case TEMPOTRACK:
return wblock->tempoarea.x;
break;
case TEMPONODETRACK:
return wblock->temponodearea.x;
break;
};
RError("Error in function GetXSubTrack_B1 in file gfx_subtrack.c\n");
return 0;
}
static void DrawAllWTrackNames(
struct Tracker_Windows *window,
struct WBlocks *wblock
)
{
struct WTracks *wtrack1 = (struct WTracks *)ListFindElement1(&wblock->wtracks->l,wblock->left_track);
if (wtrack1==NULL)
return;
int tracknum1 = wtrack1->l.num;
int channelnum1 = ATOMIC_GET(wtrack1->track->midi_channel);
struct Patch *patch1 = wtrack1->track->patch;
struct WTracks *wtrack2 = NextWTrack(wtrack1);
int tracknum2 = tracknum1;
for(;;){
int channelnum2 = wtrack2==NULL ? 0 : ATOMIC_GET(wtrack2->track->midi_channel);
if (wtrack2==NULL || wtrack2->track->patch==NULL || patch1==NULL || wtrack2->track->patch != patch1 || channelnum2 != channelnum1){
DrawWTrackNames(window, wblock, tracknum1, tracknum2);
tracknum1 = tracknum2 = tracknum2+1;
channelnum1 = channelnum2;
patch1 = wtrack2==NULL ? NULL : wtrack2->track->patch;
} else {
tracknum2++;
}
if (wtrack2==NULL)
break;
else
wtrack2 = NextWTrack(wtrack2);
}
}
void MIDIGetEvents(
struct Instruments *instrument,
int arg0,
int arg1,
int arg2,
int arg3
)
{
struct Tracker_Windows *window=root->song->tracker_windows;
struct Patch *patch=g_currpatch;
struct PatchData *patchdata;
int channel;
switch(arg0){
case MIDIEVENT_USE0x90FORNOTEOFF:
useOx90ForNoteOff=arg1;
break;
case MIDIEVENT_NEWPATCH:
SelectPatch(window,window->wblock->wtrack->track);
return;
break;
case MIDIEVENT_SETSTANDARDVEL:
if(g_currpatch==NULL){
root->standardvel=arg1;
}else{
g_currpatch->standardvel=arg1;
}
break;
case MIDIEVENT_CHANGECURRENTPATCH:
{
struct Patch *patch=NULL;
if(arg1!=0){
patch=ListFindElement1(&instrument->patches->l,arg1);
}
if( ! is_playing()){
window->wblock->wtrack->track->patch=patch;
if (patch != NULL)
patch->has_been_assigned_to_editor_track = true;
DrawWTrackHeader(window,window->wblock,window->wblock->wtrack);
}
instrument->PP_Update(instrument,patch,false);
}
break;
case MIDIEVENT_CHANGECURRENTPORT:
printf("MIDIEVENT_CHANGE.. %d\n",arg1);
break;
default:
break;
}
if(g_currpatch==NULL) return;
patchdata=(struct PatchData *)patch->patchdata;
channel=patchdata->channel;
struct MidiPort *midi_port = patchdata->midi_port;
printf("Got MidiEvent %d, %d,%d,%d\n",arg0,arg1,arg2,arg3);
if(arg0>0x7f){
R_PutMidi3(midi_port,arg0,arg1,arg2);
}else{
switch(arg0){
case MIDIEVENT_SETMIDIINPUT:
break;
case MIDIEVENT_CHANGEPATCHNAME:
break;
case MIDIEVENT_SETPORT:
break;
case MIDIEVENT_CHANGEPORT:
break;
case MIDIEVENT_SETCHANNEL:
if(arg1<1 || arg1>16){
MIDIGFX_SetChannel(patchdata->channel);
}else{
patchdata->channel=arg1-1;
MIDIGFX_UpdateAll();
}
break;
case MIDIEVENT_SETMSB:
if(arg1>=-1 && arg1<128){
patchdata->MSB=arg1;
}else{
MIDIGFX_SetMSB(patchdata->MSB);
}
break;
case MIDIEVENT_SETLSB:
if(arg1>=-1 && arg1<128){
patchdata->LSB=arg1;
}else{
MIDIGFX_SetLSB(patchdata->LSB);
}
break;
case MIDIEVENT_SETPRESET:
patchdata->preset=arg1-1;
break;
case MIDIEVENT_PANNINGONOFF:
patchdata->panonoff=patchdata->panonoff?false:true;
MIDIGFX_SetPanSlider(patchdata->panonoff,patchdata->pan);
break;
case MIDIEVENT_SETPANNING:
patchdata->pan=arg1;
D_PutMidi3(midi_port,0xb0|channel,0xa,patchdata->pan);
break;
case MIDIEVENT_SETVOLONOFF:
patchdata->volumeonoff=patchdata->volumeonoff?false:true;
MIDIGFX_SetVolumeSlider(patchdata->volumeonoff,patchdata->volume);
break;
case MIDIEVENT_SETVOL:
patchdata->volume=arg1;
D_PutMidi3(midi_port,0xb0|channel,0x7,patchdata->volume);
break;
case MIDIEVENT_CC_ONOFF:
patchdata->ccsonoff[arg1]=arg2==1?true:false;
MIDIGFX_SetCCSlider(arg1,patchdata->ccsonoff[arg1],patchdata->ccvalues[arg1]);
break;
case MIDIEVENT_CC_VAL:
patchdata->ccvalues[arg1]=arg2;
break;
default:
printf("Unknown MIDIEVENT message: %d\n",arg0);
break;
}
}
}
int MoveWTrackBorder_Mouse(
struct Tracker_Windows *window,
float x,float y
){
struct WBlocks *wblock=window->wblock;
struct WTracks *wtrack=(struct WTracks *)ListFindElement1_r0(&wblock->wtracks->l,(NInt)window->prevaction.eint1);
if(window->prevaction.action==NOACTION)
window->must_redraw=true; // fix up slightly skewed gradient caused by the direct blitting. (blitting is wrong, but it's faster)
if(wtrack==NULL) return 0;
x=R_BOUNDARIES(wtrack->fxarea.x+3, x, wblock->t.x2-3);
int oldfxwidth=wtrack->fxwidth;
wtrack->fxwidth=x - wtrack->fxarea.x;
wtrack->fxwidth=R_MAX(wtrack->fxwidth,2);
if(oldfxwidth==wtrack->fxwidth && window->prevaction.action!=NOACTION){
return 0;
}
#if !USE_OPENGL
NInt oldrighttrack=wblock->right_track;
GFX_BitBlt(window,wtrack->fxwidth-oldfxwidth,0,
wtrack->fxarea.x2-2,wblock->a.y1,
wblock->a.x2,wblock->t.y2
);
#endif
UpdateWBlockCoordinates(window,wblock);
DrawAllWTrackHeaders(window,wblock);
#if !USE_OPENGL
DrawUpWTrack(window,wblock,wtrack);
struct WTracks *wtrack2;
if(oldfxwidth>wtrack->fxwidth){
wtrack2=ListFindElement1(&wblock->wtracks->l,oldrighttrack);
while(wtrack2!=NULL && wtrack2->l.num<=wblock->right_track){
DrawUpWTrack(window,wblock,wtrack2);
DrawWTrackHeader(window,wblock,wtrack2);
wtrack2=NextWTrack(wtrack2);
}
}else{
while(GetXSubTrack_B2(wblock,window->curr_track,window->curr_track_sub)+3>=wblock->a.x2){
window->curr_track_sub--;
if(window->curr_track_sub==-2){
wblock->wtrack=ListFindElement1(&wblock->wtracks->l,window->curr_track-1);
window->curr_track_sub=wblock->wtrack->num_vel-1;
window->curr_track--;
}
}
}
wtrack2=ListLast1(&wblock->wtracks->l);
if(wtrack2->fxarea.x2<wblock->a.x2){
GFX_FilledBox(window,0,
wtrack2->fxarea.x2+1,wblock->a.y1,
wblock->a.x2,wblock->t.y1,
PAINT_BUFFER);
GFX_FilledBox(window,0,wtrack2->fxarea.x2+3,wblock->a.y1,wblock->a.x2,wblock->t.y2,PAINT_BUFFER);
EraseAllLines(window,wblock,
wtrack2->x, wtrack2->x2);
}
UpdateBottomSlider(window);
if(wtrack->fxarea.x2<wblock->a.x2){
Blt_mark(window,wblock->top_realline,wblock->bot_realline,
wtrack->fxarea.x2,wblock->a.x2
);
Blt_marktrackheader(window,wtrack->l.num,wblock->right_track);
}
#else
UpdateBottomSlider(window);
{
struct WTracks *wtrack2=wtrack;
while(wtrack2!=NULL && wtrack2->l.num<=wblock->right_track){
DrawAllWTrackHeaders(window,wblock);
wtrack2=NextWTrack(wtrack2);
}
}
#endif
//window->must_redraw=true;
return 0;
}
