DestroyObjects.c

Go to the documentation of this file.

/*------------------------------------------------------------------------
 *    Graphic library 
 *    Copyright INRIA
 *    newGraph Library header
 *    Matthieu PHILIPPE  , INRIA 2001-2002
 *    Djalel ABDEMOUCHE  , INRIA 2002-2004
 *    Fabrice Leray      , INRIA 2004-2006
 *    Jean-Baptiste Silvy, INRIA 2005-xxxx
 *    Comment:
 *    This file contains all functions used to BUILD new objects : 
 - break the binding between the deleted object and its parent in the 
 existing hierarchy
 - freeing memory
 --------------------------------------------------------------------------*/

#include <stdio.h> 
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <stdarg.h>
#include <time.h>

#include "DestroyObjects.h"
#include "GetProperty.h"
#include "DrawObjects.h"
#include "SetProperty.h"
#include "Interaction.h" /* for callback funtions */
#include "StringMatrix.h"
#include "Xcall1.h"
#include "WindowList.h"
#include "PloEch.h"
#include "sciprint.h"
#include "CurrentObjectsManagement.h"
#include "ObjectSelection.h"

#ifdef WITH_TK
#include "../../../tclsci/includes/GedManagement.h"
#endif

#include "MALLOC.h" /* MALLOC */


/*----------------------------------------------------------------------------*/

/********************* modifie le 01/02/2002 ************************
 * On detruit pas la sous fenetre, elle est initialiser avec la figure
 * pour cette version, on considere qu'il y'a 1 seule sous fenetre et 
 * elle suit la fenetre principale (voir xbasc() ), la fenetre n'est pas 
 * consideree comme un des fils.  
 **DestroyAllGraphicsSons
 * This function destroies childs and pthis
 * @param sciPointObj * pthis: the pointer to the entity
 */
int
DestroyAllGraphicsSons (sciPointObj * pthis)
{
  /* to destroy only the sons put the while into the switch !*/
  sciSons *toto = NULL;
 
  toto = sciGetSons (pthis);
  while ((toto != (sciSons *) NULL) &&
         (toto->pointobj != (sciPointObj *) NULL))
    {
      DestroyAllGraphicsSons (toto->pointobj);
      toto = sciGetSons (pthis);
    }
  switch (sciGetEntityType (pthis))
    {

    case SCI_FIGURE:
      return 0;
      break;
    case SCI_SUBWIN:
      DestroySubWin (pthis);
      return 0;
      break;
    case SCI_TEXT:
      DestroyText (pthis);
      return 0;
      break;
    case SCI_TITLE:
      DestroyTitle (pthis);
      return 0;
      break;
    case SCI_LEGEND:
      DestroyLegend (pthis);
      return 0;
      break;
    case SCI_ARC:
      DestroyArc (pthis);
      return 0; 
      break;
    case SCI_SEGS:
      DestroySegs (pthis);
      return 0;
      break;  
    case SCI_FEC:  
      DestroyFec (pthis);
      return 0;
      break; 
    case SCI_GRAYPLOT: 
      DestroyGrayplot (pthis);
      return 0;
      break; 
    case SCI_POLYLINE:
      DestroyPolyline (pthis);
      return 0;
      break;
    case SCI_RECTANGLE:
      DestroyRectangle (pthis);
      return 0;
      break;
    case SCI_SURFACE:
      DestroySurface (pthis);
      return 0;
      break;
    case SCI_LIGHT:
      break;
    case SCI_AXES:
      DestroyAxes (pthis);
      return 0;
      break;
    case SCI_PANNER:
      break;
    case SCI_SBH:
      DestroyScrollH (pthis);
      return 0;
      break;
    case SCI_SBV:
      DestroyScrollV (pthis);
      return 0;
      break;
    case SCI_MENU:
      DestroySciMenu (pthis);
      return 0;
      break;
    case SCI_MENUCONTEXT:
      DestroyMenuContext (pthis);
      return 0;
      break;
    case SCI_STATUSB:
      DestroyStatusBar (pthis);
      return 0;
      break;
    case SCI_AGREG:
      DestroyCompound (pthis);
      return 0;
      break; 
    case SCI_MERGE:
      DestroyMerge (pthis);
      return 0;
      break;
    case SCI_LABEL: /* F.Leray 28.05.04 */
      DestroyLabel (pthis);
      return 0;
      break;
    case SCI_UIMENU:
      DestroyUimenu (pthis);
      return 0;
      break;
    case SCI_CONSOLE:
      sciDestroyConsole( pthis ) ;
      return 0 ;
    case SCI_FRAME:
      sciDestroyFrame( pthis ) ;
      return 0 ;
    case SCI_WINDOW:
      sciDestroyWindow(pthis) ;
      return 0 ;
    case SCI_WINDOWFRAME:
      sciDestroyWindowFrame(pthis) ;
      return 0 ;
    case SCI_SCREEN:
      sciDestroyScreen(pthis) ;
      return 0 ;
    default:
      sciprint ("Entity with type %d cannot be destroyed\n",sciGetEntityType (pthis));
      return -1;
      break;
    }

  return 0;
}



