// OPIS 2.0 version #1
// Written by Mark V Andrews
// Indigo Hills GIS/Highland Mapping Inc.
// April 2010
// ---------------------------------
//  Configurable Variables
// ---------------------------------

var parcelLayerID = 1
var structureLayerID = 0
var mainMapURL = "http://gis2.pittcountync.gov/ArcGIS/rest/services/OPIS_Lite/MapServer";
var identifyURL = "http://gis2.pittcountync.gov/ArcGIS/rest/services/OPIS_Search/MapServer";
var geoServiceUrl = "http://gis2.pittcountync.gov/ArcGIS/rest/services/PASS/Geometry/GeometryServer"
var overviewMapUrl = "http://gis2.pittcountync.gov/ArcGIS/rest/services/OPIS_Overview/MapServer";
var addressSearchURL = "http://gis2.pittcountync.gov/ArcGIS/rest/services/OPIS_Search/MapServer/" + structureLayerID;
var searchURL = "http://gis2.pittcountync.gov/ArcGIS/rest/services/OPIS_Search/MapServer/" + parcelLayerID;
var tocServiceURL = "./MapServiceHandler.ashx"
var mapViewServiceURL = "./MapViewHandler.ashx"

//var parcelLayerID = 15
//var structureLayerID = 3
//var mainMapURL = "http://mva1/ArcGIS/rest/services/pitt/MapServer";
//var identifyURL = "http://mva1/ArcGIS/rest/services/pitt/MapServer";
//var geoServiceUrl = "http://mapping.yanceycountync.gov/ArcGIS/rest/services/Geometry/GeometryServer"
//var overviewMapUrl = "http://mva1/ArcGIS/rest/services/pittoverview/MapServer";
//var addressSearchURL = "http://mva1/ArcGIS/rest/services/pitt/MapServer/3";
//var searchURL = "http://mva1/ArcGIS/rest/services/pitt/MapServer/15";
//var tocServiceURL = "./MapServiceHandler.ashx"
//var mapViewServiceURL = "./MapViewHandler.ashx"

var idLayers = [parcelLayerID];
var maxExtents = new esri.geometry.Extent({
    xmin: 2383697,
    ymin: 578000,
    xmax: 2578900,
    ymax: 762500,
    spatialReference:{"wkid": 2264}
});
// -----------------------------
//  Global Variables
// -----------------------------
var currentTool = "ZOOMIN";
var map = null; ovmap = null; printmapObj = null;
var initialMapState = null; initialScale = null;
var navToolbar = null; var resizeTimer = null;


var identifyTask, identifyParams;
var mTolerance = 1;
var mSelectPolygonSymbol = null;
var m_idPointSymbol = null;
var idHandle;
var outSpRef, gsrv;

var tocLayers = []; mapViewStates = [];
var mapHelper = null; measureTask = null;
var selectedPIN = "";
var showTransitions = true;
var ovMapSymbol = new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID, new dojo.Color([255, 0, 0]), 2);

var rightPanels = ["about", "searchE911", "searchAddress", "searchOwner", "searchPIN", "details", "results", "toc", "working", "error"];
var tools = ["PAN", "ZOOMIN", "ZOOMOUT", "SELECT"];  // note these are tool with buttons... tools without buttons don;t need to be in this list.

function startup() {

    handleResize();
    dojo.connect(window, "onresize", handleResize);
    map = new esri.Map("map", { nav: false, slider: false });

    // add the county layer           
    var countylayer = new esri.layers.ArcGISDynamicMapServiceLayer(mainMapURL, {
        id: "map",
        opacity: 1,
        visible: true
    });
    countylayer.setImageFormat("jpg");
    map.addLayer(countylayer);

    // on load event
    dojo.connect(map, "onLoad", function() {

        // set up the proxy handler to handle large JSON Objects
        esriConfig.defaults.io.proxyUrl = "proxy.ashx";
        esriConfig.defaults.io.alwaysUseProxy = false;

        // populate the side panel about dialog.
        $('#about-content').load('text.htm');

        // initialize some global variables...
        mapHelper = new Maphelper({ map: map, fullextent: map.extent });
        navToolbar = new esri.toolbars.Navigation(map);
        map.disableDoubleClickZoom();
        initialMapState = { initialExtent: dojo.toJson(map.extent), visible: countylayer.visibleLayers };
        initialScale = mapHelper.calculateMapScale();
        InitializeToolbar();
        idHandle = dojo.connect(map, "onClick", map_onclick);
        initIdentifyFunctionality();
        initRightPanels();

        console.debug(countylayer.visibleLayers);

        // zoom to full extent
        map.setExtent(countylayer.fullExtent, true);
        document.getElementById("FULL").onmousedown = function() {
            map.setExtent(countylayer.fullExtent, true);
            // update the map visibility
            countylayer.setDefaultVisibleLayers();
            document.getElementById("ddlMode").value = "DEFAULT";
            setTimeout(refreshTOC, 1000);
            showRightPanel("about");
            ToolbarMouseDown("ZOOMIN", "Tool");
        };

        // resize the map when the window resizes
        dojo.connect(window, 'onresize', function() {
            clearTimeout(resizeTimer);

            resizeTimer = setTimeout(function() {
                map.resize();
                map.reposition();
                //initialScale = mapHelper.calculateMapScale();
                $("#message").text("Refreshing the map, please be patient...").show().fadeOut(2000);
            }, 500);
        });

        // update the table of contents when the extent changes
        dojo.connect(map, "onExtentChange", function() {
            refreshTOC();
            updatePrintFunctions();
        });
        dojo.connect(countylayer, "onUpdate", function() {
            updatePrintFunctions();
        });


        // set up the overview map... 
        ovmap = new esri.Map("ovmap", { nav: false, slider: false });
        var ovURL = overviewMapUrl;
        var ovlayer = new esri.layers.ArcGISDynamicMapServiceLayer(ovURL, { id: "overviewmap" });
        ovmap.addLayer(ovlayer);
        dojo.connect(ovlayer, "onLoad", function() { ovmap.disableMapNavigation(); updateOverviewExtent(); });
        dojo.connect(map, "onExtentChange", updateOverviewExtent);
        dojo.connect(ovmap, "onClick", function(evt) { map.centerAt(evt.mapPoint); });

        // populate the layer list
        dojo.xhrGet({ url: tocServiceURL, handleAs: "json", contentType: "application/json; charset=utf-8",
            load: function(data, arg) {
                tocLayers = data.Layers;
                refreshTOC();
            },
            error: function(error, args) { console.debug(error); }
        });

        dojo.xhrGet({
            url: mapViewServiceURL, handleAs: "json", contentType: "application/json; charset=utf-8",
            load: function(data, arg) {
                var ddl = document.getElementById("ddlMode");
                mapViewStates = data;
                dojo.forEach(data, function(item, indx) {
                    var opt = dojo.doc.createElement("option");
                    opt.innerHTML = item.Label;
                    opt.setAttribute("value", item.Key);
                    ddl.appendChild(opt);
                });
                dojo.connect(ddl, "onchange", ddlMode_onchange);

            },
            error: function(error, args) { console.debug(error); }
        });

        // init the scale bar
        dojo.connect(map, "onExtentChange", updateScalebar);
        updateScalebar();

        ToolbarMouseDown(currentTool, "Tool"); // set the default tool

        // map navigation
        map.enableScrollWheelZoom();

        // process the url
        var url = esri.urlToObject(window.location.toString());
        if (url.query != undefined) {
            try {
                if (url.query.pid != "") {
                    $("#APN").val(url.query.pid);
                    doSearchPin();
                }
                if ((url.query.visible != "") && (url.query.visible != undefined)) {
                    var visibleStr = url.query.visible;
                    var visible = visibleStr.split(",");
                    countylayer.setVisibleLayers(visible);
                }

            } catch (ex) { console.debug(ex); }
        }

    });

    // create the output spatial reference - projecting to longitude/latitude
    outSpRef = new esri.SpatialReference({ wkid: 4326 });
    // initialize the geometry service              
    gsrv = new esri.tasks.GeometryService(geoServiceUrl);

}

