Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.javascript > #36151 > unrolled thread

Realtime pianoroll "scroll" logic

Started byJonas Thörnvall <jonas.thornvall@gmail.com>
First post2019-03-24 15:38 -0700
Last post2019-03-26 19:17 +0000
Articles 14 — 2 participants

Back to article view | Back to comp.lang.javascript

Contents

  Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-24 15:38 -0700
    Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-24 22:06 -0700
      Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-25 02:44 -0700
    Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-25 04:59 -0700
      Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-25 05:29 -0700
        Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-25 05:33 -0700
          Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-25 06:04 -0700
            Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-25 06:10 -0700
            Re: Realtime pianoroll "scroll" logic John G Harris <niam@jghnorth.org.uk.invalid> - 2019-03-25 18:17 +0000
              Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-26 00:17 -0700
                Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-26 02:04 -0700
                  Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-26 07:24 -0700
                    Re: Realtime pianoroll "scroll" logic Jonas Thörnvall <jonas.thornvall@gmail.com> - 2019-03-26 07:46 -0700
                Re: Realtime pianoroll "scroll" logic John G Harris <niam@jghnorth.org.uk.invalid> - 2019-03-26 19:17 +0000

#36151 — Realtime pianoroll "scroll" logic

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-24 15:38 -0700
SubjectRealtime pianoroll "scroll" logic
Message-ID<efe5cd64-b4ae-4553-8ad9-77422f159bcf@googlegroups.com>
Recording, I now buffer the key strokes "note on and off" in an array. But the logic for a pianoroll isn't as plain and easy as i thought.

Now this is only a visual thingy so no ***exact time*** is needed for the calculation of pianoroll keystrokes "only position".

I can't see i missed any case, but the pianoroll does not behave as i expect.

CASE 1 KEY PRESSED STILL NOT RELEASED, FRONTEND MOVE INDEPENDENT OF LOCKED STARTPOINT "CALCULATE  FRONTEND RELATIVE SCROLLBAR ENTRYPOINT

CASE 2 KEY IS RELEASED, ***FIXED LENGTH*** OF KEYSTROKE CALCULATED

CASE 3 BOTH FRONTEND AND BACKEND MOVING synchronus, frontend calculated using offset relative scrollbar "same as CASE1", backend calculated using "LENGTH CASE 2" relative the frontend

I know it is hard to read others logic but i tried keep complexity to a minimum, maybe someone done something similar comoving thingy and have a good eye for logics.

http://midisequenser.000webhostapp.com/

var xKeylength=0;
var midiEv=0;
var xFrontStart=[];
var FRONTOFFSET=[];
var backStuck=0;
var keyreleased=[];
for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}

function pianoSCROLL(){
console.log(pianoroll.length); 
var nbrOfEv = pianoroll.length;
  while (midiEv<nbrOfEv){
    
    // Pianoroll Array Events reversed last event "keypress" ***IS FIRST***, 
    
    // CASE one still holding key only front moves
    // While key not released back is stuck at start of pianoroll "stroke not released still going"
    
    if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
        backStuck=keylength;
        ctm.fillStyle = "magenta";
        ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
        //When key pressed a startpoint, relative scrollbar created ***FRONTOFFSET***
        if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
        xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
    
    //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
    //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 

    } else if(pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==false){
       console.log("keyreleased!");
       for(var q=midiEv+1;q<nbrOfEv;q++){
       if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-xBackEnd;}
       }
    
    //These events should have a moving backend  in sync with the moving front

    } else  if (pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==true) {
      console.log("bothmove");
      ctm.fillStyle = "black";
      ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
      //Math.round(all the values); maybe not needed
      moveFront=scrollBarPos-FRONTOFFSET[midiEv];
      moveBack=moveFront-xBarLength[midiEv];
      ctm.fillStyle = "orange";
      ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
    }

  midiEv++; 
  }
  midiEv=0; 
}

[toc] | [next] | [standalone]

#36152

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-24 22:06 -0700
Message-ID<b5701df6-6498-4e72-9891-ec644588b89c@googlegroups.com>
In reply to#36151
Den söndag 24 mars 2019 kl. 23:38:19 UTC+1 skrev Jonas Thörnvall:
> Recording, I now buffer the key strokes "note on and off" in an array. But the logic for a pianoroll isn't as plain and easy as i thought.
> 
> Now this is only a visual thingy so no ***exact time*** is needed for the calculation of pianoroll keystrokes "only position".
> 
> I can't see i missed any case, but the pianoroll does not behave as i expect.
> 
> CASE 1 KEY PRESSED STILL NOT RELEASED, FRONTEND MOVE INDEPENDENT OF LOCKED STARTPOINT "CALCULATE  FRONTEND RELATIVE SCROLLBAR ENTRYPOINT
> 
> CASE 2 KEY IS RELEASED, ***FIXED LENGTH*** OF KEYSTROKE CALCULATED
> 
> CASE 3 BOTH FRONTEND AND BACKEND MOVING synchronus, frontend calculated using offset relative scrollbar "same as CASE1", backend calculated using "LENGTH CASE 2" relative the frontend
> 
> I know it is hard to read others logic but i tried keep complexity to a minimum, maybe someone done something similar comoving thingy and have a good eye for logics.
> 
> http://midisequenser.000webhostapp.com/
> 
> var xKeylength=0;
> var midiEv=0;
> var xFrontStart=[];
> var FRONTOFFSET=[];
> var backStuck=0;
> var keyreleased=[];
> for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> 
> function pianoSCROLL(){
> console.log(pianoroll.length); 
> var nbrOfEv = pianoroll.length;
>   while (midiEv<nbrOfEv){
>     
>     // Pianoroll Array Events reversed last event "keypress" ***IS FIRST***, 
>     
>     // CASE one still holding key only front moves
>     // While key not released back is stuck at start of pianoroll "stroke not released still going"
>     
>     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
>         backStuck=keylength;
>         ctm.fillStyle = "magenta";
>         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
>         //When key pressed a startpoint, relative scrollbar created ***FRONTOFFSET***
>         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
>         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
>     
>     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
>     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> 
>     } else if(pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==false){
>        console.log("keyreleased!");
>        for(var q=midiEv+1;q<nbrOfEv;q++){
>        if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-xBackEnd;}
>        }
>     
>     //These events should have a moving backend  in sync with the moving front
> 
>     } else  if (pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==true) {
>       console.log("bothmove");
>       ctm.fillStyle = "black";
>       ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
>       //Math.round(all the values); maybe not needed
>       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
>       moveBack=moveFront-xBarLength[midiEv];
>       ctm.fillStyle = "orange";
>       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
>     }
> 
>   midiEv++; 
>   }
>   midiEv=0; 
> }



var xKeylength=0;
var midiEv=0;
var xFrontStart=[];
var FRONTOFFSET=[];
var xBarLength=[];
var keyreleased=[];
var backStuck=0;
for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}

