Klassen des Pakets AstroOL/beans: Zur Doku-Startseite Zurück zur Homepage

Klasse Primaries

Javadoc von Primaries   Primaries.java herunterladen

package AstroOL.beans;

import AstroOL.Calculator;
import AstroOL.Horoscope;
import AstroOL.Direct;
import AstroOL.Mundan;
import AstroOL.Direction;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.Properties;
import java.io.StringWriter;
import java.text.ParseException;

/** Bean-Klasse für den Einsatz in der Java Server Page
    <a href="./doc-files/primaries.html">primaries.jsp</a>,
    mit welcher man Listen von Primärdirektionen erstellen kann. */
public class Primaries {

/** Mit der Datei PrimariesSettings.ini steuerbare Einstellungen */
    private static Properties settings;
    static {
     try {
       settings = new Properties();
       settings.load(Primaries.class.getResourceAsStream( "PrimariesSettings.ini" ));
       } catch (java.io.IOException ex) {
           System.out.println("Kann Datei PrimariesSettings.ini nicht finden");
           }
     }

    /** Wurzelverzeichnis für Graphiken */
    private static final String GRAPHICS = settings.getProperty("graphics");
    private static final String IMG1 = "<img border=\"0\" src=\"" + GRAPHICS;
    private static final String IMG2 = ".gif\">";

    /** Die drei Werte, die ein Horoskop bestimmen */
    private double jd = 0, lon = 0, lat = 0;

    // Steuergrössen für die Direktionsliste
    /** Intervall */
    private int jahrVon, jahrBis;
    /** - Aspektumfang */
    private long sensPtScope = Horoscope.sensPtAsp;

    /** Eingabefeld für Direktionsformel */
    private String dirForm;

    /** Panel */
    private String panel = "horo";  // Defaultseite ist die Horoskopeingabe
    private String oldPanel = "";
    public boolean panelChanged = false;

    // Steuergrössen für die Direktionsrechnung
    /** Mundanes Positionssystem (Placidus, Regiomontanus, etc.) */
    private int hsys = Mundan.PLACIDUS;
    /** Direktionsverfahren (Standard, Kühr, Goldmayer) */
    private byte dirsys = Direct.STANDARD;
    /** Direktionsschlüssel */
    private byte key = Direct.keyPtolemaeus;
    /** Promissoren mit Breite rechnen? */
    private boolean promLat = false;
    /** Signifikatoren mit Breite rechnen? */
    private boolean sigLat = false;
    /** Nur direkte Direktionen */
    private boolean onlyDirect = false;

    /** Meldungszeile für Nachrichtenausgabe */
    private String msg;
    /** Meldungstyp 'E', 'W', 'I' für Fehler, Warnung oder Info */
    private char msgType = ' ';
    /** Flag, ob Eingaben die Validierung überstanden haben */
    private boolean isValid = true;

    /** Instanz des Direktionsrechners */
    private Direct d;
    /** Instanz des Horoskops */
    private Horoscope h;
    /** Instanz der errechneten Direktionsliste */
    private ArrayList dirList;

    /** Signifikatorenliste */
    private String sigFilter = "pam";
    private static final int[] PAM = new int[] { 0,1,2,3,4,5,6,7,8,9,10,11 };
    private static final int[] PT = new int[] { 0,1,10,11 };
    private static final int[] P7 = new int[] { 0,1,2,3,4,5,6 };
    private static final int[] AM = new int[] { 10,11 };
    private int[] sigList = PAM;




    public Primaries() {
    /** Defaultwerte setzen, die erst zur Laufzeit bestimmt werden können: */
      jahrVon = Calendar.getInstance().get(Calendar.YEAR) - 5;
      jahrBis = jahrVon + 10;
      }


    /** Setter für Panel */
    public void setPanel(String iPanel) {
      panelChanged = !panel.equals(iPanel);
      oldPanel = panel;
      panel    = iPanel;
      }

    public String getPanel() {
      return panel;
      }


    /** Setter für das Jahr, ab dem Direktionen zu berechnen sind */
    public void setJahrVon(int iJahrVon) {
      jahrVon = iJahrVon;
      }