function updateScalebar() {
    var scale = mapHelper.calculateMapScale();
    scale = scale.toFixed(0);
    $("#SCALETEXT").text(scale + "ft");
}

function updateOverviewExtent() {

    try {
        var scale = mapHelper.calculateMapScale();
        var ext = map.extent;
       if (scale < 1000) {
                var ovPtMapSymbol = new esri.symbol.SimpleMarkerSymbol(esri.symbol.SimpleMarkerSymbol.STYLE_SQUARE, 4,
                                              new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID,
                                              new dojo.Color([255, 0, 0]), 1),
                                              new dojo.Color([255, 0, 0, 1]));
                var point = ext.getCenter();

                ovmap.graphics.clear();
                var ovGraphic = new esri.Graphic(point, ovPtMapSymbol);
                ovmap.graphics.add(ovGraphic);
         } else if (scale > 20000) {

             var polygon = new esri.geometry.Polygon(new esri.SpatialReference({ wkid: 2264 }));
             polygon.addRing([[maxExtents.xmax, maxExtents.ymax], [maxExtents.xmax, maxExtents.ymin], [maxExtents.xmin, maxExtents.ymin], [maxExtents.xmin, maxExtents.ymax], [maxExtents.xmax, maxExtents.ymax]]);
             ovmap.graphics.clear();
             var ovGraphic = new esri.Graphic(polygon, ovMapSymbol);
             ovmap.graphics.add(ovGraphic);

         } else {
                var polygon = new esri.geometry.Polygon(new esri.SpatialReference({ wkid: 2264 }));
                polygon.addRing([[ext.xmax, ext.ymax], [ext.xmax, ext.ymin], [ext.xmin, ext.ymin], [ext.xmin, ext.ymax], [ext.xmax, ext.ymax]]);
                ovmap.graphics.clear();
                var ovGraphic = new esri.Graphic(polygon, ovMapSymbol);
                ovmap.graphics.add(ovGraphic);
        }      
    } catch (ex) {
        console.debug(ex);
    }
}

//-----------------------------------------------
// changes the current visible panel on the right
// clears panel children where appropriate.
// set the mouse focus
// ----------------------------------------------
function showRightPanel(name) {
    // hide right panels
    dojo.forEach(rightPanels, function(p) {
        dojo.style(p, { display: "none" });
    });

    showTransitions ? $("#" + name).fadeIn(500) : $("#" + name).css(display, "block");

    // set the focus
    switch (name) {
        case "searchOwner":
            selectedPIN = "";
            map.graphics.clear();
            $("#LAST").val(""); $("#FIRST").val("");
            $("#error_searchOwner").empty();
            document.getElementById("LAST").focus();
            break;
        case "searchPIN":
            selectedPIN = "";
            map.graphics.clear();
            $("#APN").val("");
            $("#error_searchPIN").empty();
            document.getElementById("APN").focus();
            break;
        case "searchE911":
            selectedPIN = "";
            map.graphics.clear();
            $("#STNO").val(""); $("#STNAME").val("");
            $("#error_searchE911").empty();
            document.getElementById("STNO").focus();
            break;
        case "searchAddress":
            selectedPIN = "";
            map.graphics.clear();
            $("#HOUSENUM").val(""); $("#STREETADDRESS").val("");
            $("#error_searchAddress").empty();
            document.getElementById("HOUSENUM").focus();
            break;
        case "about":
            selectedPIN = "";
            map.graphics.clear();
            updatePrintFunctions();
            resetDataFrames();
            break;
    }
}

// --------------------------------------------
//  Basic Functions of the page & map
// --------------------------------------------

function handleResize() {

    var h = $(window).height();
    var w = $(window).width();

    if (document.documentElement) {
        document.documentElement.style.overflow = "hidden";
        document.documentElement.style.height = "100%";
    } else {
        document.body.style.overflow = "hidden";
        document.body.style.height = "100%";
    }


    // header height = 103px
    // left side bar width = 161px
    // right side bar width = 280px
    // 
    // minimum height of the left side panel = 600
    //   
    var mapwidth = w - (161 + 280);
    var rightHeight = h - 153;
    $("#toolbar").css("width", w - 161 + "px");
    $("#header").css("width", w - 161 + "px");    
    $("#rightpanel").css("left", w - 280 + "px").css("height",h - 153 + "px");
    $("#ParcelUpdateInfo").css("left", w - 280 + "px");    
    $("#map").css("width",  mapwidth + "px").css("height",h - 103 + "px" );
    $("#rightpanel_inner").css("height", rightHeight + "px");
    $("#searchwindow").css("height", h - 290 + "px");
}

function InitializeToolbar() {

    // top toolbar
    document.getElementById("WEST").onmousedown = canGoWest;
    document.getElementById("EAST").onmousedown = canGoEast;
    document.getElementById("NORTH").onmousedown = canGoNorth;
    document.getElementById("SOUTH").onmousedown = canGoSouth;
    document.getElementById("ZOOMOUT2X").onmousedown = canZoomOut;
    document.getElementById("ZOOMIN2X").onmousedown = function() { map.centerAndZoom(map.extent.getCenter(), 0.5); };

    // side bar toolbar
    document.getElementById("PAN").onmousedown = function() {
        var cp = map.extent.getCenter();
        if (!maxExtents.contains(cp)) {
            $("#message").text("you panned outside of the boundary of Pitt County!").show().fadeOut(3000);
            map.disablePan();
            ToolbarMouseDown("ZOOMIN", "Tool");
        } else {
            //map.enablePan();
            ToolbarMouseDown("PAN", "Tool");
        }
    };    
    dojo.connect(map, "onPanEnd", function(extent, endpt) {
        var cp = extent.getCenter();
        if (!maxExtents.contains(cp)) {
            $("#message").text("you panned outside of the boundary of Pitt County!").show().fadeOut(3000);
            map.disablePan();
            ToolbarMouseDown("ZOOMIN", "Tool");
        }
    });
    
    document.getElementById("ZOOMIN").onmousedown = function() {
        ToolbarMouseDown("ZOOMIN", "Tool");
    };

    document.getElementById("ZOOMOUT").onmousedown = function() {
        ToolbarMouseDown("ZOOMOUT", "Tool");
    };

    document.getElementById("SELECT").onmousedown = function() {
        ToolbarMouseDown("SELECT", "Tool");
    };

    document.getElementById("MEASURE").onmousedown = function() {
        ToolbarMouseDown("Measure", "Command");
    };

    document.getElementById("MAPZOOMCOORDS").onmousedown = function() { ToolbarMouseDown("MAPZOOMCOORDS", "Command"); };
}

function canGoNorth() {
    var ext = map.extent;
    if (ext.ymax > maxExtents.ymax) {
        $("#message").text("you are too far north!").show().fadeOut(3000);
        return false;
    } else { $("#message").text(""); map.panUp(); return true; }
}

function canGoSouth() {
    var ext = map.extent;
    if (ext.ymin < maxExtents.ymin) {
        $("#message").text("you are too far south!").show().fadeOut(3000);
        return false;
    } else { $("#message").text(""); map.panDown(); return true; }
}

function canGoEast() {
    var ext = map.extent;
    if (ext.xmax > maxExtents.xmax) {
        $("#message").text("you are too far east!").show().fadeOut(3000);
        return false;
    } else { $("#message").text(""); map.panRight(); return true; }
}

function canGoWest() {
    var ext = map.extent;
    if (ext.xmin < maxExtents.xmin) {
        $("#message").text("your are too far west!").show().fadeOut(3000);
        return false;
    } else { $("#message").text(""); map.panLeft(); return true; }
}

function canZoomOut() {
    var scale = mapHelper.calculateMapScale();
    if ((scale * 0.95) > initialScale) {
        $("#message").text("zoomed too far out!").show().fadeOut(3000);
        return false;
    } else { map.centerAndZoom(map.extent.getCenter(), 2.0); return true; }
}