function pianoSCROLL(){
console.log(pianoroll.length); 
var nbrOfEv = pianoroll.length;
  while (midiEv<nbrOfEv){
    
    // Pianoroll Array is reversed last keyevent "keypress / release" ***IS FIRST***, 
    // When still holding key only front moves
    // While key not released back is stuck at start of pianoroll "stroke not released still going"
    if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
        console.log("frontmove");
        backStuck=keylength;
        ctm.fillStyle = "magenta";
        ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
        //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
        if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
        xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
    
    //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
    //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
    } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
       console.log("keyreleased!");
       for(var q=midiEv+1;q<nbrOfEv;q++){ 
           if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[midiEv]=true; keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-backStuck;}
       } 

    //Case not necessary... Length of released bar already calculated above, do nothing
    } else if (pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==true){

    //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
    //So midiEv *fixed* barlength has calculated above
    } else  if (pianoroll[midiEv]==NOTE_ON && keyreleased[midiEv]==true) {
      console.log("bothmove");
      ctm.fillStyle = "black";
      ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
      //Math.round(all the values); maybe not needed
      moveFront=scrollBarPos-FRONTOFFSET[midiEv];
      moveBack=moveFront-xBarLength[midiEv];
      ctm.fillStyle = "orange";
      ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
    }
  midiEv++; 
  }
  midiEv=0; 
}

[toc] | [prev] | [next] | [standalone]

#36156

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-25 02:44 -0700
Message-ID<dbc297a8-f58a-46eb-8faf-6ea07565c167@googlegroups.com>
In reply to#36152
Den måndag 25 mars 2019 kl. 06:06:53 UTC+1 skrev Jonas Thörnvall:
> Den söndag 24 mars 2019 kl. 23:38:19 UTC+1 skrev Jonas Thörnvall:
> > Recording, I now buffer the key strokes "note on and off" in an array. But the logic for a pianoroll isn't as plain and easy as i thought.
> > 
> > Now this is only a visual thingy so no ***exact time*** is needed for the calculation of pianoroll keystrokes "only position".
> > 
> > I can't see i missed any case, but the pianoroll does not behave as i expect.
> > 
> > CASE 1 KEY PRESSED STILL NOT RELEASED, FRONTEND MOVE INDEPENDENT OF LOCKED STARTPOINT "CALCULATE  FRONTEND RELATIVE SCROLLBAR ENTRYPOINT
> > 
> > CASE 2 KEY IS RELEASED, ***FIXED LENGTH*** OF KEYSTROKE CALCULATED
> > 
> > CASE 3 BOTH FRONTEND AND BACKEND MOVING synchronus, frontend calculated using offset relative scrollbar "same as CASE1", backend calculated using "LENGTH CASE 2" relative the frontend
> > 
> > I know it is hard to read others logic but i tried keep complexity to a minimum, maybe someone done something similar comoving thingy and have a good eye for logics.
> > 
> > http://midisequenser.000webhostapp.com/
> > 
> > var xKeylength=0;
> > var midiEv=0;
> > var xFrontStart=[];
> > var FRONTOFFSET=[];
> > var backStuck=0;
> > var keyreleased=[];
> > for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > 
> > function pianoSCROLL(){
> > console.log(pianoroll.length); 
> > var nbrOfEv = pianoroll.length;
> >   while (midiEv<nbrOfEv){
> >     
> >     // Pianoroll Array Events reversed last event "keypress" ***IS FIRST***, 
> >     
> >     // CASE one still holding key only front moves
> >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> >     
> >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> >         backStuck=keylength;
> >         ctm.fillStyle = "magenta";
> >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> >         //When key pressed a startpoint, relative scrollbar created ***FRONTOFFSET***
> >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> >     
> >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> > 
> >     } else if(pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==false){
> >        console.log("keyreleased!");
> >        for(var q=midiEv+1;q<nbrOfEv;q++){
> >        if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-xBackEnd;}
> >        }
> >     
> >     //These events should have a moving backend  in sync with the moving front
> > 
> >     } else  if (pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==true) {
> >       console.log("bothmove");
> >       ctm.fillStyle = "black";
> >       ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
> >       //Math.round(all the values); maybe not needed
> >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> >       moveBack=moveFront-xBarLength[midiEv];
> >       ctm.fillStyle = "orange";
> >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
> >     }
> > 
> >   midiEv++; 
> >   }
> >   midiEv=0; 
> > }
> 
> 
> 
> var xKeylength=0;
> var midiEv=0;
> var xFrontStart=[];
> var FRONTOFFSET=[];
> var xBarLength=[];
> var keyreleased=[];
> var backStuck=0;
> for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> 
> function pianoSCROLL(){
> console.log(pianoroll.length); 
> var nbrOfEv = pianoroll.length;
>   while (midiEv<nbrOfEv){
>     
>     // Pianoroll Array is reversed last keyevent "keypress / release" ***IS FIRST***, 
>     // When still holding key only front moves
>     // While key not released back is stuck at start of pianoroll "stroke not released still going"
>     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
>         console.log("frontmove");
>         backStuck=keylength;
>         ctm.fillStyle = "magenta";
>         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
>         //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
>         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
>         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
>     
>     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
>     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
>     } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
>        console.log("keyreleased!");
>        for(var q=midiEv+1;q<nbrOfEv;q++){ 
>            if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[midiEv]=true; keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-backStuck;}
>        } 
> 
>     //Case not necessary... Length of released bar already calculated above, do nothing
>     } else if (pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==true){
> 
>     //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
>     //So midiEv *fixed* barlength has calculated above
>     } else  if (pianoroll[midiEv]==NOTE_ON && keyreleased[midiEv]==true) {
>       console.log("bothmove");
>       ctm.fillStyle = "black";
>       ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
>       //Math.round(all the values); maybe not needed
>       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
>       moveBack=moveFront-xBarLength[midiEv];
>       ctm.fillStyle = "orange";
>       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
>     }
>   midiEv++; 
>   }
>   midiEv=0; 
> }

Gettin closer but can't quite figure out why not same midiEv is in both NOTE_OM cases. I do set keyreleased[q]=true; as far as i can tell that is the only note on event. Because i only press key once and release it. The OFFSET[midiEv] become zero in NOTE ON KEYRELEASE TRUE CASE. But for the correct mideEv there is of course a value set. I am not sure how wrong midiEv can have NOTE ON suddenly.

var midiEv=0;
var xFrontStart=[];
var FRONTOFFSET=[];
var xBarLength=[];
var keyreleased=[]; 
backStuck=50;
for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}

function pianoSCROLL(){
console.log(pianoroll.length); 
var nbrOfEv = pianoroll.length;
  while (midiEv<nbrOfEv){
    
    // Pianoroll Array is reversed last keyevent "keypress / release" ***IS FIRST***, 
    // When still holding key only front moves
    // While key not released back is stuck at start of pianoroll "stroke not released still going"
    if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
        console.log("frontmove");
       
        ctm.fillStyle = "magenta";
        ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
        //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
        if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
        xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
        console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
    
    //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
    //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
    } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
       console.log("keyreleased!");
       for(var q=midiEv+1;q<nbrOfEv;q++){ 
        console.log("midiEv="+midiEv+" q="+q);
        console.log(" pianoroll[q].data0="+pianoroll[q].data0+" pianoroll[midiEv].data0="+pianoroll[midiEv].data0);
        console.log(" pianoroll[q].data1="+pianoroll[q].data1+" pianoroll[midiEv].data1="+pianoroll[midiEv].data1);
           if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[midiEv]=true; keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-backStuck;}
       } 

    //Case not necessary... Length of released bar already calculated above, do nothing
    } else if (pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==true){
    console.log("Don't do shit");
    //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
    //So midiEv *fixed* barlength has been calculated above
    } else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
      console.log("bothmove");
      ctm.fillStyle = "black";
      ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
      //Math.round(all the values); maybe not needed
      moveFront=scrollBarPos-FRONTOFFSET[midiEv];
      moveBack=moveFront-xBarLength[midiEv];
      console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
      console.log("scrollBarPos="+scrollBarPos);
      console.log("moveFront="+moveFront+" moveBack="+moveBack);
      ctm.fillStyle = "orange";
      ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
    }
  midiEv++; 
  }
  midiEv=0; 
}