    /** Getter für das Jahr, ab dem Direktionen zu berechnen sind */
    public int getJahrVon() {
      return jahrVon;
      }

    /** Setter für das Jahr, bis zu dem Direktionen zu berechnen sind */
    public void setJahrBis(int iJahrBis) {
      jahrBis = iJahrBis;
      }

    /** Getter für das Jahr, bis zu dem Direktionen zu berechnen sind */
    public int getJahrBis() {
      return jahrBis;
      }


    /** Setter für den Promissorenfilter */
    public void setSensPtScope(long iSensPtScope) {
      sensPtScope = iSensPtScope;
      }

    /** Getter für den Promissorenfilter */
    public long getSensPtScope() {
      return sensPtScope;
      }


    /** Setter für Direktionsformel */
    public void setDirForm(String iDirForm) {
      dirForm = iDirForm;
      }

    /** Getter für Direktionsformel */
    public String getDirForm() {
      return dirForm;
      }

    /** Setter für Direktionsformel */
    public void setKey(byte iKey) {
      key = iKey;
      if (d!=null) d.key = key;
      }

    /** Setter für Direktionsformel */
    public byte getKey() {
      return key;
      }

    /** Setter für das Direktionssystem */
    public void setDirsys(byte iDirsys) {
      dirsys = iDirsys;
      if (d!=null) {
        d.dirsystem = dirsys;
        if (dirsys==Direct.GOLDMAYER) d.setHsys( Mundan.REGIOMONTANUS );
        else d.setHsys( Mundan.PLACIDUS );
       }
      }

    /** Getter für das Direktionssystem */
    public byte getDirsys() {
      return dirsys;
      }

    /** Setter für das Häusersystem */
    public void setHsys(int iHsys) {
      hsys = iHsys;
      }

    /** Getter für das Häusersystem */
    public int getHsys() {
      return hsys;
      }

    /** Setter für das Kennzeichen "Promissoren mit Breite rechnen" */
    public void setPromLat(boolean iPromLat) {
      promLat = iPromLat;
      }

    /** Getter für das Kennzeichen "Promissoren mit Breite rechnen" */
    public boolean getPromLat() {
      return promLat;
      }

    /** Setter für das Kennzeichen "Signifikatoren mit Breite rechnen" */
    public void setSigLat(boolean iSigLat) {
      sigLat = iSigLat;
      if (d!=null) d.sigBreite = sigLat;
      }

    /** Getter für das Kennzeichen "Signifikatoren mit Breite rechnen" */
    public boolean getSigLat() {
      return sigLat;
      }

    /** Setter für das Kennzeichen "Nur direkte Direktionen" */
    public void setOnlyDirect(boolean iOnlyDirect) {
      onlyDirect = iOnlyDirect;
      }

    /** Getter für das Kennzeichen "Signifikatoren mit Breite rechnen" */
    public boolean getOnlyDirect() {
      return onlyDirect;
      }

    /** Setter für den Signifikatorenfilter */
    public void setSigFilter(String iSigFilter) {
      sigFilter = iSigFilter;
      if (sigFilter.equals("pt")) sigList = PT;
      else if (sigFilter.equals("p7")) sigList = P7;
      else if (sigFilter.equals("pam")) sigList = PAM;
      else if (sigFilter.equals("am")) sigList = AM;
      }

    public String getSigFilter() {
      return sigFilter;
      }

    /** Setter für Julianisches Datum */
    public void setJd(double iJd) {
      jd = iJd;
      if ( (Calculator.calendarDate( jd )[0] < (jahrVon-180)) ||
           (Calculator.calendarDate( jd )[0] > jahrVon ) ) {
           jahrVon = Calculator.calendarDate( jd )[0] + 1;
           jahrBis = jahrVon + 10;
           }
      }

    /** Getter für Julianisches Datum */
    public double getJd() {
      return jd;
      }


    /** Setter für geographische Länge */
    public void setLon(double iLon) {
      lon = iLon;
      }


    /** Getter für geographische Länge */
    public double getLon() {
      return lon;
      }


    /** Setter für geographische Breite */
    public void setLat(double iLat) {
      lat = iLat;
      }

