| gvSIG desktop 1

/* jdwglib. Java Library for reading Dwg files.

 * 

 * Author: Jose Morell Rama (jose.morell@gmail.com).

 * Port from the Pythoncad Dwg library by Art Haas.

 *

 * Copyright (C) 2005 Jose Morell, IVER TI S.A. and Generalitat Valenciana

 *

 * 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.

 *

 * For more information, contact:

 *

 * Jose Morell (jose.morell@gmail.com)

 * 

 * or

 *

 * IVER TI S.A.

 *  C/Salamanca, 50

 *  46005 Valencia

 *  Spain

 *  +34 963163400

 *  dac@iver.es

 */

package com.iver.cit.jdwglib.dwg.objects;

import java.awt.geom.Point2D;

import java.util.List;

import java.util.Map;

import com.iver.cit.gvsig.fmap.core.FPoint2D;

import com.iver.cit.gvsig.fmap.core.FPoint3D;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.jdwglib.dwg.DwgFile;

import com.iver.cit.jdwglib.dwg.DwgHandleReference;

import com.iver.cit.jdwglib.dwg.DwgObject;

import com.iver.cit.jdwglib.dwg.IDwg2FMap;

import com.iver.cit.jdwglib.dwg.IDwg3DTestable;

import com.iver.cit.jdwglib.dwg.IDwgBlockMember;

import com.iver.cit.jdwglib.dwg.IDwgExtrusionable;

import com.iver.cit.jdwglib.util.AcadExtrusionCalculator;

/**

 * The DwgInsert class represents a DWG Insert

 * 

 * @author jmorell

 */

