package com.ximple.io.dgn7;
|
|
//~--- JDK imports ------------------------------------------------------------
|
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.ListIterator;
|
|
import org.apache.log4j.Logger;
|
|
import com.vividsolutions.jts.geom.Coordinate;
|
import com.vividsolutions.jts.geom.Geometry;
|
import com.vividsolutions.jts.geom.GeometryFactory;
|
import com.vividsolutions.jts.geom.CoordinateList;
|
|
import com.ximple.util.DgnUtility;
|
|
/**
|
* TextNodeElement
|
*
|
* @author Ulysses
|
* @version 0.1
|
* @since 2006/5/18 下午 04:02:58
|
*/
|
public class TextNodeElement extends Element implements ComplexElement, GeometryConverter
|
{
|
private static final Logger logger = Logger.getLogger(TextElement.class);
|
|
private ArrayList list = new ArrayList();
|
|
public TextNodeElement(byte[] raw)
|
{
|
super(raw);
|
}
|
|
public int size()
|
{
|
return list.size();
|
}
|
|
public boolean isEmpty()
|
{
|
return list.isEmpty();
|
}
|
|
public boolean contains(Object o)
|
{
|
return list.contains(o);
|
}
|
|
public Iterator iterator()
|
{
|
return list.iterator();
|
}
|
|
public Object[] toArray()
|
{
|
return list.toArray();
|
}
|
|
public boolean add(Object o)
|
{
|
return list.add(o);
|
}
|
|
public boolean remove(Object o)
|
{
|
return list.remove(o);
|
}
|
|
public boolean addAll(Collection c)
|
{
|
return list.addAll(c);
|
}
|
|
public boolean addAll(int index, Collection c)
|
{
|
return list.addAll(index, c);
|
}
|
|
public void clear()
|
{
|
list.clear();
|
}
|
|
public Object get(int index)
|
{
|
return list.get(index);
|
}
|
|
public Object set(int index, Object element)
|
{
|
return list.set(index, element);
|
}
|
|
public void add(int index, Object element)
|
{
|
list.add(index, element);
|
}
|
|
public Object remove(int index)
|
{
|
return list.remove(index);
|
}
|
|
public int indexOf(Object o)
|
{
|
return list.indexOf(o);
|
}
|
|
public int lastIndexOf(Object o)
|
{
|
return list.lastIndexOf(o);
|
}
|
|
public ListIterator listIterator()
|
{
|
return list.listIterator();
|
}
|
|
public ListIterator listIterator(int index)
|
{
|
return list.listIterator(index);
|
}
|
|
public List subList(int fromIndex, int toIndex)
|
{
|
return list.subList(fromIndex, toIndex);
|
}
|
|
public boolean retainAll(Collection c)
|
{
|
return list.retainAll(c);
|
}
|
|
public boolean removeAll(Collection c)
|
{
|
return list.removeAll(c);
|
}
|
|
public boolean containsAll(Collection c)
|
{
|
return list.containsAll(c);
|
}
|
|
public Object[] toArray(Object[] a)
|
{
|
return list.toArray(a);
|
}
|
|
public String[] getTextArray()
|
{
|
ArrayList list = new ArrayList();
|
|
for (ListIterator it = listIterator(); it.hasNext();)
|
{
|
Element element = (Element) it.next();
|
|
if (element instanceof TextElement)
|
{
|
list.add(((TextElement) element).getText());
|
}
|
}
|
|
return (String[]) list.toArray(new String[list.size()]);
|
}
|
|
public Geometry toGeometry(GeometryFactory factory)
|
{
|
/*
|
* CoordinateList coords = new CoordinateList();
|
* for (ListIterator it = listIterator(); it.hasNext(); )
|
* {
|
* Element element = (Element) it.next();
|
* if (element instanceof TextElement)
|
* {
|
* coords.add(((TextElement) element).getUserOrigin());
|
* }
|
* }
|
*/
|
return factory.createPoint(getOrigin());
|
|
// return factory.createMultiPoint(coords.toCoordinateArray());
|
}
|
|
public Geometry toAnchorGeometry(GeometryFactory factory)
|
{
|
CoordinateList coords = new CoordinateList();
|
for (int i = 0; i < size(); i++)
|
{
|
TextElement txtElm = (TextElement) get(i);
|
coords.add(txtElm.toAnchorCoordinates());
|
}
|
return factory.createMultiPoint(coords.toCoordinateArray());
|
}
|
|
public int getTotalWords()
|
{
|
return (raw[18] & 0x0000ffff);
|
}
|
|
public void setTotalWords(int value)
|
{
|
raw[18] = (short) (value & 0x0000ffff);
|
}
|
|
public int getNumString()
|
{
|
return (raw[19] & 0x0000ffff);
|
}
|
|
public void setNumString(int value)
|
{
|
raw[19] = (short) (value & 0x0000ffff);
|
}
|
|
public int getNodeNumber()
|
{
|
return (raw[20] & 0x0000ffff);
|
}
|
|
public void setNodeNumber(int value)
|
{
|
raw[20] = (short) (value & 0x0000ffff);
|
}
|
|
public int getMaxLength()
|
{
|
return (raw[21] & 0x00ff);
|
}
|
|
public void setMaxLength(int value)
|
{
|
raw[21] = (short) ((value & 0x00ff) | (raw[21] & 0xff00));
|
}
|
|
public int getMaxUsed()
|
{
|
return ((raw[21] >> 8) & 0x00ff);
|
}
|
|
public void setMaxUsed(int value)
|
{
|
raw[21] = (short) (((value << 8) & 0xff00) | (raw[21] & 0x00ff));
|
}
|
|
public int getJustification()
|
{
|
return ((raw[22] >> 8) & 0x00ff);
|
}
|
|
public void setJustification(int value)
|
{
|
raw[22] = (short) (((value << 8) & 0xff00) | (raw[22] & 0x00ff));
|
}
|
|
public int getFontIndex()
|
{
|
return (raw[22] & 0x00ff);
|
}
|
|
public void setFontIndex(int value)
|
{
|
raw[22] = (short) ((value & 0x00ff) | (raw[22] & 0xff00));
|
}
|
|
public double getLineSpacing()
|
{
|
int lineSpace;
|
lineSpace = ((raw[23] & 0x0000ffff) << 16) | (raw[24] & 0x0000ffff);
|
|
return lineSpace;
|
}
|
|
public void setLineSpacing(double value)
|
{
|
int temp = (int) (value*1000.0);
|
raw[23] = (short) ((temp >> 16) & 0x0000ffff);
|
raw[24] = (short) (temp & 0x0000ffff);
|
}
|
|
public double getTextNodeLength()
|
{
|
int lengthMult;
|
|
lengthMult = ((raw[25] << 16) & 0xffff0000);
|
lengthMult += (raw[26] & 0x0000ffff);
|
|
return DgnUtility.converIntToDouble(lengthMult);
|
}
|
|
public void setTextNodeLength(double value)
|
{
|
int temp = DgnUtility.converDoubleToInt(value);
|
raw[25] = (short) ((temp >> 16) & 0x0000ffff);
|
raw[26] = (short) (temp & 0x0000ffff);
|
}
|
|
public double getTextNodeHeight()
|
{
|
int heightMult;
|
|
heightMult = ((raw[27] << 16) & 0xffff0000);
|
heightMult += (raw[28] & 0x0000ffff);
|
|
return DgnUtility.converIntToDouble(heightMult);
|
}
|
|
public void setTextNodeHeight(double value)
|
{
|
int temp = DgnUtility.converDoubleToInt(value);
|
raw[27] = (short) ((temp >> 16) & 0x0000ffff);
|
raw[28] = (short) (temp & 0x0000ffff);
|
}
|
|
public double getRotationAngle()
|
{
|
int rotation = (raw[29] << 16 & 0xffff0000);
|
rotation += raw[30];
|
|
return DgnUtility.converIntToRotation(rotation);
|
}
|
|
public void setRotationAngle(double value)
|
{
|
int temp = DgnUtility.converRotatioToInt(value);
|
raw[29] = (short) (temp >> 16 & 0x0000ffff);
|
raw[30] = (short) (temp & 0x0000ffff);
|
}
|
|
public Coordinate getOrigin()
|
{
|
int x = ((raw[31] << 16) & 0xffff0000) | (raw[32] & 0x0000ffff);
|
double dx = DgnUtility.converUnitToCoord(x);
|
// return DgnUtility.convertFromDGN(x);
|
|
int y = ((raw[33] << 16) & 0xffff0000) | (raw[34] & 0x0000ffff);
|
double dy = DgnUtility.converUnitToCoord(y);
|
|
return new Coordinate(dx, dy);
|
}
|
|
public void setOrigin(Coordinate value)
|
{
|
int x = DgnUtility.converCoordToUnit(value.x);
|
raw[31] = (short) (x >> 16 & 0x0000ffff);
|
raw[32] = (short) (x & 0x0000ffff);
|
|
int y = DgnUtility.converCoordToUnit(value.y);
|
raw[33] = (short) (y >> 16 & 0x0000ffff);
|
raw[34] = (short) (y & 0x0000ffff);
|
}
|
|
public Object clone() throws CloneNotSupportedException
|
{
|
int pos = this.rawBuffer.position();
|
this.rawBuffer.position(0);
|
byte[] rawBytes = this.rawBuffer.array();
|
byte[] otherRaw = new byte[rawBytes.length];
|
System.arraycopy(rawBytes, 0, otherRaw, 0, rawBytes.length);
|
this.rawBuffer.position(pos);
|
|
TextNodeElement other = new TextNodeElement(otherRaw);
|
for (Object o : this)
|
{
|
TextElement textElm = (TextElement) o;
|
other.add(textElm.clone());
|
}
|
|
return other;
|
}
|
|
public static class ElementHandler extends Element.ElementHandler
|
{
|
private static ElementHandler instance = null;
|
|
public ElementHandler()
|
{
|
super(ElementType.TEXTNODE);
|
}
|
|
public static IElementHandler getInstance()
|
{
|
if (instance == null)
|
{
|
instance = new ElementHandler();
|
}
|
|
return instance;
|
}
|
|
protected Element createElement(byte[] raw)
|
{
|
return new TextNodeElement(raw);
|
}
|
}
|
}
|
