HandleManagement.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 in graphics handle management.
 --------------------------------------------------------------------------*/

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

#include "HandleManagement.h"
#include "InitObjects.h"
#include "DrawObjects.h"
#include "DestroyObjects.h"
#include "SetProperty.h"
#include "GetProperty.h"
#include "BuildObjects.h"
#include "bcg.h"
#include "WindowList.h"
#include "../../../data_structures/includes/DoublyLinkedList.h" /* REORGANISATION TEMPORAIRE */
#include "sciprint.h"
#include "CurrentObjectsManagement.h"
#include "ObjectSelection.h"


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

sciHandleTab * PENDOFHANDLETAB;

int sciSwapObjects( sciPointObj * firstObject, sciPointObj * secondObject );
int sciRelocateObject( sciPointObj * movedObj, sciPointObj * newParent );

/*********************************** Handle ******************************************/

void
sciSetHandle (sciPointObj * pobj, sciHandleTab * pvalue)
{
  if ( (pobj != getFigureModel()) && (pobj != getAxesModel()))
  {
    sciGetRelationship(pobj)->phandle = pvalue ; 
  }
}


sciHandleTab * sciGetpendofhandletab()
{
  return PENDOFHANDLETAB;
}

int
sciAddNewHandle (sciPointObj * pobj)
{
  sciHandleTab *newhd;
  
  if ((newhd = MALLOC ((sizeof (sciHandleTab)))) == NULL)
    return -1;
  newhd->pprev = PENDOFHANDLETAB;/* We have to use directly PENDOFHANDLETAB and not sciGetHandleTabPointer */
  newhd->pnext = (sciHandleTab *) NULL;
  newhd->index = (long)pobj;/* pour l'instant je prend la valeur du pointeur comme handle !!! */
  
  newhd->pointobj = pobj;
  if (PENDOFHANDLETAB != (sciHandleTab *) NULL)
    PENDOFHANDLETAB->pnext = newhd;
  else
    newhd->pprev = (sciHandleTab *) NULL;
  PENDOFHANDLETAB = newhd;
  
  sciSetHandle (pobj, PENDOFHANDLETAB);
  return 0;
}


sciHandleTab * sciGetHandleTabPointer (sciPointObj * pobj)
{
  return sciGetRelationship (pobj)->phandle ;
}




extern int sciDelHandle
(sciPointObj * pobj)
{
  int tmp = 0;
  sciHandleTab *phandletabtodel;        /* point to a handle structure (prev, value, next) */

  /* We get the handle pointer */
  tmp = 0;
  phandletabtodel = (sciHandleTab *) sciGetHandleTabPointer (pobj);
  if (phandletabtodel == (sciHandleTab *) NULL)
    tmp = 1;
  else
    {
      if (phandletabtodel->pprev == (sciHandleTab *) NULL)
        tmp += 2;
      if (phandletabtodel->pnext == (sciHandleTab *) NULL)
        tmp += 4;
    }
  switch (tmp)
    {
    case 0: /* le phandletabtodel->pprev != NULL et le phandletabtodel->pnext != NULL */
      /*(phandletabtodel->pnext)->pprev = (phandletabtodel->pprev)->pnext; ERREUR */
      (phandletabtodel->pnext)->pprev = phandletabtodel->pprev;
      (phandletabtodel->pprev)->pnext = phandletabtodel->pnext;
      FREE (phandletabtodel);
      break;
    case 2:/* le phandletabtodel->pprev == NULL et le phandletabtodel->pnext !NULL */
      (phandletabtodel->pnext)->pprev = (sciHandleTab *) NULL;
      FREE (phandletabtodel);
      break;
    case 4:/* le phandletabtodel->pprev != NULL et le phandletabtodel->pnext == NULL */
      (phandletabtodel->pprev)->pnext = (sciHandleTab *) NULL;
      PENDOFHANDLETAB = phandletabtodel->pprev;
      FREE (phandletabtodel);    
      break;
    case 6:/* le phandletabtodel->pprev == NULL et le phandletabtodel->pnext == NULL */
      FREE (phandletabtodel);
      PENDOFHANDLETAB = (sciHandleTab *) NULL;
      break;
    case 1:/* the handeltab is empty */
    case 3:/* in prevision */
    case 5:/* in prevision */
    case 7:/* in prevision */
    default:
      sciprint ("no handle to del\n");
      return -1;
      break;
    }
  return 0;
}


