@armyc2.c5isr.renderer/mil-sym-ts-web 2.2.0

package/src/main/ts/android/graphics/Bitmap.ts

@@ -0,0 +1,7 @@
+export class Bitmap
+{
+    public constructor()
+    {
+
+    }
+};

package/src/main/ts/android/graphics/Paint.ts

@@ -0,0 +1,26 @@
+import { Rect } from "./Rect";
+import { type float } from "../../armyc2/c5isr/graphics2d/BasicTypes";
+
+export class Paint
+{
+    public constructor()
+    {
+
+    }
+    public getTextBounds(str:string, xstart:number, end:number, rect:Rect) {
+        return null;
+    };
+    public setTextSize(size:float) {
+        return;
+    };
+    public setAntiAlias(b:boolean) {
+        return;
+    };
+    public setColor(color) {
+        return;
+    };
+    public setTypeface(tf) {
+        return;
+    };
+
+};

package/src/main/ts/android/graphics/Path.ts

@@ -0,0 +1,78 @@
+import { POINT2 } from "../../armyc2/c5isr/JavaLineArray/POINT2"
+
+export class Path {
+    private pts: Array<POINT2> = [];
+
+    public lineTo(x, y) {
+        if (this.pts.length > 0)
+        {
+            var lastPt = this.pts[this.pts.length - 1];
+            if (lastPt.x === x && lastPt.y === y)
+                return;
+        }
+        this.pts.push(new POINT2(x, y));
+    };
+    public moveTo(x, y) {
+        if (this.pts.length > 0)
+        {
+            var lastPt = this.pts[this.pts.length - 1];
+            if (lastPt.x === x && lastPt.y === y)
+                return;
+        }
+        this.pts.push(new POINT2(x, y));
+    };
+    public curveTo(x1, y1, x2, y2, x3, y3) {
+        this.pts.push(new POINT2(x1, y1));
+        this.pts.push(new POINT2(x2, y2));
+        this.pts.push(new POINT2(x3, y3));
+    };
+    public cubicTo(x1, y1, x2, y2, x3, y3) {
+        this.pts.push(new POINT2(x1, y1));
+        this.pts.push(new POINT2(x2, y2));
+        this.pts.push(new POINT2(x3, y3));
+    };
+    public quadTo(x1, y1, x2, y2) {
+        this.pts.push(new POINT2(x1, y1));
+        this.pts.push(new POINT2(x2, y2));
+    };
+    public addPath(path) {
+        this.pts.push(...path.getPts());
+        return;
+    };
+    public computeBounds(rect, exact) {
+        var j = 0;
+        var left = this.pts[0].x;
+        var right = this.pts[0].x;
+        var top = this.pts[0].y;
+        var bottom = this.pts[0].y;
+        var pt = null;
+        for (j = 1; j < this.pts.length; j++) {
+            pt = this.pts[j];
+            if (pt.x < left)
+                left = pt.x;
+            if (pt.x > right)
+                right = pt.x;
+            if (pt.y < top)
+                top = pt.y;
+            if (pt.y > bottom)
+                bottom = pt.y;
+        }
+        rect.left = left;
+        rect.top = top;
+        rect.right = right;
+        rect.bottom = bottom;
+        return;
+    };
+    public close() {
+    };
+    public getPts() {
+        return this.pts;
+    };
+    public reset() {
+        this.pts.length = 0;
+    }
+};
+
+
+
+

package/src/main/ts/android/graphics/PointF.ts

@@ -0,0 +1,14 @@
+export class PointF
+{
+    public x:number = 0;
+    public y:number = 0;
+    private constructor(xval?:number,yval?:number)
+    {
+        
+        if (arguments.length === 2)
+        {
+            this.x = xval;
+            this.y = yval;
+        }
+    }
+};

package/src/main/ts/android/graphics/Rect.ts

@@ -0,0 +1,18 @@
+export class Rect
+{
+    public left:number = 0;
+    public top:number = 0;
+
+    public contructor()
+    {
+
+    }
+
+    public width():number {
+        return 0;
+    };
+    public height():number {
+        return 0;
+    };
+
+};

package/src/main/ts/android/graphics/RectF.ts

@@ -0,0 +1,50 @@
+export class RectF 
+{
+    public top = 0;
+    public left = 0;
+    public bottom = 0;
+    public right = 0;
+    
+    public constructor();
+    public constructor(left:number,top:number,right:number,bottom:number);
+    public constructor(...args: unknown[])
+    {
+        switch (args.length) 
+        {
+            case 4: {
+                const [left, top, right, bottom] = args as [number, number,number, number];
+                if (arguments.length === 4)
+                {
+                    this.left = left;
+                    this.top = top;
+                    this.right = right;
+                    this.bottom = bottom;
+                }
+            }
+        }
+    }
+    
+    public static intersects(a:RectF, b:RectF): boolean {
+        if (a.contains(b.left, b.top))
+            return true;
+        else if (a.contains(b.left, b.bottom))
+            return true;
+        else if (a.contains(b.right, b.top))
+            return true;
+        else if (a.contains(b.right, b.bottom))
+            return true;
+        return false;
+    };
+    public width():number {
+        return this.right - this.left;
+    };
+    public height():number {
+        return this.bottom - this.top;
+    };
+    public contains(x:number, y:number):boolean {
+        if (this.left < x && x < this.right)
+            if (this.top < y && y < this.bottom)
+                return true;
+        return false;
+    };
+};

