home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / util / rsys-1.3.lha / RSys-1.3 / src / RSysPreferenceLists.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-15  |  16.9 KB  |  666 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysPreferenceLists.c
  6. *
  7. * Inhalt:
  8. *    void SysPrefList(void);
  9. *    void SysEnvList(void);
  10. *    void SysExtPrinterData(void);
  11. *
  12. * Bemerkungen:
  13. *    Liste der System- und Druckereinstellungen sowie der Env:-Variablen.
  14. *
  15. * Erstellungsdatum:
  16. *    07-Jul-93    Rolf Böhme
  17. *
  18. * Änderungen:
  19. *    07-Jul-93    Rolf Böhme    Erstellung
  20. *
  21. ***************************************************************************
  22. */
  23.  
  24. #include "RSysDebug.h"
  25. #include "RSysFunc.h"
  26.  
  27.    /*
  28.     * MakeNumEntry() erzeugt ein Zahleneintrag für die
  29.     * anzuzeigende Liste
  30.     */
  31. static void
  32. MakeNumEntry(int *num, char *title, long entry)
  33. {
  34.    sprintf(Entries[*num].se_Entry, "%-22s : %ld", title, entry);
  35.    AddNodeToList(*num, NO_SORT);
  36.  
  37.    (*num)++;
  38.  
  39.    return;
  40. }
  41.  
  42.    /*
  43.     * MakeStringEntry() erzeugt ein Zeileneintrag für die
  44.     * anzuzeigende Liste
  45.     */
  46. static void
  47. MakeStringEntry(int *num, char *title, char *entry)
  48. {
  49.    sprintf(Entries[*num].se_Entry, "%-22s : %s", title, entry);
  50.    AddNodeToList(*num, NO_SORT);
  51.  
  52.    (*num)++;
  53.  
  54.    return;
  55. }
  56.  
  57.    /*
  58.     * MakeHeadEntry() erzeugt eine Titelzeileneintrag für die
  59.     * anzuzeigende Liste
  60.     */
  61. void
  62. MakeHeadEntry(int *num, char *title)
  63. {
  64.    strcpy(Entries[*num].se_Entry, field[BLANK_FIELD]);
  65.    AddNodeToList(*num, NO_SORT);
  66.  
  67.    (*num)++;
  68.  
  69.    strncpy(Entries[*num].se_Entry, title,BUFSIZE);
  70.    AddNodeToList(*num, NO_SORT);
  71.  
  72.    (*num)++;
  73.  
  74.    return;
  75. }
  76.  
  77.    /*
  78.     * MakeColEntry() erzeugt ein Zahleneintrag für die
  79.     * anzuzeigende Liste in einem bestimmten Format
  80.     */
  81. static void
  82. MakeColEntry(int *num, char *title, long entry)
  83. {
  84.    sprintf(Entries[*num].se_Entry, "%-22s : 0x%04lx", title, (long)entry);
  85.    AddNodeToList(*num, NO_SORT);
  86.  
  87.    (*num)++;
  88.  
  89.    return;
  90. }
  91.  
  92.    /*
  93.     * MakeHexEntry() erzeugt einen hexadezimalen
  94.     * Zahleneintrag für die anzuzeigende Liste
  95.     */
  96. void
  97. MakeHexEntry(int *num, char *title, APTR entry)
  98. {
  99.    sprintf(Entries[*num].se_Entry, "%-14s : 0x%08lx", title, entry);
  100.    AddNodeToList(*num, NO_SORT);
  101.  
  102.    (*num)++;
  103.  
  104.    return;
  105. }
  106.  
  107.    /*
  108.     * MakeTimeEntry() erzeugt einen Zeiteintrag für die
  109.     * anzuzeigende Liste
  110.     */
  111. static void
  112. MakeTimeEntry(int *num, char *title, struct timeval *tv)
  113. {
  114.    sprintf(Entries[*num].se_Entry, "%-22s : %ld sec %-6ld µsec",
  115.            title, tv->tv_secs, tv->tv_micro);
  116.  
  117.    AddNodeToList(*num, NO_SORT);
  118.  
  119.    (*num)++;
  120.  
  121.    return;
  122. }
  123.  
  124.    /*
  125.     * MakeMeasureEntry() erzeugt ein Maßzahleneintrag für die
  126.     * anzuzeigende Liste
  127.     */
  128. static void
  129. MakeMeasureEntry(int *num, char *title, long entry, char *measure)
  130. {
  131.    sprintf(Entries[*num].se_Entry, "%-22s : %ld %s",
  132.            title, (long)entry, measure);
  133.  
  134.    AddNodeToList(*num, NO_SORT);
  135.  
  136.    (*num)++;
  137.  
  138.    return;
  139. }
  140.  
  141.    /*
  142.     * SysPrefList() listet die Preferenceseinstellungen auf.
  143.     * Diese werden NICHT aus den 2.0-IFF-Prefs-Dateien
  144.     * geholt, sondern mit einer Systemfunktion ausgelesen
  145.     */
  146. void
  147. SysPrefList(void)
  148. {
  149.    int   i = 0;
  150.    struct Preferences PrefCopy,
  151.         *PCptr;
  152.    char *prtype = "Printer type",
  153.         *prshade = "Print shade",
  154.         *prpaper = "Paper size",
  155.         *baudrate = "Baud rate",
  156.         *parity = "Parity",
  157.         *handshake = "Handshake",
  158.         *baud = "Baud";
  159.  
  160.    DPOS;
  161.  
  162.    if (PCptr = GetPrefs(&PrefCopy, sizeof(struct Preferences)))
  163.    {
  164.       PrintHeader(PREFS, NULL);
  165.  
  166.       EmptyListView();
  167.  
  168.       PrintInfo("Read Preferences", NO_SPEAK, 0);
  169.  
  170.       countentries = 61;
  171.       Entries = AllocScrollEntries(countentries);
  172.  
  173.       strcpy(Entries[i].se_Entry, "----- Input/Keyboard:");
  174.       AddNodeToList(i++, NO_SORT);
  175.  
  176.       MakeTimeEntry(&i, "Keyboard repeat speed", &PCptr->KeyRptSpeed);
  177.  
  178.       MakeTimeEntry(&i, "Keyboard repeat delay", &PCptr->KeyRptDelay);
  179.  
  180.       MakeTimeEntry(&i, "Double click time", &PCptr->DoubleClick);
  181.  
  182.  
  183.       MakeHeadEntry(&i, "----- Pointer");
  184.  
  185.    /* Intuition Pointer data */
  186.       MakeNumEntry(&i, "\"Hot spot\" X", (long)PCptr->XOffset);
  187.       MakeNumEntry(&i, "\"Hot spot\" Y", (long)PCptr->YOffset);
  188.  
  189.       MakeColEntry(&i, "Pointer Sprite Col 0", (long)PCptr->color17);
  190.       MakeColEntry(&i, "Pointer Sprite Col 1", (long)PCptr->color18);
  191.       MakeColEntry(&i, "Pointer Sprite Col 2", (long)PCptr->color19);
  192.  
  193.       MakeNumEntry(&i, "Pointer Sensitivity", (long)PCptr->PointerTicks);
  194.  
  195.  
  196.  
  197.       MakeHeadEntry(&i, "----- Workbench");
  198.  
  199.       MakeNumEntry(&i, "Height default font", (long)PCptr->FontHeight);
  200.  
  201.       MakeColEntry(&i, "Standard Color 0", (long)PCptr->color0);
  202.       MakeColEntry(&i, "Standard Color 1", (long)PCptr->color1);
  203.       MakeColEntry(&i, "Standard Color 2", (long)PCptr->color2);
  204.       MakeColEntry(&i, "Standard Color 3", (long)PCptr->color3);
  205.  
  206.       MakeNumEntry(&i, "View X-Offset", (long)PCptr->ViewXOffset);
  207.       MakeNumEntry(&i, "View Y-Offset", (long)PCptr->ViewYOffset);
  208.       MakeNumEntry(&i, "View init offset X", (long)PCptr->ViewInitX);
  209.       MakeNumEntry(&i, "View init offset Y", (long)PCptr->ViewInitY);
  210.  
  211.       MakeNumEntry(&i, "Height default font", (long)PCptr->FontHeight);
  212.  
  213.       MakeStringEntry(&i, "CLI availability",
  214.                       (PCptr->EnableCLI ? "CLI enabled" : "CLI disabled"));
  215.  
  216.       MakeStringEntry(&i, "Workbench interlaced",
  217.                       (PCptr->LaceWB ? "Yes" : "No"));
  218.  
  219.       MakeNumEntry(&i, "Override WB width", (long)PCptr->wb_Width);
  220.  
  221.       MakeNumEntry(&i, "Override WB height", (long)PCptr->wb_Height);
  222.  
  223.       MakeNumEntry(&i, "Override WB depth", (long)PCptr->wb_Depth);
  224.  
  225.       MakeNumEntry(&i, "Extension Info size", (long)PCptr->ext_size);
  226.  
  227.  
  228.  
  229.       MakeHeadEntry(&i, "----- Printer");
  230.  
  231.       MakeStringEntry(&i, "Printer port",
  232.                       (PCptr->PrinterPort ? "Serial port" : "Parallel port"));
  233.  
  234.       switch (PCptr->PrinterType)
  235.       {
  236.          case 0x00:
  237.             MakeStringEntry(&i, prtype, "Custom");
  238.             break;
  239.  
  240.          case 0x01:
  241.             MakeStringEntry(&i, prtype, "Alpha P101");
  242.             break;
  243.  
  244.          case 0x02:
  245.             MakeStringEntry(&i, prtype, "Brother 15XL");
  246.             break;
  247.  
  248.          case 0x03:
  249.             MakeStringEntry(&i, prtype, "CBM MPS1000");
  250.             break;
  251.  
  252.          case 0x04:
  253.             MakeStringEntry(&i, prtype, "Diabolo 630");
  254.             break;
  255.  
  256.          case 0x05:
  257.             MakeStringEntry(&i, prtype, "Diabolo ADV-D25");
  258.             break;
  259.  
  260.          case 0x06:
  261.             MakeStringEntry(&i, prtype, "Diabolo C-150");
  262.             break;
  263.  
  264.          case 0x07:
  265.             MakeStringEntry(&i, prtype, "Epson");
  266.             break;
  267.  
  268.          case 0x08:
  269.             MakeStringEntry(&i, prtype, "Epson JX-80");
  270.             break;
  271.  
  272.          case 0x09:
  273.             MakeStringEntry(&i, prtype, "Okimate 20");
  274.             break;
  275.  
  276.          case 0x0A:
  277.             MakeStringEntry(&i, prtype, "Qume-LP 20");
  278.             break;
  279.  
  280.          case 0x0B:
  281.             MakeStringEntry(&i, prtype, "HP-Laserjet");
  282.             break;
  283.  
  284.          case 0x0C:
  285.             MakeStringEntry(&i, prtype, "HP-Laserjet +");
  286.             break;
  287.  
  288.          default:
  289.             MakeStringEntry(&i, prtype, "Unknown");
  290.             break;
  291.       }
  292.  
  293.       MakeStringEntry(&i, "Printer Driver", (char *)PCptr->PrinterFilename);
  294.  
  295.       MakeNumEntry(&i, "Print pitch", (long)PCptr->PrintPitch);
  296.  
  297.       MakeStringEntry(&i, "Print quality",
  298.                       (PCptr->PrintQuality ? "Letter" : "Draft"));
  299.  
  300.       MakeStringEntry(&i, "Lines per inch",
  301.                       (PCptr->PrintSpacing ? "8 LPI" : "6 LPI"));
  302.  
  303.       MakeNumEntry(&i, "Left margin", (long)PCptr->PrintLeftMargin);
  304.  
  305.       MakeMeasureEntry(&i, "Right margin", (long)PCptr->PrintRightMargin,
  306.                        "Chars");
  307.  
  308.       MakeStringEntry(&i, "Print image",
  309.                       (PCptr->PrintImage ? "Negative" : "Positive"));
  310.  
  311.       MakeStringEntry(&i, "Print aspect",
  312.                       (PCptr->PrintImage ? "Vertical" : "Horizontal"));
  313.  
  314.  
  315.       switch (PCptr->PrintShade)
  316.       {
  317.          case 0:
  318.             MakeStringEntry(&i, prshade, "Black/White");
  319.             break;
  320.  
  321.          case 1:
  322.             MakeStringEntry(&i, prshade, "Grey scale");
  323.             break;
  324.  
  325.          default:
  326.             MakeStringEntry(&i, prshade, "Color");
  327.             break;
  328.       }
  329.  
  330.       MakeNumEntry(&i, "Print Threshold", (long)PCptr->PrintThreshold);
  331.  
  332.       switch (PCptr->PaperSize)
  333.       {
  334.          case US_LETTER:
  335.             MakeStringEntry(&i, prpaper, "USA Letter");
  336.             break;
  337.  
  338.          case US_LEGAL:
  339.             MakeStringEntry(&i, prpaper, "USA Legal");
  340.             break;
  341.  
  342.          case N_TRACTOR:
  343.             MakeStringEntry(&i, prpaper, "Narrow tractor");
  344.             break;
  345.  
  346.          case W_TRACTOR:
  347.             MakeStringEntry(&i, prpaper, "Wide tractor");
  348.             break;
  349.  
  350.          case CUSTOM:
  351.             MakeStringEntry(&i, prpaper, "Custom width");
  352.             break;
  353.  
  354.       }
  355.  
  356.       MakeMeasureEntry(&i, "Paper length", (long)PCptr->PaperLength,
  357.                        "Rows");
  358.  
  359.       MakeStringEntry(&i, "Paper type",
  360.                       (PCptr->PaperType ? "Single paper" : "Fanfold paper"));
  361.  
  362.       MakeStringEntry(&i, "Temp file for printer",
  363.                       ((PCptr->WorkName != NULL) ? (char *)PCptr->WorkName :
  364.                        (char *)"None"));
  365.  
  366.       MakeNumEntry(&i, "Affect Rows/Columns", (long)PCptr->RowSizeChange);
  367.  
  368.       sprintf(Entries[i].se_Entry, "User preference flags  : 0x%08lx",
  369.               PCptr->PrintFlags);
  370.       AddNodeToList(i++, NO_SORT);
  371.  
  372.       MakeMeasureEntry(&i, "Max width of picture", (long)PCptr->PrintMaxWidth / 10,
  373.                        "inch");
  374.  
  375.       MakeMeasureEntry(&i, "Max height of picture", (long)PCptr->PrintMaxHeight / 10,
  376.                        "inch");
  377.       MakeMeasureEntry(&i, "Offset of picture", (long)PCptr->PrintXOffset / 10,
  378.                        "inch");
  379.       MakeNumEntry(&i, "Print density", (long)PCptr->PrintDensity);
  380.  
  381.  
  382.  
  383.       MakeHeadEntry(&i, "----- Serial configuration");
  384.  
  385.       switch (PCptr->BaudRate)
  386.       {
  387.          case 0x00:
  388.             MakeMeasureEntry(&i, baudrate, 110L, baud);
  389.             break;
  390.  
  391.          case 0x01:
  392.             MakeMeasureEntry(&i, baudrate, 300L, baud);
  393.             break;
  394.  
  395.          case 0x02:
  396.             MakeMeasureEntry(&i, baudrate, 1200L, baud);
  397.             break;
  398.  
  399.          case 0x03:
  400.             MakeMeasureEntry(&i, baudrate, 2400L, baud);
  401.             break;
  402.  
  403.          case 0x04:
  404.             MakeMeasureEntry(&i, baudrate, 4800L, baud);
  405.             break;
  406.  
  407.          case 0x05:
  408.             MakeMeasureEntry(&i, baudrate, 9600L, baud);
  409.             break;
  410.  
  411.          case 0x06:
  412.             MakeMeasureEntry(&i, baudrate, 19200L, baud);
  413.             break;
  414.  
  415.          case 0x07:
  416.             MakeStringEntry(&i, baudrate, "MIDI (31.250 baud)");
  417.             break;
  418.  
  419.          default:
  420.             MakeStringEntry(&i, baudrate, (char *)field[NO_BAUD]);
  421.             break;
  422.       }
  423.  
  424.       MakeNumEntry(&i, "Read bits", (long)SRBNUM(PCptr->SerRWBits));
  425.       MakeNumEntry(&i, "Write bits", (long)SWBNUM(PCptr->SerRWBits));
  426.  
  427.       MakeNumEntry(&i, "Stop bits", (long)SSBNUM(PCptr->SerStopBuf));
  428.  
  429.       switch (SPARNUM(PCptr->SerParShk))
  430.       {
  431.          case SPARITY_NONE:
  432.             MakeStringEntry(&i, parity, "None");
  433.             break;
  434.  
  435.          case SPARITY_EVEN:
  436.             MakeStringEntry(&i, parity, "Even");
  437.             break;
  438.  
  439.          case SPARITY_ODD:
  440.             MakeStringEntry(&i, parity, "Odd");
  441.             break;
  442.  
  443.          default:
  444.             MakeStringEntry(&i, parity, (char *)field[NO_PARITY]);
  445.             break;
  446.       }
  447.  
  448.       switch (SHAKNUM(PCptr->SerParShk))
  449.       {
  450.          case SHSHAKE_XON:
  451.             MakeStringEntry(&i, handshake, "XOn/XOff");
  452.             break;
  453.  
  454.          case SHSHAKE_RTS:
  455.             MakeStringEntry(&i, handshake, "RTS/CTS");
  456.             break;
  457.  
  458.          case SHSHAKE_NONE:
  459.             MakeStringEntry(&i, handshake, "None");
  460.             break;
  461.  
  462.          default:
  463.             MakeStringEntry(&i, handshake, (char *)field[NO_HANDSHK]);
  464.             break;
  465.       }
  466.    }
  467.    else
  468.       ErrorHandle(ENV_ERR, INFO_FAIL, NO_KILL);
  469.  
  470.    PrintStatistics();
  471.  
  472.    return;
  473. }
  474.  
  475.  
  476.    /*
  477.     * SysEnvList() erzeugt eine Liste aller Dateien
  478.     * (Environmentvariablen) im Verzeichnis ENV:
  479.     */
  480. void
  481. SysEnvList(void)
  482. {
  483.    int   i;
  484.    UBYTE envline[MAXFULLNAME+1];
  485.    char  envname[ENVLEN+1], envfullname[MAXFULLNAME];
  486.    struct ExAllControl *eac;
  487.    struct ExAllData *EAData,
  488.         *ead;
  489.    int   more;
  490.    long  s;
  491.    int   d = 0;
  492.    BPTR  lock;
  493.    int ftyp;
  494.  
  495.    DPOS;
  496.  
  497.    PrintHeader(ENVVARS, NULL);
  498.  
  499.    EmptyListView();
  500.  
  501.    if (lock = Lock((UBYTE *) "ENV:", ACCESS_READ))
  502.    {
  503.       countentries = SizeOfDir(lock, &s, &d);
  504.       countentries += d;
  505.  
  506.       if (NoEntries())
  507.       {
  508.          UnLock(lock);
  509.          return;
  510.       }
  511.  
  512.       Entries = AllocScrollEntries(countentries);
  513.  
  514.       i = 0;
  515.  
  516.       if (eac = AllocDosObject(DOS_EXALLCONTROL, NULL))
  517.       {
  518.          eac->eac_LastKey = 0;
  519.  
  520.          EAData = MyAllocVec((MAXLARGEMEM+1) * sizeof(struct ExAllData),
  521.                              MEMF_ANY | MEMF_CLEAR, NO_KILL);
  522.  
  523.          if (EAData)
  524.          {
  525.             do
  526.             {
  527.                more = ExAll(lock, EAData, MAXLARGEMEM * sizeof(struct ExAllData),
  528.                             ED_TYPE, eac);
  529.  
  530.                if ((!more) && (IoErr()!= ERROR_NO_MORE_ENTRIES))
  531.                {
  532.                   ErrorHandle(DOS_EXALL_ERR, EXALL_FAIL, NO_KILL);
  533.                   break;
  534.                }
  535.  
  536.                if (eac->eac_Entries == 0)
  537.                   continue;
  538.  
  539.                ead = EAData;
  540.  
  541.                do
  542.                {
  543.                   strncpy(envname, (char *)ead->ed_Name, ENVLEN);
  544.                   envname[ENVLEN] = STRINGEND;
  545.                   sprintf(envfullname,"ENV:%s",envname);
  546.  
  547.                   ftyp  = filetype((char *)envfullname);
  548.  
  549.                   if(ead->ed_Type > 0)
  550.                      sprintf(Entries[i].se_Entry,EntryAttr[18].ea_dataformat,
  551.                              envname, "<dir>");
  552.                   else if(ftyp == TYPE_TEXT)
  553.                   {
  554.                      if (GetVar((STRPTR)envname, envline, MAXFULLNAME,GVF_GLOBAL_ONLY) > 0)
  555.                      {
  556.                         envline[MAXSTRLEN-1] = STRINGEND;
  557.  
  558.                         sprintf(Entries[i].se_Entry, EntryAttr[18].ea_dataformat,
  559.                                 envname, (char *)envline);
  560.                      }
  561.                      else
  562.                         sprintf(Entries[i].se_Entry,
  563.                                 EntryAttr[18].ea_dataformat,
  564.                                 envname, "<env error>");
  565.                   }
  566.                   else
  567.                      sprintf(Entries[i].se_Entry,
  568.                              EntryAttr[18].ea_dataformat,
  569.                              envname, "<no text>");
  570.  
  571.                   AddNodeToList(i++, SORT);
  572.  
  573.                   ead = ead->ed_Next;
  574.                }
  575.                while (ead && (i < countentries));
  576.             }
  577.             while (more && (i < countentries));
  578.  
  579.             MyFreeVec(EAData);
  580.          }
  581.  
  582.          FreeDosObject(DOS_EXALLCONTROL, eac);
  583.       }
  584.       else
  585.          ErrorHandle(MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  586.  
  587.       UnLock(lock);
  588.    }
  589.    else
  590.    {
  591.       ErrorHandle(ENV_ERR, FIND_FAIL, NO_KILL);
  592.       return;
  593.    }
  594.  
  595.    PrintStatistics();
  596.  
  597.    return;
  598. }
  599.  
  600.  
  601.  
  602. void
  603. SysExtPrinterData(void)
  604. {
  605.    union printerIO
  606.    {
  607.        struct IOStdReq    ios;
  608.        struct IODRPReq    iodrp;
  609.        struct IOPrtCmdReq iopc;
  610.    } *PIO;
  611.    struct MsgPort *PrinterMP;
  612.    struct PrinterData *PD;
  613.    struct PrinterExtendedData *PED;
  614.    int i = 0;
  615.  
  616.    DPOS;
  617.  
  618.    PrintHeader(PRINTERDATA, NULL);
  619.  
  620.    EmptyListView();
  621.  
  622.    countentries = 13;
  623.    Entries = AllocScrollEntries(countentries);
  624.  
  625.    if (PrinterMP = (struct MsgPort *) CreateMsgPort())
  626.    {
  627.       if (PIO = (union printerIO *) CreateExtIO(PrinterMP,
  628.                                                 sizeof(union printerIO)))
  629.       {
  630.          if (!(OpenDevice((STRPTR)"printer.device", 0,
  631.                           (struct IORequest *) PIO, 0)))
  632.          {
  633.             PD = (struct PrinterData *) PIO->iodrp.io_Device;
  634.             PED = (struct PrinterExtendedData *) &PD->pd_SegmentData->ps_PED;
  635.  
  636.             MakeStringEntry(&i,"Printer name",PED->ped_PrinterName);
  637.             MakeNumEntry(&i,"Version",(long)PD->pd_SegmentData->ps_Version);
  638.             MakeNumEntry(&i,"Revision",(long)PD->pd_SegmentData->ps_Revision);
  639.  
  640.             MakeNumEntry(&i,"Printer class",(long)PED->ped_PrinterClass);
  641.             MakeNumEntry(&i,"Color class",(long)PED->ped_ColorClass);
  642.  
  643.             MakeNumEntry(&i,"Print columns",(long)PED->ped_MaxColumns);
  644.             MakeNumEntry(&i,"Char sets",(long)PED->ped_NumCharSets);
  645.             MakeNumEntry(&i,"Print head pins",(long)PED->ped_NumRows);
  646.  
  647.             MakeMeasureEntry(&i,"Max X-dots in dump",PED->ped_MaxXDots,"dots");
  648.             MakeMeasureEntry(&i,"Max Y-dots in dump",PED->ped_MaxYDots,"dots");
  649.             MakeMeasureEntry(&i,"Density X",(long)PED->ped_XDotsInch,"dots/inch");
  650.             MakeMeasureEntry(&i,"Density Y",(long)PED->ped_YDotsInch,"dots/inch");
  651.             MakeMeasureEntry(&i,"Timeout",(long)PED->ped_TimeoutSecs,"sec");
  652.  
  653.             CloseDevice((struct IORequest *) PIO);
  654.          }
  655.  
  656.          DeleteExtIO((struct IORequest *) PIO);
  657.       }
  658.  
  659.       DeleteMsgPort((struct MsgPort *) PrinterMP);
  660.    }
  661.  
  662.    PrintStatistics();
  663.  
  664.    return;
  665. }
  666.