long sciGetHandle (sciPointObj * pobj)
{
  return (sciGetRelationship(pobj))->phandle->index ;
}



sciPointObj *
sciGetPointerFromHandle (long handle)
{

  sciHandleTab *phandletab;
  if ( handle != sciGetHandle(getFigureModel()) && handle != sciGetHandle(getAxesModel()))
    {
      phandletab = PENDOFHANDLETAB;
      while ((phandletab != NULL) && (phandletab->index != handle))
        phandletab = phandletab->pprev;
      
      if (phandletab == NULL)
        {
          /* sciprint ("this is not or no more a valid handle !!\n");  F.Leray Adding 'or no more' */
          return (sciPointObj *) NULL;
        }  
      return (sciPointObj *) phandletab->pointobj;
    }
  else if ( handle == sciGetHandle(getFigureModel()))
    return (sciPointObj *) getFigureModel();
  else if ( handle == sciGetHandle(getAxesModel()))
    return (sciPointObj *) getAxesModel();
  else
    {
      /* sciprint ("this is not or no more a valid handle !!\n");  F.Leray Adding 'or no more' */
      return (sciPointObj *) NULL;
    }
    
}

/************************************************ End Handle *************************************************/




sciRelationShip *
sciGetRelationship (sciPointObj * pobj)
{
  sciRelationShip *tmp=NULL;
  switch (sciGetEntityType (pobj))
    {
    case SCI_FIGURE:
      return &(pFIGURE_FEATURE (pobj)->relationship);
      break;
    case SCI_SUBWIN:
      return  &(pSUBWIN_FEATURE (pobj)->relationship);
      break;
    case SCI_TEXT:
      return  &(pTEXT_FEATURE (pobj)->relationship);
      break;
    case SCI_TITLE:
      return  &(pTITLE_FEATURE (pobj)->text.relationship);
      break;
    case SCI_LEGEND:
      return  &(pLEGEND_FEATURE (pobj)->text.relationship);
      break;
    case SCI_ARC:
      return  &(pARC_FEATURE (pobj)->relationship);
      break;
    case SCI_SEGS: 
      return  &(pSEGS_FEATURE (pobj)->relationship);
      break; 
    case SCI_FEC:  
      return  &(pFEC_FEATURE (pobj)->relationship);
      break;
    case SCI_GRAYPLOT:
      return  &(pGRAYPLOT_FEATURE (pobj)->relationship);
      break;
    case SCI_POLYLINE:
      return  &(pPOLYLINE_FEATURE (pobj)->relationship);
      break;
    case SCI_RECTANGLE:
      return  &(pRECTANGLE_FEATURE (pobj)->relationship);
      break;
    case SCI_SURFACE:
      return  &(pSURFACE_FEATURE (pobj)->relationship);
      break;
    case SCI_LIGHT:
      return  &(pLIGHT_FEATURE (pobj)->relationship);
      break;
    case SCI_AXES:
      return  &(pAXES_FEATURE (pobj)->relationship);
      break;
    case SCI_PANNER:
      return  &(pPANNER_FEATURE (pobj)->relationship);
      break;
    case SCI_SBH:
      return  &(pSBH_FEATURE (pobj)->relationship);
      break;
    case SCI_SBV:
      return  &(pSBV_FEATURE (pobj)->relationship);
      break;
    case SCI_MENU:
      return  &(pMENU_FEATURE (pobj)->relationship);
      break;
    case SCI_MENUCONTEXT:
      return  &(pMENUCONTEXT_FEATURE (pobj)->relationship);
      break;
    case SCI_STATUSB:
      return  &(pSTATUSB_FEATURE (pobj)->relationship);
      break;
    case SCI_AGREG:
      return  &(pAGREG_FEATURE (pobj)->relationship);
      break; 
    case SCI_MERGE:
      return  &(pMERGE_FEATURE (pobj)->relationship);
      break;
    case SCI_LABEL: /* F.Leray 27.05.04 */
      return  sciGetRelationship( pLABEL_FEATURE (pobj)->text ) ;
      break;
    case SCI_UIMENU: 
      tmp=&(pUIMENU_FEATURE (pobj)->label.relationship);
      return  &(pUIMENU_FEATURE (pobj)->label.relationship);
      break;
    case SCI_CONSOLE:
      return  &(pCONSOLE_FEATURE (pobj)->relationship);
      break;
    case SCI_FRAME:
      return  &(pFRAME_FEATURE (pobj)->relationship);
      break;
    case SCI_WINDOW:
      return  &(pWINDOW_FEATURE (pobj)->relationship);
      break;
    case SCI_WINDOWFRAME:
      return  &(pWINDOWFRAME_FEATURE (pobj)->relationship);
      break;
    case SCI_SCREEN:
      return  &(pSCREEN_FEATURE (pobj)->relationship);
      break;
    default:
      return (sciRelationShip *) NULL;
      break;
    }
  return (sciRelationShip *) NULL;
}