    /** Getter für geographische Breite */
    public double getLat() {
      return lat;
      }


    /** Gibt 'wahr' zurück, wenn die Eingabeüberprüfungen keinen Fehler brachten. */
    public boolean isValid() {
      return isValid;
      }


    /** Nach Neueingabe eines Horoskops muss auch eine neue Horoskopinstanz gebildet werden */
    public void actualize() {
      if ((h==null)||(d==null)||(jd != h.jd)||(lat!=h.lat)||(lon!=h.lon)) {
        h = new Horoscope(jd,lon,lat);
        d = new Direct( h, dirsys, key );
        // Aktualisierung invalidiert die Direktionsliste
        dirList = null;
        }
      }


    /** Eingabeüberprüfungen durchführen. Das Ergebnis wird im globalen Flag {@link #isValid isValid}
    gespeichert, das auch mit der Methode {@link #isValid isValid()} abgefragt werden kann.
    @param iNew Bestehende, bereits gesammelte Fehler löschen (neu prüfen)
    @returns Wahr, wenn die Eingaben alle Prüfungen bestanden haben. */
    public boolean validate(boolean iNew) {

      int radixJahr;

      // Wenn Eingabeüberprüfungen bereits Fehler brachten - nicht weitermachen
      if (!isValid && !iNew) return false;

      // Beginn der Prüfungen
      isValid = false;
      resetMsg();

      if (panel.equals("list")) {

        // Jahr Untergrenze < Obergrenze
        if (jahrVon > jahrBis)
          { addMsg( 'E', "'Jahr von' ist grösser als 'Jahr bis'");
            return (isValid=false); }

        // Jahr Untergrenze darf nicht vor Radixjahr liegen
        radixJahr = Calculator.calendarDate( h.jd )[0];

        if (radixJahr > jahrVon)
          { addMsg( 'E', "'Jahr von' ist kleiner als das Radixjahr");
            return (isValid=false); }

        // Jahr von darf Radixjahr nicht um 180 Jahre übersteigen
        if (jahrVon > (radixJahr + 180))
           { addMsg( 'E', "'Jahr von' darf Radixjahr nicht um 180 Jahre überschreiten");
             return (isValid=false); }

        }

      // Im Detailbild
      else if (panel.equals("detail")) {
        if ((dirForm != null) && (dirForm.length() > 0))
          try {
            Direction.parseForm(dirForm);
            }  catch (ParseException ex) {
                 addMsg( 'E', ex.getMessage() );
                 return (isValid=false);
                 }
        }

      // Alle Prüfungen bestanden
      return (isValid = true);

      }

    /** Eingabeüberprüfungen durchführen. Zu Beginn der Prüfungen wird ein etwaiger Fehlerstatus
        zurückgesetzt. Ein etwaiger Panel-Wechsel wird rückgängig gemacht, falls die
        Validierung nicht erfolgreich war.
        @returns Wahr, wenn die Eingaben alle Prüfungen bestanden haben. */
    public boolean validate() {
      if (!validate(true)) {
        panel = oldPanel;
        panelChanged = false;
        }
      return isValid;
      }

    public void resetMsg() {
      msgType = ' ';
      msg = null;
      }


    public boolean hasMsg() {
      return (msgType != ' ');
      }

    public boolean hasTimePlace() {
      return ((lon!=0)||(lat!=0)||(jd!=0));
      }

    public void addMsg(char iMsgType, String iMsg) {
      msg = iMsg;
      msgType = iMsgType;
      if (iMsgType == 'E') isValid = false;
      }

    /** Message-Zeile für die Ausgabe in der Java Server Page. Wenn im Laufe der
    Eingabevalidierung oder Funktionsbearbeitung Fehler aufgetreten sind, wurde eine
    Meldungszeile gesammelt. Auf diese kann mit der Methode msg2html() zugegriffen
    werden. */
    public String msg2html() {
      String s;
      switch (msgType) {
        case 'E':
          s = "<span class=\"errorMsg\">"+msg+"</span>";
          break;
        case 'W':
          s = "<span class=\"warningMsg\">"+msg+"</span>";
          break;
        case 'I':
          s = "<span class=\"infoMsg\">"+msg+"</span>";
          break;
        default:
          s = "";
          break;
      }
      return s;
    }