[toc] | [prev] | [next] | [standalone]

#36159

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-25 04:59 -0700
Message-ID<e8d82946-06d5-490d-8b24-c493a3c00240@googlegroups.com>
In reply to#36151
Den söndag 24 mars 2019 kl. 23:38:19 UTC+1 skrev Jonas Thörnvall:
> Recording, I now buffer the key strokes "note on and off" in an array. But the logic for a pianoroll isn't as plain and easy as i thought.
> 
> Now this is only a visual thingy so no ***exact time*** is needed for the calculation of pianoroll keystrokes "only position".
> 
> I can't see i missed any case, but the pianoroll does not behave as i expect.
> 
> CASE 1 KEY PRESSED STILL NOT RELEASED, FRONTEND MOVE INDEPENDENT OF LOCKED STARTPOINT "CALCULATE  FRONTEND RELATIVE SCROLLBAR ENTRYPOINT
> 
> CASE 2 KEY IS RELEASED, ***FIXED LENGTH*** OF KEYSTROKE CALCULATED
> 
> CASE 3 BOTH FRONTEND AND BACKEND MOVING synchronus, frontend calculated using offset relative scrollbar "same as CASE1", backend calculated using "LENGTH CASE 2" relative the frontend
> 
> I know it is hard to read others logic but i tried keep complexity to a minimum, maybe someone done something similar comoving thingy and have a good eye for logics.
> 
> http://midisequenser.000webhostapp.com/
> 
> var xKeylength=0;
> var midiEv=0;
> var xFrontStart=[];
> var FRONTOFFSET=[];
> var backStuck=0;
> var keyreleased=[];
> for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> 
> function pianoSCROLL(){
> console.log(pianoroll.length); 
> var nbrOfEv = pianoroll.length;
>   while (midiEv<nbrOfEv){
>     
>     // Pianoroll Array Events reversed last event "keypress" ***IS FIRST***, 
>     
>     // CASE one still holding key only front moves
>     // While key not released back is stuck at start of pianoroll "stroke not released still going"
>     
>     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
>         backStuck=keylength;
>         ctm.fillStyle = "magenta";
>         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
>         //When key pressed a startpoint, relative scrollbar created ***FRONTOFFSET***
>         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
>         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
>     
>     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
>     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> 
>     } else if(pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==false){
>        console.log("keyreleased!");
>        for(var q=midiEv+1;q<nbrOfEv;q++){
>        if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-xBackEnd;}
>        }
>     
>     //These events should have a moving backend  in sync with the moving front
> 
>     } else  if (pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==true) {
>       console.log("bothmove");
>       ctm.fillStyle = "black";
>       ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
>       //Math.round(all the values); maybe not needed
>       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
>       moveBack=moveFront-xBarLength[midiEv];
>       ctm.fillStyle = "orange";
>       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
>     }
> 
>   midiEv++; 
>   }
>   midiEv=0; 
> }

http://midisequenser.000webhostapp.com/

Pressing a single key and release it while recording seem to imply wrong event used after release but i can't really see how

var midiEv=0;
var xFrontStart=[];
var FRONTOFFSET=[];
var xBarLength=[];
var keyreleased=[]; 
backStuck=50;
for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}

function pianoSCROLL(){
console.log(pianoroll.length); 
var nbrOfEv = pianoroll.length;
  while (midiEv<nbrOfEv){
    
    // Pianoroll Array is reversed last keyevent "keypress / release" ***IS FIRST***, 
    // When still holding key only front moves
    // While key not released back is stuck at start of pianoroll "stroke not released still going"
    if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
        console.log("frontmove");
       
        ctm.fillStyle = "magenta";
        ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
        //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
        if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
        xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
        console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
   
    //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
    //So midiEv *fixed* barlength has been calculated above
    } else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
      console.log("bothmove");
      ctm.fillStyle = "black";
      ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
      //Math.round(all the values); maybe not needed
      moveFront=scrollBarPos-FRONTOFFSET[midiEv];
      moveBack=moveFront-xBarLength[midiEv];
      console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
      console.log("scrollBarPos="+scrollBarPos);
      console.log("moveFront="+moveFront+" moveBack="+moveBack);
      ctm.fillStyle = "orange";
      ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
   
    //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
    //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
    } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
      console.log("keyreleased!");
      for(var q=midiEv;q<nbrOfEv;q++){ 
        console.log("midiEv="+midiEv+" q="+q);
        console.log(" pianoroll[q].data0="+pianoroll[q].data0+" pianoroll[midiEv].data0="+pianoroll[midiEv].data0);
        console.log(" pianoroll[q].data1="+pianoroll[q].data1+" pianoroll[midiEv].data1="+pianoroll[midiEv].data1);
        if(pianoroll[q].data1==pianoroll[midiEv].data1) { keyreleased[q]=true; xBarLength[q]=xFrontStart[midiEv]-backStuck;}
      }
    keyreleased[midiEv]=true;
   }
  midiEv++; 
  }
  midiEv=0; 
}

[toc] | [prev] | [next] | [standalone]