int sciSetParent (sciPointObj * pson, sciPointObj * pparent)
{
  sciGetRelationship(pson)->pparent = pparent ;
  return 0;
}


sciPointObj * sciGetParent (sciPointObj * pobj)
{
  return sciGetRelationship(pobj)->pparent ;
}


/****************************************** SONS ******************************************/


BOOL
sciAddThisToItsParent (sciPointObj * pthis, sciPointObj * pparent)
{
  sciSons * OneSon = NULL ;
  
  if ( sciSetParent(pthis, pparent) == -1 )
  {
    return FALSE ;
  }

  if ( pparent == NULL )
  {
    /* nothing more to do */
    return TRUE ;
  }

  /* Si c'est null alors il n'y a pas encore de fils d'affecte */
  if ( sciGetRelationship (pparent)->psons != NULL )
  {                     
    /* Il existe au moins un fils d'affecte */
    /* on cree la nouvelle variable */
    if ( (OneSon = MALLOC(sizeof(sciSons))) == NULL ) { return FALSE ; }
    OneSon->pnext = sciGetRelationship (pparent)->psons ;
    OneSon->pprev = NULL;
    sciGetRelationship(pparent)->psons->pprev = OneSon ;
  }
  else
  {
    /* C'est tout neuf alors on cree la variable */
    if ( (OneSon = MALLOC( sizeof(sciSons) )) == NULL ) {return FALSE ; }
    OneSon->pnext = NULL ;
    OneSon->pprev = NULL ;
    sciGetRelationship(pparent)->plastsons = OneSon ;
  }
  OneSon->pointobj = pthis ;
  sciGetRelationship(pparent)->psons = OneSon;
  return TRUE;
}


BOOL sciDelThisToItsParent (sciPointObj * pthis, sciPointObj * pparent)
{
  int tmp = 0 ;
  sciSons *OneSon     = NULL ;
  sciSons *OneSonprev = NULL ;

  if ( pparent == NULL )
  {
    /* nothing to do */
    return TRUE ;
  }

  /* recherche de l'objet a effacer*/
  OneSon = (sciGetRelationship (pparent)->psons);
  OneSonprev = OneSon;
  while ( (OneSon != NULL) &&  (OneSon->pointobj != pthis) )
  {
    OneSonprev = OneSon ; 
    OneSon = OneSon->pnext;
  }

  /* dans quel cas de figure somme nous ? */
  if ( OneSon == NULL )
  {
    tmp++ ;
  }
  else 
  {
    if ( OneSon->pprev == NULL ) { tmp += 2 ; }
    if ( OneSon->pnext == NULL ) { tmp += 4 ; }
  }

  switch(tmp)
  {
    case 0:/* ok<-OneSon->ok     */
      (OneSon->pnext)->pprev = (OneSon->pprev);
      (OneSon->pprev)->pnext = (OneSon->pnext);
      FREE(OneSon);
      return TRUE;
      break;
    case 2:/* ok<-OneSon->NULL   */
      (sciGetRelationship (pparent)->psons) = OneSon->pnext;
      (sciGetRelationship (pparent)->psons)->pprev = NULL ;
      FREE(OneSon);
      return TRUE;
      break;
    case 4:/* NULL<-OneSon->ok   */
      sciGetRelationship (pparent)->plastsons = OneSon->pprev;
      (sciGetRelationship (pparent)->plastsons)->pnext = NULL;
      FREE(OneSon);
      return TRUE;
      break;
    case 6:/* NULL<-OneSon->NULL */
      sciGetRelationship (pparent)->plastsons = NULL;
      sciGetRelationship (pparent)->psons = NULL;
      FREE(OneSon);
      return TRUE;
      break;
    case 1:/* OneSon == NULL     */
    case 3:
    case 5:
    case 7:
    default :
      sciprint ("There is no Son in this Parent!!!!\n");
      return FALSE;
      break;
    }

  return FALSE ;
}