function updatePrintFunctions() {
    var lyr = map.getLayer("map");
    var extent = map.extent;
    document.getElementById("printAlt").href = "print.aspx?resetSession=true&x1=" + extent.xmin + "&y1=" + extent.ymin + "&x2=" + extent.xmax + "&y2=" + extent.ymax + "&pid=" + selectedPIN + "&visible=" + lyr.visibleLayers;
}

function ToolbarMouseDown(tool, tooltype) {

    $("#coordinatetool").css("display", "none");
    $("#measuretool").css("display", "none");

    map.infoWindow.hide();
    if (tooltype === "Tool") {
        clearCurrentTool();
        currentTool = tool;

        var obj = document.getElementById(tool);
        if (obj != null) {
            obj.src = "images/" + tool.toLowerCase() + "1.gif";
        }

        switch (tool) {
            case "ZOOMIN":
                navToolbar.activate(esri.toolbars.Navigation.ZOOM_IN);
                break;
            case "ZOOMOUT":
                navToolbar.activate(esri.toolbars.Navigation.ZOOM_OUT);
                break;
            case "PAN":
                navToolbar.activate(esri.toolbars.Navigation.PAN);
                break;
            case "SELECT":
                showRightPanel("about");
                navToolbar.activate(esri.toolbars.Navigation.PAN);
                break;
            default:
                navToolbar.activate(esri.toolbars.Navigation.PAN);
                break;
        }

    } else {

        switch (tool) {
            case "Measure":
                map.graphics.clear();
                navToolbar.activate(esri.toolbars.Navigation.PAN);
                $("#measuretool").css("display", "block");
                clearCurrentTool();
                var closeCmd = function() { map.graphics.clear(); $("#measuretool").css("display", "none"); measureTask.onDestroy(); measureTask = null; clearCurrentTool(); }
                $("#SEGMENTLENGTH").val("");
                $("#TOTALLENGTH").val("");
                $("#TOTALAREA").val("");
                $("#TOTALACRES").val("");
                currentTool = "MEASURE";
                $("#MEASURECLOSE").click(closeCmd);
                measureTask = new MeasureTask({ map: map, geometryService: gsrv });
                break;
            case "MAPZOOMCOORDS":
                map.graphics.clear();
                navToolbar.activate(esri.toolbars.Navigation.PAN);
                $("#coordinatetool").css("display", "block");
                clearCurrentTool();
                currentTool = "COORDS";
                $("#LONGITUDE").val("");
                $("#LATITUDE").val("");
                $("#COORDLABEL").html("click on the map to get coordinates <br/> or enter coordinates in the textboxes above");
                // attach the events
                var closeCmd = function() { map.graphics.clear(); $("#coordinatetool").css("display", "none"); clearCurrentTool(); }
                var keycmd = function(evt) { if (isEnter(evt)) { doMapCoords(); } };
                $("#COORDGO").click(doMapCoords);
                $("#LATITUDE").keydown(keycmd);
                $("#LONGITUDE").keydown(keycmd);
                $("#COORDCLOSE").click(closeCmd);
                var focuscmd = function() { document.getElementById("LONGITUDE").focus(); };
                window.setTimeout(focuscmd, 1000);
                break;
            case "ClearSelection":
                break;
            default:
                break;
        }
    }
}

function resetDataFrames() {
    map.graphics.clear();
    $("#RESULTSNODE").empty();
    $("#DETAILNODE").empty();
}

function clearCurrentTool() {
    try {
        // clear selected tools
        currentTool = "";
        dojo.forEach(tools, function(tool) {
            document.getElementById(tool).src = "images/" + tool.toLowerCase() + ".gif";
        });

    } catch (Error) { }
}

function doEmail() {
    sendMail();

//    $("#mailDialog").css({ "height": "200px", "width": "200px" }).fadeIn(500);
//    $("#modalBackground").show();
}

function hideMail() {
    $("#mailDialog").hide();
    $("#modalBackground").hide();
}


// ------------------------------------
// Map Interaction functions
// ------------------------------------
function map_onclick(evt) {
    map.infoWindow.hide();
    switch (currentTool) {
        case "SELECT":
            doIdentify(evt);
            break;
        case "MEASURE":
            measureTask.addPoint(evt.mapPoint);
            $("#TOTALLENGTH").val(dojo.number.round(measureTask.totalLength(), 2));
            measureTask.calculateArea();
            measureTask.updateGraphics();
            break;
        case "COORDS":
            var graphic = new esri.Graphic(evt.mapPoint);
            gsrv.project([graphic], outSpRef, function(features) {
                pt = features[0].geometry;
                var xText = dojo.number.round(pt.x, 6);
                var yText = dojo.number.round(pt.y, 6);

                $("#LONGITUDE").val(xText);
                $("#LATITUDE").val(yText);
                var txt = "Long: " + xText + "  Lat: " + yText;
                addMapCoordGraphics(evt.mapPoint, txt);

            });
            break;
        default:
            // do nothing at all
    }
}


// -----------------------
//  Map Coordinate tool
// -----------------------
function doMapCoords() {

    var lon = document.getElementById("LONGITUDE").value;
    var lat = document.getElementById("LATITUDE").value;

    // validate...
    if (isNaN(lon) || isNaN(lat)) {
        $("#COORDLABEL").html("You must enter a number");
        return;
    }

    $("#COORDLABEL").html("");
    if (lon > 0) lon = "-" + lon

    var nlon = 0;
    var nlat = 0;
    nlon = eval(lon);
    nlat = eval(lat);

    var txt = "Lon: " + lon + "  Lat: " + lat;
    var pt = new esri.geometry.Point(nlon, nlat, outSpRef);
    var graphic = new esri.Graphic(pt);
    gsrv.project([graphic], map.spatialReference, function(features) {
        var pt2 = features[0].geometry;
        mapHelper.centerAndZoom(pt2, 1200);
        addMapCoordGraphics(pt2, txt);
    });

}

function addMapCoordGraphics(pt, txt) {
    map.graphics.clear();
    // add a graphic
    var symbol = new esri.symbol.SimpleMarkerSymbol(esri.symbol.SimpleMarkerSymbol.STYLE_CROSS, 12,
               new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID,
               new dojo.Color([255, 0, 0]), 1),
               new dojo.Color([255, 0, 0, 0.25]));

    var font = new esri.symbol.Font("12pt", esri.symbol.Font.STYLE_ITALIC, esri.symbol.Font.VARIANT_NORMAL);
    map.graphics.add(new esri.Graphic(pt, symbol));
    map.graphics.add(new esri.Graphic(pt, new esri.symbol.TextSymbol(txt, font, new dojo.Color([255, 0, 0])).setOffset(15, 15)));
}

