/********************************************************************
Iterierte Funktionen Systeme
Plugin für Cinema Version 8.0
(c) Jürgen Meier (www.3d-meier.de)
Version : 1.00
30.09.2004
*********************************************************************/

// Globale Variablen und Konstanten
   // Plugin ID Nummer
      const var cPluginID = 1016509;
   // Pluginname
      const var cPlugName = "IFS";
   // Pluginhilfstext
      const var cPlugHelp = "Iterierte Funktionen Systeme";
   // Breite des Menütextes
      var Breite=200;
   // Maximalwerte
      var cMaxFloat=10000000000;
      var cMaxInt=100000000;
   // Objektvariable
      var para;
   // Dialogvariable
      var gDial;

   // Variablen für die Berechnung
      var i,j;           // Indizes für die Schleifen
      var zz;            // Zähler
      var SP;            // Anzahl Punkte des Polygonobjektes
      var SQ;            // Anzahl Quadrate des Polygonobjektes
      var x,xa,y,z;      // Koordinaten eines Punktes
      var N=100000;      // Anzahl Punkte
      var Zufall;        // Zufallszahl
      var Neu;           // Neuer Punkt
      var Wahl;          // Auswahl der Figur
      var Dx,Dy;         // Punktgröße
      var D=0.075;       // Punktgröße

   // Variablen für das Polygonobjekt
      var vObj,
      vSP,               // Anzahl der Punkte
      vPointAry,         // Array für die Punkte
      vSQ,               // Anzahl der Polygone
      vPolyAry;          // Array für die Polygone


// ******************************************************************
// Funktion zum Objekt aktivieren (c) h.g.seib
// ******************************************************************
   fSetActiveObject(vDoc,vObj)
   {

   // Aktives Objekt ermitteln
      var vAObj = GetActiveObject(vDoc);
   // Active object Bit bzw. Flag setzen
      if (vAObj) vAObj->DelBit(BIT_AOBJ);
          vObj->SetBit(BIT_AOBJ);
   // Änderung im Dokument bekanngeben (neues Objekt selektiert)
      GeEventAdd(NEW_ACTIVE_OBJECT);
   }