package/src/main/ts/android/graphics/Region.ts

@@ -0,0 +1,36 @@
+import { GeneralPath } from "../../armyc2/c5isr/graphics2d/GeneralPath";
+import { RectF } from "./RectF";
+import { Rectangle } from "../../armyc2/c5isr/graphics2d/Rectangle";
+
+export class Region
+{
+    private _gp:GeneralPath = new GeneralPath();
+    private _rect:RectF = null;
+    public constructor()
+    {
+        if (arguments.length === 1)
+        {
+            var rect = arguments[0];
+            this._gp.moveTo(rect.x, rect.y);
+            this._gp.lineTo(rect.x + rect.width, rect.y);
+            this._gp.lineTo(rect.x + rect.width, rect.y + rect.height);
+            this._gp.lineTo(rect.x, rect.y + rect.height);
+            this._gp.lineTo(rect.x, rect.y);
+            this._rect = rect;
+        }
+    }
+    
+    public setPath(path, clipRegion) {
+        return true;
+    };
+    public contains(x:number, y:number) {
+        return this._gp.contains(x, y);
+    };
+    public getBounds = function() {
+        var rect = this._gp.getBounds();
+        return  new Rectangle(rect.x, rect.y, rect.width, rect.height);
+    };
+    public op = function(region:any, op:any) {
+        return false;
+    };
+};

package/src/main/ts/android/graphics/Typeface.ts

@@ -0,0 +1,11 @@
+export class Typeface
+{
+    public constructor()
+    {
+
+    }
+    public create(str:string, t:any) {
+        return null;
+    };
+    public static readonly BOLD = 1;
+};

package/src/main/ts/armyc2/c5isr/JavaLineArray/BasicShapes.ts

@@ -0,0 +1,99 @@
+import { TacticalLines } from "./TacticalLines";
+import { DrawRules } from "../renderer/utilities/DrawRules";
+
+export class BasicShapes {
+    /**
+     * Anchor Points: This symbol requires at least two anchor points, points 1
+     * and 2, to define the line. Additional points can be defined to extend the
+     * line.
+     * <p>
+     * Size/Shape: The first and last anchor points determine the length of the
+     * line.
+     * <p>
+     * Orientation: Orientation is determined by the order in which the anchor points are entered.
+     * <p>
+     * Modifiers: T
+     *
+     * @see DrawRules.LINE1
+     */
+    public static readonly LINE = TacticalLines.BS_LINE;
+
+    /**
+     * Anchor Points: This symbol requires at least three anchor points to
+     * define the boundary of the area. Add as many points as necessary to
+     * accurately reflect the area’s size and shape.
+     * <p>
+     * Size/Shape: Determined by the anchor points. The information fields
+     * should be moveable and scalable as a block within the area.
+     * <p>
+     * Modifiers: T
+     *
+     * @see DrawRules.AREA1
+     */
+    public static readonly AREA = TacticalLines.BS_AREA;
+
+    /**
+     * Anchor Points: This symbol requires one anchor point. This anchor point
+     * represents the center of an ellipse and, therefore, the geographic
+     * location of that ellipse.
+     * <p>
+     * Size/Shape: The size and shape of this symbol is determined by three
+     * additional numeric values; A major axis radius, a minor axis radius, and
+     * a rotation angle. The radii should be expressed in the appropriate map
+     * distance units.
+     * <p>
+     * Orientation: The orientation of this symbol is determined by the rotation
+     * angle provided, where 0 degrees is east/west and a positive rotation
+     * angle rotates the ellipse in a counter-clockwise direction.
+     * <p>
+     * Modifiers: AM, AN, T
+     *
+     * @see DrawRules.ELLIPSE1
+     */
+    public static readonly ELLIPSE = TacticalLines.PBS_ELLIPSE;
+
+    /**
+     * Anchor Points: This symbol requires one (1) anchor point and a radius.
+     * Point 1 defines the center point of the symbol.
+     * <p>
+     * Size/Shape: Size: The radius defines the size.
+     * <p>
+     * Orientation: Not applicable
+     * <p>
+     * Modifiers: AM, T
+     *
+     * @see DrawRules.CIRCULAR1
+     */
+    public static readonly CIRCLE = TacticalLines.PBS_CIRCLE;
+
+    /**
+     * Anchor Points: This symbol requires one (1) anchor point to define the
+     * center of the area.
+     * <p>
+     * Size/Shape: Size is determined by the anchor point, the length (in meters)
+     * and width (in meters).
+     * <p>
+     * Orientation: The orientation of this symbol is determined by the rotation
+     * angle provided, where 0 degrees is east/west and a positive rotation
+     * angle rotates the ellipse in a clockwise direction.
+     * <p>
+     * Modifiers: AM, AN, T
+     *
+     * @see DrawRules.RECTANGULAR2
+     */
+    public static readonly RECTANGLE = TacticalLines.PBS_RECTANGLE;
+
+    /**
+     * Anchor Points: This symbol requires one anchor point. The center point
+     * defines/is the center of the symbol.
+     * <p>
+     * Size/Shape: Line width defines the size of the point. The radius defines the size of the outline.
+     * <p>
+     * Orientation: Not applicable
+     * <p>
+     * Modifiers: AM, T
+     *
+     * @see DrawRules.POINT2
+     */
+    public static readonly POINT = TacticalLines.BBS_POINT;
+}