// -----------------------
//  Identify tool
// -----------------------
function doIdentify(evt) {

    var smallExt = new esri.geometry.Extent({
        xmin: evt.mapPoint.x - 100,
        ymin: evt.mapPoint.y - 100,
        xmax: evt.mapPoint.x + 100,
        ymax: evt.mapPoint.y + 100,
        spatialReference: { "wkid": 2264 }
    });

    map.graphics.clear();
    identifyParams.geometry = evt.mapPoint;
    identifyParams.mapExtent = smallExt;
    showRightPanel("working");
    identifyTask.execute(identifyParams, function(idResults) { identifyTask_onComplete(idResults, evt); }, identify_error);
}
function identify_error(error) {
    var s = [];
    s.push("<div class=\"searches\"><p><strong>Error Occurred</strong></p>");
    s.push("<p>" + error.message + "</p>");
    s.push("</div>");
    document.getElementById("ERRORNODE").innerHTML = s.join("");
    showRightPanel("error");
}
function initIdentifyFunctionality() {
    identifyTask = new esri.tasks.IdentifyTask(identifyURL);
    identifyParams = new esri.tasks.IdentifyParameters();
    identifyParams.tolerance = mTolerance;
    identifyParams.returnGeometry = true;
    identifyParams.layerIds = idLayers;
    identifyParams.layerOption = esri.tasks.IdentifyParameters.LAYER_OPTION_ALL;

    mSelectPolygonSymbol = new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID, new dojo.Color([0, 200, 255]), 2);
    m_idPointSymbol = new esri.symbol.PictureMarkerSymbol("images/pin.png", 20, 20);
}
function identifyTask_onComplete(idResults, evt) {
    if (idResults.length == 0) {
        map.graphics.clear();
        var s = [];
        s.push("<div class=\"searches\"><p><strong>No Results Found!</strong></p>");
        document.getElementById("ERRORNODE").innerHTML = s.join("");
        showRightPanel("error");
        return;
    }
    // center and zoom the graphic
    var graphic = idResults[0].feature;
    graphic.setSymbol(mSelectPolygonSymbol);
    map.graphics.add(graphic);
    mapHelper.zoomToFeature(graphic.geometry, 2);

    // get the parcel number
    var parcelNum = graphic.attributes["Parcel Number"];
    if (parcelNum.length > 5) {
        map.graphics.clear();
        var s = [];
        s.push("<div class=\"searches\"><p><strong>You have selected a common area, right-of-way parcel or a parcel that is outside of Pitt County.  These parcels have no attributes in the system.</strong></p>");
        $("#ERRORNODE").html(s.join(""));
        showRightPanel("error");
        return;
    }
    showParcelDetail(parcelNum);
}

// ----------------------------------------
// Functions dealing with searches
// ----------------------------------------
function initRightPanels() {
    // attach the search event on enter key to all search textboxes...
    // owner search
    $("#LAST").keydown(function(event) { if (isEnter(event)) doSearchOwner(); });
    $("#FIRST").keydown(function(event) { if (isEnter(event)) doSearchOwner(); });
    $("#SEARCHOWNER").click(doSearchOwner);

    // Pin search
    $("#APN").keydown(function(evt) { if (isEnter(evt)) doSearchPin(); });
    $("#SEARCHAPN").click(doSearchPin);

    // parcel address search
    $("#HOUSENUM").keydown(function(evt) { if (isEnter(evt)) doSearchPropertyAddress(); });
    $("#STREETADDRESS").keydown(function(evt) { if (isEnter(evt)) doSearchPropertyAddress(); });
    $("#SEARCHADDRESS").click(doSearchPropertyAddress);

    // E911 Search
    $("#STNO").keydown(function(evt) { if (isEnter(evt)) doE911Search(); });
    $("#STNAME").keydown(function(evt) { if (isEnter(evt)) doE911Search(); });
    $("#SEARCHE911").click(doE911Search);
}
function doSearchOwner() {
    // get the input...
    var fname = document.getElementById("FIRST").value;
    var lname = document.getElementById("LAST").value;
    var owner = lname + "  " + fname;

    // check to see if input is valid...
    if (fname == "" && lname == "") {
        // invalidate the query
        //alert("you must enter a name");
        $("#error_searchOwner").text("You must enter a name").show();
        return;
    }
    // do a database query...
    //showRightPanel("working");
    $("#working").css("display", "block");
    dojo.xhrGet({
        url: "./DataHandler.ashx?q=ow&v=" + owner,
        handleAs: "json", contentType: "application/json; charset=utf-8",
        load: function(data, arg) {
            ProcessSearchResults(data);
        },
        error: function(error, args) { identify_error(error); }
    });
}

function doSearchPin() {

    var parcelNum = document.getElementById("APN").value;
    if (parcelNum == "") {
        $("#error_searchPIN").text("You must enter a parcel number");
        return;
    }
    // showRightPanel("working");
    $("#working").css("display", "block");
    showParcelDetail(parcelNum);
    doSearchGIS(parcelNum);
}

function doSearchPropertyAddress() {

    var hn = document.getElementById("HOUSENUM").value;
    var addr = document.getElementById("STREETADDRESS").value;

    if (hn == "" && addr == "") {
        // invalidate the query
        $("#error_searchAddress").text("you must enter a street name");
        return;
    }
    // showRightPanel("working");
    $("#working").css("display", "block");
    dojo.xhrGet({
        url: "./DataHandler.ashx?q=pa&hn=" + hn + "&ad=" + addr,
        handleAs: "json",
        contentType: "application/json; charset=utf-8",
        load: function(data, arg) {
            ProcessSearchResults(data);
        },
        error: function(error, args) { identify_error(error); }
    });

}

function doE911Search() {

    var hn = document.getElementById("STNO").value;
    var addr = document.getElementById("STNAME").value;

    if (hn == "" && addr == "") {
        $("#STNO").focus();

        // invalidate the query
        $("#error_searchE911").text("you must enter a street name");
        return;
    }
//    var whereClause = "ADDR_HN like '" + hn + "%' and ADDR_SN like '" + addr + "%'";
//    // showRightPanel("working");
//    $("#working").css("display", "block");

//    //Search Fields are: ADDR_HN   ADDR_SN            
//    var queryTask = new esri.tasks.QueryTask(addressSearchURL);
//    var query = new esri.tasks.Query();
//    query.where = whereClause;
//    query.outFields = ["ADDRESS", "ADDR_ZN"];
//    query.returnGeometry = true;

//    //Execute task and call showResults on completion
    //    queryTask.execute(query, ProcessE911SearchResults, function(ex) { identify_error(error); });


    $("#working").css("display", "block");
    dojo.xhrGet({
        url: "./DataHandler.ashx?q=e9&hn=" + hn + "&ad=" + addr,
        handleAs: "json",
        contentType: "application/json; charset=utf-8",
        load: function(data, arg) {
            ProcessE911SearchResults(data);
        },
        error: function(error, args) { identify_error(error); }
    });


}


// ----------------------------------------
// Process Search Results
// ----------------------------------------
function ProcessE911SearchResults(data) {
 
        $("#RESULTSNODE").empty();

        if (data.length == 0) {
            $("<p>").addClass("bold-text").text("There are no matching records in database.").css("margin-top", "25px").appendTo("#RESULTSNODE");
            showRightPanel("results");
        } else {

            if (data.length == 1) {
                doE911toParcel(data[0].uniqueid);
                return;
            }

            var div = dojo.doc.createElement("div");
            var table = document.createElement("table");
            var tbody = document.createElement("tbody");
            table.appendChild(tbody);
            div.appendChild(table);
            // more than one selected...
            dojo.forEach(data, function(item, indx) {

                var a = document.createElement("a");
                var cmd = "javascript:doE911toParcel('" + item.uniqueid + "');";
                a.href = cmd;
                a.innerHTML = item.Address;
                var tr = document.createElement("tr");
                var td1 = document.createElement("td");
                td1.setAttribute("valign", "top");
                td1.appendChild(a);
                var td2 = document.createElement("td");
                td2.setAttribute("valign", "top");
                td2.innerHTML = item.City;
                tr.appendChild(td1);
                tr.appendChild(td2);
                tbody.appendChild(tr);
            });

            document.getElementById("RESULTSNODE").appendChild(div);

            showRightPanel("results");
        }
    }

    function doE911toParcel(uniqueid) {
        var whereClause = "OBJECTID=" + uniqueid;                  
        var queryTask = new esri.tasks.QueryTask(addressSearchURL);
        var query = new esri.tasks.Query();
        query.where = whereClause;
        query.outFields = ["ADDRESS", "ADDR_ZN"];
        query.returnGeometry = true;
        queryTask.execute(query, function(results) {
            var e911Feature = results.features[0];
            if (e911Feature != null) {
                var pt = e911Feature.geometry;
                var evtProxy = { mapPoint: pt };
                doIdentify(evtProxy);
            }
        }, function(ex) { identify_error(error); });
    }

//////////    $("#RESULTSNODE").empty();