#36160

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-25 05:29 -0700
Message-ID<552fc962-1a26-419f-8e42-9265343ca367@googlegroups.com>
In reply to#36159
Den måndag 25 mars 2019 kl. 12:59:31 UTC+1 skrev Jonas Thörnvall:
> Den söndag 24 mars 2019 kl. 23:38:19 UTC+1 skrev Jonas Thörnvall:
> > Recording, I now buffer the key strokes "note on and off" in an array. But the logic for a pianoroll isn't as plain and easy as i thought.
> > 
> > Now this is only a visual thingy so no ***exact time*** is needed for the calculation of pianoroll keystrokes "only position".
> > 
> > I can't see i missed any case, but the pianoroll does not behave as i expect.
> > 
> > CASE 1 KEY PRESSED STILL NOT RELEASED, FRONTEND MOVE INDEPENDENT OF LOCKED STARTPOINT "CALCULATE  FRONTEND RELATIVE SCROLLBAR ENTRYPOINT
> > 
> > CASE 2 KEY IS RELEASED, ***FIXED LENGTH*** OF KEYSTROKE CALCULATED
> > 
> > CASE 3 BOTH FRONTEND AND BACKEND MOVING synchronus, frontend calculated using offset relative scrollbar "same as CASE1", backend calculated using "LENGTH CASE 2" relative the frontend
> > 
> > I know it is hard to read others logic but i tried keep complexity to a minimum, maybe someone done something similar comoving thingy and have a good eye for logics.
> > 
> > http://midisequenser.000webhostapp.com/
> > 
> > var xKeylength=0;
> > var midiEv=0;
> > var xFrontStart=[];
> > var FRONTOFFSET=[];
> > var backStuck=0;
> > var keyreleased=[];
> > for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > 
> > function pianoSCROLL(){
> > console.log(pianoroll.length); 
> > var nbrOfEv = pianoroll.length;
> >   while (midiEv<nbrOfEv){
> >     
> >     // Pianoroll Array Events reversed last event "keypress" ***IS FIRST***, 
> >     
> >     // CASE one still holding key only front moves
> >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> >     
> >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> >         backStuck=keylength;
> >         ctm.fillStyle = "magenta";
> >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> >         //When key pressed a startpoint, relative scrollbar created ***FRONTOFFSET***
> >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> >     
> >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> > 
> >     } else if(pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==false){
> >        console.log("keyreleased!");
> >        for(var q=midiEv+1;q<nbrOfEv;q++){
> >        if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-xBackEnd;}
> >        }
> >     
> >     //These events should have a moving backend  in sync with the moving front
> > 
> >     } else  if (pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==true) {
> >       console.log("bothmove");
> >       ctm.fillStyle = "black";
> >       ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
> >       //Math.round(all the values); maybe not needed
> >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> >       moveBack=moveFront-xBarLength[midiEv];
> >       ctm.fillStyle = "orange";
> >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
> >     }
> > 
> >   midiEv++; 
> >   }
> >   midiEv=0; 
> > }
> 
> http://midisequenser.000webhostapp.com/
> 
> Pressing a single key and release it while recording seem to imply wrong event used after release but i can't really see how
> 
> var midiEv=0;
> var xFrontStart=[];
> var FRONTOFFSET=[];
> var xBarLength=[];
> var keyreleased=[]; 
> backStuck=50;
> for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> 
> function pianoSCROLL(){
> console.log(pianoroll.length); 
> var nbrOfEv = pianoroll.length;
>   while (midiEv<nbrOfEv){
>     
>     // Pianoroll Array is reversed last keyevent "keypress / release" ***IS FIRST***, 
>     // When still holding key only front moves
>     // While key not released back is stuck at start of pianoroll "stroke not released still going"
>     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
>         console.log("frontmove");
>        
>         ctm.fillStyle = "magenta";
>         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
>         //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
>         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
>         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
>         console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
>    
>     //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
>     //So midiEv *fixed* barlength has been calculated above
>     } else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
>       console.log("bothmove");
>       ctm.fillStyle = "black";
>       ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
>       //Math.round(all the values); maybe not needed
>       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
>       moveBack=moveFront-xBarLength[midiEv];
>       console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
>       console.log("scrollBarPos="+scrollBarPos);
>       console.log("moveFront="+moveFront+" moveBack="+moveBack);
>       ctm.fillStyle = "orange";
>       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
>    
>     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
>     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
>     } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
>       console.log("keyreleased!");
>       for(var q=midiEv;q<nbrOfEv;q++){ 
>         console.log("midiEv="+midiEv+" q="+q);
>         console.log(" pianoroll[q].data0="+pianoroll[q].data0+" pianoroll[midiEv].data0="+pianoroll[midiEv].data0);
>         console.log(" pianoroll[q].data1="+pianoroll[q].data1+" pianoroll[midiEv].data1="+pianoroll[midiEv].data1);
>         if(pianoroll[q].data1==pianoroll[midiEv].data1) { keyreleased[q]=true; xBarLength[q]=xFrontStart[midiEv]-backStuck;}
>       }
>     keyreleased[midiEv]=true;
>    }
>   midiEv++; 
>   }
>   midiEv=0; 
> }

Oooh i see a giant problem i have wandering indexes "i must somehow label them".

[toc] | [prev] | [next] | [standalone]

#36161

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-25 05:33 -0700
Message-ID<5ce59fc3-4790-4b34-a811-b6908655f267@googlegroups.com>
In reply to#36160
Den måndag 25 mars 2019 kl. 13:29:24 UTC+1 skrev Jonas Thörnvall:
> Den måndag 25 mars 2019 kl. 12:59:31 UTC+1 skrev Jonas Thörnvall:
> > Den söndag 24 mars 2019 kl. 23:38:19 UTC+1 skrev Jonas Thörnvall:
> > > Recording, I now buffer the key strokes "note on and off" in an array. But the logic for a pianoroll isn't as plain and easy as i thought.
> > > 
> > > Now this is only a visual thingy so no ***exact time*** is needed for the calculation of pianoroll keystrokes "only position".
> > > 
> > > I can't see i missed any case, but the pianoroll does not behave as i expect.
> > > 
> > > CASE 1 KEY PRESSED STILL NOT RELEASED, FRONTEND MOVE INDEPENDENT OF LOCKED STARTPOINT "CALCULATE  FRONTEND RELATIVE SCROLLBAR ENTRYPOINT
> > > 
> > > CASE 2 KEY IS RELEASED, ***FIXED LENGTH*** OF KEYSTROKE CALCULATED
> > > 
> > > CASE 3 BOTH FRONTEND AND BACKEND MOVING synchronus, frontend calculated using offset relative scrollbar "same as CASE1", backend calculated using "LENGTH CASE 2" relative the frontend
> > > 
> > > I know it is hard to read others logic but i tried keep complexity to a minimum, maybe someone done something similar comoving thingy and have a good eye for logics.
> > > 
> > > http://midisequenser.000webhostapp.com/
> > > 
> > > var xKeylength=0;
> > > var midiEv=0;
> > > var xFrontStart=[];
> > > var FRONTOFFSET=[];
> > > var backStuck=0;
> > > var keyreleased=[];
> > > for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > > 
> > > function pianoSCROLL(){
> > > console.log(pianoroll.length); 
> > > var nbrOfEv = pianoroll.length;
> > >   while (midiEv<nbrOfEv){
> > >     
> > >     // Pianoroll Array Events reversed last event "keypress" ***IS FIRST***, 
> > >     
> > >     // CASE one still holding key only front moves
> > >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> > >     
> > >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> > >         backStuck=keylength;
> > >         ctm.fillStyle = "magenta";
> > >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> > >         //When key pressed a startpoint, relative scrollbar created ***FRONTOFFSET***
> > >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> > >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> > >     
> > >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> > >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> > > 
> > >     } else if(pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==false){
> > >        console.log("keyreleased!");
> > >        for(var q=midiEv+1;q<nbrOfEv;q++){
> > >        if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-xBackEnd;}
> > >        }
> > >     
> > >     //These events should have a moving backend  in sync with the moving front
> > > 
> > >     } else  if (pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==true) {
> > >       console.log("bothmove");
> > >       ctm.fillStyle = "black";
> > >       ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
> > >       //Math.round(all the values); maybe not needed
> > >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> > >       moveBack=moveFront-xBarLength[midiEv];
> > >       ctm.fillStyle = "orange";
> > >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
> > >     }
> > > 
> > >   midiEv++; 
> > >   }
> > >   midiEv=0; 
> > > }
> > 
> > http://midisequenser.000webhostapp.com/
> > 
> > Pressing a single key and release it while recording seem to imply wrong event used after release but i can't really see how
> > 
> > var midiEv=0;
> > var xFrontStart=[];
> > var FRONTOFFSET=[];
> > var xBarLength=[];
> > var keyreleased=[]; 
> > backStuck=50;
> > for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > 
> > function pianoSCROLL(){
> > console.log(pianoroll.length); 
> > var nbrOfEv = pianoroll.length;
> >   while (midiEv<nbrOfEv){
> >     
> >     // Pianoroll Array is reversed last keyevent "keypress / release" ***IS FIRST***, 
> >     // When still holding key only front moves
> >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> >         console.log("frontmove");
> >        
> >         ctm.fillStyle = "magenta";
> >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> >         //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
> >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> >         console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
> >    
> >     //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
> >     //So midiEv *fixed* barlength has been calculated above
> >     } else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
> >       console.log("bothmove");
> >       ctm.fillStyle = "black";
> >       ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
> >       //Math.round(all the values); maybe not needed
> >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> >       moveBack=moveFront-xBarLength[midiEv];
> >       console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
> >       console.log("scrollBarPos="+scrollBarPos);
> >       console.log("moveFront="+moveFront+" moveBack="+moveBack);
> >       ctm.fillStyle = "orange";
> >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
> >    
> >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> >     } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
> >       console.log("keyreleased!");
> >       for(var q=midiEv;q<nbrOfEv;q++){ 
> >         console.log("midiEv="+midiEv+" q="+q);
> >         console.log(" pianoroll[q].data0="+pianoroll[q].data0+" pianoroll[midiEv].data0="+pianoroll[midiEv].data0);
> >         console.log(" pianoroll[q].data1="+pianoroll[q].data1+" pianoroll[midiEv].data1="+pianoroll[midiEv].data1);
> >         if(pianoroll[q].data1==pianoroll[midiEv].data1) { keyreleased[q]=true; xBarLength[q]=xFrontStart[midiEv]-backStuck;}
> >       }
> >     keyreleased[midiEv]=true;
> >    }
> >   midiEv++; 
> >   }
> >   midiEv=0; 
> > }
> 
> Oooh i see a giant problem i have wandering indexes "i must somehow label them".

