home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 199.lha / GimmeLib / copystuff.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-12-28  |  9.0 KB  |  368 lines
  1. /*
  2.  *  FILE: copystuff.c
  3.  *  Support routines for copying (mainly intuition-type) structures.
  4.  *
  5.  *  Public Domain, but keep my name in it as the original author.
  6.  *  31-Oct-88    Jan Sven Trabandt   split from intuistuff.c
  7.  *                    added more functions
  8.  */
  9.  
  10.  
  11. #define I_AM_COPYSTUFF
  12. #include "gimmelib/gimmefuncs.h"
  13. #include "gimmelib/copystuff.h"
  14. #include "gimmelib/intuistuff.h"
  15. #define GIM_BUILTIN
  16. #include "gimmelib/macros.h"
  17.  
  18.  
  19. short copyDataImage( data, image )
  20.     USHORT  *data;
  21.     register struct Image   *image;
  22. {
  23.     register struct Image   *ip;
  24.     ULONG   size;            /* image datasize (bytes) for copying */
  25.     UBYTE   *idata, *srcdata;        /* UBYTE makes additions easier */
  26.  
  27. #ifdef GIMME_WIMPY
  28.     if( !data || !image || !image->ImageData ) {
  29.     return( -1 );
  30.     }
  31. #endif
  32.     size = GIM_IMAGESIZE(image->Depth, image->Width, image->Height);
  33.     if( size > 0x07fffL ) {
  34.     idata = (UBYTE *) image->ImageData;
  35.     srcdata = (UBYTE *) data;
  36.     for( ; size > 0L; size -= 0x07fffL ) {
  37.         movmem( srcdata, idata, (int)(size & 0x07fffL) );
  38.         srcdata += 0x07fffL;
  39.         idata += 0x07fffL;
  40.     } /* for */
  41.     } else {
  42.     movmem( data, image->ImageData, (int) size );
  43.     }
  44.     return( 0 );
  45. } /* copyDataImage */
  46.  
  47.  
  48. short copyImageData( image, data )
  49.     register struct Image   *image;
  50.     USHORT  *data;
  51. {
  52.     register struct Image   *ip;
  53.     ULONG   size;            /* image datasize (bytes) for copying */
  54.     UBYTE   *idata, *destdata;        /* UBYTE makes additions easier */
  55.  
  56. #ifdef GIMME_WIMPY
  57.     if( !data || !image || !image->ImageData ) {
  58.     return( -1 );
  59.     }
  60. #endif
  61.     size = GIM_IMAGESIZE(image->Depth, image->Width, image->Height);
  62.     if( size > 0x07fffL ) {
  63.     idata = (UBYTE *) image->ImageData;
  64.     destdata = (UBYTE *) data;
  65.     for( ; size > 0L; size -= 0x07fffL ) {
  66.         movmem( idata, destdata, (int)(size & 0x07fffL) );
  67.         idata += 0x07fffL;
  68.         destdata += 0x07fffL;
  69.     } /* for */
  70.     } else {
  71.     movmem( image->ImageData, data, (int) size );
  72.     }
  73.     return( 0 );
  74. } /* copyImageData */
  75.  
  76.  
  77. struct Border *copyBorder( mh, oldbp, numbord, myflags )
  78.     void    **mh;
  79.     register struct Border  *oldbp;
  80.     SHORT   numbord;
  81.     ULONG   myflags;
  82. {
  83.     register struct Border  *bp;
  84.     struct Border        *retbp, *temp;
  85.     ULONG            size;
  86.     void            *mymh = NULL;
  87.  
  88. #ifdef GIMME_WIMPY
  89.     if( !mh ) {
  90.     return( NULL );
  91.     }
  92. #endif
  93.     retbp = bp = NULL;
  94.     for( ; oldbp && numbord != 0; oldbp = oldbp->NextBorder, --numbord ) {
  95.     if( !(temp = chainAllocMem(&mymh, (ULONG)sizeof(struct Border),
  96.                     MEMF_PUBLIC)) ) {
  97.         if( !(myflags & GCP_SALVAGE) ) {
  98.         chainFreeMem( mymh );
  99.         retbp = NULL;
  100.         }
  101.         return( retbp );
  102.     }
  103.     if( !bp ) {
  104.         retbp = temp;
  105.     } else {
  106.         bp->NextBorder = temp;
  107.     }
  108.     bp = temp;
  109.     *bp = *oldbp;        /* struct copy */
  110.     if( oldbp->XY && !(myflags & GCP_NOT_POINTS) ) {
  111.         size = sizeof(SHORT) * 2L  * bp->Count;
  112.         if( !(bp->XY = chainAllocMem(&mymh, size, MEMF_PUBLIC)) ) {
  113.         if( !(myflags & GCP_SALVAGE) ) {
  114.             chainFreeMem( mymh );
  115.             return( NULL );
  116.         } else {
  117.             bp->Count = 0;
  118.         }
  119.         } else {
  120.         movmem( oldbp->XY, bp->XY, (int)size );
  121.         }
  122.     }
  123.     } /* for */
  124.     linkChainMem( mh, mymh );
  125.     return( retbp );
  126. } /* copyBorder */
  127.  
  128.  
  129. struct Image *copyImage( mh, oldip, numimage, myflags )
  130.     void    **mh;
  131.     register struct Image   *oldip;
  132.     SHORT   numimage;
  133.     ULONG   myflags;
  134. {
  135.     register struct Image   *ip;
  136.     struct Image        *retip, *temp;
  137.     ULONG            size;
  138.     void            *mymh = NULL;
  139.  
  140. #ifdef GIMME_WIMPY
  141.     if( !mh ) {
  142.     return( NULL );
  143.     }
  144. #endif
  145.     retip = ip = NULL;
  146.     for( ; oldip && numimage != 0; oldip = oldip->NextImage, --numimage ) {
  147.     if( !(temp = chainAllocMem(&mymh, (ULONG)sizeof(struct Image),
  148.                     MEMF_PUBLIC)) ) {
  149.         if( !(myflags & GCP_SALVAGE) ) {
  150.         chainFreeMem( mymh );
  151.         retip = NULL;
  152.         }
  153.         return( retip );
  154.     }
  155.     if( !ip ) {
  156.         retip = temp;
  157.     } else {
  158.         ip->NextImage = temp;
  159.     }
  160.     ip = temp;
  161.     *ip = *oldip;        /* struct copy */
  162.     if( oldip->ImageData && !(myflags & GCP_NOT_BYTES) ) {
  163.         size = GIM_IMAGESIZE(ip->Depth, ip->Width, ip->Height);
  164.         if( !(ip->ImageData = chainAllocMem(&mymh, size, MEMF_PUBLIC)) ) {
  165.         if( !(myflags & GCP_SALVAGE) ) {
  166.             chainFreeMem( mymh );
  167.             return( NULL );
  168.         }
  169.         } else {
  170.         copyImageData( oldip, ip->ImageData );
  171.         }
  172.     }
  173.     } /* for */
  174.     linkChainMem( mh, mymh );
  175.     return( retip );
  176. } /* copyImage */
  177.  
  178.  
  179. struct IntuiText *copyIntuiText( mh, otext, numitext, myflags )
  180.     void    **mh;
  181.     register struct IntuiText    *otext;
  182.     SHORT   numitext;
  183.     ULONG   myflags;
  184. {
  185.     register struct IntuiText    *itext;
  186.     struct IntuiText        *retitext, *temp;
  187.     ULONG            size;
  188.     void            *mymh = NULL;
  189.  
  190. #ifdef GIMME_WIMPY
  191.     if( !mh ) {
  192.     return( NULL );
  193.     }
  194. #endif
  195.     retitext = itext = NULL;
  196.     for( ; otext && numitext != 0; otext = otext->NextText, --numitext ) {
  197.     if( !(temp = chainAllocMem(&mymh, (ULONG)sizeof(struct IntuiText),
  198.                     MEMF_PUBLIC)) ) {
  199.         if( !(myflags & GCP_SALVAGE) ) {
  200.         chainFreeMem( mymh );
  201.         retitext = NULL;
  202.         }
  203.         return( retitext );
  204.     }
  205.     if( !itext ) {
  206.         retitext = temp;
  207.     } else {
  208.         itext->NextText = temp;
  209.     }
  210.     itext = temp;
  211.     *itext = *otext;       /* struct copy */
  212.     if( otext->IText && !(myflags & GCP_NOT_STRING) ) {
  213.         size = strlen( otext->IText );
  214.         if( !(itext->IText = chainAllocMem(&mymh, size, MEMF_PUBLIC)) ) {
  215.         if( !(myflags & GCP_SALVAGE) ) {
  216.             chainFreeMem( mymh );
  217.             return( NULL );
  218.         }
  219.         } else {
  220.         /* strcpy( itext->IText, otext->IText ); */
  221.         movmem( otext->IText, itext->IText, (int) size + 1 );
  222.         }
  223.     }
  224.     if( otext->ITextFont && !(myflags & GCP_NOT_TEXTATTR) ) {
  225.         if( !(itext->ITextFont = chainAllocMem(&mymh,
  226.             (ULONG)sizeof(struct TextAttr), MEMF_PUBLIC)) ) {
  227.         if( !(myflags & GCP_SALVAGE) ) {
  228.             chainFreeMem( mymh );
  229.             return( NULL );
  230.         }
  231.         } else {
  232.         *itext->ITextFont = *otext->ITextFont;        /* struct copy */
  233.         }
  234.     }
  235.     } /* for */
  236.     linkChainMem( mh, mymh );
  237.     return( retitext );
  238. } /* copyIntuiText */
  239.  
  240.  
  241. struct MenuItem *copyMenuItem( mhptr, olditem, numitem, numsub, myflags )
  242.     void            **mhptr;
  243.     register struct MenuItem    *olditem;
  244.     SHORT            numitem, numsub;
  245.     ULONG            myflags;
  246. {
  247.     register struct MenuItem    *item, *temp;
  248.     struct MenuItem        *menuitem = NULL;
  249.     APTR            (*copyfunc)();
  250.     void            *mymh = NULL;
  251.  
  252. #ifdef GIMME_WIMPY
  253.     if( !mhptr ) {
  254.     return( NULL );
  255.     }
  256. #endif
  257.     item = NULL;
  258.     for( ; olditem && numitem != 0; olditem = olditem->NextItem ) {
  259.     if( !(temp = chainAllocMem(&mymh, (ULONG)sizeof(struct MenuItem),
  260.                         MEMF_PUBLIC)) ) {
  261.         chainFreeMem( mymh );
  262.         return( NULL );
  263.     }
  264.     if( !item ) {
  265.         menuitem = temp;
  266.     } else {
  267.         item->NextItem = temp;
  268.     }
  269.     item = temp;
  270.     *item = *olditem;    /* struct copy */
  271.     if( !(myflags & GCP_NOT_STRUCTS) ) {
  272.         if( item->Flags & ITEMTEXT ) {
  273.         (APTR) copyfunc = (APTR) copyIntuiText;
  274.         } else {
  275.         (APTR) copyfunc = (APTR) copyImage;
  276.         }
  277.         if( olditem->ItemFill ) {
  278.         if( !(item->ItemFill = copyfunc(&mymh, olditem->ItemFill,
  279.                         -1, myflags)) ) {
  280.             chainFreeMem( mymh );
  281.             return( NULL );
  282.         }
  283.         }
  284.         if( (item->Flags & HIGHIMAGE) && olditem->SelectFill ) {
  285.         if( !(item->SelectFill = copyfunc(&mymh, olditem->SelectFill,
  286.                         -1, 0L)) ) {
  287.             chainFreeMem( mymh );
  288.             return( NULL );
  289.         }
  290.         }
  291.     }
  292.     if( numsub != 0 && olditem->SubItem ) {
  293.         if( !(item->SubItem = copyMenuItem(&mymh,
  294.                     olditem->SubItem, numsub, 0)) ) {
  295.         chainFreeMem( mymh );
  296.         return( NULL );
  297.         }
  298.     } else {
  299.         item->SubItem = NULL;
  300.     }
  301.     } /* for */
  302.     item->NextItem = NULL;
  303.     if( mymh ) {
  304.     linkChainMem( mhptr, mymh );
  305.     }
  306.     return( menuitem );
  307. } /* copyMenuItem */
  308.  
  309.  
  310. struct Menu *copyMenu( mhptr, oldmenu, nummenu, numitem, numsub, myflags )
  311.     void            **mhptr;
  312.     register struct Menu    *oldmenu;
  313.     SHORT            nummenu, numitem, numsub;
  314.     ULONG            myflags;
  315. {
  316.     register struct Menu    *menu, *temp;
  317.     struct Menu         *menustrip = NULL;
  318.     ULONG            size;
  319.     void            *mymh = NULL;
  320.  
  321. #ifdef GIMME_WIMPY
  322.     if( !mhptr ) {
  323.     return( NULL );
  324.     }
  325. #endif
  326.     menu = NULL;
  327.     for( ; oldmenu && nummenu != 0; oldmenu = oldmenu->NextMenu, --nummenu ) {
  328.     if( !(temp = chainAllocMem(&mymh, (ULONG)sizeof(struct Menu),
  329.                     MEMF_PUBLIC)) ) {
  330.         chainFreeMem( mymh );
  331.         return( NULL );
  332.     }
  333.     if( !menu ) {
  334.         menustrip = temp;
  335.     } else {
  336.         menu->NextMenu = temp;
  337.     }
  338.     menu = temp;
  339.     *menu = *oldmenu;    /* struct copy */
  340.     if( menu->MenuName && !(myflags & GCP_NOT_STRING) ) {
  341.         size = strlen( oldmenu->MenuName );
  342.         if( !(menu->MenuName = chainAllocMem(&mymh, size, MEMF_PUBLIC)) ) {
  343.         if( !(myflags & GCP_SALVAGE) ) {
  344.             chainFreeMem( mymh );
  345.             return( NULL );
  346.         }
  347.         } else {
  348.         /* strcpy( menu->MenuName, oldmenu->MenuName ); */
  349.         movmem( oldmenu->MenuName, menu->MenuName, (int) size + 1 );
  350.         }
  351.     }
  352.     if( numitem != 0 && oldmenu->FirstItem ) {
  353.         if( !(menu->FirstItem = copyMenuItem(&mymh,
  354.                 oldmenu->FirstItem, numitem, numsub, myflags)) ) {
  355.         chainFreeMem( mymh );
  356.         return( NULL );
  357.         }
  358.     } else {
  359.         menu->FirstItem = NULL;
  360.     }
  361.     } /* for */
  362.     menu->NextMenu = NULL;
  363.     if( mymh ) {
  364.     linkChainMem( mhptr, mymh );
  365.     }
  366.     return( menustrip );
  367. } /* copyMenu */
  368.