Klasse HoroCompare

package AstroUI;

import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.net.*;
import java.io.*;
import AstroOL.Calculator;

/** Diese Kindklasse von HoroApplet dient der Darstellung zweier
    Horoskope in einer Zusammenschau.
    Üblicherweise enthält der Innenkreis ein Radix- und der
    Aussenkreis ein abgeleitetes Horoskop (Transite, Solar, Lunar
    o.ä.) */
public class HoroCompare extends HoroApplet {

/** Rote Planetensymbole, werden für die Aussenstände verwendet */
  public static Image[] planet2Image = new Image[10];

/** Ekliptikale Längen der zehn astrologischen Planeten.
    Das Attribut ist zwar öffentlich, von anderen
    Klassen sollte aber nur lesender Zugriff erfolgen. Zum Setzen
    der Planetenstände von aussen verwendet man die Methode
    {@link #setPlanetsAndHousesOut setPlanetsAndHousesOut().}  */
  public double plOut[] = new double[10];

/** Zeichenörter der Planeten<br>
    Wo sich Stellien (Planetenhäufungen) bilden, müssen die
    Planetensymbole entzerrt dargestellt werden. Die Positionen
    der Planetensymbole in der graphischen Darstellung werden
    im Array plGraphOut festgehalten. */
  protected double plGraphOut[] = { };

/** Ekliptikale Längen der zwölf Häuserspitzen, gezählt ab Index 1 */
  public double hOut[] = new double[13];

/** Julianisches Datum (in <i>Weltzeit</i>, nicht Ephemeridenzeit). */
  public double xjdOut;

/** Geographische Länge */
  public double lonOut;

/** Geographische Breite */
  public double latOut;

  protected static final double factor11 = 1.1;
  protected static final double factor101 = 1.02;
  protected static final double factor102 = 1.03;

/** Parameter zum Unterdrücken der Aussenstände */
  public boolean noOut = false;

//Das Applet konstruieren
  public HoroCompare() {
    }

  public void init() {
    if (tracker == null) tracker = new MediaTracker( (Component) this );
    try {
    URL ressourceURL = new URL( getCodeBase().toString() + "rsc/mime/" );
    for ( int i = 0; i < 10; i++ ) {
      HoroCompare.planet2Image[i] = this.getImage( ressourceURL, Calculator.pknam.substring(2*i,2*i+2)+"rot.gif" );
      tracker.addImage(planet2Image[i],0);
      }
    }
    catch(Exception e) {};

// Parmeter, ob Aussenstände angezeigt werden sollen
    noOut = Boolean.valueOf(getParameter("noOut")).booleanValue();

// Super-Initialisierung erst jetzt - denn dort läuft waitForImages()
    tile=.6d;
    rd = .9d;
    super.init();
  }

  public void start() {
     // Parameterwert interpretieren, Horoskopstände berechnen
    String s=null,sOut=null;
    s = getParameter("timePlace");
    if (!noOut) sOut = getParameter("timePlaceOut");
    setTimePlace(s,sOut);
  }


