/********************************************************************
Pascal Dreieck
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 = 1016499;
   // Pluginname
      const var cPlugName = "Pascal Dreieck";
   // Pluginhilfstext
      const var cPlugHelp = "Erzeugt das Pascal Dreieck";
   // 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,k,l;           // Indizes für die Schleifen
      var zz;                // Zähler
      var N=150;             // Anzahl Punkte
      var G=256;             // Kantenlänge
      var D=7;               // Punktgröße

   // Variablen für das Objekt
      var vObj;
   // Felder für Integer
      var IntA,IntB,IntC;
   // Index für Negativbild
      var Negativ;

      var M,hh;

// ******************************************************************
// 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 Prüfung ob Zahl gleich Null
// ******************************************************************
   fNull(a)
   {
   // Variablen
      var l;                 // Laufvariable
      var null;              // Index ob Null
   // Prüfung ob Zahl (alle Stellen) = Null
      null=0;
      for (l=0;l<N;l++)
             {
                 if (a[l]!=0) {  null=1;  }
             }
   // Ergebnis übergeben
      return null;
   }

// ******************************************************************
// Funktion zur Ermittlung der Länge der Zahl
// ******************************************************************
   fLaenge(a)
   {
   // Variablen
      var z;                 // Zähler
   if (fNull(a)==1)
      {
   // Erste Stelle ermitteln
      z=0;
      do
         {
            z=z+1;
         }
      while(a[N-z]==0);
      }
      else { z=N; }

   // Ergebnis übergeben
      return N-z;
   }


// ******************************************************************
// Funktion zum Drucken von Integer Arrays
// ******************************************************************
   fDruck(a)
   {
   // Variablen
      var h;                 // Hilfsvariable
      var l;                 // Laufvariable
      var s;                 // String
      var null;              // Index ob Null
   if (fNull(a)==1)
      {
      // Zahl ausgeben
         h=fLaenge(a);
         s="";
         for (l=0;l<=h;l++)
             {
                s=s+tostring(a[h-l]);
             }
      }
      else {  s="0";  }
   // Ergebnis übergeben
      return s;
   }


// ******************************************************************
// Funktion zur Division von Integer Arrays
// ******************************************************************
   fMod(a,nn)
   {
   // Variablen
      var h;                 // Hilfsvariable
      var u;                 // Übertrag
      var l;                 // Laufvariable
      var r,r0,r1;           // Rest der Division
      var z;                 // Zähler
      var e;                 // Position der ersten Stelle
      var z1,z2,z3;          // Mögliche Zähler
      var zaehler;           // Zähler der Division
      var dd,ddi;            // Ergebnis der Division
      var Drucken=FALSE;

if (fNull(a)==1)
      {

   // Ersten Stelle ermitteln
      e=fLaenge(a);

if (e>=8) {

while(e>6)
{
   // Ersten Stelle ermitteln
      e=fLaenge(a);
   // e in der Konsole ausgeben
      if (Drucken==TRUE)
         {
           print("e = ");
           println(e);
         }
   // Mögliche Zähler ermitteln
      z1=a[e];
      if (e>=1) {  z2=10*a[e]+a[e-1];              }
      if (e>=2) {  z3=100*a[e]+10*a[e-1]+a[e-2];   }
      if (Drucken==TRUE)
         {
//          print("Teiler = ");    println(nn);
//          print("z1 = ");    println(z1);
//          print("z2 = ");    println(z2);
//          print("z3 = ");    println(z3);
         }

   // Richtigen Zähler ermitteln
      if (z3>=nn)
         {
           zaehler=z3;
           z=2;
         }
      if (z2>=nn)
         {
           zaehler=z2;
           z=1;
         }
      if (z1>=nn)
         {
           zaehler=z1;
           z=0;
         }
   // Ergebnis der Division
      dd=int(zaehler/(nn+0.0));
   // Rest der Division ermitteln
      r=zaehler-dd*nn;
//************** Rest ungleich Null
   // Verlauf der Division in die Konsole ausgeben
      if (Drucken==TRUE)
         {
            print("zaehler =");
            println(zaehler);
            print("z =");
            println(z);
            print("Rest =");
            println(r);
         }
   // Divisionsrest in Dezimalstellen aufspalten
      if (r!=10)
          {
             r1=int(r/10.0);
             r0=r % 10;
          }
          else {
             r1=1;
             r0=0;
          }
   // Neue Zahl ermitteln
if (e>2) {
      switch (z)
         {
            case 0 : {
                       a[e]=r0;
                       break;
                     }
            case 1 : {
                     
                       a[e]=r1;
                       a[e-1]=r0;
                       break;
                     }
            case 2 : {
                       a[e]=0;
                       a[e-1]=r1;
                       a[e-2]=r0;
                       break;
                     }
         } // Ende switch
} // Ende e>2
   // Neue Zahl Drucken
      if (Drucken==TRUE)
         {
           print("Neue Zahl : ");
           println(fDruck(a));
         }
   } // Ende while e>3
} // Ende if e>=5


   // Zahl rekonstruieren
      h= a[0]+10*a[1]+100*a[2] +1000*a[3] +10000*a[4] +100000*a[5] +1000000*a[6] +10000000*a[7];

} // Ende if null==1
else {  h=0;  }


   // Modulo berechnen
      return h % nn;
// return h;

   }


// ******************************************************************
// Funktion zur Addition von Integer Arrays
// ******************************************************************
   fAdd(a,b,c)
   {
   // Variablen
      var h;                 // Hilfsvariable
      var u;                 // Übertrag
      var l;                 // Laufvariable
   // Addition
      u=0;
      for (l=0;l<N;l++)
             {
              h=a[l]+b[l]+u;
              u=0;
              if (h>=10)
                  {
                  c[l]=h-10;
                  u=1;
                  }
                  else {
                  c[l]=h;
                  }
             }
   return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Dreiecks
// ******************************************************************
   fPascal(vDoc)
   {

   // Nullobjekt erzeugen
      var attraktor = new(NullObject);
   // Name zuweisen
      attraktor->SetName("Das Bild ist im Cinema Hauptverzeichnis");
   // Nullobjekt in die Szene einfügen
      vDoc->InsertObject(attraktor,NULL,NULL);

   // Arrays erzeugen
      var FeldA= new(array,G,N);
      var FeldB= new(array,G,N);
   // Arrays auf Null setzen
      for (i=0;i<G;i++)
          {
          for (j=0;j<N;j++)
              {
              FeldA[i][j]=0;
              FeldB[i][j]=0;
              }
          }
   // Feld A auf 1 setzen
      for (i=0;i<G;i++)
          {
            FeldA[i][0]=1;
          }
      FeldB[0][0]=1;

   // Bitmapobjekt erzeugen
      var bm = new(BaseBitmap,G,G);

   // Erste Pixelreihe
      for (k=0;k<G;k++)
          {
            if (Negativ==TRUE) {  bm->DrawPixel(k,0, vector(1.0));  }
                          else {  bm->DrawPixel(k,0, vector(0.0));  }
          }

   for (i=0;i<G-1;i++)
          {
           println(i);
           for (j=1;j<G;j++)
               {
                // IntC löschen
                   for (k=0;k<N;k++)
                       {
                        IntC[k]=0;
                       }
                // Zelle Feld A kopieren
                   for (k=0;k<N;k++)
                       {
                        IntA[k]=FeldA[j][k];
                       }
                // Zelle Feld B kopieren
                   for (k=0;k<N;k++)
                       {
                        IntB[k]=FeldB[j-1][k];
                       }
                // Zahlen addieren
                   fAdd(IntA,IntB,IntC);
                // Ergebnis in Feld B kopieren
                   for (k=0;k<N;k++)
                       {
                        FeldB[j][k]=IntC[k];
                       }
                // Modulo
//                  println(fDruck(IntC));
                   hh=fMod(IntC,D);
//                  print("Mod ");
//                   println(hh);

                // Pixel zeichnen
                   // Erstes Pixel
                      if (Negativ==TRUE)
                              {
                                bm->DrawPixel(0,i+1, vector(1.0));
                              }
                              else {
                                bm->DrawPixel(0,i+1, vector(0.0));
                              }
                   // Restliche Pixel
                      if (hh==0)
                         {
                           if (Negativ==TRUE)
                              {
                                  bm->DrawPixel(j,i+1, vector(0.0));
                              }
                              else {
                                  bm->DrawPixel(j,i+1, vector(1.0));
                              }
                         }
                         else {
                           if (Negativ==TRUE)
                              {   
                                    bm->DrawPixel(j,i+1, vector(1.0));
                              }
                              else {
                                  bm->DrawPixel(j,i+1, vector(0.0));
                              }
                         }
               }

           // Feld B nach Feld A kopieren
              for (l=0;l<G;l++)
                  {
                   for (j=0;j<N;j++)
                       {
                        FeldA[l][j]=FeldB[l][j];
                       }
                  }
           // Feld B löschen
              for (l=0;l<G;l++)
                  {
                   for (j=0;j<N;j++)
                       {
                        FeldB[l][j]=0;
                       }
                  }
           // Erste 1 setzen
              FeldA[0][0]=1;
              FeldB[0][0]=1;

          }

   // Pfad und Dateiname erzeugen
      var fn = GeGetStartupPath();
      fn->AddLast("Pascal "+tostring(D)+".bmp");
   // Container erzeugen
      var bc = new(BaseContainer);
   // Bitmap abspeichern
      bm->Save(fn,FILTER_BMP,bc);

   // Objekt aktivieren
      fSetActiveObject(vDoc,attraktor);
      GeEventAdd(DOCUMENT_CHANGED);
      attraktor->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);
   // Regel bestimmen

   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Gruppe für die Parameter der Berechnung
      AddGroupBeginV(1002,BFH_CENTER,2,"",0);
      {
         AddStaticText(0,BFH_LEFT,Breite,0," Länge Integer",0);
         AddEditNumberArrows(2007,BFH_LEFT,100,0);
         AddStaticText(0,BFH_LEFT,Breite,0," Kantenlänge",0);
         AddEditNumberArrows(2008,BFH_LEFT,100,0);
         AddStaticText(0,BFH_LEFT,Breite,0," Teiler",0);
         AddEditNumberArrows(2009,BFH_LEFT,100,0);
      }
      // Vertikal orientierte Gruppe schliessen
         AddGroupEnd();
   // Waagerechte Trennlinie
      AddSeparatorH(0);
      AddCheckbox(2010,BFH_LEFT,0,0," Negativbild");

   // 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()
   {
     SetInt(2007,N,0,512,1);
     SetInt(2008,G,0,512,1);
     SetInt(2009,D,0,99,1);
  // Arrays erzeugen
     IntA = new(array,N);
     IntB = new(array,N);
     IntC = new(array,N);
   // Arrays auf Null setzten
      for (i=0;i<N;i++)
          {
           IntA[i]=0;
           IntB[i]=0;
           IntC[i]=0;
           }
   Negativ=TRUE;
   SetCheckbox(2010,TRUE);
   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;
                         fPascal(vDoc);
                      }
        case 2007 : N=GetInt(2007);
        case 2008 : G=GetInt(2008);
        case 2009 : D=GetInt(2009);
        case 2010 : Negativ=GetCheckbox(2010);

      }
      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);
}