//////////    if (results.features.length === 0) {
//////////        var div = document.createElement("div");
//////////        var p = document.createElement("p");
//////////        p.setAttribute("class", "bold-text");
//////////        p.innerHTML = "There are no matching records in database.";
//////////        div.appendChild(p);
//////////        document.getElementById("ERRORNODE").appendChild(div);
//////////        showRightPanel("error");
//////////        return;
//////////    }

//////////    if (results.features.length === 1) {
//////////        var graphic = results.features[0];
//////////        var pt = graphic.geometry;
//////////        var evtProxy = { mapPoint: pt };
//////////        doIdentify(evtProxy);
//////////        return;
//////////    }

//////////    var div = dojo.doc.createElement("div");
//////////    var table = document.createElement("table");
//////////    var tbody = document.createElement("tbody");
//////////    table.appendChild(tbody);
//////////    div.appendChild(table);
//////////    // more than one selected...
//////////    dojo.forEach(results.features, function(graphic, indx) {

//////////        var pt = graphic.geometry;
//////////        var address = graphic.attributes["ADDRESS"];
//////////        var city = graphic.attributes["ADDR_ZN"];
//////////        console.debug(graphic);

//////////        var a = document.createElement("a");

//////////        var cmd = function() { var evtProxy = { mapPoint: pt }; doIdentify(evtProxy); }
//////////        a.href = "javascript:void(0);";
//////////        a.onmousedown = cmd;
//////////        a.innerHTML = address;
//////////        var tr = document.createElement("tr");
//////////        var td1 = document.createElement("td");
//////////        td1.setAttribute("valign", "top");
//////////        td1.appendChild(a);
//////////        var td2 = document.createElement("td");
//////////        td2.setAttribute("valign", "top");
//////////        td2.innerHTML = city;
//////////        tr.appendChild(td1);
//////////        tr.appendChild(td2);
//////////        tbody.appendChild(tr);
//////////    });

//////////    $("#RESULTSNODE").append(div);
//////////    showRightPanel("results");

function ProcessSearchResults(data) {
    var s = [];

    switch (data.length) {
        case 0:
            s.push("<div>");
            s.push("<p class=\"bold-text\" style=\"color:black\">There are no matching records in database.</p>");
            s.push("</div>");
            document.getElementById("ERRORNODE").innerHTML = s.join("");
            showRightPanel("error");

            break;
        case 1:
            var item = data[0];
            showParcelDetail(item.ParcelNumber);
            doSearchGIS(item.ParcelNumber);
            break;
        default:

            if (dojo.isIE)
                s.push("<table cellspacing=\"1\" cellpadding=\"1\" border=\"0\" width=\"90%\">");
            else
                s.push("<table cellspacing=\"1\" cellpadding=\"1\" border=\"0\" width=\"100%\">");

            s.push("<tbody>");
            dojo.forEach(data, function(item, indx) {
                var cssClass = "r2";
                if (indx % 2 == 0)
                    cssClass = "r1";

                var cmd = "javascript:showParcelDetail('" + item.ParcelNumber + "');doSearchGIS('" + item.ParcelNumber + "');";

                s.push("<tr class=\"" + cssClass + "\">");
                s.push("<td>" + (indx + 1) + "</td>");
                s.push("<td><a href=\"" + cmd + "\"  >" + item.ParcelNumber + "</a></td>");
                s.push("<td>" + item.OwnerName + "</td>");
                s.push("<td>" + item.Address + "</td>");
                s.push("</tr>");
            });

            s.push("</tbody></table>");
            document.getElementById("RESULTSNODE").innerHTML = s.join("");
            showRightPanel("results");
            break;
    }

}

// ----------------------------------------
// Process parcel detail window
// ----------------------------------------
// parcelNum = parcelNumber
// searchGIS = Whether to search for the graphic in the GIS System
// showBack = Whether to show the back button to return to search Results panel.        
function showParcelDetail(parcelNum) {

    var showBack = false;
    var rN = document.getElementById("RESULTSNODE");
    if (rN.hasChildNodes()) showBack = true;

    selectedPIN = parcelNum;

    dojo.xhrGet({
        url: "./Datahandler.ashx?pin=" + parcelNum + "",
        handleAs: "json",
        contentType: "application/json; charset=utf-8",
        load: function(data, arg) {

            if (data.length == 0) {
                $("#DETAILNODE").html("<p>There was no information returned from the database for this parcel number: " + parcelNum + "</p>");
                showRightPanel("details");
                return;
            }

            var s = [];
            s.push("<table cellspacing=\"2\" cellpadding=\"2\" border=\"0\" width=\"100%\">");

            s.push("<tbody>");

            if (showBack == true) {
                s.push("<tr>");
                s.push("<td colspan=\"2\"><a href=\"javascript:showRightPanel('results');map.graphics.clear();\"> Go Back to Results </a></td>");
                s.push("</tr>");
            }

            dojo.forEach(data, function(item, indx) {
                var cssClass = "r2";
                if (indx % 2 == 0)
                    cssClass = "r1";

                s.push("<tr class=\"" + cssClass + "\">");
                s.push("<td width=\"40%\" align=\"left\" valign=\"top\"><b>" + item.FieldName + ":</b>&nbsp;</td>");

                var html = item.FieldValue;
                if (item.linkURL != "") {
                    html = "<a href=\"" + item.linkURL + "\" target=\"_blank\">" + item.FieldValue + "</a>";
                }

                s.push("<td width=\"60%\" align=\"left\" valign=\"top\">" + html + "</td>");
                s.push("</tr>");
            });

            s.push("</tbody></table>");

            var details = document.getElementById("DETAILNODE");
            details.innerHTML = s.join("");
            showRightPanel("details");
        },
        error: function(error, args) { identify_error(error); }
    });
}

function doSearchGIS(parcelNum) {

    parcelNum = dojo.string.pad(parcelNum, 5);

    // find the parcel id using the REST Services
    var queryTask = new esri.tasks.QueryTask(searchURL);
    var query = new esri.tasks.Query();
    query.where = "PARCELNUMBER = '" + parcelNum + "'";
    query.outFields = ["PARCELNUMBER"];
    query.returnGeometry = true;
    queryTask.execute(query, function(results) {

        if (results.features.length == 0) {
            $("#DETAILNODE").html("<p>The GIS System could not find the requested parcel</p>");
            showRightPanel("details");
            return;
        }

        var graphic = results.features[0];
        if (graphic != null) {


            mapHelper.zoomToFeature(graphic.geometry, 2, 1000);
            window.setTimeout(function() {
                map.graphics.clear();
                graphic.setSymbol(mSelectPolygonSymbol);
                map.graphics.add(graphic);
            }, 1000);


        }

    }, function(ex) {
        console.debug(ex);
    });
}

// ----------------------------------------
// Change Map View Drop down button
// ----------------------------------------
function ddlMode_onchange() {

    var key = document.getElementById("ddlMode").value;
    var mapViewState = null;
    
    // find the map view
    dojo.forEach(mapViewStates, function(item) {
        if (item.Key == key)
            mapViewState = item;
    });
    
    // set the visiable layers
    if (mapViewState != null) {
        mapHelper.turnOffMapLayers("map", mapViewState.NotVisibleLayers);
        mapHelper.turnOnMapLayers("map", mapViewState.VisibleLayers);
    }

    refreshTOC();

}


