/*
    *  nextobjects Copyright (C) 2001-2005 Emmanuel Florent
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by the
    *  Free Software Foundation; either version 2 of the License, or (at your
    *  option) any later version.
    *  This program is distributed in the hope that it will
    *  be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
    *  of MERCHANTABILITY or FITNESS FOR A PARTICULAR
   *  PURPOSE. See the GNU General Public License for more details.
   *  You should have received a copy of the GNU General Public License along
   *  with this program; if not, write to the Free Software Foundation, Inc., 59
   *  Temple Place - Suite 330, Boston, MA 02111-1307, USA.
   */
  package org.devaki.nextobjects.workspace.models.graphics;
  import java.io.Serializable;
  import java.awt.Graphics;
  import java.awt.Font;
  import java.awt.Point;
  import javax.swing.UIManager;
  import java.awt.Polygon;
  import org.devaki.nextobjects.util.NOGraphicsUtil;
  import org.devaki.nextobjects.workspace.models.objects.BaseLine;
  import org.devaki.nextobjects.workspace.models.objects.Constraint;
  import org.devaki.nextobjects.workspace.models.columns.Column;
  /***
   *  Draw a Constraint in a PhysicalView of a PhysicalModel
   *
   * @author     <a href="mailto:eflorent@devaki.org">Emmanuel Florent</a>
   * @created    December 22, 2003
   */
  public class ConstraintView extends LineView implements Serializable
  {
      /***  Arrowhead sharpness */
      private double fTheta = Math.toRadians(20);
      /***  Arrowhead length */
      private final int fSize = 15;
      /***
       *  Construct a new 'ConstraintView' object
       *
       * @param  pConstraint  the contextual <code>Constraint</code>
       */
      public ConstraintView(final Constraint pConstraint)
      {
          super(pConstraint);
          selectionPoints[0] =
              ((BaseLine) this.getBaseObject())
                  .getParentClass()
                  .getObjectView()
                  .getSelectionPoint(0);
          selectionPoints[1] =
              ((BaseLine) this.getBaseObject())
                  .getChildClass()
                  .getObjectView()
                  .getSelectionPoint(0);
          computeBestPoints();
      }
      /***
       *  Paint
       *
       * @param  g  the graphics context
       */
      public final void paint(final Graphics g)
      {
          Point p0 =
              ((PhysicalView) myObject.getMyModel().getPanel())
                  .getRectangle()
                  .getLocation();
          Point p1 = selectionPoints[1].getPoint();
          p1.translate(-p0.x, -p0.y);
          Point p2 = selectionPoints[0].getPoint();
          p2.translate(-p0.x, -p0.y);
          int x1 = (int) p1.getX();
          int y1 = (int) p1.getY();
          int x2 = (int) p2.getX();
          int y2 = (int) p2.getY();
          // Set color from style
          g.setColor(this.myStyle.getLineColor());
          if (!((Constraint) this.getBaseObject()).isSelfRef())
          {
              g.drawLine(x1, y1, x2, y2);
          }
          else
          {
              Point p = getCtrlPoint(p2);
              g.drawLine(x1, y1, p.x, p.y);
              g.drawLine(x2, y2, p.x, p.y);
              //used to write smre else ..
              x1 = p.x;
              y1 = p.y;
          }
          g.setFont(
              new Font(
                  ((Font) UIManager.get("Label.font")).getName(),
                  Font.BOLD,
                  ((Font) UIManager.get("Label.font")).getSize()));
          // calculate points for arrowhead
          double angle = Math.atan2(y1 - y2, x1 - x2) + Math.PI;
          int x3 = (int) (x1 + Math.cos(angle - fTheta) * fSize);
         int y3 = (int) (y1 + Math.sin(angle - fTheta) * fSize);
         if (((Column) ((Constraint) this.myObject)
             .getLocalColumns()
             .iterator()
             .next())
             .isRequired())
         {
             g.drawString("1", x3, y3);
         }
         else
         {
             g.drawString("0 ... 1", x3, y3);
         }
         angle = Math.atan2(y2 - y1, x2 - x1) + Math.PI;
         int x4 = (int) (x2 + Math.cos(angle - fTheta) * fSize);
         int y4 = (int) (y2 + Math.sin(angle - fTheta) * fSize);
         x3 = (int) (x2 + Math.cos(angle + fTheta) * fSize);
         y3 = (int) (y2 + Math.sin(angle + fTheta) * fSize);
         g.drawLine(x3, y3, x2, y2);
         g.drawLine(x4, y4, x2, y2);
         x3 = (int) (x2 + Math.cos(angle + fTheta) * fSize * 1.1);
         y3 = (int) (y2 + Math.sin(angle + fTheta) * fSize * 1.1);
         g.drawString("*", x3, y3);
     }
     /***
      *  Gets the ctrlPoint attribute of the ConstraintView object
      *
      * @param  p  Description of the Parameter
      * @return    The ctrlPoint value
      */
     public final Point getCtrlPoint(final Point p)
     {
         int x = p.x;
         int y = p.y;
         int location = SelectionPoint.NORTH;
         SelectionPoint[] pArray =
             ((Constraint) myObject)
                 .getParentClass()
                 .getObjectView()
                 .getSelectionPoints();
         for (int i = 0; i < pArray.length; i++)
         {
             if (pArray[i].getPoint().x == selectionPoints[0].getPoint().x
                 && pArray[i].getPoint().y == selectionPoints[0].getPoint().y)
             {
                 location = i;
             }
         }
         int r = 30;
         switch (location)
         {
             case 2 :
                 // SelectionPoint.NORTH_WEST :
                 x = x - r;
                 y = y - r;
                 break;
             case 6 :
                 //SelectionPoint.WEST :
                 x = x - r;
                 break;
             case 0 :
                 //SOUTH_WEST :
                 x = x - r;
                 y = y + r;
                 break;
             case 5 :
                 //SOUTH:
                 x = x + r;
                 y = y + r;
                 break;
             case 1 :
                 //SOUTH_EAST :
                 //nothing to do
                 x = x + r;
                 y = y + r;
                 break;
             case 7 :
                 //EAST :
                 x = x + r;
                 break;
             case 3 :
                 //NORTH_EAST :
                 y = y - r;
                 y = y - r;
                 break;
             case 4 :
                 //NORTH
             default :
                 x = x - r;
                 y = y - r;
                 break;
         }
         return new Point(x, y);
     }
     /***  Reset the selection point. */
     public void resetSelectionPoint()
     {
     }
     /***
      *  Return the surface on which the user can click to select the object
      *
      * @return    the surface as polygon/shape
      */
     public final Polygon getSurface()
     {
         int delta = 30;
         Point ctrlPoint =
             NOGraphicsUtil.getMiddle(
                 selectionPoints[0].getPoint(),
                 selectionPoints[1].getPoint());
         //selfRef or not ..
         if (((Constraint) this.getBaseObject()).isSelfRef())
         {
             ctrlPoint = getCtrlPoint(selectionPoints[0].getPoint());
         }
         int tmpX1 = (int) ctrlPoint.getX();
         int tmpY1 = (int) ctrlPoint.getY();
         int[] xi = {// +-5 is a seed of noise to avoid having
             // a line when two points are same. Doing like this we have a
             //parralelogram even if two points ares the same ...
             (int) selectionPoints[0].getPoint().x - 5,
                 tmpX1 - delta,
                 (int) selectionPoints[1].getPoint().x + 5,
                 tmpX1 + delta,
                 selectionPoints[0].getPoint().x - 5 };
         int[] yi =
             {
                 selectionPoints[0].getPoint().y,
                 tmpY1 - delta,
                 selectionPoints[1].getPoint().y,
                 tmpY1 + delta,
                 selectionPoints[1].getPoint().y };
         return new Polygon(xi, yi, 4);
     }
 }