  /** Haus- und Planetenpositionen des Aussenkreises direkt angeben.<br>
      In manchen Fällen ist es gewünscht, die Planetenstände dem Applet
      direkt mitzugeben, zum Beispiel weil es sich um hypothetische Stände
      handelt (beispielsweise das berühmte Thema Mundi, mit fiktiven,
      rein symbolischen Planetenständen, oder die vorgeschobenen oder
      primären Stände zu einem Horoskop, die keine reale Entsprechung mit
      dem Sternenhimmel haben), oder weil man die Stände mit
      einem eigenen Berechnungsprogramm ermittelt hat.<br>
      In diesen Fällen sind die Stände dem Applet mit der Methode
      setPlanetsAndHousesOut() mitzuteilen. Die Methode nimmt einen String
      entgegen, der die Planeten- und Hauslängen enthält.<br>
      @param response Enthält, von den Schlüsselwörtern "planets:" und "houses:"
      gefolgt, die 10 bzw. 12 Positionen als komma-getrennte Liste von
      Doubles.<br>
      Beispiel:
      "planets:15.1,30,45,60,75,90,105,120,135,150<br>
       houses:0,30,60,90,120,150,180,210,240,270,300,330,360" */
  public void setPlanetsAndHousesOut( String response ) {
    Calculator.analyzeString(new BufferedReader(new StringReader(response)), hOut, plOut);
    called = true;
    }

/** Mit dieser Methode kann dem Applet ein neuer Datum/Zeit/Ort-String
    übergeben werden. Das Applet zeichnet sich dann neu
    @param s Datum/Zeit/Ort-String für das innere Horoskop
    @param sOut Datum/Zeit/Ort-String für das äussere Horoskop */
  public void setTimePlace(String s, String sOut) {

     double[] tp = new double[3];
     double[] h0 = new double[13];
     int i;

     if (s != null) {
       if (!Calculator.parseTimePlace(s,tp)) {
         xjd = Calculator.thisjd();
         lon = Calculator.DEFAULT_LON;
         lat = Calculator.DEFAULT_LAT;
         }
       else {
         xjd = tp[0];
         lon = tp[1];
         lat = tp[2];
         }
       }


     if (sOut != null) {
       if (!Calculator.parseTimePlace(sOut,tp)) {
         xjdOut = Calculator.thisjd();
         lonOut = Calculator.DEFAULT_LON;
         latOut = Calculator.DEFAULT_LAT;
         }
       else {
         xjdOut = tp[0];
         lonOut = tp[1];
         latOut = tp[2];
         }
       }

       if ( !called ) {
// Parameter werden dem Applet übergeben
       if ( (Calculator.parseDoubleList(getParameter("planets"),pl) == 10) &&
            (Calculator.parseDoubleList(getParameter("houses"),h) == 12) ) {
// Rechts-Shift der Häuser
         for( i = 11; i >= 0; i--) h[i+1] = h[i];
         h[0] = 0.;
         }
// Parameter durch den Rechner ermitteln
       else {
         calc.getPlanetsAndHouses( xjd, lon, lat, pl, h);
         if (noHouses &&
            ((i=Calculator.parseDoubleList(getParameter("houses"),h0)) > 0) ) {
// Rechts-Shift der Häuser
              for( --i; i >= 0; i--) h[i+1] = h0[i];
              h[0] = 0.;
            }
         }

// Parameter werden dem Applet übergeben
       if ( (Calculator.parseDoubleList(getParameter("planetsOut"),plOut) == 10) &&
            (Calculator.parseDoubleList(getParameter("housesOut"),hOut) == 12) ) {
// Rechts-Shift der Häuser
         for( i = 11; i >= 0; i--) hOut[i+1] = hOut[i];
         hOut[0] = 0.;
         }
// Parameter sind per Request zu ermitteln
       else {
         calc.getPlanetsAndHouses( xjdOut, lonOut, latOut, plOut, hOut);
         if (noHouses &&
            ((i=Calculator.parseDoubleList(getParameter("housesOut"),h0)) > 0) ) {
// Rechts-Shift der Häuser
              for( --i; i >= 0; i--) hOut[i+1] = h0[i];
              hOut[0] = 0.;
            }
         }

       }

// Alles neu zeichnen
    drawAll();

// Paint aufrufen
    update(this.getGraphics());

   }


  /** Den inneren Horoskopkreis anhand des mitgegebenen Datum/Zeit/Ort-Strings neuberechnen */
  public void setTimePlace(String s) {
    setTimePlace(s,null);
    }

/** Aktuelles Julianisches Datum des Aussenkreises zurückgeben.<p>
    Die Funktion ist für den Einsatz des Applets im
    Zusammenspiel mit JavaScript gedacht. */
  public String getJdOut() {
    return Double.toString(xjdOut);
    }

/** Aktuelles Julianisches Datum, Länge und Breite der im Aussenkreis
    dargestellten Konstellationen als String (durch Zeilenumbruch
    getrennt) zurückgeben. Die Funktion ist für den Einsatz des Applets im
    Zusammenspiel mit JavaScript gedacht. */
  public String getTripleOut() {
      return
      Double.toString(xjdOut) + "\n" +
      Double.toString(lonOut) + "\n" +
      Double.toString(latOut) ;
      }

/** Zeit/Ort-String des Aussenkreises zurückgeben. Es wird die Information über Zeit und
    Ort, wie sie auch unterhalb des Horoskopkreises angezeigt wird,
    zurückgegeben.<p>
    Die Funktion ist für den Einsatz des Applets im Zusammenspiel mit JavaScript gedacht. */
  public String getTimePlaceOut() {
    return Calculator.renderTimePlace(xjdOut, lonOut, latOut, precision);
    }