And i thought it was a smart idea to push them in from start, i am having second doubts.

[toc] | [prev] | [next] | [standalone]

#36163

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-25 06:04 -0700
Message-ID<98c398bb-ec87-4bd5-9d2d-6d1a1ce363c3@googlegroups.com>
In reply to#36161
Den måndag 25 mars 2019 kl. 13:33:55 UTC+1 skrev Jonas Thörnvall:
> Den måndag 25 mars 2019 kl. 13:29:24 UTC+1 skrev Jonas Thörnvall:
> > Den måndag 25 mars 2019 kl. 12:59:31 UTC+1 skrev Jonas Thörnvall:
> > > Den söndag 24 mars 2019 kl. 23:38:19 UTC+1 skrev Jonas Thörnvall:
> > > > Recording, I now buffer the key strokes "note on and off" in an array. But the logic for a pianoroll isn't as plain and easy as i thought.
> > > > 
> > > > Now this is only a visual thingy so no ***exact time*** is needed for the calculation of pianoroll keystrokes "only position".
> > > > 
> > > > I can't see i missed any case, but the pianoroll does not behave as i expect.
> > > > 
> > > > CASE 1 KEY PRESSED STILL NOT RELEASED, FRONTEND MOVE INDEPENDENT OF LOCKED STARTPOINT "CALCULATE  FRONTEND RELATIVE SCROLLBAR ENTRYPOINT
> > > > 
> > > > CASE 2 KEY IS RELEASED, ***FIXED LENGTH*** OF KEYSTROKE CALCULATED
> > > > 
> > > > CASE 3 BOTH FRONTEND AND BACKEND MOVING synchronus, frontend calculated using offset relative scrollbar "same as CASE1", backend calculated using "LENGTH CASE 2" relative the frontend
> > > > 
> > > > I know it is hard to read others logic but i tried keep complexity to a minimum, maybe someone done something similar comoving thingy and have a good eye for logics.
> > > > 
> > > > http://midisequenser.000webhostapp.com/
> > > > 
> > > > var xKeylength=0;
> > > > var midiEv=0;
> > > > var xFrontStart=[];
> > > > var FRONTOFFSET=[];
> > > > var backStuck=0;
> > > > var keyreleased=[];
> > > > for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > > > 
> > > > function pianoSCROLL(){
> > > > console.log(pianoroll.length); 
> > > > var nbrOfEv = pianoroll.length;
> > > >   while (midiEv<nbrOfEv){
> > > >     
> > > >     // Pianoroll Array Events reversed last event "keypress" ***IS FIRST***, 
> > > >     
> > > >     // CASE one still holding key only front moves
> > > >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> > > >     
> > > >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> > > >         backStuck=keylength;
> > > >         ctm.fillStyle = "magenta";
> > > >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> > > >         //When key pressed a startpoint, relative scrollbar created ***FRONTOFFSET***
> > > >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> > > >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> > > >     
> > > >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> > > >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> > > > 
> > > >     } else if(pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==false){
> > > >        console.log("keyreleased!");
> > > >        for(var q=midiEv+1;q<nbrOfEv;q++){
> > > >        if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-xBackEnd;}
> > > >        }
> > > >     
> > > >     //These events should have a moving backend  in sync with the moving front
> > > > 
> > > >     } else  if (pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==true) {
> > > >       console.log("bothmove");
> > > >       ctm.fillStyle = "black";
> > > >       ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
> > > >       //Math.round(all the values); maybe not needed
> > > >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> > > >       moveBack=moveFront-xBarLength[midiEv];
> > > >       ctm.fillStyle = "orange";
> > > >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
> > > >     }
> > > > 
> > > >   midiEv++; 
> > > >   }
> > > >   midiEv=0; 
> > > > }
> > > 
> > > http://midisequenser.000webhostapp.com/
> > > 
> > > Pressing a single key and release it while recording seem to imply wrong event used after release but i can't really see how
> > > 
> > > var midiEv=0;
> > > var xFrontStart=[];
> > > var FRONTOFFSET=[];
> > > var xBarLength=[];
> > > var keyreleased=[]; 
> > > backStuck=50;
> > > for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > > 
> > > function pianoSCROLL(){
> > > console.log(pianoroll.length); 
> > > var nbrOfEv = pianoroll.length;
> > >   while (midiEv<nbrOfEv){
> > >     
> > >     // Pianoroll Array is reversed last keyevent "keypress / release" ***IS FIRST***, 
> > >     // When still holding key only front moves
> > >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> > >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> > >         console.log("frontmove");
> > >        
> > >         ctm.fillStyle = "magenta";
> > >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> > >         //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
> > >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> > >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> > >         console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
> > >    
> > >     //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
> > >     //So midiEv *fixed* barlength has been calculated above
> > >     } else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
> > >       console.log("bothmove");
> > >       ctm.fillStyle = "black";
> > >       ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
> > >       //Math.round(all the values); maybe not needed
> > >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> > >       moveBack=moveFront-xBarLength[midiEv];
> > >       console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
> > >       console.log("scrollBarPos="+scrollBarPos);
> > >       console.log("moveFront="+moveFront+" moveBack="+moveBack);
> > >       ctm.fillStyle = "orange";
> > >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
> > >    
> > >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> > >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> > >     } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
> > >       console.log("keyreleased!");
> > >       for(var q=midiEv;q<nbrOfEv;q++){ 
> > >         console.log("midiEv="+midiEv+" q="+q);
> > >         console.log(" pianoroll[q].data0="+pianoroll[q].data0+" pianoroll[midiEv].data0="+pianoroll[midiEv].data0);
> > >         console.log(" pianoroll[q].data1="+pianoroll[q].data1+" pianoroll[midiEv].data1="+pianoroll[midiEv].data1);
> > >         if(pianoroll[q].data1==pianoroll[midiEv].data1) { keyreleased[q]=true; xBarLength[q]=xFrontStart[midiEv]-backStuck;}
> > >       }
> > >     keyreleased[midiEv]=true;
> > >    }
> > >   midiEv++; 
> > >   }
> > >   midiEv=0; 
> > > }
> > 
> > Oooh i see a giant problem i have wandering indexes "i must somehow label them".
> 
> And i thought it was a smart idea to push them in from start, i am having second doubts.

