home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / libs / plotlib.lha / Plot_1.lzh / Demo / Hardcopy.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-05  |  27.0 KB  |  680 lines
  1. /****************************************************************
  2. *                                                                                                                                *
  3. * Filename : HardCopy.c                                                                                    *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. * Comment : Alle Funktionen für die Hardcopyfunktion.                        *
  8. *                                                                                                                                *
  9. *         Rev : V1.2                                                                                                    *
  10. *                                                                                                                                *
  11. * History : V1.0 erstellen dieses Files                                24.06.89    *
  12. *                     V1.1 erweitern um X/Y-Option                                02.09.89    *
  13. *                     V1.2 Convert() verbessert                                    30.09.89    *
  14. *                                                                                                                                *
  15. *        Bugs : keine bekannten                                                                            *
  16. *                                                                                                                                *
  17. *     Autor : Oesch Silvano                                                                                *
  18. *                                                                                                                                *
  19. *     Datum : 02.09.89                                                                                            *
  20. *                                                                                                                                *
  21. ****************************************************************/
  22.  
  23. /****************************************************************
  24. *                                                                                                                                *
  25. * allgemeine Includedateien                                                                            *
  26. *                                                                                                                                *
  27. ****************************************************************/
  28.  
  29. #include <exec/types.h>
  30. #include <exec/exec.h>
  31. #include <intuition/intuition.h>
  32. #include <intuition/intuitionbase.h>
  33. #include <intuition/screens.h>
  34. #include <devices/printer.h>
  35. #include <libraries/dos.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  38. #include <ctype.h>
  39. #include <stdio.h>
  40. #include <mylib/mylib.h>
  41.  
  42. /****************************************************************
  43. *                                                                                                                                *
  44. * programmspezifische Includedateien                                                        *
  45. *                                                                                                                                *
  46. ****************************************************************/
  47.  
  48. #include "Hardcopy.h"                                /* Window und Gadget def.        */
  49.  
  50. /****************************************************************
  51.  *                                                                                                                            *
  52.  * externe Definitionen                                                                                    *
  53.  *                                                                                                                            *
  54.  ****************************************************************/
  55.  
  56. extern struct IntuitionBase *IntuitionBase;
  57.  
  58. /****************************************************************
  59.  *                                                                                                                            *
  60.  * globale Definitionen                                                                                    *
  61.  *                                                                                                                            *
  62.  ****************************************************************/
  63.  
  64. static struct MsgPort *port = NULL;    /* Printer Port Struktur        */
  65. static struct Preferences *prefs = NULL;
  66.                                                                         /* Preferences Struktur            */
  67. static struct IODRPReq *dump = NULL;
  68.                                                                         /* Dump-Structure                        */
  69. static struct Window *Hc = NULL;        /* Hardcopy Window                    */
  70.  
  71. static struct Prt_Commands init[2] =
  72. {
  73.     aRIN,0,0,0,
  74.     aVERP0,0,0,0
  75. };
  76.  
  77. /****************************************************************
  78.  *                                                                                                                            *
  79.  *    Funktion : Convert()                                                                                *
  80.  *                                                                                                                            *
  81.  ****************************************************************
  82.  *                                                                                                                            *
  83.  *        Input : Zahl,Text                                                                                    *
  84.  *                        Zahl     -> zu konvertierende Zahl                                    *
  85.  *                        Text     -> Adresse der Textstruktur                                *
  86.  *                                                                                                                            *
  87.  *     Output : None                                                                                            *
  88.  *                                                                                                                            *
  89.  *                                                                                                                            *
  90.  ****************************************************************
  91.  *                                                                                                                            *
  92.  *    Comment : Konvertiert eine 2 oder 1 stellige Zahl auf                *
  93.  *                        konstante Länge und schreibt sie rechtsbündig            *
  94.  *                        in einen String referenziert in einer Intuitext     *
  95.  *                        Struktur und beginnt ab dieser Struktur eine            *
  96.  *                        Neuzeichnung des Textes.                                                    *
  97.  *                                                                                                                            *
  98.  *            Rev : V1.1                                                                                            *
  99.  *                                                                                                                            *
  100.  *    History : V1.0 erstellen dieser Funktion                    19.06.89    *
  101.  *                        V1.1 allgemeine übergabe einer                                        *
  102.  *                                 Intuitextstruktur                                    30.09.89    *
  103.  *                                                                                                                            *
  104.  *         Bugs : keine bekannten                                                                        *
  105.  *                                                                                                                            *
  106.  *        Autor : Oesch Silvano                                                                            *
  107.  *                                                                                                                            *
  108.  *        Datum : 30.09.89                                                                                    *
  109.  *                                                                                                                            *
  110.  ****************************************************************/
  111.  
  112. void convert(rp,zahl,text)
  113. struct RastPort *rp;
  114. int zahl;                                                        /* Integer Zahl                            */
  115. struct IntuiText *text;                            /* IntuiText Struktur                */
  116. {
  117.     sprintf(text->IText,"%2d",zahl);    /* konver. und schreibe            */
  118.     PrintIText(rp,text,0,0);                    /* nun ab Dichte schreiben    */
  119. }
  120.  
  121. /****************************************************************
  122.  *                                                                                                                            *
  123.  *    Funktion : PrtCommand()                                                                            *
  124.  *                                                                                                                            *
  125.  ****************************************************************
  126.  *                                                                                                                            *
  127.  *        Input : Port,Commands,Nbr                                                                    *
  128.  *                        Port            -> Portadresse                                                    *
  129.  *                        Commands    -> Adresse des Commandarrays                        *
  130.  *                        Nbr                -> Anzahl Commands                                            *
  131.  *                                                                                                                            *
  132.  *     Output : Boolean                                                                                        *
  133.  *                            TRUE        -> erfolgreiches senden der Commands        *
  134.  *                            FALSE        -> Fehler beim Senden                                        *
  135.  *                                                                                                                            *
  136.  *                                                                                                                            *
  137.  ****************************************************************
  138.  *                                                                                                                            *
  139.  *    Comment : Sendet einen beliebigen Command an das                        *
  140.  *                        Printerdevice.                                                                        *
  141.  *                                                                                                                            *
  142.  *                                                                                                                            *
  143.  *                                                                                                                            *
  144.  *            Rev : V1.0                                                                                            *
  145.  *                                                                                                                            *
  146.  *    History : V1.0 erstellen dieses Files                            01.09.89    *
  147.  *                                                                                                                            *
  148.  *         Bugs : keine bekannten                                                                        *
  149.  *                                                                                                                            *
  150.  *        Autor : Oesch Silvano                                                                            *
  151.  *                                                                                                                            *
  152.  *        Datum : 01.09.89                                                                                    *
  153.  *                                                                                                                            *
  154.  ****************************************************************/
  155.  
  156. static int prtcommand(port,commands,nbr)
  157. struct MsgPort *port;                                /* MsgPort                                    */
  158. struct Prt_Commands *commands;            /* Commandarray                            */
  159. short nbr;                                                    /* Elementanzahl                        */
  160. {
  161.     int fehler,                                                /* Rückgabewert                            */
  162.             i;                                                        /* Schleifenzähler                    */
  163.     struct IOPrtCmdReq req;                        /* Commandstruktur                    */
  164.     fehler = OpenDevice("printer.device",NULL,&req,NULL);
  165.                                                                         /* reserviere Device                */
  166.     if (!fehler)                                            /* nur wenn bekommen                */
  167.     {                                                                    /* init. der Struktur                */
  168.         req.io_Message.mn_ReplyPort = port;
  169.         req.io_Command = PRD_PRTCOMMAND;
  170.         for ( i=0;i<nbr;i++)                        /* alle Kommandos senden        */
  171.         {                                                                /* Kommando einsetzten            */
  172.             req.io_PrtCommand = commands[i].Command;
  173.             req.io_Parm0 = commands[i].P_0;
  174.             req.io_Parm1 = commands[i].P_1;
  175.             req.io_Parm2 = commands[i].P_2;
  176.             req.io_Parm3 = commands[i].P_3;
  177.             fehler = DoIO(&req);                    /* und senden                                */
  178.             if (fehler) break;                        /* wenn Fehler verlassen        */
  179.         }
  180.         CloseDevice(&req);                            /* Device freigeben                    */
  181.     }
  182.     return ( fehler );                                /* Fehler zurückgeben                */
  183. }
  184.  
  185. /****************************************************************
  186.  *                                                                                                                            *
  187.  *    Funktion : PrtText()                                                                                *
  188.  *                                                                                                                            *
  189.  ****************************************************************
  190.  *                                                                                                                            *
  191.  *        Input : Port,Text                                                                                    *
  192.  *                                                                                                                            *
  193.  *                                                                                                                            *
  194.  *     Output : None                                                                                            *
  195.  *                                                                                                                            *
  196.  *                                                                                                                            *
  197.  ****************************************************************
  198.  *                                                                                                                            *
  199.  *    Comment : Sendet einen Text an die Printer.device                        *
  200.  *                                                                                                                            *
  201.  *            Rev : V1.0                                                                                            *
  202.  *                                                                                                                            *
  203.  *    History : V1.0 erstellen dieses Files                            01.06.89    *
  204.  *                                                                                                                            *
  205.  *            Doc :                                                                                                        *
  206.  *                                                                                                                            *
  207.  *         Bugs : keine bekannten                                                                        *
  208.  *                                                                                                                            *
  209.  *        Autor : Oesch Silvano                                                                            *
  210.  *                                                                                                                            *
  211.  *        Datum : 01.06.89                                                                                    *
  212.  *                                                                                                                            *
  213.  ****************************************************************/
  214.  
  215. static int prttext(port,text)
  216.     struct MsgPort *port;                            /* MsgPort                                    */
  217.     char *text;                                                /* Textpointer                            */
  218.     {
  219.         struct IOStdReq prreq;                    /* Sendstruktur                            */
  220.         int fehler;                                            /* Rückgabewert                            */
  221.         fehler = OpenDevice("printer.device",NULL,&prreq,NULL);
  222.                                                                         /* reservieren des Gerätes    */
  223.         if ( !fehler )                                    /* bekommen                                    */
  224.             {                                                            /* init. der Struktur                */
  225.                 prreq.io_Message.mn_ReplyPort = port;
  226.                 prreq.io_Command = CMD_WRITE;
  227.                 prreq.io_Data = ( APTR )text;
  228.                 prreq.io_Length = -1;
  229.                 fehler = DoIO(&prreq);            /* und senden                                */
  230.                 CloseDevice(&prreq);                /* Device freigeben                    */
  231.             }
  232.         return ( fehler );                            /* Fehler zurückgeben                */
  233.      }
  234.  
  235.  
  236. /****************************************************************
  237.  *                                                                                                                            *
  238.  *    Funktion : SetCursor()                                                                            *
  239.  *                                                                                                                            *
  240.  ****************************************************************
  241.  *                                                                                                                            *
  242.  *        Input : nbr                                                                                                *
  243.  *                        Positionierung in cm                                                            *
  244.  *                                                                                                                            *
  245.  *     Output : None                                                                                            *
  246.  *                                                                                                                            *
  247.  *                                                                                                                            *
  248.  ****************************************************************
  249.  *                                                                                                                            *
  250.  *    Comment : Setzt den Printercursor auf die entsprechende            *
  251.  *                        Position.                                                                                    *
  252.  *                        ACHTUNG: Diese Funktion ist Geräteabhängig.                *
  253.  *                                                                                                                            *
  254.  *            Rev : V1.0                                                                                            *
  255.  *                                                                                                                            *
  256.  *    History : V1.0 erstellen dieses Files                            01.06.90    *
  257.  *                                                                                                                            *
  258.  *            Doc :                                                                                                        *
  259.  *                                                                                                                            *
  260.  *         Bugs : keine bekannten                                                                        *
  261.  *                                                                                                                            *
  262.  *        Autor : Oesch Silvano                                                                            *
  263.  *                                                                                                                            *
  264.  *        Datum : 01.06.90                                                                                    *
  265.  *                                                                                                                            *
  266.  ****************************************************************/
  267.  
  268. static void setcursor(nbr)
  269.     int nbr;                                                    /* Position in Zentimeter        */
  270.     {
  271.         ULONG datei;                                        /* Dateipointer                            */
  272.         int i,                                                    /* Schleifenzähler                    */
  273.                 error;                                            /* Rückgabewert                            */
  274.         char text[] = "\x1b*p+118Y";        /* Kommando für 1 cm                */
  275.         datei = Open("PAR:",MODE_NEWFILE);
  276.                                                                         /* Öffnen der Schnittstelle    */
  277.         for ( i=0;i<nbr;i++)                        /* alle senden                            */
  278.             {
  279.                 error = Write(datei,&text[0],sizeof(text));
  280.             }
  281.         Close(datei);                                        /* Schnittstelle schliessen    */
  282.     }
  283.  
  284. /****************************************************************
  285. *                                                                                                                                *
  286. *    Funktion : CloseHc()                                                                                    *
  287. *                                                                                                                                *
  288. *****************************************************************
  289. *                                                                                                                                *
  290. *        Input : None                                                                                                *
  291. *                                                                                                                                *
  292. *     Output : None                                                                                                *
  293. *                                                                                                                                *
  294. *****************************************************************
  295. *                                                                                                                                *
  296. *    Comment : Schliesst alles offene und kehrt danach ins                    *
  297. *                        aufrufende Programm zurück.                                                    *
  298. *                                                                                                                                *
  299. *            Rev : V1.0                                                                                                *
  300. *                                                                                                                                *
  301. *    History : V1.0 erstellen dieses Files                                01.06.89    *
  302. *                                                                                                                                *
  303. *         Bugs : keine bekannten                                                                            *
  304. *                                                                                                                                *
  305. *        Autor : Oesch Silvano                                                                                *
  306. *                                                                                                                                *
  307. *        Datum : 01.06.89                                                                                        *
  308. *                                                                                                                                *
  309. ****************************************************************/
  310.  
  311. static void closeHc()
  312. {
  313.     if ( prefs )
  314.     {
  315.         SetPrefs(prefs,sizeof(struct Preferences),FALSE);
  316.                                                                         /* Preferences setzen                */
  317.         free(prefs);                                        /* Speicher freigeben                */
  318.     }
  319.     if ( Hc ) CloseWindow ( Hc );            /* Hardcopy schliessen            */
  320.     if ( dump) free(dump);                        /* Dumpstruktur freigeben        */
  321.     if ( port ) DeletePort(port);            /* Port schliessen                    */
  322. }
  323.  
  324. /****************************************************************
  325. *                                                                                                                                *
  326. * Funktion : HardCopy(Sc,Mw)                                                                        *
  327. *                                                                                                                                *
  328. *****************************************************************
  329. *                                                                                                                                *
  330. *     Input : Screenpointer,Windowpointer                                                    *
  331. *                                                                                                                                *
  332. *                     Screen -> Für Workbenchscreen = NULL                                    *
  333. *                                    -> Für Customscreen = Screenpointer                        *
  334. *                                                                                                                                *
  335. *                     Window -> Windowpointer welches ausgedruckt                    *
  336. *                                         werden soll.                                                                *
  337. *                                         Window = NULL => Screendump                                *
  338. *                                                                                                                                *
  339. *    Output : Boolean                                                                                            *
  340. *                                                                                                                                *
  341. *                     TRUE        -> Hardcopy erfolgreich                                                *
  342. *                     FALSE     -> Printerport oder Deviceport konnte                    *
  343. *                                         nicht geöffnet werden.                                            *
  344. *                                         Ev. kein Speicher für Graphik.                            *
  345. *                                                                                                                                *
  346. *****************************************************************
  347. *                                                                                                                                *
  348. * Comment : Die Hardcopyfunktion nimmt das spez. Window und            *
  349. *                     druckt es mit den eingestellten Parametern auf                *
  350. *                     die Printerdevice.                                                                        *
  351. *                     Die Dichte kann man einstellen, ebenso die                        *
  352. *                     Grösse.                                                                                            *
  353. *                     Die Koordinaten auf dem Papier können ebenfalls            *
  354. *                     eingestellt werden.                                                                    *
  355. *                     Reverse bedeutet die umkehrung der Farben                        *
  356. *                     ( weiss = schwarz ... ).                                                            *
  357. *                     Für die einzelnen Parameter wird die                                    *
  358. *                     Preferencesstruktur geholt und entsprechend                    *
  359. *                     geändert. Nach erfolgter Hardcopy wird diese                    *
  360. *                     Struktur wieder zurückgesetzt.                                                *
  361. *                     Für die Hardcopy wird die IODRPReq-Struktur ver-            *
  362. *                     wendet.                                                                                            *
  363. *                                                                                                                                *
  364. *                     Als externe Referenz ist nur die IntuitionBase                *
  365. *                     aufgeführt. D.h. die Intuition Library muss                    *
  366. *                     vorher geöffnet werden.                                                            *
  367. *                                                                                                                                *
  368. *         Rev : V1.1                                                                                                    *
  369. *                                                                                                                                *
  370. * History : V1.0 erstellen dieses Files                                01.06.89    *
  371. *                     V1.1 erweitern um X/Y-Option                                01.09.89    *
  372. *                                                                                                                                *
  373. *        Bugs : keine bekannten                                                                            *
  374. *                                                                                                                                *
  375. *     Autor : Oesch Silvano                                                                                *
  376. *                                                                                                                                *
  377. *     Datum : 01.09.89                                                                                            *
  378. *                                                                                                                                *
  379. ****************************************************************/
  380.  
  381. int HardCopy(Sc,Mw)                                    /* BOOLEAN als Rückgabewert    */
  382. struct Screen *Sc;                                    /* Screen Pointer                        */
  383. struct Window *Mw;                                    /* Window Pointer                        */
  384. {
  385.     struct IntuiMessage *message;            /* Message Strukutr                    */
  386.     struct IODRPReq *printmessage;        /* Printer Message                    */
  387.     struct Gadget *gadmess;                        /* Gadget Message                        */
  388.     struct ViewPort *Vp;                            /* ViewPort Pointer                    */
  389.     struct RastPort *Rp;                            /* RastPort Pointer                    */
  390.     struct RastPort *rp;                            /* Hardcopy Window Rastport    */
  391.  
  392.     static int    dichte = DICHTE,            /* Voreinstellung Dichte        */
  393.                             breite = BREITE,            /* Voreinstellung Breite        */
  394.                             hoehe = HOEHE,                /* Voreinstellung Höhe            */
  395.                             x = XRAND,                        /* Voreinstellung X                    */
  396.                             y = YRAND,                        /* Voreinstellung Y                    */
  397.                             reverse = TRUE;                /* Voreinstellung Reverse        */
  398.  
  399.     int fehler,                                                /* Printer Rückgabewert            */
  400.             error,                                                /* allg. Rückgabewert                */
  401.             erfolg,
  402.             loop = TRUE;                                    /* Hauptschle-ife Abbruch        */
  403.  
  404.     UBYTE tempd;                                            /* Temp. Datenspeicher            */
  405.     USHORT tempi,
  406.                  tempx;
  407.  
  408.     if (( Sc == NULL)&&(Mw == NULL))    /* min. 1 Parameter setzen    */
  409.         return(FALSE);                                    /* So nicht                                    */
  410.  
  411.     if ( Sc )                                                    /* eigener Screen ?                    */
  412.     {                                                                    /* Ja                                                */
  413.         HCW.Screen = Sc;                                /* Init. Windowstruktur            */
  414.         if ( Mw != NULL )                                /* wenn Mw und Sc dann            */
  415.             HCW.Type = CUSTOMSCREEN;            /* natürlich eigener Typ        */
  416.     }
  417.     else                                                            /* Workbenchscreen                    */
  418.         Sc = Mw->WScreen;                                /* Screenpointer                        */
  419.  
  420.     Vp = &Sc->ViewPort;                                /* Viewport initialisieren    */
  421.     if ( Mw != NULL )                                    /* Windowdump ?                            */
  422.         Rp = Mw->RPort;                                    /* Ja, Windowrastport                */
  423.     else                                                            /* Nein, Screendump                    */
  424.         Rp = &Sc->RastPort;                            /* Screenrastport                        */
  425.  
  426.     Hc = (struct Window *)OpenWindow(&HCW);
  427.                                                                         /* Öffne Hardcopywindow            */
  428.     if ( Hc == NULL )                                    /* Fehler ?                                    */
  429.     {                                                                    /* Hc = NULL                                */
  430.         closeHc();                                            /* alles schliessen                    */
  431.         return ( FALSE );                                /* Return mit Fehler                */
  432.     }
  433.     rp = Hc->RPort;                                        /* Hardcopy RastPort holen    */
  434.     PrintIText(rp,&ITHc1,0,0);                /* Text setzen                            */
  435.     DrawBorder(rp,&BHc7,0,0);                    /* Rahmen setzen                        */
  436.  
  437.     while ( loop )                                        /* Schleife für Einstellung    */
  438.     {
  439.         message = ( struct IntuiMessage *)
  440.             GetMsg(Hc->UserPort);                /* Message holen                        */
  441.         if ( message==NULL)                        /* keine Message                        */
  442.         {                                                        /* dann warten auf Message    */
  443.             Wait(1L << Hc->UserPort->mp_SigBit);
  444.             continue;                                    /* Message erhalten, das        */
  445.         }                                                        /* ganze von vorne                    */
  446.         gadmess = (struct Gadget *)message->IAddress;
  447.                                                                         /* kann nur Gadget sein,        */
  448.                                                                         /* also Gadgetadresse holen    */
  449.         ReplyMsg(message);                            /* antworten                                */
  450.  
  451.         switch (gadmess->GadgetID)            /* welches Gadget gedrückt    */
  452.         {
  453.             case GDU:                                            /* Dichte wurde gedrückt        */
  454.             case GDD:
  455.                 if (gadmess->GadgetID == GDU)
  456.                                                                         /* Dichte auf ?                            */
  457.                 {                                                        /* Ja                                                */
  458.                     if (dichte < MAXDICHTE)        /* noch in Grenzen ?                */
  459.                         dichte++;                                /* ja, dann addiere                    */
  460.                 }
  461.                 else                                                /* also Dichte ab                        */
  462.                     if (dichte > MINDICHTE)        /* noch in Grenzen ?                */
  463.                         dichte--;                                /* ja, dann subtrahiere            */
  464.                 convert(rp,dichte,&ITHc3);    /* konvertiere und schreibe    */
  465.                 break;                                            /* von vorne                                */
  466.             case GXU:                                            /* X wurde gedrückt                    */
  467.             case GXD:
  468.                 if (gadmess->GadgetID == GXU)
  469.                                                                         /* X auf ?                                    */
  470.                 {                                                        /* Ja                                                */
  471.                     if (x < (MAXBREITE-breite))
  472.                                                                         /* noch in Grenzen ?                */
  473.                         x++;                                        /* ja, dann addiere                    */
  474.                 }
  475.                 else                                                /* also X ab                                */
  476.                     if (x > MINXRAND)                    /* noch in Grenzen ?                */
  477.                         x--;                                        /* ja, dann subtrahiere            */
  478.                 convert(rp,x,&ITHc4);                /* konvertiere und schreibe    */
  479.                 break;                                            /* von vorne                                */
  480.             case GYU:                                    /* Y wurde gedrückt                    */
  481.             case GYD:
  482.                 if (gadmess->GadgetID == GYU)
  483.                                                                         /* Y auf ?                                    */
  484.                 {                                                        /* Ja                                                */
  485.                     if (y < (MAXHOEHE-hoehe))    /* noch in Grenzen ?                */
  486.                         y++;                                        /* ja, dann addiere                    */
  487.                 }
  488.                 else                                                /* also Y ab                                */
  489.                     if (y > MINYRAND)                    /* noch in Grenzen ?                */
  490.                         y--;                                        /* ja, dann subtrahiere            */
  491.                 convert(rp,y,&ITHc5);                /* konvertiere und schreibe    */
  492.                 break;                                            /* von vorne                                */
  493.             case GBU:
  494.             case GBD:                                            /* Breite wurde gedrückt        */
  495.                         if (gadmess->GadgetID == GBU)
  496.                                                                         /* Breite auf ?                            */
  497.                             {                                            /* Ja                                                */
  498.                                 if (breite < (MAXBREITE-x))
  499.                                                                         /* noch in Grenzen ?                */
  500.                                     breite++;                    /* ja, dann addiere                    */
  501.                             }
  502.                         else                                        /* also Breite ab                        */
  503.                             if (breite > MINBREITE)
  504.                                                                         /* noch in Grenzen ?                */
  505.                                 breite--;                        /* ja, dann subtrahiere            */
  506.                         convert(rp,breite,&ITHc6);
  507.                                                                         /* konvertiere und schreibe    */
  508.                         break;                                    /* von vorne                                */
  509.                     case GHU:
  510.                     case GHD:                                    /* Höhe wurde gedrückt            */
  511.                         if (gadmess->GadgetID == GHU)
  512.                                                                         /* Höhe auf ?                                */
  513.                             {                                            /* ja                                                */
  514.                                 if (hoehe < (MAXHOEHE-y))
  515.                                                                         /* noch in Grenzen ?                */
  516.                                     hoehe++;                    /* ja, dann addiere                    */
  517.                             }
  518.                         else                                        /* also Höhe ab                            */
  519.                                 if (hoehe > MINHOEHE)
  520.                                                                         /* noch in Grenzen ?                */
  521.                                     hoehe--;                    /* ja, dann subtrahiere            */
  522.                         convert(rp,hoehe,&ITHc7);
  523.                                                                         /* konvertiere und schreibe    */
  524.                         break;                                    /* von vorne                                */
  525.                     case GP:                                    /* Print wurde gedrückt            */
  526.                         loop=FALSE;                            /* setze ende loop                    */
  527.                         break;                                    /* von vorne                                */
  528.                     case GC:                                    /* Cancel wurde gedrückt        */
  529.                         closeHc();
  530.                         return(TRUE);                        /* verlasse Hardcopy ohne        */
  531.                         break;                                    /* Fehler                                        */
  532.                     case GR:                                    /* Reverse wurde gedrückt        */
  533.                         reverse = reverse^TRUE;    /* switch reverse                        */
  534.                         break;                                    /* von vorne                                */
  535.                 }                                                        /* ende von switch                    */
  536.         }                                                                /* ende von loop                        */
  537.  
  538.     CloseWindow(Hc);                                    /* Hardcopy schliessen            */
  539.  
  540.     Hc = MakeWindow(HRX,HRY,HRXh,HRYh," Hardcopy ",Sc);
  541.                                                                         /* Öffne Requestwindow            */
  542.     if (Hc == NULL)                                        /* Fehler ?                                    */
  543.     {                                                                    /* Hc = NULL                                */
  544.         closeHc();                                            /* alles schliessen                    */
  545.         return(FALSE);                                    /* Return mit Fehler                */
  546.     }
  547.     rp = Hc->RPort;                                        /* Hardcopy RastPort holen    */
  548.     PrintText(rp,"Bitte warten, Hardcopy in Arbeit",15,20,2);
  549.     PrintText(rp,"Close für Abbruch",15,30,2);
  550.     prefs = (struct Preferences *)
  551.                     malloc(sizeof(struct Preferences));
  552.     if ( prefs == NULL)                                /* Speicher für Preferences    */
  553.         {                                                                /* kein Speicher bekommen        */
  554.             closeHc();                                        /* alles schliessen                    */
  555.             return (FALSE);                                /* Return mit Fehler                */
  556.         }
  557.  
  558.     GetPrefs(prefs,sizeof(struct Preferences));
  559.                                                                         /* Preferences holen                */
  560.     tempd = prefs->PrintDensity;
  561.     tempi = prefs->PrintImage;
  562.     tempx = prefs->PrintXOffset;
  563.  
  564.     prefs->PrintDensity=(UBYTE)dichte;
  565.                                                                         /* Dichte setzen                        */
  566.     prefs->PrintImage=(USHORT)reverse;
  567.                                                                         /* Reverse setzen                        */
  568.     prefs->PrintXOffset=(USHORT)4*x;    /* linker Rand in 1/10"            */
  569.     SetPrefs(prefs,sizeof(struct Preferences),FALSE);
  570.                                                                         /* Preferences setzen                */
  571.     prefs->PrintDensity = tempd;            /* Dichte rücksetzen                */
  572.     prefs->PrintImage = tempi;                /* Reverse rücksetzen                */
  573.     prefs->PrintXOffset = tempx;            /* linker Rand rücksetzen        */
  574.     port = (struct MsgPort *)CreatePort("Printer.Port",NULL);
  575.                                                                         /* Drucker-Port öffnen            */
  576.     if(port == NULL)                                    /* Port bekommen ?                    */
  577.     {                                                                    /* Nein                                            */
  578.         closeHc();                                            /* alles schliessen                    */
  579.         return(FALSE);                                    /* Return mit Fehler                */
  580.     }
  581.     dump = (struct IODRPReq *)
  582.                     malloc(sizeof(struct IODRPReq));
  583.                                                                         /* Speicher Dumpstruktur        */
  584.     if (dump == NULL)                                    /* Speicher bekommen ?            */
  585.     {                                                                    /* Nein                                            */
  586.         closeHc();                                            /* alles schliessen                    */
  587.         return (FALSE);                                    /* Return mit Fehler                */
  588.     }
  589.  
  590.     error = prtcommand(port,&init[0],2);
  591.                                                                         /* Initialisiere Drucker        */
  592.     setcursor(y);                                            /* Setzte Cursor                        */
  593.  
  594.     fehler = OpenDevice("printer.device",NULL,dump,NULL);
  595.                                                                         /* Drucker-Device öffnen        */
  596.     if( fehler == NULL )                            /* Device bekommen                    */
  597.     {                                                                    /* Ja                                                */
  598.         dump->io_Message.mn_ReplyPort = port;
  599.                                                                         /* Antwort-Port zuweisen        */
  600.         dump->io_Command=PRD_DUMPRPORT;    /* Dump Command                            */
  601.         dump->io_RastPort=Rp;                        /* Dump RastPort                        */
  602.         dump->io_ColorMap=Vp->ColorMap;    /* Dump Farbtabelle                    */
  603.         dump->io_Modes=Vp->Modes;                /* Dump View Mode                        */
  604.         dump->io_DestCols=breite*394;        /* Breite in 1/1000"                */
  605.         dump->io_DestRows=hoehe*394;        /* Höhe in 1/1000"                    */
  606.         dump->io_Special=SPECIAL_MILCOLS+SPECIAL_MILROWS;
  607.                                                                         /* Angaben von Breite Höhe    */
  608.         if ( Mw != NULL )                                /* Window Dump ?                        */
  609.         {                                                                /* Ja                                                */
  610.             dump->io_SrcX=Mw->LeftEdge;        /* Start Dump X                            */
  611.             dump->io_SrcY=Mw->TopEdge+WINDOWHEADER;
  612.                                                                         /* Start Dump Y                            */
  613.             dump->io_SrcWidth=Mw->Width;    /* Ende Dump X                            */
  614.             dump->io_SrcHeight=Mw->Height-WINDOWHEADER;
  615.                                                                         /* Ende Dump Y                            */
  616.         }
  617.         else                                                        /* also Screen Dump                    */
  618.         {
  619.             dump->io_SrcX=Sc->LeftEdge;        /* Start Dump X                            */
  620.             dump->io_SrcY=Sc->TopEdge+SCREENHEADER;
  621.                                                                         /* Start Dump Y                            */
  622.             dump->io_SrcWidth=Sc->Width;    /* Ende Dump X                            */
  623.             dump->io_SrcHeight=Sc->Height-SCREENHEADER;
  624.                                                                         /* Ende Dump Y                            */
  625.         }
  626.  
  627. /****************************************************************
  628.  *                                                                                                                            *
  629.  * Bei Asynchroner Ausgabe der Hardcopy kann man diesen I/O            *
  630.  * zu einem späteren Zeitpunkt abbrechen. Dies wird in der            *
  631.  * Folge hier abgearbeitet. Zuerst wird auf beidem Ports                *
  632.  * gewartet bis etwas passiert. Wenn eine Message angekommen        *
  633.  * ist, wird entsprechend gehandelt. Bei Antwort von der                *
  634.  * Printerdevice wird diese beantwortet und die Schleife                *
  635.  * wird verlassen.                                                                                            *
  636.  * Bei Abbruch wird zuerst kontrolliert, ob die Hardcopy                *
  637.  * noch in arbeit ist. Wenn ja, so wird die Hardcopy                        *
  638.  * abbgebrochen.                                                                                                *
  639.  *                                                                                                                            *
  640.  ****************************************************************/
  641.  
  642.         fehler=SendIO(dump);                        /* Asynchrone Ausgabe                */
  643.  
  644.         loop=TRUE;                                            /* Initialisierung                    */
  645.         while ( loop )                                    /* Schleife für Hardcopy        */
  646.         {
  647.             message=(struct IntuiMessage *)
  648.                 GetMsg(Hc->UserPort);                /* Abortmessage holen                */
  649.             printmessage=(struct IODRPReq *)
  650.                 GetMsg(port);                                /* Printermessage holen            */
  651.             if (( message== NULL)&&
  652.                 (printmessage==NULL))                /* keine von beiden Message    */
  653.             {                                                            /* dann warten auf Message    */
  654.                 Wait((1L << Hc->UserPort->mp_SigBit)|
  655.                     (1L << port->mp_SigBit));
  656.                 continue;                                        /* Message erhalten, das        */
  657.             }                                                            /* ganze von vorne                    */
  658.             if ( message )                                /* Abortmessage ?                        */
  659.             {                                                            /* Ja                                                */
  660.                 ReplyMsg(message);                    /* Antworten                                */
  661.                 erfolg=CheckIO(dump);                /* Ist Hardcopy noch da ?        */
  662.                 if ( erfolg == NULL )                /* Ja                                                */
  663.                     AbortIO(dump);                        /* Abbrechen                                */
  664.             }
  665.             if ( printmessage )                        /* Printermessage ?                    */
  666.             {                                                            /* Ja                                                */
  667.                 ReplyMsg(printmessage);            /* Antworten                                */
  668.                 loop=FALSE;                                    /* Schleifenexit setzen            */
  669.             }
  670.         }
  671.         CloseDevice(dump);                            /* Device freigeben                    */
  672.     }
  673.     closeHc();                                                /* alles schliessen                    */
  674.     if (fehler)                                                /* Fehler von SendIO                */
  675.         return ( FALSE );                                /* Return mit Fehler                */
  676.     else                                                            /* kein Fehler                            */
  677.         return(TRUE);                                        /* alles OK!                                */
  678. }
  679.  
  680.