001/*
002 * To change this template, choose Tools | Templates
003 * and open the template in the editor.
004 */
005package sec.geo.shape;
006
007import sec.geo.*;
008import sec.geo.kml.KmlOptions.AltitudeMode;
009import armyc2.c2sd.graphics2d.AffineTransform;
010import java.util.ArrayList;
011
012/**
013 *
014 * @author Michael Deutch
015 */
016public class AExtObject {
017    public static final int CAKE = 0;
018    public static final int LINE = 1;
019    public static final int ORBIT = 2;
020    public static final int POINT = 3;
021    public static final int CIRCLE = 4;
022    public static final int RADARC = 5;
023    public static final int POLYARC = 6;
024    public static final int POLYGON = 7;
025    public static final int ROUTE = 8;
026    public static final int TRACK = 9;
027    private int type = -1;
028    private Orbit orbit = null;
029    private Cake cake = null;
030    private Circle circle = null;
031    private Point point = null;
032    private Radarc radarc = null;
033    private Polyarc polyarc = null;
034    private Polygon polygon = null;
035    private Line line = null;
036    private Route route = null;
037    private Track track = null;
038
039    public AExtObject(Object obj) {
040        if (obj instanceof Integer) {
041            this.type = (Integer) obj;
042            switch (type) {
043                case LINE:
044                    line = new Line();
045                    break;
046                case ORBIT:
047                    orbit = new Orbit();
048                    break;
049                case ROUTE:
050                    route = new Route();
051                    break;
052                case TRACK:
053                    track = new Track();
054                    break;
055                case RADARC:
056                    radarc = new Radarc();
057                    break;
058                case CAKE:
059                    cake = new Cake();
060                    break;
061                default:
062                    break;
063            }
064        } //we do not want new objects, this is a pass-thru
065        //because the client is subsequently using the object it's passing
066        else if (obj instanceof Line) {
067            line = (Line) obj;
068            type = LINE;
069        } else if (obj instanceof Route) {
070            route = (Route) obj;
071            type = ROUTE;
072        } else if (obj instanceof Polygon) {
073            polygon = (Polygon) obj;
074            type = POLYGON;
075        } else if (obj instanceof Radarc) {
076            radarc = (Radarc) obj;
077            type = RADARC;
078        } else if (obj instanceof Polyarc) {
079            polyarc = (Polyarc) obj;
080            type = POLYARC;
081        } else if (obj instanceof Orbit) {
082            orbit = (Orbit) obj;
083            type = ORBIT;
084        } else if (obj instanceof Cake) {
085            cake = (Cake) obj;
086            type = CAKE;
087        } else if (obj instanceof Circle) {
088            circle = (Circle) obj;
089            type = CIRCLE;
090        } else if (obj instanceof Point) {
091            point = (Point) obj;
092            type = POINT;
093        } else if (obj instanceof Track) {
094            track = (Track) obj;
095            type = TRACK;
096        }
097
098    }
099
100    public void setMaxDistance(double maxDistanceMeters) {
101        //this.maxDistanceMeters = maxDistanceMeters;
102        //shapeChanged();
103        switch (this.type) {
104            case ORBIT:
105                orbit.setMaxDistance(maxDistanceMeters);
106                break;
107            case RADARC:
108                radarc.setMaxDistance(maxDistanceMeters);
109                break;
110            case POLYARC:
111                polyarc.setMaxDistance(maxDistanceMeters);
112                break;
113            case POLYGON:
114                polygon.setMaxDistance(maxDistanceMeters);
115                break;
116            case LINE:
117                line.setMaxDistance(maxDistanceMeters);
118                break;
119            case CIRCLE:
120                circle.setMaxDistance(maxDistanceMeters);
121                break;
122            case ROUTE:
123                route.setMaxDistance(maxDistanceMeters);
124                break;
125            default:
126                break;
127        }
128    }
129
130    public void addPoint(GeoPoint point) {
131        switch (type) {
132            case LINE:
133                line.addPoint(point);
134                break;
135            case RADARC:
136                //radarc.addPoint(point);
137                break;
138            case ORBIT:
139                orbit.addPoint(point);
140                break;
141            case POLYARC:
142                polyarc.addPoint(point);
143                break;
144            case POLYGON:
145                polygon.addPoint(point);
146                break;
147            case ROUTE:
148                route.addPoint(point);
149                break;
150            default:
151                break;
152        }
153    }
154
155    public void setFlatness(double flatnessDistanceMeters) {
156        switch (type) {
157            case LINE:
158                line.flatnessDistanceMeters = flatnessDistanceMeters;
159                break;
160            case CIRCLE:
161                circle.flatnessDistanceMeters = flatnessDistanceMeters;
162                break;
163            case ORBIT:
164                orbit.flatnessDistanceMeters = flatnessDistanceMeters;
165                break;
166            case RADARC:
167                radarc.flatnessDistanceMeters = flatnessDistanceMeters;
168                break;
169            case POLYARC:
170                polyarc.flatnessDistanceMeters = flatnessDistanceMeters;
171                break;
172            case POLYGON:
173                polygon.flatnessDistanceMeters = flatnessDistanceMeters;
174                break;
175            case ROUTE:
176                route.flatnessDistanceMeters = flatnessDistanceMeters;
177                break;
178            default:
179                break;
180        }
181        shapeChanged();
182    }
183
184    public void setLimit(int limit) {
185        //this.limit = limit;
186        //shapeChanged();
187        switch (type) {
188            case LINE:
189                line.limit = limit;
190                break;
191            case CIRCLE:
192                circle.limit = limit;
193                break;
194            case ORBIT:
195                orbit.limit = limit;
196                break;
197            case RADARC:
198                radarc.limit = limit;
199                break;
200            case POLYARC:
201                polyarc.limit = limit;
202                break;
203            case POLYGON:
204                polygon.limit = limit;
205                break;
206            case ROUTE:
207                route.limit = limit;
208                break;
209            default:
210                break;
211        }
212        shapeChanged();
213    }
214
215    public double getMinAltitude() {
216        //return minAltitudeMeters;
217        switch (type) {
218            case LINE:
219                return line.getMinAltitude();
220            case CIRCLE:
221                return circle.getMinAltitude();
222            case ORBIT:
223                return orbit.getMinAltitude();
224            case POLYARC:
225                return polyarc.getMinAltitude();
226            case POLYGON:
227                return polygon.getMinAltitude();
228            case ROUTE:
229                return route.getMinAltitude();
230            case RADARC:
231                return radarc.getMinAltitude();
232            default:
233                break;
234        }
235        return -1;
236    }
237
238    public double getMaxAltitude() {
239        //return minAltitudeMeters;
240        switch (type) {
241            case LINE:
242                return line.getMaxAltitude();
243            case CIRCLE:
244                return circle.getMaxAltitude();
245            case ORBIT:
246                return orbit.getMaxAltitude();
247            case POLYARC:
248                return polyarc.getMaxAltitude();
249            case POLYGON:
250                return polygon.getMaxAltitude();
251            case ROUTE:
252                return route.getMaxAltitude();
253            case RADARC:
254                return radarc.getMaxAltitude();
255            default:
256                break;
257        }
258        return -1;
259    }
260
261    public AltitudeMode getAltitudeMode() {
262        switch (type) {
263            case LINE:
264                return line.getAltitudeMode();
265            case CIRCLE:
266                return circle.getAltitudeMode();
267            case ORBIT:
268                return orbit.getAltitudeMode();
269            case POLYARC:
270                return polyarc.getAltitudeMode();
271            case POLYGON:
272                return polygon.getAltitudeMode();
273            case ROUTE:
274                return route.getAltitudeMode();
275            case RADARC:
276                return radarc.getAltitudeMode();
277            default:
278                break;
279        }
280        return AltitudeMode.ABSOLUTE;
281    }
282
283    public ArrayList getElements() {
284        if (track != null) {
285            return this.track.elements;
286        } else if (cake != null) {
287            return cake.getElements();
288        } else {
289            return null;
290        }
291    }
292
293    public Object getPathIterator(AffineTransform at) {
294        switch (type) {
295            case LINE:
296                return line.getShape().getPathIterator(at);
297            case ORBIT:
298                return orbit.getShape().getPathIterator(at);
299            case POLYGON:
300                return polygon.getShape().getPathIterator(at);
301            case POLYARC:
302                return polyarc.getShape().getPathIterator(at);
303            case CIRCLE:
304                return circle.getShape().getPathIterator(at);
305            case RADARC:
306                return radarc.getShape().getPathIterator(at);
307            case ROUTE:
308                return route.getShape().getPathIterator(at);
309            default:
310                return null;
311        }
312    }
313
314    private void shapeChanged() {
315        switch (type) {
316            case POLYGON:
317                polygon.shapeChanged();
318                break;
319            case ORBIT:
320                orbit.shapeChanged();
321                break;
322            case ROUTE:
323                route.shapeChanged();
324                break;
325            case RADARC:
326                radarc.shapeChanged();
327                break;
328            case POLYARC:
329                polyarc.shapeChanged();
330                break;
331            default:
332                break;
333        }
334    }
335}