home *** CD-ROM | disk | FTP | other *** search
/ CD Direkt 1995 #1 / Image.iso / cdd / winanw / condor / vardemoc.c < prev    next >
Encoding:
C/C++ Source or Header  |  2004-01-31  |  24.2 KB  |  526 lines
  1.  
  2. #include <windows.h>            /* die allgemeinen Windows Definitionen */
  3.  
  4. #include <string.h>
  5. #include <math.h>
  6. #include "cndvarob.h"           /* von CONDOR exportierte Typen und Funktionen */
  7.  
  8. #define pi 3.14159265358
  9.  
  10. /* Prototypen deklarationen */
  11. void far pascal wep (int);
  12. int  far pascal varobjinit(long);
  13. int far pascal defparameter(long link, int id);
  14. int far pascal paraminit(long link, int id, Parameter *parblock);
  15. int far pascal paramchange(long link, int id, Parameter *parblock,
  16.                            int sit, GeoPoint *hsp);
  17. int far pascal defhotspots(long link, int id, Parameter *parblock);
  18. int far pascal enumgeo(long link, int id, Parameter *parblock, int sit);
  19. int far pascal defsnappoints(long link, int id, Parameter *parblock);
  20.  
  21. /* die minimale libmain Funktion, die main() Funktion der DLL. Diese Funktion
  22.    wird beim Laden der DLL aufgerufen und kann beliebige Initialisierungen
  23.    beinhalten */
  24.  
  25. int far pascal libmain(HANDLE hinstance, WORD wdataseg, WORD cbheapsize, LPSTR lpcmdline)
  26. {
  27.    if (cbheapsize!=0) UnlockData(0);
  28.    return(1);
  29. }
  30.  
  31. /* die minimale WEP Funktion, die beim verlassen der DLL aufgerufen wird */
  32. void far pascal wep (int nparameter)
  33. {
  34.    return; }
  35.  
  36.  
  37. /* hier beginnen die Definitionen der Funktionen fⁿr die variablen Elemente */
  38.  
  39. int far pascal varobjinit(long link)
  40. /* Die Initialisierung. In dieser Funktion mⁿssen die Namen der variablen
  41.    Elemente aufgezΣhlt werden. CONDOR ruft diese Funktion nur ein einziges
  42.    Mal pro Sitzung auf. Sie kann also auch zur Initialisierung von Variablen
  43.    verwendet werden*/
  44. {
  45.    CndDefVarObj(link,"gleichseitiges Dreieck",1,VO_MOVE | VO_ROTATE | VO_SIZE | VO_REFLECT | VO_DLG,
  46.                             VO_HOTSPOT);
  47.    /* das erste variable Element ist ein gleichseitiges Dreieck, das mit den
  48.       Modifikationen Verschieben, Drehen, Gr÷▀e Σndern und Spiegeln
  49.       verΣndert werden kann, diese Modifikationen aber nicht selbst ausfⁿhrt.
  50.       Es kann Hotspots setzen und darauf reagieren. Es bekommt die
  51.       Identifikationsnummer 1 */
  52.    CndDefVarObj(link,"schiefes Dreieck",2,VO_MOVE | VO_ROTATE | VO_SIZE | VO_REFLECT | VO_DLG,
  53.                             VO_MOVE | VO_ROTATE | VO_SIZE | VO_HOTSPOT);
  54.    /* das zweite variable Element ist ein beliegiges Dreieck, das im
  55.    Gegensatz zum ersten die Modifikationen auch selbst ausfⁿhrt. Es bekommt
  56.    die Identifikationsnummer 2 */
  57.    CndDefVarObj(link,"Epizykloide",3,VO_MOVE | VO_ROTATE | VO_SIZE | VO_REFLECT | VO_DLG,
  58.                             VO_HOTSPOT);
  59.    /* die Epizykloide ist die Kurve, die entsteht, wenn ein Kreis auf einem
  60.       anderen Kreis abgerollt wird. Ein Punkt auf dem abrollenden Kreis
  61.       hinterlΣ▀t ein Spur. Hier arbeiten wir wieder im Ursprung des
  62.       Koordinatensystems*/
  63.    return(1);
  64. }
  65.  
  66. int far pascal defparameter(long link, int id)
  67. /* die Definition der Parameter. */
  68. {
  69.    switch (id)
  70.    {
  71.     case 1: /* das gleichseitige Dreieck */
  72.        CndDefParams(link,"SeitenlΣnge",PT_LENGTH);
  73.        CndDefParams(link,"Inkreis",PT_BOOL);
  74.        CndDefParams(link,"Umkreis",PT_BOOL);
  75.        /* das gleichseitige Dreieck hat drei Parameter. Die SeitenlΣnge als
  76.           LΣngenparameter und zwei boolean Parameter, die angeben ob ein
  77.           Inkreis und ein Umkreis dargestellt werden sollen */
  78.        return(1);
  79.        break;
  80.     case 2: /* das schiefe Dreieck */
  81.        CndDefParams(link,"1. Punkt",PT_POINT);
  82.        CndDefParams(link,"2. Punkt",PT_POINT);
  83.        CndDefParams(link,"3. Punkt",PT_POINT);
  84.        CndDefParams(link,"Unterschrift",PT_STRING);
  85.        CndDefParams(link,"Textlage: unterhalb; Mitte; oberhalb",PT_MODE);
  86.        CndDefParams(link,"Textgr÷▀e",PT_LENGTH);
  87.        /* Das schiefe Dreieck hat sechs Parameter: die drei Eckpunkte des
  88.           Dreiecks, einen Text, der zur Beschriftung dienen soll, einen
  89.           "Mode" Parameter, der drei M÷glichkeiten fⁿr die Lage des Textes
  90.           angibt und die Textgr÷▀e. */
  91.        return(1);
  92.        break;
  93.     case 3: /* die Epizykloide */
  94.        CndDefParams(link,"Radius fester Kreis",PT_LENGTH);
  95.        CndDefParams(link,"Radius Rollkreis",PT_LENGTH);
  96.        CndDefParams(link,"Startwinkel",PT_ANGLE);
  97.        CndDefParams(link,"Umlauf",PT_REAL);
  98.        CndDefParams(link,"Ausladung",PT_LENGTH);
  99.        CndDefParams(link,"geschlossen",PT_BOOL);
  100.        CndDefParams(link,"ganzzahlig",PT_BOOL);
  101.        return(1);
  102.        break;
  103.     default: return(0);
  104.    }
  105. }
  106.  
  107. int far pascal paraminit(long link, int id, Parameter *parblock)
  108. /* die Initialisierung der Parameter zur erstmaligen Darstellung
  109.    im Zeichnungsfenster*/
  110. {
  111.    GeoPoint p1,p2;
  112.    double l,zx,zy;
  113.  
  114.    switch (id) /* welches Element soll initialisiert werden */
  115.    {
  116.     case 1:  /* das gleichseitige Dreieck */
  117.              CndGetDisplayExtent(link,&p1,&p2);
  118.              /* wie gro▀ ist der augenblicklich dargestellte
  119.                 Ausschnitt der Zeichnung */
  120.              parblock->pararray[0]->UN.volength = (p2.y-p1.y)/4;
  121.              /* die SeitenlΣnge wird ein Viertel der Ausschnitth÷he */
  122.              parblock->pararray[1]->UN.vobool = 0; /* Inkreis nicht darstellen */
  123.              parblock->pararray[2]->UN.vobool = 1; /* Umkreis darstellen */
  124.              /* da das gleichseitige Dreieck sich nicht um die Verschiebung
  125.                 kⁿmmert, wird somit von Seiten CONDORs sichergestellt, da▀
  126.                 es in der Mitte des Zeichnungsfensters erscheint */
  127.              return(1);
  128.     case 2:  /* das schiefe Dreieck */
  129.              CndGetDisplayExtent(link,&p1,&p2);
  130.              /* wie gro▀ ist der augenblicklich dargestellte
  131.                 Ausschnitt der Zeichnung */
  132.              l = (p2.y-p1.y)/4; /* ein Viertel der Ausschnittsh÷he */
  133.              zx = (p1.x+p2.x)/2; /* der Mittelpunkt in x */
  134.              zy = (p1.y+p2.y)/2; /* der Mittelpunkt in y */
  135.              parblock->pararray[0]->UN.vopoint.x = zx-l/2;
  136.              parblock->pararray[0]->UN.vopoint.y = zy-l/2;
  137.              /* erster Punkt ist um l/2 links unterhalb des Mittelpunkts */
  138.  
  139.              parblock->pararray[1]->UN.vopoint.x = zx+l/2;
  140.              parblock->pararray[1]->UN.vopoint.y = zy-l/4;
  141.              /* der zweite Punkt etwas rechts unterhalb des Mittelpunkts */
  142.  
  143.              parblock->pararray[2]->UN.vopoint.x = zx+l/4;
  144.              parblock->pararray[2]->UN.vopoint.y = zy+l/2;
  145.              /* der dritte Punkt etwas rechts oberhalb des Mittelpunkts */
  146.  
  147.              parblock->pararray[3]->UN.vostring = (pPString) CndMalloc(link,2+14);
  148.              strcpy(parblock->pararray[3]->UN.vostring->content,"ein Beispiel");
  149.              parblock->pararray[3]->UN.vostring->length = 14;
  150.              /* der Text-Parameter wird mit "ein Beispiel" vorbesetzt */
  151.  
  152.              parblock->pararray[4]->UN.Mode.vomode = 1;
  153.              /* Modus 1, also Text in der Mitte */
  154.              parblock->pararray[5]->UN.volength = l/5;
  155.              return(1);
  156.     case 3:
  157.              CndGetDisplayExtent(link,&p1,&p2);
  158.              l = (p2.y-p1.y)/8; /* ein Achtel der Ausschnittsh÷he */
  159.              parblock->pararray[0]->UN.volength = l;
  160.              parblock->pararray[1]->UN.volength = l;
  161.              parblock->pararray[2]->UN.voangle = 0;
  162.              parblock->pararray[3]->UN.voreal = 2*pi;
  163.              parblock->pararray[4]->UN.volength = 0;
  164.              parblock->pararray[5]->UN.vobool = 1;
  165.              parblock->pararray[6]->UN.vobool = 1;
  166.  
  167.     default: return(0);
  168.    }
  169. }
  170.  
  171. int far pascal paramchange(long link, int id, Parameter *parblock,
  172.                      int sit, GeoPoint *hsp)
  173. /* ein Parameter wird verΣndert */
  174. {
  175.  
  176.    switch (id) /* welches variable Element */
  177.    {
  178.     case 1: /* das gleichseitige Dreieck */
  179.        switch (sit) /* aus welcher Situation erfolgt die ─nderung */
  180.        { /* es sind nur die Hotspots von Interesse und davon auch nur der
  181.             dritte, die anderen beiden werden von CONDOR bereits richtig
  182.             behandelt */
  183.         case -3: parblock->pararray[0]->UN.volength = fabs(hsp->x);
  184.                  /* es war der dritte Hotspot, der fⁿr die SeitenlΣnge
  185.                     zustΣndig sein soll. Die SeitenlΣnge wird hier als der
  186.                     horizontale Abstand des Hotspot vom Nullpunkt bestimmt */
  187.                  return(1);
  188.         default: return(1);
  189.        };
  190.        return(1);
  191.     case 2: /* das schiefe Dreieck */
  192.        switch (sit) /* die Situation */
  193.        { /* auch hier sind nur dei Hotspots von Interesse, die in diesem Fall
  194.             mit den drei Punkten identisch sind */
  195.         case -2: parblock->pararray[0]->UN.vopoint = *hsp;
  196.                  return(1);
  197.         case -3: parblock->pararray[1]->UN.vopoint = *hsp;
  198.                  return(1);
  199.         case -4: parblock->pararray[2]->UN.vopoint = *hsp;
  200.                  return(1);
  201.         default: return(1);
  202.        }
  203.     case 3: /* Epizykloide */
  204.        switch (sit) /* die Situation */
  205.        {
  206.         case -2: /* der Hotspot fⁿr den Festkreisradius wird geΣndert */
  207.                  parblock->pararray[0]->UN.volength = hsp->x;
  208.         case 1: /* Festkreisradius wurde in der Dialogbox geΣndert */
  209.                 if (parblock->pararray[5]->UN.vobool!=0) /* geschlossen */
  210.                 {  parblock->pararray[3]->UN.voreal =
  211.                       (parblock->pararray[0]->UN.volength)/
  212.                       (parblock->pararray[1]->UN.volength)*2*pi;
  213.                 }
  214.                  return(1);
  215.         case -3: parblock->pararray[1]->UN.volength = hsp->x-parblock->pararray[0]->UN.volength;
  216.         case 2: /* Rollkreisradius wurde geΣndert */
  217.                 if (parblock->pararray[5]->UN.vobool!=0) /* geschlossen */
  218.                 {  parblock->pararray[3]->UN.voreal =
  219.                       (parblock->pararray[0]->UN.volength)/
  220.                       (parblock->pararray[1]->UN.volength)*2*pi;
  221.                 }
  222.                  return(1);
  223.         default: return(1);
  224.        }
  225.     default: return(0);
  226.    }
  227. }
  228.  
  229. int far pascal defhotspots(long link, int id, Parameter *parblock)
  230. /* Festlegen von Lage und Typ der Hotspots */
  231. {
  232.    GeoPoint p1;
  233.    double l;
  234.  
  235.    switch (id) /* welches Element */
  236.    {
  237.     case 1: /* gleichseitiges Dreieck */
  238.             /* alle Koordinaten beziehen sich auf den Nullpunkt als eine
  239.                Ecke des Dreiecks. Verschieben und Drehen wird von CONDOR
  240.                abgehandelt */
  241.             p1.x = 0;
  242.             p1.y = 0;
  243.             l = parblock->pararray[0]->UN.volength; /* die SeitenlΣnge */
  244.             CndDefHotSpot(link,&p1,CUR_MOVE,"verschieben"); /* verschieben */
  245.             /* der Nullpunkt dient als Hotspot zum Verschieben. */
  246.  
  247.             p1.x = l/2;
  248.             CndDefHotSpot(link,&p1,CUR_ROT,"drehen"); /* drehen */
  249.             /* der Mittelpunkt der Grundlinie dient als Hotspot zum Drehen */
  250.  
  251.             p1.x = l;
  252.             CndDefHotSpot(link,&p1,CUR_POINT,"SeitenlΣnge"); /* Punktcursor */
  253.             /* das rechte Ende der Grundlinie dient als Hotspot zum ─ndern
  254.                der SeitenlΣnge */
  255.             return(1);
  256.     case 2: /* das schiefe Dreieck */
  257.             p1.x = (parblock->pararray[0]->UN.vopoint.x+
  258.                     parblock->pararray[1]->UN.vopoint.x+
  259.                     parblock->pararray[2]->UN.vopoint.x)/3;
  260.             p1.y = (parblock->pararray[0]->UN.vopoint.y+
  261.                     parblock->pararray[1]->UN.vopoint.y+
  262.                     parblock->pararray[2]->UN.vopoint.y)/3;
  263.             /* der Mittelpunkt des Dreiecks (Schwerpunkt ) */
  264.             CndDefHotSpot(link,&p1,CUR_MOVE,"verschieben");
  265.             /* der Mittelpunkt dient als Hotspot zum Verschieben */
  266.  
  267.             CndDefHotSpot(link,&parblock->pararray[0]->UN.vopoint,CUR_POINT,"1. Punkt");
  268.             CndDefHotSpot(link,&parblock->pararray[1]->UN.vopoint,CUR_POINT,"2. Punkt");
  269.             CndDefHotSpot(link,&parblock->pararray[2]->UN.vopoint,CUR_POINT,"3. Punkt");
  270.             /* die drei Eckpunkte bekommen jeweils einen Hotspot, mit dem
  271.                eben diese Eckpunkte verΣndert werden k÷nnen */
  272.             return(1);
  273.     case 3: /* die Epizykloide */
  274.             p1.x = 0;
  275.             p1.y = 0;
  276.             CndDefHotSpot(link,&p1,CUR_MOVE,"verschieben"); /* verschieben */
  277.             p1.x = parblock->pararray[0]->UN.volength;
  278.             CndDefHotSpot(link,&p1,CUR_POINT,"Festkreis"); /* Punktcursor */
  279.             p1.x = parblock->pararray[0]->UN.volength+
  280.                    parblock->pararray[1]->UN.volength;
  281.             CndDefHotSpot(link,&p1,CUR_POINT,"Rollkreis"); /* Punktcursor */
  282.     default: return(0);
  283.    }
  284. }
  285.  
  286. int far pascal enumgeo(long link, int id, Parameter *parblock, int sit)
  287. /* Definition der Geometrie */
  288. {
  289.    GeoPoint mpkt,p1,p2,p3,p4;
  290.    double   l,h,r1,r2,a,b,c,d,delta;
  291.    int      n,i,pos,anz;
  292.    Attribut atrundef = {255,255,255,255}; /* dieses Attribut ist das in
  293.                                             CONDOR voreingestellte Attribut */
  294.    Attribut atr;
  295.  
  296.    switch (id) /* welches Element */
  297.    {
  298.     case 1: /* das gleichseitige Dreieck */
  299.             l = parblock->pararray[0]->UN.volength; /* die SeitenlΣnge */
  300.             h = l*sqrt(3)/2; /* die H÷he des Dreiecks */
  301.             p1.x = 0;
  302.             p1.y = 0;
  303.             p2.x = l;
  304.             p2.y = 0;
  305.             p3.x = l/2;
  306.             p3.y = h;
  307.             p4.x = l/2;
  308.             p4.y = 0;
  309.             /* die drei Eckpunkte und der Mittelpunkt der Grundlinie */
  310.  
  311.             atr = atrundef;
  312.             if (CndLine(link,&p1,&p2,atrundef)==0) return(0);
  313.             if (CndLine(link,&p2,&p3,atrundef)==0) return(0);
  314.             if (CndLine(link,&p3,&p1,atrundef)==0) return(0);
  315.             /* definiere die drei Seiten des Dreiecks als Linien. Wenn CndLine
  316.                0 liefert, dann soll nicht mehr weiterdefiniert werden. Das ist
  317.                z.B. dann der Fall, wenn beim Anpicken bereits eine Linie
  318.                getroffen wurde, dann iste es nichtmehr n÷tig die restlichen
  319.                Linien zu berechnen */
  320.             r1 = l/2*sqrt(3)/3; /* Radius des Inkreises */
  321.             r2 = r1*2; /* Radius des Umkreises */
  322.             mpkt.x = l/2;
  323.             mpkt.y = r1; /* Mittelpunkt der beiden Kreise */
  324.             atr.color = 2; /* der Inkreis soll mit Farbe 2 gezeichnet werden */
  325.             if (parblock->pararray[1]->UN.vobool != 0) /* soll der Inkreis gezeichnet werden */
  326.                {if (CndCircle(link,&mpkt,r1,atr)==0) return(0);};
  327.  
  328.             atr.color = 3; /* der Umkreis soll mit Farbe 3 gezeichnet werden */
  329.             if (parblock->pararray[2]->UN.vobool != 0) /* soll der Umkreis gezeichnet werden */
  330.                {if (CndCircle(link,&mpkt,r2,atr)==0) return(0);};
  331.             return(1);
  332.     case 2: /* das schiefe Dreieck */
  333.             CndLine(link,&parblock->pararray[0]->UN.vopoint,
  334.                          &parblock->pararray[1]->UN.vopoint,atrundef);
  335.             CndLine(link,&parblock->pararray[1]->UN.vopoint,
  336.                          &parblock->pararray[2]->UN.vopoint,atrundef);
  337.             CndLine(link,&parblock->pararray[2]->UN.vopoint,
  338.                          &parblock->pararray[0]->UN.vopoint,atrundef);
  339.             /* ganz einfach die drei Seitenlinien aus den drei Eckpunkten
  340.                bestimmen. Der Ergebniswert von CndLine bleibt hier unberⁿcksichtigt,
  341.                was fⁿr CONDOR evtl. Zeitverluste bedeutet, bei drei Linien
  342.                spielt das aber keine Rolle */
  343.  
  344.             i = parblock->pararray[3]->UN.vostring->length;
  345.             parblock->pararray[3]->UN.vostring->content[i] = 0;
  346.             /* den Pascal-String mit einer 0 am Ende versehen */
  347.             p1.x = (parblock->pararray[0]->UN.vopoint.x +
  348.                     parblock->pararray[1]->UN.vopoint.x +
  349.                     parblock->pararray[2]->UN.vopoint.x ) / 3;
  350.             /* Mittelpunkt in x */
  351.             switch (parblock->pararray[4]->UN.Mode.vomode)
  352.             /* wo soll der Text erscheinen */
  353.                {
  354.                 case 0:/* unten */
  355.                         p1.y = min(min(parblock->pararray[0]->UN.vopoint.y,
  356.                                        parblock->pararray[1]->UN.vopoint.y),
  357.                                    parblock->pararray[2]->UN.vopoint.y);
  358.                         pos = TXT_TOP;
  359.                         break;
  360.                 case 1: /* Mitte */
  361.                         p1.y = (parblock->pararray[0]->UN.vopoint.y +
  362.                                 parblock->pararray[1]->UN.vopoint.y +
  363.                                 parblock->pararray[2]->UN.vopoint.y ) / 3;
  364.                         pos = TXT_V_CENT;
  365.                         break;
  366.  
  367.                 case 2: /* oben */
  368.                         p1.y = max(max(parblock->pararray[0]->UN.vopoint.y,
  369.                                        parblock->pararray[1]->UN.vopoint.y),
  370.                                    parblock->pararray[2]->UN.vopoint.y);
  371.                         pos = TXT_BOTTOM;
  372.                         /* oben */
  373.                         break;
  374.                }
  375.             atr = atrundef;
  376.             atr.color = 4;
  377.             pos = pos | TXT_H_CENT; /* die Zentrierung des Textes */
  378.             CndText(link,&p1,parblock->pararray[3]->UN.vostring->content,
  379.                     (Pointer)0,parblock->pararray[5]->UN.volength,0,pos,atr);
  380.             /* definiert einen Text am Punkt p1. Der Text selbst ist
  381.                identisch mit dem 4. Parameter, es wird der voreingestellte
  382.                Zeichensatz verwendet, die Gr÷▀e ergibt sich aus dem
  383.                6. Parameter, der Text ist horizontal, die Zentrierung ergibt
  384.                sich aus dem "Mode" Parameter, Farbe ist 4 */
  385.             CndGetTextExtent(link,&p1,parblock->pararray[3]->UN.vostring->content,
  386.                             (Pointer)0,parblock->pararray[5]->UN.volength,0,pos,
  387.                             &p1,&p2,&p3,&p4);
  388.             CndLine(link,&p1,&p2,atrundef);
  389.             CndLine(link,&p2,&p3,atrundef);
  390.             CndLine(link,&p3,&p4,atrundef);
  391.             CndLine(link,&p4,&p1,atrundef);
  392.             return(1);
  393.     case 3: /* die Epizykloide */
  394.             anz = 100;
  395.             if (sit==SIT_DRAW) anz=200;
  396.             if (sit==SIT_PLOT) anz=400;
  397.             /* anz ist die Anzahl der Linien, die gezeichnet werden sollen */
  398.  
  399.             a = parblock->pararray[0]->UN.volength; /* Radius Festkreis */
  400.             if (parblock->pararray[6]->UN.vobool!=0) /* ganzzahlig */
  401.             /* wenn ganzzahlig eingestellt ist, dann soll der Roolkreisradius
  402.                ganz im Festkreisradius enthalten sein */
  403.             {  n = (int) (parblock->pararray[0]->UN.volength/
  404.                           parblock->pararray[1]->UN.volength);
  405.                b = parblock->pararray[0]->UN.volength/max(n,1);
  406.             }
  407.             else
  408.                b = parblock->pararray[1]->UN.volength; /* Radius Rollkreis */
  409.             c = b+parblock->pararray[4]->UN.volength; /* VerlΣngerung */
  410.             if (parblock->pararray[5]->UN.vobool!=0) /* geschlossen */
  411.             /* wenn geschlossen eingestellt ist, dann soll der Rollkreis
  412.                genau einmal auf dem Festkreis abrollen */
  413.               d = (parblock->pararray[0]->UN.volength)/b*2*pi;
  414.             else
  415.               d = parblock->pararray[3]->UN.voreal;
  416.  
  417.             delta = ( d - parblock->pararray[2]->UN.voangle) /anz; /* Schrittweite */
  418.  
  419.             p1.x = 0;
  420.             p1.y = 0;
  421.             atr = atrundef;
  422.             switch (sit)
  423.             /* wenn gerade die beiden Hotspots verzogen werden, d.h. die
  424.                Maustaste ist gedrⁿckt, dann wird zusΣtzlich zu Epizykloide
  425.                noch der Kreis gezeichnet, dessen Radius mit diesem Hotspot
  426.                gerade verΣndert wird. Wird die Maustaste wieder losgelassen,
  427.                dann wird wiedr nur die Epizykloide gezeichnet */
  428.             {
  429.              case -2: /* der Radius des Festkreises wird verΣndert */
  430.                 atr.color = 0; /* graue Farbe, dient nur zum zeichnen beim
  431.                                   aktuellen Element */
  432.                 atr.linepattern = 1; /* durchgezogen */
  433.                 CndCircle(link,&p1,parblock->pararray[0]->UN.volength,atr);
  434.                 p1.x = parblock->pararray[0]->UN.volength +
  435.                       parblock->pararray[1]->UN.volength;
  436.                 atr.linepattern = 3; /* gepunktet */
  437.                 CndCircle(link,&p1,parblock->pararray[1]->UN.volength,atr);
  438.                 /* der Festkreis also grau und durchgezogenen Linien, der
  439.                    Rollkreis gepunktet */
  440.                 break;
  441.              case -3:
  442.                 atr.color = 0; /* graue Farbe, dient nur zum zeichnen beim
  443.                                   aktuellen Element */
  444.                 atr.linepattern = 3; /* gepunktet */
  445.                 CndCircle(link,&p1,parblock->pararray[0]->UN.volength,atr);
  446.                 p1.x = parblock->pararray[0]->UN.volength +
  447.                       parblock->pararray[1]->UN.volength;
  448.                 atr.linepattern = 1; /* durchgezogen */
  449.                 CndCircle(link,&p1,parblock->pararray[1]->UN.volength,atr);
  450.                 break;
  451.              default: {};
  452.              /* in allen anderen FΣllen werden keine zusΣtzlichen Kreise gezeichnet */
  453.             }
  454.             p1.x = (a+b)*cos(b/a*parblock->pararray[2]->UN.voangle)-
  455.                    c*cos((a+b)/a*parblock->pararray[2]->UN.voangle);
  456.             p1.y = (a+b)*sin(b/a*parblock->pararray[2]->UN.voangle)-
  457.                    c*sin((a+b)/a*parblock->pararray[2]->UN.voangle);
  458.             /* p1 ist der Anfangspunkt der Epizykloide, wird in der Schleife
  459.                jeweils auf den Endpunkt der gezeichneten Linie gelegt */
  460.             for (i=1; i<=anz; i++)
  461.             /* in dieser Schleife werden die Punkte der Epizykloide berechnet
  462.                und lauter kleine Linienstⁿcke definiert */
  463.             {
  464.              p2.x = (a+b)*cos(b/a*(parblock->pararray[2]->UN.voangle+i*delta))-
  465.                     c*cos((a+b)/a*(parblock->pararray[2]->UN.voangle+i*delta));
  466.              p2.y = (a+b)*sin(b/a*(parblock->pararray[2]->UN.voangle+i*delta))-
  467.                     c*sin((a+b)/a*(parblock->pararray[2]->UN.voangle+i*delta));
  468.              if (CndLine(link,&p1,&p2,atrundef)==0) return(0);
  469.              /* definiert ein kleines Linienstⁿck der Kurve. In diesem Fall ist
  470.                 es wichtig, den Rⁿckgabewert von CndLine zu beachten und im Falle 0
  471.                 die Procedure zu beenden, da sonst CONDOR-Funktionen verlangsamt
  472.                 werden k÷nnten */
  473.              p1 = p2; /* der alte Endpunkt wird zum neuen Anfangspunkt */
  474.             }
  475.             /* es wΣre auch m÷glich mit CndPolyline zuerst alle Punkte zu
  476.                berechnen und auf einem Array zwischenzuspeichern. Der Vorteil
  477.                wΣre, da▀ beim Trimmen das ganze Teilstⁿck abgeschnitten wird,
  478.                der Nachteil, da▀ beim dynamischen Zeichnen zunΣchst alles
  479.                berechnet wird, und dann keine Zeit mehr fⁿr die Darstellung
  480.                bleibt, der Anwender also nur das erste Teilstrichlein zu
  481.                sehen bekommt. Ganz komfartabel wΣre die Unterscheidung der
  482.                beiden FΣlle anhand von st */
  483.     default:return(0);
  484.    }
  485. }
  486.  
  487. int far pascal defsnappoints(long link, int id, Parameter *parblock)
  488. /* Definition der Fangpunkte */
  489. {
  490.    GeoPoint p1;
  491.    double l,h;
  492.  
  493.    switch (id) /* welches Element */
  494.    {
  495.     case 1: /* das gleichseitige Dreieck */
  496.             l = parblock->pararray[0]->UN.volength;
  497.             h = l*sqrt(3)/2;
  498.             p1.x = 0;
  499.             p1.y = 0;
  500.             CndDefSnapPoint(link,&p1);
  501.             p1.x = l;
  502.             p1.y = 0;
  503.             CndDefSnapPoint(link,&p1);
  504.             p1.x = l/2;
  505.             p1.y = h;
  506.             CndDefSnapPoint(link,&p1);
  507.             /* die drei Fangpunkte sind die drei Eckpunkte. Zur Berechnung
  508.                siehe enumgeo */
  509.             return(1);
  510.     case 2: /* das schiefe Dreieck */
  511.             CndDefSnapPoint(link,&parblock->pararray[0]->UN.vopoint);
  512.             CndDefSnapPoint(link,&parblock->pararray[1]->UN.vopoint);
  513.             CndDefSnapPoint(link,&parblock->pararray[2]->UN.vopoint);
  514.             /* die Fangpunkte sind die drei Eckpunkte */
  515.             return(1);
  516.     case 3: /* die Epizykloide */
  517.             p1.x = 0;
  518.             p1.y = 0;
  519.             CndDefSnapPoint(link,&p1);
  520.             /* nur der Mittelpunkt ist Fangpunkt */
  521.             return(1);
  522.     default: return(0);
  523.    }
  524. }
  525.  
  526.