home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 200-299 / ff282.lzh / PrintHandler / Print-Handler.c < prev    next >
C/C++ Source or Header  |  1989-11-21  |  15KB  |  656 lines
  1. /*    Print-Handler.c v1.1, 30 September 1989
  2.  *
  3.  *    This  printer  device handler implements the single sheet support
  4.  *    and data-spooling facility the usual PRT:  device does not have.
  5.  *
  6.  *    Each time a page has been successfully transferred to the printer
  7.  *    and  single paper sheets are selected in Preferences, a requestor
  8.  *    pops  up  on  the Workbench screen telling the user to insert the
  9.  *    next  sheet  of  paper.   If a process addresses this handler via
  10.  *    Open()  and  Write()s  data  to it, the incoming text is buffered
  11.  *    until the data stream is Close()d.  After that the buffer sent to
  12.  *    the  printer  device and finally gets discarded.  Note that there
  13.  *    will  be  a buffer for each calling process (up to twenty callers
  14.  *    are  allowed),  so  you may get low on memory.  This handler will
  15.  *    notice low memory situations and return a write error in critical
  16.  *    situations.   This handler does no first-in-first-out or last-in-
  17.  *    first-out data stack handling, the first data to come out is from
  18.  *    the first buffer to be closed
  19.  *
  20.  *    Don't  be  confused if the requestor pops up while the printer is
  21.  *    still  working.  Since most printers have a write buffer of their
  22.  *    own true synchronous printer I/O is almost impossible.
  23.  *
  24.  *    Installation is as follows:
  25.  *
  26.  *    * Add the following lines to your DEVS:Mountlist
  27.  *
  28.  *      PRT:    Handler        = L:Print-Handler
  29.  *          Stacksize    = 3000
  30.  *          Priority    = 5
  31.  *          GlobVec        = 1
  32.  *      #
  33.  *
  34.  *    * Add the following lines to your S:Startup-Sequence
  35.  *
  36.  *      Assign PRT: Remove
  37.  *      Mount PRT:
  38.  *
  39.  *    * Copy Print-Handler to your L:
  40.  *
  41.  *    Skeleton handler code by Phillip Lindsay (C) 1986 Commodore
  42.  *    You may freely distribute this source and use it for Amiga Development,
  43.  *    as long as the Copyright notice is left intact.
  44.  *
  45.  *    Print-Handler (C) Copyright 1989 by Olaf Barthel & ED Hannover
  46.  *
  47.  *    Contact:    Olaf Barthel, Electronic Design Hannover
  48.  *            Brabeckstrasse 35
  49.  *            D-3000 Hannover 71
  50.  *
  51.  *            Federal Republic of Germany
  52.  */
  53.  
  54. #include <intuition/intuitionbase.h>
  55. #include <libraries/filehandler.h>
  56. #include <libraries/dosextens.h>
  57. #include <devices/prtbase.h>
  58. #include <devices/printer.h>
  59. #include <exec/memory.h>
  60.  
  61.     /* This version of BADDR() has no problems with castings. */
  62.  
  63. #undef  BADDR
  64. #define BADDR(x) ((APTR)((long)x << 2))
  65.  
  66.     /* Define the packet types which are not available
  67.      * in the dos 1.1/1.2 include files.
  68.      */
  69.  
  70. #define ACTION_FIND_INPUT    1005
  71. #define ACTION_FIND_OUTPUT    1006
  72. #define ACTION_END        1007
  73.  
  74.     /* Some BCPL boolean definitions. */
  75.  
  76. #define DOS_FALSE     0
  77. #define DOS_TRUE    -1
  78.  
  79.     /* Forward declarations. */
  80.  
  81. extern struct Library        *OpenLibrary();
  82. extern struct Process        *FindTask();
  83. extern struct MsgPort        *CreatePort();
  84. extern struct MsgPort        *FindPort();
  85. extern struct Message        *GetMsg();
  86. extern struct IOStdReq        *CreateStdIO();
  87. extern void            *AllocMem();
  88.  
  89.     /* This is a data segment, a part of a larger printer
  90.      * buffer used for data-spooling.
  91.      */
  92.  
  93. struct DataSeg
  94. {
  95.     struct DataSeg    *NextSeg;    /* Next segment. */
  96.  
  97.     APTR        Buffer;        /* Data array. */
  98.     long        Length;        /* Length of array. */
  99. };
  100.  
  101.     /* Some global data. */
  102.  
  103. struct IntuitionBase    *IntuitionBase;
  104. struct Preferences    *Preferences;
  105. struct DataSeg        *PrintSlot[20];
  106. struct IOStdReq        *PrinterDevice;
  107. struct MsgPort        *PrinterPort;
  108.  
  109.     /* Position counters to take care of the current page length. */
  110.  
  111. long LinesDone = 0;
  112. long ColumnsDone = 0;
  113.  
  114.     /* CreateSeg(Buffer,Length):
  115.      *
  116.      *    Creates a new segment entry for a linked list of
  117.      *    buffers.
  118.      */
  119.  
  120. struct DataSeg *
  121. CreateSeg(Buffer,Length)
  122. register APTR Buffer;
  123. register long Length;
  124. {
  125.     register struct DataSeg *NewSeg;
  126.  
  127.         /* Allocate memory for the list element. */
  128.  
  129.     if(NewSeg = (struct DataSeg *)AllocMem(sizeof(struct DataSeg),MEMF_PUBLIC | MEMF_CLEAR))
  130.     {
  131.             /* Allocate memory for the data buffer. */
  132.  
  133.         if(NewSeg -> Buffer = (APTR)AllocMem(Length,MEMF_PUBLIC | MEMF_CLEAR))
  134.         {
  135.                 /* Copy the data and set the buffer size. */
  136.  
  137.             CopyMem(Buffer,NewSeg -> Buffer,Length);
  138.             NewSeg -> Length = Length;
  139.  
  140.                 /* Return the new segment. */
  141.  
  142.             return(NewSeg);
  143.         }
  144.  
  145.             /* Free the segment data. */
  146.  
  147.         FreeMem(NewSeg,sizeof(struct DataSeg));
  148.     }
  149.  
  150.         /* We failed. */
  151.  
  152.     return(NULL);
  153. }
  154.  
  155.     /* DeleteSeg(OldSeg):
  156.      *
  157.      *    Deletes both the contents and the memory occupied
  158.      *    by a data segment and returns a pointer to the
  159.      *    next segment.
  160.      */
  161.  
  162. struct DataSeg *
  163. DeleteSeg(OldSeg)
  164. register struct DataSeg *OldSeg;
  165. {
  166.     register struct DataSeg *NextSeg = NULL;
  167.  
  168.         /* Valid pointer given? */
  169.  
  170.     if(OldSeg)
  171.     {
  172.             /* Remember this. */
  173.  
  174.         NextSeg = OldSeg -> NextSeg;
  175.  
  176.             /* Free the contents of the buffer. */
  177.  
  178.         if(OldSeg -> Buffer && OldSeg -> Length)
  179.         {
  180.             FreeMem(OldSeg -> Buffer,OldSeg -> Length);
  181.  
  182.                 /* Zero this out. */
  183.  
  184.             OldSeg -> Buffer = NULL;
  185.             OldSeg -> Length = 0;
  186.         }
  187.  
  188.             /* Free the segment data. */
  189.  
  190.         FreeMem(OldSeg,sizeof(struct DataSeg));
  191.     }
  192.  
  193.         /* Return pointer to next segment or null. */
  194.  
  195.     return(NextSeg);
  196. }
  197.  
  198.     /* ReturnPacket(Packet,res1,res2):
  199.      *
  200.      *    This one returns an AmigaDOS packet we have just
  201.      *    received.
  202.      */
  203.  
  204. void
  205. ReturnPacket(Packet,res1,res2)
  206. register struct DosPacket *Packet;
  207. register ULONG res1,res2;
  208. {
  209.     register struct Message    *Message;
  210.     register struct MsgPort    *ReplyPort;
  211.     register struct Process    *ThisProg;
  212.  
  213.     Packet -> dp_Res1        = res1;
  214.     Packet -> dp_Res2        = res2; 
  215.     ReplyPort            = Packet -> dp_Port;
  216.     Message                = Packet -> dp_Link;
  217.     ThisProg            = (struct Process *)FindTask(NULL);
  218.     Packet -> dp_Port        = &ThisProg -> pr_MsgPort;
  219.  
  220.     Message -> mn_Node . ln_Name    = (char *)Packet;
  221.     Message -> mn_Node . ln_Succ    = NULL;
  222.     Message -> mn_Node . ln_Pred    = NULL;
  223.  
  224.     PutMsg(ReplyPort,Message); 
  225. }
  226.  
  227.     /* TaskWait():
  228.      *
  229.      *    This one waits for an AmigaDOS packet to arrive
  230.      *    and returns a pointer to it.
  231.      */
  232.  
  233. struct DosPacket *
  234. TaskWait()
  235. {
  236.     register struct Process    *ThisProg;
  237.     register struct MsgPort    *MyPort;
  238.     register struct Message    *MyMessage;
  239.  
  240.     ThisProg = (struct Process *)FindTask(NULL);
  241.     MyPort = &ThisProg -> pr_MsgPort;
  242.  
  243.     WaitPort(MyPort);
  244.     MyMessage = (struct Message *)GetMsg(MyPort);
  245.  
  246.     return((struct DosPacket *)MyMessage -> mn_Node . ln_Name);
  247. } 
  248.  
  249.     /* PrintIt(Buffer,Length):
  250.      *
  251.      *    This function handles the printing. We could as well
  252.      *    replace the data <-> printer transfer by a short call
  253.      *    to Write(); probably the easiest way to implement
  254.      *    output redirection.
  255.      */
  256.  
  257. long
  258. PrintIt(Buffer,Length)
  259. register APTR Buffer;
  260. register long Length;
  261. {
  262.         /* Are buffer and size both valid? */
  263.  
  264.     if(Buffer && Length)
  265.     {
  266.             /* Send the text to the printer. */
  267.  
  268.         PrinterDevice -> io_Command    = CMD_WRITE;
  269.         PrinterDevice -> io_Data    = Buffer;
  270.         PrinterDevice -> io_Length    = Length;
  271.  
  272.         return(DoIO(PrinterDevice));
  273.     }
  274.  
  275.     return(-1);
  276. }
  277.  
  278.     /* DoRequest():
  279.      *
  280.      *    Displays the requestor asking to insert the next
  281.      *    sheet of paper and returns the result.
  282.      */
  283.  
  284. BOOL
  285. DoRequest()
  286. {
  287.     static struct TextAttr DefaultFont =
  288.     {
  289.         (UBYTE *)"topaz.font",9,FS_NORMAL,FPF_ROMFONT
  290.     };
  291.  
  292.     static struct IntuiText RequestTxt[] =
  293.     {
  294.         {0,1,JAM1,18, 4,(struct TextAttr *)&DefaultFont,(UBYTE *)"Finished with current page,",    &RequestTxt[1]},
  295.         {0,1,JAM1,18,14,(struct TextAttr *)&DefaultFont,(UBYTE *)"please insert next sheet.",    NULL},
  296.         {0,1,JAM1, 5, 3,(struct TextAttr *)&DefaultFont,(UBYTE *)"Ready",            NULL},
  297.         {0,1,JAM1, 5, 3,(struct TextAttr *)&DefaultFont,(UBYTE *)"Abort",            NULL}
  298.     };
  299.  
  300.         /* Open the Workbench first, we don't want to have a dead
  301.          * Workbench screen hanging around if a task preferred to
  302.          * close it.
  303.          */
  304.  
  305.     OpenWorkBench();
  306.  
  307.     return(AutoRequest(NULL,&RequestTxt[0],&RequestTxt[2],&RequestTxt[3],NULL,NULL,326,59));
  308. }
  309.  
  310.     /* PrintData(Buffer,Length):
  311.      *
  312.      *    This is the main interface processing the incoming
  313.      *    data.
  314.      */
  315.  
  316. BOOL
  317. PrintData(Buffer,Length)
  318. register char *Buffer;
  319. register long Length;
  320. {
  321.     register long i,j,InBuff = 0,PaperWidth = Preferences -> PrintRightMargin - Preferences -> PrintLeftMargin;
  322.     char LineStack[1024];
  323.  
  324.         /* Clear out the contents of the line buffer. */
  325.  
  326.     for(i = 0 ; i < 1024 ; i++)
  327.         LineStack[i] = 0;
  328.  
  329.     if(Buffer)
  330.     {
  331.         for(i = 0 ; i < Length ; i++)
  332.         {
  333.                 /* Put the data into the line buffer. */
  334.  
  335.             LineStack[InBuff++] = Buffer[i];
  336.             ColumnsDone++;
  337.  
  338.                 /* Right margin reached/newline encountered? */
  339.  
  340.             if(ColumnsDone == PaperWidth || Buffer[i] == '\n')
  341.             {
  342.                     /* Overriding the paper width
  343.                      * does not necessarily include a
  344.                      * newline.
  345.                      */
  346.  
  347.                 if(ColumnsDone == PaperWidth || ColumnsDone == 1024)
  348.                 {
  349.                     LineStack[InBuff++] = '\n';
  350.                     ColumnsDone++;
  351.                 }
  352.  
  353.                     /* Send the line to the printer. */
  354.  
  355.                 PrintIt(LineStack,InBuff);
  356.  
  357.                     /* Did we reach the bottom line? */
  358.  
  359.                 if((++LinesDone) == Preferences -> PaperLength)
  360.                 {
  361.                     LinesDone = 0;
  362.  
  363.                         /* Inform the user about it. */
  364.  
  365.                     if(Preferences -> PaperType == SINGLE)
  366.                         if(!DoRequest())
  367.                             return(FALSE);
  368.                 }
  369.  
  370.                     /* Clear the rest. */
  371.  
  372.                 ColumnsDone = InBuff = 0;
  373.  
  374.                 for(j = 0 ; j < 1024 ; j++)
  375.                     LineStack[j] = 0;
  376.             }
  377.         }
  378.  
  379.             /* Is there still something in the line buffer? */
  380.  
  381.         if(InBuff)
  382.             PrintIt(LineStack,InBuff);
  383.     }
  384.  
  385.         /* We succeeded and nobody cancelled us. */
  386.  
  387.     return(TRUE);
  388. }
  389.  
  390.     /* _main():
  391.      *
  392.      *    Handler main routine, bypasses all typical Aztec
  393.      *    startup code.
  394.      */
  395.  
  396. _main()
  397. {
  398.     struct Process        *ThisProg = (struct Process *)FindTask(NULL);
  399.     struct DosPacket    *MyPacket;
  400.     struct DeviceNode    *MyNode;    /* Our device node passed in parmpkt Arg3. */
  401.     long            OpenCount = 0;    /* Handler open flag. */
  402.     BOOL            Running = TRUE;    /* Handler main loop flag. */
  403.  
  404.     register long NextSlot = 0;
  405.     register long i;
  406.  
  407.         /* The list of available buffers. */
  408.  
  409.     UBYTE Available[20];
  410.  
  411.         /* Since we were started as a non-BCPL module we get sent the
  412.          * parameter packet (i.e. parameter packet not in D1).
  413.          */
  414.  
  415.     MyPacket = TaskWait();    /* Wait for parameter packet. */
  416.  
  417.         /* Mark all buffers as empty. */
  418.  
  419.     for(i = 0 ; i < 20 ; i++)
  420.     {
  421.         Available[i] = TRUE;
  422.         PrintSlot[i] = NULL;
  423.     }
  424.  
  425.         /* Get a pointer to our device node. */
  426.  
  427.     MyNode = (struct DeviceNode *)BADDR(MyPacket -> dp_Arg3);
  428.  
  429.         /* Do the main handler initialization. */
  430.  
  431.     if(!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",33)))
  432.     {
  433.         ReturnPacket(MyPacket,DOS_FALSE,MyPacket -> dp_Res2);
  434.         goto FallOff;
  435.     }
  436.  
  437.     if(!(PrinterPort = (struct MsgPort *)CreatePort(NULL,0)))
  438.     {
  439.         ReturnPacket(MyPacket,DOS_FALSE,MyPacket -> dp_Res2);
  440.         goto FallOff;
  441.     }
  442.  
  443.     if(!(PrinterDevice = (struct IOStdReq *)CreateStdIO(PrinterPort)))
  444.     {
  445.         ReturnPacket(MyPacket,DOS_FALSE,MyPacket -> dp_Res2);
  446.         goto FallOff;
  447.     }
  448.  
  449.     if(OpenDevice("printer.device",0,PrinterDevice,0))
  450.     {
  451.         ReturnPacket(MyPacket,DOS_FALSE,MyPacket -> dp_Res2);
  452.         goto FallOff;
  453.     }
  454.  
  455.         /* Initialize the Preferences pointer to
  456.          * reflect current printer.device settings.
  457.          */
  458.  
  459.     Preferences = &((struct PrinterData *)PrinterDevice -> io_Device) -> pd_Preferences;
  460.  
  461.         /* If initialization was possible then we install our
  462.          * taskid.   If we don't...for every reference to our
  463.          * handler  a  new  process will be created.  This is
  464.          * fine  for  things like CON:  (console handler) but
  465.          * if  you  plan  to be the only dude on block  (like
  466.          * the file-system handler or SER:)   you should fill
  467.          * the    task    field   with   your   taskid  (i.e.
  468.          * &(pr_MsgPort))    Note:  remember that shared code
  469.          * has  to  be reentrant.  (like CON:  handler), keep
  470.          * your  variables on the stack [autos], and allocate
  471.          * memory  for  larger  data  structures  and  "FLAG"
  472.          * global   data   structures   that   need  only  be
  473.          * intialized once.
  474.          */
  475.  
  476.     MyNode -> dn_Task = &ThisProg -> pr_MsgPort;
  477.  
  478.     ReturnPacket(MyPacket,DOS_TRUE,MyPacket -> dp_Res2);
  479.  
  480.     while(Running)    /* Start of the real work. */
  481.     {
  482.         MyPacket = TaskWait();    /* Wait for a packet. */
  483.  
  484.         switch(MyPacket -> dp_Type)
  485.         {
  486.                 /* Somebody Open()ed us. */
  487.  
  488.             case ACTION_FIND_INPUT:
  489.             case ACTION_FIND_OUTPUT:
  490.             {
  491.                 struct FileHandle *FileHandle = (struct FileHandle *)BADDR(MyPacket -> dp_Arg1);
  492.  
  493.                     /* Assume failure. */
  494.  
  495.                 FileHandle -> fh_Port = DOS_FALSE;
  496.  
  497.                 for(i = 0 ; i < 20 ; i++)
  498.                 {
  499.                         /* Any buffer available? */
  500.  
  501.                     if(Available[i])
  502.                     {
  503.                             /* We didn't fail. */
  504.  
  505.                         FileHandle -> fh_Port = DOS_TRUE;
  506.                         FileHandle -> fh_Arg1 = i;
  507.  
  508.                         Available[i] = FALSE;
  509.  
  510.                             /* Increment usercount. */
  511.  
  512.                         OpenCount++;
  513.  
  514.                         break;
  515.                     }
  516.                 }
  517.  
  518.                     /* Return the compliment. */    
  519.  
  520.                 ReturnPacket(MyPacket,FileHandle -> fh_Port,MyPacket -> dp_Res2);
  521.                 break;
  522.             }
  523.  
  524.                 /* Someone Close()d the file. */
  525.  
  526.             case ACTION_END:
  527.             {
  528.                 long TheSlotIs = MyPacket -> dp_Arg1;
  529.                 BOOL GoOn = TRUE;
  530.  
  531.                     /* We want to fall out of the loop if not OPEN. */
  532.  
  533.                 if((--OpenCount) <= 0)
  534.                     Running = FALSE;
  535.  
  536.                 ReturnPacket(MyPacket,DOS_TRUE,MyPacket -> dp_Res2);
  537.  
  538.                     /* Print the current buffer. */
  539.  
  540.                 while(PrintSlot[TheSlotIs])
  541.                 {
  542.                     if(GoOn)
  543.                         if(!PrintData(PrintSlot[TheSlotIs] -> Buffer,PrintSlot[TheSlotIs] -> Length))
  544.                             GoOn = FALSE;
  545.  
  546.                     PrintSlot[TheSlotIs] = DeleteSeg(PrintSlot[TheSlotIs]);
  547.                 }
  548.  
  549.                 Available[TheSlotIs] = TRUE;
  550.  
  551.                     /* Reset the line counters. */
  552.  
  553.                 LinesDone = ColumnsDone = 0;
  554.  
  555.                 break;
  556.             }
  557.  
  558.                 /* Someone tries to Read() us. */
  559.  
  560.             case ACTION_READ:
  561.             {
  562.                     /* We *always* read nothing. */
  563.  
  564.                 ReturnPacket(MyPacket,NULL,MyPacket -> dp_Res2);
  565.                 break;
  566.             }
  567.  
  568.                 /* Someone tries to Write() to us. */
  569.  
  570.             case ACTION_WRITE:
  571.             {
  572.                 long TheSlotIs = MyPacket -> dp_Arg1;
  573.                 char *Buffer = (char *)MyPacket -> dp_Arg2;
  574.                 struct DataSeg *NextSlot;
  575.  
  576.                 MyPacket -> dp_Res1 = MyPacket -> dp_Arg3;
  577.  
  578.                     /* Buffer not initialized yet? */
  579.  
  580.                 if(!PrintSlot[TheSlotIs])
  581.                 {
  582.                     if(!(PrintSlot[TheSlotIs] = CreateSeg(Buffer,MyPacket -> dp_Res1)))
  583.                         MyPacket -> dp_Res1 = -1;
  584.                 }
  585.                 else
  586.                 {
  587.                         /* Add a new buffer to the current list. */
  588.  
  589.                     NextSlot = PrintSlot[TheSlotIs];
  590.  
  591.                     while(NextSlot -> NextSeg)
  592.                         NextSlot = NextSlot -> NextSeg;
  593.  
  594.                     if(!(NextSlot -> NextSeg = CreateSeg(Buffer,MyPacket -> dp_Res1)))
  595.                         MyPacket -> dp_Res1 = -1;
  596.                 }
  597.  
  598.                     /* We *always* write everything. */
  599.  
  600.                 ReturnPacket(MyPacket,MyPacket -> dp_Arg3,MyPacket -> dp_Res2);
  601.                 break;
  602.             }
  603.  
  604.                 /* Someone wants us the leave the town. */
  605.  
  606.             case ACTION_DIE:
  607.             {
  608.                     /* Empty all buffers. */
  609.  
  610.                 for(i = 0 ; i < 20 ; i++)
  611.                     while(PrintSlot[i])
  612.                         PrintSlot[i] = DeleteSeg(PrintSlot[i]);
  613.  
  614.                     /* Result will be ignored anyway. */
  615.  
  616.                 ReturnPacket(MyPacket,DOS_FALSE,ERROR_ACTION_NOT_KNOWN);
  617.  
  618.                 goto FallOff;
  619.             }
  620.  
  621.                 /* For any other purpose: ignore the message. */
  622.  
  623.             default:
  624.             {
  625.                     /* Say what? */
  626.  
  627.                 ReturnPacket(MyPacket,DOS_FALSE,ERROR_ACTION_NOT_KNOWN);
  628.  
  629.                 break;
  630.             }
  631.         }
  632.     }
  633.  
  634.         /* Fall off the edge of the world. */
  635.  
  636. FallOff:MyNode -> dn_Task = FALSE; /* Zero the TaskID field of device node. */
  637.  
  638.         /* Free all our data. */
  639.  
  640.     if(PrinterDevice)
  641.     {
  642.         if(PrinterDevice -> io_Device)
  643.             CloseDevice(PrinterDevice);
  644.  
  645.         DeleteStdIO(PrinterDevice);
  646.     }
  647.  
  648.     if(PrinterPort)
  649.         DeletePort(PrinterPort);
  650.  
  651.     if(IntuitionBase)
  652.         CloseLibrary(IntuitionBase);
  653.  
  654.         /* This is truly the end. */
  655. }
  656.