  protected void drawAll() {
    super.drawAll();
// Zeichenpositionen berechnen
    plGraphOut = getPlGraph( plOut );
    drawAllOut();
    }

/** Mit dieser Methode kann dem Applet ein neuer Datum/Zeit/Ort-String
    für den Aussenkreis übergeben werden. Das Applet zeichnet sich dann neu */
  public void setTimePlaceOut(String s) {
     int i;
     double[] tp = new double[3];
     double[] h0 = new double[13];

    if (noOut) return;

       if (!Calculator.parseTimePlace(s,tp)) {
         xjdOut = Calculator.thisjd();
         latOut = Calculator.DEFAULT_LAT;
         lonOut = Calculator.DEFAULT_LON;
         }
       else {
         xjdOut = tp[0];
         lonOut = tp[1];
         latOut = tp[2];
         }

       if ( !called ) {
// Parameter werden dem Applet übergeben
       if ( (Calculator.parseDoubleList(getParameter("planetsOut"),plOut) == 10) &&
            (Calculator.parseDoubleList(getParameter("housesOut"),hOut) == 12) ) {
// Rechts-Shift der Häuser
         for( i = 11; i >= 0; i--) hOut[i+1] = hOut[i];
         h[0] = 0.;
         }
// Parameter durch den Rechner ermitteln
       else {
         calc.getPlanetsAndHouses( xjdOut, lonOut, latOut, plOut, hOut);
         if (noHouses &&
            ((i=Calculator.parseDoubleList(getParameter("housesOut"),h0)) > 0) ) {
// Rechts-Shift der Häuser
              for( --i; i >= 0; i--) hOut[i+1] = h0[i];
              h[0] = 0.;
            }
          }
        }

// Alles neu zeichnen
   drawAll();

// Paint aufrufen
    update(this.getGraphics());

   }

/** Vertauschen der Innen- mit den Aussenständen<br>
    Das Applet vertauscht die aktuellen Innen- mit den Aussenständen
    und zeichnet sich vollständig neu. */
public void toggle() {
 double[] hSave = hOut, plSave = plOut, plGraphSave = plGraphOut;
 double latSave = latOut, lonSave = lonOut, xjdSave = xjdOut;

 hOut = h;
 plOut = pl;
 plGraphOut = plGraph;
 latOut = lat;
 lonOut = lon;
 xjdOut = xjd;

 h = hSave;
 pl = plSave;
 plGraph = plGraphSave;
 lon = lonSave;
 lat = latSave;
 xjd = xjdSave;

 drawAll();
 update(this.getGraphics());

 }

protected void drawAllOut() {
  if (noOut) return;
  drawOuterHoroscope();
  drawPositions2();
// Paint aufrufen
  update(this.getGraphics());
  }

 protected void drawOuterHoroscope() {
      int i;

      if (noOut) return;
      g.setColor(Color.red);
      for (i = 0; i < 10; i++) {
          line( plOut[i], 1., factor101);
          g.drawLine(x(plOut[i], factor101),
                     y(plOut[i], factor101),
                     x(plGraphOut[i], factor102),
                     y(plGraphOut[i], factor102));

          g.drawImage( HoroCompare.planet2Image[i],
                       x(plGraphOut[i],factor11) - HoroApplet.planetImage[i].getWidth(this)/2,
                       y(plGraphOut[i],factor11) - HoroApplet.planetImage[i].getHeight(this)/2,
                         this );
          }


          g.drawLine(x(hOut[1], factor101),
                     y(hOut[1], factor101),
                     x(hOut[1], factor102),
                     y(hOut[1], factor102));

          g.drawString( "ASC" ,
                       x(hOut[1],factor11)-15,
                       y(hOut[1],factor11)+3);

          g.drawLine(x(hOut[10], factor101),
                     y(hOut[10], factor101),
                     x(hOut[10], factor102),
                     y(hOut[10], factor102));

          g.drawString( "MC" ,
                       x(hOut[10],factor11)-12,
                       y(hOut[10],factor11)+3);
      g.setFont(courierplain12);
      double[] tp = { xjdOut, lonOut, latOut};
      int stringwidth = ((precision==Calculator.SEC)?41:30)*g.getFontMetrics().charWidth('1');
      g.drawString( Calculator.renderTimePlace(tp, precision),
                    xm - stringwidth/2,
                    height - d-13*g.getFontMetrics().getHeight()/6
                    );



    }

  protected void drawPositions2() {
    int i;
    int halign2 = width * 140 / 100,
        voffset = 30;
    g.setFont(courierplain12);
    for (i = 0; i < 10; i++) {
       g.drawString(Calculator.dms(plOut[i],Calculator.ECL+precision),
                    halign2,
                    20*i + 13 + voffset );

      }

    for (i = 0; i < 6; i++) {
       g.drawString(Calculator.dms(hOut[i+1],Calculator.ECL+precision),
                    halign2,
                    20*i+223 + voffset );

      }

   g.setFont(courierbold12);
   g.drawString("Aussen",halign2, voffset - 7);


    }


}