// ******************************************************************
// Funktion zur Erzeugung von Zweig 2
// ******************************************************************
   fZweig2(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Zweig 2");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 75;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 0.25) {
                   xa=0.2439*y;
                   y=0.3053*y;
                   x=xa;
                 }
              if ((Zufall >= 0.25)&&(Zufall < 0.50)) {
                   xa=0.7248*x+0.0337*y+20.60;
                   y=-0.02530.7*x+0.7426*y+25.38;
                   x=xa;
                 }
              if ((Zufall >= 0.50)&&(Zufall < 0.75)) {
                   xa=0.1583*x-0.1297*y+13.83;
                   y=0.3550*x+0.3676*y+17.50;
                   x=xa;
                 }
              if (Zufall >= 0.75) {
                   xa=0.3386*x+0.3694*y+6.79;
                   y=0.2227*x-0.0756*y+8.26;
                   x=xa;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung von Zweig 1
// ******************************************************************
   fZweig1(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Zweig 1");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 75;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 0.25) {
                   xa=0.5*x-0.5*y+20;
                   y=0.5*y+20;
                   x=xa;
                 }
              if ((Zufall >= 0.25)&&(Zufall < 0.50)) {
                   xa=0.5*x+20;
                   y=0.7*y+20;
                   x=xa;
                 }
              if ((Zufall >= 0.50)&&(Zufall < 0.75)) {
                   xa=0.25*x+0.35*y;
                   y=0.35*x+0.25*y;
                   x=xa;
                 }
              if (Zufall >= 0.75) {
                   xa=0.8*y;
                   y=0.8*x;
                   x=xa;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Sierpinski Dreiecks 2
// ******************************************************************
   fSierpinski2(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Sierpinski Dreieck 2");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 75;
      y= 50;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 1/3.0) {
                   x=0.5*x;
                   y=0.5*y;
                 }
              if ((Zufall >= 1/3.0)&&(Zufall < 2/3.0)) {
                   x=0.5*x;
                   y=0.5*y+100;
                 }
              if (Zufall >= 2/3.0) {
                   x=0.5*x+100;
                   y=0.5*y+100;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Twindragons
// ******************************************************************
   fTwindragon(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Twindragon");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 75;
      y= 50;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 0.5) {
                   xa=-0.5*x+0.5*y;
                   y=-0.5*x-0.5*y;
                   x=xa;
                 }
              if (Zufall >= 0.5) {
                   xa=-0.5*x+0.5*y-100;
                   y=-0.5*x-0.5*y-100;
                   x=xa;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung der Schneeflocke
// ******************************************************************
   fFlocke(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Schneeflocke");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 100;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 0.2) {
                   x=0.3333*x;
                   y=0.3333*y;
                 }
              if ((Zufall >= 0.2)&&(Zufall < 0.4)) {
                   x=0.3333*x+66.67;
                   y=0.3333*y;
                 }
              if ((Zufall >= 0.4)&&(Zufall < 0.6)) {
                   x=0.3333*x;
                   y=0.3333*y+66.67;
                 }
              if ((Zufall >= 0.6)&&(Zufall < 0.8)) {
                   x=0.3333*x+66.67;
                   y=0.3333*y+66.67;
                 }
              if (Zufall >= 0.8) {
                   x=0.3333*x+33.33;
                   y=0.3333*y+33.33;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Sierpinski Pentagramms
// ******************************************************************
   fKristall(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Sierpinski Pentagramm");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 100;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 0.2) {
                   x=0.382*x+30.72;
                   y=0.382*y+61.90;
                 }
              if ((Zufall >= 0.2)&&(Zufall < 0.4)) {
                   x=0.382*x+60.33;
                   y=0.382*y+40.44;
                 }
              if ((Zufall >= 0.4)&&(Zufall < 0.6)) {
                   x=0.382*x+1.39;
                   y=0.382*y+40.44;
                 }
              if ((Zufall >= 0.6)&&(Zufall < 0.8)) {
                   x=0.382*x+12.53;
                   y=0.382*y+5.95;
                 }
              if (Zufall >= 0.8) {
                   x=0.382*x+49.20;
                   y=0.382*y+5.95;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Cantor Labyrinths
// ******************************************************************
   fCantor(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Cantor Labyrinth");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 0;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 1/7.0) {
                   x=0.3333*x+33.33;
                   y=0.3333*y+66,67;
                 }
              if ((Zufall >= 1/7.0)&&(Zufall < 4/7.0)) {
                   xa=0.3333*y+66,67;
                   y=1.00*x;
                   x=xa;
                 }
              if (Zufall >= 4/7.0) {
                   xa=-0.3333*y+33.33;
                   y=1.00*x;
                   x=xa;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Baums
// ******************************************************************
   fBaum(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Baum");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 0;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 0.05) {
                   x=0.0;
                   y=0.50*y;
                 }
              if ((Zufall >= 0.05)&&(Zufall < 0.45)) {
                   xa=0.42*x-0.42*y;
                   y=0.42*x+0.42*y+20;
                   x=xa;
                 }
              if ((Zufall >= 0.45)&&(Zufall < 0.85)) {
                   xa=0.42*x+0.42*y;
                   y=-0.42*x+0.42*y+20;
                   x=xa;
                 }
              if (Zufall >= 0.85) {
                   xa=0.10*x;
                   y=0.10*y+20;
                   x=xa;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung der Koch Kurve
// ******************************************************************
   fKoch(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Koch Kurve");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 75;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 0.25) {
                   x=x/3.0;
                   y=y/3.0;
                 }
              if ((Zufall >= 0.25)&&(Zufall < 0.50)) {
                   xa=x/6.0-0.2887*y+33.333;
                   y=0.2887*x+0.1667*y;
                   x=xa;
                 }
              if ((Zufall >= 0.50)&&(Zufall < 0.75)) {
                   xa=x/6.0+0.2887*y+50;
                   y=-0.2887*x+0.1667*y+28.868;
                   x=xa;
                 }
              if (Zufall >= 0.75) {
                   xa=x/3.0+66,667;
                   y=0.3333*y;
                   x=xa;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Barnsley Farns
// ******************************************************************
   fFarn(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Barnsley Farn");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 75;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 0.01) {
                   x=0.00*x;
                   y=0.16*y;
                 }
              if ((Zufall >= 0.01)&&(Zufall < 0.86)) {
                   xa=0.85*x+0.04*y;
                   y=-0.04*x+0.85*y+160;
                   x=xa;
                 }
              if ((Zufall >= 0.86)&&(Zufall < 0.93)) {
                   xa=0.20*x-0.26*y;
                   y=0.23*x+0.22*y+160;
                   x=xa;
                 }
              if (Zufall >= 0.93) {
                   xa=-0.15*x+0.28*y;
                   y=0.26*x+0.24*y+44;
                   x=xa;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Sierpinski Teppichs
// ******************************************************************
   fTeppich(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Sierpinski Teppich");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 75;
      y= 75;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 1/8.0) {
                   x=0.333333*x;
                   y=0.333333*y;
                 }
              if ((Zufall >= 1/8.0)&&(Zufall < 2/8.0)) {
                   x=0.333333*x+33.333;
                   y=0.333333*y;
                 }
              if ((Zufall >= 2/8.0)&&(Zufall < 3/8.0)) {
                   x=0.333333*x+66.667;
                   y=0.333333*y;
                 }
              if ((Zufall >= 3/8.0)&&(Zufall < 4/8.0)) {
                   x=0.333333*x;
                   y=0.333333*y+33.333;
                 }
              if ((Zufall >= 4/8.0)&&(Zufall < 5/8.0)) {
                   x=0.333333*x+66.667;
                   y=0.333333*y+33.333;
                 }
              if ((Zufall >= 5/8.0)&&(Zufall < 6/8.0)) {
                   x=0.333333*x;
                   y=0.333333*y+66.667;
                 }
              if ((Zufall >= 6/8.0)&&(Zufall < 7/8.0)) {
                   x=0.333333*x+33.333;
                   y=0.333333*y+66.667;
                 }

              if (Zufall >= 7/9.0) {
                   x=0.333333*x+66.667;
                   y=0.333333*y+66.667;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Sierpinski Dreiecks
// ******************************************************************
   fSierpinski(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Sierpinski Dreieck 1");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);
   // Startpunkt
      x= 75;
      y= 50;

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=random->Get01();
           // Affine Abbildung auswählen
              if (Zufall < 1/3.0) {
                   x=0.5*x;
                   y=0.5*y;
                 }
              if ((Zufall >= 1/3.0)&&(Zufall < 2/3.0)) {
                   x=0.5*x+25;
                   y=0.5*y+50;
                 }
              if (Zufall >= 2/3.0) {
                   x=0.5*x+50;
                   y=0.5*y;
                 }
           // Neuen Punkt berechnen
              Neu= vector(x,y,0);
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Ableitung der Klasse MyDialog von GeDialog
// ******************************************************************
class MyDialog : GeDialog
{
   public:
      MyDialog();
      CreateLayout();
      Init();
      CoreMessage(vID,vMSG);
      Command(vID,vMSG);
}
// ******************************************************************
// Deklaration des Konstruktors
   MyDialog::MyDialog()
   {
   // Konstruktor der parent class aufrufen
      super(cPluginID);
   }

// ******************************************************************
// Deklaration der Methode CreateLayout
   MyDialog::CreateLayout()
   {     
   // Plugintitel setzen
      SetTitle(cPlugName);
   // Auswahl der Figur
      AddComboBox(9000,BFH_LEFT,300,0);
      AddItem(9000,9010,"Sierpinski Dreieck 1");
      AddItem(9000,9011,"Sierpinski Teppich");
      AddItem(9000,9012,"Barnsley Farn");
      AddItem(9000,9013,"Koch Kurve");
      AddItem(9000,9014,"Baum");
      AddItem(9000,9015,"Cantor Labyrinth");
      AddItem(9000,9016,"Sierpinski Pentagramm");
      AddItem(9000,9017,"Schneeflocke");
      AddItem(9000,9018,"Twindragon");
      AddItem(9000,9019,"Sierpinski Dreieck 2");
      AddItem(9000,9020,"Zweig 1");
      AddItem(9000,9021,"Zweig 2");
   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Gruppe für die Parameter der Berechnung
      AddGroupBeginV(1002,BFH_CENTER,2,"",0);
      {
         AddStaticText(0,BFH_LEFT,Breite,0," Anzahl Punkte",0);
         AddEditNumber(2000,BFH_LEFT,100,0);
         AddStaticText(0,BFH_LEFT,Breite,0," Punktgröße",0);
         AddEditNumber(2001,BFH_LEFT,100,0);
      }
      // Vertikal orientierte Gruppe schliessen
         AddGroupEnd();
   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Button für den Start der Berechnung
      AddButton (3000,BFH_CENTER,200,0,"Start");
   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Impressum
      AddStaticText(0,BFH_CENTER,Breite,0," (c) 2004 Jürgen Meier",0);
      AddStaticText(0,BFH_CENTER,Breite,0," www.3d-meier.de",0);
      return TRUE;
   }

// ******************************************************************
// Deklaration der Methode Init
   MyDialog::Init()
   {
   // Startwerte setzen
      SetInt(2000,N,1,cMaxInt,1);
      SetFloat(2001,D,0,cMaxFloat,0);
   // Figur auswählen
      SetItem(9000,9010);
      return TRUE;
   }

// ******************************************************************
// Deklaration der Methode CoreMessage
   MyDialog::CoreMessage(vID,vMSG)
   {
      switch (vID)
         {
            case NEW_DOCUMENT:
            case DOCUMENT_CHANGED:
            case NEW_ACTIVE_OBJECT:
            case ACTIVE_OBJECT_CHANGED:
            return TRUE;
            break;
         }
      return FALSE;
   }

// ******************************************************************
// Deklaration der Methode Command
   MyDialog::Command(vID,vMSG)
   {
      var vDoc;
   //
      StopAllThreads();
      switch (vID)
      {
        case 3000 : // Start Button gedrückt
                      {
                         vDoc = GetActiveDocument();
                         if (!vDoc) return FALSE;

                         switch (Wahl)
                         {
                            case  0 : { fSierpinski(vDoc);   break; }
                            case  1 : { fTeppich(vDoc);      break; }
                            case  2 : { fFarn(vDoc);         break; }
                            case  3 : { fKoch(vDoc);         break; }
                            case  4 : { fBaum(vDoc);         break; }
                            case  5 : { fCantor(vDoc);       break; }
                            case  6 : { fKristall(vDoc);     break; }
                            case  7 : { fFlocke(vDoc);       break; }
                            case  8 : { fTwindragon(vDoc);   break; }
                            case  9 : { fSierpinski2(vDoc);  break; }
                            case 10 : { fZweig1(vDoc);       break; }
                            case 11 : { fZweig2(vDoc);       break; }

                         }
                      }

        case 9000 : {
                       if (GetItem(9000)==9010) { Wahl=0; }
                       if (GetItem(9000)==9011) { Wahl=1; }
                       if (GetItem(9000)==9012) { Wahl=2; }
                       if (GetItem(9000)==9013) { Wahl=3; }
                       if (GetItem(9000)==9014) { Wahl=4; }
                       if (GetItem(9000)==9015) { Wahl=5; }
                       if (GetItem(9000)==9016) { Wahl=6; }
                       if (GetItem(9000)==9017) { Wahl=7; }
                       if (GetItem(9000)==9018) { Wahl=8; }
                       if (GetItem(9000)==9019) { Wahl=9; }
                       if (GetItem(9000)==9020) { Wahl=10; }
                       if (GetItem(9000)==9021) { Wahl=11; }
                    }

        case 2000 : N=GetInt(2000);
        case 2001 : D=GetFloat(2001);

      }
      return TRUE;
   }


// ******************************************************************
// Ableitung der Klasse MyMenuPlugin von MenuPlugin
// ******************************************************************
   class MyMenuPlugin : MenuPlugin
   {  public:
          MyMenuPlugin();
          GetID();
          GetName();
          GetHelp();
          Execute(doc);
          RestoreLayout(secret);
   }
// ******************************************************************
// Deklaration des Konstruktors
   MyMenuPlugin::MyMenuPlugin()
   { 
      super();
   }

// ******************************************************************
// Deklaration der Methode GetID
   MyMenuPlugin::GetID()
   {
      return cPluginID;
   }

// ******************************************************************
// Deklaration der Methode GetName
   MyMenuPlugin::GetName()
   {
       return cPlugName;
   }

// ******************************************************************
// Deklaration der Methode GetHelp
   MyMenuPlugin::GetHelp()
   {
       return cPlugHelp;
   }

// ******************************************************************
// Deklaration der Methode Execute
   MyMenuPlugin::Execute(doc)
   {
      if (!gDial)
         gDial=new(MyDialog);
     gDial->Open(TRUE,-1,-1);
   }
// ******************************************************************
// Deklaration der Methode RestoreLayout
   MyMenuPlugin::RestoreLayout(secret)
   {
      if (!gDial)
         gDial=new(MyDialog);
      gDial->RestoreLayout(secret);
   }

// ******************************************************************
main()
{
   Register(MyMenuPlugin);
}