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

package/src/main/ts/armyc2/c5isr/renderer/shapes/point.ts

@@ -0,0 +1,120 @@
+import { Point2D } from "../../graphics2d/Point2D";
+
+export class Point{
+    public x = 0;
+    public y = 0;
+
+    /**
+     * 
+     * @param x 
+     * @param y 
+     */
+    constructor(x:number,y:number)
+    {
+        this.x = x;
+        this.y = y;
+    };
+    /**
+     * Returns a string representing one of the shape types
+     * from "armyc2.c2sd.renderer.so.ShapeTypes"
+     * @returns {String} 
+     */
+    public getShapeType():string
+    {
+        return "POINT";//armyc2.c2sd.renderer.so.ShapeTypes.POINT;
+    };
+    /**
+     * 
+     * @returns {Number}
+     */
+    public getX():number
+    {
+        return this.x;
+    };
+    /**
+     * 
+     * @returns {Number}
+     */
+     public getY():number
+     {
+        return this.y;
+    };
+    /**
+     * Reset the x & y of this point object.
+     * @param {Number} x
+     * @param {Number} y
+     * @returns {void}
+     */
+    public setLocation(x:number,y:number): void
+    {
+        this.x = x;
+        this.y = y;
+    };
+    /**
+     * move x & y by specified amounts.
+     * @param {Number} x shift x point by this value
+     * @param {Number} y shift y point by this value
+     * @returns {void}
+     */
+    public shift(x:number,y:number): void
+    {
+        this.x += x;
+        this.y += y;
+    };
+    /**
+     * @returns {String} like "{x:#,y:#}"
+     */
+    public toStringFormatted(): string
+    {
+        return "{x:" + this.x + ", y:" + this.y + "}";
+    };
+    /**
+     * Makes a copy of this point object.
+     * @returns {armyc2.c2sd.renderer.so.Point} Copy of original point.
+     */
+    public clone():Point
+    {
+        return new Point(this.x,this.y);
+    };
+    /**
+     * @param {CanvasRenderingContext2D} context object from html5 canvas
+     * @returns {void}
+     */
+    public setPath(context:CanvasRenderingContext2D): void
+    {
+        let x = this.x;
+        let y = this.y;
+
+        //context.beginPath();
+        context.moveTo(x, y);
+        context.lineTo(x + 1,y);
+        context.lineTo(x + 1,y + 1);
+        context.lineTo(x,y + 1);
+        context.closePath();
+
+    };
+    /**
+     * @param {context} context object from html5 canvas
+     * @returns {void}
+     */
+    public stroke(context:CanvasRenderingContext2D): void{
+        context.beginPath();
+        this.setPath(context);
+        context.stroke();
+    };
+    /**
+     * @param {context} context object from html5 canvas
+     * @returns {void}
+     */
+    public fill(context:CanvasRenderingContext2D): void{
+        context.beginPath();
+        this.setPath(context);
+        context.fill();
+    };
+
+    public toPoint2D()
+    {
+        return new Point2D(this.x,this.y);
+    }
+
+}

package/src/main/ts/armyc2/c5isr/renderer/shapes/rectangle.ts

