home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / Capture.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  9.4 KB  |  534 lines
  1. /*
  2. **    Capture.c
  3. **
  4. **    File and printer capture support routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14. STATIC VOID
  15. CaptureCallback1(register APTR Buffer,register LONG Size)
  16. {
  17.     AddLine(Buffer,Size);
  18.  
  19.     CaptureToFile(Buffer,Size);
  20.     CaptureToFile("\n",1);
  21. }
  22.  
  23. STATIC VOID
  24. CaptureCallback3(register APTR Buffer,register LONG Size)
  25. {
  26.     AddLine(Buffer,Size);
  27.  
  28.     CaptureToFile(Buffer,Size);
  29.     CaptureToFile("\n",1);
  30.  
  31.     CaptureToPrinter(Buffer,Size);
  32.     CaptureToPrinter("\n",1);
  33. }
  34.  
  35. STATIC VOID
  36. CaptureCallback4(register APTR Buffer,register LONG Size)
  37. {
  38.     CaptureToFile(Buffer,Size);
  39.     CaptureToFile("\n",1);
  40. }
  41.  
  42. STATIC VOID
  43. CaptureCallback5(register APTR Buffer,register LONG Size)
  44. {
  45.     CaptureToFile(Buffer,Size);
  46.     CaptureToFile("\n",1);
  47.  
  48.     CaptureToPrinter(Buffer,Size);
  49.     CaptureToPrinter("\n",1);
  50. }
  51.  
  52. STATIC VOID
  53. CaptureCallback6(register APTR Buffer,register LONG Size)
  54. {
  55.     CaptureToPrinter(Buffer,Size);
  56.     CaptureToPrinter("\n",1);
  57. }
  58.  
  59. STATIC VOID
  60. CaptureCallback7(register APTR Buffer,register LONG Size)
  61. {
  62.     AddLine(Buffer,Size);
  63.  
  64.     CaptureToPrinter(Buffer,Size);
  65.     CaptureToPrinter("\n",1);
  66. }
  67.  
  68. VOID
  69. CaptureFilteredTo_Buffer(register APTR Buffer,register LONG Size)
  70. {
  71.     CaptureParser(ParserStuff,Buffer,Size,AddLine);
  72. }
  73.  
  74. VOID
  75. CaptureFilteredTo_Buffer_File(register APTR Buffer,register LONG Size)
  76. {
  77.     CaptureParser(ParserStuff,Buffer,Size,CaptureCallback1);
  78. }
  79.  
  80. VOID
  81. CaptureFilteredTo_Buffer_File_Printer(register APTR Buffer,register LONG Size)
  82. {
  83.     CaptureParser(ParserStuff,Buffer,Size,CaptureCallback3);
  84. }
  85.  
  86. VOID
  87. CaptureFilteredTo_File(register APTR Buffer,register LONG Size)
  88. {
  89.     CaptureParser(ParserStuff,Buffer,Size,CaptureCallback4);
  90. }
  91.  
  92. VOID
  93. CaptureFilteredTo_File_Printer(register APTR Buffer,register LONG Size)
  94. {
  95.     CaptureParser(ParserStuff,Buffer,Size,CaptureCallback5);
  96. }
  97.  
  98. VOID
  99. CaptureFilteredTo_Printer(register APTR Buffer,register LONG Size)
  100. {
  101.     CaptureParser(ParserStuff,Buffer,Size,CaptureCallback6);
  102. }
  103.  
  104. VOID
  105. CaptureFilteredTo_Buffer_Printer(register APTR Buffer,register LONG Size)
  106. {
  107.     CaptureParser(ParserStuff,Buffer,Size,CaptureCallback7);
  108. }
  109.  
  110. VOID
  111. CaptureRawTo_Buffer(register APTR Buffer,register LONG Size)
  112. {
  113.     CaptureParser(ParserStuff,Buffer,Size,AddLine);
  114. }
  115.  
  116. VOID
  117. CaptureRawTo_Buffer_File(register APTR Buffer,register LONG Size)
  118. {
  119.     CaptureParser(ParserStuff,Buffer,Size,AddLine);
  120.  
  121.     CaptureToFile(Buffer,Size);
  122. }
  123.  
  124. VOID
  125. CaptureRawTo_Buffer_File_Printer(register APTR Buffer,register LONG Size)
  126. {
  127.     CaptureParser(ParserStuff,Buffer,Size,AddLine);
  128.  
  129.     CaptureToFile(Buffer,Size);
  130.     CaptureToPrinter(Buffer,Size);
  131. }
  132.  
  133. VOID
  134. CaptureRawTo_Buffer_Printer(register APTR Buffer,register LONG Size)
  135. {
  136.     CaptureParser(ParserStuff,Buffer,Size,AddLine);
  137.  
  138.     CaptureToPrinter(Buffer,Size);
  139. }
  140.  
  141. VOID
  142. CaptureRawTo_File(register APTR Buffer,register LONG Size)
  143. {
  144.     CaptureToFile(Buffer,Size);
  145. }
  146.  
  147. VOID
  148. CaptureRawTo_File_Printer(register APTR Buffer,register LONG Size)
  149. {
  150.     CaptureToFile(Buffer,Size);
  151.     CaptureToPrinter(Buffer,Size);
  152. }
  153.  
  154. VOID
  155. CaptureRawTo_Printer(register APTR Buffer,register LONG Size)
  156. {
  157.     CaptureToPrinter(Buffer,Size);
  158. }
  159.  
  160.     /* ClosePrinterCapture(BOOL Force):
  161.      *
  162.      *    Closes printer capture file.
  163.      */
  164.  
  165. VOID
  166. ClosePrinterCapture(BOOL Force)
  167. {
  168.     if(PrinterCapture)
  169.     {
  170.         if(ControllerActive && StandardPrinterCapture && !Force)
  171.             FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_ENDING_TXT));
  172.  
  173.         if(Force)
  174.         {
  175.             Close(PrinterCapture);
  176.  
  177.             CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  178.  
  179.             PrinterCapture = NULL;
  180.  
  181.             ConOutputUpdate();
  182.  
  183.             StandardPrinterCapture = FALSE;
  184.         }
  185.     }
  186.  
  187.     ControllerActive = FALSE;
  188.  
  189.     ConOutputUpdate();
  190. }
  191.  
  192.     /* OpenPrinterCapture(BOOL Controller):
  193.      *
  194.      *    Opens printer capture file.
  195.      */
  196.  
  197. BOOL
  198. OpenPrinterCapture(BOOL Controller)
  199. {
  200.     if(PrinterCapture)
  201.     {
  202.         if(Controller && !ControllerActive)
  203.         {
  204.             ControllerActive = TRUE;
  205.  
  206.             ConOutputUpdate();
  207.  
  208.             FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
  209.         }
  210.  
  211.         return(TRUE);
  212.     }
  213.     else
  214.     {
  215.         if(PrinterCapture = Open("PRT:",MODE_NEWFILE))
  216.             CheckItem(MEN_CAPTURE_TO_PRINTER,TRUE);
  217.         else
  218.         {
  219.             CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  220.  
  221.             BlockWindows();
  222.  
  223.             ShowRequest(Window,LocaleString(MSG_TERMMAIN_ERROR_OPENING_PRINTER_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),"PRT:");
  224.  
  225.             ReleaseWindows();
  226.         }
  227.  
  228.         if(Controller)
  229.         {
  230.             ControllerActive    = TRUE;
  231.             StandardPrinterCapture    = FALSE;
  232.         }
  233.         else
  234.         {
  235.             StandardPrinterCapture = FALSE;
  236.  
  237.             if(ControllerActive)
  238.                 FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_USER_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
  239.         }
  240.  
  241.         ConOutputUpdate();
  242.  
  243.         if(PrinterCapture)
  244.             return(TRUE);
  245.         else
  246.             return(FALSE);
  247.     }
  248. }
  249.  
  250.     /* CloseFileCapture():
  251.      *
  252.      *    Close the capture file.
  253.      */
  254.  
  255. VOID
  256. CloseFileCapture()
  257. {
  258.     if(FileCapture)
  259.     {
  260.         BufferClose(FileCapture);
  261.  
  262.         FileCapture = NULL;
  263.  
  264.         if(!GetFileSize(CaptureName))
  265.             DeleteFile(CaptureName);
  266.         else
  267.         {
  268.             AddProtection(CaptureName,FIBF_EXECUTE);
  269.  
  270.             if(Config -> MiscConfig -> CreateIcons)
  271.                 AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
  272.         }
  273.     }
  274.  
  275.     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  276.     CheckItem(MEN_CAPTURE_TO_RAW_FILE,FALSE);
  277.  
  278.     RawCapture = FALSE;
  279.  
  280.     ConOutputUpdate();
  281. }
  282.  
  283.     /* OpenFileCapture():
  284.      *
  285.      *    Open a capture file.
  286.      */
  287.  
  288. BOOL
  289. OpenFileCapture(BOOL Raw)
  290. {
  291.     struct FileRequester    *FileRequest;
  292.     UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  293.                 *DummyChar;
  294.     BOOL             Aborted = FALSE;
  295.  
  296.     CloseFileCapture();
  297.  
  298.     BlockWindows();
  299.  
  300.     if(!CaptureName[0])
  301.     {
  302.         strcpy(CaptureName,Config -> CaptureConfig -> CapturePath);
  303.  
  304.         if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),MAX_FILENAME_LENGTH))
  305.             CaptureName[0] = 0;
  306.     }
  307.  
  308.     strcpy(DummyBuffer,CaptureName);
  309.  
  310.     DummyChar = PathPart(DummyBuffer);
  311.  
  312.     *DummyChar = 0;
  313.  
  314.     if(FileRequest = GetFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),DummyBuffer,FilePart(CaptureName),DummyBuffer,NULL,TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_OPEN_TXT),FALSE))
  315.     {
  316.         if(GetFileSize(DummyBuffer))
  317.         {
  318.             switch(ShowRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
  319.             {
  320.                 case 1:
  321.  
  322.                     FileCapture = BufferOpen(DummyBuffer,"w");
  323.                     break;
  324.  
  325.                 case 2:
  326.  
  327.                     FileCapture = BufferOpen(DummyBuffer,"a");
  328.                     break;
  329.  
  330.                 case 0:
  331.  
  332.                     FileCapture = NULL;
  333.  
  334.                     Aborted = TRUE;
  335.  
  336.                     break;
  337.             }
  338.         }
  339.         else
  340.             FileCapture = BufferOpen(DummyBuffer,"w");
  341.  
  342.         if(!Aborted)
  343.         {
  344.             if(!FileCapture)
  345.                 ShowError(Window,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  346.             else
  347.                 strcpy(CaptureName,DummyBuffer);
  348.         }
  349.  
  350.         FreeAslRequest(FileRequest);
  351.     }
  352.  
  353.     if(Raw)
  354.     {
  355.         if(FileCapture)
  356.             CheckItem(MEN_CAPTURE_TO_RAW_FILE,TRUE);
  357.         else
  358.             CheckItem(MEN_CAPTURE_TO_RAW_FILE,FALSE);
  359.  
  360.         RawCapture = TRUE;
  361.     }
  362.     else
  363.     {
  364.         if(FileCapture)
  365.             CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
  366.         else
  367.             CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  368.  
  369.         RawCapture = FALSE;
  370.     }
  371.  
  372.     ConOutputUpdate();
  373.  
  374.     ReleaseWindows();
  375.  
  376.     if(FileCapture)
  377.         return(TRUE);
  378.     else
  379.         return(FALSE);
  380. }
  381.  
  382.     /* CaptureToFile(APTR Buffer,LONG Size):
  383.      *
  384.      *    Send data to the capture file.
  385.      */
  386.  
  387. VOID
  388. CaptureToFile(APTR Buffer,LONG Size)
  389. {
  390.     if(Size)
  391.     {
  392.         if(BufferWrite(FileCapture,Buffer,Size) != Size)
  393.         {
  394.             BlockWindows();
  395.  
  396.                 /* We had an error writing to the file. */
  397.  
  398.             switch(ShowRequest(NULL,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_CAPTURE_FILE_TXT),LocaleString(MSG_CONSOLE_IGNORE_DISCARD_CLOSE_TXT),CaptureName))
  399.             {
  400.                 case 1:
  401.  
  402.                     BufferClose(FileCapture);
  403.  
  404.                     DeleteFile(CaptureName);
  405.  
  406.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  407.  
  408.                     FileCapture = NULL;
  409.  
  410.                     ConOutputUpdate();
  411.  
  412.                     break;
  413.  
  414.                 case 2:
  415.  
  416.                     BufferClose(FileCapture);
  417.  
  418.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  419.  
  420.                     FileCapture = NULL;
  421.  
  422.                     if(!GetFileSize(CaptureName))
  423.                         DeleteFile(CaptureName);
  424.                     else
  425.                     {
  426.                         AddProtection(CaptureName,FIBF_EXECUTE);
  427.  
  428.                         if(Config -> MiscConfig -> CreateIcons)
  429.                             AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
  430.                     }
  431.  
  432.                     ConOutputUpdate();
  433.  
  434.                     break;
  435.             }
  436.  
  437.             ReleaseWindows();
  438.         }
  439.     }
  440. }
  441.  
  442.     /* CaptureToPrinter(APTR Buffer,LONG Size):
  443.      *
  444.      *    Send capture data to the printer, convert the
  445.      *    characters as necessary to avoid shocking the
  446.      *    printer.
  447.      */
  448.  
  449. VOID
  450. CaptureToPrinter(APTR Buffer,LONG Size)
  451. {
  452.     if(!Config -> CaptureConfig -> ConvertChars && Config -> TerminalConfig -> FontMode != FONT_STANDARD)
  453.     {
  454.         UBYTE     LocalBuffer[BUFFER_LINE_MAX];
  455.  
  456.         UBYTE    *Src = Buffer,
  457.             *Dst,
  458.              c;
  459.  
  460.         ULONG     Count;
  461.  
  462.         while(Size > 0)
  463.         {
  464.             Count = MIN(Size,BUFFER_LINE_MAX);
  465.  
  466.             Size -= Count;
  467.  
  468.             Dst = LocalBuffer;
  469.  
  470.             do
  471.             {
  472.                 if(c = ISOConversion[*Src++])
  473.                     *Dst++ = c;
  474.                 else
  475.                     *Dst++ = ' ';
  476.             }
  477.             while(--Count > 0);
  478.  
  479.             Count = (ULONG)Dst - (ULONG)&LocalBuffer[0];
  480.  
  481.             while(Count > 0 && LocalBuffer[Count - 1] == ' ')
  482.                 Count--;
  483.  
  484.             if(Count > 0)
  485.             {
  486.                 if(Write(PrinterCapture,LocalBuffer,Count) != Count)
  487.                 {
  488.                     BlockWindows();
  489.  
  490.                     if(!ShowRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  491.                     {
  492.                         Close(PrinterCapture);
  493.  
  494.                         CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  495.  
  496.                         PrinterCapture = NULL;
  497.  
  498.                         ConOutputUpdate();
  499.  
  500.                         Size = 0;
  501.                     }
  502.  
  503.                     ReleaseWindows();
  504.                 }
  505.             }
  506.         }
  507.     }
  508.     else
  509.     {
  510.         if(Size > 0)
  511.         {
  512.                 /* Send the buffer to the printer. */
  513.  
  514.             if(Write(PrinterCapture,Buffer,Size) != Size)
  515.             {
  516.                 BlockWindows();
  517.  
  518.                 if(!ShowRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  519.                 {
  520.                     Close(PrinterCapture);
  521.  
  522.                     CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  523.  
  524.                     PrinterCapture = NULL;
  525.  
  526.                     ConOutputUpdate();
  527.                 }
  528.  
  529.                 ReleaseWindows();
  530.             }
  531.         }
  532.     }
  533. }
  534.