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