what happen if you read thru array in loop in one thread and at same time insert elements into it with unshift() in another trhead???

[toc] | [prev] | [next] | [standalone]

#36164

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-25 06:10 -0700
Message-ID<43359102-e7be-40a3-a747-9e5404505701@googlegroups.com>
In reply to#36163
Den måndag 25 mars 2019 kl. 14:05:09 UTC+1 skrev Jonas Thörnvall:
> Den måndag 25 mars 2019 kl. 13:33:55 UTC+1 skrev Jonas Thörnvall:
> > Den måndag 25 mars 2019 kl. 13:29:24 UTC+1 skrev Jonas Thörnvall:
> > > Den måndag 25 mars 2019 kl. 12:59:31 UTC+1 skrev Jonas Thörnvall:
> > > > Den söndag 24 mars 2019 kl. 23:38:19 UTC+1 skrev Jonas Thörnvall:
> > > > > Recording, I now buffer the key strokes "note on and off" in an array. But the logic for a pianoroll isn't as plain and easy as i thought.
> > > > > 
> > > > > Now this is only a visual thingy so no ***exact time*** is needed for the calculation of pianoroll keystrokes "only position".
> > > > > 
> > > > > I can't see i missed any case, but the pianoroll does not behave as i expect.
> > > > > 
> > > > > CASE 1 KEY PRESSED STILL NOT RELEASED, FRONTEND MOVE INDEPENDENT OF LOCKED STARTPOINT "CALCULATE  FRONTEND RELATIVE SCROLLBAR ENTRYPOINT
> > > > > 
> > > > > CASE 2 KEY IS RELEASED, ***FIXED LENGTH*** OF KEYSTROKE CALCULATED
> > > > > 
> > > > > CASE 3 BOTH FRONTEND AND BACKEND MOVING synchronus, frontend calculated using offset relative scrollbar "same as CASE1", backend calculated using "LENGTH CASE 2" relative the frontend
> > > > > 
> > > > > I know it is hard to read others logic but i tried keep complexity to a minimum, maybe someone done something similar comoving thingy and have a good eye for logics.
> > > > > 
> > > > > http://midisequenser.000webhostapp.com/
> > > > > 
> > > > > var xKeylength=0;
> > > > > var midiEv=0;
> > > > > var xFrontStart=[];
> > > > > var FRONTOFFSET=[];
> > > > > var backStuck=0;
> > > > > var keyreleased=[];
> > > > > for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > > > > 
> > > > > function pianoSCROLL(){
> > > > > console.log(pianoroll.length); 
> > > > > var nbrOfEv = pianoroll.length;
> > > > >   while (midiEv<nbrOfEv){
> > > > >     
> > > > >     // Pianoroll Array Events reversed last event "keypress" ***IS FIRST***, 
> > > > >     
> > > > >     // CASE one still holding key only front moves
> > > > >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> > > > >     
> > > > >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> > > > >         backStuck=keylength;
> > > > >         ctm.fillStyle = "magenta";
> > > > >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> > > > >         //When key pressed a startpoint, relative scrollbar created ***FRONTOFFSET***
> > > > >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> > > > >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> > > > >     
> > > > >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> > > > >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> > > > > 
> > > > >     } else if(pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==false){
> > > > >        console.log("keyreleased!");
> > > > >        for(var q=midiEv+1;q<nbrOfEv;q++){
> > > > >        if(pianoroll[q].data1==pianoroll[midiEv].data1) {keyreleased[q]=true; xBarLength[q]=xFrontStart[q]-xBackEnd;}
> > > > >        }
> > > > >     
> > > > >     //These events should have a moving backend  in sync with the moving front
> > > > > 
> > > > >     } else  if (pianoroll[midiEv]==NOTE_OFF && keyreleased[midiEv]==true) {
> > > > >       console.log("bothmove");
> > > > >       ctm.fillStyle = "black";
> > > > >       ctm.fillRect(keylength, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)), Mwidth, keyHeight+2);
> > > > >       //Math.round(all the values); maybe not needed
> > > > >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> > > > >       moveBack=moveFront-xBarLength[midiEv];
> > > > >       ctm.fillStyle = "orange";
> > > > >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv]-8)),moveFront,keyHeight);
> > > > >     }
> > > > > 
> > > > >   midiEv++; 
> > > > >   }
> > > > >   midiEv=0; 
> > > > > }
> > > > 
> > > > http://midisequenser.000webhostapp.com/
> > > > 
> > > > Pressing a single key and release it while recording seem to imply wrong event used after release but i can't really see how
> > > > 
> > > > var midiEv=0;
> > > > var xFrontStart=[];
> > > > var FRONTOFFSET=[];
> > > > var xBarLength=[];
> > > > var keyreleased=[]; 
> > > > backStuck=50;
> > > > for (var p=0;p<300;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > > > 
> > > > function pianoSCROLL(){
> > > > console.log(pianoroll.length); 
> > > > var nbrOfEv = pianoroll.length;
> > > >   while (midiEv<nbrOfEv){
> > > >     
> > > >     // Pianoroll Array is reversed last keyevent "keypress / release" ***IS FIRST***, 
> > > >     // When still holding key only front moves
> > > >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> > > >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> > > >         console.log("frontmove");
> > > >        
> > > >         ctm.fillStyle = "magenta";
> > > >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> > > >         //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
> > > >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> > > >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> > > >         console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
> > > >    
> > > >     //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
> > > >     //So midiEv *fixed* barlength has been calculated above
> > > >     } else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
> > > >       console.log("bothmove");
> > > >       ctm.fillStyle = "black";
> > > >       ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
> > > >       //Math.round(all the values); maybe not needed
> > > >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> > > >       moveBack=moveFront-xBarLength[midiEv];
> > > >       console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
> > > >       console.log("scrollBarPos="+scrollBarPos);
> > > >       console.log("moveFront="+moveFront+" moveBack="+moveBack);
> > > >       ctm.fillStyle = "orange";
> > > >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
> > > >    
> > > >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> > > >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> > > >     } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
> > > >       console.log("keyreleased!");
> > > >       for(var q=midiEv;q<nbrOfEv;q++){ 
> > > >         console.log("midiEv="+midiEv+" q="+q);
> > > >         console.log(" pianoroll[q].data0="+pianoroll[q].data0+" pianoroll[midiEv].data0="+pianoroll[midiEv].data0);
> > > >         console.log(" pianoroll[q].data1="+pianoroll[q].data1+" pianoroll[midiEv].data1="+pianoroll[midiEv].data1);
> > > >         if(pianoroll[q].data1==pianoroll[midiEv].data1) { keyreleased[q]=true; xBarLength[q]=xFrontStart[midiEv]-backStuck;}
> > > >       }
> > > >     keyreleased[midiEv]=true;
> > > >    }
> > > >   midiEv++; 
> > > >   }
> > > >   midiEv=0; 
> > > > }
> > > 
> > > Oooh i see a giant problem i have wandering indexes "i must somehow label them".
> > 
> > And i thought it was a smart idea to push them in from start, i am having second doubts.
> 
> what happen if you read thru array in loop in one thread and at same time insert elements into it with unshift() in another trhead???