sciSons * sciGetSons (sciPointObj * pobj)
{
  return (sciSons *) (sciGetRelationship (pobj)->psons);
}


sciSons * sciGetLastSons (sciPointObj * pobj)
{
  return (sciSons *)sciGetRelationship (pobj)->plastsons ;
}

/*-----------------------------------------------------------------------------------*/
sciSons * sciGetNextAccessibleSon( sciSons * son )
{
  sciSons * nextSon = son->pnext ;
  while ( nextSon != NULL && !(sciGetIsAccessibleChild( nextSon->pointobj ) ) )
  {
    nextSon = nextSon->pnext ;
  }
  return nextSon ;
}
/*-----------------------------------------------------------------------------------*/
sciSons * sciGetFirstAccessibleSon( sciPointObj * pObj )
{
  sciSons * firstSon = sciGetSons( pObj ) ;
  while( firstSon != NULL && !(sciGetIsAccessibleChild( firstSon->pointobj ) ) )
  {
    firstSon = firstSon->pnext ;
  }
  return firstSon ;
}
/*-----------------------------------------------------------------------------------*/
sciSons * sciFindSon( sciPointObj * searchedObj, sciPointObj * parentObj )
{
  sciSons * curSon = sciGetSons( parentObj ) ;
  while ( curSon != NULL && curSon->pointobj != searchedObj )
  {
    curSon = curSon->pnext ;
  }
  return curSon ;
}
/*-----------------------------------------------------------------------------------*/

