Fix scope display when ending simulation: causes some demos failure.

Change-Id: Ia8744262dc9ff42d9757601eba9aa2793dddf832

4 files changed, 396 insertions, 384 deletions

diff --git a/scilab/modules/scicos_blocks/src/c/cevscpe.c b/scilab/modules/scicos_blocks/src/c/cevscpe.c
index 275c30e..899627d 100755
--- a/scilab/modules/scicos_blocks/src/c/cevscpe.c
+++ b/scilab/modules/scicos_blocks/src/c/cevscpe.c
@@ -18,7 +18,7 @@
 *
 * See the file ./license.txt
 */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /**
    \file cevscpe.c
    \author Benoit Bayol
@@ -27,7 +27,7 @@
    \brief CEVSCPE is a scope that indicates when the clocks is activated
    \see CEVENTSCOPE.sci in macros/scicos_blocks/Sinks/
 */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 #include "CurrentObjectsManagement.h"
 #include "scicos.h"
 #include "scoMemoryScope.h"
@@ -42,7 +42,7 @@
 #include "scicos_free.h"
 #include "MALLOC.h"
 #include "dynlib_scicos_blocks.h"
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /** \fn cscopxy_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -116,7 +116,7 @@ SCICOS_BLOCKS_IMPEXP void cevscpe_draw(scicos_block * block, ScopeMemory ** pSco
         sciSetJavaUseSingleBuffer(scoGetPointerScopeWindow(*pScopeMemory), TRUE);
     }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /** \fn void cevscpe(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -136,87 +136,88 @@ SCICOS_BLOCKS_IMPEXP void cevscpe(scicos_block * block, int flag)
     {
     case Initialization:
       {
-        cevscpe_draw(block,&pScopeMemory,1);
-        break;
+    cevscpe_draw(block,&pScopeMemory,1);
+    break;
       }
 
     case StateUpdate:
       {
 
-        /* Charging elements */
-
-        scoRetrieveScopeMemory(block->work,&pScopeMemory);
-
-        if(scoGetScopeActivation(pScopeMemory) == 1)
-          {
-           
-            t = get_scicos_time();
-            if(scoGetPointerScopeWindow(pScopeMemory) == NULL)
-              {
-                cevscpe_draw(block,&pScopeMemory,0);
-              }
-
-            scoRefreshDataBoundsX(pScopeMemory,t);
-        
-            /*Not Factorize*/
-
-            for(i = 0 ; i < scoGetNumberOfCurvesBySubwin(pScopeMemory,0) ; i++)
-              {
-                if((GetNevIn(block)&(1<<i))==(1<<i))
-                  {
-                    tab[nbseg]=i;
-                    nbseg++;
-                  }
-              }
-
-            for(i = 0 ; i < nbseg ; i++)
-              {
-                pShortDraw = scoGetPointerShortDraw(pScopeMemory,0,tab[i]);
-                pSEGS_FEATURE(pShortDraw)->vx[0] = t;
-                pSEGS_FEATURE(pShortDraw)->vx[1] = t;
-                pSEGS_FEATURE(pShortDraw)->vy[0] = i*0.8/nbseg;
-                pSEGS_FEATURE(pShortDraw)->vy[1] = (i+1)*0.8/nbseg;
-                pSEGS_FEATURE(pShortDraw)->Nbr1 = 2;
-                pSEGS_FEATURE(pShortDraw)->Nbr2 = 2;
-              }
-            /*End of Not Factorize*/
-            scoDrawScopeAmplitudeTimeStyle(pScopeMemory,t);
-          }
-        break;
+    /* Charging elements */
+
+    scoRetrieveScopeMemory(block->work,&pScopeMemory);
+
+    if(scoGetScopeActivation(pScopeMemory) == 1)
+      {
+
+        t = get_scicos_time();
+        if(scoGetPointerScopeWindow(pScopeMemory) == NULL)
+          {
+        cevscpe_draw(block,&pScopeMemory,0);
+          }
+
+        scoRefreshDataBoundsX(pScopeMemory,t);
+
+        /*Not Factorize*/
+
+        for(i = 0 ; i < scoGetNumberOfCurvesBySubwin(pScopeMemory,0) ; i++)
+          {
+        if((GetNevIn(block)&(1<<i))==(1<<i))
+          {
+            tab[nbseg]=i;
+            nbseg++;
+          }
+          }
+
+        for(i = 0 ; i < nbseg ; i++)
+          {
+        pShortDraw = scoGetPointerShortDraw(pScopeMemory,0,tab[i]);
+        pSEGS_FEATURE(pShortDraw)->vx[0] = t;
+        pSEGS_FEATURE(pShortDraw)->vx[1] = t;
+        pSEGS_FEATURE(pShortDraw)->vy[0] = i*0.8/nbseg;
+        pSEGS_FEATURE(pShortDraw)->vy[1] = (i+1)*0.8/nbseg;
+        pSEGS_FEATURE(pShortDraw)->Nbr1 = 2;
+        pSEGS_FEATURE(pShortDraw)->Nbr2 = 2;
+          }
+        /*End of Not Factorize*/
+        scoDrawScopeAmplitudeTimeStyle(pScopeMemory,t);
+      }
+    break;
       }
 
     case Ending:
       {
 
-                                scoRetrieveScopeMemory(block->work, &pScopeMemory);
-                                if(scoGetScopeActivation(pScopeMemory) == 1)
-                                {
-                                        /* sciSetUsedWindow(scoGetWindowID(pScopeMemory)); */
-                                        /* Check if figure is still opened, otherwise, don't try to destroy it again. */
-                                        if(scoGetPointerScopeWindow(pScopeMemory) != NULL)
-                                        {
-                                                for(i = 0 ; i < scoGetNumberOfCurvesBySubwin(pScopeMemory,0) ; i++)
-                                                {
-                                                        /* maybe a bug here in the last argument of the following instruction (see tab[i]) */
-                                                        pLongDraw = scoGetPointerLongDraw(pScopeMemory,0,i);
-                                                        forceRedraw(pLongDraw);
-                                                }
-                                        
-
-                                                /* pShortDraw = sciGetCurrentFigure(); */
-                                                pShortDraw = scoGetPointerScopeWindow(pScopeMemory);
-                                                clearUserData(pShortDraw);
-                                                /* pFIGURE_FEATURE(pShortDraw)->user_data = NULL; */
-                                                /* pFIGURE_FEATURE(pShortDraw)->size_of_user_data = 0; */
-                                                /* restore double buffering */
+                scoRetrieveScopeMemory(block->work, &pScopeMemory);
+                if(scoGetScopeActivation(pScopeMemory) == 1)
+                {
+                    /* sciSetUsedWindow(scoGetWindowID(pScopeMemory)); */
+                    /* Check if figure is still opened, otherwise, don't try to destroy it again. */
+                    if(scoGetPointerScopeWindow(pScopeMemory) != NULL)
+                    {
+                        for(i = 0 ; i < scoGetNumberOfCurvesBySubwin(pScopeMemory,0) ; i++)
+                        {
+                            /* maybe a bug here in the last argument of the following instruction (see tab[i]) */
+                            pLongDraw = scoGetPointerLongDraw(pScopeMemory,0,i);
+                            forceRedraw(pLongDraw);
+                        }
+
+
+                        /* pShortDraw = sciGetCurrentFigure(); */
+                        pShortDraw = scoGetPointerScopeWindow(pScopeMemory);
+                        clearUserData(pShortDraw);
+                        /* pFIGURE_FEATURE(pShortDraw)->user_data = NULL; */
+                        /* pFIGURE_FEATURE(pShortDraw)->size_of_user_data = 0; */
+                        /* restore double buffering */
                         if (pShortDraw) {
                             sciSetJavaUseSingleBuffer(pShortDraw, FALSE);
                         }
-                                        }
-                                }
-                                scoFreeScopeMemory(block->work,&pScopeMemory);
-                                break;
-                        }
-        }
+                        scoDelCoupleOfSegments(pScopeMemory);
+                    }
+                }
+                scoFreeScopeMemory(block->work,&pScopeMemory);
+                break;
+            }
+    }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/scicos_blocks/src/c/cmscope.c b/scilab/modules/scicos_blocks/src/c/cmscope.c
index 7504298..b8e7bba 100644
--- a/scilab/modules/scicos_blocks/src/c/cmscope.c
+++ b/scilab/modules/scicos_blocks/src/c/cmscope.c
@@ -18,7 +18,7 @@
 *
 * See the file ./license.txt
 */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /**
    \file cmscope.c
    \author Benoit Bayol
@@ -27,7 +27,7 @@
    \brief CMSCOPE is a typical scope which links its input to the simulation time
    \see CMSCOPE.sci in macros/scicos_blocks/Sinks/
 */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 #include "CurrentObjectsManagement.h"
 #include "scicos.h"
 #include "scoMemoryScope.h"
