home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 449a.lha / Plotter / src / Maus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-02  |  9.8 KB  |  392 lines
  1.  /********************************************************************/
  2.  /****                                                            ****/
  3.  /****                                                            ****/
  4.  /****    Program          : Maus.c                               ****/
  5.  /****                                                            ****/
  6.  /****    Version          :    03.71                             ****/
  7.  /****                                                            ****/
  8.  /****    Erstversion      : 14.08.1988                           ****/
  9.  /****                                                            ****/
  10.  /****    Letzte Änderung  : 05.08.1990                           ****/
  11.  /****                                                            ****/
  12.  /****    Compiliert mit   : siehe MAKEFILE                       ****/
  13.  /****                                                            ****/
  14.  /****    Gelinkt mit      : siehe MAKEFILE                       ****/
  15.  /****                                                            ****/
  16.  /********************************************************************/
  17.  /****                                                            ****/
  18.  /****                                                            ****/
  19.  /****               Copyright by Rüdiger Dreier                  ****/
  20.  /****                                                            ****/
  21.  /****                                                            ****/
  22.  /********************************************************************/
  23.  
  24.  
  25.  /* Einbinden der Includes */
  26.  
  27.  #ifdef DEBUG
  28.  #include "Plotter.h"
  29.  #include <proto/tool.h>
  30.  #endif
  31.  #include <string.h>
  32.  #include <intuition/intuitionbase.h>
  33.  #include <proto/mathieeedoubbas.h>
  34.  #include <proto/mathieeedoubtrans.h>
  35.  
  36.  
  37.  /* Variablendeklaration für Abfragefenster */
  38.  
  39.  struct RastPort *RastPort2;
  40.  struct Window   *Window2;
  41.  
  42.  UBYTE MinXText[8],MaxXText[8],MinYText[8],MaxYText[8];
  43.  
  44.  /* Definition der Umrandungen */
  45.  SHORT paare1[]=
  46.   {
  47.    -2,-2,122,-2,122,10,-2,10,-2,-2
  48.   };
  49.  SHORT paare2[]=
  50.   {
  51.    -2,-2,222,-2,222,10,-2,10,-2,-2
  52.   };
  53.  SHORT paare3[]=
  54.   {
  55.    0,0,0,9,33,9,33,0,0,0
  56.   };
  57.  struct Border Rand2=
  58.   {
  59.    0,0,FARBE2,FARBE3,JAM2,5,(SHORT *)&paare2,NULL
  60.   };
  61.  struct Border Rand=
  62.   {
  63.    0,0,FARBE2,FARBE3,JAM2,5,(SHORT *)&paare1,NULL
  64.   };
  65.  struct Border Rand1 =
  66.   {
  67.    -1,-1,FARBE2,FARBE3,JAM2,5,paare3,0
  68.   };
  69.  
  70.  /* Definition der benötigten Texte */
  71.  
  72.  struct IntuiText Bedeutung4=
  73.   {
  74.    FARBE1,FARBE0,JAM1,-65,0,NULL,MinXText,NULL
  75.   };
  76.  struct IntuiText Bedeutung3=
  77.   {
  78.    FARBE1,FARBE0,JAM1,-65,0,NULL,MaxXText,NULL
  79.   };
  80.  struct IntuiText Bedeutung2=
  81.   {
  82.    FARBE1,FARBE0,JAM1,-65,0,NULL,MinYText,NULL
  83.   };
  84.  struct IntuiText Bedeutung1=
  85.   {
  86.    FARBE1,FARBE0,JAM1,-65,0,NULL,MaxYText,NULL
  87.   };
  88.  struct IntuiText BedeutungFormel=
  89.   {
  90.    FARBE1,FARBE0,JAM1,6,-20,NULL,MAUS_ENTERFUNC,NULL
  91.   };
  92.  
  93.  /* Definitionen für TextGadgets */
  94.  
  95.  struct StringInfo TextStringFormel=
  96.   {
  97.    Abgeleitet[0],undoFormel,0,MAXCHARS,0,0,5,0,0,0,NULL,0,NULL
  98.   };
  99.  struct StringInfo TextString1=
  100.   {
  101.    NULL,undo1,0,20,0,0,5,0,0,0,NULL,0,NULL
  102.   };
  103.  struct StringInfo TextString2=
  104.   {
  105.    NULL,undo1,0,20,0,0,5,0,0,0,NULL,0,NULL
  106.   };
  107.  struct StringInfo TextString3=
  108.   {
  109.    NULL,undo1,0,20,0,0,5,0,0,0,NULL,0,NULL
  110.   };
  111.  struct StringInfo TextString4=
  112.   {
  113.    NULL,undo1,0,20,0,0,5,0,0,0,NULL,0,NULL
  114.   };
  115.  
  116.  struct IntuiText Texte=
  117.   {
  118.    FARBE2,FARBE3,JAM2,0,0,0," OK ",0
  119.   };
  120.  
  121.  /* Definitionen für Gadgets */
  122.  
  123.  struct Gadget OKgadget=
  124.   {
  125.    NULL    ,100,100,32,8,GADGHCOMP,RELVERIFY|GADGIMMEDIATE,BOOLGADGET,(APTR)&Rand1,0,&Texte,NULL,NULL,4,0
  126.   };
  127.  struct Gadget FormelGadget=
  128.   {
  129.    &OKgadget   ,10,50,220,10,GADGHCOMP,RELVERIFY|STRINGCENTER,STRGADGET,(APTR)&Rand2,0,&BedeutungFormel,0,(APTR)&TextStringFormel,NULL,0  
  130.   };
  131.  struct Gadget gadget4=
  132.   {
  133.    &OKgadget   ,70,20,120,10,GADGHCOMP,GADGIMMEDIATE|RELVERIFY|STRINGCENTER,STRGADGET,(APTR)&Rand,0,&Bedeutung4,0,(APTR)&TextString4,3,0  
  134.   };
  135.  struct Gadget gadget3=
  136.   {
  137.    &gadget4,70,35,120,10,GADGHCOMP,GADGIMMEDIATE|RELVERIFY|STRINGCENTER,STRGADGET,(APTR)&Rand,0,&Bedeutung3,0,(APTR)&TextString3,2,0  
  138.   };
  139.  struct Gadget gadget2=
  140.   {
  141.    &gadget3,70,50,120,10,GADGHCOMP,GADGIMMEDIATE|RELVERIFY|STRINGCENTER,STRGADGET,(APTR)&Rand,0,&Bedeutung2,0,(APTR)&TextString2,1,0 
  142.   };
  143.  struct Gadget gadget1=
  144.   {
  145.    &gadget2,70,65,120,10,GADGHCOMP,GADGIMMEDIATE|RELVERIFY|STRINGCENTER,STRGADGET,(APTR)&Rand,0,&Bedeutung1,0,(APTR)&TextString1,0,0 
  146.   };
  147.  
  148.  /* Definition des allg. Fensters */
  149.  
  150.  struct NewWindow Fenster2=
  151.   {
  152.    100,10,200,115,FARBE0,FARBE1,GADGETUP,ACTIVATE|WINDOWDRAG,
  153.    &gadget1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
  154.    CUSTOMSCREEN
  155.   };
  156.  
  157.  /* Routine bestimmt Ausschnitt per Maus */
  158.  VOID AusSchnitt(DOUBLE *x1,
  159.                  DOUBLE *y1,
  160.                  DOUBLE *x2,
  161.                  DOUBLE *y2)
  162.   {
  163.    long x,y,xs=0,ys=0,xe=0,ye=0;
  164.    char click=0;
  165.    
  166.    SetDrMd(RastPort,COMPLEMENT); /* DrawMode verändern */
  167.    
  168.    while(click<=1)
  169.     {
  170.      /* Wartet bis 2 mal geklickt */
  171.      Wait(1L<<Window->UserPort->mp_SigBit);
  172.      while(EventAbfrage(Window,&msgInfo))
  173.       {
  174.        /* X/YOffset gibt linke/obere Ecke des View-Ports an */
  175.        x=msgInfo.MouseX+XOffset;
  176.        y=msgInfo.MouseY+YOffset;
  177.        if(x<Abstand+1)
  178.         {
  179.          x=Abstand+1;
  180.         }
  181.        if(x>Abstand+xx)
  182.         {
  183.          x=Abstand+xx;
  184.         }
  185.        if(y<Abstand+1)
  186.         {
  187.          y=Abstand+1;
  188.         }
  189.        if(y>Abstand+yy)
  190.         {
  191.          y=Abstand+yy;
  192.         }
  193.        
  194.        switch(msgInfo.NachrichtenArt)
  195.         {
  196.          case MOUSEBUTTONS:
  197.           {
  198.            if(msgInfo.code==SELECTDOWN)
  199.             {
  200.              /* Erster Klick : Box neu zeichnen */
  201.              click=1;
  202.              xs=xe=x;
  203.              ys=ye=y;
  204.              Box(RastPort,ys,ys,xe,ye);
  205.             }
  206.            else
  207.             {
  208.              /* Zweiter Klick : Box löschen */
  209.              click=2;
  210.              Box(RastPort,xs,ys,xe,ye);
  211.              xe=x;
  212.              ye=y;
  213.             };
  214.            break;
  215.           }
  216.          case RAWKEY:
  217.           {
  218.            if(Groesse==GROSS)
  219.             {
  220.              TastaturAbfrage();
  221.             }
  222.           }
  223.          case MOUSEMOVE:
  224.           {
  225.            if (click==1)
  226.             {
  227.              /* Box löschen und an neuer Position neu zeichnen */
  228.              Box(RastPort,xs,ys,xe,ye);
  229.              xe=x;
  230.              ye=y;
  231.              Box(RastPort,xs,ys,xe,ye);
  232.             }
  233.           }
  234.         }
  235.       }
  236.     }
  237.    SetDrMd(RastPort,JAM1);
  238.    
  239.    /* Bestimmung von xmp/n und ymp/n */
  240.    if (xe>xs)
  241.     {
  242.      *x2=Flt(xe-Abstand);
  243.      *x1=Flt(xs-Abstand);
  244.     }
  245.    else
  246.     {
  247.      *x1=Flt(xe-Abstand);
  248.      *x2=Flt(xs-Abstand);
  249.     }
  250.    
  251.    if (ye<ys)
  252.     {
  253.      *y2=Flt(ye-Abstand);
  254.      *y1=Flt(ys-Abstand);
  255.     }
  256.    else
  257.     {
  258.      *y1=Flt(ye-Abstand);
  259.      *y2=Flt(ys-Abstand);
  260.     }
  261.    
  262.    *x1=Div(Sub(*x1,x0),xm);
  263.    *x2=Div(Sub(*x2,x0),xm);
  264.    *y1=Div(Add(Neg(*y1),y0),ym);
  265.    *y2=Div(Add(Neg(*y2),y0),ym);
  266.    
  267.    /* Gleiche Grenzen werden nicht angenommen */
  268.    if(!(Cmp(*x1,*x2)) || !(Cmp(*y1,*y2)))
  269.     {
  270.      UmwandlungInIntervall();
  271.     }
  272.    
  273.    /* Zahlenwerte auch in Strings speichern */
  274.    UmwFtoS(xmnstring,x1,5);
  275.    UmwFtoS(xmpstring,x2,5);
  276.    UmwFtoS(ymnstring,y1,5);
  277.    UmwFtoS(ympstring,y2,5);
  278.   }
  279.  
  280.  /* Ermittelt neues Intervall für Funktion  */
  281.  /* bzw. ermitteln neue Konstanten          */
  282.  VOID Grenzen(char *xn,
  283.               char *yn,
  284.               char *xp,
  285.               char *yp)
  286.   {
  287.    struct Gadget *GadgetPtr;
  288.    USHORT GadgetID;
  289.    
  290.    /* Strings kopieren */
  291.    TextString4.Buffer=xn;
  292.    TextString3.Buffer=xp;
  293.    TextString2.Buffer=yn;
  294.    TextString1.Buffer=yp;
  295.    
  296.    /* Zwei Routinen benutzen gleiches Fenster mit Gadgets */
  297.    Fenster2.FirstGadget=&gadget1;
  298.    Fenster2.Width =200;
  299.    
  300.    if(!(Window2=(struct Window *)OpenWindow(&Fenster2)))return;
  301.    
  302.    RastPort2=Window2->RPort;
  303.    
  304.    ActivateGadget(&gadget4,Window2,NULL); /* Direkte Eingabe ermöglichen */
  305.    
  306.    /* Endlosschleife */
  307.    FOREVER
  308.     {
  309.      Wait(1L<<Window2->UserPort->mp_SigBit);
  310.      while(EventAbfrage(Window2,&msgInfo))
  311.       {
  312.        /* Es gibt nur das Ereignis GADGETDOWN */
  313.        GadgetID=((struct Gadget *)msgInfo.IAddress)->GadgetID;
  314.        switch(GadgetID)
  315.         {
  316.          case 4:
  317.           {
  318.            CloseWindow(Window2);
  319.            return;
  320.           }
  321.          case 3:
  322.           {
  323.            GadgetPtr=&gadget3;
  324.            goto Einsprung2;
  325.           }
  326.          case 2:
  327.           {
  328.            GadgetPtr=&gadget2;
  329.            goto Einsprung2;
  330.           }
  331.          case 1:
  332.           {
  333.            GadgetPtr=&gadget1;
  334.            Einsprung2:
  335.            ActivateGadget(GadgetPtr,Window2,NULL);
  336.            break;
  337.           }
  338.          case 0:            
  339.           {
  340.            CloseWindow(Window2);
  341.            return;
  342.           }
  343.         }
  344.       }
  345.     }
  346.   }
  347.  
  348.  
  349.  /* Eingabe der neuen Funktion, alter Wert wird übergeben */
  350.  VOID __asm Funktionseingabe(register __a0 UBYTE *string)
  351.   {
  352.    /* Siehe Grenzen */
  353.    Fenster2.FirstGadget=&FormelGadget;
  354.    Fenster2.Width=240;
  355.    
  356.    strcpy(Abgeleitet[0],string); /* Wird zum Anzeigen des Strings benutzt */
  357.    if(!(Window2=(struct Window *)OpenWindow(&Fenster2)))return;
  358.    
  359.    ActivateGadget(&FormelGadget,Window2,NULL);
  360.    
  361.    Wait(1L<<Window2->UserPort->mp_SigBit);
  362.    EventAbfrage(Window2,&msgInfo);
  363.    /* Wenn <RETURN> oder Mausklich auf <OK> -> Beenden */
  364.    CloseWindow(Window2);
  365.    strcpy(string,Abgeleitet[0]);
  366.   }
  367.  
  368.  
  369.  /* Kopiert Text in die passenden Variablen, die */
  370.  /* im Fenster dann angezeigt werden.            */
  371.  
  372.  /* Für Intervalleingabe  */
  373.  VOID TextFuerIntervall()
  374.   {
  375.    strcpy(MinXText,"X-Min :");
  376.    strcpy(MinYText,"Y-Min :");
  377.    strcpy(MaxXText,"X-Max :");
  378.    strcpy(MaxYText,"Y-Max :");
  379.   }
  380.  
  381.  /* Für Konstanteneingabe */
  382.  VOID TextFuerKonstanten()
  383.   {
  384.    strcpy(MinXText,"    A :");
  385.    strcpy(MinYText,"    C :");
  386.    strcpy(MaxXText,"    B :");
  387.    strcpy(MaxYText,"    D :");
  388.   }
  389.  
  390.  
  391.  
  392.