// Mondrian - This program randomly generates modern art in the 
// style of Piet Mondrian (1872 - 1944). You may use and change 
// this software as you wish.
// Cleve Lendon 1999  klivo@infotrans.or.jp

// Mondrian - Ĉi tiu programo kreas modernan arton laŭ la stilo de 
// Piet Mondrian (1872 - 1944). Vi rajtas uzi kaj ŝanĝi ĉi tiun
// softaron laŭ via plaĉo.
// Klivo 1999  klivo@infotrans.or.jp

import java.applet.*;
import java.awt.*;
import java.util.*;


public class Mondrian extends Applet implements Runnable {

   Thread    fadeno = null;

   // Hazardaj numeroj.
   Random hazarda  = new Random();

   static int  maks_x, maks_y;  // Maksimumoj de la kanvaso.

   final static int  maks_linioj = 7;  // maksimuma nombro da linioj.
   final static int  maks_rektanguloj = 7;  // maksimuma nombro da rektanguloj
   int n_vertikalaj;    // nombro da vertikalaj linioj
   int n_horizontalaj;  // nombro da horizontalaj linioj
   int n_rektanguloj;   // nombro da rektanguloj

   Linio[] v_linioj    = new Linio[maks_linioj*2];   // vertikalaj linioj
   Linio[] h_linioj    = new Linio[maks_linioj*2];   // horizontalaj linioj
   Rekt[]  rektanguloj = new Rekt[maks_rektanguloj]; 

   final static int  l_largheco = 5;   // larĝeco de linio
   final static int  l_spaco = 20;     // spaco inter linioj

   public Mondrian()
   {
      super();
   }



   // La metodo "main" funkcias nur en memstaraj aplikaĵoj, ne en retprogramoj.
   public static void main (String args[]) {

      Frame   frame = new Frame("   Mondrian - Klivo 1999");
      frame.show();
      frame.hide();
      frame.resize(380,250);
      frame.show();

      Mondrian  mondrian = new Mondrian();

      frame.add("Center",mondrian);
      mondrian.init();
      maks_x = 380;
      maks_y = 250;
      frame.show();
      mondrian.start();

   }  // fino de main


   public void init()
   {

      fadeno = new Thread(this);  // Kreu la fadenon.
      fadeno.start();

      maks_x = size().width;
      maks_y = size().height;

      repaint();

   }   // fino de Init()


   public void paint (Graphics g) {

      int nom;   // nombro da kreotaj linioj
      n_vertikalaj = 0;
      n_horizontalaj = 0;

      g.setColor(Color.white);
      g.fillRect(0,0,maks_x,maks_y);
      g.setColor(Color.black);
      //desegnu_kradon(g);
      nom = (int)((hazarda.nextFloat() * maks_linioj) / 1.0 + 1.0);
      kreu_v_liniojn(nom);
      nom = (int)((hazarda.nextFloat() * maks_linioj) / 1.0 + 1.0);
      kreu_h_liniojn(nom);
      nom = (int)((hazarda.nextFloat() * 4) / 1.0 + 1.0);
      kreu_v_liniojn2(nom);
      nom = (int)((hazarda.nextFloat() * 4) / 1.0 + 1.0);
      kreu_h_liniojn2(nom);
      kreu_rektangulojn();
      desegnu_rektangulojn(g);
      desegnu_v_liniojn(g);
      desegnu_h_liniojn(g);

   }   // fino de "paint"

   
   public boolean mouseDown(Event evt, int mus_x, int mus_y) {
      repaint();
      return true;
   }

   public void start() {
      if (fadeno.isAlive()) {
         fadeno.resume();
      } 
      else {
         fadeno.start();
      }
      repaint();
   }

   public void stop() {
       fadeno.suspend();
   }

   public void destroy() {
      fadeno.stop();
   }

   public void run() {
      while (true) {
         repaint();
         try {
            Thread.sleep(60000);
         }
         catch (InterruptedException e) {
            stop();
         }
      }     // fino de while
   }  // fino de run



   // Informoj de la retprogramo:
   //----------------------------------------
      public String getAppletInfo()
      {
         return "Mondrian Versio 1.0\n" +
         "Moderna arto.\n" +
         "Verkita de Klivo  (klivo@infotrans.or.jp)\n" +
         "Junio, 1999\n";
      }

   
   void desegnu_kradon (Graphics g) {

      int  x,y;

      // vertikalaj linioj
      for (x = 0; x < maks_x; x = x + l_spaco) {
         g.drawLine(x,0,x,maks_y);
      }
      // horizontalaj linioj
      for (y = 0; y < maks_y; y = y + l_spaco) {
         g.drawLine(0,y,maks_x,y);
      }
   }

   void kreu_v_liniojn (int nombro) {
      int x;
      for (int i = 0; i < nombro; i++) {
         x = (int)((hazarda.nextFloat() * maks_x) / l_spaco) * l_spaco;
         v_linioj[i] = new Linio(x,0,x,maks_y);
         n_vertikalaj++;
      }
   }

   // kreu_v_liniojn2 similas al la supra metodo, sed la finoj de la 
   // linioj ne necese estas la rando de la kanvaso. Ĝi povas
   // finiĝi ĉe alia linio
   void kreu_v_liniojn2 (int nombro) {
      int x,y;
      for (int i = 0; i < nombro; i++) {
         x = (int)((hazarda.nextFloat() * maks_x) / l_spaco) * l_spaco;
         y = (int)((hazarda.nextFloat() * maks_y) / l_spaco) * l_spaco;
         v_linioj[n_vertikalaj] = new Linio(x,supra_flanko(x,y),x,malsupra_flanko(x,y));
         n_vertikalaj++;
      }
   }