@@ -41,7 +41,7 @@
 #include "scicos_free.h"
 #include "MALLOC.h"
 #include "dynlib_scicos_blocks.h"
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /** \fn cmscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
@@ -102,7 +102,7 @@ SCICOS_BLOCKS_IMPEXP void cmscope_draw(scicos_block * block, ScopeMemory ** pSco
   for (i = 0 ; i < number_of_subwin ; i++)
     {
       period[i] = rpar[i+1];
-      nbr_period++; 
+      nbr_period++;
     }
   ymin = (double*)scicos_malloc(number_of_subwin*sizeof(double));
   ymax = (double*)scicos_malloc(number_of_subwin*sizeof(double));
@@ -118,11 +118,11 @@ SCICOS_BLOCKS_IMPEXP void cmscope_draw(scicos_block * block, ScopeMemory ** pSco
 
       scoInitScopeMemory(block->work,pScopeMemory, number_of_subwin, number_of_curves_by_subwin);
       for(i = 0 ; i < number_of_subwin ; i++)
-        {
-          scoSetLongDrawSize(*pScopeMemory, i, 5000);
-          scoSetShortDrawSize(*pScopeMemory,i,buffer_size);
-          scoSetPeriod(*pScopeMemory,i,period[i]);
-        }    
+    {
+      scoSetLongDrawSize(*pScopeMemory, i, 5000);
+      scoSetShortDrawSize(*pScopeMemory,i,buffer_size);
+      scoSetPeriod(*pScopeMemory,i,period[i]);
+    }
     }
 
   /* Xmin and Xmax are calculated here because we need a variable which is only existing in the pScopeMemory. pScopeMemory is allocated just few lines before. Indeed in this TimeAmplitudeScope Xmin and Xmax have to change often. To be sure to redraw in the correct scale we have to calculate xmin and xmax thanks to the period_counter. If the window haven't to be redraw (recreate)  it wouldn't be necessary*/
@@ -141,7 +141,7 @@ SCICOS_BLOCKS_IMPEXP void cmscope_draw(scicos_block * block, ScopeMemory ** pSco
       scoAddTitlesScope(*pScopeMemory,label,"t","y",NULL);
 
   /*Add a couple of polyline : one for the shortdraw and one for the longdraw*/
-  /*    scoAddPolylineLineStyle(*pScopeMemory,colors); */
+  /*     scoAddPolylineLineStyle(*pScopeMemory,colors); */
       scoAddCoupleOfPolylines(*pScopeMemory,colors);
     }
   scicos_free(number_of_curves_by_subwin);
@@ -157,7 +157,7 @@ SCICOS_BLOCKS_IMPEXP void cmscope_draw(scicos_block * block, ScopeMemory ** pSco
     sciSetJavaUseSingleBuffer(scoGetPointerScopeWindow(*pScopeMemory), TRUE);
   }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /** \fn void cmscope(scicos_block * block, int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -173,100 +173,101 @@ SCICOS_BLOCKS_IMPEXP cmscope(scicos_block * block, int flag)
   scoGraphicalObject pShortDraw;
   int i = 0,j = 0;
 
-  double d_current_real_time = 0. ; 
+  double d_current_real_time = 0. ;
 
   /* Initializations and Allocations*/
   //Allocations are done here because there are dependent of some values presents below
- 
+
   /* State Machine Control */
   switch(flag)
     {
     case Initialization:
       {
-        cmscope_draw(block,&pScopeMemory,1);
-        
+    cmscope_draw(block,&pScopeMemory,1);
+
         //** Init the real time section
-          //** current real time as double [second] 
+          //** current real time as double [second]
           d_current_real_time = scoGetRealTime();
-          pScopeMemory->d_last_scope_update_time = d_current_real_time ; //** update the ds for the next step 
+          pScopeMemory->d_last_scope_update_time = d_current_real_time ; //** update the ds for the next step
 
-        break; //Break of the switch condition: dont forget it 
+    break; //Break of the switch condition: dont forget it
       } //End of Initialization
-  
+
     case StateUpdate:
       {
-        /*Retreiving Scope in the block->work*/
-        scoRetrieveScopeMemory(block->work,&pScopeMemory);
-        if(scoGetScopeActivation(pScopeMemory) == 1)
-          {
-            /* Charging Elements */
-            t = get_scicos_time();
-            /* If window has been destroyed we recreate it */
-            if(scoGetPointerScopeWindow(pScopeMemory) == NULL)
-              {
-                cmscope_draw(block,&pScopeMemory,0);
-              }
+    /*Retreiving Scope in the block->work*/
+    scoRetrieveScopeMemory(block->work,&pScopeMemory);
+    if(scoGetScopeActivation(pScopeMemory) == 1)
+      {
+        /* Charging Elements */
+        t = get_scicos_time();
+        /* If window has been destroyed we recreate it */
+        if(scoGetPointerScopeWindow(pScopeMemory) == NULL)
+          {
+        cmscope_draw(block,&pScopeMemory,0);
+          }
 
-            scoRefreshDataBoundsX(pScopeMemory,t);
+        scoRefreshDataBoundsX(pScopeMemory,t);
 
-            //Here we are calculating the points in the polylines
-            for (i = 0 ; i < scoGetNumberOfSubwin(pScopeMemory) ; i++)
-              {
-                u1 = GetRealInPortPtrs(block,i+1);
-                pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,0);
-                NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1;
-                for (j = 0; j < scoGetNumberOfCurvesBySubwin(pScopeMemory,i) ; j++)
-                  {
-                    pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,j);
-                    pPOLYLINE_FEATURE(pShortDraw)->pvx[NbrPtsShort] = t;
-                    pPOLYLINE_FEATURE(pShortDraw)->pvy[NbrPtsShort] = u1[j];
-                    pPOLYLINE_FEATURE(pShortDraw)->n1++;
-                  }
-              }
+        //Here we are calculating the points in the polylines
+        for (i = 0 ; i < scoGetNumberOfSubwin(pScopeMemory) ; i++)
+          {
+        u1 = GetRealInPortPtrs(block,i+1);
+        pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,0);
+        NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1;
+        for (j = 0; j < scoGetNumberOfCurvesBySubwin(pScopeMemory,i) ; j++)
+          {
+            pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,j);
+            pPOLYLINE_FEATURE(pShortDraw)->pvx[NbrPtsShort] = t;
+            pPOLYLINE_FEATURE(pShortDraw)->pvy[NbrPtsShort] = u1[j];
+            pPOLYLINE_FEATURE(pShortDraw)->n1++;
+          }
+          }
 
             // Draw the Scope