// ----------------------------------------
// Table of Contents
// ----------------------------------------
function refreshTOC() {

    var TOC = document.getElementById("toc");
    if (TOC.style.display == "none")
        return;


    var mapLayer = this.map.getLayer("map");
    console.debug(mapLayer.visibleLayers);

    var scale = dojo.number.round(mapHelper.calculateMapScale(), 0);
    scale = scale * 12;
    var alwaysHide = true;
    var toc = document.getElementById("TOCNODE")
    toc.innerHTML = "";

    var div = dojo.doc.createElement("div");
    var table = document.createElement("table");
    var tbody = document.createElement("tbody");
    table.appendChild(tbody);
    div.appendChild(table);

    // find the layer in tocLayer list
    dojo.forEach(tocLayers, function(lyr) {

        var visible = false;
        visible = lyr.isService ? mapHelper.isServiceVisible(lyr.mapname) : mapHelper.isLayerVisible(lyr.mapname, lyr.layerIds);

        var resultitem = document.createElement("div");
        var legendNode = document.createElement("div");

        if (lyr.legendItems != null) {
            if (lyr.legendItems.length > 0) {
                dojo.forEach(lyr.legendItems, function(li) {
                    var legChild = document.createElement("div");
                    var s = [];

                    s.push("<img src=\"" + li.legendurl + "\" style=\"background-color:" + li.backgroundColor + "\" />");
                    if (li.label != "") s.push("<label>" + li.label + "</label>");

                    legChild.innerHTML = s.join("");
                    legendNode.appendChild(legChild);
                });
            }
        }

        var labelNode = document.createElement("div");
        labelNode.innerHTML = lyr.text;

        labelNode.onclick = function() {
            lyr.showLegend = !lyr.showLegend;
            if (showTransitions) {
                lyr.showLegend ? $(legendNode).slideDown() : $(legendNode).slideUp();
            } else {
                esri.toggle(legendNode);
            }
        }

        resultitem.appendChild(labelNode);
        resultitem.appendChild(legendNode);

        lyr.showLegend ? dojo.style(legendNode, { "display": "block" }) : dojo.style(legendNode, { "display": "none" })

        var tr = document.createElement("tr");
        var td1 = document.createElement("td");
        td1.setAttribute("valign", "top");
        var input = dojo.doc.createElement("input");
        dojo.attr(input, { type: "checkbox" });
        td1.appendChild(input);

        var cmd = function() {
            if (input.checked)
                mapHelper.turnOnMapLayers(lyr.mapname, lyr.layerIds);
            else
                mapHelper.turnOffMapLayers(lyr.mapname, lyr.layerIds);
        };

        if (visible == true)
            dojo.attr(input, { "checked": "checked" });

        var enabled = true;
        if (lyr.minimumScale != "-1" && lyr.minimumScale < scale) {
            enabled = false;
        }

        if (lyr.maximumScale != "-1" && lyr.maximumScale > scale) {
            enabled = false;
        }
        if (enabled == false)
            input.setAttribute("disabled", "true");

        dojo.connect(input, "onclick", cmd);

        td2 = document.createElement("td");
        td2.setAttribute("valign", "top");
        td2.appendChild(resultitem);
        tr.appendChild(td1);
        tr.appendChild(td2);
        
        if (!visible && lyr.hideWhenNotVisible) {
            // then hide the move to the next one.
        } else {
            if (enabled == true)
                tbody.appendChild(tr);
        }

    });

    toc.appendChild(div);

}

function showDialog() {

    var h = $(window).height();
    var h1 = (h / 2);

    $("#terms").load("terms.htm");
    $("#dialog").css({"height": h1 + "px","top": "103px" });
    
    $("#modalBackground").show();
}

function acceptAgreement() {
    $("#modalBackground").hide();
    $("#dialog").hide();
}

function declineAgreement() {
    document.location = "noaccess.htm";
}

// -----------------------------
//  Start up functions
// -----------------------------

dojo.addOnLoad(startup);

$(document).ready(function() {
    showDialog();
});
 

// ------------------------------
//  Map Helper class
// ------------------------------   
dojo.declare("Maphelper", null, {

    map: null,
    fullextent: null,

    mapScaleElement: "mapScale",
    mapPositionElement: "mapPosition",

    //constructor for layer with custom required option: layers, extent
    constructor: function(params) {
        this.map = params.map;
        this.fullextent = params.fullextent;
    },

    createLayer: function(mapServiceInfo) {

        try {

            var layer = null;
            if (mapServiceInfo.type === "tiled") {
                layer = new esri.layers.ArcGISTiledMapServiceLayer(mapServiceInfo.url, {
                    id: mapServiceInfo.label,
                    visible: mapServiceInfo.visible
                });
                return layer;
            }
            else
                if (mapServiceInfo.type === "dynamic") {
                layer = new esri.layers.ArcGISDynamicMapServiceLayer(mapServiceInfo.url, {
                    id: mapServiceInfo.label,
                    opacity: mapServiceInfo.alpha,
                    visible: mapServiceInfo.visible
                });

                if ((mapServiceInfo.layerIDs !== undefined)) {
                    layer.setVisibleLayers(mapServiceInfo.layerIDs);
                }
            }

            return layer;

        }
        catch (err) {
            console.error("Loading map service at url: " + mapServiceInfo.url);
        }

    },

    findLayerByName: function(layername, mapservice) {
        // returns id of the first occurrence of a layer in the map

        var id = -1;
        var gLayer = map.getLayer(mapservice);
        if (gLayer != null) {
            dojo.forEach(gLayer.layerInfos, function(layerinfo) {
                console.debug(layerinfo.name.toUpperCase());
                if (layerinfo.name.toUpperCase() == layername.toUpperCase()) {
                    id = layerinfo.id;
                    return id;
                }
            });
        }
        return id
    },

    findIDsByLayerName: function(layername, layerInfos) {
        var ids = [];
        dojo.forEach(layerInfos, function(layerinfo) {
            if (layerinfo.name.toUpperCase() == layername.toUpperCase()) {
                ids.push(layerinfo.id);
            }
        });
        return ids;
    }, 
    
    getFieldValue: function(graphic, fieldName) {
        // return the value of a named field
        var res = esri.substitute(graphic.attributes, "${" + fieldName + "}");
        return (res);
    }, 

    centerMap: function(graphic) {
        var fExtent = graphic.geometry.getExtent();
        var centerPt = new esri.geometry.Point;
        centerPt = fExtent.getCenter();
        map.centerAt(centerPt);
    },

    calculateMapScale: function() {
        try {
            var extent = this.map.extent;

            var xmin = extent.xmin;
            var ymin = extent.ymin;
            var xmax = extent.xmax;
            var ymax = extent.ymax;

            var dpi = 96;
            var w = this.map.width / dpi;
            var h = this.map.height / dpi;

            var mapH = this.map.extent.getHeight();
            var mapW = this.map.extent.getWidth();

            var distanceOnMap = Math.sqrt((w * w) + (h * h));
            var distanceOnGround = Math.sqrt((mapH * mapH) + (mapW * mapW));
            var scale = distanceOnGround / distanceOnMap;
            return scale;

        } catch (Err) {
            console.debug(Err)
            return -1;
        }
    },

    zoomToScale: function(zoomscale) {
        try {
            zoomscale = parseInt(zoomscale);
            var centerPt = this.map.extent.getCenter();
            var w = map.width;
            var h = map.height;
            var dpi = 96;
            var mapH = this.map.extent.getHeight();
            var mapW = this.map.extent.getWidth();
            var xDist = ((w / dpi) * (zoomscale)) / 2;
            var yDist = ((h / dpi) * (zoomscale)) / 2;

            var xmin, ymin, xmax, ymax;
            xmin = centerPt.x - xDist;
            ymin = centerPt.y - yDist;
            xmax = centerPt.x + xDist;
            ymax = centerPt.y + yDist;
            var nExtent = new esri.geometry.Extent(xmin, ymin, xmax, ymax, this.map.spatialReference);
            this.map.setExtent(nExtent);

        } catch (Error) {
            console.debug(Error);
        }
    },

    disableNavigation: function() {

        this.map.enableScrollWheelZoom();
        this.map.disableShiftDoubleClickZoom();
        this.map.disableRubberBandZoom();
        this.map.disablePan();
        this.map.disableClickRecenter();
        this.map.disableKeyboardNavigation();
        this.map.disableMapNavigation();
        this.map.disableDoubleClickZoom()        
        this.map.showInfoWindowOnClick = false;

    },

    zoomToFeature: function(geometry, expansion, envHeight) {

        try {

            minHeight = envHeight || 1;

            var fExtent = geometry.getExtent().expand(expansion);

            if (fExtent.getHeight() < minHeight) {
                var dx, dy;
                var centerPt = new esri.geometry.Point;
                centerPt = fExtent.getCenter();

                var xmin, ymin, xmax, ymax;
                xmin = centerPt.x - (minHeight / 2);
                ymin = centerPt.y - (minHeight / 2);
                xmax = centerPt.x + (minHeight / 2);
                ymax = centerPt.y + (minHeight / 2);

                var nExtent = new esri.geometry.Extent(xmin, ymin, xmax, ymax, geometry.spatialReference);
                this.map.setExtent(nExtent, true);
            }
            else {
                this.map.setExtent(fExtent, true);
            }
        } catch (Error) {
            console.debug("error occurred in 'zoomToFeaure' function", Error);
        }
    },

    centerAndZoom: function(centerPt, envheight) {

        var xmin, ymin, xmax, ymax;
        xmin = centerPt.x - (envheight / 2);
        ymin = centerPt.y - (envheight / 2);
        xmax = centerPt.x + (envheight / 2);
        ymax = centerPt.y + (envheight / 2);

        var nExtent = new esri.geometry.Extent(xmin, ymin, xmax, ymax, centerPt.spatialReference);
        this.map.setExtent(nExtent, true);

    },


    zoomToFullExtent: function() {
        this.map.setExtent(this.fullextent, true);
    },


    mapServiceExists: function(layer) {
        var l = this.map.getLayer(layer);
        if (l != null) return true;
        else return false;
    },

    turnOffMapService: function(layer) {
        var l = this.map.getLayer(layer);
        if (l != null) {
            l.hide();
        }
    },

    turnOnMapService: function(layer) {
        var l = this.map.getLayer(layer);
        if (l != null) {
            l.show();
        }
    },

    isServiceVisible: function(layer) {
        var l = this.map.getLayer(layer);
        if (l != null) {
            return l.isVisible;
        } else return false;
    },

    isLayerVisible: function(layername, layerIDs) {

        var mapLayer = this.map.getLayer(layername);
        isVisible = mapLayer.visible;
        if (isVisible) {
            if (dojo.indexOf(mapLayer.visibleLayers, layerIDs[0]) >= 0)
                return true;
            else
                return false;
        } else return false;


    },

    turnOnMapLayers: function(layername, layerIDs) {

        var layer = this.map.getLayer(layername);
        if (layer == null)
            return;

        if (!layer.isVisible)
            layer.show();

        var visible = layer.visibleLayers;
        dojo.forEach(layerIDs, function(layerID) {
            var li = layer.layerInfos[layerID]
            if (li != undefined) {
                if (dojo.indexOf(visible, layerID) <0)
                    visible.push(li.id);
                
            }
        });

        visible.sort(function(a, b) { return a - b; });        
        layer.setVisibleLayers(visible);

    },

    turnOffMapLayers: function(layername, layerIDs) {

        var layer = this.map.getLayer(layername);
        if (layer == null)
            return;

        var visible = layer.visibleLayers;
        dojo.forEach(layerIDs, function(layerID) {
            if (dojo.indexOf(visible, layerID) >= 0)
                visible.splice(dojo.indexOf(visible, layerID), 1);
        });

        visible.sort(function(a, b) { return a - b; });
        layer.setVisibleLayers(visible);

    }
});