  /** Direktionsliste berechnen. Zur Berechnungen werden die Selektionsoptionen
  und Einstellungen gemäss den globalen Attributen {@link AstroOL.Direct#dirsystem dirsystem},
  {@link AstroOL.Direct#key key} usw. der Instanz verwendet.
  @param iNew Liste soll auf jeden Fall neu berechnet werden
  @returns Liste der Direktionen als <code>ArrayList</code>. Jedes Element ist eine
  Instanz der Datenklasse {@link AstroOL.Direction AstroOL.Direction} */
  public ArrayList getDirList(boolean iNew) {
    if (h == null) h = new Horoscope( jd, lon, lat, hsys);
    if (d == null) d = new Direct( h, dirsys, key );
    if ((dirList == null)||iNew) {
      d.sigBreite = sigLat;
      d.onlyDirect = onlyDirect;
      d.dirsystem  = dirsys;
      if (dirsys==Direct.GOLDMAYER) d.setHsys( Mundan.REGIOMONTANUS );
      else d.setHsys( Mundan.PLACIDUS );
      dirList = d.getDirections(
                  h,
                  Calculator.julianDate(jahrVon,1,1,0d),
                  Calculator.julianDate(jahrBis,12,31,0d),
                  sensPtScope,
                  null,
                  sigList);
      }

     return dirList;
    }

  /** Direktionsliste berechnen oder zurückgeben */
  public ArrayList getDirList() { return getDirList(false); }


  /** Direktionsliste im HTML-Format erzeugen. Wenn noch keine Direktionsliste erzeugt wurde
  (daran erkenntlich, dass der private Zeiger <code>dirList</code> noch nicht gebunden ist), wird
  zunächst die Direktionsberechnung mittels Methode {@link #getDirList getDirList()} gerufen.
  @returns Liste der Primärdirektionen im HTML-Format. */
  public String list2html() {

    int[] date;
    int i;
    Direction dir;

    // Stylesheet-Klassen sind zur Laufzeit der Klasse durch die Datei Primaries.ini bestimmt
    String tableClass     = settings.getProperty("tableClass"),
           tdHeadClass    = settings.getProperty("tdHeadClass"),
           tdNameClass    = settings.getProperty("tdNameClass"),
           tdDetailClass  = settings.getProperty("tdDetailClass"),
           tdContentClass = settings.getProperty("tdContentClass");

    if (!hasTimePlace()) return "";
    StringBuffer s = new StringBuffer();
    /** Gegebenenfalls ist die Direktionsliste neu zu berechnen */
    getDirList();
    if (dirList.size() > 0) {
      s.append("<table class=\""+tableClass+"\">\n");
      s.append("<tr><td class=\""+tdHeadClass+"\">Direktion</td><td class=\""+tdHeadClass+"\">Fällig am</td>"+
               "<td class=\""+tdHeadClass+"\">DB</td><td class=\""+tdHeadClass+"\">Ort</td>"+
               "<td class=\""+tdHeadClass+"\">RAMC d.</td><td class=\""+tdHeadClass+"\">RAMC c.</td></tr>\n");
      }
    for (i=0;i<dirList.size();i++) {

      dir = (Direction) dirList.get(i);
      s.append( "<tr>\n");

// Direktionsformel
      s.append( "<td class=\""+tdNameClass+"\" title=\"Details zur Direktion " + dir + "\">"
      + "<a class=\""+tdDetailClass+"\" href=\"javascript:process( 'detail"
      + i + "');\">" + getPlanetRsc(dir.sig) + " " );
      if (dir.prom.planet2 >= 0)
        s.append(getAspectRsc(0)+getPlanetRsc(dir.prom.planet1)+"/"+getPlanetRsc(dir.prom.planet2)+" ");
      else if (dir.prom.aspect < 100)
        s.append(getAspectRsc(dir.prom.aspect)+" "+getPlanetRsc(dir.prom.planet1)+" ");
      else
        s.append("AZM "+getPlanetRsc(dir.prom.planet1)+" ");
// Direkt oder convers
      s.append( dir.direct ? " dir.  \t" : " conv. \t" );
      s.append( "</a></td>\n" );

// Datum in Kalenderdatum konvertieren
      date = Calculator.calendarDate(dir.jd);
      s.append("<td class=\""+tdContentClass+"\">"+date[2]+"."+date[1]+"."+date[0]+"</td>\n");

// Direktionsbogen
      s.append("<td class=\""+tdContentClass+"\">"+Calculator.dms(dir.db,Calculator.GEO|Calculator.SEC)+"</td>\n");


// Ekliptikale Länge
      s.append("<td class=\""+tdContentClass+"\">"+getEclLong(dir.prom.lon)+"</td>\n");


// RAMC direkt
      if (dir.direct) s.append("<td class=\""+tdContentClass+"\">"+Calculator.dms(dir.ramc,Calculator.SEC)+"</td>\n");
      else s.append("<td class=\""+tdContentClass+"\">&nbsp;</td>");

// RAMC convers
      if (!dir.direct) s.append("<td class=\""+tdContentClass+"\">"+Calculator.dms(dir.ramc,Calculator.SEC)+"</td>\n");
      else s.append("<td class=\""+tdContentClass+"\">&nbsp;</td>");

// Zeilenvorschub
      s.append("</tr>\n");
      }

    if (dirList.size() > 0) s.append("</table>");
    return s.toString();
    }