-            scoDrawScopeAmplitudeTimeStyle(pScopeMemory, t); //** the scope update condition
-                                                             //** is hidden here 
+        scoDrawScopeAmplitudeTimeStyle(pScopeMemory, t); //** the scope update condition
+                                                             //** is hidden here
 
-          } 
-        break; 
+      }
+    break;
 
       } //**End of stateupdate
-    
+
    //** Ending is activated when the simulation is done or when we close Scicos
     case Ending:
       {
-        scoRetrieveScopeMemory(block->work, &pScopeMemory);
-        if(scoGetScopeActivation(pScopeMemory) == 1)
-          {
-          //  sciSetUsedWindow(scoGetWindowID(pScopeMemory));
-          //  pShortDraw = sciGetCurrentFigure();
-          //  pFIGURE_FEATURE(pShortDraw)->user_data = NULL;
-          //  pFIGURE_FEATURE(pShortDraw)->size_of_user_data = 0;
-                        ///* restore double buffering */
-                        //sciSetJavaUseSingleBuffer(pShortDraw, FALSE);
-          //  scoDelCoupleOfPolylines(pScopeMemory);
+    scoRetrieveScopeMemory(block->work, &pScopeMemory);
+    if(scoGetScopeActivation(pScopeMemory) == 1)
+      {
+      //  sciSetUsedWindow(scoGetWindowID(pScopeMemory));
+      //  pShortDraw = sciGetCurrentFigure();
+      //  pFIGURE_FEATURE(pShortDraw)->user_data = NULL;
+      //  pFIGURE_FEATURE(pShortDraw)->size_of_user_data = 0;
+            ///* restore double buffering */
+            //sciSetJavaUseSingleBuffer(pShortDraw, FALSE);
+      //  scoDelCoupleOfPolylines(pScopeMemory);
 
 
-                        /* Check if figure is still opened, otherwise, don't try to destroy it again. */
-                        scoGraphicalObject figure = scoGetPointerScopeWindow(pScopeMemory);
-                        if (figure != NULL)
-                        {
-                                /*pShortDraw = scoGetPointerScopeWindow(pScopeMemory);*/
-                                clearUserData(figure);
+            /* Check if figure is still opened, otherwise, don't try to destroy it again. */
+            scoGraphicalObject figure = scoGetPointerScopeWindow(pScopeMemory);
+            if (figure != NULL)
+            {
+                /*pShortDraw = scoGetPointerScopeWindow(pScopeMemory);*/
+                clearUserData(figure);
 
-                                /* restore double buffering */
-                                if (figure) {
+                /* restore double buffering */
+                if (figure) {
                     sciSetJavaUseSingleBuffer(figure, FALSE);
                 }
-                        }
+                scoDelCoupleOfPolylines(pScopeMemory);
+            }
 
-          }
+      }
 
         scoFreeScopeMemory(block->work, &pScopeMemory);
 
-        break;
+        break;
       }
     }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/scicos_blocks/src/c/cscope.c b/scilab/modules/scicos_blocks/src/c/cscope.c
index 1604911..ad6f057 100644
--- a/scilab/modules/scicos_blocks/src/c/cscope.c
+++ b/scilab/modules/scicos_blocks/src/c/cscope.c
@@ -1,24 +1,24 @@
 /*  Scicos
-*
-*  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
-*
-* This program is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation; either version 2 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program; if not, write to the Free Software
-* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*
-* See the file ./license.txt
-*/
-/*--------------------------------------------------------------------------*/ 
+ *
+ *  Copyright (C) INRIA - METALAU Project <scicos@inria.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * See the file ./license.txt
+ */
+/*--------------------------------------------------------------------------*/
 /**
    \file cscope.c
    \author Benoit Bayol
@@ -27,7 +27,7 @@
    \brief CSCOPE is a typical scope which links its input to the simulation time but there is only one input instead of CMSCOPE
    \see CSCOPE.sci in macros/scicos_blocks/Sinks/
 */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 #include <stdio.h>
 #include "CurrentObjectsManagement.h"
 #include "scicos.h"