function isEnter(event) {
    if (window.event)  // IE
        if (window.event.keyCode == 13)
        return true;
    else
        return false;
    else if (event.which) // Netscape/Firefox/Opera
    {
        if (event.which == 13)
            return true;
        else
            return false;
    }

}

// ----------------------------------------
// Measure Task
// ----------------------------------------
dojo.declare("MeasureTask", null, {

    points: null,
    totallength: 0,
    totalAcres: 0,
    totalArea: 0,
    map: null,
    geometryService: null,
    evtHandle: null,
    evtHandleDblClick: null,
    rubberband: null,

    constructor: function(params) {
        this.points = [];
        this.map = params.map;
        this.geometryService = params.geometryService;
        console.debug(this.geometryService);
        this.evtHandle = dojo.connect(map, "onMouseMove", this, "onMouseMove");
        this.evtHandleDblClick = dojo.connect(map, "onDblClick", this, "finishSketch");
    },

    onDestroy: function() {
        dojo.disconnect(this.evtHandle);

    },

    finishSketch: function(e) {

        this.addPoint(e.mapPoint);
        this.updateGraphics();
        this.points = [];

    },

    addPoint: function(pt) {
        this.points.push(pt);
    },


    onMouseMove: function(e) {

        if (this.points.length > 0) {

            var lastPt = this.points[this.points.length - 1];
            var d = this.getDistance(lastPt, e.mapPoint);
            $("#SEGMENTLENGTH").val(dojo.number.round(d, 2));

            var rbSymbol = new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID,
               new dojo.Color([255, 0, 0]), 3)


            var pts = [];
            pts.push(lastPt);
            pts.push(e.mapPoint);

            var polyline = new esri.geometry.Polyline(new esri.SpatialReference({ wkid: 2264 }));
            polyline.addPath(pts);

            if (this.rubberband == null) {
                this.rubberband = new esri.Graphic(polyline, rbSymbol);
                map.graphics.add(this.rubberband);
            } else {
                this.rubberband.setGeometry(polyline);
            }


        }

    },

    updateGraphics: function() {

        this.map.graphics.clear();
        this.rubberband = null;

        if (this.points.length >= 2) {
            var polygon = new esri.geometry.Polygon(new esri.SpatialReference({ wkid: 2264 }));
            polygon.addRing(this.points);

            var sym = new esri.symbol.SimpleFillSymbol(esri.symbol.SimpleFillSymbol.STYLE_SOLID,
                  new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID,
                  new dojo.Color([0, 255, 255]), 3), new dojo.Color([255, 255, 0, 0.50]));
            var graphic = new esri.Graphic(polygon, sym);
            this.map.graphics.add(graphic);
        }

        var marker = new esri.symbol.SimpleMarkerSymbol(esri.symbol.SimpleMarkerSymbol.STYLE_CIRCLE, 8,
               new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID,
               new dojo.Color([255, 0, 0]), 1),
               new dojo.Color([0, 255, 0, 0.25]));

        dojo.forEach(this.points, function(pt, indx) {
            this.map.graphics.add(new esri.Graphic(pt, marker));
        });

    },

    lastSegmentLength: function() {
        if (this.points.length < 2) return 0;

        if (this.points.length > 1) {
            var i = this.points.length - 1;
            return this.getDistance(this.points[i - 1], this.points[i]);
        }
    },

    totalLength: function() {
        var polyline = new esri.geometry.Polyline(new esri.SpatialReference({ wkid: 2264 }));
        polyline.addPath(this.points);

        return this.calculateLength(polyline);
    },

    getDistance: function(p1, p2) {
        return Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
    },

    getDistanceXYXY: function(x1, y1, x2, y2) {
        return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
    },

    calculateLength: function(polyline) {
        var length = [];
        if (polyline && polyline.type && polyline.type == "polyline") {
            for (var i in polyline.paths) {
                var l = 0;

                for (var j = 0; j < polyline.paths[i].length - 1; j++) {
                    var x1 = polyline.paths[i][j][0];
                    var y1 = polyline.paths[i][j][1];
                    var x2 = polyline.paths[i][j + 1][0];
                    var y2 = polyline.paths[i][j + 1][1];
                    var d = this.getDistanceXYXY(x1, y1, x2, y2);
                    l += d;
                }
                length.push(l);
            }
        }
        return length;
    },

    onError: function(ex) {
        console.debug(ex.message);
    },

    calculateArea: function() {

        if (this.points.length > 2) {
            var polygon = new esri.geometry.Polygon(new esri.SpatialReference({ wkid: 2264 }));
            polygon.addRing(this.points);
            var graphic = new esri.Graphic(polygon);

            var measureFunc = dojo.hitch(this, function(results) {
                try {
                    // acres
                    var areaft = Math.abs(results.areas[0]);
                    var acres = areaft / 43560;

                    $("#TOTALAREA").val(dojo.number.round(areaft, 2));
                    $("#TOTALACRES").val(dojo.number.round(acres, 3));

                } catch (Error) {
                    console.warn("An error occurred retrieving measure areas", Error);
                }
            });

            this.geometryService.areasAndLengths([graphic], measureFunc, dojo.hitch(this, "onError"));
        }
    }

});

