Amiga Developer CD v1.2/amidev_cd_12.iso/reference/amiga_mail_vol1/printer/printer.c

C/C++ Source or Header | 1990-01-26 | 6KB | 240 lines

(c)  Copyright 1989 Commodore-Amiga, Inc.   All rights reserved.
The information contained herein is subject to change without notice, and
is provided "as is" without warranty of any kind, either expressed or implied.
The entire risk as to the use of this information is assumed by the user.



                   Printer.c - A Printer Text
                     and Graphics Module

                      by Carolyn Scheppner


     One strong feature of the Amiga system software is the built-in support
for a wide variety of printers.  By supporting printers at the system level,
print functions can be device-independent.  This allows the application
developer to concentrate on the code instead of worrying about the many
printer prototcol details which differ from one printer to another.  The
printer.c program listed below is a C source module which lets you easily
add printer text and graphic capability to your C programs.

The program provides you with 6 functions:  openPrinter(), pString(), pText(),
dumpScreen(), dumpRpVp() and closePrinter().  When using this module or any
other printer code, always remember to close the printer when you are not
actively using it.  This will allow other tasks which may be running to
access the printer.

Here is a summary of the printer.c functions:


   o  openPrinter() -  Allocates and initializes iodrp, and opens the
                       printer.device.

                       Usage: iodrp = (struct IODRPReq *)openPrinter();

   o  closePrinter() - Closes the printer.device and deallocates the
                       iodrp.

                       Usage: closePrinter(iodrp);


The following functions all require an open iodrp.  Note that the text
functions reference the larger iodrp as a simple IOStdRequest.


   o  pString()      - Prints a null terminated text string.

                       Usage: error = pString(ioreq,string);


   o  pText()        - Prints an arbitrary string of a specified
                       length.

                       Usage: error = pText(ioreq,string,length);


   o  dumpScreen()   - Does a raster dump of the entire screen to the
                       printer.

                       Usage: error = dumpScreen(iodrp,screen);


   o  dumpRpVp()     - Does a raster dump of the specified portion of
                       any rastport to the printer.

                       Usage: error = dumpRpVp(iodrp,rp,vp,x,y,w,h);

The printer.c code takes care of setting up the appropriate IO blocks and
reply port and opens and closes the device for you.  Simply call
openPrinter().  If a valid (non-zero) iodrp is returned, you may use it
in calls to any of the printer.c output routines.  When you are finished,
pass the iodrp to the closePrinter() routine to free up the printer for other
tasks.

/*
 * printer.c - routines to print text or dump rastport
 *             C. Scheppner
 */


#include "exec/types.h"
#include "intuition/intuition.h"
#include "devices/printer.h"

extern struct IODRPReq  *openPrinter();
extern struct IODRPReq  *CreateExtIO();
extern struct MsgPort   *CreatePort();


/* pString() - Prints null terminated string
 *             You supply ioreq from openPrinter, and ptr to string
 *             Returns 0 or error
 */
pString(ioreq,s)
struct IOStdReq *ioreq;
UBYTE *s;
   {
   return(pText(ioreq,s,strlen(s)));
   }



/* pText() - Prints non-null-terminated text
 *           You supply ioreq from openPrinter, ptr to text, text length
 *           Returns 0 or error
 */
pText(ioreq,s,l)
struct IOStdReq *ioreq;
UBYTE *s;
ULONG l;
   {
   int error = 1;
   if(ioreq)
      {
      ioreq->io_Data = (APTR)s;
      ioreq->io_Length = l;
      ioreq->io_Command = CMD_WRITE;
      error = DoIO(ioreq);
      }
   return(error);
   }













/* dumpScreen() - Dumps whole screen
 *                You supply open iodrp and pointer to Screen
 *                Returns 0 or error
 */
dumpScreen(iodrp,sc)
struct IODRPReq *iodrp;
struct Screen *sc;
   {
   return(dumpRpVp(iodrp,&sc->RastPort,&sc->ViewPort,0,0,sc->Width,sc->Height));
   }





/* dumpRpVp() - Dumps specified portion of supplied rastport
 *              You supply open iodrp, ptrs to RastPort and ViewPort,
 *              upper left source x,y, and pixel w,h of source
 *              Returns 0 or error
 */
dumpRpVp(iodrp,rp,vp,x,y,w,h)
struct IODRPReq *iodrp;
struct RastPort *rp;
struct ViewPort *vp;
ULONG  x, y, h, w;
   {
   int error = -1;

   if(iodrp)
      {
      iodrp->io_Command = PRD_DUMPRPORT;
      iodrp->io_RastPort = rp;
      iodrp->io_ColorMap = vp->ColorMap;
      iodrp->io_Modes = (ULONG)vp->Modes;
      iodrp->io_SrcX = x;
      iodrp->io_SrcY = y;
      iodrp->io_SrcWidth = w;
      iodrp->io_SrcHeight = h;
      /* iodrp->io_DestCols = 0; MEMF_CLEAR zeroed this  */
      /* iodrp->io_DestRows = 0; MEMF_CLEAR zeroed this  */
      iodrp->io_Special = SPECIAL_FULLCOLS|SPECIAL_ASPECT;

      error = DoIO(iodrp);
      }
   return(error);
   }













/* openPrinter() - Returns largest printer IORequest (iodrp) or 0=failure
 *                 Cast return as IOStdReq for plain text printing
 */
struct IODRPReq *
openPrinter()
   {
   struct IODRPReq *iodrp;    /* Largest printer request */
   struct MsgPort  *printerPort;
   int error = 1;

   if(printerPort = CreatePort("CBM_prtport",0))
      {
      if(iodrp=CreateExtIO(printerPort,sizeof(struct IODRPReq)))
         {
         if(!(error=OpenDevice("printer.device",0,iodrp,0)))
            {
            return(iodrp);
            }
         DeleteExtIO(iodrp);
         }
      DeletePort(printerPort);
      }
   return((struct IODRPReq *)NULL);  /* failure */
   }




closePrinter(iodrp)
struct IODRPReq *iodrp;
   {
   struct MsgPort *msgport;

   if(iodrp)
      {
      CloseDevice(iodrp);
      msgport = iodrp->io_Message.mn_ReplyPort;
      DeleteExtIO(iodrp);
      DeletePort(msgport);
      }
   }