@@ -42,88 +42,88 @@
 #include "scicos_free.h"
 #include "MALLOC.h"
 #include "dynlib_scicos_blocks.h"
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /** \fn cscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
     \brief Function to draw or redraw the window
 */
 SCICOS_BLOCKS_IMPEXP void cscope_draw(scicos_block * block, ScopeMemory ** pScopeMemory, int firstdraw)
 {
-  int i = 0;
-  double *rpar = NULL;
-  int *ipar = NULL, nipar = 0;
-  double period = 0.;
-  int dimension = 0;
-  double ymin = 0., ymax = 0., xmin = 0., xmax = 0.;
-  int buffer_size = 0;
-  int win_pos[2];
-  int win_dim[2];
-  int win = 0;
-  int number_of_subwin = 0;
-  int number_of_curves_by_subwin[1];
-  int * colors = NULL;
-  char *label = NULL;
-
-  /*Retrieving Parameters*/
-  rpar = GetRparPtrs(block);
-  ipar = GetIparPtrs(block);
-  nipar = GetNipar(block);
-  
-  buffer_size = ipar[2]; //** this is the "standard" buffer size 
-  
-  win = ipar[0];
-  period  = rpar[3];
-  win_pos[0] = ipar[(nipar-1) - 3];
-  win_pos[1] = ipar[(nipar-1) - 2];
-  win_dim[0] = ipar[(nipar-1) - 1];
-  win_dim[1] = ipar[nipar-1];
-  dimension = 2;
-  number_of_curves_by_subwin[0] = GetInPortRows(block,1);
-
-  number_of_subwin = 1;
-  ymin = rpar[1];
-  ymax = rpar[2];
-  label = GetLabelPtrs(block);
-
-  colors = (int*)scicos_malloc(number_of_curves_by_subwin[0]*sizeof(int));
-  for(i = 0 ; i < number_of_curves_by_subwin[0] ; i++)
+    int i = 0;
+    double *rpar = NULL;
+    int *ipar = NULL, nipar = 0;
+    double period = 0.;
+    int dimension = 0;
+    double ymin = 0., ymax = 0., xmin = 0., xmax = 0.;
+    int buffer_size = 0;
+    int win_pos[2];
+    int win_dim[2];
+    int win = 0;
+    int number_of_subwin = 0;
+    int number_of_curves_by_subwin[1];
+    int * colors = NULL;
+    char *label = NULL;
+
+    /*Retrieving Parameters*/
+    rpar = GetRparPtrs(block);
+    ipar = GetIparPtrs(block);
+    nipar = GetNipar(block);
+
+    buffer_size = ipar[2]; //** this is the "standard" buffer size
+
+    win = ipar[0];
+    period  = rpar[3];
+    win_pos[0] = ipar[(nipar-1) - 3];
+    win_pos[1] = ipar[(nipar-1) - 2];
+    win_dim[0] = ipar[(nipar-1) - 1];
+    win_dim[1] = ipar[nipar-1];
+    dimension = 2;
+    number_of_curves_by_subwin[0] = GetInPortRows(block,1);
+
+    number_of_subwin = 1;
+    ymin = rpar[1];
+    ymax = rpar[2];
+    label = GetLabelPtrs(block);
+
+    colors = (int*)scicos_malloc(number_of_curves_by_subwin[0]*sizeof(int));
+    for(i = 0 ; i < number_of_curves_by_subwin[0] ; i++)
     {
-      colors[i] = ipar[3+i];
+        colors[i] = ipar[3+i];
     }
 
-  /*Allocating memory*/
-  if(firstdraw == 1)
+    /*Allocating memory*/
+    if(firstdraw == 1)
     {
-      scoInitScopeMemory(block->work,pScopeMemory, number_of_subwin, number_of_curves_by_subwin);
-      /*Must be placed before adding polyline or other elements*/
-      scoSetLongDrawSize(*pScopeMemory, 0, 50);
+        scoInitScopeMemory(block->work,pScopeMemory, number_of_subwin, number_of_curves_by_subwin);
+        /*Must be placed before adding polyline or other elements*/
+        scoSetLongDrawSize(*pScopeMemory, 0, 50);
 
-      scoSetShortDrawSize(*pScopeMemory,0,buffer_size); //** set the short draw size 
+        scoSetShortDrawSize(*pScopeMemory,0,buffer_size); //** set the short draw size
 
-      scoSetPeriod(*pScopeMemory,0,period);
+        scoSetPeriod(*pScopeMemory,0,period);
     }
 
-  xmin = period*scoGetPeriodCounter(*pScopeMemory,0);
-  xmax = period*(scoGetPeriodCounter(*pScopeMemory,0)+1);
+    xmin = period*scoGetPeriodCounter(*pScopeMemory,0);
+    xmax = period*(scoGetPeriodCounter(*pScopeMemory,0)+1);
 
-  /*Creating the Scope*/
-  scoInitOfWindow(*pScopeMemory, dimension, win, win_pos, win_dim, &xmin, &xmax, &ymin, &ymax, NULL, NULL);
-  if(scoGetScopeActivation(*pScopeMemory) == 1)
+    /*Creating the Scope*/
+    scoInitOfWindow(*pScopeMemory, dimension, win, win_pos, win_dim, &xmin, &xmax, &ymin, &ymax, NULL, NULL);
+    if(scoGetScopeActivation(*pScopeMemory) == 1)
     {
-      scoAddTitlesScope(*pScopeMemory,label,"t","y",NULL);
-      /*Add a couple of polyline : one for the shortdraw and one for the longdraw*/
-      scoAddCoupleOfPolylines(*pScopeMemory,colors);
-      /* scoAddPolylineLineStyle(*pScopeMemory,colors); */
+        scoAddTitlesScope(*pScopeMemory,label,"t","y",NULL);
+        /*Add a couple of polyline : one for the shortdraw and one for the longdraw*/
+        scoAddCoupleOfPolylines(*pScopeMemory,colors);
+        /* scoAddPolylineLineStyle(*pScopeMemory,colors); */
     }
-  scicos_free(colors);
+    scicos_free(colors);
 
-  /* use only single buffering to be sure to draw on the screen */
-  if (scoGetPointerScopeWindow(*pScopeMemory) != NULL)
+    /* use only single buffering to be sure to draw on the screen */
+    if (scoGetPointerScopeWindow(*pScopeMemory) != NULL)
     {
-      sciSetJavaUseSingleBuffer(scoGetPointerScopeWindow(*pScopeMemory), TRUE);
+        sciSetJavaUseSingleBuffer(scoGetPointerScopeWindow(*pScopeMemory), TRUE);
     }
-  
+
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /** \fn void cscope(scicos_block * block,int flag)
     \brief the computational function
     \param block A pointer to a scicos_block
@@ -131,100 +131,101 @@ SCICOS_BLOCKS_IMPEXP void cscope_draw(scicos_block * block, ScopeMemory ** pScop
 */
 SCICOS_BLOCKS_IMPEXP void cscope(scicos_block * block,int flag)
 {
-  ScopeMemory * pScopeMemory = NULL;
-  int i = 0;
-  double t = 0.;
-  int NbrPtsShort = 0;
-  double * u1 = NULL;
-  scoGraphicalObject pShortDraw;
+    ScopeMemory * pScopeMemory = NULL;
+    int i = 0;
+    double t = 0.;
+    int NbrPtsShort = 0;
+    double * u1 = NULL;
+    scoGraphicalObject pShortDraw;
 
-  double d_current_real_time = 0.; 
+    double d_current_real_time = 0.;
+
+    switch(flag)
+    {
 
-  switch(flag) 
+    case Initialization:
     {
-    
-     case Initialization:
-      {
-        cscope_draw(block,&pScopeMemory,1);
+        cscope_draw(block,&pScopeMemory,1);
 
         //** Init the real time section
-          //** current real time as double [second] 
-          d_current_real_time = scoGetRealTime();
-          pScopeMemory->d_last_scope_update_time = d_current_real_time ; //** update the ds for the next step
-          //** printf("Init:Start! \n\n"); //** DEBUG ONLY ! 
-                                        
-        break;
-      }
-    
-     case StateUpdate:
-      {
-        scoRetrieveScopeMemory(block->work,&pScopeMemory);
-        if(scoGetScopeActivation(pScopeMemory) == 1)
-          {
-            t = get_scicos_time();
-            /*Retreiving Scope in the block->work*/
-            
-            /*If window has been destroyed we recreate it*/
-            if (scoGetPointerScopeWindow(pScopeMemory) == NULL)
-             {
-               cscope_draw(block,&pScopeMemory,0);
-             }
-            
+        //** current real time as double [second]
+        d_current_real_time = scoGetRealTime();
+        pScopeMemory->d_last_scope_update_time = d_current_real_time ; //** update the ds for the next step
+        //** printf("Init:Start! \n\n"); //** DEBUG ONLY !
+
+        break;
+    }
+
+    case StateUpdate:
+    {
+        scoRetrieveScopeMemory(block->work,&pScopeMemory);
+        if(scoGetScopeActivation(pScopeMemory) == 1)
+        {
+            t = get_scicos_time();
+            /*Retreiving Scope in the block->work*/
+
+            /*If window has been destroyed we recreate it*/
+            if (scoGetPointerScopeWindow(pScopeMemory) == NULL)
+            {
+                cscope_draw(block,&pScopeMemory,0);
+            }
+
             /*Maybe we are in the end of axes so we have to draw new ones */
-            scoRefreshDataBoundsX(pScopeMemory,t);
-
-            // Cannot be factorized depends of the scope
-            u1 = GetRealInPortPtrs(block,1);
-            for (i = 0 ; i < scoGetNumberOfCurvesBySubwin(pScopeMemory,0) ; i++)
-               {
-                 pShortDraw  = scoGetPointerShortDraw(pScopeMemory,0,i);
-                         if (pShortDraw)
-                         {
-                                NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1;
-                                pPOLYLINE_FEATURE(pShortDraw)->pvx[NbrPtsShort] = t;
-                                pPOLYLINE_FEATURE(pShortDraw)->pvy[NbrPtsShort] = u1[i];
-                                pPOLYLINE_FEATURE(pShortDraw)->n1++;
-                         }
-               }
-            // End of Cannot
-
-            // Draw the Scope
-            scoDrawScopeAmplitudeTimeStyle(pScopeMemory, t); //** the scope update condition
-                                                             //** is hidden here 
-          }
-
-        break;
-      } //**-----------------------------------------------------------
+            scoRefreshDataBoundsX(pScopeMemory,t);
+
+            // Cannot be factorized depends of the scope
+            u1 = GetRealInPortPtrs(block,1);
+            for (i = 0 ; i < scoGetNumberOfCurvesBySubwin(pScopeMemory,0) ; i++)
+            {
+                pShortDraw  = scoGetPointerShortDraw(pScopeMemory,0,i);
+                if (pShortDraw)
+                {
+                    NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1;
+                    pPOLYLINE_FEATURE(pShortDraw)->pvx[NbrPtsShort] = t;
+                    pPOLYLINE_FEATURE(pShortDraw)->pvy[NbrPtsShort] = u1[i];
+                    pPOLYLINE_FEATURE(pShortDraw)->n1++;
+                }
+            }
+            // End of Cannot
+
+            // Draw the Scope
+            scoDrawScopeAmplitudeTimeStyle(pScopeMemory, t); //** the scope update condition
+                                                             //** is hidden here
+        }
+
+        break;
+    } //**-----------------------------------------------------------
 
     case Ending:
-      {
-        scoRetrieveScopeMemory(block->work, &pScopeMemory);
-        if(scoGetScopeActivation(pScopeMemory) == 1)
-          {
-          //  sciSetUsedWindow(scoGetWindowID(pScopeMemory));
-          //  pShortDraw = sciGetCurrentFigure();
-          //  pFIGURE_FEATURE(pShortDraw)->user_data = NULL;
-          //  pFIGURE_FEATURE(pShortDraw)->size_of_user_data = 0;
-                        ///* restore double buffering */
-                        //sciSetJavaUseSingleBuffer(pShortDraw, FALSE);
-          //  scoDelCoupleOfPolylines(pScopeMemory);
-
-                        /* Check if figure is still opened, otherwise, don't try to destroy it again. */
-                        scoGraphicalObject figure = scoGetPointerScopeWindow(pScopeMemory);
-                        if (figure != NULL)
-                        {
-                                clearUserData(figure);
-                                
-                                /* restore double buffering */
-                                if (figure) {
+    {
+        scoRetrieveScopeMemory(block->work, &pScopeMemory);
+        if(scoGetScopeActivation(pScopeMemory) == 1)
+        {
+            //  sciSetUsedWindow(scoGetWindowID(pScopeMemory));
+            //  pShortDraw = sciGetCurrentFigure();
+            //  pFIGURE_FEATURE(pShortDraw)->user_data = NULL;
+            //  pFIGURE_FEATURE(pShortDraw)->size_of_user_data = 0;
+            ///* restore double buffering */
+            //sciSetJavaUseSingleBuffer(pShortDraw, FALSE);
+            //  scoDelCoupleOfPolylines(pScopeMemory);
+
+            /* Check if figure is still opened, otherwise, don't try to destroy it again. */
+            scoGraphicalObject figure = scoGetPointerScopeWindow(pScopeMemory);
+            if (figure != NULL)
+            {
+                clearUserData(figure);
+
+                /* restore double buffering */
+                if (figure) {
                     sciSetJavaUseSingleBuffer(figure, FALSE);
                 }
-                        }
+                scoDelCoupleOfPolylines(pScopeMemory);
+            }
 
-          }
-        scoFreeScopeMemory(block->work, &pScopeMemory);
-        break;  
-      }
+        }
+        scoFreeScopeMemory(block->work, &pScopeMemory);
+        break;
+    }
     }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/scicos_blocks/src/c/scoWindowScope.c b/scilab/modules/scicos_blocks/src/c/scoWindowScope.c
index 455b5e2..d540bc1 100644
--- a/scilab/modules/scicos_blocks/src/c/scoWindowScope.c
+++ b/scilab/modules/scicos_blocks/src/c/scoWindowScope.c
@@ -18,7 +18,7 @@
 *
 * See the file ./license.txt
 */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 /**
 \file scoWindowScope.c
 \author Benoit Bayol
@@ -26,7 +26,7 @@
 \date September 2006 - January 2007
 \brief Source Code of all functions wich interact with the window like creation of graphical object or refreshing the window
 */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 #include <stdio.h>
 #include <string.h>
 #include "scoBase.h"
@@ -48,9 +48,9 @@
 #include "HandleManagement.h" /* sciGetHandle */
 #include "scicos_block4.h"
 #include "localization.h"
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 extern int C2F(dcopy)();
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 static void scoSetWindowIDInUserData(ScopeMemory * pScopeMemory,int block_number)
 {
         /* 15/07/2009, S. Steer: user data set to a Scilab data structure instead of only the block_number value  */
@@ -73,7 +73,7 @@ static void scoSetWindowIDInUserData(ScopeMemory * pScopeMemory,int block_number
         *ptr_d = (double) block_number;
         *size_ptr = 6;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 scoInteger scoGetUserData(scoGraphicalObject pTemp)
 {
         /* 15/07/2009, S. Steer: to take into account the scoSetWindowIDInUserData change */
@@ -83,7 +83,7 @@ scoInteger scoGetUserData(scoGraphicalObject pTemp)
         ptr_d = (double *) (*user_data_ptr+4);
         return (scoInteger) *ptr_d;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoInitOfWindow(ScopeMemory * pScopeMemory, int dimension, int win_id, int * win_pos, int * win_dim, double * xmin, double * xmax, double * ymin, double * ymax, double * zmin, double * zmax)
 {
         int i = 0;
@@ -94,7 +94,7 @@ void scoInitOfWindow(ScopeMemory * pScopeMemory, int dimension, int win_id, int
         //if win-id is -1 we give an auto number based on the block_number on the diagram
         if (win_id == -1)
         {
-                win_id = 20000 + block_number; 
+                win_id = 20000 + block_number;
         }
         //if we restart the simulation this command delete all previous children of the window
         /* WARNING HERE */
@@ -107,7 +107,7 @@ void scoInitOfWindow(ScopeMemory * pScopeMemory, int dimension, int win_id, int
                         user_data = scoGetUserData(pTemp);
                 }
 
-                sciClearFigure(pTemp); //** if already present is cleared 
+                sciClearFigure(pTemp); //** if already present is cleared
 
         }
         /*if ((user_data == -1 ) || (user_data == win_id))*/
@@ -127,7 +127,7 @@ void scoInitOfWindow(ScopeMemory * pScopeMemory, int dimension, int win_id, int
                         {
                                 //We are getting the Handle of the current axes but in the same time we are constructing it (see below)
                                 //Here pTemp is the pointer on the ScopeWindow
-                                // J-B please check this 
+                                // J-B please check this
                                 scoSetHandleAxes(pScopeMemory,i,sciGetHandle(sciGetFirstTypedSelectedSon( pTemp, SCI_SUBWIN )) );
                         }
                         else
@@ -196,7 +196,7 @@ void scoInitOfWindow(ScopeMemory * pScopeMemory, int dimension, int win_id, int
                 Coserror(_("This scope has the same window id than another."));
         }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoRefreshDataBoundsX(ScopeMemory * pScopeMemory, double t)
 {
         scoGraphicalObject pLongDraw = NULL;
@@ -336,10 +336,10 @@ void scoRefreshDataBoundsX(ScopeMemory * pScopeMemory, double t)
                 }
         }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 //** ------------------------------------------------------------------------------------------------
 //**
-//** ------------ The physical redraw of the scope is hidden here ----------------------------------- 
+//** ------------ The physical redraw of the scope is hidden here -----------------------------------
 //**
 //**
 void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
@@ -352,7 +352,7 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
         int NumCurvInSubWin = 0;
         int NumSubWin = 0 ;
         int NumCurvTotal = 0;
-        int ShortDrawTableIndex = 0;  
+        int ShortDrawTableIndex = 0;
         scoGraphicalObject pLongDraw = NULL;
         scoGraphicalObject pShortDraw = NULL;
         scoGraphicalObject *pShortDrawTable = NULL;
@@ -360,25 +360,25 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
         double d_current_real_time = 0. ; //** the current real time as  double (52 bit) data structure
         double last_update_time = 0. , delta_time = 0.;
         int force_update[256]; //** ... for some headroom :)
-        //** ------ Real Time section -------------------------------------------------------------  
-        //** current real time as double [second] 
-        d_current_real_time = scoGetRealTime();  
-        last_update_time = pScopeMemory->d_last_scope_update_time; //** recover the last update time 
-        delta_time = d_current_real_time - last_update_time ; 
-        //refresh_time = 0.040 ; //** 40ms -> 25 fps min  
+        //** ------ Real Time section -------------------------------------------------------------
+        //** current real time as double [second]
+        d_current_real_time = scoGetRealTime();
+        last_update_time = pScopeMemory->d_last_scope_update_time; //** recover the last update time
+        delta_time = d_current_real_time - last_update_time ;
+        //refresh_time = 0.040 ; //** 40ms -> 25 fps min
         //** ------ End of Real Time section ------------------------------------------------------
 
-        ShortDrawTableIndex = 0; 
-        NumCurvTotal = 0;  
+        ShortDrawTableIndex = 0;
+        NumCurvTotal = 0;
         NumSubWin = scoGetNumberOfSubwin(pScopeMemory);
-        for(i = 0 ; i < NumSubWin ; i++) //** for all the subwindows in the scope 
+        for(i = 0 ; i < NumSubWin ; i++) //** for all the subwindows in the scope
         {
                 pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,0);
                 switch (sciGetEntityType(pShortDraw))
                 {
 
                 case SCI_POLYLINE:
-                        NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1; //** this is incremented by one at each iteration 
+                        NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1; //** this is incremented by one at each iteration
                         break;
 
                 case SCI_SEGS:
@@ -391,27 +391,27 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
                 }
 
                 //** combined condition for forced redraw
-                //S.Steer time condition commented out because it slow down the display 
+                //S.Steer time condition commented out because it slow down the display
                 //an option should be to increase the ShortDraw size if it is full before refresh_time is reached
-                force_update[i]=/*((delta_time>refresh_time) && (NbrPtsShort>=2)) ||*/ 
+                force_update[i]=/*((delta_time>refresh_time) && (NbrPtsShort>=2)) ||*/
                         (NbrPtsShort>=scoGetShortDrawSize(pScopeMemory,i));
 
 
 
                 NumCurvTotal += scoGetNumberOfCurvesBySubwin(pScopeMemory,i);
 
-        } 
+        }
 
         pShortDrawTable = scicos_malloc( NumCurvTotal * sizeof(scoGraphicalObject) );
-        //** for all the sub window in the scope 
-        for (i = 0 ; i < NumSubWin ; i++) 
+        //** for all the sub window in the scope
+        for (i = 0 ; i < NumSubWin ; i++)
         {
                 pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,0);
                 switch (sciGetEntityType(pShortDraw))
                 {
 
                 case SCI_POLYLINE:
-                        NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1; //** this is incremented by one at each iteration 
+                        NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1; //** this is incremented by one at each iteration
                         break;
 
                 case SCI_SEGS:
@@ -423,10 +423,10 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
                         break;
                 }
 
-                //**-------------------------------------------------------------------------------------------------------    
-                //**  
-                if (force_update[i] == 1) 
-                {   
+                //**-------------------------------------------------------------------------------------------------------
+                //**
+                if (force_update[i] == 1)
+                {
                         /*Block for Realloc*/
                         pLongDraw = scoGetPointerLongDraw(pScopeMemory,i,0);
                         switch (sciGetEntityType(pLongDraw))
@@ -456,13 +456,13 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
                         /*End od block for Realloc*/
 
                         /*Block for Draw*/
-                        NumCurvInSubWin = scoGetNumberOfCurvesBySubwin(pScopeMemory,i); //** get number of curves in subwin 
+                        NumCurvInSubWin = scoGetNumberOfCurvesBySubwin(pScopeMemory,i); //** get number of curves in subwin
                         for (j = 0 ; j < NumCurvInSubWin ; j++)
                         {
                                 pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,j);
                                 pLongDraw = scoGetPointerLongDraw(pScopeMemory,i,j);
 
-                                if (pShortDraw != NULL) //** protection for NULL pointer 
+                                if (pShortDraw != NULL) //** protection for NULL pointer
                                 {
                                         sciSetUsedWindow(scoGetWindowID(pScopeMemory));
                                         sciSetSelectedSubWin(scoGetPointerAxes(pScopeMemory,i));
@@ -478,20 +478,20 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
                         /*End of Block for Draw*/
 
                 }
-        } //** end of the for loop for all the subwindow in the scope 
+        } //** end of the for loop for all the subwindow in the scope
 
         /* Draw all short draw(s) in all the _concerned_ subwindows in a row :) */
         sciDrawSetOfObj(pShortDrawTable, ShortDrawTableIndex );
         scicos_free(pShortDrawTable);
 
-        for (i = 0 ; i < NumSubWin ; i++) //** for all the subwin in the scope 
+        for (i = 0 ; i < NumSubWin ; i++) //** for all the subwin in the scope
         {
                 pShortDraw = scoGetPointerShortDraw(pScopeMemory,i,0);
                 pLongDraw = scoGetPointerLongDraw(pScopeMemory,i,0);
                 switch (sciGetEntityType(pShortDraw))
                 {
                 case SCI_POLYLINE:
-                        NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1; //** this is incremented by one at each iteration 
+                        NbrPtsShort = pPOLYLINE_FEATURE(pShortDraw)->n1; //** this is incremented by one at each iteration
                         break;
                 case SCI_SEGS:
                         NbrPtsShort = pSEGS_FEATURE(pShortDraw)->Nbr1;
@@ -500,7 +500,7 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
                         Coserror(_("Cannot use %s with this type of object."), "scoDrawScopeAmplitudeTimeStyle");
                         break;
                 }
-                if (force_update[i] == 1) //** scope need a redraw 
+                if (force_update[i] == 1) //** scope need a redraw
                 {
                         switch (sciGetEntityType(pLongDraw))
                         {
@@ -523,10 +523,10 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
                                 pLongDraw = scoGetPointerLongDraw(pScopeMemory,i,j);
                                 /*Block for Memory*/
                                 /*
-                                * Alan's patch, 04/10/2007 : add NbrPtsToCopy to copy good numbers of pts for the first buffer in LongDraw + 
+                                * Alan's patch, 04/10/2007 : add NbrPtsToCopy to copy good numbers of pts for the first buffer in LongDraw +
                                 * Tricks to handle the trace empty case
                                 */
-                                inc = NbrPtsLong!=0; 
+                                inc = NbrPtsLong!=0;
                                 NbrPtsToCopy = NbrPtsShort + (NbrPtsLong==0);
 
                                 switch (sciGetEntityType(pShortDraw))
@@ -580,12 +580,12 @@ void scoDrawScopeAmplitudeTimeStyle(ScopeMemory * pScopeMemory, double t)
                                                 break;
                                         }
                                 }
-                        } //** close of if() 
+                        } //** close of if()
 
-                        pScopeMemory->d_last_scope_update_time = scoGetRealTime(); //** update the time stamping AFTER the draw 
+                        pScopeMemory->d_last_scope_update_time = scoGetRealTime(); //** update the time stamping AFTER the draw
                         //** this "trick" assure at least 25ms of pure simulation (if the buffer is big enough)
 
-                } //** the scope has been updated  
+                } //** the scope has been updated
 
         } //** for all the subwin
 
@@ -662,14 +662,14 @@ scoGraphicalObject scoCreatePolyline(scoGraphicalObject pAxes, scoInteger polyli
 
         return pPolyline;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddPolylineForShortDraw(ScopeMemory * pScopeMemory, int i, int j, int color)
 {
         scoGraphicalObject pShortDraw;
         pShortDraw = scoCreatePolyline(scoGetPointerAxes(pScopeMemory,i),scoGetShortDrawSize(pScopeMemory,i),color);
         scoSetHandleFromPointerShortDraw(pScopeMemory,i,j,pShortDraw);
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddPolylineForLongDraw(ScopeMemory * pScopeMemory, int i, int j, int color)
 {
 
@@ -678,7 +678,7 @@ void scoAddPolylineForLongDraw(ScopeMemory * pScopeMemory, int i, int j, int col
         scoSetHandleFromPointerLongDraw(pScopeMemory,i,j,pLongDraw);
 
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddCoupleOfPolylines(ScopeMemory * pScopeMemory, int * colors)
 {
         int i,j;
@@ -702,7 +702,7 @@ void scoAddCoupleOfPolylines(ScopeMemory * pScopeMemory, int * colors)
                 inc = j+inc; //not +1 because of we have exited the loop
         }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoDelCoupleOfPolylines(ScopeMemory * pScopeMemory)
 {
         int i,j;
@@ -716,7 +716,16 @@ void scoDelCoupleOfPolylines(ScopeMemory * pScopeMemory)
                 for(i = 0 ; i < scoGetNumberOfSubwin(pScopeMemory) ; i++)
                 {
                         pLongDraw = scoGetPointerLongDraw(pScopeMemory,i,0);
-                        NbrPtsLong = pPOLYLINE_FEATURE(pLongDraw)->n1;
+            /*
+            ** If we have 2 scopes with the same ID, pLongDraw may have already
+            ** been deleted, but we still need to call sciDrawObj in the end.
+            ** http://bugzilla.scilab.org/show_bug.cgi?id=8630
+            */
+                        if (pLongDraw == NULL)
+            {
+                break;
+            }
+            NbrPtsLong = pPOLYLINE_FEATURE(pLongDraw)->n1;
                         if(NbrPtsLong + scoGetShortDrawSize(pScopeMemory,i) > scoGetLongDrawSize(pScopeMemory,i))
                         {
                                 //We realloc because maybe if we add the shortdraw the size would be bigger than the longdraw size
@@ -756,7 +765,7 @@ void scoDelCoupleOfPolylines(ScopeMemory * pScopeMemory)
                 //**redrawHierarchy(scoGetPointerScopeWindow(pScopeMemory));
         }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddCoupleOfSegments(ScopeMemory * pScopeMemory, int * color)
 {
         int i,j;
@@ -834,7 +843,7 @@ void scoAddCoupleOfSegments(ScopeMemory * pScopeMemory, int * color)
                 scicos_free(vy2);
         }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoDelCoupleOfSegments(ScopeMemory * pScopeMemory)
 {
         /* destroy all short draw */
@@ -849,34 +858,34 @@ void scoDelCoupleOfSegments(ScopeMemory * pScopeMemory)
         }
         sciDrawObj(scoGetPointerScopeWindow(pScopeMemory));
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 scoGraphicalObject scoCreateSphere(scoGraphicalObject pAxes, double radius, int color)
 {
         scoGraphicalObject pSphere;
         pSphere=ConstructArc(pAxes, 0, 0, radius, radius, 0, 23040, &color, &color, TRUE, FALSE);
         return pSphere;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddSphereForShortDraw(ScopeMemory * pScopeMemory, int i, int j, double radius, int color)
 {
         scoGraphicalObject pShortDraw;
         pShortDraw = scoCreateSphere(scoGetPointerAxes(pScopeMemory,i),radius,color);
         scoSetHandleFromPointerShortDraw(pScopeMemory,i,j,pShortDraw);
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddSphereForLongDraw(ScopeMemory * pScopeMemory, int i, int j, double radius, int color)
 {
         scoGraphicalObject pLongDraw;
         pLongDraw = scoCreateSphere(scoGetPointerAxes(pScopeMemory,i),radius,color);
         scoSetHandleFromPointerLongDraw(pScopeMemory,i,j,pLongDraw);
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddCoupleOfSpheres(ScopeMemory * pScopeMemory, double * radius, int * colors)
 {
         int i = 0,j = 0;
         sciSetUsedWindow(scoGetWindowID(pScopeMemory));
         for (i = 0 ; i < scoGetNumberOfSubwin(pScopeMemory) ; i++)
-        { 
+        {
                 for(j = 0 ; j < scoGetNumberOfCurvesBySubwin(pScopeMemory,i) ; j++)
                 {
                         if(colors != NULL)
@@ -892,21 +901,21 @@ void scoAddCoupleOfSpheres(ScopeMemory * pScopeMemory, double * radius, int * co
                 }
         }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 scoGraphicalObject scoCreateRectangle(scoGraphicalObject pAxes, double x, double y, double width, double height)
 {
         scoGraphicalObject pRectangle;
         pRectangle = ConstructRectangle(pAxes,x,y,height,width,NULL,NULL,0,1);
         return pRectangle;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddRectangleForLongDraw(ScopeMemory * pScopeMemory, int i, int j, double x, double y, double width, double height)
 {
         scoGraphicalObject pLongDraw;
         pLongDraw = scoCreateRectangle(scoGetPointerAxes(pScopeMemory,i),x,y,width,height);
         scoSetHandleFromPointerLongDraw(pScopeMemory,i,j,pLongDraw);
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddTitlesScope(ScopeMemory * pScopeMemory, char * label, char * x, char * y, char * z)
 {
 
@@ -962,7 +971,7 @@ void scoAddTitlesScope(ScopeMemory * pScopeMemory, char * label, char * x, char
         if (label != NULL)
         {
                 nxname = (int)strlen(label);
-                if (nxname > 39) 
+                if (nxname > 39)
                 {
                         nxname = 39;
                 }
@@ -981,7 +990,7 @@ void scoAddTitlesScope(ScopeMemory * pScopeMemory, char * label, char * x, char
         sciDrawObj(scoGetPointerScopeWindow(pScopeMemory));
         //**redrawHierarchy(scoGetPointerScopeWindow(pScopeMemory));
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoDrawScopeXYStyle(ScopeMemory * pScopeMemory)
 {
         /* 15/07/2009, S. Steer: efficiency improved by grouping the objects to be drawn  */
@@ -997,7 +1006,7 @@ void scoDrawScopeXYStyle(ScopeMemory * pScopeMemory)
         //Coded only for one subwin can be easily extended to many with a factorj , j < scoGetNumberOfSubwin()
 
         /* Display the ShortDraw polylines which are filled */
-        /* The loop on curv has been duplicated for efficiency reason: 
+        /* The loop on curv has been duplicated for efficiency reason:
         to be able to draw all the polyline in one call*/
 
         DrawTable = scicos_malloc( Ncurv * sizeof(scoGraphicalObject) );
@@ -1005,7 +1014,7 @@ void scoDrawScopeXYStyle(ScopeMemory * pScopeMemory)
         {
                 Pinceau = scoGetPointerShortDraw(pScopeMemory,0,i);
                 NbrPtsShort = pPOLYLINE_FEATURE(Pinceau)->n1;
-                if(NbrPtsShort >= scoGetShortDrawSize(pScopeMemory,0)){ 
+                if(NbrPtsShort >= scoGetShortDrawSize(pScopeMemory,0)){
                         DrawTable[ DrawTableIndex++]=Pinceau;
                 }
         }
@@ -1042,7 +1051,7 @@ void scoDrawScopeXYStyle(ScopeMemory * pScopeMemory)
                         if(pPOLYLINE_FEATURE(Pinceau)->pvz != NULL)
                         {
                                 C2F(dcopy)(&NbrPtsShort,pPOLYLINE_FEATURE(Pinceau)->pvz,&c__1,pPOLYLINE_FEATURE(Trait)->pvz+NbrPtsLong,&c__1);
-                        }      
+                        }
                         pPOLYLINE_FEATURE(Trait)->n1 = NbrPtsLong + NbrPtsShort;
                         /*reset the ShortDraw polyline */
                         pPOLYLINE_FEATURE(Pinceau)->pvx[0] = pPOLYLINE_FEATURE(Pinceau)->pvx[NbrPtsShort-1];
@@ -1055,7 +1064,7 @@ void scoDrawScopeXYStyle(ScopeMemory * pScopeMemory)
                 }
         }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoDrawScopeAnimXYStyle(ScopeMemory * pScopeMemory, double * u1, double * u2, double * u3)
 /* 15/07/2009, S. Steer: efficiency improved by grouping the objects to be drawn  */
 {
@@ -1120,7 +1129,7 @@ void scoDrawScopeAnimXYStyle(ScopeMemory * pScopeMemory, double * u1, double * u
                                                 pPOLYLINE_FEATURE(Trait)->pvz[j] = pPOLYLINE_FEATURE(Trait)->pvz[j-1];
                                         }
                                         pPOLYLINE_FEATURE(Trait)->pvz[0] = pPOLYLINE_FEATURE(Pinceau)->pvz[0];
-                                        pPOLYLINE_FEATURE(Pinceau)->pvz[0] = u3[i];  
+                                        pPOLYLINE_FEATURE(Pinceau)->pvz[0] = u3[i];
                                 }
 
                                 /* memorize objects to be drawn */
@@ -1190,7 +1199,7 @@ void scoDrawScopeAnimXYStyle(ScopeMemory * pScopeMemory, double * u1, double * u
 
         }
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 scoGraphicalObject scoCreateGrayplot(scoGraphicalObject pAxes, int size_x, int size_y)
 {
         scoGraphicalObject pGrayplot;
@@ -1217,14 +1226,14 @@ scoGraphicalObject scoCreateGrayplot(scoGraphicalObject pAxes, int size_x, int s
 
         return pGrayplot;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddGrayplotForShortDraw(ScopeMemory * pScopeMemory, int i, int j, int size_x, int size_y)
 {
         scoGraphicalObject pShortDraw;
         pShortDraw = scoCreateGrayplot(scoGetPointerAxes(pScopeMemory,i),size_x,size_y);
         scoSetHandleFromPointerShortDraw(pScopeMemory,i,j,pShortDraw);
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 scoGraphicalObject scoCreatePlot3d(scoGraphicalObject pAxes, int size_x, int size_y)
 {
         scoGraphicalObject pPlot3d;
@@ -1281,11 +1290,11 @@ scoGraphicalObject scoCreatePlot3d(scoGraphicalObject pAxes, int size_x, int siz
 
         return pPlot3d;
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 void scoAddPlot3dForShortDraw(ScopeMemory * pScopeMemory, int i, int j, int size_x, int size_y)
 {
         scoGraphicalObject pShortDraw;
         pShortDraw = scoCreatePlot3d(scoGetPointerAxes(pScopeMemory,i),size_x,size_y);
         scoSetHandleFromPointerShortDraw(pScopeMemory,i,j,pShortDraw);
 }
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/