/*
 * BordeElemento.java
 *
 *
 */

package com.uvigo.tMaestro.SCOCreator.tool;

/**
 * Esta clase se utiliza para describir los diferentes elementos de un borde.
 * Se utiliza tambien para pintar el borde sobre un elemento determinado.
 * @author raul
 * @version 0.1
 */
public class BordeElemento {
    
    /**
     * Clase contenida del tipo enumerado empleado para diferenciar diferentes bordes
     * (diferentes formas de dibujar los bordes)
     */
    public enum Tipo {
        /**
         * Indica un tipo de borde compuesto por cuatro lineas
         */
        LINEA,
        /**
         * Indica un tipo de borde compuesto por cuatro lineas punteadas
         */
        PUNTEADO};
        
        /**
         * Indica el grosor de los elementos
         */
        private int iGrosor;
        
        /**
         * Indica el color del borde
         */
        private java.awt.Color oColor;
        
        /**
         * El tipo de borde
         */
        private Tipo eTipo;
        
        
        
        //------------------------------------------------------------------------//
        // METODOS
        //------------------------------------------------------------------------//
        
        
        
        /**
         * Crea una nueva instancia de BordeElemento.
         * Permite especificar las caracterasticas del borde como
         * el color y el grosor
         * @param oColor El color del borde
         * @param iGrosor El grosor del borde
         * @param eTipo El Tipo del borde
         */
        public BordeElemento(java.awt.Color oColor, int iGrosor,Tipo eTipo) {
            this.iGrosor=iGrosor;
            this.oColor=oColor;
            this.eTipo=eTipo;
        }
        
        /**
     * Esta funcion es llamada para pintar el borde de acuerdo
     * con sus caracteristicas sobre el elemento grafico pasado.
     * @param oG El objeto grafico en el que va a aparecer el borde.
     * @param iX El punto x de inicio del dibujado del borde
     * @param iY El punto y de inicio del dibujado del borde
     * @param iWidth La distancia en X en la que se pintara el borde
     * @param iHeight La distancia en Y en la que se pintara el borde
     */
        public void paintBorder(java.awt.Graphics oG,int iX,int iY,int iWidth,int iHeight) {
            
            switch (this.eTipo) {
                case LINEA: paintRectBorder(oG,iX-iGrosor,iY-iGrosor,iWidth+2*iGrosor, iHeight+2*iGrosor);
                break;
                case PUNTEADO: paintDotBorder(oG,iX-iGrosor,iY-iGrosor,iWidth+2*iGrosor, iHeight+2*iGrosor);
                break;
            }
        }
        
        
        /**
         * Esta funcion es llamada para dibujar un borde rectangular formado por cuatro lineas.
         * @param oG El elemento grafico sobre el que pintar el borde.
         * @param iX La coordenada X en donde empezar a pintar
         * @param iY La coordenada Y en donde empezar a pintar
         * @param iWidth La distancia en X en la que se pintara el borde
         * @param iHeight La distancia en Y en la que se pintara el borde
         */
        public void paintRectBorder(java.awt.Graphics oG, int iX, int iY, int iWidth, int iHeight) {
            java.awt.Color oColorAnterior = oG.getColor();
            oG.setColor(this.oColor);
            int i;
            for(i = 0; i < this.iGrosor; i++)  {
                oG.drawRect(iX+i, iY+i, iWidth-i-i-1, iHeight-i-i-1);
            }
            oG.setColor(oColorAnterior);
        }
        
        
        /**
         * Esta funcion es llamada para dibujar un borde rectangular formado por cuatro lineas punteadas.
         * @param oG El elemento grafico sobre el que pintar el borde.
         * @param iX La coordenada X en donde empezar a pintar
         * @param iY La coordenada Y en donde empezar a pintar
         * @param iWidth La distancia en X en la que se pintara el borde
         * @param iHeight La distancia en Y en la que se pintara el borde
         */
        public void paintDotBorder(java.awt.Graphics oG, int iX, int iY, int iWidth, int iHeight) {
            java.awt.Color oColorAnterior = oG.getColor();
            oG.setColor(this.oColor);
            int i;
            int iLenX=0;
            int iLenY=0;
            int iSize=5;
            int iLenLine=0;
            //for(i = 0; i < this.iGrosor; i++)  {
                while (iLenX<iWidth) {
                    iLenLine=iX+iLenX+iSize;
                    if (iLenLine>iX+iWidth) iLenLine=iX+iWidth;
                    oG.drawLine(iX+iLenX,iY,iLenLine,iY);
                    oG.drawLine(iX+iLenX,iY+iHeight,iLenLine,iY+iHeight);
                    iLenX+=2*iSize;
                }
                while (iLenY<iHeight) {
                    iLenLine=iY+iLenY+iSize;
                    if (iLenLine>iY+iHeight) iLenLine=iY+iHeight;
                    oG.drawLine(iX,iY+iLenY,iX,iLenLine);
                    oG.drawLine(iX+iWidth,iY+iLenY,iX+iWidth,iLenLine);
                    iLenY+=2*iSize;
                }
            //}
            oG.setColor(oColorAnterior);
        }
        
        /**
         * Metodo para establecer el color de este borde.
         * @param oColor El nuevo color.
         */
        public void vSetColor(java.awt.Color oColor) {
            this.oColor=oColor;
        }
        
        
        /**
         * Metodo para establecer el grosor del borde.
         * @param iGrosor El nuevo grosor del borde.
         */
        public void vSetGrosor(int iGrosor) {
            this.iGrosor=iGrosor;
        }
        
        /**
         * Devuelve el color actual de este borde
         * @return El color
         */
        public java.awt.Color oGetColor(){
            return this.oColor;
        }
        
        /**
         * Devuelve el grosor actual de este borde
         * @return El grosor
         */
        public int iGetGrosor(){
            return this.iGrosor;
        }
        
        
}