int
sciDelGraphicObj (sciPointObj * pthis)
{
  switch (sciGetEntityType (pthis))
    {
    case SCI_TITLE:
    case SCI_LEGEND:
    case SCI_ARC:
    case SCI_SEGS: 
    case SCI_FEC: 
    case SCI_GRAYPLOT: 
    case SCI_POLYLINE:
    case SCI_RECTANGLE:
    case SCI_SURFACE:

    case SCI_AXES:
    case SCI_MENU:
    case SCI_MENUCONTEXT:
    case SCI_AGREG:
    case SCI_TEXT:
    case SCI_MERGE: 
    case SCI_LABEL:
    case SCI_UIMENU:
    case SCI_FIGURE:
    case SCI_CONSOLE:
    case SCI_FRAME:
    case SCI_WINDOW:
    case SCI_WINDOWFRAME:
    case SCI_SCREEN:
      DestroyAllGraphicsSons (pthis);
      return 0;
      break;
    case SCI_SUBWIN:
      if (sciGetAxes (sciGetParent(pthis),pthis) == (sciPointObj *) NULL)
        sciXbasc();
      else
        DestroyAllGraphicsSons (pthis);
      return 0;
      break;         
    case SCI_LIGHT:
    case SCI_PANNER:
    case SCI_SBH:
    case SCI_SBV:
    case SCI_STATUSB:
    default:
      sciprint ("This object cannot be deleted\n");
      return -1;
      break;
    }

  return 0;
}

/*-----------------------------------------------------------------------------*/
int C2F(scigerase)( void )
{
  integer verb=0,lstr,v,na,win;
  double dv;
  char str[4];
  C2F(xgetg)("auto clear",str,&lstr,11L,4L);
  if (strcmp(str,"on") == 0) {
    C2F(dr1)("xget","window",&verb,&win,&na,&v,&v,&v,&dv,&dv,&dv,&dv,5L,7L);
    C2F(dr1)("xclear",C2F(cha1).buf,&v,&v,&v,&v,&v,&v,&dv,&dv,&dv,&dv,7L,bsiz);
    C2F(dr1)("xstart",C2F(cha1).buf,&win,&v,&v,&v,&v,&v,&dv,&dv,&dv,&dv,7L,bsiz);
  }
  return 0;
} 
/*-----------------------------------------------------------------------------*/

int DestroyFigure (sciPointObj * pthis)
{
  /* This code has to be validated on all systems
   * because sciGetPointerToFeature returns a void
   */
  FREE ((sciGetFontContext(pthis))->pfontname);
  FREE(pFIGURE_FEATURE(pthis)->pcolormap);
  FREE( pFIGURE_FEATURE(pthis)->infoMessage ) ;
  sciStandardDestroyOperations(pthis) ;
  /* delete windows() */
  return 0;
}



int
DestroyStatusBar (sciPointObj * pthis)
{
  sciDelThisToItsParent(pthis, sciGetParent (pthis));
  FREE ((sciGetFontContext(pthis))->pfontname);
  return sciStandardDestroyOperations(pthis) ;
}



