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 / HpPlot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-18  |  10.4 KB  |  288 lines
  1. /****************************************************************
  2.  *                                                                                                                            *
  3.  * Filename : HpPlot.c                                                                                    *
  4.  *                                                                                                                            *
  5.  ****************************************************************
  6.  *                                                                                                                            *
  7.  * Comment : Alle Funktionen für die Plotfunktion.                            *
  8.  *                                                                                                                            *
  9.  *         Rev : V1.1                                                                                                *
  10.  *                                                                                                                            *
  11.  * History : V1.0 erstellen dieses Files                            24.06.89    *
  12.  *                                                                                                                            *
  13.  *         Doc :                                                                                                        *
  14.  *                                                                                                                            *
  15.  *        Bugs : keine bekannten                                                                        *
  16.  *                                                                                                                            *
  17.  *     Autor : Oesch Silvano                                                                            *
  18.  *                                                                                                                            *
  19.  *     Datum : 02.09.89                                                                                        *
  20.  *                                                                                                                            *
  21.  ****************************************************************/
  22.  
  23.  
  24. /****************************************************************
  25.  *                                                                                                                            *
  26.  * allgemeine Includedateien                                                                        *
  27.  *                                                                                                                            *
  28.  ****************************************************************/
  29.  
  30. #include <exec/types.h>
  31. #include <exec/exec.h>
  32. #include <intuition/intuition.h>
  33. #include <intuition/intuitionbase.h>
  34. #include <intuition/screens.h>
  35. #include <devices/printer.h>
  36. #include <libraries/dos.h>
  37. #include <stdlib.h>
  38. #include <string.h>
  39. #include <ctype.h>
  40. #include <stdio.h>
  41. #include <math.h>
  42. #include <Plot/PlotLib.h>
  43. #include <Plot/Plot.h>
  44. #include <libraries/reqbase.h>
  45. #include <proto/reqproto.h>
  46.  
  47. /****************************************************************
  48.  *                                                                                                                            *
  49.  * programmspezifische Includedateien                                                        *
  50.  *                                                                                                                            *
  51.  ****************************************************************/
  52.  
  53. #include "HpPlot.h"                                    /* Window und Gadget def.        */
  54.  
  55.  
  56. /****************************************************************
  57.  *                                                                                                                            *
  58.  * externe Definitionen                                                                                    *
  59.  *                                                                                                                            *
  60.  ****************************************************************/
  61.  
  62. extern struct IntuitionBase *IntuitionBase;
  63. extern struct ReqLib *ReqBase;
  64. extern struct Plot *plot;
  65.  
  66.  
  67. /****************************************************************
  68.  *                                                                                                                            *
  69.  * globale Definitionen                                                                                    *
  70.  *                                                                                                                            *
  71.  ****************************************************************/
  72.  
  73. static struct Window *Hp = NULL;        /* HpPlot Window                        */
  74.  
  75.  
  76. /****************************************************************
  77.  *                                                                                                                            *
  78.  *    Funktion : CloseHp()                                                                                *
  79.  *                                                                                                                            *
  80.  ****************************************************************
  81.  *                                                                                                                            *
  82.  *        Input : None                                                                                            *
  83.  *                                                                                                                            *
  84.  *                                                                                                                            *
  85.  *     Output : None                                                                                            *
  86.  *                                                                                                                            *
  87.  *                                                                                                                            *
  88.  ****************************************************************
  89.  *                                                                                                                            *
  90.  *    Comment : Schliesst alles offene und kehrt danach ins                *
  91.  *                        aufrufende Programm zurück.                                                *
  92.  *                                                                                                                            *
  93.  *            Rev : V1.0                                                                                            *
  94.  *                                                                                                                            *
  95.  *    History : V1.0 erstellen dieses Files                            01.06.89    *
  96.  *                                                                                                                            *
  97.  *            Doc :                                                                                                        *
  98.  *                                                                                                                            *
  99.  *         Bugs : keine bekannten                                                                        *
  100.  *                                                                                                                            *
  101.  *        Autor : Oesch Silvano                                                                            *
  102.  *                                                                                                                            *
  103.  *        Datum : 01.06.89                                                                                    *
  104.  *                                                                                                                            *
  105.  ****************************************************************/
  106.  
  107. void closeHp()
  108.     {
  109.         if ( Hp ) CloseWindow ( Hp );        /* HpPlot schliessen                */
  110.     }
  111.  
  112.  
  113. /****************************************************************
  114.  *                                                                                                                            *
  115.  * Funktion : HpPlot(Sc)                                                                                *
  116.  *                                                                                                                            *
  117.  ****************************************************************
  118.  *                                                                                                                            *
  119.  *     Input : Screenpointer                                                                            *
  120.  *                                                                                                                            *
  121.  *                     Screen -> Für Workbenchscreen = NULL                                *
  122.  *                                    -> Für Customscreen = Screenpointer                    *
  123.  *                                                                                                                            *
  124.  *    Output : Boolean                                                                                        *
  125.  *                                                                                                                            *
  126.  *                     TRUE    -> HpPlot erfolgreich                                                    *
  127.  *                     FALSE -> HpPlot nicht erfolgreich.                                    *
  128.  *                                                                                                                            *
  129.  *                                                                                                                            *
  130.  ****************************************************************
  131.  *                                                                                                                            *
  132.  * Comment :                                                                                                        *
  133.  *                                                                                                                            *
  134.  *         Rev : V1.0                                                                                                *
  135.  *                                                                                                                            *
  136.  * History : V1.0 erstellen dieses Files                            01.06.89    *
  137.  *                                                                                                                            *
  138.  *         Doc :                                                                                                        *
  139.  *                                                                                                                            *
  140.  *        Bugs : keine bekannten                                                                        *
  141.  *                                                                                                                            *
  142.  *     Autor : Oesch Silvano                                                                            *
  143.  *                                                                                                                            *
  144.  *     Datum : 01.09.89                                                                                        *
  145.  *                                                                                                                            *
  146.  ****************************************************************/
  147.  
  148. int HpPlot(Sc)                                            /* BOOLEAN als Rückgabewert    */
  149. struct Screen *Sc;
  150. {
  151.     struct IntuiMessage *message;            /* Message Strukutr                    */
  152.     struct Gadget *gadmess;                        /* Gadget Message                        */
  153.     static struct RastPort *rp;                /* HpPlot Window Rastport        */
  154.  
  155.     static int    breite = BREITE,            /* Voreinstellung Breite        */
  156.                             hoehe = HOEHE,                /* Voreinstellung Höhe            */
  157.                             x = XRAND,                        /* Voreinstellung X                    */
  158.                             y = YRAND,                        /* Voreinstellung Y                    */
  159.                             drehung = FALSE;            /* Voreinstellung Normal        */
  160.  
  161.     int loop = TRUE;                                    /* Hauptschleife Abbruch        */
  162.  
  163.     if ( Sc )                                                    /* eigener Screen ?                    */
  164.         {                                                                /* Ja                                                */
  165.             HPW.Screen = Sc;                            /* Init. Windowstruktur            */
  166.             HPW.Type = CUSTOMSCREEN;            /* natürlich eigener Typ        */
  167.         }
  168.  
  169.     Hp = (struct Window *)OpenWindow(&HPW);
  170.                                                                         /* Öffne HpPlotwindow                */
  171.     if ( Hp == NULL )                                    /* Fehler ?                                    */
  172.         {                                                                /* Hp = NULL                                */
  173.             closeHp();                                        /* alles schliessen                    */
  174.             return ( FALSE );                            /* Return mit Fehler                */
  175.         }
  176.     rp = Hp->RPort;                                        /* HpPlot RastPort holen        */
  177.     PrintIText(rp,&ITHp1,0,0);                /* Text setzen                            */
  178.     DrawBorder(rp,&BHp7,0,0);                    /* Rahmen setzen                        */
  179.  
  180.     while ( loop )                                        /* Schleife für Einstellung    */
  181.         {
  182.             message = ( struct IntuiMessage *)
  183.                 GetMsg(Hp->UserPort);                /* Message holen                        */
  184.             if ( message==NULL)                        /* keine Message                        */
  185.                 {                                                        /* dann warten auf Message    */
  186.                     Wait(1L << Hp->UserPort->mp_SigBit);
  187.                     continue;                                    /* Message erhalten, das        */
  188.                 }                                                        /* ganze von vorne                    */
  189.             gadmess = (struct Gadget *)message->IAddress;
  190.                                                                         /* kann nur Gadget sein,        */
  191.                                                                         /* also Gadgetadresse holen    */
  192.             ReplyMsg(message);                        /* antworten                                */
  193.  
  194.             switch (gadmess->GadgetID)        /* welches Gadget gedrückt    */
  195.                 {
  196.                     case GXU:                                    /* X wurde gedrückt                    */
  197.                     case GXD:
  198.                         if (gadmess->GadgetID == GXU)
  199.                                                                         /* X auf ?                                    */
  200.                             {                                            /* Ja                                                */
  201.                                 if (x < (MAXBREITE-breite))
  202.                                                                         /* noch in Grenzen ?                */
  203.                                     x++;                            /* ja, dann addiere                    */
  204.                             }
  205.                         else                                        /* also X ab                                */
  206.                             if (x > MINXRAND)            /* noch in Grenzen ?                */
  207.                                 x--;                                /* ja, dann subtrahiere            */
  208.                         convert(rp,x,&ITHp4);
  209.                                                                         /* konvertiere und schreibe    */
  210.                         break;                                    /* von vorne                                */
  211.                     case GYU:                                    /* Y wurde gedrückt                    */
  212.                     case GYD:
  213.                         if (gadmess->GadgetID == GYU)
  214.                                                                         /* Y auf ?                                    */
  215.                             {                                            /* Ja                                                */
  216.                                 if (y < (MAXHOEHE-hoehe))
  217.                                                                         /* noch in Grenzen ?                */
  218.                                     y++;                            /* ja, dann addiere                    */
  219.                             }
  220.                         else                                        /* also Y ab                                */
  221.                             if (y > MINYRAND)            /* noch in Grenzen ?                */
  222.                                 y--;                                /* ja, dann subtrahiere            */
  223.                         convert(rp,y,&ITHp5);
  224.                                                                         /* konvertiere und schreibe    */
  225.                         break;                                    /* von vorne                                */
  226.                     case GBU:
  227.                     case GBD:                                    /* Breite wurde gedrückt        */
  228.                         if (gadmess->GadgetID == GBU)
  229.                                                                         /* Breite auf ?                            */
  230.                             {                                            /* Ja                                                */
  231.                                 if (breite < (MAXBREITE-x))
  232.                                                                         /* noch in Grenzen ?                */
  233.                                     breite++;                    /* ja, dann addiere                    */
  234.                             }
  235.                         else                                        /* also Breite ab                        */
  236.                             if (breite > MINBREITE)
  237.                                                                         /* noch in Grenzen ?                */
  238.                                 breite--;                        /* ja, dann subtrahiere            */
  239.                         convert(rp,breite,&ITHp6);
  240.                                                                         /* konvertiere und schreibe    */
  241.                         break;                                    /* von vorne                                */
  242.                     case GHU:
  243.                     case GHD:                                    /* Höhe wurde gedrückt            */
  244.                         if (gadmess->GadgetID == GHU)
  245.                                                                         /* Höhe auf ?                                */
  246.                             {                                            /* ja                                                */
  247.                                 if (hoehe < (MAXHOEHE-y))
  248.                                                                         /* noch in Grenzen ?                */
  249.                                     hoehe++;                    /* ja, dann addiere                    */
  250.                             }
  251.                         else                                        /* also Höhe ab                            */
  252.                                 if (hoehe > MINHOEHE)
  253.                                                                         /* noch in Grenzen ?                */
  254.                                     hoehe--;                    /* ja, dann subtrahiere            */
  255.                         convert(rp,hoehe,&ITHp7);
  256.                                                                         /* konvertiere und schreibe    */
  257.                         break;                                    /* von vorne                                */
  258.                     case GP:                                    /* Print wurde gedrückt            */
  259.                         loop=FALSE;                            /* setze ende loop                    */
  260.                         break;                                    /* von vorne                                */
  261.                     case GC:                                    /* Cancel wurde gedrückt        */
  262.                         closeHp();
  263.                         return(TRUE);                        /* verlasse HpPlot ohne            */
  264.                         break;                                    /* Fehler                                        */
  265.                     case GR:                                    /* drehung wurde gedrückt        */
  266.                         drehung ^= TRUE;                /* switch drehung                        */
  267.                         break;
  268.                     default:
  269.                         break;                                    /* von vorne                                */
  270.                 }                                                        /* ende von switch                    */
  271.         }                                                                /* ende von loop                        */
  272.  
  273.     CloseWindow ( Hp );                                /* HpPlot schliessen                */
  274.  
  275.     if (drehung)
  276.         drehung = ROTATE;
  277.     else
  278.         drehung = NULL;
  279.  
  280.     loop = set_plotsize(x,y,breite,hoehe,drehung,GHpSIB1);
  281.     if (loop)
  282.         return(display(PLOTOUT,GRAPHSET));
  283.     else 
  284.         return(loop);
  285.                                                                         /* alles OK!                                */
  286. }
  287.  
  288.