@@ -0,0 +1,431 @@
+import { Rectangle2D } from "../../graphics2d/Rectangle2D";
+import { Point } from "./point";
+import { ShapeTypes } from "./types";
+
+export class Rectangle
+{
+
+    private x:number;
+    private y:number;
+    private width:number;
+    private height:number;
+    private bottom:number;
+    private right:number;
+
+    public static readonly OUT_LEFT = 1;
+    public static readonly OUT_TOP = 2;
+    public static readonly OUT_RIGHT = 4;
+    public static readonly OUT_BOTTOM = 8;
+
+    constructor(x:number,y:number,width:number,height:number) 
+    {
+        this.x = x,
+        this.y = y,
+        this.width = width,
+        this.height = height,
+        this.bottom = y + height,
+        this.right = x + width;
+    }      
+    // <editor-fold defaultstate="collapsed" desc="Public Property Functions">
+
+    public getShapeType():string
+    {
+        return ShapeTypes.RECTANGLE;
+    }
+    
+    public getBounds():Rectangle
+    {
+        return new Rectangle(this.x-1,
+                                this.y-1,
+                                this.width+2,
+                                this.height+2);
+    };
+
+    public toRectangle2D():Rectangle2D
+    {
+        return new Rectangle2D(this.x,
+            this.y,
+            this.width,
+            this.height);
+    }
+
+    public getX():number
+    {
+        return this.x;
+    };
+
+    public getY():number{
+        return this.y;
+    };
+
+    public getWidth():number{
+        return this.width;
+    };
+
+    public getHeight():number{
+        return this.height;
+    };
+
+    public getBottom():number{
+        return this.bottom;
+    };
+
+    public getRight():number{
+        return this.right;
+    };
+
+    public getCenterX():number{
+        return this.x + (this.width/2);
+    };
+    /**
+     * 
+     * @returns {Number}
+     */
+    public getCenterY(){
+        return this.y + (this.height/2);
+    };
+
+    /**
+     * setLocation x,y (top,left) while maintaining the width and height.
+     * @param x 
+     * @param y 
+     */
+    public setLocation(x:number,y:number):void{
+        this.x = x;
+        this.y = y;
+        this.bottom = y + this.height;
+        this.right = x + this.width;
+    };
+    
+    public isEmpty():boolean
+    {
+        return (this.width <= 0.0) || (this.height <= 0.0);
+    };
+    
+    // </editor-fold>
+    
+    // <editor-fold defaultstate="collapsed" desc="Public Utility Functions">
+    
+    public shift(x:number,y:number):void
+    {
+        this.x += x;
+        this.y += y;
+        this.right += x;
+        this.bottom +=y;
+        //height & width shouldn't change in a full shift of the rectangle.
+        //this.height = this.bottom - this.y;
+        //this.width = this.right - this.x;
+    };
+    /**
+     * moves top,left points leaving bottom,right intact.
+     * adjusts the height & width values as necessary
+     * @param x 
+     * @param y 
+     */
+    public shiftTL(x:number,y:number):void{
+        this.x += x;
+        this.y += y;
+        this.height = this.bottom - this.y;
+        this.width = this.right - this.x;
+    };
+    /**
+     * moves bottom,right points leaving top,left intact.
+     * adjusts the height & width values as necessary
+     * @param {type} x the amount to move the right point by
+     * @param {type} y the amount to move the bottom point by
+     * @returns {_L7.Anonym$0.Rectangle.shiftTL}
+     */
+    public shiftBR(x:number,y:number):void{
+        this.right += x;
+        this.bottom += y;
+        this.height = this.bottom - this.y;
+        this.width = this.right - this.x;
+    };
+
+    /**
+     * Grow the rectangle by this many pixels in every direction
+     * @param pixel 
+     */
+    public grow (pixel:number){
+        this.shiftTL(-pixel,-pixel);
+        this.shiftBR(pixel,pixel);
+    };
+
+    /**
+     * Will merge the bounds of two rectangle.
+     * @param rect 
+     */
+    public union(rect:Rectangle){
+        if(rect)
+        {
+            if(rect.y < this.y)
+                this.y = rect.y;
+            if(rect.x < this.x)
+                this.x = rect.x;
+            if(rect.bottom > this.bottom)
+                this.bottom = rect.bottom;
+            if(rect.right > this.right)
+                this.right = rect.right;
+            this.width = this.right - this.x;
+            this.height = this.bottom - this.y;
+        }
+            
+    }
+
+    public unionPoint(point:Point){
+        if(point)
+        {
+            if(point.y < this.y)
+                this.y = point.y;
+            if(point.x < this.x)
+                this.x = point.x;
+            if(point.y > this.bottom)
+                this.bottom = point.y;
+            if(point.x > this.right)
+                this.right = point.x;
+            this.width = this.right - this.x;
+            this.height = this.bottom - this.y;
+        }
+            
+    };
+
+    /**
+     * if 2 values passed in, they are assumed to be the x,y of a point.
+     * if 4 values passed in, they are assumed to be the x,y,w,h values
+     * of a Rectangle.
+     * @param x 
+     * @param y 
+     * @param w 
+     * @param h 
+     * @returns 
+     */
+    public contains(x:number,y:number,w?:number,h?:number)
+    {
+        if(x && y && w && h)
+        {
+            if (this.isEmpty() || w <= 0 || h <= 0) {
+                return false;
+            }
+            var x0 = this.getX(),
+                y0 = this.getY();
+            return (x >= x0 &&
+                    y >= y0 &&
+                    (x + w) <= x0 + this.getWidth() &&
+                    (y + h) <= y0 + this.getHeight());
+        }
+        else if(x && y)
+        {
+            var x0 = this.getX(),
+                y0 = this.getY();
+            return (x >= x0 &&
+                y >= y0 &&
+                x < x0 + this.getWidth() &&
+                y < y0 + this.getHeight());
+        }
+        else
+            return false;
+    };
+    
+    /**
+     * 
+     * @param point 
+     * @returns 
+     */
+    public containsPoint(point:Point):boolean
+    {
+        if(point)
+        {
+            var x = point.getX();
+            var y = point.getY();
+            var x0 = this.getX(),
+                y0 = this.getY();
+            return (x >= x0 &&
+                y >= y0 &&
+                x < x0 + this.getWidth() &&
+                y < y0 + this.getHeight());
+        }
+        else
+            return false;
+    };
+    
+    public containsRectangle(rect:Rectangle):boolean
+    {
+        if(rect)
+        {
+            var x = rect.getX();
+            var y = rect.getY();
+            var w = rect.getWidth();
+            var h = rect.getHeight();
+            if (this.isEmpty() || w <= 0 || h <= 0) 
+            {
+                return false;
+            }
+            var x0 = this.getX(),
+                y0 = this.getY();
+            return (x >= x0 &&
+                y >= y0 &&
+                (x + w) <= x0 + this.getWidth() &&
+                (y + h) <= y0 + this.getHeight());
+        }
+        else
+            return false;
+    };
+    
+    /**
+     * Ported from Java
+     */
+    private outcode(x:number, y:number) 
+    {
+        var out = 0;
+        if (this.width <= 0) {
+        out |= Rectangle.OUT_LEFT | Rectangle.OUT_RIGHT;
+        } else if (x < this.x) {
+        out |= Rectangle.OUT_LEFT;
+        } else if (x > this.x + this.width) {
+        out |= Rectangle.OUT_RIGHT;
+        }
+        if (this.height <= 0) {
+        out |= Rectangle.OUT_TOP | Rectangle.OUT_BOTTOM;
+        } else if (y < this.y) {
+        out |= Rectangle.OUT_TOP;
+        } else if (y > this.y + this.height) {
+        out |= Rectangle.OUT_BOTTOM;
+        }
+        return out;
+    };
+    
+    /**
+    * Tests if the specified line segment intersects the interior of this
+    * <code>Rectangle</code>. Ported from java.
+    *
+    * @param x1 the X coordinate of the start point of the specified
+    *           line segment
+    * @param y1 the Y coordinate of the start point of the specified
+    *           line segment
+    * @param x2 the X coordinate of the end point of the specified
+    *           line segment
+    * @param y2 the Y coordinate of the end point of the specified
+    *           line segment
+    * @return <code>true</code> if the specified line segment intersects
+    * the interior of this <code>Rectangle</code>; <code>false</code>
+    * otherwise.
+    */
+    public intersectsLine(x1: number, y1: number, x2: number, y2: number):boolean
+    {
+        let out1: number = 0;
+        let out2: number = 0;
+        if ((out2 = this.outcode(x2, y2)) === 0) {
+            return true;
+        }
+        while ((out1 = this.outcode(x1, y1)) !== 0) {
+            if ((out1 & out2) !== 0) {
+                return false;
+            }
+            if ((out1 & (Rectangle.OUT_LEFT | Rectangle.OUT_RIGHT)) !== 0) {
+                var x = this.getX();
+                if ((out1 & Rectangle.OUT_RIGHT) !== 0) {
+                    x += this.getWidth();
+                }
+                y1 = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
+                x1 = x;
+            } else {
+                var y = this.getY();
+                if ((out1 & Rectangle.OUT_BOTTOM) !== 0) {
+                    y += this.getHeight();
+                }
+                x1 = x1 + (y - y1) * (x2 - x1) / (y2 - y1);
+                y1 = y;
+            }
+        }
+        return true;
+    };
+    
+    // </editor-fold>
+    
+    public setPath(context:OffscreenCanvasRenderingContext2D | any)
+    {
+        var x = this.getX(),
+            y = this.getY(),
+            w = this.getWidth(),
+            h = this.getHeight();
+        
+        //context.beginPath();
+        context.moveTo(x, y);
+        context.lineTo(x + w,y);
+        context.lineTo(x + w,y + h);
+        context.lineTo(x,y + h);
+        context.closePath();
+        
+    };
+    public stroke(context:OffscreenCanvasRenderingContext2D){
+        context.strokeRect(this.getX(),this.getY(),this.getWidth(),this.getHeight());
+    };
+    public fill(context:OffscreenCanvasRenderingContext2D){
+        context.fillRect(this.getX(),this.getY(),this.getWidth(),this.getHeight());
+    };
+    public clone():Rectangle{
+        return new Rectangle(this.x,this.y,this.width,this.height);
+    };
+    
+    /**
+     * ported from java
+     */
+    public intersects(r:Rectangle):boolean
+    {
+        if(r)
+        {
+            var tw = this.width;
+            var th = this.height;
+            var rw = r.width;
+            var rh = r.height;
+            if (rw <= 0 || rh <= 0 || tw <= 0 || th <= 0) {
+                return false;
+            }
+            var tx = this.x;
+            var ty = this.y;
+            var rx = r.x;
+            var ry = r.y;
+            rw += rx;
+            rh += ry;
+            tw += tx;
+            th += ty;
+            //      overflow || intersect
+            return ((rw < rx || rw > tx) &&
+                    (rh < ry || rh > ty) &&
+                    (tw < tx || tw > rx) &&
+                    (th < ty || th > ry));    
+        }
+        else
+            return false;
+        
+    };//*/
+    
+    /**
+     * 
+     * @param stroke named color or value of rgb(#,#,#)
+     * @param strokeWidth width of line in # of pixels
+     * @param fill named color or value of rgb(#,#,#)
+     * @returns 
+     */
+    public toSVGElement(stroke:string | null, strokeWidth:number, fill:string | null):string
+    {
+        var line = '<rect x="' + this.x + '" y="' + this.y;
+        line += '" width="' + this.width + '" height="' + this.height + '"';
+        
+        if(strokeWidth)
+            line += ' stroke-width="' + strokeWidth + '"';
+        else if(stroke) 
+            line += ' stroke-width="2"';
+        
+        if(stroke)
+            line += ' stroke="' + stroke + '"';
+            
+        if(fill)
+            line += ' fill="' + fill + '"';
+        else
+            line += ' fill="none"';
+        
+        line += '/>';
+        return line;
+    }
+}