int
DestroySubWin (sciPointObj * pthis)
{ 
  /* Add. grads arrays */ /* F.Leray 11.10.04 */
  /* specific user arrays */
  sciSubWindow * ppsubwin = pSUBWIN_FEATURE (pthis);


  FREE( ppsubwin->axes.u_xgrads); ppsubwin->axes.u_xgrads = (double *) NULL;
  FREE( ppsubwin->axes.u_ygrads); ppsubwin->axes.u_ygrads = (double *) NULL;
  FREE( ppsubwin->axes.u_zgrads); ppsubwin->axes.u_zgrads = (double *) NULL;
  ppsubwin->axes.u_xlabels = FreeUserLabels(ppsubwin->axes.u_xlabels, &ppsubwin->axes.u_nxgrads);
  ppsubwin->axes.u_ylabels = FreeUserLabels(ppsubwin->axes.u_ylabels, &ppsubwin->axes.u_nygrads);
  ppsubwin->axes.u_zlabels = FreeUserLabels(ppsubwin->axes.u_zlabels, &ppsubwin->axes.u_nzgrads);

  ppsubwin->axes.u_xlabels = NULL;
  ppsubwin->axes.u_ylabels = NULL;
  ppsubwin->axes.u_zlabels = NULL;

  ppsubwin->axes.u_nxgrads = 0;
  ppsubwin->axes.u_nygrads = 0;
  ppsubwin->axes.u_nzgrads = 0;
 
 
  /* auto (computed) arrays are defined with max. length == 20 */
  ppsubwin->axes.nxgrads = 0;
  ppsubwin->axes.nygrads = 0;
  ppsubwin->axes.nzgrads = 0;
  
  if ( sciGetCallback(pthis) != (char *)NULL)
    FREE(sciGetCallback(pthis));

  FREE ((sciGetFontContext(pthis))->pfontname);
  return sciStandardDestroyOperations(pthis) ;
}



int
DestroyScrollV (sciPointObj * pthis)
{
   return sciStandardDestroyOperations(pthis) ;
}



int
DestroyScrollH (sciPointObj * pthis)
{
  return sciStandardDestroyOperations(pthis) ;
}

int deallocateText( sciPointObj * pthis )
{
  deleteMatrix( pTEXT_FEATURE(pthis)->pStrings ) ;
  FREE (pTEXT_FEATURE (pthis)->user_data);
  pTEXT_FEATURE (pthis)->size_of_user_data = 0;

  FREE (sciGetFontContext(pthis)->pfontname);
  FREE (sciGetPointerToFeature (pthis));
  FREE (pthis);

  return 0;
}

int DestroyText (sciPointObj * pthis)
{
  deleteMatrix( pTEXT_FEATURE(pthis)->pStrings ) ;
  FREE ((sciGetFontContext(pthis))->pfontname);
  return sciStandardDestroyOperations(pthis) ;
}




int
DestroyTitle (sciPointObj * pthis)
{
  deleteMatrix( pTITLE_FEATURE (pthis)->text.pStrings ) ;
  FREE ((sciGetFontContext(pthis))->pfontname);
  return sciStandardDestroyOperations(pthis) ;
}




int
DestroyLegend (sciPointObj * pthis)
{
  sciLegend * ppLegend = pLEGEND_FEATURE (pthis) ;
  FREE ( ppLegend->pptabofpointobj );
  FREE ( ppLegend->pstyle ) ;
  deleteMatrix( ppLegend->text.pStrings ) ;

  FREE ((sciGetFontContext(pthis))->pfontname);
  return sciStandardDestroyOperations(pthis) ;
  /* on peut alors destroyer le parent */
}



int
DestroyPolyline (sciPointObj * pthis)
{
  FREE (pPOLYLINE_FEATURE (pthis)->pvx);
  FREE (pPOLYLINE_FEATURE (pthis)->pvy);

  if (pPOLYLINE_FEATURE (pthis)->pvz != NULL) 
    FREE (pPOLYLINE_FEATURE (pthis)->pvz);
  return sciStandardDestroyOperations(pthis) ;
}


int
DestroyArc (sciPointObj * pthis)
{
  FREE(pARC_FEATURE (pthis)->callback);
  return sciStandardDestroyOperations(pthis) ;
}



int
DestroyRectangle (sciPointObj * pthis)
{
  return sciStandardDestroyOperations(pthis) ;
}