// ----------------------------------------
// swap images on toolbar
// ----------------------------------------
function swap(name, imgname) {
    var obj = document.getElementById(name);
    if (obj != null) {
        if (name != currentTool)
            obj.src = "images/" + imgname + ".gif";
    }
}


// ----------------------------------------
// Functions dealing with searches
// ----------------------------------------
// not used -- mva 4/13/2010
//function sendPrint() {

//    var printWidth = 370;  //96 * 10;
//    var printHeight = 690;  //96 * 6.625;

//    if (selectedPIN == "")
//        printWidth = printWidth * 2;
//        
//    var mapscale = esri.geometry.getScale(map.extent, map.width, map.spatialReference.wkid);
//    //mapscale = mapscale * 12;
//    var state = {
//        map: getMapState(map),
//        height: printHeight,
//        width: printWidth,
//        scale: mapscale,
//        printExtent: getPrintExtent(map, printWidth, printHeight)
//    };

//    if (checkGraphicExtent(printWidth, printHeight)) {

//        var ovPrintHeight = ovmap.height;
//        var ovPrintWidth = ovmap.width;

//        var ovState = {
//            map: getMapState(ovmap),
//            height: ovPrintHeight,
//            width: ovPrintWidth,            
//            printExtent: getPrintExtent(ovmap, ovPrintWidth, ovPrintHeight)
//        };
//           
//        document.getElementById("appState").value = dojo.toJson(state);
//        document.getElementById("ovState").value = dojo.toJson(ovState);
//        document.getElementById("printdata").value = selectedPIN;
//        document.getElementById("printForm").submit();
//    } else {
//        var idHandle = dojo.connect(map, "onExtentChange", function() {
//            dojo.disconnect(idHandle);
//            sendPrint();
//        });
//        map.centerAndZoom(map.extent.getCenter(), 2);       
//    }
//}

function sendMail() {
    var printWidth = 740;  //96 * 10;
    var printHeight = 690;  //96 * 6.625;
    var mapscale = esri.geometry.getScale(map.extent, map.width, map.spatialReference.wkid);
    var state = {
        map: getMapState(map),
        height: printHeight,
        width: printWidth,
        scale: mapscale,
        printExtent: getPrintExtent(map, printWidth, printHeight)
    };

    if (checkGraphicExtent(printWidth, printHeight)) {
        document.getElementById("mailState").value = dojo.toJson(state);
        document.getElementById("mailData").value = selectedPIN;
        document.getElementById("sendMailForm").submit();
    } else {
        var idHandle = dojo.connect(map, "onExtentChange", function() {
            dojo.disconnect(idHandle);
            sendMail();
        });
        map.centerAndZoom(map.extent.getCenter(), 2);
    }
}

function checkGraphicExtent(printWidth, printHeight) {
    var origGraphic = map.graphics.graphics[0];
    if (origGraphic == null)
        return true;
    else {
        var centerPt = map.extent.getCenter();
        var screenCenter = map.toScreen(centerPt);

        var deltaX = printWidth / 2;
        var deltaY = printHeight / 2;

        var urPt1 = new esri.geometry.Point((screenCenter.x + deltaX), (screenCenter.y + deltaY));
        var ulPt1 = new esri.geometry.Point((screenCenter.x - deltaX), (screenCenter.y + deltaY));
        var llPt1 = new esri.geometry.Point((screenCenter.x - deltaX), (screenCenter.y - deltaY));
        var lrPt1 = new esri.geometry.Point((screenCenter.x + deltaX), (screenCenter.y - deltaY));

        var urPt = map.toMap(urPt1);
        var ulPt = map.toMap(ulPt1);
        var llPt = map.toMap(llPt1);
        var lrPt = map.toMap(lrPt1);

        var points = [];
        points.push(urPt);
        points.push(ulPt);
        points.push(llPt);
        points.push(lrPt);
        points.push(urPt);

        var polygon = new esri.geometry.Polygon(new esri.SpatialReference({ wkid: 2264 }));
        polygon.addRing(points);

        if (origGraphic.geometry.getExtent().getWidth() > polygon.getExtent().getWidth()) { return false; }
        else { return true;}

    }
    
}

function getPrintExtent(m, printWidth, printHeight) {

        var centerPt = m.extent.getCenter();
        var screenCenter = m.toScreen(centerPt);

        var deltaX = printWidth / 2;
        var deltaY = printHeight / 2;

        var urPt1 = new esri.geometry.Point((deltaX + screenCenter.x), (screenCenter.y - deltaY));
        var llPt1 = new esri.geometry.Point((screenCenter.x - deltaX), (screenCenter.y + deltaY));

        var urPt = m.toMap(urPt1);
        var llPt = m.toMap(llPt1);

        var offsetx = llPt1.x;
        var offsety = urPt1.y;

        return { xmin: llPt.x, ymin: llPt.y, xmax: urPt.x, ymax: urPt.y, offsetx: offsetx, offsety: offsety };
}

function getMapState(m) {
    var layerStates = [], graphicsState = [], svgState = [];
    //serialize each layer's state
    dojo.forEach(m.layerIds, function(layerId) {
        var gl = m.getLayer(layerId);
        if (gl.visible)
            layerStates.push(getLayerState(gl));
    });

    // first add the main graphic layer to the map...
    graphics = m.graphics.graphics;
    for (var i = graphics.length - 1; i >= 0; i--) {

        try {
            var g = graphics[i];
            if (g.geometry != null) {
                var svg = esri.geometry.toScreenGeometry(m.extent, m.width, m.height, g.geometry);
                var gclone = new esri.Graphic(svg, g.symbol);
                graphicsState.push(gclone.toJson());
            }
        } catch (Error) {
            console.warn("error serializing graphic...", Error);
        }

    };


    var graphicLayers = m.graphicsLayerIds;
    dojo.forEach(graphicLayers, function(layerId) {
        var gl = m.getLayer(layerId);
        if (gl != null) {
            //serialize graphics from last to first to retain graphics drawing order
            graphics = gl.graphics;
            if (gl.visible) {
                for (var i = graphics.length - 1; i >= 0; i--) {
                    try {
                        var g = graphics[i];
                        if (g.geometry != null) {
                            var svg = esri.geometry.toScreenGeometry(m.extent, m.width, m.height, g.geometry);
                            var gclone = new esri.Graphic(svg, g.symbol);
                            graphicsState.push(gclone.toJson());
                        }
                    } catch (Error) {
                        console.warn("error serializing graphic...", Error);
                    }
                };
            }
        }
    });



    return {
        extent: m.extent.toJson(),
        layers: layerStates,
        graphics: graphicsState
    };
}

function getLayerState(layer) {
    return {
        id: layer.id,
        type: layer.declaredClass,
        url: layer.url,
        visible: layer.visible,
        opacity: layer.opacity,
        layerDefs: layer.layerDefinitions,
        layers: layer.visibleLayers
    };
}

//function getMapScale(m) {
//    var extent = m.extent;
//    var xmin = extent.xmin;
//    var ymin = extent.ymin;
//    var xmax = extent.xmax;
//    var ymax = extent.ymax;

//    var dpi = 96;
//    var w = m.width / dpi;
//    var h = m.height / dpi;

//    var mapH = m.extent.getHeight();
//    var mapW = m.extent.getWidth();

//    var distanceOnMap = Math.sqrt((w * w) + (h * h));
//    var distanceOnGround = Math.sqrt((mapH * mapH) + (mapW * mapW));
//    var scale = distanceOnGround / distanceOnMap;
//    return scale.toFixed(0);
//}