public class DwgInsert extends DwgObject

        implements IDwgExtrusionable, IDwg3DTestable, IDwg2FMap, IDwgBlockMember {

        public DwgInsert(int index) {

                super(index);

        }

        private double[] insertionPoint;

        private double[] scale;

        private double rotation;

        private double[] extrusion;

        private DwgHandleReference blockHeaderHandle = null;

        private DwgHandleReference firstAttribHandle = null;

        private DwgHandleReference lastAttribHandle = null;

        private DwgHandleReference seqendHandle = null;

        /**

         * An insert could be nexted in other insert.

         * We wont process and insert two times.

         * */

        private boolean processed = false;

        /**

         * @return Returns the blockHeaderHandle.

         */

        public DwgHandleReference getBlockHeaderHandle() {

                return blockHeaderHandle;

        }

        /**

         * @param blockHeaderHandle The blockHeaderHandle to set.

         */

        public void setBlockHeaderHandle(DwgHandleReference blockHeaderHandle) {

                this.blockHeaderHandle = blockHeaderHandle;

        }

        /**

         * @return Returns the firstAttribHandle.

         */

        public DwgHandleReference getFirstAttribHandle() {

                return firstAttribHandle;

        }

        /**

         * @param firstAttribHandle The firstAttribHandle to set.

         */

        public void setFirstAttribHandle(DwgHandleReference firstAttribHandle) {

                this.firstAttribHandle = firstAttribHandle;

        }

        /**

         * @return Returns the insertionPoint.

         */

        public double[] getInsertionPoint() {

                return insertionPoint;

        }

        /**

         * @param insertionPoint The insertionPoint to set.

         */

        public void setInsertionPoint(double[] insertionPoint) {

                this.insertionPoint = insertionPoint;

        }

        /**

         * @return Returns the lastAttribHandle.

         */

        public DwgHandleReference getLastAttribHandle() {

                return lastAttribHandle;

        }

        /**

         * @param lastAttribHandle The lastAttribHandle to set.

         */

        public void setLastAttribHandle(DwgHandleReference lastAttribHandle) {

                this.lastAttribHandle = lastAttribHandle;

        }

        /**

         * @return Returns the rotation.

         */

        public double getRotation() {

                return rotation;

        }

        /**

         * @param rotation The rotation to set.

         */

        public void setRotation(double rotation) {

                this.rotation = rotation;

        }

        /**

         * @return Returns the scale.

         */

        public double[] getScale() {

                return scale;

        }

        /**

         * @param scale The scale to set.

         */

        public void setScale(double[] scale) {

                this.scale = scale;

        }

        /**

         * @return Returns the extrusion.

         */

        public double[] getExtrusion() {

                return extrusion;

        }

        /**

         * @param extrusion The extrusion to set.

         */

        public void setExtrusion(double[] extrusion) {

                this.extrusion = extrusion;

        }

        /**

         * @return Returns the seqendHandle.

         */

        public DwgHandleReference getSeqendHandle() {

                return seqendHandle;

        }

        /**

         * @param seqendHandle The seqendHandle to set.

         */

        public void setSeqendHandle(DwgHandleReference seqendHandle) {

                this.seqendHandle = seqendHandle;

        }

        /* (non-Javadoc)

         * @see com.iver.cit.jdwglib.dwg.IDwgExtrusionable#applyExtrussion()

         */

        public void applyExtrussion() {

                 double[] insertPoint = getInsertionPoint();

         double[] insertExt = getExtrusion();

         insertPoint = AcadExtrusionCalculator.CalculateAcadExtrusion(insertPoint, insertExt);

         setInsertionPoint(insertPoint);

        }

        /* (non-Javadoc)

         * @see com.iver.cit.jdwglib.dwg.IDwg3DTestable#has3DData()

         */

        public boolean has3DData() {

                return (getInsertionPoint()[2] != 0.0);

        }

        public double getZ() {

                return getInsertionPoint()[2];

        }

        public FShape toFMapGeometry(boolean is3DFile) {

                double[] p = getInsertionPoint();

//                Point2D point = new Point2D.Double(p[0], p[1]);

                FPoint2D fPoint;

                /*

                 * double[] scale = ((DwgInsert)entity).getScale(); double rot =

                 * ((DwgInsert)entity).getRotation(); int blockHandle =

                 * ((DwgInsert)entity).getBlockHeaderHandle();

                 */

                // manageInsert(dwgObjects, point, scale, rot, blockHandle, i,

                // auxRow);

                if (is3DFile) {

                        fPoint = new FPoint3D(p[0], p[1], p[2]);

                } else {

                        fPoint = new FPoint2D(p[0], p[1]);

                }

                return fPoint;

        }

        public String toFMapString(boolean is3DFile) {

                if(is3DFile)

                        return "FPoint3D";

                else

                        return "FPoint2D";

        }

        public String toString(){

                return "Insert";

        }

        public void transform2Block(double[] bPoint, Point2D insPoint, 

                        double[] scale, double rot, 

                        List dwgObjectsWithoutBlocks, Map handle_objWithoutBlocks, DwgFile callBack) {

                processed = true;

                double[] p = this.getInsertionPoint();

                Point2D point = new Point2D.Double(p[0], p[1]);

                double[] newScale = this.getScale();

                double newRot = this.getRotation();

                DwgHandleReference newBlockHandle = this.getBlockHeaderHandle();

                Point2D pointAux = new Point2D.Double(point.getX() - bPoint[0], point.getY() - bPoint[1]);

                double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                double laZ = p[2] * scale[2];

                Point2D newInsPoint = new Point2D.Double(laX, laY);

                newScale = new double[]{scale[0]*newScale[0], scale[1]*newScale[1], scale[2]*newScale[2]};

        newRot = newRot + rot;

        if (newRot<0) {

            newRot = newRot + (2*Math.PI);

        } else if (newRot>(2*Math.PI)) {

            newRot = newRot - (2*Math.PI);

        }

        callBack.manageInsert(newInsPoint, 

                                                                newScale, 

                                                                newRot, 

                                                                newBlockHandle.getOffset(), 

                                                                dwgObjectsWithoutBlocks,

                                                                handle_objWithoutBlocks);

        }

        /* (non-Javadoc)

         * @see java.lang.Object#clone()

         */

        public Object clone(){

                DwgInsert obj = new DwgInsert(index);

                this.fill(obj);

                return obj;

        }

        protected void fill(DwgObject obj){

                super.fill(obj);

                DwgInsert myObj = (DwgInsert)obj;

                myObj.setBlockHeaderHandle(blockHeaderHandle);

                myObj.setExtrusion(extrusion);

                myObj.setFirstAttribHandle(firstAttribHandle);

                myObj.setInsertionPoint(insertionPoint);

                myObj.setLastAttribHandle(lastAttribHandle);

                myObj.setRotation(rotation);

                myObj.setScale(scale);

                myObj.setSeqendHandle(seqendHandle);

        }

        public boolean isProcessed() {

                return processed;

        }

        public void setProcessed(boolean processed) {

                this.processed = processed;

        }

}