home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 449a.lha / Plotter / src / Plot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-02  |  20.6 KB  |  615 lines
  1.  /********************************************************************/
  2.  /****                                                            ****/
  3.  /****                                                            ****/
  4.  /****    Program          : C-Plot.c                             ****/
  5.  /****                                                            ****/
  6.  /****    Version          :    03.71                             ****/
  7.  /****                                                            ****/
  8.  /****    Erstversion      : 14.08.1988                           ****/
  9.  /****                                                            ****/
  10.  /****    Letzte Änderung  : 09.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.  /* Einbinden der Include-Files */
  25.  
  26.  #ifdef DEBUG
  27.  #include <exec/types.h>
  28.  #include <proto/tool.h>
  29.  #include "Plotter.h"
  30.  #endif
  31.  #include <string.h>
  32.  #include <devices/printer.h>
  33.  #include <intuition/intuitionbase.h>
  34.  #include <graphics/regions.h>
  35.  #include <proto/mathieeedoubbas.h>
  36.  #include <proto/mathieeedoubtrans.h>
  37.  #include <proto/layers.h>
  38.  #include <math.h>
  39.  #include <stdio.h>
  40.  #include <string.h>
  41.  #include <stdlib.h>
  42.  #include <exec/memory.h>
  43.  #include <exec/tasks.h>
  44.  #include <libraries/dosextens.h>
  45.  #include <dos.h>
  46.  
  47.  
  48.  /* Variablendeklaration */
  49.  BOOL KoordinatenKreuz_gezeichnet; /* Gibt an, ob Koordinatenkreuz neu gezeichnet werden muß   */
  50.  int GE=1;                         /* Für die Genauigkeit der Zeichnung                        */
  51.  int Groesse;
  52.  
  53.  APTR                  Konstantenstart; /* Zeiger auf die Konstanten  */
  54.  struct Block          *StartBlock;     /* Zeiger auf ersten Block    */
  55.  struct LayersBase     *LayersBase;
  56.  struct ViewPort       *viep;           /* Zeiger auf ViewPort        */
  57.  struct IntuitionBase  *IntuitionBase;  /* Zeiger auf IntuitionBase   */
  58.  struct ToolBase       *ToolBase;
  59.  struct Library        *MathIeeeDoubTransBase;
  60.  struct Window         *Window;         /* Zeiger auf Fenster         */
  61.  struct RastPort       *RastPort;       /* Zeiger auf RastPort        */
  62.  struct Screen         *Screen;         /* Zeiger auf Screen          */
  63.  struct GfxBase        *GfxBase;        /* Zeiger auf Grafik-Library  */
  64.  struct View           *View;
  65.  struct BitMap         bitmap;
  66.  struct Layer          *layer;
  67.  struct Layer_Info     *layerinfo;
  68.  struct info           msgInfo;
  69.  
  70.  /* Strings */
  71.  UBYTE undo1[20];                              /* Für Gadget, Intervall und Konstanten */
  72.  UBYTE undoFormel[MAXCHARS];                   /* Für Gadget, Formeleingabe            */
  73.  UBYTE xmpstring[20], xmnstring[20];           /* Strings für Intervall                */
  74.  UBYTE ympstring[20], ymnstring[20];           /* Strings für Intervall                */
  75.  UBYTE KonAString[20],KonBString[20];          /* Strings für Konstanten               */
  76.  UBYTE KonCString[20],KonDString[20];          /* Strings für Konstanten               */
  77.  UBYTE Formeln[11][MAXCHARS];                  /* Strings für Formeln                  */
  78.  UBYTE Abgeleitet[2][MAXCHARS];                /* Strings für 1. und 2. Ableitung      */
  79.  char  SubMenuTitle[10][16];                   /* Die Strings für die 10 SubItems      */
  80.  
  81.  SHORT XOffset,YOffset;
  82.  
  83.  /* Variablen, in denen wichtige Werte gespeichert werden                              */
  84.  LONG   xx=609,yy=PLOT_Y;                         /* Punkte in x/y-Richtung               */
  85.  double xmp,xmn,ymp,ymn;                       /* Intervallgrenzen                     */
  86.  double x0,y0;                                 /* Position der Achsen                  */
  87.  double xm,ym;                                 /* Maßstab für x/y-Achse                */
  88.  
  89.  /* Daten für Screen und Window */
  90.  
  91.  struct NewScreen Schirm=
  92.   {
  93.    0,0,640,YSCREEN,2,2,1,HIRES,CUSTOMSCREEN,NULL,"Plotter",NULL,NULL
  94.   };
  95.  
  96.  struct NewWindow Fenster=
  97.   {
  98.    0,10,640,YSCREEN-10,FARBE0,FARBE1,MENUPICK|MOUSEBUTTONS|RAWKEY,
  99.    BORDERLESS|ACTIVATE|REPORTMOUSE|SUPER_BITMAP,
  100.    NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
  101.    CUSTOMSCREEN
  102.   };
  103.  
  104.  /* Hauptprogramm */
  105.  
  106.  VOID _main()
  107.   {
  108.    /* Einige Formeln vorschlagen */
  109.    strcpy(Formeln[0],"sin(x)");
  110.    strcpy(Formeln[1],"cos(x)");
  111.    strcpy(Formeln[2],"tan(x)");
  112.    strcpy(Formeln[3],"x^2");
  113.    strcpy(Formeln[4],"x^3");
  114.    strcpy(Formeln[5],"5*x");
  115.    strcpy(Formeln[6],"x");
  116.    strcpy(Formeln[7],"sqr(x)");
  117.    strcpy(Formeln[8],"ln(x)");
  118.    strcpy(Formeln[9],"log(x)");
  119.    
  120.    /* Intervall vorschlagen */
  121.    strcpy(xmpstring,"pi");
  122.    strcpy(xmnstring,"-pi");
  123.    ympstring[0]='1';         /* global, NULL ist schon gesetzt */
  124.    ymnstring[0]='-';
  125.    ymnstring[1]='1';
  126.    
  127.    /* Konstanten vorschlagen */
  128.    strcpy(KonAString,"-pi");
  129.    strcpy(KonBString,"-pi");
  130.    strcpy(KonCString,"-pi");
  131.    strcpy(KonDString,"-pi");
  132.    
  133.    if(oeffne())                 /* Öffnen der Libraries, Screen, Fenster      */
  134.     {
  135.      LoadRGB4(viep,Farb2,4L);   /* Farben setzen                              */
  136.      UpdateMenuText();          /* SubMenuText erneuern                       */
  137.      UmwandlungInIntervall();   /* Intervallstrings in double umwandeln       */
  138.      UmwandlungInKonstanten();  /* Konstantenstrings in double umwandeln      */
  139.      MenuWahl();                /* Verwertet die Intuition-Messages           */
  140.     }
  141.    ende();                      /* Gibt den belegten Speicher wieder frei     */
  142.   }
  143.  
  144.  
  145.  /* Routine, die Punkt setzt. Parameter DOUBLE */
  146.  VOID Pset(DOUBLE x1,DOUBLE y1)
  147.   {
  148.    Move(RastPort,Fix(Add(x1,RUNDEN))+Abstand,Fix(Add(y1,RUNDEN))+Abstand);
  149.    Draw(RastPort,Fix(Add(x1,RUNDEN))+Abstand,Fix(Add(y1,RUNDEN))+Abstand);
  150.   }
  151.  
  152.  /* Routine, die Linie zieht. Parameter DOUBLE */
  153.  VOID DrawTo(DOUBLE x1,DOUBLE y1)
  154.   {
  155.    Draw(RastPort,Fix(Add(x1,RUNDEN))+Abstand,Fix(Add(y1,RUNDEN))+Abstand);
  156.   }
  157.  
  158.  /* Zeichnet Linie von (x1,y1) - (x2,y2) Parameter : DOUBLE  */
  159.  VOID Line(DOUBLE x1,DOUBLE y1,DOUBLE x2,DOUBLE y2)
  160.   {
  161.    /* Zum Anfang bewegen und Linie ziehen */
  162.    Move(RastPort,Fix(Add(x1,RUNDEN))+Abstand,Fix(Add(y1,RUNDEN))+Abstand);
  163.    Draw(RastPort,Fix(Add(x2,RUNDEN))+Abstand,Fix(Add(y2,RUNDEN))+Abstand);
  164.   }
  165.  
  166.  /* Routine zum Beschriften des Koordinatenkreuzes */
  167.  VOID zeichne(VOID)
  168.   {
  169.    char buffer[11];
  170.    double i,dx,dy,x,y;
  171.    char Zaehler;
  172.    long xx,yy;
  173.    
  174.    SetDrMd(RastPort,JAM1);
  175.    /* Bestimmt Abstand zwischen 2 Skalenunterteilungen */
  176.    dx=Div(Sub(xmp,xmn),10.0);
  177.    dy=Div(Sub(ymp,ymn),10.0);
  178.    
  179.    /* Zeichnet Unterteilung der Achsen */
  180.    i=Sub(xmn,dx);
  181.    yy=Fix(y0)+Abstand+12;
  182.    for(Zaehler=0;Zaehler<=10;Zaehler++)
  183.     {
  184.      i=Add(i,dx);
  185.      if(Cmp(Abs(i),Div(dx,1000.0))==-1)i=0.0000;
  186.      x=Add(x0,Mul(i,xm));
  187.      Line(x,Sub(y0,3.0),x,Add(y0,3.0));
  188.      UmwFtoS(buffer,&i,2);
  189.      xx=Fix(x)-(strlen(buffer)<<2)+Abstand;
  190.      Print(RastPort,buffer,FARBE1,xx,yy);
  191.     }
  192.    
  193.    
  194.    i=Sub(ymn,dy);
  195.    xx=Fix(x0)+Abstand+8;
  196.    for(Zaehler=0;Zaehler<=10;Zaehler++)
  197.     {
  198.      i=Add(i,dy);
  199.      if(Cmp(Abs(i),Div(dy,1000.0))==-1)i=0.0000;
  200.      y=Sub(y0,Mul(i,ym));
  201.      Line(Sub(x0,5.0),y,Add(x0,5.0),y);
  202.      UmwFtoS(buffer,&i,2);
  203.      yy=Fix(y)+Abstand+3;
  204.      Print(RastPort,buffer,FARBE1,xx,yy);
  205.     }
  206.   }
  207.  
  208.  
  209.  /* Wertet Mausklick aus */
  210.  VOID MenuWahl(VOID)
  211.   {
  212.    struct MenuItem *Item;
  213.    long menu,item;
  214.    char ENDE=1;
  215.    USHORT sub,menunr;
  216.    
  217.    while(ENDE)
  218.     {
  219.      /* Wartet auf Event */
  220.      Wait(1L<<Window->UserPort->mp_SigBit);
  221.      /* Arbeitet ab, bis keine Events mehr */
  222.      while(EventAbfrage(Window,&msgInfo))
  223.       {
  224.        /* Verzweigt entsprechend der Events */
  225.        switch(msgInfo.NachrichtenArt)
  226.         {
  227.          /* Menupunkt gewählt */
  228.          case MENUPICK:
  229.           {
  230.            menunr=msgInfo.code;
  231.            
  232.            /* Wurde wirklich ein Menu gewählt ? */
  233.            while(menunr!=MENUNULL)
  234.             {
  235.              /* Wenn ja, dann Menu-, Item- und SubItemNummer bestimmen */
  236.              menu=MENUNUM(menunr);
  237.              item=ITEMNUM(menunr);
  238.              sub =SUBNUM (menunr);
  239.              /* Entsprechend des Menus verzweigen */
  240.              switch (menu)
  241.               {
  242.                case 0:
  243.                 {
  244.                  /* Ein Punkt des ersten Menus wurde gewählt */
  245.                  switch(item)
  246.                   {
  247.                    /* Entsprechend des Items verzweigen */
  248.                    case 0:
  249.                     {
  250.                      /* Bestimmung der neuen Zeichengenauigkeit */
  251.                      GE=sub;
  252.                      break;
  253.                     }
  254.                    case 1:
  255.                     {
  256.                      /* Eingabe eines neuen Intervall */
  257.                      do
  258.                       {
  259.                        TextFuerIntervall();     /* Gadget vorbereiten      */
  260.                        /* */                    /* Grenzen abfragen        */
  261.                        Grenzen(xmnstring,ymnstring,xmpstring,ympstring);
  262.                        UmwandlungInIntervall(); /* Werte kopieren          */
  263.                       }
  264.                      while(Cmp(xmn,xmp)==1 || Cmp(ymn,ymp)==1);
  265.                     }
  266.                    case 2:
  267.                     {
  268.                      /* Schirm löschen */
  269.                      /* Loeschen();    */
  270.                      goto Einsprung_P2;
  271.                     }
  272.                    case 3:
  273.                     {
  274.                      /* Routine zum Drucken */
  275.                      drucken();
  276.                      /* Farben wieder zurücksetzen */
  277.                      LoadRGB4(viep,Farb2,4L);
  278.                      break;
  279.                     }
  280.                    case 4:
  281.                     {
  282.                      ULONG OldIDCMP;
  283.                      if(KoordinatenKreuz_gezeichnet)
  284.                       {
  285.                        OldIDCMP=Window->IDCMPFlags;
  286.                        ModifyIDCMP(Window,MOUSEMOVE|MOUSEBUTTONS);
  287.                        
  288.                        /* */                            /* Bereich mit Maus auswählen */
  289.                        AusSchnitt(&xmn,&ymn,&xmp,&ymp); /* Funktion aufrufen          */
  290.                        ModifyIDCMP(Window,OldIDCMP);
  291.                        Einsprung_P2:
  292.                        Loeschen();
  293.                       }
  294.                      break;
  295.                     }
  296.                    case 5:
  297.                     {
  298.                      /* Eingabe der Werte für die Konstanten               */
  299.                      TextFuerKonstanten();     /* Gadget vorbereiten       */
  300.                      /* */                     /* Werte vom Anwender holen */
  301.                      Grenzen(KonAString,KonCString,KonBString,KonDString);
  302.                      UmwandlungInKonstanten(); /* Werte kopieren           */
  303.                      break;
  304.                     }
  305.                    case 6:
  306.                     {
  307.                      /* About */
  308.                      Einsprung_P3:
  309.                      About();
  310.                      break;
  311.                     }
  312.                    case 7:
  313.                     {
  314.                      /* Beenden des Programms */
  315.                      ENDE=1-request(PLOT_END,PLOT_CONT,PLOT_QUEST);
  316.                     }
  317.                   }
  318.                  break;
  319.                 }
  320.                case 1:
  321.                 {
  322.                  /* Das nullte Menu wurde gewählt      */
  323.                  switch (item)
  324.                   {
  325.                    /* Entsprechend des Items verzweigen */
  326.                    case 7:
  327.                     {
  328.                      Full_Discussion(sub);
  329.                      goto Einsprung_P3;
  330.                     }
  331.                    case 0:
  332.                     {
  333.                      /* Funktionsterm ändern */
  334.                      do
  335.                       {
  336.                        Funktionseingabe(Formeln[sub]); /* Holen der neuen Vorschrift */
  337.                       }
  338.                      while(AnzahlKlammern((char *)Formeln[sub]));
  339.                      UpdateMenuText();                 /* SubItemText erneuern       */
  340.                      break;
  341.                     }
  342.                    case 1:
  343.                    case 2:
  344.                    case 3:
  345.                     {
  346.                      /* Entsprechend dem SubItem zeichnen   */
  347.                      ZeichneFunktion(sub,(int)item-1);
  348.                      break;
  349.                     }
  350.                    /* Item 4 ist ---------- */
  351.                    case 5:
  352.                     {
  353.                      /* 1. Abl. symbolisch */
  354.                      /* Entsprechend dem SubItem zeichnen   */
  355.                      strcpy(Formeln[10],Ableiten(Formeln[sub]));
  356.                      goto Einsprung_P1;
  357.                     }
  358.                    case 6:
  359.                     {
  360.                      /* 2. Abl. symbolisch */
  361.                      strcpy(Formeln[10],Ableiten(Formeln[sub]));
  362.                      strcpy(Formeln[10],Ableiten(Formeln[10]));
  363.                      Einsprung_P1:
  364.                      ZeichneFunktion(10,0);
  365.                     }
  366.                   }
  367.                  break;
  368.                 }
  369.                case 2:
  370.                 {
  371.                  switch(item)
  372.                   {
  373.                    case 1:
  374.                     {
  375.                      Groesse=GROSS;
  376.                      xx=969; /* Definiert, wie viele Punkte für Grafik */
  377.                      yy=257; /* genutzt werden sollen                  */
  378.                      break;
  379.                     }
  380.                    case 0:
  381.                     {
  382.                      Groesse=KLEIN;
  383.                      xx=609; /* Definiert, wie viele Punkte für Grafik */
  384.                      yy=PLOT_Y; /* genutzt werden sollen                  */
  385.                     }
  386.                   }
  387.                  goto Einsprung_P2;
  388.                 }
  389.               }
  390.              Item=ItemAddress(Menu,(LONG)menunr);
  391.              menunr=Item->NextSelect;
  392.              Item->NextSelect=MENUNULL;
  393.             }
  394.           }
  395.          case RAWKEY:
  396.           {
  397.            if(Groesse)
  398.             {
  399.              TastaturAbfrage();
  400.             }
  401.           }
  402.         }
  403.       }
  404.     }
  405.   }
  406.  
  407.  
  408.  /* Öffnet Libraries, Screen, Window */
  409.  int oeffne()
  410.   {
  411.    int Failed=0;
  412.    if((ToolBase=(struct ToolBase *)OpenLibrary("tool.library",0)))
  413.     {
  414.      IntuitionBase=ToolBase->IntuitionBase;
  415.      GfxBase=ToolBase->GfxBase;
  416.      MathIeeeDoubTransBase=ToolBase->MathIeeeDoubTransBase;
  417.      MathIeeeDoubBasBase=ToolBase->MathIeeeDoubBasBase;
  418.      if(Konstantenstart=Init_Konst())
  419.       {
  420.        if((LayersBase = (struct LayersBase *)OpenLibrary("layers.library",0)))
  421.         {
  422.          if((Screen=(struct Screen *)OpenScreen(&Schirm)))
  423.           {
  424.            InitBitMap(&bitmap,2,1000,MAXPIXELY);
  425.            
  426.            if((bitmap.Planes[0]=AllocRaster(1000,MAXPIXELY)))
  427.             {
  428.              Delay(5);
  429.              if((bitmap.Planes[1]=AllocRaster(1000,MAXPIXELY)))
  430.               {
  431.                Fenster.Screen=Screen; /* Fenster soll auf Screen erscheinen */
  432.                Fenster.BitMap=&bitmap;
  433.                if((Window=(struct Window *)OpenWindow(&Fenster)))
  434.                 {
  435.                          /* Zuweisung von Variablen, Einfärben des Windows */
  436.                  
  437.                  
  438.                  MakeMenu();                        /* Menustrukturen erzeugen     */
  439.                  NewSetMenuStrip(Window,Menu);      /* Menus verknüpfen            */
  440.                  
  441.                  viep=&Screen->ViewPort;            /* ViewPort-Zeiger füllen      */
  442.                  RastPort=Window->RPort;            /* Variablenzuweisung          */
  443.                  layer=RastPort->Layer;             /* LayerPointer holen          */
  444.                  layerinfo=layer->LayerInfo;        /* LayerInfo    holen          */
  445.                  SetRast(RastPort,FARBE0);          /* Schirm löschen              */
  446.                  
  447.                  Fenster2.Screen=Screen;            /* Fenster2 auch auf Screen    */
  448.                  Fenster3.Screen=Screen;            /* Fenster3 auch auf Screen    */
  449.                  Failed=1;                          /* Nur wenn alles geklappt hat */
  450.                 }
  451.               }
  452.             }
  453.           }
  454.         }
  455.       }
  456.     }
  457.    return(Failed);
  458.   }
  459.  
  460.  
  461.  /* Routine, die alles wieder schließt */
  462.  VOID ende(VOID)
  463.   {
  464.    LONG H;
  465.    Delay(20);
  466.    if(Konstantenstart)Free_Konst(Konstantenstart);
  467.    
  468.    /* Wenn offen -> schließen */
  469.    if(Window)
  470.     {
  471.      while(H=EventAbfrage(Window,&msgInfo));
  472.      ReMakeMenu(Window);
  473.      CloseWindow(Window);
  474.     };
  475.    if(bitmap.Planes[0])
  476.     {
  477.      FreeRaster(bitmap.Planes[0],1000,MAXPIXELY);
  478.      bitmap.Planes[0]=0;
  479.     }
  480.    if(bitmap.Planes[1])
  481.     {
  482.      FreeRaster(bitmap.Planes[1],1000,MAXPIXELY);
  483.      bitmap.Planes[1]=0;
  484.     }
  485.    if(Screen)CloseScreen(Screen);
  486.    
  487.    /* Schließt auch automatisch IntuitionBase etc. */
  488.    if(ToolBase)CloseLibrary((struct Library *)ToolBase);
  489.    
  490.    if(LayersBase)CloseLibrary((struct Library *)LayersBase);
  491.   }
  492.  
  493.  /* Für Intervall */
  494.  VOID UmwandlungInIntervall(VOID)
  495.   {
  496.    /* Sollte nicht benutzt werden, darum ruhig undefinierter Wert */
  497.    berechnen(&xmp,xmpstring,&x0,(struct Konstanten *)Konstantenstart,&MatheFehler);
  498.    berechnen(&xmn,xmnstring,&x0,(struct Konstanten *)Konstantenstart,&MatheFehler);
  499.    berechnen(&ymp,ympstring,&x0,(struct Konstanten *)Konstantenstart,&MatheFehler);
  500.    berechnen(&ymn,ymnstring,&x0,(struct Konstanten *)Konstantenstart,&MatheFehler);
  501.   }
  502.  
  503.  /* Für Konstanten */
  504.  VOID UmwandlungInKonstanten(VOID)
  505.   {
  506.    /* Eine Konstante darf nicht aus dem Wert einer anderen Konstanten bestehen */
  507.    /* Also nicht A=1+B, da B zum Zeitpunkt der Bestimmung von A nicht unbe-    */
  508.    /* dingt den richtigen Wert haben muß.                                      */
  509.    /* Es ist zwar prinzipiell möglich, aber man sollte keine Rekursionen be-   */
  510.    /* nutzen, wie a=d+1 und d=a*10                                             */
  511.    DOUBLE var;
  512.    
  513.    berechnen(&var,KonAString,&var,(struct Konstanten *)Konstantenstart,&MatheFehler);
  514.    Set_Konst_P(Konstantenstart,1,&var);
  515.    berechnen(&var,KonBString,&var,(struct Konstanten *)Konstantenstart,&MatheFehler);
  516.    Set_Konst_P(Konstantenstart,2,&var);
  517.    berechnen(&var,KonCString,&var,(struct Konstanten *)Konstantenstart,&MatheFehler);
  518.    Set_Konst_P(Konstantenstart,3,&var);
  519.    berechnen(&var,KonDString,&var,(struct Konstanten *)Konstantenstart,&MatheFehler);
  520.    Set_Konst_P(Konstantenstart,4,&var);
  521.   }
  522.  
  523.  /* Erneuert SubMenuTexte */
  524.  VOID UpdateMenuText(VOID)
  525.   {
  526.    /* Füllt die SubMenuTitel mit den aktuellen Funktionsdefinitionen */
  527.    USHORT i;
  528.    ClearMenuStrip(Window);                        /* Menuverknüpfung aufheben  */
  529.    for(i=0;i<=9;i++)
  530.     {
  531.      left(SubMenuTitle[i],Formeln[i],14L);        /* Ans Ziel kopieren         */
  532.     }
  533.    SetMenuStrip(Window,Menu);                     /* Wieder verknüpfen         */
  534.   }
  535.  
  536.  VOID SetRXOffset(VOID)
  537.   {
  538.    LONG dx,dy;
  539.    
  540.    if(YOffset<0)YOffset=0;
  541.    if(XOffset<0)XOffset=0;
  542.    
  543.    if(YOffset>(MAXPIXELY-YSCREEN))YOffset=MAXPIXELY-YSCREEN;
  544.    if(XOffset>(1000-640))XOffset=1000-640;
  545.    
  546.    dx=XOffset-(layer->Scroll_X);
  547.    dy=YOffset-(layer->Scroll_Y);
  548.    /* Mit der Abfrage geht es schneller. Auch ein ScrollLayer(..,..,0,0) */
  549.    /* braucht relativ viel Zeit.                                         */
  550.    if(dx||dy)ScrollLayer(layerinfo,layer,dx,dy);
  551.   }
  552.  
  553.  VOID TastaturAbfrage(VOID)
  554.   {
  555.    static short add=1;
  556.    switch(msgInfo.code)
  557.     {
  558.      case 69:
  559.       {
  560.        /* ESC = Ursprung */
  561.        XOffset=YOffset=0;
  562.        break;
  563.       }
  564.      case 76:
  565.       {
  566.        /* Cursor up */
  567.        YOffset-=add;
  568.        goto Einsprung;
  569.       }
  570.      case 77:
  571.       {
  572.        /* Cursor down */
  573.        YOffset+=add;
  574.        goto Einsprung;
  575.       }
  576.      case 78:
  577.       {
  578.        /* Cursor right */
  579.        XOffset+=add;
  580.        goto Einsprung;
  581.       }
  582.      case 79:
  583.       {
  584.        /* Cursor left */
  585.        XOffset-=add;
  586.        
  587.        Einsprung:
  588.        add++;
  589.        break;
  590.       }
  591.      case 204:
  592.      case 205:
  593.      case 206:
  594.      case 207:
  595.       {
  596.        /* Damit nicht zu schnell gescrollt wird... */
  597.        add=1;
  598.       }
  599.     }
  600.    SetRXOffset();
  601.    if(add>10)add=10;
  602.   }
  603.  
  604.  VOID Loeschen(VOID)
  605.   {
  606.    SetRast(RastPort,0);
  607.    /* Koordinatenkreuz beim nächsten Mal neu zeichnen */
  608.    KoordinatenKreuz_gezeichnet=FALSE;
  609.    ScrollLayer(layerinfo,layer,(LONG)-(layer->Scroll_X),(LONG)-(layer->Scroll_Y));
  610.   }
  611.  
  612.  
  613.  
  614.  
  615.