int
DestroySurface (sciPointObj * pthis)
{
  sciPointObj * psubwin ;
  sciSubWindow * ppSubWin ;
  sciSurface * ppSurface = pSURFACE_FEATURE (pthis) ;
  int res = -1 ;
  
  psubwin  = sciGetParentSubwin(pthis) ;
  ppSubWin = pSUBWIN_FEATURE ( psubwin ) ;

  FREE(ppSurface->pvecz);
  FREE(ppSurface->pvecy);
  FREE(ppSurface->pvecx);
  FREE(ppSurface->inputCMoV); /* Adding F.Leray 24.03.04*/
  FREE(ppSurface->color); /* Adding F.Leray 18.03.05 */
  
  if ( ppSurface->izcol != 0 )
  { 
    FREE(ppSurface->zcol);
  }
  ppSubWin->surfcounter-- ;
  /* DJ.A 2003 */
  res = sciStandardDestroyOperations(pthis) ;

  /* delete the merge object if needed */
  /* Jb Silvy 07/2006 */
  updateMerge( psubwin ) ;

  return res;
}


int DestroyMerge (sciPointObj * pthis)
{
  pSUBWIN_FEATURE (sciGetParentSubwin(pthis))->facetmerge = FALSE;
  FREE(pMERGE_FEATURE (pthis)->index_in_entity);
  FREE(pMERGE_FEATURE (pthis)->from_entity);
  return sciStandardDestroyOperations(pthis) ;
}



int
DestroyGrayplot (sciPointObj * pthis)
{
  FREE (pGRAYPLOT_FEATURE (pthis)->pvecx);
  if (pGRAYPLOT_FEATURE (pthis)->type != 2)
    FREE (pGRAYPLOT_FEATURE (pthis)->pvecy);
  FREE (pGRAYPLOT_FEATURE (pthis)->pvecz);
  return sciStandardDestroyOperations(pthis) ;

}


int
DestroyAxes (sciPointObj * pthis)
{
  int i;
  char **str;

  FREE (pAXES_FEATURE(pthis)->vx);
  FREE (pAXES_FEATURE(pthis)->vy);
  str=pAXES_FEATURE(pthis)->str;
  for (i=Max(pAXES_FEATURE(pthis)->nx,pAXES_FEATURE(pthis)->ny)-1;i<0;i--) 
    FREE (pAXES_FEATURE(pthis)->str); 
  FREE (pAXES_FEATURE(pthis)->str);
  return sciStandardDestroyOperations(pthis) ;
}

int
DestroyFec (sciPointObj * pthis)
{
  FREE (pFEC_FEATURE (pthis)->pvecx);
  FREE (pFEC_FEATURE (pthis)->pvecy);
  FREE (pFEC_FEATURE (pthis)->pnoeud); 
  FREE (pFEC_FEATURE (pthis)->pfun); 
  FREE (pFEC_FEATURE (pthis)->zminmax);  
  FREE (pFEC_FEATURE (pthis)->colminmax);
  FREE (pFEC_FEATURE (pthis)->colout);
  return sciStandardDestroyOperations(pthis) ;
}


int
DestroySegs (sciPointObj * pthis)
{  
  FREE (pSEGS_FEATURE (pthis)->vx);
  FREE (pSEGS_FEATURE (pthis)->vy); 
  if (pSEGS_FEATURE (pthis)->vz != (double *)NULL) 
    FREE (pSEGS_FEATURE (pthis)->vz);  
  if (pSEGS_FEATURE (pthis)->ptype <=0) 
    {
      FREE(pSEGS_FEATURE (pthis)->pstyle);
    } 
  else 
    {
      FREE(pSEGS_FEATURE (pthis)->vfx); pSEGS_FEATURE (pthis)->vfx = NULL;
      FREE(pSEGS_FEATURE (pthis)->vfy); pSEGS_FEATURE (pthis)->vfy = NULL;
      FREE(pSEGS_FEATURE (pthis)->vfz); pSEGS_FEATURE (pthis)->vfz = NULL;
    } 
  return sciStandardDestroyOperations(pthis) ;
}

int DestroyCompound (sciPointObj * pthis)
{
  return sciStandardDestroyOperations(pthis) ;
}

void DeleteObjs(integer win_num)
{
  sciPointObj *figure;
  struct BCG *Xgc;

  figure = (sciPointObj *)  sciIsExistingFigure(&win_num);
  if (  figure != (sciPointObj *) NULL )
    {
      Xgc = (struct BCG *) pFIGURE_FEATURE(figure)->pScilabXgc;
      
      DestroyAllGraphicsSons (figure);
#ifdef WITH_TK
            /* close ged to prevent errors when using it */
            sciDestroyGed( sciGetNum(figure) ) ;
#endif
      DestroyFigure (figure);
      Xgc->mafigure = (sciPointObj *) NULL;
    }
}


