//
// JavaScript functions to support Redline
//
/////////////////////////////////////////////////////////////////////////////
//
//
// Description:			Javascript functions to support redlining functionality
//
// File:  redline.js
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////

//Global variables
var g_flag = "";      //Use this flag to determine if Point, Text, resize command is invoked.
var g_oSelObj = null; //Selected object for resizing
var g_nCnt = 0;       //All redlines are named as "Markup_n" where n = incremental number.
var g_sFontData = ""; //All fonts and their font styles available in this map are stored as "fontname|style1,style2;fontname2|style1,style2..."
var g_oDefaultFillAttr;
var g_oDefaultEdgeAttr;
var g_oDefaultLineAttr;
var g_oDefaultTextAttr;
var g_oRedlinesLayer;  // temp storage for storing redlines layer once created.
var g_bEvents = false; // bool to indicate if drawing redline is in progress
var g_sIsURLLoaded = "Y"; // Flag to indicate whether to set the Map url for
//                           the first time only. value = Y or N
var g_sKey = "";  // save the symbol key before the edit.

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function redline(type)
//
// Return Value:	N/A
//
// Parameters:		string
//
// Remarks:
//
//       Determines what to draw.
//
//
// Notes:
//       Called by Event Handler/Event support function
/////////////////////////////////////////////////////////////////////////////
function redline(type)
{
    var map = getMap();                

    switch(type)
    {
        case 'LINE':
            drawLine(map);
			break;
        case 'POLYLINE':
            drawPolyline(map);
            break;        
        case 'CIRCLE':
            drawCircle(map);
            break;
		case 'POLYGON':
            drawPolygon(map);
			break;
        case 'RECTANGLE':
            drawRectangle(map);
			break;                        
        case 'DELETE':
            deleteRedline(map);
            break;        
    }
}

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function drawCircle(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:
//
//       Draws a redline circle.
//
//
// Notes:
//       Called by Event Handler/Event support function
/////////////////////////////////////////////////////////////////////////////
function drawCircle(map)
    {
    var map1;
    map1 = map;
    map1.digitizeCircle(map1.getDisplayUnits());
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function onDigitizedCircle(map1, units, center, radius)
//
// Return Value:	N/A
//
// Parameters:		map object, map units, center point object, radius string
//
// Remarks:
//
//       Sets the key and adds to redline layer for the circle object.
//
//
// Notes:
//       Called by drawCircle
/////////////////////////////////////////////////////////////////////////////
function onDigitizedCircle(map1, units, center, radius)
    {

    var oRedlinesLayer = setupRedlineLayer(map1);
    var key;
    key = "C_" + center.x                        + "," + center.y                     + "_"
               + radius                          + "_" + g_oDefaultFillAttr.BackColor + "_"
               + g_oDefaultFillAttr.BackMode     + "_" + g_oDefaultFillAttr.Color     + "_"
               + g_oDefaultFillAttr.Style        + "_" + g_oDefaultFillAttr.HatchPattern + "_" 
               + g_oDefaultEdgeAttr.Color        + "_" + g_oDefaultEdgeAttr.Style     + "_"
               + g_oDefaultEdgeAttr.Thickness    + "_" + g_oDefaultEdgeAttr.Visible   + "_"
               + new Date().valueOf();
	//alert(key);
    var oMapObj;
    oMapObj = oRedlinesLayer.createmapobject(key, "Markup_" + g_nCnt++, "");

    oMapObj.addCirclePrimitive(center, false,  parseFloat(radius) , units, 200);
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function drawLine(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:
//
//           Draws a redline Line.
//
//
// Notes:
//       Called by Event Handler/Event support function
/////////////////////////////////////////////////////////////////////////////
function drawLine(map)
    {
    map.digitizeLine();
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function drawPolyline(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:
//
//     Draws a redline Polyline.
//
//
// Notes:
//       Called by Event Handler/Event support function
/////////////////////////////////////////////////////////////////////////////
function drawPolyline(map)
    {
    map.digitizePolyline();
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function onDigitizedPolyline(map1, NumVertices, Vertices)
//
// Return Value:	N/A
//
// Parameters:		map object, number of vertices, vertice coords
//
// Remarks:
//
//     Draws a redline Polyline.
//
//
// Notes:
//       Called by drawPolyline
/////////////////////////////////////////////////////////////////////////////

function onDigitizedPolyline(map1, NumVertices, Vertices)
    {
    if (g_flag == "moveRedline")
        {
        g_flag = "";

        var deltaPt;
        deltaPt = map1.createObject("MGPoint");

        deltaPt.x = Vertices(1).getX() - Vertices(0).getX();
        deltaPt.y = Vertices(1).getY() - Vertices(0).getY();
        moveRedlineContd(deltaPt);
        }

    else if (g_flag == "rotateRedline")
        {
        var deltaPt;
        deltaPt = map1.createObject("MGPoint");

        deltaPt.x = Vertices(1).getX() - Vertices(0).getX();
        deltaPt.y = Vertices(1).getY() - Vertices(0).getY();
        rotateRedlineContd(deltaPt);
        }

    else
        {
		var oRedlinesLayer = setupRedlineLayer(map1);

        var nVertices;
        nVertices = map1.createObject("MGCollection");
        nVertices.add(NumVertices);

        var key;
        key = "P_" + g_oDefaultLineAttr.Color + "_" + g_oDefaultLineAttr.Style + "_" + g_oDefaultLineAttr.Thickness
                   + "_"                      + new Date().valueOf();

        var oMapObj;
        oMapObj = oRedlinesLayer.createmapobject(key, "Markup_" + g_nCnt++, "");
        oMapObj.addPolylinePrimitive(Vertices, nVertices, false);
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function drawRectangle(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:
//
//       Draws a redline Rectangle.
//
//
// Notes:
//       Called by Event Handler/Event support function
/////////////////////////////////////////////////////////////////////////////
function drawRectangle(map)
    {
    map.digitizeRectangle();
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function onDigitizedRectangle(map1, AnchorPt, EndPt)
//
// Return Value:	N/A
//
// Parameters:		map object, AnchorPoint, End Point
//
// Remarks:
//
//     Draws a redline Polyline.
//
//
// Notes:
//       Called by drawRectangle
/////////////////////////////////////////////////////////////////////////////

function onDigitizedRectangle(map1, AnchorPt, EndPt)
    {
    var oRedlinesLayer = setupRedlineLayer(map1);

    var nVertices;
    nVertices = map1.createObject("MGCollection");
    nVertices.add(5);

    var Vertices;
    Vertices = map1.createObject("MGCollection");

    var Vertex1;
    Vertex1 = map1.createObject("MGPoint");
    Vertex1.x = AnchorPt.x;
    Vertex1.y = AnchorPt.y;
    Vertices.add(Vertex1);

    var Vertex2;
    Vertex2 = map1.createObject("MGPoint");
    Vertex2.x = EndPt.x;
    Vertex2.y = AnchorPt.y;
    Vertices.add(Vertex2);

    var Vertex3;
    Vertex3 = map1.createObject("MGPoint");
    Vertex3.x = EndPt.x;
    Vertex3.y = EndPt.y;
    Vertices.add(Vertex3);

    var Vertex4;
    Vertex4 = map1.createObject("MGPoint");
    Vertex4.x = AnchorPt.x;
    Vertex4.y = EndPt.y;
    Vertices.add(Vertex4);

    Vertices.add(Vertex1);

    var key;
    key = "G_" + g_oDefaultFillAttr.BackColor + "_" + g_oDefaultFillAttr.BackMode     + "_"
               + g_oDefaultFillAttr.Color     + "_" + g_oDefaultFillAttr.HatchPattern + "_"
               + g_oDefaultFillAttr.Style     + "_" + g_oDefaultEdgeAttr.Color        + "_"
               + g_oDefaultEdgeAttr.Style     + "_" + g_oDefaultEdgeAttr.Thickness    + "_"
               + g_oDefaultEdgeAttr.Visible   + "_" + new Date().valueOf();

    var oMapObj;
    oMapObj = oRedlinesLayer.createmapobject(key, "Markup_" + g_nCnt++, "");
    oMapObj.addPolygonPrimitive(Vertices, nVertices, false);
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function drawPolygon(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:
//
//       Draws a redline Polygon.
//
//
// Notes:
//       Called by Event Handler/Event support function
/////////////////////////////////////////////////////////////////////////////

function drawPolygon(map)
    {
    map.digitizePolygon();
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function onDigitizedPolygon(map1, NumVertices, Vertices)
//
// Return Value:	N/A
//
// Parameters:		map object, vertice Count, Vertice Coords
//
// Remarks:
//
//     Draws a redline Polyline.
//
//
// Notes:
//       Called by drawPolygon
/////////////////////////////////////////////////////////////////////////////

function onDigitizedPolygon(map1, NumVertices, Vertices)
    {
    var oRedlinesLayer = setupRedlineLayer(map1);

    var nVertices;
    nVertices = map1.createObject("MGCollection");
    nVertices.add(NumVertices);

    var key;
    key = "G_" + g_oDefaultFillAttr.BackColor + "_" + g_oDefaultFillAttr.BackMode     + "_"
               + g_oDefaultFillAttr.Color     + "_" + g_oDefaultFillAttr.HatchPattern + "_"
               + g_oDefaultFillAttr.Style     + "_" + g_oDefaultEdgeAttr.Color        + "_"
               + g_oDefaultEdgeAttr.Style     + "_" + g_oDefaultEdgeAttr.Thickness    + "_"
               + g_oDefaultEdgeAttr.Visible   + "_" + new Date().valueOf();

    var oMapObj;
    oMapObj = oRedlinesLayer.createmapobject(key, "Markup_" + g_nCnt++, "");
    oMapObj.addPolygonPrimitive(Vertices, nVertices, false);
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function drawPoint(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:
//
//       Draws a redline Point.
//
//
// Notes:
//       Called by drawPoint
/////////////////////////////////////////////////////////////////////////////

function drawPoint(map)
    {
    g_flag = "insertSymbol";

    var map1;
    map1 = getMap();
	var scale = map1.getScale();
    var nSmbCnt;
    nSmbCnt = map1.getSymbols().Count;

    var sSmbData = "";

    //Iterate thru the symbols in the mwf.
    for (var i = 0; i <= nSmbCnt - 1; i++)
        {
        sSmbData = sSmbData + map1.getSymbols(i) + "|"; //Build string as symbolName1|symbolName2|symbolName3|....
        }

    sSmbData = sSmbData.substr(0, sSmbData.length - 1); //Remove last piping symbol.

    //Display a modal dialog with various options for drawing a symbol

    RedlineManager.bReturn.value = "false";
    // init the text value in the form field to null

    var param = "?symbol=" + sSmbData;
    param += "&rotation=" + RedlineManager.smbRotation.value;
    param += "&width=" + RedlineManager.smbWidth.value;
    param += "&height=" + RedlineManager.smbHeight.value;
    param += "&Note=" + RedlineManager.smbNote.value;
    param += "&selected=" + RedlineManager.smbSelected.value;
    param += "&scale="+scale;
    openWin("Symbol.aspx", param, "SymbolAttributes", 400, 400, "false", "yes");
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function digitizeSymbol()
//
// Return Value:	N/A
//
// Parameters:		none
//
// Remarks:
//
//       Prompts the user for insertion point
//
//
// Notes:
//       Called by Event Handler/Event support function
/////////////////////////////////////////////////////////////////////////////

function digitizeSymbol()
    {
    if (RedlineManager.bReturn.value == "true")
        {
        var map1 = getMap();
        map1.digitizePoint();
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function onDigitizedPoint(map2, InsPoint)
//
// Return Value:	N/A
//
// Parameters:		map object, Insertion Point
//
// Remarks:
//
//       Draws a redline symbol and addes attributes.
//
//
// Notes:
//       Called by digitizePoint
/////////////////////////////////////////////////////////////////////////////

function onDigitizedPoint(map2, InsPoint)
    {
    //alert("digitize point");
    var map1 = getMap();
    var oMapObj;
    var key;
    
    var oRedlinesLayer = setupRedlineLayer(map1);

    //Add a symbol for representation.
    if (g_flag == "insertSymbol")
        {
        //"N_symbolName_symbolHeight_symbolWidth_symbolRotation_DatetTime"

        g_flag = "";
        key = "N_" + RedlineManager.smbSelected.value + "_" + RedlineManager.smbHeight.value   + "_"
                   + RedlineManager.smbWidth.value    + "_" + RedlineManager.smbRotation.value + "_"
                   + new Date().valueOf()             + "_" + RedlineManager.smbNote.value;

        var tempString = "Markup_" + g_nCnt++;

        if (RedlineManager.smbNote.value != "")
            {
            tempString = RedlineManager.smbNote.value;
            }

        oMapObj = oRedlinesLayer.createmapobject(key, RedlineManager.smbNote.value, "");

        var smbAttr;
        smbAttr = map1.RedlineSetup.getSymbolAttr();
        smbAttr.setSymbol(RedlineManager.smbSelected.value);
        smbAttr.setHeight(RedlineManager.smbHeight.value, map1.getDisplayUnits());
        smbAttr.setWidth(RedlineManager.smbWidth.value, map1.getDisplayUnits());
        smbAttr.setRotation(RedlineManager.smbRotation.value);

        oMapObj.addSymbolPrimitive(InsPoint, false);
        }

    else if (g_flag == "insertText")
        {
        g_flag = "";
        var txtAttr;
        txtAttr = map1.RedlineSetup.getTextAttr();

        var aColor;
        
        aColor = RedlineManager.txtBackColor.value;
		txtAttr.setBackColor(aColor);
        
        aColor = RedlineManager.txtColor.value;
        txtAttr.setColor(aColor);
        txtAttr.setBackMode(RedlineManager.txtBackMode.value);
        txtAttr.setFontName(RedlineManager.txtFontName.value);
        txtAttr.setFontStyle(RedlineManager.txtFontStyle.value);
        txtAttr.setHeight(RedlineManager.txtHeight.value, map1.getDisplayUnits());
        txtAttr.setHorizAlign(RedlineManager.txtHorizAlign.value);
        txtAttr.setRotation(RedlineManager.txtRotation.value);
        txtAttr.setVertAlign(RedlineManager.txtVertAlign.value);

        //"T_BackColor_BackMode_ForeColor_FontName_FontStyle_Height_Horizalign_Rotation_VertAlign_DateTime"
        key = "T_" + RedlineManager.txtBackColor.value  + "_" + RedlineManager.txtBackMode.value + "_"
                   + RedlineManager.txtColor.value      + "_" + RedlineManager.txtFontName.value + "_"
                   + RedlineManager.txtFontStyle.value  + "_" + RedlineManager.txtHeight.value   + "_"
                   + RedlineManager.txtHorizAlign.value + "_" + RedlineManager.txtRotation.value + "_"
                   + RedlineManager.txtVertAlign.value  + "_" + new Date().valueOf();

        oMapObj = oRedlinesLayer.createMapObject(key, "Markup_" + g_nCnt++, "");
        oMapObj.addTextPrimitive(InsPoint, true, RedlineManager.txtValue.value);
        }

    else if (g_flag == "resize")
        {
        g_flag = "";
        var oGripsLayer;
        oGripsLayer = map1.getMapLayer("GRIPS");

        var oSelection;
        oSelection = map1.getSelection();

        if (oSelection == null)
            {
            return;
            }

        var oObjs;
        oObjs = oSelection.getmapobjectsEx(oGripsLayer);

        var index;
        index = oObjs(0).getName().substr(4);

        var oPoints;
        var nPoints;
        oPoints = map1.createObject("MGCollection");
        nPoints = map1.createObject("MGCollection");

        var oLayer;
        var objName;
        key = g_oSelObj.getKey();
        objName = g_oSelObj.getName();
        oLayer = g_oSelObj.getMapLayer();
        g_oSelObj.getVertices(oPoints, nPoints);
        setSettings(g_oSelObj.getKey(), map1);

        switch (g_oSelObj.getType())
            {
            case 'Polyline':
                oLayer.removeObject(g_oSelObj);

                oPoints(index).setX(InsPoint.getX());
                oPoints(index).setY(InsPoint.getY());

                oGripsLayer.removeAllObjects();

                oMapObj = oLayer.createmapobject(key, objName, "");
                oMapObj.addPolylinePrimitive(oPoints, nPoints, true);

                map1.removeMapLayer("GRIPS");
                break;

            case 'Polygon':
                if (g_oSelObj.getkey().charAt(0) == 'C')
                    {
                    var oExtent;
                    oExtent = g_oSelObj.getExtentEx(true);

                    var oCenPt;
                    oCenPt = map1.createObject("MGPoint");
                    oCenPt.x = oExtent.getMinX() + (oExtent.getMaxX() - oExtent.getMinX()) / 2.0;
                    oCenPt.y = oExtent.getMinY() + (oExtent.getMaxY() - oExtent.getMinY()) / 2.0;

                    oGripsLayer.removeAllObjects();

                    oLayer.removeObject(g_oSelObj);
                    oMapObj = oLayer.createmapobject(key, objName, "");
                    oMapObj.addCirclePrimitive(oCenPt,
                                               true,
                                               Math.sqrt(Math.pow(Math.abs(InsPoint.x - oCenPt.x), 2)
                                                             + Math.pow(Math.abs(InsPoint.y - oCenPt.y), 2)),
                                               map1.getDisplayUnits(),
                                               nPoints(0) - 1);

                    map1.removeMapLayer("GRIPS");
                    }

                else
                    {
                    oLayer.removeObject(g_oSelObj);

                    if (index == 0)
                        {
                        oPoints(index).x = InsPoint.x;
                        oPoints(index).y = InsPoint.y;
                        oPoints(oPoints.Count - 1).x = InsPoint.x;
                        oPoints(oPoints.Count - 1).y = InsPoint.y;
                        }

                    else
                        {
                        oPoints(index).x = InsPoint.x;
                        oPoints(index).y = InsPoint.y;
                        }

                    oGripsLayer.removeAllObjects();

                    oMapObj = oLayer.createmapobject(key, objName, "");
                    oMapObj.addPolygonPrimitive(oPoints, nPoints, true);

                    map1.removeMapLayer("GRIPS");
                    }

                break;
            }

        g_oSelObj = null;
        restoreDefaultSettings(map1);
        }
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function drawText(map1)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:
//
//       Draws a redline Text.
//
//
// Notes:
//       Called by Event Handler/Event support function
/////////////////////////////////////////////////////////////////////////////

function drawText(map1)
    {
    g_flag = "insertText";

    RedlineManager.txtFontName.value = g_oDefaultTextAttr.FontName;
    RedlineManager.txtFontStyle.value = g_oDefaultTextAttr.FontStyle;
    RedlineManager.txtHeight.value = g_oDefaultTextAttr.Height;
    RedlineManager.txtRotation.value = g_oDefaultTextAttr.Rotation;
    RedlineManager.txtBackMode.value = g_oDefaultTextAttr.BackMode;
    RedlineManager.txtHorizAlign.value = g_oDefaultTextAttr.HorizAlign;
    RedlineManager.txtVertAlign.value = g_oDefaultTextAttr.VertAlign;
    RedlineManager.txtBackColor.value = g_oDefaultTextAttr.BackColor;
    RedlineManager.txtColor.value = g_oDefaultTextAttr.Color;

    //Display a modal dialog with various options for drawing a text
  
    var param = "?backColor=" + RedlineManager.txtBackColor.value;
    param += "&backMode=" + RedlineManager.txtBackMode.value;
    param += "&foreColor=" + RedlineManager.txtColor.value;
    param += "&fontName=" + RedlineManager.txtFontName.value;
    param += "&fontStyle=" + RedlineManager.txtFontStyle.value;
    param += "&height=" + RedlineManager.txtHeight.value;
    param += "&horizAlign=" + RedlineManager.txtHorizAlign.value;
    param += "&rotation=" + RedlineManager.txtRotation.value;
    param += "&vertAlign=" + RedlineManager.txtVertAlign.value;

    RedlineManager.bReturn.value = "false";
    // init the text value in the form field to null
    RedlineManager.txtValue.value = "";
	var scale = map1.getScale();
	param += "&scale=" + scale;
    openWin("Text.aspx", param, "TextAttributes", 550, 350, "false", "yes");    
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function digitizeText()
//
// Return Value:	N/A
//
// Parameters:		none
//
// Remarks:
//
//       Prompts the user for insertion point
//
//
// Notes:
//       Called by Event Handler
/////////////////////////////////////////////////////////////////////////////

function digitizeText()
    {    
    if (RedlineManager.bReturn.value == "true")
        {        
        g_flag="insertText";     
        var map1 = getMap();
        map1.digitizePoint();
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function createText(map1, InsPoint, textstring)
//
// Return Value:	N/A
//
// Parameters:		map object, InsertionPoint, Input Text Note
//
// Remarks:
//
//       Adds text to redline layer with attributes
//
//
// Notes:
//       Called by Event Handler
/////////////////////////////////////////////////////////////////////////////

function createText(map1, InsPoint, textstring)
    {
    var oRedlinesLayer = setupRedlineLayer(map1);

    var oMapObj;
    var key;
    key = "T_" + RedlineManager.txtHeight.value + "_" + new Date().valueOf();
    oMapObj = oRedlinesLayer.createMapObject(key, "Markup_" + g_nCnt++, "");
    oMapObj.addTextPrimitive(InsPoint, true, textstring);
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function setDefaultVariables()
//
// Return Value:	N/A
//
// Parameters:		none
//
// Remarks:			Sets the global variables from RedlineManager.aspx page variables
//
//
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////

function setDefaultVariables()
    {
    if (RedlineManager.bReturn.value == "true")
        {
        var map1;
        map1 = getMap();

        var oFillAttr;
        oFillAttr = map1.getRedlineSetup().getFillAttr();
        var oEdgeAttr;
        oEdgeAttr = map1.getRedlineSetup().getEdgeAttr();
        var oLineAttr;
        oLineAttr = map1.getRedlineSetup().getLineAttr();

        g_oDefaultFillAttr.BackColor = RedlineManager.fillBackColor.value; //1 to 256
        g_oDefaultFillAttr.BackMode = RedlineManager.fillBackMode.value;   //Transparent or Opaque.
        g_oDefaultFillAttr.Color = RedlineManager.fillColor.value;         //1 to 256
        g_oDefaultFillAttr.HatchPattern
            = RedlineManager.fillHatchPattern.value;                       // Horizontal, Vertical, Diagonal45, Diagonal135, Cross, or DiagonalCross.
        g_oDefaultFillAttr.Style = RedlineManager.fillStyle.value;         // None, Solid, or Hatch.

        g_oDefaultEdgeAttr.Color = RedlineManager.edgeColor.value;         //1 to 256
        g_oDefaultEdgeAttr.Style = RedlineManager.edgeStyle.value;         //Solid, Dash, Dot, DashDot, DashDotDot, or Rail.
        g_oDefaultEdgeAttr.Thickness = RedlineManager.edgeThickness.value; //1 to 16384
        g_oDefaultEdgeAttr.Visible = RedlineManager.edgeVisible.value;

        g_oDefaultLineAttr.Color = RedlineManager.lineColor.value;         //1 to 256
        g_oDefaultLineAttr.Style = RedlineManager.lineStyle.value;         //Solid, Dash, Dot, DashDot, DashDotDot, or Rail.
        g_oDefaultLineAttr.Thickness = RedlineManager.lineThickness.value; //1 to 16384

        aColor = g_oDefaultFillAttr.BackColor;
        oFillAttr.setBackColor(aColor);
        oFillAttr.setBackMode(g_oDefaultFillAttr.BackMode);
        aColor = g_oDefaultFillAttr.Color;
        oFillAttr.setColor(aColor);     
        oFillAttr.setHatchPattern(g_oDefaultFillAttr.HatchPattern);
        oFillAttr.setStyle(g_oDefaultFillAttr.Style);

        aColor = g_oDefaultEdgeAttr.Color;
        oEdgeAttr.setColor(aColor);

        oEdgeAttr.setStyle(g_oDefaultEdgeAttr.Style);
        oEdgeAttr.setThickness(g_oDefaultEdgeAttr.Thickness);
        oEdgeAttr.setVisible(g_oDefaultEdgeAttr.Visible);

        oLineAttr.setStyle(g_oDefaultLineAttr.Style);
        oLineAttr.setThickness(g_oDefaultLineAttr.Thickness);
        aColor = g_oDefaultLineAttr.Color;
        oLineAttr.setColor(aColor);
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function restoreDefaultSettings(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:			Restores the map fill and line attributes from the global vars
//
//
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////

function restoreDefaultSettings(map)
    {
    var map1;
    map1 = getMap();

    var aColor;
    var oFillAttr;
    oFillAttr = map1.getRedlineSetup().getFillAttr();
    oFillAttr.setBackMode(g_oDefaultFillAttr.BackMode);
    oFillAttr.setHatchPattern(g_oDefaultFillAttr.HatchPattern);
    oFillAttr.setStyle(g_oDefaultFillAttr.Style);
    aColor = g_oDefaultFillAttr.BackColor;
    oFillAttr.setBackColor(aColor);
    aColor = g_oDefaultFillAttr.Color;
    oFillAttr.setColor(aColor);

    var oEdgeAttr;
    oEdgeAttr = map1.getRedlineSetup().getEdgeAttr();
    oEdgeAttr.setStyle(g_oDefaultEdgeAttr.Style);
    oEdgeAttr.setThickness(g_oDefaultEdgeAttr.Thickness);
    oEdgeAttr.setVisible(g_oDefaultEdgeAttr.Visible);
    aColor = g_oDefaultEdgeAttr.Color;
    oEdgeAttr.setColor(aColor);

    var oLineAttr;
    oLineAttr = map1.getRedlineSetup().getLineAttr();
    oLineAttr.setStyle(g_oDefaultLineAttr.Style);
    oLineAttr.setThickness(g_oDefaultLineAttr.Thickness);
    aColor = g_oDefaultLineAttr.Color;
    oLineAttr.setColor(aColor);

    var oTextAttr;
    oTextAttr = map1.getRedlineSetup().getTextAttr();
    oTextAttr.setFontName(g_oDefaultTextAttr.FontName);
    oTextAttr.setFontStyle(g_oDefaultTextAttr.FontStyle);
    oTextAttr.setHeight(g_oDefaultTextAttr.Height, map1.getDisplayUnits());
    oTextAttr.setRotation(g_oDefaultTextAttr.Rotation);
    oTextAttr.setBackMode(g_oDefaultTextAttr.BackMode);
    oTextAttr.setHorizAlign(g_oDefaultTextAttr.HorizAlign);
    oTextAttr.setVertAlign(g_oDefaultTextAttr.VertAlign);
    aColor = g_oDefaultTextAttr.BackColor;
    oTextAttr.setBackColor(aColor);
    aColor = g_oDefaultTextAttr.Color;
    oTextAttr.setColor(aColor);
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function setSettings(sKey, map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:			Restores the map fill and line attributes from the global vars
//
//
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////

function setSettings(sKey, map)
    {
    var map1;
    map1 = getMap();

    var aColor;
    var fillAttr;
    var edgeAttr;
    var lineAttr;
    var txtAttr;
    fillAttr = map1.getRedlineSetup().getFillAttr();
    edgeAttr = map1.getRedlineSetup().getEdgeAttr();
    lineAttr = map1.getRedlineSetup().getLineAttr();
    txtAttr = map1.getRedlineSetup().getTextAttr();

    var aString;
    aString = sKey.split("_");

    switch (aString[0])
        {
        //"C_center.x,center.y_radius_FBackColor_FBackMode_FColor_FHatchPattern_FStyle_EColor_EStyle_EThickness_EVisible_DateTime"
        case 'C':
            aColor = aString[3];

            fillAttr.setBackColor(aColor);
            fillAttr.setBackMode(aString[4]);
            aColor = aString[5];
            fillAttr.setColor(aColor);
            fillAttr.setHatchPattern(aString[7]);
            fillAttr.setStyle(aString[6]);

            aColor = aString[8];
            edgeAttr.setColor(aColor);
            edgeAttr.setStyle(aString[9]);
            edgeAttr.setThickness(aString[10]);
            edgeAttr.setVisible(aString[11]);
            break;

        //"P_LColor_LStyle_LThickness_DateTime"
        case 'P':
            aColor = aString[1];

            lineAttr.setColor(aColor);
            lineAttr.setStyle(aString[2]);
            lineAttr.setThickness(aString[3]);
            break;

        //"G_FBackColor_FBackMode_FColor_FHatchPattern_FStyle_EColor_EStyle_EThickness_EVisible_DateTime"
        case 'G':
            aColor = aString[1];

            fillAttr.setBackColor(aColor);
            fillAttr.setBackMode(aString[2]);
            aColor = aString[3];
            fillAttr.setColor(aColor);
            fillAttr.setHatchPattern(aString[4]);
            fillAttr.setStyle(aString[5]);

            aColor = aString[6];
            edgeAttr.setColor(aColor);
            edgeAttr.setStyle(aString[7]);
            edgeAttr.setThickness(aString[8]);
            edgeAttr.setVisible(aString[9]);
            break;

        //"T_BackColor_BackMode_ForeColor_FontName_FontStyle_Height_Horizalign_Rotation_VertAlign_DateTime"
        case 'T':
            aColor = aString[1];

            txtAttr.setBackColor(aColor);
            txtAttr.setBackMode(aString[2]);
            aColor = aString[3];
            txtAttr.setColor(aColor);
            txtAttr.setFontName(aString[4]);
            txtAttr.setFontStyle(aString[5]);
            txtAttr.setHeight(aString[6], map1.getDisplayUnits());
            txtAttr.setHorizAlign(aString[7]);
            txtAttr.setRotation(aString[8]);
            txtAttr.setVertAlign(aString[9]);
            break;
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function pushToDB(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
// Remarks:			Sets the geometry data to redlinemanager page var and submits the page
//              to insert/upd to the database
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////

function pushToDB(map)
    {
    var map1;
    map1 = map;
	
    var oRedlinesLayer;
    oRedlinesLayer = map1.getMapLayer("Redlines");

    if (oRedlinesLayer == null)
        {
			alert("There are no Redlines drawn on map, Please draw and save");
			return;
		}

    var sData = "";
    var nCnt;
    var oObjs;

    oObjs = oRedlinesLayer.getMapObjectsEx();

    nCnt = oRedlinesLayer.getMapObjectsEx().Count;
	
	if (nCnt == 0)
	{
		alert("There are no Redlines drawn on map, Please draw and save");
		return;
    }
    for (k = 0; k <= oObjs.Count - 1; k++)
        {
        var oRLObj;
        oRLObj = oObjs(k);

        switch ((oRLObj.key).charAt(0))
            {
            case 'C': //circle
                sData = buildCircleData(sData, oRLObj.key);

                break;

            case 'P': //Polyline, Line
                sData = buildPolylineData(sData, "P", oRLObj);

                break;

            case 'G': //Polygon, Rectangle
                sData = buildPolylineData(sData, "G", oRLObj);

                break;

            case 'T': //Text
                sData = buildTextData(sData, oRLObj);

                break;

            case 'N': //Point, Symbol
                sData = buildSymbolData(sData, oRLObj);

                break;
            }
        }

		if (sData != "")
			{
			sData = sData.substr(0, sData.length - 1);
			// To remove the last semicolon ';' symbol.

			document.RedlineManager.redlinedata.value = sData;
			document.RedlineManager.buttonState.value = "P";
			var url = "RedlineManager.aspx?OPTION=&SEQ=&facility=";
			url += document.RedlineManager.facilityId.value;
			url += "&bldg=";
			url += document.RedlineManager.bldgId.value;
			url += "&floor=";
			url += document.RedlineManager.flrId.value;
			document.RedlineManager.action = url;
			document.RedlineManager.submit();
			}
		else
		{
			alert("There are no Redlines drawn on map, Please draw and save");
			return;
		}  
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function buildCircleData(sData, sKey)
//
// Return Value:	N/A
//
// Parameters:		transformed geometry string, object key
//
//  Return:       Transformed/Concat string
//
// Remarks:			Transforms the key string and appends to the geometry data
//
// Notes:
//          Called by PushToDB
/////////////////////////////////////////////////////////////////////////////

function buildCircleData(sData, sKey)
    {
    //"C_center.x,center.y_radius_FBackColor_FBackMode_FColor_FHatchPattern_FStyle_EColor_EStyle_EThickness_EVisible_DateTime"
    //"C|FBackColor|FBackMode|FColor|FStyle|FHatchPattern|EColor|EStyle|EThickness|EVisible|center.x,center.y|radius"
    var aString;
    aString = sKey.split("_");
    sData = sData + "C"
                  + "|" + + aString[3]+ "|"
                  + aString[4]  + "|" + aString[5] + "|" 
                  + aString[6]  + "|" + aString[7] + "|"   
                  + aString[8]  + "|" + aString[9] + "|" 
                  + aString[10] + "|" + aString[11]+ "|~|" 
                  + aString[1]  + "|" + aString[2];

    return sData + ";";
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function buildPolylineData(sData, sEntity, oRLObj)
//
// Return Value:	N/A
//
// Parameters:		transformed geometry string, geometry Type, Redline Object
//
//  Return:       Transformed/Concat string
//
// Remarks:			Transforms the key string and appends to the geometry data
//              for Polyline, Polygon geometry
// Notes:
//          Called by PushToDB
/////////////////////////////////////////////////////////////////////////////

function buildPolylineData(sData, sEntity, oRLObj)
    {
    //"P_LColor_LStyle_LThickness_DateTime"
    //"P|LColor|LStyle|LThickness|x1,y1|x2,y2|x3,y3|...."

    //"G_FBackColor_FBackMode_FColor_FHatchPattern_FStyle_EColor_EStyle_EThickness_EVisible_DateTime"
    //"G|FBackColor|FBackMode|FColor|FHatchPattern|FStyle|EColor|EStyle|EThickness|EVisible|x1,y1|x2,y2|..."
    var map1;
    map1 = getAMap();

    var Points;
    var nPoints;
    Points = map1.createObject("MGCollection");
    nPoints = map1.createObject("MGCollection");

    oRLObj.getVertices(Points, nPoints);

    var aString;
    aString = oRLObj.getKey().split("_");

    if (sEntity == 'P')
        {
        sData = sData + sEntity + "|" + aString[1] + "|" + aString[2] + "|" + aString[3] + "|~|";
        }

    else if (sEntity == 'G')
        {
        sData = sData + sEntity    + "|" + aString[1] + "|" + aString[2] + "|" + aString[3] + "|" + aString[4] + "|"
                      + aString[5] + "|" + aString[6] + "|" + aString[7] + "|" + aString[8] + "|" + aString[9] + "|~|";
        }

    for (i = 0; i <= Points.Count - 1; i++)
        {
        sData = sData + Points(i).x + "," + Points(i).y + "|";
        }

    sData = sData.substr(0, sData.length - 1); //To remove the last piping symbol '|'.
    return sData + ";";
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function buildTextData(sData, oRLObj)
//
// Return Value:	N/A
//
// Parameters:		transformed geometry string, Redline Object
//
//  Return:       Transformed/Concat string
//
// Remarks:			Transforms the key string and appends to the geometry data
//              for text geometry
// Notes:
//          Called by PushToDB
/////////////////////////////////////////////////////////////////////////////

function buildTextData(sData, oRLObj)
    {
    //"T_BackColor_BackMode_ForeColor_FontName_FontStyle_Height_Horizalign_Rotation_VertAlign_DateTime"
    //"T|TBackColor|TBackMode|TForeColor|TFontName|TFontStyle|THeight|THorizalign|TRotation|TVertAlign|TextString|Width|x,y|"
    var map1;
    map1 = getAMap();

    var Points;
    var nPoints;
    Points = map1.createObject("MGCollection");
    nPoints = map1.createObject("MGCollection");
    oRLObj.getVertices(Points, nPoints);

    var sText;
    var txtExtent;
    var txtWidth;
    var txtPrimitive;
    txtPrimitive = oRLObj.getPrimitives()(0);
    txtExtent = txtPrimitive.getExtent(true);
    txtWidth = txtExtent.getMaxX() - txtExtent.getMinX(); //Use this to specify the mtext's width in autocad.

    var aString;
    aString = oRLObj.key.split("_");

    sText = txtPrimitive.getTextValue();
    sText = sText.replace(/\\/g, "\\\\");
    // escape for / characters
    sText = sText.replace(/\r\n/g, "\\P");
    //carriage return

    sData = sData + "T|" + aString[1] + "|"   + aString[2]  + "|" + aString[3] + "|" + aString[4] + "|" + aString[5]
                  + "|"  + aString[6] + "|"   + aString[7]  + "|" + aString[8] + "|" + aString[9] + "|" + sText
                  + "|"  + txtWidth   + "|~|" + Points(0).x + "," + Points(0).y;
    return sData + ";";
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function buildSymbolData(sData, oRLObj)
//
// Return Value:	N/A
//
// Parameters:		transformed geometry string, Redline Object
//
//  Return:       Transformed/Concat string
//
// Remarks:			Transforms the key string and appends to the geometry data
//              for symbol geometry
// Notes:
//          Called by PushToDB
/////////////////////////////////////////////////////////////////////////////

function buildSymbolData(sData, oRLObj)
    {
    //"N_symbolName_symbolHeight_symbolWidth_symbolRotation_DatetTime"
    //"N|symbolName|symbolHeight|symbolWidth|symbolRotation|x,y"
    var map1;
    map1 = getAMap();

    var Points;
    var nPoints;
    Points = map1.createObject("MGCollection");
    nPoints = map1.createObject("MGCollection");
    oRLObj.getVertices(Points, nPoints);

    var aString;
    aString = oRLObj.key.split("_");
    sData = sData + "N|"  + aString[1]       + "|" + aString[2]       + "|" + aString[3] + "|" + aString[4]
                  + "|~|" + Points(0).getX() + "," + Points(0).getY() + "|" + aString[6];
    return sData + ";";
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function readFromDB()
//
// Return Value:	N/A
//
// Parameters:		none
//
//
// Remarks:
//             read the saved redlines from database
// Notes:
//          Called by PushToDB
/////////////////////////////////////////////////////////////////////////////

function readFromDB()
    {
    if (document.RedlineManager.redlinedata.value != "")
        {
        document.RedlineManager.drawButton.disabled = false;
        document.RedlineManager.buttonState.value = "R";
        document.RedlineManager.action = "RedlineManager.aspx";
        document.RedlineManager.submit();
        }

    else
        {
        document.RedlineManager.drawButton.disabled = true;
        }
    }


/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function createMapLayer()
//
// Return Value:	N/A
//
// Parameters:		none
//
//
// Remarks:
//         Checks and adds redline layer to map and sets the global var to redline layer object.
// Notes:
//          Called by drawFromDB
/////////////////////////////////////////////////////////////////////////////
function createMapLayer()
    {
    var mapObj = document.MapFrame.document.map;
    //= getMap();

    var oRedlinesLayer;
    oRedlinesLayer = mapObj.getMapLayer("redline");

    if (oRedlinesLayer == null)
        {
        oRedlinesLayer = mapObj.createLayer("redline", "redline");
        }

    else
        {
        var bSuccess;
        bSuccess = oRedlinesLayer.removeAllObjects();
        }

    g_oRedlinesLayer = oRedlinesLayer;
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function setRedlineSettings(sKey, map)
//
// Return Value:	N/A
//
// Parameters:		object Key, Map object
//
//
// Remarks:
//       Sets the redline attribute settings in the map before digitize
// Notes:
//          Called by drawFromDB
/////////////////////////////////////////////////////////////////////////////

function setRedlineSettings(sKey, map)
    {
    var map1 = map;
    //map1 = getAMap();
	if (sKey == "")
	{
	return;
	}
    var aColor;
    var fillAttr;
    var edgeAttr;
    var lineAttr;
    var txtAttr;
    fillAttr = map1.getRedlineSetup().getFillAttr();
    edgeAttr = map1.getRedlineSetup().getEdgeAttr();
    lineAttr = map1.getRedlineSetup().getLineAttr();
    txtAttr = map1.getRedlineSetup().getTextAttr();

    var aString;
    aString = sKey.split("|");


    switch (aString[0])
        {
        //"C_FBackColor_FBackMode_FColor_FStyle_FHatchPattern_EColor_EStyle_EThickness_EVisible_center.x,center.y_radius_"
        case 'C':
            aColor = aString[1];

            fillAttr.setBackColor(aColor);
            fillAttr.setBackMode(aString[2]);
            aColor = aString[3];
            fillAttr.setColor(aColor);
            fillAttr.setHatchPattern(aString[5]);
            fillAttr.setStyle(aString[4]);

            aColor = aString[6];
            edgeAttr.setColor(aColor);
            edgeAttr.setStyle(aString[7]);
            edgeAttr.setThickness(aString[8]);
            edgeAttr.setVisible(aString[9]);
            break;

        //"P_LColor_LStyle_LThickness_DateTime"
        case 'P':
            aColor = aString[1];

            lineAttr.setColor(aColor);
            lineAttr.setStyle(aString[2]);
            lineAttr.setThickness(aString[3]);
            break;

        //"G_FBackColor_FBackMode_FColor_FHatchPattern_FStyle_EColor_EStyle_EThickness_EVisible_DateTime"
        case 'G':
            aColor = aString[1];

            fillAttr.setBackColor(aColor);
            fillAttr.setBackMode(aString[2]);
            aColor = aString[3];
            fillAttr.setColor(aColor);  
            
			fillAttr.setStyle(aString[5]); 
            fillAttr.setHatchPattern(aString[4]);   
                                                     
			                   
            aColor = aString[6];
            edgeAttr.setColor(aColor);                        
            edgeAttr.setStyle(aString[7]);                  
            edgeAttr.setThickness(aString[8]);   
            
            edgeAttr.setVisible(aString[9]);    
            
            
       
            break;

        //"T_BackColor_BackMode_ForeColor_FontName_FontStyle_Height_Horizalign_Rotation_VertAlign_DateTime"
        case 'T':
            aColor = aString[1];

            txtAttr.setBackColor(aColor);
            txtAttr.setBackMode(aString[2]);
            aColor = aString[3];
            txtAttr.setColor(aColor);
            txtAttr.setFontName(aString[4]);
            txtAttr.setFontStyle(aString[5]);
            txtAttr.setHeight(aString[6], map1.getDisplayUnits());
            txtAttr.setHorizAlign(aString[7]);
            txtAttr.setRotation(aString[8]);
            txtAttr.setVertAlign(aString[9]);
            break;
        }
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function buildCircleObject(map1, redlineObject, point, redlineString)
//
// Return Value:	N/A
//
// Parameters:		Map object, redlineObject, center point, key
//
//
// Remarks:
//           Build Circle Object
// Notes:
//          Called by drawFromDB
/////////////////////////////////////////////////////////////////////////////


function buildCircleObject(map1, redlineObject, point, redlineString)
    {
    var key;
    key = redlineString.charAt(0);
    var centerX;
    var centerY;
    var radius;
    var tempString;
    var saveString;

    tempString = redlineString.substr(redlineString.lastIndexOf("|") + 1);

    radius = parseFloat(tempString);

    tempString = redlineString.substr(1, redlineString.lastIndexOf("|") - 1);
    saveString = tempString.substr(tempString.lastIndexOf("|") + 1);
    var coordArray = saveString.split(",");
    saveString = coordArray[0];

    centerX = parseFloat(saveString);

    saveString = coordArray[1];

    centerY = parseFloat(saveString);
    point.setX(centerX);
    point.setY(centerY);
    redlineObject.addCirclePrimitive(point, false, radius, map1.getDisplayUnits(), 100);
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function buildPolylineObject(map1, redlineObject, redlinetype, redlineString)
//
// Return Value:	N/A
//
// Parameters:		Map object, redlineObject, redline type, key
//
//
// Remarks:
//             Build Polyline Object
// Notes:
//          Called by drawFromDB
/////////////////////////////////////////////////////////////////////////////


function buildPolylineObject(map1, redlineObject, redlinetype, redlineString)
    {
    var key;
    key = redlineString.charAt(0);
    var centerX;
    var centerY;
    var radius;
    var tempString;
    var redlineArray;
    var mapCollection = map1.createObject("MGCollection");

    redlineArray = redlineString.split("|");
    var cnt = redlineArray.length;
    var j = 0;
    // set start point for polygon as default
    var k = 11;

    // Polyline Object - reset the start point
    if (redlinetype == "P")
        {
        k = 5;
        }

    for (i = k; i <= cnt - 1; i++)
        {
        
        j++;
        var pointObject = map1.createObject("MGPoint");
        tempString = redlineArray[i];
        var tempArray = tempString.split(",");
        tempString = tempArray[0];
        centerX = parseFloat(tempString);
        tempString = tempArray[1];
        centerY = parseFloat(tempString);
        pointObject.SetX(centerX);
        pointObject.SetY(centerY);
        mapCollection.add(pointObject);
        }

    var nVertices;
    nVertices = map1.createObject("MGCollection");
    nVertices.add(j);

    // Polyline Object
    if (redlinetype == "P")
        {
        redlineObject.addPolylinePrimitive(mapCollection, nVertices, false);
        }

    // Polygon object
    if (redlinetype == "G")
        {
        redlineObject.addPolygonPrimitive(mapCollection, nVertices, false);
        }
    }


/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function buildTextObject(map1, redlineObject, redlineString)
//
// Return Value:	N/A
//
// Parameters:		Map object, redlineObject,  key
//
//
// Remarks:
//             Build Text Object
// Notes:
//          Called by drawFromDB
/////////////////////////////////////////////////////////////////////////////

function buildTextObject(map1, redlineObject, redlineString)
    {
    var key;
    key = redlineString.charAt(0);
    var centerX;
    var centerY;
    var radius;
    var tempString;
    var redlineArray;
    var mapCollection = map1.createObject("MGCollection");
    redlineArray = redlineString.split("|");

    var pointObject = map1.createObject("MGPoint");
    var pointCoord = redlineArray[13];
    var pointArray = pointCoord.split(",");
    tempString = pointArray[0];
    centerX = parseFloat(tempString);
    tempString = pointArray[1];
    centerY = parseFloat(tempString);
    pointObject.SetX(centerX);
    pointObject.SetY(centerY);
	var txtString;
	txtString = redlineArray[10];
	
	txtString = txtString.replace(/\\/g, "\\\\");
	
    // escape for / characters
    txtString = txtString.replace(/\\\\\P/g, "\n");
    
    //carriage return
	
    redlineObject.addTextPrimitive(pointObject, false, txtString);
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function buildSymbolObject(map1, redlineObject, redlineString)
//
// Return Value:	N/A
//
// Parameters:		Map object, redlineObject,  key
//
//
// Remarks:
//             Build Symbol Object
// Notes:
//          Called by drawFromDB
/////////////////////////////////////////////////////////////////////////////

function buildSymbolObject(map1, redlineObject, redlineString)
    {
    var key;
    key = redlineString.charAt(0);
    var centerX;
    var centerY;
    var radius;
    var tempString;
    var redlineArray;
    redlineArray = redlineString.split("|");
    var pointObject = map1.createObject("MGPoint");
    tempString = redlineArray[6];
    tempString = tempString.substr(0, tempString.lastIndexOf(","));

    centerX = parseFloat(tempString);
    tempString = redlineArray[6];
    tempString = tempString.substr(tempString.lastIndexOf(",") + 1);

    centerY = parseFloat(tempString);
    pointObject.SetX(centerX);
    pointObject.SetY(centerY);
    var smbAttr;
    smbAttr = map1.RedlineSetup.getSymbolAttr();
    smbAttr.setSymbol(redlineArray[1]);
    smbAttr.setHeight(redlineArray[2], map1.getDisplayUnits());
    smbAttr.setWidth(redlineArray[3], map1.getDisplayUnits());    
    smbAttr.setRotation(redlineArray[4]);

    redlineObject.addSymbolPrimitive(pointObject, false);
    redlineObject.setName(redlineArray[7]);
    }

// *******************************************


//Editing commands

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function moveRedline()
//
// Return Value:	N/A
//
// Parameters:		Map object, redlineObject,  key
//
//
// Remarks:
//          Moves selected entities.
// Notes:
//          Called by Menu Function
/////////////////////////////////////////////////////////////////////////////

function moveRedline()
    {
    var map1;
    map1 = getAMap();

    map1.selectMode();

    //Check Grips layer existence.
    var oGripsLayer;

    if ((oGripsLayer = map1.getMapLayer("GRIPS")) != null)
        map1.removeMapLayer('GRIPS');

    var oSelection;
    oSelection = map1.getSelection();

    if (oSelection == null)
        {
        return;
        }

    var oObjs;
    oObjs = oSelection.getMapObjectsEx("");

    if (oObjs.Count > 0)
        {
        g_flag = "moveRedline";
        map1.digitizeLine();
        }
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function moveRedlineContd(deltaPt)
//
// Return Value:	N/A
//
// Parameters:		new point
//
//
// Remarks:
//          Moves selected entities.
// Notes:
//          Called by MoveRedline
/////////////////////////////////////////////////////////////////////////////

function moveRedlineContd(deltaPt)
    {
    var map1;
    var oObj;
    map1 = getAMap();

    var oSelection;
    oSelection = map1.getSelection();

    if (oSelection == null)
        {
        return;
        }

    var oObjs;
    oObjs = oSelection.getMapObjectsEx("");

    for (i = 0; i <= oObjs.Count - 1; i++)
        {
        oObj = oObjs(i);

        //Make sure the selected entity is on a redline layer and is not a GRIP entity.
        if ((oObj.getMapLayer().getType() == 'Drawing') && (oObj.getName().substr(0, 4) != 'Grip'))
            {
            var oMapObj;
            var oExtent;
            var aString;
            var Vertices;
            var nVertices;
            var key;
            var objName;
            var oLayer;
            oLayer = oObj.getMapLayer();
            key = oObj.getKey();
            objName = oObj.getName();

            Vertices = map1.createObject("MGCollection");
            nVertices = map1.createObject("MGCollection");

            oObj.getVertices(Vertices, nVertices);
            setSettings(oObj.getKey(), map1);

            switch (oObj.getType())
                {
                case 'Polyline':
                    for (k = 0; k <= Vertices.Count - 1; k++)
                        {
                        Vertices(k).setX(Vertices(k).getX() + deltaPt.getX());
                        Vertices(k).setY(Vertices(k).getY() + deltaPt.getY());
                        }

                    oLayer.removeObject(oObj);
                    oMapObj = oLayer.createmapobject(key, objName, "");
                    oMapObj.addPolylinePrimitive(Vertices, nVertices, true);
                    var sData = "";
                    sData = buildPolylineData(sData, "P", oMapObj);
                    var regExp = /\|/g;
					sData = sData.replace(regExp, "_");
                    sData = sData.substr(0, sData.length - 1);
                    sData = sData.
                    oLayer.removeObject(oMapObj);
                    oMapObj = oLayer.createmapobject(sData, objName, "");
                    oMapObj.addPolylinePrimitive(Vertices, nVertices, true);
                    //  oMapObj.setKey(sData);
                    break;

                case 'Polygon':
                    if ((oObj.key).charAt(0) == 'C')
                        {
                        var oPoint;
                        oPoint = map1.createObject("MGPoint");

                        oExtent = oObj.getExtentEx(true);
                        oPoint.setX(oExtent.getMinX() + (oExtent.getMaxX() - oExtent.getMinX()) / 2.0);
                        oPoint.setY(oExtent.getMinY() + (oExtent.getMaxY() - oExtent.getMinY()) / 2.0);

                        oPoint.setX(oPoint.getX() + deltaPt.getX());
                        oPoint.setY(oPoint.getY() + deltaPt.getY());

                        var sData = "";
                        sData = oObj.key;
                        var keyArray = sData.split("_");
                        var radius;
                        radius = keyArray[2];

                        var newCenter = oPoint.getX() + "," + oPoint.getY();

                        var tempKey = keyArray[0] + "_" + newCenter + "_" + radius;

                        for (i = 3; i <= keyArray.length - 1; i++)
                            {
                            tempKey = tempKey + "_" + keyArray[i];
                            }

                        key = tempKey;
                        oLayer.removeObject(oObj);
                        oMapObj = oLayer.createMapObject(key, objName, "");
                        oMapObj.addCirclePrimitive(oPoint, true, radius, map1.getDisplayUnits(), nVertices(0) - 1);
                        }

                    else
                        {
                        for (k = 0; k <= Vertices.Count - 1; k++)
                            {
                            Vertices(k).setX(Vertices(k).getX() + deltaPt.getX());
                            Vertices(k).setY(Vertices(k).getY() + deltaPt.getY());
                            }

                        oLayer.removeObject(oObj);
                        oMapObj = oLayer.createmapobject(key, objName, "");
                        oMapObj.addPolygonPrimitive(Vertices, nVertices, true);
                        var sData = "";
                        sData = buildPolylineData(sData, "G", oMapObj);
                    var regExp = /\|/g;
					sData = sData.replace(regExp, "_");

                        sData = sData.substr(0, sData.length - 1);
                        oLayer.removeObject(oMapObj);
                        oMapObj = oLayer.createmapobject(sData, objName, "");
                        oMapObj.addPolygonPrimitive(Vertices, nVertices, true);
                        //       oMapObj.setKey(sData);

                        }

                    break;

                case 'Text':
                    var oTxtString;

                    oTxtString = oObj.getPrimitives()(0).getTextValue();

                    Vertices(0).setX(Vertices(0).getX() + deltaPt.getX());
                    Vertices(0).setY(Vertices(0).getY() + deltaPt.getY());

                    oLayer.removeObject(oObj);
                    oMapObj = oLayer.createMapObject(key, objName, "");
                    oMapObj.addTextPrimitive(Vertices(0), true, oTxtString);
                    var sData = "";
                    sData = buildTextData(sData, oMapObj);
                    var regExp = /\|/g;
					sData = sData.replace(regExp, "_");
                    sData = sData.substr(0, sData.length - 1);
                    oLayer.removeObject(oMapObj);
                    oMapObj = oLayer.createMapObject(sData, objName, "");
                    oMapObj.addTextPrimitive(Vertices(0), true, oTxtString);
                    //    oMapObj.setKey(sData);
                    break;

                case 'Point':
                    var smbAttr;

                    aString = oObj.key.split("_");
                    smbAttr = map1.RedlineSetup.getSymbolAttr();
                    smbAttr.setHeight(aString[2], map1.getDisplayUnits());
                    smbAttr.setWidth(aString[3], map1.getDisplayUnits());
                    smbAttr.setRotation(aString[4]);

                    //Center of the symbol
                    Vertices(0).setX(Vertices(0).getX() + deltaPt.getX());
                    Vertices(0).setY(Vertices(0).getY() + deltaPt.getY());

                    smbAttr.setSymbol(aString[1]);

                    oLayer.removeObject(oObj);
                    oMapObj = oLayer.createMapObject(key, objName, "");
                    oMapObj.addSymbolPrimitive(Vertices(0), true);

                    break;
                }

            restoreDefaultSettings(map1);
            }
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function rotateRedline()
//
// Return Value:	N/A
//
// Parameters:		none
//
//
// Remarks:
//            Rotates selected entities.
// Notes:
//          Called by Menu  (This function is temp. not called as the
//                            logic does not rotate against z axis)
/////////////////////////////////////////////////////////////////////////////

function rotateRedline()
    {
    var map1;
    map1 = getAMap();

    map1.selectMode();

    //Check Grips layer existence.
    var oGripsLayer;

    if ((oGripsLayer = map1.getMapLayer("GRIPS")) != null)
        map1.removeMapLayer('GRIPS');

    var oSelection;
    oSelection = map1.getSelection();

    if (oSelection == null)
        {
        return;
        }

    var mapFeatures = map1.createObject("MGCollection");
    var oRedlinesLayer;
    oRedlinesLayer = map1.getMapLayer("Redlines");

    var oObjs;
    oObjs = oSelection.getMapObjectsEx("");
    var objKey = oObjs(0).getKey().charAt(0);

    if (oObjs.Count > 0)
        {
        g_flag = "rotateRedline";

        // ignore if its a circle
        if (objKey == "C")
            {
            return;
            }

        var origVerts = map1.createObject('MGCollection');
        var vertNum = map1.createObject('MGCollection');
        // Get vertices of first (and only) item in selected collection
        var result = oObjs(0).getVertices(origVerts, vertNum);

        if (result != 1)
            {
            return;
            }

        oRLObj = oRedlinesLayer.createMapObject("", "", "");
        var mapCollection = map1.createObject("MGCollection");
        var xRotated;
        var yRotated;
        var angle = 90;
        // 3.14159265358979 / 180;
        var deg2rad = .01745329;

        var X;
        var Y;
        var j = 0;

        //	mapCollection.add(origVerts(0));
        //	j++;
        for (i = 0; i <= origVerts.Count - 1; i++)
            {
            j++;
            pointObject = map1.createObject("MGPoint");
            X = origVerts(i).getX();
            Y = origVerts(i).getY();
            xRotated = X * Math.cos(angle * deg2rad) - Y * Math.sin(angle * deg2rad);
            yRotated = X * Math.sin(angle * deg2rad) + Y * Math.cos(angle * deg2rad);
            pointObject.SetX(xRotated);
            pointObject.SetY(yRotated);
            //	alert("origX = " + X + " after= " + xRotated);
            //	alert("origY = " + Y + " after= " + yRotated);
            mapCollection.add(pointObject);
            }

        //  alert("aftermath");
        var nVertices;
        nVertices = map1.createObject("MGCollection");
        nVertices.add(j);

        //		alert(mapCollection.Count);

        if (objKey == "P")
            {
            oRLObj.addPolylinePrimitive(mapCollection, nVertices, false);
            }

        else
            {
            oRLObj.addPolygonPrimitive(mapCollection, nVertices, false);
            }

        // map1.digitizeLine();
        mapFeatures.add(oRLObj);
        }
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function deleteRedline(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
//
// Remarks:
//            Deletes selected entities.
// Notes:
//          Called by Menu
/////////////////////////////////////////////////////////////////////////////

function deleteRedline(map)
    {
    var map1;
    map1 = map;

    var sArray;
    var oLayer;
    var oObjs;
    var selection = map1.getSelection();
    var objs = selection.getMapObjectsEx("redline");

    if (!(objs.size() > 0))
        {
        var bcfm = confirm("Please select a redline to delete before choosing delete menu");
        return;
        map1.selectMode();
        objs = selection.getMapObjectsEx("redline");

        if (!(objs.size() > 0))
            {
            return;
            }
        }

    if (!(confirm("Are you sure you want to delete this redline?")))
        {
        return;
        }


    //Check Grips layer existence.
    var oGripsLayer;

    if ((oGripsLayer = map1.getMapLayer("GRIPS")) != null)
        map1.removeMapLayer('GRIPS');

    if (map1.getSelection() == null)
        {
        return;
        }

    oObjs = map1.selection.getMapObjectsEx("");

    //Create an array of strings to store the layer names of those entities that needs to be deleted.
    sArray = new Array(oObjs.Count);

    for (i = 0; i <= oObjs.Count - 1; i++)
        {
        oLayer = oObjs(i).getMapLayer();
        sArray[i] = oLayer.getName();
        }

    //Iterate thru the array and delete the selected objects.
    for (i = 0; i <= sArray.length - 1; i++)
        {
        oLayer = map1.getMapLayer(sArray[i]);
        oLayer.removeObjects(oObjs);
        }
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function editProps()
//
// Return Value:	N/A
//
// Parameters:		map object
//
//
// Remarks:
//            displays properties dialog and allows editing
// Notes:
//          Called by Menu
/////////////////////////////////////////////////////////////////////////////

function editProps()
    {
    var map1;
    map1 = getAMap();

    map1.selectMode();

    var oSelection;
    oSelection = map1.getSelection();

    if (oSelection == null)
        {
        return;
        }

    //Check Grips layer existence.
    var oGripsLayer;

    if ((oGripsLayer = map1.getMapLayer("GRIPS")) != null)
        map1.removeMapLayer('GRIPS');

    var oObjs;
    oObjs = oSelection.getMapObjectsEx("");

    if (oObjs.Count > 1)
        {
        alert("Edit properties of one entity at a time!");
        return;
        }

    if (oObjs.Count == 0)
        {
        return;
        }

    var oObj;
    var oRedlinesLayer;
    oObj = oObjs(0);
    oRedlinesLayer = oObj.getMapLayer();

    if (oRedlinesLayer.getName() == "Redlines")
        {
        var aString;
        var oMapObj;
        var oPoints;
        var nPoints;
        oPoints = map1.createObject("MGCollection");
        nPoints = map1.createObject("MGCollection");

        var aColor;
        var oLayer;
        var objName;
        var key;
        objName = oObj.getName();
        oObj.getVertices(oPoints, nPoints);

        switch (oObj.getType())
            {
            case 'Polyline':
                //"P_LColor_LStyle_LThickness_Date"
                aString = oObj.getKey().split("_");

                RedlineManager.lineColor.value = aString[1];
                RedlineManager.lineStyle.value = aString[2];
                RedlineManager.lineThickness.value = aString[3];

                //Display a modal dialog with various options for drawing a polyline
     
                var param = "?lineStyle=" + RedlineManager.lineStyle.value;
                param += "&lineColor=" + RedlineManager.lineColor.value;
                param += "&lineWidth=" + RedlineManager.lineThickness.value;
                RedlineManager.bReturn.value = "edit";
				var scale = map1.getScale();
				param += "&scale=" + scale;
                openWin("Polyline.aspx", param, "PolylineAttributes", 275, 250, "false", "no");
                break;

            case 'Polygon':
                if (oObj.getkey().charAt(0) == 'C')
                    {
                    //"C_center.x,center.y_radius_FBackColor_FBackMode_FColor_FStyle_FHatchPattern_EColor_EStyle_EThickness_EVisible_Date"
                    aString = oObj.getKey().split("_");
                    RedlineManager.fillBackColor.value = aString[3];
                    RedlineManager.fillBackMode.value = aString[4];
                    RedlineManager.fillColor.value = aString[5];
                    RedlineManager.fillHatchPattern.value = aString[7];
                    RedlineManager.fillStyle.value = aString[6];

                    RedlineManager.edgeColor.value = aString[8];
                    RedlineManager.edgeStyle.value = aString[9];
                    RedlineManager.edgeThickness.value = aString[10];
                    RedlineManager.edgeVisible.value = aString[11];
                    }

                else
                    {
                    //"G_FBackColor_FBackMode_FColor_FHatchPattern_FStyle_EColor_EStyle_EThickness_EVisible_Date"
                    aString = oObj.getKey().split("_");
                    RedlineManager.fillBackColor.value = aString[1];
                    RedlineManager.fillBackMode.value = aString[2];
                    RedlineManager.fillColor.value = aString[3];
                    RedlineManager.fillHatchPattern.value = aString[4];
                    RedlineManager.fillStyle.value = aString[5];

                    RedlineManager.edgeColor.value = aString[6];
                    RedlineManager.edgeStyle.value = aString[7];
                    RedlineManager.edgeThickness.value = aString[8];
                    RedlineManager.edgeVisible.value = aString[9];
                    }

                //Display a modal dialog with various options for drawing a polyline
                var param = "?foregroundColor=" + RedlineManager.fillColor.value;

                if (RedlineManager.fillStyle.value == "None" || RedlineManager.fillStyle.value == "Solid")
                    {
                    param += "&fillStyle=" + RedlineManager.fillStyle.value;
                    }

                else
                    {
                    param += "&fillStyle=" + RedlineManager.fillHatchPattern.value;
                    }

                param += "&backgroundFill=" + RedlineManager.fillBackMode.value;
                param += "&lineStyle=" + RedlineManager.edgeStyle.value;
                param += "&lineColor=" + RedlineManager.edgeColor.value;
                param += "&lineWidth=" + RedlineManager.edgeThickness.value;
                param += "&visible=" + RedlineManager.edgeVisible.value;
                RedlineManager.bReturn.value = "edit";
                var title = "PolygonAttributes";

                if (oObj.getkey().charAt(0) == 'C')
                    {
                    title = "CircleAttributes"
                    }
				var scale = map1.getScale();
				param += "&scale=" + scale;
                openWin("Polygon.aspx", param, title, 275, 400, "false", "no");

                break;

            case 'Text':
                //"T_BackColor_BackMode_ForeColor_FontName_FontStyle_Height_HorizAlign_Rotation_VertAlign"
                aString = oObj.getkey().split("_");

                RedlineManager.txtValue.value = oObj.getPrimitives()(0).getTextValue();
                RedlineManager.txtBackColor.value = aString[1];
                RedlineManager.txtBackMode.value = aString[2];
                RedlineManager.txtColor.value = aString[3];
                RedlineManager.txtFontName.value = aString[4];
                RedlineManager.txtFontStyle.value = aString[5];
                RedlineManager.txtHeight.value = aString[6];
                RedlineManager.txtHorizAlign.value = aString[7];
                RedlineManager.txtRotation.value = aString[8];
                RedlineManager.txtVertAlign.value = aString[9];

                //Display a modal dialog with various options for editing the selected text
     
                var param = "?backColor=" + RedlineManager.txtBackColor.value;
                param += "&backMode=" + RedlineManager.txtBackMode.value;
                param += "&foreColor=" + RedlineManager.txtColor.value;
                param += "&fontName=" + RedlineManager.txtFontName.value;
                param += "&fontStyle=" + RedlineManager.txtFontStyle.value;
                param += "&height=" + RedlineManager.txtHeight.value;
                param += "&horizAlign=" + RedlineManager.txtHorizAlign.value;
                param += "&rotation=" + RedlineManager.txtRotation.value;
                param += "&vertAlign=" + RedlineManager.txtVertAlign.value;

                RedlineManager.bReturn.value = "edit";
				var scale = map1.getScale();
				param += "&scale=" + scale;
                openWin("Text.aspx", param, "TextAttributes", 550, 350, "false", "yes");

                break;

            case 'Point':
				RedlineManager.bReturn.value = "editprop";
                onDoubleClickObject(oObj);

                break;
            }
        }

    else
        {
        oSelection = map1.getSelection();

        if (oSelection == null)
            {
            oSelection.clear();
            }
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function setVariables(geometryType)
//
// Return Value:	N/A
//
// Parameters:		Geometry Type
//
//
// Remarks:
//            Sets the javascript globals
// Notes:
//          Called by Menu
/////////////////////////////////////////////////////////////////////////////

function setVariables(geometryType)
    {
    var map1;
    var oObj;
    map1 = getAMap();
	var oObjs;
	
	if (geometryType == "Point" || geometryType == "Text")
	{
	
		var layer = map1.getMapLayer("Redlines");

			if (layer != null)
			{
			
				oObj = layer.getMapObject(g_sKey);	
				
				if (oObj == null)
				{
					return;
				}			
			}
			else
			{
				return;
			}
	}
	else
	{
		map1.selectMode();

		var oSelection;
	   
		oSelection = map1.getSelection();

		if (oSelection == null)
			{
			return;
			}

	  
		oObjs = oSelection.getMapObjectsEx("");
	
	
		if (oObjs.Count > 1)
			{
			alert("Edit properties of one entity at a time!");
			return;
			}

		if (oObjs.Count == 0)
			{
			return;
			}
			oObj = oObjs(0);
	}
    
    var oRedlinesLayer;
    
    oRedlinesLayer = oObj.getMapLayer();

    if (oRedlinesLayer.getName() == "Redlines")
        {
        var aString;
        var oMapObj;
        var oPoints;
        var nPoints;
        oPoints = map1.createObject("MGCollection");
        nPoints = map1.createObject("MGCollection");

        var aColor;
        var oLayer;
        var objName;
        var key;
        objName = oObj.getName();
        oLayer = oObj.getMapLayer();
        oObj.getVertices(oPoints, nPoints);

        if (RedlineManager.bReturn.value == "true")
            {
            var aString = oObj.getKey().split("_");

            switch (geometryType)
                {
                case 'Point':
                
                    oExtent = oObj.getExtentEx(true);
					oPoint0 = map1.createObject("MGPoint");
                    oPoint0.x = oExtent.getMinX() + (oExtent.getMaxX() - oExtent.getMinX()) / 2.0;
                    oPoint0.y = oExtent.getMinY() + (oExtent.getMaxY() - oExtent.getMinY()) / 2.0;

                    key = aString[0] + "_" + RedlineManager.smbSelected.value + "_" + RedlineManager.smbHeight.value
                                     + "_" + RedlineManager.smbWidth.value    + "_" + RedlineManager.smbRotation.value
                                     + "_" + aString[5];

                    oLayer.removeObject(oObj);

                    var smbAttr;
                    smbAttr = map1.RedlineSetup.getSymbolAttr();
                    
                    smbAttr.setHeight(RedlineManager.smbHeight.value, map1.getDisplayUnits());
                    smbAttr.setWidth(RedlineManager.smbWidth.value, map1.getDisplayUnits());
                    
                    
					
                   smbAttr.setSymbol(RedlineManager.smbSelected.value);
                   smbAttr.setRotation(parseFloat(RedlineManager.smbRotation.value));
				


                    if (RedlineManager.smbNote.value != "")
                        {
                        objName = RedlineManager.smbNote.value;
                        }

                    oMapObj = oLayer.createMapObject(key, objName, "");
                    oMapObj.addSymbolPrimitive(oPoint0, true);
					
					
                    break;

                case 'Polygon':
                    var fillAttr;

                    var edgeAttr;
                    fillAttr = map1.getRedlineSetup().getFillAttr();
                    edgeAttr = map1.getRedlineSetup().getEdgeAttr();

                    fillAttr.setStyle(RedlineManager.fillStyle.value);
                    fillAttr.setBackMode(RedlineManager.fillBackMode.value);
                    fillAttr.setHatchPattern(RedlineManager.fillHatchPattern.value);
                    aColor = RedlineManager.fillBackColor.value;
                    fillAttr.setBackColor(aColor);
                    aColor = RedlineManager.fillColor.value;
                    fillAttr.setColor(aColor);

                    aColor = RedlineManager.edgeColor.value;
                    edgeAttr.setColor(aColor);
                    edgeAttr.setStyle(RedlineManager.edgeStyle.value);
                    edgeAttr.setThickness(RedlineManager.edgeThickness.value);
                    edgeAttr.setVisible(RedlineManager.edgeVisible.value);

                    if (oObj.getkey().charAt(0) == 'C')
                        {
                        key = "C_" + aString[1]                            + "_"
                                   + aString[2]                            + "_"
                                   + RedlineManager.fillBackColor.value    + "_"
                                   + RedlineManager.fillBackMode.value     + "_"
                                   + RedlineManager.fillColor.value        + "_"
                                   + RedlineManager.fillStyle.value        + "_"
                                   + RedlineManager.fillHatchPattern.value + "_"                      
                                   + RedlineManager.edgeColor.value        + "_"
                                   + RedlineManager.edgeStyle.value        + "_"
                                   + RedlineManager.edgeThickness.value    + "_"
                                   + RedlineManager.edgeVisible.value      + "_"
                                   + aString[12];
                        }

                    else
                        {
                        key = "G_" + RedlineManager.fillBackColor.value    + "_"
                                   + RedlineManager.fillBackMode.value     + "_"
                                   + RedlineManager.fillColor.value        + "_"
                                   + RedlineManager.fillHatchPattern.value + "_"
                                   + RedlineManager.fillStyle.value        + "_"
                                   + RedlineManager.edgeColor.value        + "_"
                                   + RedlineManager.edgeStyle.value        + "_"
                                   + RedlineManager.edgeThickness.value    + "_"
                                   + RedlineManager.edgeVisible.value      + "_"
                                   + aString[10];
                        }

                    oRedlinesLayer.removeObject(oObj);
                    oMapObj = oRedlinesLayer.createmapobject(key, objName, "");
                    oMapObj.addPolygonPrimitive(oPoints, nPoints, true);
                    restoreDefaultSettings(map1);

                    break;

                case 'Polyline':
                    var lineAttr;

                    lineAttr = map1.getRedlineSetup().getLineAttr();
                    lineAttr.setStyle(RedlineManager.lineStyle.value);
                    lineAttr.setThickness(RedlineManager.lineThickness.value);

                    aColor = RedlineManager.lineColor.value;
                    lineAttr.setColor(aColor);

                    key = "P_" + RedlineManager.lineColor.value     + "_" + RedlineManager.lineStyle.value + "_"
                               + RedlineManager.lineThickness.value + "_" + aString[4];

                    oRedlinesLayer.removeObject(oObj);
                    oMapObj = oRedlinesLayer.createmapobject(key, objName, "");
                    oMapObj.addPolylinePrimitive(oPoints, nPoints, true);
                    restoreDefaultSettings(map1);

                    break;

                case 'Text':
                    var aColor;

                    oObj.getVertices(oPoints, nPoints);
					g_flag = "insertText";
                    var txtAttr;
                    txtAttr = map1.RedlineSetup.getTextAttr();

                    aColor = RedlineManager.txtBackColor.value;
					txtAttr.setBackColor(aColor);
					
                    txtAttr.setBackMode(RedlineManager.txtBackMode.value);
                    aColor = RedlineManager.txtColor.value;
                    txtAttr.setColor(aColor);
                    txtAttr.setFontName(RedlineManager.txtFontName.value);
                    txtAttr.setFontStyle(RedlineManager.txtFontStyle.value);
                    txtAttr.setHeight(RedlineManager.txtHeight.value, map1.getDisplayUnits());
                    txtAttr.setRotation(RedlineManager.txtRotation.value);
                    txtAttr.setHorizAlign(RedlineManager.txtHorizAlign.value);
                    txtAttr.setVertAlign(RedlineManager.txtVertAlign.value);

                    //"T_BackColor_BackMode_ForeColor_FontName_FontStyle_Height_Horizalign_Rotation_VertAlign"
                    key = "T_" + RedlineManager.txtBackColor.value  + "_" + RedlineManager.txtBackMode.value + "_"
                               + RedlineManager.txtColor.value      + "_" + RedlineManager.txtFontName.value + "_"
                               + RedlineManager.txtFontStyle.value  + "_" + RedlineManager.txtHeight.value   + "_"
                               + RedlineManager.txtHorizAlign.value + "_" + RedlineManager.txtRotation.value + "_"
                               + RedlineManager.txtVertAlign.value  + "_" + new Date().valueOf(); //aString[10];
					  var sText = RedlineManager.txtValue.value;
					 
					
                    oRedlinesLayer.removeObject(oObj);
                    oMapObj = oRedlinesLayer.createMapObject(key, objName, "");
                    oMapObj.addTextPrimitive(oPoints(0), true, sText);
                     RedlineManager.txtFontName.value = g_oDefaultTextAttr.FontName;
                    
					g_oDefaultTextAttr.FontStyle	= RedlineManager.txtFontStyle.value;
					g_oDefaultTextAttr.Height		= RedlineManager.txtHeight.value;
					g_oDefaultTextAttr.Rotation		= RedlineManager.txtRotation.value ;
					g_oDefaultTextAttr.BackMode		= RedlineManager.txtBackMode.value;
					g_oDefaultTextAttr.HorizAlign	= RedlineManager.txtHorizAlign.value;
					g_oDefaultTextAttr.VertAlign	= RedlineManager.txtVertAlign.value;
					g_oDefaultTextAttr.BackColor	= RedlineManager.txtBackColor.value;
					g_oDefaultTextAttr.Color		= RedlineManager.txtColor.value;
					break;
			
                }
            }

        RedlineManager.bReturn.value = "";
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function onSelectionChanged(map1)
//
// Return Value:	N/A
//
// Parameters:		Map Object
//
//
// Remarks:
//          Following is for testing purpose only.
// Notes:
//          Called by Menu
/////////////////////////////////////////////////////////////////////////////

function onSelectionChanged(map1)
    {
    //Check Grips layer existence.
    var oGripsLayer;

    if ((oGripsLayer = map1.getMapLayer("GRIPS")) != null)
        {
        //Get all objects currently selected from Grips layer.
        var oSelection;
        oSelection = map1.getSelection();

        if (oSelection != null)
            {
            var oObjs;
            oObjs = oSelection.getMapObjectsEx(oGripsLayer);

            //Process only if 1 Grip is selected.
            var nObjCnt = oObjs.Count;

            if (nObjCnt == 1)
                {
                g_flag = "resize";
                map1.digitizePoint();
                }

            else
                {
                map1.removeMapLayer('GRIPS');
                //oGripsLayer.removeAllObjects();
                }
            }
        }
    }


/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function Test()
//
// Return Value:	N/A
//
// Parameters:		none
//
//
// Remarks:
//            Test function
// Notes:
//          Called by Event handler
/////////////////////////////////////////////////////////////////////////////

function Test(map)
    {
    if (map.getSelection().getmapobjectsEx('Redlines')(0) != null)
    {
		alert(map.getSelection().getmapobjectsEx('Redlines')(0).getKey());
    }
    }

/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function getAMap()
//
// Return Value:	N/A
//
// Parameters:		none
//
//
// Remarks:
//            function to get handle to map object
// Notes:
//          Called by all the function in this javascipt
/////////////////////////////////////////////////////////////////////////////

function getAMap()
    {
    return getMap("dummy");
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function showRedline(map)
//
// Return Value:	N/A
//
// Parameters:		map object
//
//
// Remarks:
//            function to turn the redline layer on and off
// Notes:
//          Called by menu
/////////////////////////////////////////////////////////////////////////////

function showRedline(map)
    {
    var layer = map.getMapLayer("Redlines");

    if (layer != null)
        {
        layer.setVisibility(!layer.getVisibility());
        map.refresh();
        }
    }
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function setPriority(map, bUpDown)
//
// Return Value:	N/A
//
// Parameters:		map object, up or down flag
//
//
// Remarks:
//            function to move up and down the priority number
// Notes:
//          Called by menu
/////////////////////////////////////////////////////////////////////////////

function setPriority(map, bUpDown)
    {
    var redlineLayer = map.getMapLayer("Redlines");
    var redlineLayerPriority = 0;

    if (redlineLayer != null)
        {
        redlineLayerPriority = redlineLayer.getPriority();

        // Assign collection to layers variable
        var layers = map.getMapLayersEx();
        var layerPriority = 0;

        var eachLayer;

        // Use size() to step through collection
        for (var i = 0; i < layers.size(); i++)
            {

            // Get each item in collection...

            eachLayer = layers.item(i);

            if (eachLayer.isVisible())
                {
                if (eachLayer.getName() != redlineLayer.getName())
                    {
                    layerPriority = eachLayer.getPriority();
                    // ...then check if u want to move the redline layer
                    //    one up or down

                    if (bUpDown == "UP")
                        {
                        if (layerPriority >= redlineLayerPriority)
                            {
                            redlineLayerPriority = layerPriority + 1;
                            break;
                            }
                        }

                    else
                        {
                        if (layerPriority <= redlineLayerPriority)
                            {
                            redlineLayerPriority = layerPriority - 1;
                            break;
                            }
                        }
                    }
                }
            }

        // Set the new priority
        // alert(redlineLayerPriority);
        if (redlineLayerPriority < 0)
            {
            redlineLayerPriority = 0;
            }

        if (redlineLayerPriority > 100)
            {
            redlineLayerPriority = 100;
            }

        redlineLayer.setPriority(redlineLayerPriority);        
        map.refresh();
        redrawLegend();        
        }
    }
    
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function copyToClipboard()
//
// Return Value:	N/A
//
// Parameters:		none
//
//
// Remarks:
//            function to copy the current map into clipboard for user to paste
//				it in the email client
// Notes:
//          Called by redlinemanager.aspx
/////////////////////////////////////////////////////////////////////////////
function copyRedlineToClipboard()
{
	var map = getMap();
	if (map.isBusy())
	{
		setTimeout("copyRedlineToClipboard();",100);		
	}
	else
	{
		map.copyMap();
	}
}    
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function redrawLegend()
//
// Return Value:	N/A
//
// Parameters:		none
//
//
// Remarks:
//            function to redraw legends on the map
// Notes:
//          Called by set priority
/////////////////////////////////////////////////////////////////////////////
function redrawLegend()
{
	var map = getMap();
	if (map.isBusy())
	{
		setTimeout("redrawLegend();",100);
	}
	else
	{
		map.redrawLegend();
	}
}
    
/////////////////////////////////////////////////////////////////////////////
//
// Syntax:			function redlineInfo(map)
//
// Return Value:	N/A
//
// Parameters:		map object, up or down flag
//
//
// Remarks:
//            function to display key of redline object
// Notes:
//          Called by menu only when needed to debug
/////////////////////////////////////////////////////////////////////////////

function redlineInfo(map)
    {
    Test(map);
    }

function setupRedlineLayer(map)
{
    var RED = 5;
    var layer = map.getMapLayer("redline");
    if( layer == null )
        layer = map.createLayer("redline", "redline");
    layer.setPriority(100.0);
    var redlineSetup = map.getRedlineSetup();
    
 //   var edgeAttr = redlineSetup.getEdgeAttr();
 //   var lineAttr = redlineSetup.getLineAttr();
 //   var fillAttr = redlineSetup.getFillAttr();
    
 //   edgeAttr.setColor(RED);
 //   edgeAttr.setStyle("Solid");
 //   edgeAttr.setThickness(1);
 //   edgeAttr.setVisible(true);
    
 //   lineAttr.setColor(RED);
 //   lineAttr.setStyle("Solid");
 //   lineAttr.setThickness(1);
    
 //   fillAttr.setBackColor(RED);
 //   fillAttr.setBackMode("Transparent");
 //   fillAttr.setColor(RED);
 //   fillAttr.setStyle("Diagonal135");
    
        //Default settings - Fill, Edge, Line, Text attributes
    if (g_oDefaultFillAttr == null)
		g_oDefaultFillAttr = new Object();
    if (g_oDefaultEdgeAttr == null)
		g_oDefaultEdgeAttr = new Object();
    if (g_oDefaultLineAttr == null)
	    g_oDefaultLineAttr = new Object();
    if (g_oDefaultTextAttr == null)
	    g_oDefaultTextAttr = new Object();

    var oFillAttr;
    oFillAttr = redlineSetup.getFillAttr();
    var oEdgeAttr;
    oEdgeAttr = redlineSetup.getEdgeAttr();
    var oLineAttr;
    oLineAttr = redlineSetup.getLineAttr();
    var oTextAttr;
    oTextAttr = redlineSetup.getTextAttr();
    oFillAttr.setBackMode("Transparent");
    oFillAttr.setStyle("Hatch");
    oFillAttr.setHatchPattern("Diagonal135");

    g_oDefaultFillAttr.BackColor = "6"; //oFillAttr.getBackColor();
    g_oDefaultFillAttr.BackMode = oFillAttr.getBackMode();
    g_oDefaultFillAttr.Color = "5";     //oFillAttr.getColor();
    g_oDefaultFillAttr.HatchPattern = oFillAttr.getHatchPattern();
    g_oDefaultFillAttr.Style = oFillAttr.getStyle();

    g_oDefaultEdgeAttr.Color = "5"; //oEdgeAttr.getColor();
    g_oDefaultEdgeAttr.Style = oEdgeAttr.getStyle();
    g_oDefaultEdgeAttr.Thickness = oEdgeAttr.getThickness();
    g_oDefaultEdgeAttr.Visible = oEdgeAttr.getVisible();

    g_oDefaultLineAttr.Color = "5"; //oLineAttr.getColor();
    g_oDefaultLineAttr.Style = oLineAttr.getStyle();
    g_oDefaultLineAttr.Thickness = oLineAttr.getThickness();

    g_oDefaultTextAttr.FontName = oTextAttr.getFontName();
    g_oDefaultTextAttr.FontStyle = oTextAttr.getFontStyle();
    g_oDefaultTextAttr.Height = oTextAttr.getHeight(map.getDisplayUnits());
    g_oDefaultTextAttr.Rotation = oTextAttr.getRotation();
    g_oDefaultTextAttr.BackMode = oTextAttr.getBackMode();
    g_oDefaultTextAttr.HorizAlign = oTextAttr.getHorizAlign();
    g_oDefaultTextAttr.VertAlign = oTextAttr.getVertAlign();
    g_oDefaultTextAttr.BackColor = "6";
    g_oDefaultTextAttr.Color = "5";
    
    restoreDefaultSettings(map);


    return layer;
}
// =======================================================================