/************************************ END SONS **************************************/
/*-----------------------------------------------------------------------------------*/
int sciRelocateObject( sciPointObj * movedObj, sciPointObj * newParent )
{
  sciPointObj * oldParent = sciGetParent( movedObj ) ;
  
  if ( oldParent == newParent )
  {
    /* nothing to do */
    return 0 ;
  }
  
  sciDelThisToItsParent( movedObj, oldParent ) ;
  sciAddThisToItsParent( movedObj, newParent ) ;

  /* if an axis has been moved, its previous parent, a figure might haven't son any more.*/
  if ( sciGetEntityType( movedObj ) == SCI_SUBWIN && sciGetIsSelected( movedObj ) )
  {
    sciSelectFirstSubwin( oldParent ) ;
    if ( sciGetNbTypedObjects( oldParent, SCI_SUBWIN ) == 0 )
    {
      /* we need to recreate a subwin */
      sciPointObj * newSubWin = ConstructSubWin( oldParent, sciGetNumFigure( oldParent ) ) ;
      if ( newSubWin == NULL )
      {
        return -1 ;
      }
      /* we must set the selected subwin */
      sciSetOriginalSubWin( oldParent, newSubWin ) ;
      sciInitSelectedSubWin( newSubWin ) ;
    }
  }
  else if ( sciGetEntityType( movedObj ) == SCI_SURFACE )
  {
    /* we must take care of the merge objects */
    sciPointObj * oldParentSubwin = sciGetParentSubwin( oldParent ) ;
    sciPointObj * newParentSubwin = sciGetParentSubwin( newParent ) ;

    /* the merge object will be the same if the surfaces are in the same subwin */
    if ( oldParentSubwin != newParentSubwin )
    {
      pSUBWIN_FEATURE(oldParent)->surfcounter-- ;
      pSUBWIN_FEATURE(newParent)->surfcounter++ ;
      
      /* reccompute the merge objects */
      updateMerge( oldParentSubwin ) ;
      updateMerge( newParentSubwin ) ;
    }
  }

  return 0 ;
}
/*-----------------------------------------------------------------------------------*/
int sciGetNbFigures( void )
{
  int nbFigure = 0 ;
  int flag     = 0 ;
  int ids          ;
  getWins( &nbFigure, &ids, &flag ) ;
  return nbFigure ;
}
/*-----------------------------------------------------------------------------------*/
BOOL sciCanBeSonOf( sciPointObj * son, sciPointObj * parent )
{
  sciEntityType parentType ;

  if ( parent == NULL || son == NULL )
  {
    return FALSE ;
  }
  
  parentType = sciGetEntityType( parent ) ;
  switch ( sciGetEntityType( son ) )
  {
  case SCI_SCREEN:
    return FALSE ;
  case SCI_WINDOWFRAME:
    return ( parentType == SCI_SCREEN ) ;
  case SCI_WINDOW:
    return ( parentType == SCI_WINDOWFRAME ) ;
  case SCI_FRAME:
    return ( parentType == SCI_WINDOW || parentType == SCI_FRAME ) ;
  case SCI_CONSOLE:
    return ( parentType == SCI_FRAME ) ;
  case SCI_FIGURE:
    return ( parentType == SCI_FRAME ) ;
  case SCI_SUBWIN:
    /* axes can only have figure parents */
    return ( parentType == SCI_FIGURE ) ;
  default:
    return ( parentType == SCI_SUBWIN || parentType == SCI_AGREG ) ;
  }
  return FALSE ;
}
/*-----------------------------------------------------------------------------------*/
int sciRelocateHandles( unsigned long handles[], int nbHandles, unsigned long newParentHandle )
{
  sciPointObj ** movedObjs = NULL ; /* array of moved objects */
  sciPointObj *  parentObj = sciGetPointerFromHandle( newParentHandle ) ;
  int i ;
  int nbFigure = 0 ;
  DoublyLinkedList * modifiedFiguresList = DoublyLinkedList_new() ; /* list of modified figures. */
                                                              /* Only the needed figures are redrawn at the end of the function. */
  
  /* check parent */
  if ( parentObj == NULL )
  {
    Scierror( 999,"The parent handle is not or no more valid.\r\n" ) ;
    return -1 ;
  }

  /* we copy the pointer on the objects in this array */
  movedObjs = MALLOC( nbHandles * sizeof(sciPointObj *) ) ;
  if ( movedObjs == NULL )
  {
    Scierror(999,"Memory full, aborting operation.\r\n") ;
    return -1 ;
  }

  /* check handles and copy their object in an array */
  /* It is better to do a first loop, just to test the validity of the handles. */
  /* As a result, we won't need to stop in the middle of the changes. */
  for ( i = 0 ; i < nbHandles ; i++ )
  {
    movedObjs[i] = sciGetPointerFromHandle( handles[i] ) ;
    /* check handle validity */
    if ( movedObjs[i] == NULL )
    {
       Scierror(999,"Handle number %d is not or no more valid.\r\n", i + 1  ) ;
       FREE( movedObjs ) ;
       return -1 ;
    }
    /* check that handles can be inserted under the parent */
    if ( !sciCanBeSonOf( movedObjs[i], parentObj ) )
    {
      Scierror(999,"Handle number %d is not compatible with the parent handle.\r\n", i + 1 ) ;
      FREE( movedObjs ) ;
      return -1 ;
    }
  }

  /* allocate the array with as much space as number of figures. */
  nbFigure = sciGetNbFigures() ;

  /* now move each object */
  for ( i = 0 ; i < nbHandles ; i++ )
  {
    /* both the current and future (wich might be the same) figure of the object */
    /* are modified. */
    sciPointObj * currentFig = sciGetParentFigure( movedObjs[i] ) ;
    sciPointObj * futureFig  = sciGetParentFigure( parentObj    ) ;

    if ( List_find( modifiedFiguresList, currentFig ) == NULL )
    {
      /* the figure was not already considered modified */
      modifiedFiguresList = List_push( modifiedFiguresList, currentFig ) ;
    }

    if ( List_find( modifiedFiguresList, futureFig ) == NULL )
    {
      /* the figure was not already considered modified */
      modifiedFiguresList = List_push( modifiedFiguresList, futureFig ) ;
    }

    if ( sciRelocateObject( movedObjs[i], parentObj ) != 0 )
    {
      Scierror(999,"Error relocating handle %d.", i  ) ;
    }
  }
  
  FREE( movedObjs ) ;
 
  


  /* redraw the modified figures */
  while( !List_is_empty( modifiedFiguresList ) )
  {
    sciPointObj * modifiedFig  = NULL ;
    modifiedFiguresList = List_pop( modifiedFiguresList, (void *)&modifiedFig ) ;
    sciDrawObj( modifiedFig ) ;
  }
  
  List_free( modifiedFiguresList ) ;
  
  return 0 ;
}
/*-----------------------------------------------------------------------------------*/
int sciSwapObjects( sciPointObj * firstObject, sciPointObj * secondObject )
{
  sciSons * firstSon  = NULL ; /* the two sons entitities pointing on the objects */
  sciSons * secondSon = NULL ;
  sciPointObj * firstParent  = sciGetParent( firstObject  ) ; /* current parent of the first object */
  sciPointObj * secondParent = sciGetParent( secondObject ) ;

  /* check compatibility of the objects with new parents */
  if ( !sciCanBeSonOf( firstObject, sciGetParent( secondObject ) ) )
  {
    Scierror(999,"First handle is not compatible with its new parent.\r\n" ) ;
    return -1 ;
  }
  
  if ( !sciCanBeSonOf( secondObject, sciGetParent( firstObject ) ) )
  {
    Scierror(999,"Second handle is not compatible with its new parent.\r\n" ) ;
    return -1 ;
  }

  firstSon  = sciFindSon( firstObject , firstParent  ) ;
  secondSon = sciFindSon( secondObject, secondParent ) ;
  
  /* check if the sons are correct. This should always be true. */
  if ( firstSon == NULL )
  {
    Scierror( 999,"First object is not correctly placed in the hierarchy.\r\n" ) ;
    return -1 ;
  }
  if ( secondSon == NULL )
  {
    Scierror( 999,"Second object is not correctly placed in the hierarchy.\r\n" ) ;
    return -1 ;
  }

  /* Swap the two pointed values of the handles */
  firstSon->pointobj  = secondObject ;
  secondSon->pointobj = firstObject  ;

  /* change their parents */
  sciSetParent( firstObject , secondParent ) ;
  sciSetParent( secondObject, firstParent  ) ;


  /* In the case of surface handles we must take care of merge objects */
  if (    sciGetEntityType( firstObject ) == SCI_SURFACE
       || sciGetEntityType( secondObject ) == SCI_SURFACE )
  {
    sciPointObj * firstParentSubwin  = sciGetParentSubwin( firstObject  ) ;
    sciPointObj * secondParentSubwin = sciGetParentSubwin( secondObject ) ;

    /* update the number of figure for each objects */
    if ( sciGetEntityType( firstObject ) == SCI_SURFACE )
    {
      /* beware, the objects have already been moved to their new parents */
      pSUBWIN_FEATURE( firstParentSubwin  )->surfcounter++ ;
      pSUBWIN_FEATURE( secondParentSubwin )->surfcounter-- ;
    }

    if ( sciGetEntityType( secondObject ) == SCI_SURFACE )
    {
      pSUBWIN_FEATURE( secondParentSubwin )->surfcounter++ ;
      pSUBWIN_FEATURE( firstParentSubwin  )->surfcounter-- ;
    }

    updateMerge( firstParentSubwin  ) ;
    updateMerge( secondParentSubwin ) ;
  }
  

  return 0 ;

}
/*-----------------------------------------------------------------------------------*/
int swapHandles( unsigned long firstHdl, unsigned long secondHdl )
{
  sciPointObj * firstObject  = sciGetPointerFromHandle( firstHdl  )  ;
  sciPointObj * secondObject = sciGetPointerFromHandle( secondHdl )  ;
  sciPointObj * firstParentFig  = NULL ;
  sciPointObj * secondParentFig = NULL ;
  
  if ( firstObject == NULL )
  {
    Scierror( 999,"First handle is not or no more valid.\r\n" ) ;
    return -1 ;
  }

  if ( secondObject == NULL )
  {
     Scierror( 999,"Second handle is not or no more valid.\r\n" ) ;
    return -1 ;
  }

  if ( sciSwapObjects( firstObject, secondObject ) != 0 )
  {
    return -1 ;
  }

  firstParentFig  = sciGetParentFigure( firstObject ) ;
  secondParentFig = sciGetParentFigure( secondObject ) ;

  /* redraw the parent figures */
  if ( firstParentFig == secondParentFig )
  {
    /* we need only to redraw once since it is the same figure */
    sciDrawObj( firstParentFig ) ;
  }
  else
  {
    sciDrawObj( firstParentFig )  ;
    sciDrawObj( secondParentFig ) ;
  }
  
  return 0 ;

}
/*-----------------------------------------------------------------------------------*/

---