int
sciUnCompound (sciPointObj * pobj)
{
  sciPointObj *pparent, *pobjson;
  sciSons *psons = (sciSons *)NULL;
        
  if (sciGetEntityType(pobj) != SCI_AGREG)
    return -1;

  psons = sciGetLastSons(pobj);
  pobjson = psons->pointobj;
  pparent = sciGetParent(pobj);
  while ((psons != (sciSons *) NULL) && (pobjson != (sciPointObj *) NULL))
    {
      /* we delete this son to this */ 
      pobjson = psons->pointobj;
      /* take the previous sons before the current is freed */
      psons = psons->pprev;
      sciDelThisToItsParent (pobjson, pobj);
      /* and link to its old parent */
      sciAddThisToItsParent (pobjson, pparent);
    }

  sciSetCurrentObj(pparent); /* pparent is the new current object */

  DestroyCompound(pobj);
  return 0;
}


int DestroyLabel (sciPointObj * pthis)
{
  sciLabel * ppLabel = pLABEL_FEATURE (pthis);
  int textStatus = -1 ;
  sciUnselectSons( pthis ) ;
  sciDelThisToItsParent( pthis, sciGetParent(pthis) ) ;
  if ( sciDelHandle(pthis) == -1 ) { return -1 ; }
  textStatus = deallocateText( ppLabel->text ) ;
  if ( textStatus != 0 )
  {
    return textStatus ;
  }
  ppLabel->text = NULL ;
  FREE(ppLabel) ;
  FREE(pthis) ;
  return 0 ;
}

int DestroyUimenu (sciPointObj * pthis)
{
  deleteMatrix( pUIMENU_FEATURE (pthis)->label.pStrings ) ;
  FREE (pUIMENU_FEATURE (pthis)->label.callback);

  return sciStandardDestroyOperations(pthis) ;
}



int
sciDelLabelsMenu (sciPointObj * pthis)
{
  sciLabelMenu *pscilabelmenutmp;
  sciLabelMenu *pscilabelmenutofree;

  switch (sciGetEntityType (pthis))
    {
    case SCI_MENU:
      pscilabelmenutmp = (sciLabelMenu *) (pMENU_FEATURE (pthis)->plabelmenu);
      break;
    case SCI_MENUCONTEXT:
      pscilabelmenutmp =
        (sciLabelMenu *) (pMENUCONTEXT_FEATURE (pthis)->plabelmenu);
      break;
    default:
    case SCI_AGREG:
      return -1;
      break;
    }
  while (pscilabelmenutmp != (sciLabelMenu *) NULL)
    {
      /* Il faut retirer tous les menus lies par la liste aussi */
      pscilabelmenutofree = pscilabelmenutmp;
      pscilabelmenutmp = pscilabelmenutmp->pnextlabelmenu;
      FREE (pscilabelmenutofree->plabel);
      FREE (pscilabelmenutofree);
    }
  return 0;
}



int
DestroyMenuContext (sciPointObj * pthis)
{
  sciDelLabelsMenu (pthis);
  return sciStandardDestroyOperations(pthis) ;
}



int
DestroySciMenu (sciPointObj * pthis)
{
  sciDelLabelsMenu (pthis);
  FREE ((sciGetFontContext(pthis))->pfontname);
  return sciStandardDestroyOperations(pthis) ;
}



void delete_sgwin_entities( int win_num )
{
  double dv=0;
  double *XGC;
  struct BCG *CurrentScilabXgc; 
  int v=0;
  /* Need to reset the new current figure returned by sciGetCurrentFigure */
  sciHandleTab *hdl = NULL;
  sciPointObj  *pobj= NULL;

  C2F(dr)("xget","gc",&v,&v,&v,&v,&v,&v,(double *)&XGC,&dv,&dv,&dv,5L,10L); /* ajout cast ???*/
  CurrentScilabXgc=(struct BCG *)XGC;


  hdl = sciGetpendofhandletab();

  if(CurrentScilabXgc != NULL)
    while (hdl != NULL)
    {
      pobj=(sciPointObj *) sciGetPointerFromHandle (hdl->index);
      if (sciGetEntityType(pobj) == SCI_FIGURE && sciGetNum(pobj) == CurrentScilabXgc->CurWindow ) /* Adding F.Leray 19.04.04 */
      {
        sciSetCurrentFigure(pobj);
        sciSetCurrentObj(pobj); /* The current object will always be the figure too. */
        break;

      }
      hdl = hdl->pprev;
    }
}