package/src/main/ts/armyc2/c5isr/renderer/shapes/roundedrectangle.ts

@@ -0,0 +1,99 @@
+import { Rectangle } from "./rectangle";
+
+export class RoundedRectangle
+{
+    private radius:number;
+    private rectangle:Rectangle
+
+    constructor(x,y,w,h,radius) 
+    {
+
+        this.radius = radius;
+
+        this.rectangle = new Rectangle(x,y,w,h);
+	
+    }
+
+    /**
+     * 
+     */
+    getShapeType():string{
+        return "ROUNDED_RECTANGLE";//ShapeTypes.ROUNDED_RECTANGLE;
+    };
+
+    /**
+     * 
+     */
+    getBounds():Rectangle
+    {
+        return new Rectangle(this.rectangle.getX()-1,
+                                this.rectangle.getY()-1,
+                                this.rectangle.getWidth()+2,
+                                this.rectangle.getHeight()+2);
+    };
+
+    shift(x:number,y:number)
+    {
+        this.rectangle.shift(x,y);
+    };
+
+    setPath(context:CanvasRenderingContext2D){
+        var x = this.rectangle.getX(),
+            y = this.rectangle.getY(),
+            w = this.rectangle.getWidth(),
+            h = this.rectangle.getHeight();
+        if(w < (2 * this.radius))
+            this.radius = w/2;
+        if(h < (2 * this.radius))
+            this.radius = h/2;
+        var r = this.radius;
+
+        //context.beginPath();
+        context.moveTo(x + r, y);
+        context.lineTo(x + w -r,y);
+        context.arcTo(x + w, y, x + w, y+r, r);
+        context.lineTo(x + w,y + h - r);
+        context.arcTo(x + w, y+h, x+w-r, y + h, r);
+        context.lineTo(x + r,y + h);
+        context.arcTo(x, y+h, x, y+h-r, r);
+        context.lineTo(x,y + r);
+        context.arcTo(x, y, x + r, y, r);
+
+    };
+
+    stroke(context:CanvasRenderingContext2D){
+        context.beginPath();
+        this.setPath(context);
+        context.stroke();
+    };
+
+    fill(context:CanvasRenderingContext2D){
+        context.beginPath();
+        this.setPath(context);
+        context.fill();
+    };
+    
+    toSVGElement(stroke:string | null, strokeWidth:number, fill:string | null):string
+    {  
+        var line = '<rect x="' + this.rectangle.getX() + '" y="' + this.rectangle.getY();
+        line += '" rx="' + this.radius + '" ry="' + this.radius;
+        line += '" width="' + this.rectangle.getWidth() + '" height="' + this.rectangle.getHeight() + '"';
+        
+        if(strokeWidth)
+            line += ' stroke-width="' + strokeWidth + '"';
+        else if(stroke) 
+            line += ' stroke-width="2"';
+        
+        if(stroke)
+            line += ' stroke="' + stroke + '"';
+            
+        if(fill)
+            line += ' fill="' + fill + '"';
+        else
+            line += ' fill="none"';
+        
+        line += '/>';
+        return line;
+    }
+
+}

package/src/main/ts/armyc2/c5isr/renderer/shapes/types.ts

@@ -0,0 +1,25 @@
+export class ShapeTypes{
+    public static readonly RECTANGLE = "RECTANGLE";
+    public static readonly POINT = "POINT";
+    public static readonly ELLIPSE = "ELLIPSE";
+    public static readonly ROUNDED_RECTANGLE = "ROUNDED_RECTANGLE";
+    public static readonly LINE = "LINE";
+    public static readonly BCURVE = "BCURVE";
+    public static readonly ARC = "ARC";
+    public static readonly PATH = "PATH";
+}
+
+export class ActionTypes{
+    public static readonly ACTION_MOVE_TO = 0;
+    public static readonly ACTION_LINE_TO = 1;
+    public static readonly ACTION_CURVE_TO = 2;//cubic bezier cirve
+    public static readonly ACTION_QUAD_TO = 3;//quadratic bezier curve
+    public static readonly ACTION_ARC_TO = 4;
+    public static readonly ACTION_ARC = 5;
+	public static readonly ACTION_DASHED_LINE_TO = 6;
+}    
+
+
+    
+
+