    /** Eine Direktion der Direktionsliste im Detail berechnen */
    public String getDetail(int i) {
      if (dirList == null) { addMsg('E',"Bitte erst Direktionsliste berechnen");
        return null;
        }
      if ((i < 0) || (i > dirList.size())) { addMsg('E',"Ungültiger Index "+i);
        return null;
        }

      return getDetail( (Direction) dirList.get(i) );


    }


    /** Eine Direktion im Detail berechnen */
    public String getDetail(Direction iDir) {
      StringWriter sw = new StringWriter();
      d.setTraceMode(sw);
      double db = d.calcdir(iDir.ls, iDir.bs, iDir.prom.lon, 0d );
      if ((db >= 0) != iDir.direct)
        addMsg( 'W', "Die Direktion ist " + ((db>=0)? "direkt" : "convers"));
      iDir.direct = (db >= 0);
      dirForm = iDir.toString().toLowerCase();
      d.ezeit(h,db);
      d.resetTraceMode();
      return sw.toString();
      }


    /** Die eingegebene Direktionsformel berechnen */
    public String getDetail() {
      try {
        Direction lDir = Direction.parseForm( dirForm, h );
        return getDetail(lDir);
        } catch (Exception ex) {
           addMsg('E', ex.getMessage());
           return "";
           }

      }


    /** Bildnamen ermitteln, unter dem das Aspektsymbol zu finden ist */
    private String getAspectRsc(int aspect) {
      String x = Horoscope.aspectTextShort[aspect].toLowerCase();
      return (x.equals("con")) ? IMG1+"a00" + IMG2 :
                (x.equals("ssq")) ? IMG1 + "squ" + IMG2 :
                (x.equals("squ")) ? IMG1 + "qua" + IMG2 : IMG1 + x + IMG2;
      }

    /** Darstellung eines Planeten oder einer Achse */
    private String getPlanetRsc(int planet) {
      String x;
      if (planet < Horoscope.houseRange)
        return IMG1 + Horoscope.planetTextShort[planet].toUpperCase() + IMG2;
      else return Horoscope.houseTextShort[planet-Horoscope.houseRange-1];
      }

    /** Ekliptikale Länge mit Tierkreiszeichengraphik */
    private String getEclLong( double x ) {
      int i=-1,j;
      String s = Calculator.dms(x,Calculator.ECL+Calculator.SEC);
      for (j=0;j<24;j+=2) {
        i = s.indexOf(Calculator.sknam.substring(j,j+2));
        if (i>=0) break;
        }
      if (i < 0) return s;
      else return s.substring(0,i) + IMG1 + s.substring(i,i+2) + IMG2;
      }


}

Zum Seitenanfang Lizenzbedingungen Der Quellcode wird mit dem GNU source-highlight 1.7 dargestellt