   void kreu_h_liniojn (int nombro) {
      int y;
      for (int i = 0; i < nombro; i++) {
         y = (int)((hazarda.nextFloat() * maks_y) / l_spaco) * l_spaco;
         h_linioj[i] = new Linio(0,y,maks_x,y);
         n_horizontalaj++;
      }
   }


   // kreu_h_liniojn2 similas al la supra metodo, sed la finoj de la 
   // linioj ne necese estas la rando de la kanvaso. Ĝi povas
   // finiĝi ĉe alia linio
   void kreu_h_liniojn2 (int nombro) {
      int x,y;
      for (int i = 0; i < nombro; i++) {
         x = (int)((hazarda.nextFloat() * maks_x) / l_spaco) * l_spaco;
         y = (int)((hazarda.nextFloat() * maks_y) / l_spaco) * l_spaco;
         h_linioj[n_horizontalaj] = new Linio(maldekstra_flanko(x,y),y,dekstra_flanko(x,y),y);
         n_horizontalaj++;
      }
   }


   void desegnu_v_liniojn (Graphics g) {
      int  alt; 
      for (int i = 0; i < n_vertikalaj; i++) {
         alt = v_linioj[i].y2 - v_linioj[i].y1;
         g.fillRect(v_linioj[i].x1, v_linioj[i].y1, l_largheco, alt);
      }
   }

   void desegnu_h_liniojn (Graphics g) {
      int  longeco; 
      for (int i = 0; i < n_horizontalaj; i++) {
         longeco = h_linioj[i].x2 - h_linioj[i].x1;
         g.fillRect(h_linioj[i].x1, h_linioj[i].y1, longeco, l_largheco);
      }
   }


   void kreu_rektangulojn () {
      int x,y;
      int maldekstro, supro;
      int alt, lar;
      n_rektanguloj = (int)((hazarda.nextFloat() * maks_rektanguloj) / 1.0 + 1.0);
      if (n_rektanguloj >= maks_rektanguloj) n_rektanguloj = maks_rektanguloj / 2;
      for (int i = 0; i < n_rektanguloj; i++) {
         x = (int)(hazarda.nextFloat() * maks_x);
         y = (int)(hazarda.nextFloat() * maks_y);
         maldekstro = maldekstra_flanko(x,y);
         supro = supra_flanko(x,y);
         alt = malsupra_flanko(x,y) - supro;
         lar = dekstra_flanko(x,y) - maldekstro;
         rektanguloj[i] = new Rekt(maldekstro, supro, lar, alt);
      }
   }

   // Trovu la maldekstran flankon de rektangulo.
   int maldekstra_flanko(int x, int y) {
      int maldekstra = 0;
      int x2;
      for (int i = 0; i < n_vertikalaj; i++) {
         x2 = v_linioj[i].x1;
         if ((y > v_linioj[i].y1 && y < v_linioj[i].y2) &&
             (x2 > maldekstra && x2 < x)) maldekstra = x2;
      }
      return maldekstra;
   }

   // Trovu la dekstran flankon de rektangulo.
   int dekstra_flanko(int x, int y) {
      int dekstra = maks_x;
      int x2;
      for (int i = 0; i < n_vertikalaj; i++) {
         x2 = v_linioj[i].x1;
         if ((y > v_linioj[i].y1 && y < v_linioj[i].y2) &&
             (x2 < dekstra && x2 > x)) dekstra = x2;
      }
      return dekstra;
   }

   // Trovu la supran flankon de rektangulo.
   int supra_flanko(int x, int y) {
      int supra = 0;
      int y2;
      for (int i = 0; i < n_horizontalaj; i++) {
         y2 = h_linioj[i].y1;
         if ((x > h_linioj[i].x1 && x < h_linioj[i].x2) &&
             (y2 > supra && y2 < y)) supra = y2;
      }
      return supra;
   }

   // Trovu la malsupran flankon de rektangulo.
   int malsupra_flanko(int x, int y) {
      int malsupra = maks_y;
      int y2;
      for (int i = 0; i < n_horizontalaj; i++) {
         y2 = h_linioj[i].y1;
         if ((x > h_linioj[i].x1 && x < h_linioj[i].x2) &&
             (y2 < malsupra && y2 > y)) malsupra = y2;
      }
      return malsupra;
   }


   void desegnu_rektangulojn (Graphics g) {

      for (int i = 0; i < n_rektanguloj; i++) {
         g.setColor(elektu_koloron());
         g.fillRect(rektanguloj[i].x, rektanguloj[i].y,
         rektanguloj[i].l, rektanguloj[i].a);
      }
         g.setColor(Color.black);
   }

   Color  elektu_koloron() {
      int koloro;
      koloro = (int)(hazarda.nextFloat() * 4);
      if (koloro == 0) return Color.black;
      if (koloro == 1) return Color.blue;
      if (koloro == 2) return Color.red;
      if (koloro == 3) return Color.yellow;
      return Color.black;
   }

}  // fino de Mondrian





class Linio {

   public int   x1,y1, x2,y2;

   public Linio(int a1, int a2, int a3, int a4) {
      x1 = a1;
      y1 = a2;
      x2 = a3;
      y2 = a4;
   }

}  //  Linio


class Rekt {

   public int   x,y, l,a;

   public Rekt(int a1, int a2, int a3, int a4) {
      x = a1;
      y = a2;
      l = a3;
      a = a4;
   }

}  //  Rekt