It seem i have to push elements and read array from end for each setInterval calls the pianoroll animation.

No fast fix LoL?

[toc] | [prev] | [next] | [standalone]

#36167

FromJohn G Harris <niam@jghnorth.org.uk.invalid>
Date2019-03-25 18:17 +0000
Message-ID<7o6i9e1l8t5ak76vg04rf4e90vu3k80775@4ax.com>
In reply to#36163
On Mon, 25 Mar 2019 06:04:58 -0700 (PDT), Jonas Thörnvall
<jonas.thornvall@gmail.com> wrote:

  <snip>
>what happen if you read thru array in loop in one thread and at same time insert elements into it with unshift() in another trhead???

If the threads can really interleave then chaos.

If they can't then you might not know whether reading or updating will
be done first.

  John

[toc] | [prev] | [next] | [standalone]

#36169

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-26 00:17 -0700
Message-ID<f7ea2627-ae14-4a9e-8179-ea9c3cd4b421@googlegroups.com>
In reply to#36167
Den måndag 25 mars 2019 kl. 19:17:25 UTC+1 skrev John G Harris:
> On Mon, 25 Mar 2019 06:04:58 -0700 (PDT), Jonas Thörnvall
> <jonas.thornvall@gmail.com> wrote:
> 
>   <snip>
> >what happen if you read thru array in loop in one thread and at same time insert elements into it with unshift() in another trhead???
> 
> If the threads can really interleave then chaos.
> 
> If they can't then you might not know whether reading or updating will
> be done first.
> 
>   John

I guess one can not insert elements from start keeping the indexes, because that would mean element with negative index. Can arrays in javascript have indexes with negative values, where the first element negative?

An array is a stack of indexes and pointers?
If you create an array and start to insert elements at index 7, is index 0-6 there anyway holding null pointers?

[toc] | [prev] | [next] | [standalone]

#36170

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-26 02:04 -0700
Message-ID<7aaefad9-a42b-4720-aa12-2121f143fe44@googlegroups.com>
In reply to#36169
Den tisdag 26 mars 2019 kl. 08:17:14 UTC+1 skrev Jonas Thörnvall:
> Den måndag 25 mars 2019 kl. 19:17:25 UTC+1 skrev John G Harris:
> > On Mon, 25 Mar 2019 06:04:58 -0700 (PDT), Jonas Thörnvall
> > <jonas.thornvall@gmail.com> wrote:
> > 
> >   <snip>
> > >what happen if you read thru array in loop in one thread and at same time insert elements into it with unshift() in another trhead???
> > 
> > If the threads can really interleave then chaos.
> > 
> > If they can't then you might not know whether reading or updating will
> > be done first.
> > 
> >   John
> 
> I guess one can not insert elements from start keeping the indexes, because that would mean element with negative index. Can arrays in javascript have indexes with negative values, where the first element negative?
> 
> An array is a stack of indexes and pointers?
> If you create an array and start to insert elements at index 7, is index 0-6 there anyway holding null pointers?

Well the change was just a unshift to push got first case working.

var midiEv=0;
var xFrontStart=[];
var FRONTOFFSET=[];
var xBarLength=[];
var keyreleased=[]; 
backStuck=50;
for (var p=0;p<3000;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}

function pianoSCROLL(){

nbrOfEv = pianoroll.length;
 
  while (nbrOfEv>0){
     midiEv=nbrOfEv-1;
     
     //p.stop();
    // When still holding key only front moves
    // While key not released back is stuck at start of pianoroll "stroke not released still going"
    if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
        console.log("nbrOfEv="+nbrOfEv); 
        console.log("frontmove");
        ctm.fillStyle = "magenta";
        ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
        //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
        if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
        xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
        console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
   
    //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
    //So midiEv *fixed* barlength has been calculated below
    } 
    /* else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
      console.log("bothmove");
      ctm.fillStyle = "black";
      ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
      //Math.round(all the values); maybe not needed
      moveFront=scrollBarPos-FRONTOFFSET[midiEv];
      moveBack=moveFront-xBarLength[midiEv];
      ctm.fillStyle = "orange";
      ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
   
    //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
    //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
    //Q ***should*** be the not

    } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
      console.log("keyreleased!");
      for(var q=0;q<midiEv;q++){ 
           if(pianoroll[q].data1==pianoroll[midiEv].data1) { keyreleased[q]=true; xBarLength[q]=xFrontStart[midiEv]-backStuck; }
      }
    keyreleased[midiEv]=true;
   } 
  */
  nbrOfEv--; 
  }

}

[toc] | [prev] | [next] | [standalone]

#36171

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-26 07:24 -0700
Message-ID<a7177c3f-b901-4a04-bd66-fa180a5d4007@googlegroups.com>
In reply to#36170
Den tisdag 26 mars 2019 kl. 10:04:51 UTC+1 skrev Jonas Thörnvall:
> Den tisdag 26 mars 2019 kl. 08:17:14 UTC+1 skrev Jonas Thörnvall:
> > Den måndag 25 mars 2019 kl. 19:17:25 UTC+1 skrev John G Harris:
> > > On Mon, 25 Mar 2019 06:04:58 -0700 (PDT), Jonas Thörnvall
> > > <jonas.thornvall@gmail.com> wrote:
> > > 
> > >   <snip>
> > > >what happen if you read thru array in loop in one thread and at same time insert elements into it with unshift() in another trhead???
> > > 
> > > If the threads can really interleave then chaos.
> > > 
> > > If they can't then you might not know whether reading or updating will
> > > be done first.
> > > 
> > >   John
> > 
> > I guess one can not insert elements from start keeping the indexes, because that would mean element with negative index. Can arrays in javascript have indexes with negative values, where the first element negative?
> > 
> > An array is a stack of indexes and pointers?
> > If you create an array and start to insert elements at index 7, is index 0-6 there anyway holding null pointers?
> 
> Well the change was just a unshift to push got first case working.
> 
> var midiEv=0;
> var xFrontStart=[];
> var FRONTOFFSET=[];
> var xBarLength=[];
> var keyreleased=[]; 
> backStuck=50;
> for (var p=0;p<3000;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> 
> function pianoSCROLL(){
> 
> nbrOfEv = pianoroll.length;
>  
>   while (nbrOfEv>0){
>      midiEv=nbrOfEv-1;
>      
>      //p.stop();
>     // When still holding key only front moves
>     // While key not released back is stuck at start of pianoroll "stroke not released still going"
>     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
>         console.log("nbrOfEv="+nbrOfEv); 
>         console.log("frontmove");
>         ctm.fillStyle = "magenta";
>         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
>         //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
>         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
>         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
>         console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
>    
>     //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
>     //So midiEv *fixed* barlength has been calculated below
>     } 
>     /* else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
>       console.log("bothmove");
>       ctm.fillStyle = "black";
>       ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
>       //Math.round(all the values); maybe not needed
>       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
>       moveBack=moveFront-xBarLength[midiEv];
>       ctm.fillStyle = "orange";
>       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
>    
>     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
>     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
>     //Q ***should*** be the not
> 
>     } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
>       console.log("keyreleased!");
>       for(var q=0;q<midiEv;q++){ 
>            if(pianoroll[q].data1==pianoroll[midiEv].data1) { keyreleased[q]=true; xBarLength[q]=xFrontStart[midiEv]-backStuck; }
>       }
>     keyreleased[midiEv]=true;
>    } 
>   */
>   nbrOfEv--; 
>   }
> 
> }