/*------------------------------------------------------------------------------------*/
/* free the user_data */
void clearUserData( sciPointObj * pObj )
{
  int ** pUserData ;
  int *  pSizeUD   ;
  sciGetPointerToUserData( pObj, &pUserData, &pSizeUD ) ;
  if ( pUserData != NULL && *pUserData != NULL )
  {
    FREE( *pUserData ) ;
    *pUserData = NULL ;
    *pSizeUD = 0 ;
  }
}
/*------------------------------------------------------------------------------------*/
extern int C2F(deletewin)(integer *number);
void sciDeleteWindow( int winNum )
{
  C2F(deletewin)( &winNum ) ;
}
/*------------------------------------------------------------------------------------*/
int updateMerge( sciPointObj * pSubwin )
{
  if ( sciGetSubwinNbSurf( pSubwin ) == 0 )
  {
    sciPointObj * merge = sciGetMerge( pSubwin ) ;
    if ( merge != NULL )
    {
      DestroyMerge( merge ) ;
    }
    pSUBWIN_FEATURE( pSubwin )->facetmerge = FALSE ;
  }
  else
  {
    /* the merge 3d is updated */
    Merge3d( pSubwin ) ;
  }
  return 0 ;
}
/*-----------------------------------------------------------------------------------------*/
void AllGraphWinDelete( void )
{

  integer iflag=0,num=0;
  int *ArrayWGraph=NULL;

  sciGetIdFigure (ArrayWGraph,&num,&iflag);

  if (num > 0)
  {
    int i=0;
    ArrayWGraph=(int*)MALLOC(sizeof(int)*num);

    iflag = 1;
    sciGetIdFigure (ArrayWGraph,&num,&iflag);

    for (i=0;i<num;i++)
    {
      C2F (deletewin) (&ArrayWGraph[i]);
      FREE (ArrayWGraph);
    }
    ArrayWGraph=NULL;
  }
}
/*-----------------------------------------------------------------------------------------*/
void CleanPlots(char *unused, integer *winnumber, integer *v3, integer *v4, integer *v5, integer *v6, integer *v7, double *dx1, double *dx2, double *dx3, double *dx4)
{
  
  /* we remove scales in window number i */
  del_window_scale(*winnumber);
  /* if *winnumber is also the current window we reset Cscale to default value */
  if ( *winnumber == sciGetNum(sciGetCurrentFigure()) ) 
  {
    Cscale2default();
  }
  else
  {
    set_window_scale_with_default(*winnumber);
  }
}

/*-----------------------------------------------------------------------------------------*/
int sciDestroyConsole( sciPointObj * pThis )
{
  return sciStandardDestroyOperations( pThis ) ;
}
/*-----------------------------------------------------------------------------------------*/
int sciStandardDestroyOperations( sciPointObj * pThis )
{
  int res = 0 ;
  clearUserData( pThis ) ;
  sciUnselectSons( pThis ) ;
  sciDelThisToItsParent( pThis, sciGetParent(pThis) ) ;
  if ( sciDelHandle(pThis) == -1 ) { res = -1 ; }
  FREE( pThis->pfeatures ) ;
  FREE( pThis ) ;
  return res ;
}
/*-----------------------------------------------------------------------------------------*/
int sciDestroyFrame( sciPointObj * pThis )
{
  return sciStandardDestroyOperations( pThis ) ;
}
/*-----------------------------------------------------------------------------------------*/
int sciDestroyWindow( sciPointObj * pThis )
{
  return sciStandardDestroyOperations( pThis ) ;
}
/*-----------------------------------------------------------------------------------------*/
int sciDestroyWindowFrame( sciPointObj * pThis )
{
  return sciStandardDestroyOperations( pThis ) ;
}
/*-----------------------------------------------------------------------------------------*/
int sciDestroyScreen( sciPointObj * pThis )
{
  return sciStandardDestroyOperations( pThis ) ;
}
/*-----------------------------------------------------------------------------------------*/

---