package/src/main/ts/armyc2/c5isr/JavaLineArray/CChannelPoints2.ts

@@ -0,0 +1,34 @@
+import { POINT2 } from "../JavaLineArray/POINT2"
+
+
+/**
+ * A class for channel points used by clsChannelUtility
+ *
+ */
+export class CChannelPoints2 {
+	m_Line1: POINT2;
+	m_Line2: POINT2;
+	constructor();
+	constructor(pts: CChannelPoints2);
+	constructor(...args: unknown[]) {
+		switch (args.length) {
+			case 0: {
+				this.m_Line1 = new POINT2();
+				this.m_Line2 = new POINT2();
+				break;
+			}
+
+			case 1: {
+				const [pts] = args as [CChannelPoints2];
+				this.m_Line1 = new POINT2(pts.m_Line1);
+				this.m_Line2 = new POINT2(pts.m_Line2);
+				break;
+			}
+
+			default: {
+				throw Error(`Invalid number of arguments`);
+			}
+		}
+	}
+
+}

package/src/main/ts/armyc2/c5isr/JavaLineArray/CELineArray.ts

@@ -0,0 +1,193 @@
+import { type int } from "../graphics2d/BasicTypes";
+import { arraysupport } from "../JavaLineArray/arraysupport"
+import { Channels } from "../JavaLineArray/Channels"
+import { countsupport } from "../JavaLineArray/countsupport"
+import { flot } from "../JavaLineArray/flot"
+import { lineutility } from "../JavaLineArray/lineutility"
+import { POINT2 } from "../JavaLineArray/POINT2"
+import { TacticalLines } from "../JavaLineArray/TacticalLines"
+import { TGLight } from "../JavaTacticalRenderer/TGLight"
+import { ErrorLogger } from "../renderer/utilities/ErrorLogger"
+import { RendererException } from "../renderer/utilities/RendererException"
+
+/**
+ * A class for the interface between the points calculation CELineArray and
+ * the tactical renderer.
+ *
+ *
+ */
+export class CELineArray {
+    private static readonly _className: string = "CELineArray";
+    /**
+    * public function to return the line count required for all of the symbols
+    *
+    * @param plArrayOfLongs the client points as an array of POINT2 in pixels.
+    * @param lElements the number of client points.
+    * @param ChannelWidth the chanel width in pixels
+    *
+    * @return the number of points which will be required for the symbol.
+    */
+    public static CGetLineCountDouble(tg: TGLight,
+        plArrayOfLongs: number[],
+        lElements: int, //number of points
+        ChannelWidth: int): int {
+        let lResult: int = 0;
+        try {
+            //declarations
+            let lPtrcntr: int = 0;
+            let lLowerFlotCount: int = 0;
+            let lUpperFlotCount: int = 0;
+            let pLinePoints: POINT2[] = new Array<POINT2>(lElements);
+            let pLowerLinePoints: POINT2[] = new Array<POINT2>(lElements);
+            let
+                pUpperLinePoints: POINT2[] = new Array<POINT2>(lElements);
+            let
+                pUpperLowerLinePoints: POINT2[] = new Array<POINT2>(2 * lElements + 2);
+            let i: number = 0;
+            //end declarations
+
+            if (lElements <= 0) {
+                return -1;
+            }
+
+            lineutility.InitializePOINT2Array(pLinePoints);
+            lineutility.InitializePOINT2Array(pUpperLinePoints);
+            lineutility.InitializePOINT2Array(pLowerLinePoints);
+            for (i = 0; i < lElements; i++) {
+                pLinePoints[i].x = plArrayOfLongs[lPtrcntr];
+                lPtrcntr++;
+                pLinePoints[i].y = plArrayOfLongs[lPtrcntr];
+                lPtrcntr++;
+            }
+            for (i = 0; i < lElements; i++) {
+                pLowerLinePoints[i] = new POINT2(pLinePoints[i]);
+                pUpperLinePoints[i] = new POINT2(pLinePoints[i]);
+            }
+
+            switch (tg.get_LineType()) {
+                case TacticalLines.CHANNEL:
+                case TacticalLines.CHANNEL_FLARED:
+                case TacticalLines.CHANNEL_DASHED: {
+                    lResult = 2 * lElements;
+                    break;
+                }
+
+                case TacticalLines.MAIN:
+                case TacticalLines.MAIN_STRAIGHT:
+                case TacticalLines.AIRAOA:
+                case TacticalLines.SPT:
+                case TacticalLines.SPT_STRAIGHT: {
+                    //points for these need not be bounded
+                    //they have an extra 8 points for the arrowhead
+                    lResult = 2 * lElements + 8;
+                    break;
+                }
+
+                case TacticalLines.CATK: {
+                    lResult = 2 * lElements + 8;
+                    break;
+                }
+
+                case TacticalLines.CATKBYFIRE: {
+                    lResult = 2 * lElements + 17;
+                    break;
+                }
+
+                case TacticalLines.AAAAA: {
+                    lResult = 2 * lElements + 19;
+                    break;
+                }
+
+                case TacticalLines.LC: {
+                    pUpperLinePoints = Channels.GetChannelArray2Double(1, pUpperLinePoints, 1, lElements, tg.get_LineType(), ChannelWidth);
+                    pLowerLinePoints = Channels.GetChannelArray2Double(1, pLowerLinePoints, 0, lElements, tg.get_LineType(), ChannelWidth);
+                    lUpperFlotCount = flot.GetFlotCountDouble(pUpperLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), lElements);
+                    lLowerFlotCount = flot.GetFlotCountDouble(pLowerLinePoints, arraysupport.getScaledSize(20, tg.get_LineThickness(), tg.get_patternScale()), lElements);
+                    lResult = lUpperFlotCount + lLowerFlotCount;
+                    break;
+                }
+
+                default: {
+                    //call GetCountersDouble for the remaining line types.
+                    lResult = countsupport.GetCountersDouble(tg, lElements, pLinePoints, null);
+                    break;
+                }
+
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(CELineArray._className, "CGetLineCountDouble",
+                    new RendererException("Failed inside CGetLineCount " + tg.get_LineType().toString(), exc));
+            } else {
+                throw exc;
+            }
+        }
+        return (lResult);
+    }
+    /**
+     * Return true is the line type is a channel type
+     * @param lineType line type
+     * @return
+     */
+    public static CIsChannel(lineType: int): int {
+        let lResult: int = 0;
+        try {
+            switch (lineType) {
+                case TacticalLines.CATK:
+                case TacticalLines.CATKBYFIRE:
+                case TacticalLines.LC:
+                case TacticalLines.AIRAOA:
+                case TacticalLines.AAAAA:
+                case TacticalLines.MAIN:
+                case TacticalLines.MAIN_STRAIGHT:
+                case TacticalLines.SPT:
+                case TacticalLines.SPT_STRAIGHT:
+                case TacticalLines.UNSP:
+                case TacticalLines.SFENCE:
+                case TacticalLines.DFENCE:
+                case TacticalLines.DOUBLEA:
+                case TacticalLines.LWFENCE:
+                case TacticalLines.HWFENCE:
+                case TacticalLines.BBS_LINE:
+                case TacticalLines.SINGLEC:
+                case TacticalLines.DOUBLEC:
+                case TacticalLines.TRIPLE:
+                case TacticalLines.CHANNEL:
+                case TacticalLines.CHANNEL_FLARED:
+                case TacticalLines.CHANNEL_DASHED: {
+                    lResult = 1;
+                    break;
+                }
+
+                default: {
+                    lResult = 0;
+                    break;
+                }
+
+            }
+        } catch (exc) {
+            if (exc instanceof Error) {
+                ErrorLogger.LogException(CELineArray._className, "CIsChannel",
+                    new RendererException("Failed inside CIsChannel " + lineType.toString(), exc));
+            } else {
+                throw exc;
+            }
+        }
+        return lResult;
+    }
+    private static _client: string = "";
+    public static setClient(value: string): void {
+        CELineArray._client = value;
+        Channels.setClient(value);
+    }
+    public static getClient(): string {
+        return CELineArray._client;
+    }
+    //    public static void setMinLength(double value)
+    //    {
+    //        DISMSupport.setMinLength(value);
+    //        arraysupport.setMinLength(value);
+    //        countsupport.setMinLength(value);
+    //        return;
+    //    }
+}