Well except for strikingout painted keystrokes on same note, there is just the logical conundrum left.

   moveFront=scrollBarPos-FRONTOFFSET[midiEv];
   moveBack=moveFront-xBarLength[midiEv];

If scrollBarPos is a moving target each call, and FRONTOFFSET is a constant xBarlength is a constant.

How could possibly the length of rectangle created by moveBack and moveFront vary.
I can't wrap my head around it.

 ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);


http://midisequenser.000webhostapp.com

[toc] | [prev] | [next] | [standalone]

#36172

FromJonas Thörnvall <jonas.thornvall@gmail.com>
Date2019-03-26 07:46 -0700
Message-ID<91c62d4b-1395-4f2c-a681-fbcd31e6ee33@googlegroups.com>
In reply to#36171
Den tisdag 26 mars 2019 kl. 15:25:01 UTC+1 skrev Jonas Thörnvall:
> Den tisdag 26 mars 2019 kl. 10:04:51 UTC+1 skrev Jonas Thörnvall:
> > Den tisdag 26 mars 2019 kl. 08:17:14 UTC+1 skrev Jonas Thörnvall:
> > > Den måndag 25 mars 2019 kl. 19:17:25 UTC+1 skrev John G Harris:
> > > > On Mon, 25 Mar 2019 06:04:58 -0700 (PDT), Jonas Thörnvall
> > > > <jonas.thornvall@gmail.com> wrote:
> > > > 
> > > >   <snip>
> > > > >what happen if you read thru array in loop in one thread and at same time insert elements into it with unshift() in another trhead???
> > > > 
> > > > If the threads can really interleave then chaos.
> > > > 
> > > > If they can't then you might not know whether reading or updating will
> > > > be done first.
> > > > 
> > > >   John
> > > 
> > > I guess one can not insert elements from start keeping the indexes, because that would mean element with negative index. Can arrays in javascript have indexes with negative values, where the first element negative?
> > > 
> > > An array is a stack of indexes and pointers?
> > > If you create an array and start to insert elements at index 7, is index 0-6 there anyway holding null pointers?
> > 
> > Well the change was just a unshift to push got first case working.
> > 
> > var midiEv=0;
> > var xFrontStart=[];
> > var FRONTOFFSET=[];
> > var xBarLength=[];
> > var keyreleased=[]; 
> > backStuck=50;
> > for (var p=0;p<3000;p++) {xFrontStart[p]=0;FRONTOFFSET[p]=0;keyreleased[p]=false;}
> > 
> > function pianoSCROLL(){
> > 
> > nbrOfEv = pianoroll.length;
> >  
> >   while (nbrOfEv>0){
> >      midiEv=nbrOfEv-1;
> >      
> >      //p.stop();
> >     // When still holding key only front moves
> >     // While key not released back is stuck at start of pianoroll "stroke not released still going"
> >     if(pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==false){
> >         console.log("nbrOfEv="+nbrOfEv); 
> >         console.log("frontmove");
> >         ctm.fillStyle = "magenta";
> >         ctm.fillRect(backStuck,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), xFrontStart[midiEv],keyHeight);
> >         //When ***A NEW*** key pressed a startpoint relative the scrollbar created ***FRONTOFFSET***
> >         if(FRONTOFFSET[midiEv]==0) {FRONTOFFSET[midiEv]=scrollBarPos;}
> >         xFrontStart[midiEv]=scrollBarPos-FRONTOFFSET[midiEv];
> >         console.log("FRONTOFFSET[midiEv]="+FRONTOFFSET[midiEv]+" midiEv="+midiEv);
> >    
> >     //These events should have a moving backend  in sync with the moving front because NOTE_ON midiEv AND keyreleased[midiev]=true
> >     //So midiEv *fixed* barlength has been calculated below
> >     } 
> >     /* else  if (pianoroll[midiEv].data0==NOTE_ON && keyreleased[midiEv]==true) {
> >       console.log("bothmove");
> >       ctm.fillStyle = "black";
> >       ctm.fillRect(backStuck, (PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)), Mwidth, keyHeight+2);
> >       //Math.round(all the values); maybe not needed
> >       moveFront=scrollBarPos-FRONTOFFSET[midiEv];
> >       moveBack=moveFront-xBarLength[midiEv];
> >       ctm.fillStyle = "orange";
> >       ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
> >    
> >     //If a KEY EVENT Equal **released***, must find the matching KEYPRESS by looking forward 
> >     //KEYPRESS should be after the keyrelease in array because "current time" insert from start.... 
> >     //Q ***should*** be the not
> > 
> >     } else if(pianoroll[midiEv].data0==NOTE_OFF && keyreleased[midiEv]==false){
> >       console.log("keyreleased!");
> >       for(var q=0;q<midiEv;q++){ 
> >            if(pianoroll[q].data1==pianoroll[midiEv].data1) { keyreleased[q]=true; xBarLength[q]=xFrontStart[midiEv]-backStuck; }
> >       }
> >     keyreleased[midiEv]=true;
> >    } 
> >   */
> >   nbrOfEv--; 
> >   }
> > 
> > }
> 
> Well except for strikingout painted keystrokes on same note, there is just the logical conundrum left.
> 
>    moveFront=scrollBarPos-FRONTOFFSET[midiEv];
>    moveBack=moveFront-xBarLength[midiEv];
> 
> If scrollBarPos is a moving target each call, and FRONTOFFSET is a constant xBarlength is a constant.
> 
> How could possibly the length of rectangle created by moveBack and moveFront vary.
> I can't wrap my head around it.
> 
>  ctm.fillRect(moveBack,(PistartX+keyHeight*88)-(keyHeight*(pianoroll[midiEv].data1-8)),moveFront,keyHeight);
> 
> 
> http://midisequenser.000webhostapp.com

https://www.youtube.com/watch?v=mnTX2p22CWs

[toc] | [prev] | [next] | [standalone]

#36179

FromJohn G Harris <niam@jghnorth.org.uk.invalid>
Date2019-03-26 19:17 +0000
Message-ID<6cuk9el6k2jna5nhnrcvagtp8o4rlihi7u@4ax.com>
In reply to#36169
On Tue, 26 Mar 2019 00:17:05 -0700 (PDT), Jonas Thörnvall
<jonas.thornvall@gmail.com> wrote:

  <snip>
>I guess one can not insert elements from start keeping the indexes, because that would mean element with negative index. Can arrays in javascript have indexes with negative values, where the first element negative?

No. Only 0 and above says the Standard.


>An array is a stack of indexes and pointers?

It's not a "stack". It's a collection of properties where the
properties have special names : the names are non-negative (integer)
numbers.


>If you create an array and start to insert elements at index 7, is index 0-6 there anyway holding null pointers?

Like properties in ordinary objects, inserting an element inserts just
that element. No entries with other index values are created; they
remain undefined if they have never been written to.

  John

[toc] | [prev] | [standalone]

Back to top | Article view | comp.lang.javascript

csiph-web