home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 1 / LSD Compendium Deluxe 1.iso / a / text / manipulation / snap164.lha / clip.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-30  |  4.5 KB  |  169 lines
  1. /* This is just plain clipboard handling */
  2.  
  3. #if __SASC
  4. #include "snap.h"
  5. #endif
  6.  
  7. #include <setjmp.h>
  8.  
  9. #define ID(a,b,c,d) ((a << 24L) | (b << 16L) | (c << 8L) | (d))
  10.  
  11. #define ID_CAT  ID('C','A','T',' ')
  12. #define ID_FORM ID('F','O','R','M')
  13. #define ID_FTXT ID('F','T','X','T')
  14. #define ID_CHRS ID('C','H','R','S')
  15.  
  16. #define SAFE(cond, jmp_buf)  { if (!(cond)) longjmp(jmp_buf,-1); }
  17.  
  18. IMPORT struct IOClipReq *ClipReq;
  19.  
  20. VOID CBFInit(struct CBFHandle *CBFH)
  21. {
  22.     if (CBFH->Type == CBFCLIP) {
  23.         CBFH->Handle.ClipReq->io_Error = 0;
  24.         CBFH->Handle.ClipReq->io_Offset = 0L;
  25.         CBFH->Handle.ClipReq->io_ClipID = 0L;
  26.     }
  27. }
  28.  
  29. VOID CBFEndWrite(struct CBFHandle *CBFH)
  30. {
  31.     if (CBFH->Type == CBFCLIP) {
  32.         CBFH->Handle.ClipReq->io_Command = CMD_UPDATE;
  33.         DoIO((struct IORequest *)CBFH->Handle.ClipReq);
  34.     }
  35. }
  36.  
  37. VOID CBFEndRead(struct CBFHandle *CBFH)
  38. {
  39.     if (CBFH->Type == CBFCLIP) {
  40.         CBFH->Handle.ClipReq->io_Command = CMD_READ;
  41.         CBFH->Handle.ClipReq->io_Offset = 2000000000;
  42.         CBFH->Handle.ClipReq->io_Length = 1;
  43.         CBFH->Handle.ClipReq->io_Data = (STRPTR) 0;
  44.         DoIO((struct IORequest *)CBFH->Handle.ClipReq);
  45.     }
  46. }
  47.  
  48. ULONG CBFSeek(struct CBFHandle *CBFH, LONG Offset, LONG Origin)
  49. {
  50.     if (CBFH->Type == CBFCLIP) {
  51.         switch (Origin) {
  52.             case OFFSET_CURRENT: {
  53.                 CBFH->Handle.ClipReq->io_Offset += Offset;
  54.                 return CBFH->Handle.ClipReq->io_Offset;
  55.             }
  56.             case OFFSET_BEGINNING: {
  57.                 CBFH->Handle.ClipReq->io_Offset = Offset;
  58.                 return CBFH->Handle.ClipReq->io_Offset;
  59.             }
  60.             default: {
  61.                 return 2000000000;
  62.             }
  63.         }
  64.     } else {
  65.         return (ULONG)Seek(CBFH->Handle.File, Offset, Origin);
  66.     }
  67.     return 0;
  68. }
  69.  
  70. LONG CBFWrite(struct CBFHandle *CBFH, STRPTR Buf, ULONG BufSize)
  71. {
  72.     if (CBFH->Type == CBFCLIP) {
  73.         CBFH->Handle.ClipReq->io_Command = CMD_WRITE;
  74.         CBFH->Handle.ClipReq->io_Data = Buf;
  75.         CBFH->Handle.ClipReq->io_Length = BufSize;
  76.         DoIO((struct IORequest *)CBFH->Handle.ClipReq);
  77.         return (CBFH->Handle.ClipReq->io_Error ? -1 : 0);
  78.     } else {
  79.         return Write(CBFH->Handle.File, (char *)Buf, BufSize);
  80.     }
  81. }
  82.  
  83. LONG CBFRead(struct CBFHandle *CBFH, STRPTR Buf, ULONG BufSize)
  84. {
  85.     if (CBFH->Type == CBFCLIP) {
  86.         CBFH->Handle.ClipReq->io_Command = CMD_READ;
  87.         CBFH->Handle.ClipReq->io_Data = Buf;
  88.         CBFH->Handle.ClipReq->io_Length = BufSize;
  89.         DoIO((struct IORequest *)CBFH->Handle.ClipReq);
  90.         return (CBFH->Handle.ClipReq->io_Error ? -1 : 0);
  91.     } else {
  92.         return Read(CBFH->Handle.File, (char *)Buf, BufSize);
  93.     }
  94. }
  95.  
  96. jmp_buf failure;
  97.  
  98. VOID SaveClip(UBYTE *SnapSpace, ULONG SnapSize)
  99. {
  100.     ULONG Len;
  101.     struct CBFHandle CBFH;
  102.  
  103.     CBFH.Type = CBFCLIP;
  104.     CBFH.Handle.ClipReq = ClipReq;
  105.  
  106.     CBFInit(&CBFH);
  107.     CBFWrite(&CBFH, (STRPTR)"FORM", 4L);
  108.     Len = (SnapSize + 13) & ~1;
  109.     CBFWrite(&CBFH, (STRPTR)&Len, 4L);
  110.     CBFWrite(&CBFH, (STRPTR)"FTXT", 4L);
  111.     CBFWrite(&CBFH, (STRPTR)"CHRS", 4L);
  112.     Len = SnapSize;
  113.     CBFWrite(&CBFH, (STRPTR)&Len, 4L);
  114.     CBFWrite(&CBFH, SnapSpace, Len);
  115.     if (SnapSize & 1) {
  116.        CBFWrite(&CBFH, (STRPTR)"\0", 1L);
  117.     }
  118.     CBFEndWrite(&CBFH);
  119. }
  120.  
  121. struct Snap *FetchClip()
  122. {
  123.     struct Snap *Snap = NULL;
  124.     ULONG ID[3];
  125.     struct CBFHandle CBFH;
  126.     WORD done = 0;
  127.  
  128.     CBFH.Type = CBFCLIP;
  129.     CBFH.Handle.ClipReq = ClipReq;
  130.  
  131.     if (setjmp(failure)) {
  132.         if (Snap) {
  133.             FreeMem(Snap, Snap->Size);
  134.         }
  135.         CBFEndRead(&CBFH);
  136.         return NULL;
  137.     }
  138.  
  139.     CBFInit(&CBFH);
  140.     SAFE(CBFRead(&CBFH, (STRPTR)&ID[0], 12) != -1L, failure);
  141.     if (ID[0] != ID_CAT) {
  142.         CBFSeek(&CBFH, -12, OFFSET_CURRENT);
  143.     }
  144.     while (!done) {
  145.         SAFE(CBFRead(&CBFH, (STRPTR)&ID[0], 12) != -1L, failure);
  146.         switch (ID[2]) {
  147.             case ID_FTXT: {
  148.                 SAFE(CBFRead(&CBFH, (STRPTR)&ID[0], 8) != -1L, failure);
  149.                 SAFE(ID[0] == ID_CHRS, failure);
  150.                 Snap = AllocMem(sizeof(struct Snap) + ID[1],
  151.                                 MEMF_PUBLIC | MEMF_CLEAR);
  152.                 SAFE(Snap, failure);
  153.                 Snap->Size = sizeof(struct Snap) + ID[1];
  154.                 SAFE(CBFRead(&CBFH, (STRPTR)&Snap->Chars[0], Snap->Size) != -1L,
  155.                      failure);
  156.                 done = 1;
  157.                 break;
  158.             }
  159.             default: {
  160.                 SAFE(CBFSeek(&CBFH, ID[1] + (ID[1] & 1) - 4, OFFSET_CURRENT),
  161.                      failure);
  162.                 break;
  163.             }
  164.         }
  165.     }
  166.     CBFEndRead(&CBFH);
  167.     return(Snap);
  168. }
  169.