/*
 * Copyright (C) 2009 GeoNetwork
 *
 * This file is part of GeoNetwork
 *
 * GeoNetwork is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GeoNetwork is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GeoNetwork.  If not, see <http://www.gnu.org/licenses/>.
 */
Ext.namespace('GeoNetwork');

// global map object
var map;

var mapInit = false;

// print config url
var printConfigUrl = mapfish.SERVER_BASE_URL + 'pdf/info.json';

// see http://trac.openlayers.org/ticket/2478
// remove when this is properly fixed in OpenLayers
OpenLayers.Layer.WMS.prototype.getFullRequestString = function(newParams, altUrl) {
    var projectionCode = this.map.getProjection();
    var value = (projectionCode == "none") ? null : projectionCode
    if (parseFloat(this.params.VERSION) >= 1.3) {
        this.params.CRS = value;
        // the default value for exceptions is not valid for WMS 1.3.0 
        if (this.params.EXCEPTIONS === this.DEFAULT_PARAMS.exceptions) { 
            this.params.EXCEPTIONS = 'INIMAGE';     
        } 
    } else {
        this.params.SRS = value;
    }
    return OpenLayers.Layer.Grid.prototype.getFullRequestString.apply(this, arguments);
};

// create application
GeoNetwork.app = function() {
    // private vars:
    var toolbar, toctoolbar, tocbbar, viewport;

    var featureinfo;

    var westPanelWidth = 260;


    var activeNode;

    // private functions
    var createDummyBaseLayer = function() {
        var graphic = new OpenLayers.Layer.Image('Dummy', '../../scripts/openlayers/img/blank.gif', new OpenLayers.Bounds(0, 300000, 300000, 625000),
                map.getSize(), {isBaseLayer: true, displayInLayerSwitcher: false});
        map.addLayer(graphic);
    };

    var createMap = function() {
        var options = {
            projection: "EPSG:28992",
            units: 'm',
            maxExtent: new OpenLayers.Bounds(-285401.92,22598.08,595401.92,903401.92),
            resolutions: new Array(3440.64,1720.32,860.16,430.08,215.04,107.52,53.76,26.88,13.44,6.72,3.36,1.68,0.84),
            controls: []
        };
        map = new OpenLayers.Map('ol_map', options);
    };

    var createWmsLayer = function(name, url, params, options) {
        map.addLayer(new OpenLayers.Layer.WMS(name, url, params, options));
    };

    var addMapControls = function() {
        map.addControl(new GeoNetwork.Control.ZoomWheel());
        map.addControl(new GeoNetwork.Control.CursorPos({xelement: Ext.get('mousex-field'), yelement: Ext.get('mousey-field')}));
        map.addControl(new OpenLayers.Control.LoadingPanel());
        map.addControl(new OpenLayers.Control.ScaleBar());
    };

    var createToolbars = function() {
        toolbar = new mapfish.widgets.toolbar.Toolbar({
            map: map,
            configurable: false,
            items: [new Geonetwork.print.PrintAction({
                map: map,
                text: "",
                tooltip: {title: OpenLayers.i18n("printTooltipTitle"), text: OpenLayers.i18n("printTooltipText")},
                iconCls: 'print',
                configUrl: printConfigUrl,
                fillSpec: function(printCommand) {
                    Geonetwork.print.PrintAction.prototype.fillSpec.call(this, printCommand);
                    printCommand.spec.rotation = 0;

                    //our layout needs two fields... hard code them here
                    //printCommand.spec.comment = "No comment";
                    //printCommand.spec.mapTitle = "PrintControl";
                }
            })]
        });

        // this is a quick fix for http://trac.mapfish.org/trac/mapfish/ticket/126
        toolbar.autoHeight = false;
        toolbar.height = 25;

        toctoolbar = new mapfish.widgets.toolbar.Toolbar({
            map: map
        });
        toctoolbar.autoHeight = false;
        toctoolbar.height = 25;

        tocbbar = new mapfish.widgets.toolbar.Toolbar({
            map: map
        });
        tocbbar.autoHeight = false;
        tocbbar.height = 25;

    };

    var addSeparator = function() {
        toolbar.add(new Ext.Toolbar.Spacer());
        toolbar.add(new Ext.Toolbar.Separator());
        toolbar.add(new Ext.Toolbar.Spacer());
    };

    var treeConfig  = new OpenLayers.Format.JSON().write([{
        text: OpenLayers.i18n("baseLayerList"),
        expanded: true,
        nodeType: "gx_baselayercontainer",
        defaults: {
            radioGroup: "foo"
        }
    },
    {
        nodeType: "gx_overlaylayercontainer",
        expanded: true,
        text: OpenLayers.i18n("layerList"),
        // render the nodes inside this container with a radio button,
        // and assign them the group "foo"
        defaults: {
            radioGroup: "foo"
        }
    }], true);

    // the layer node's radio button with its radiochange event can be used
    // to set an active layer.
    var registerRadio = function(node){
        if(!node.hasListener("radiochange")) {
            node.on("radiochange", function(node){
            activeNode = node;
        });
        }
    };


     var addRadioNodesListeners= function(node){
        if (node.hasChildNodes()) {
            for(var i = 0; i < node.childNodes.length; i++) {
                var nodeAux = node.childNodes[i];
                addRadioNodesListeners(nodeAux);
            }

        }  else {
            registerRadio(node);
        }
    };


    var removeLayerHandlerToolbar = function(){
        removeLayerHandler(activeNode);
    };

    var removeLayerHandlerContextMenu = function(){
        var node = Ext.getCmp('toctree').getSelectionModel().getSelectedNode();

        removeLayerHandler(node);
    };


    var removeLayerHandler = function(node) {
        if (node) {
            var layer;
                layer = node.attributes.layer;
                if (layer) {
                    if (!layer.isBaseLayer) {
                        if ((typeof(layer.isLoading) == "undefined") ||  // Layers added from WMC
                            (layer.isLoading == false)) {
                            map.removeLayer(layer);
                            //Ext.getCmp('legendwms').forceRemoveLegend(node.attributes.layer.id);

                            if (activeNode == node) activeNode = null;
                            refreshTocToolbar(activeNode);
                            Ext.getCmp('toctree').getSelectionModel().clearSelections();
                       }
                    }
                }
            }
    };

    var opacityLayerHandlerToolbar = function() {
        opacityLayerHandler(activeNode);
    };

    var opacityLayerHandlerContextMenu = function() {
        var node = Ext.getCmp('toctree').getSelectionModel().getSelectedNode();

        opacityLayerHandler(node);
    };

    var opacityLayerHandler = function(node) {
        if (node) {
            var layer;

            // TODO: if layer selection changes, update the layer attached to the slider
            layer = node.attributes.layer;

            if (layer) {
                GeoNetwork.WindowManager.showWindow("opacity");
                GeoNetwork.WindowManager.getWindow("opacity").setLayer(layer);
            }
        }
    };

    var  metadataLayerHandlerToolbar = function() {
        metadataLayerHandler(activeNode);
    };

    var metadataLayerHandlerContextMenu = function() {
        var node = Ext.getCmp('toctree').getSelectionModel().getSelectedNode();

        metadataLayerHandler(node);
    };

    var metadataLayerHandler = function(node) {
        if (node) {
            var layer;

            layer = node.attributes.layer;
            if (layer) {
                // if layer is related to metadata record show it
                if (typeof(layer.metadata_id) != "undefined") {
                    hideMap();
                    selectTabMenu("zoeken-tab-tekst");
                    $('single-search-result').hide();
                    gn_showSingleResult(layer.metadata_id);

                    // else show capabilities for layer
                } else {
                    GeoNetwork.WindowManager.showWindow("wmsinfo");
                    GeoNetwork.WindowManager.getWindow("wmsinfo").showLayerInfo(layer);
                }
            }
        }
    };

    var refreshTocToolbar = function(node) {

        if ((node) && (node.attributes.layer)) {
            if (node.parentNode.attributes.nodeType == "gx_baselayercontainer") {
                Ext.getCmp("tbRemoveButton").disable();
            } else {
                Ext.getCmp("tbRemoveButton").enable();
            }

            var layer = node.attributes.layer;

            if (layer && layer.dimensions && layer.dimensions.time) {
                 Ext.getCmp("tbWmsTimeButton").enable();
            } else {
                Ext.getCmp("tbWmsTimeButton").disable();
            }

            if ((layer) && ((!layer.styles) || (layer.styles.length < 2))) {
                Ext.getCmp("tbStylesButton").disable();
            } else {
                Ext.getCmp("tbStylesButton").enable();
            }

            Ext.getCmp("tbOpacityButton").enable();
            Ext.getCmp("tbMetadataButton").enable();
            Ext.getCmp("btnZoomToExtent").enable();



        } else {
            Ext.getCmp("tbRemoveButton").disable();
            Ext.getCmp("tbWmsTimeButton").disable();
            Ext.getCmp("tbStylesButton").disable();
            Ext.getCmp("tbOpacityButton").disable();
            Ext.getCmp("tbMetadataButton").disable();
            Ext.getCmp("btnZoomToExtent").disable();
        }
    };

    var wmsTimeHandlerToolbar = function() {
       wmsTimeHandler(activeNode);
    };

    var wmsTimeHandlerContextMenu = function() {
       var node = Ext.getCmp('toctree').getSelectionModel().getSelectedNode();

       wmsTimeHandler(node);
    };

    var wmsTimeHandler = function(node) {
        if (node) {
            var layer;

            layer = node.attributes.layer;
            if (layer && layer.dimensions && layer.dimensions.time) {
               GeoNetwork.WindowManager.showWindow("wmstime");
               GeoNetwork.WindowManager.getWindow("wmstime").setLayer(layer);
            }
        }
    };

     var stylesLayerHandlerToolbar = function() {
       stylesLayerHandler(activeNode);
    };

    var stylesLayerHandlerContextMenu = function() {
       var node = Ext.getCmp('toctree').getSelectionModel().getSelectedNode();

       stylesLayerHandler(node);
    };

    var stylesLayerHandler = function(node) {
        if (node) {
            var layer;

            layer = node.attributes.layer;
            if ((layer) && (layer.styles) && (layer.styles.size > 1)) {
                GeoNetwork.WindowManager.showWindow("layerstyles");
                GeoNetwork.WindowManager.getWindow("layerstyles").showLayerStyles(layer);
            }
        }
    };

    var createViewport = function() {
        viewport = new Ext.Panel({
            renderTo: 'map_container',
            layout: 'border',
            plugins: [new Ext.ux.plugins.FitToParent("map_container")],
            items: [
                {
                    region: 'west',
                    title: '',
                    id: 'west_panel',
                    width: westPanelWidth,
                    //border: true,
                    margins: '0 0 0 0',
                    frame: false,
                    //split: true,
                    layout: 'fit',
                    //collapsible: true,
                    items: [
                        {xtype: 'panel', layout: 'accordion', autoWidth:false, deferredRender:false, items: [
                            {xtype: 'treepanel', id: 'toctree',
                                /*selModel: new Ext.tree.MultiSelectionModel(),*/ autoScroll: true, bbar: tocbbar, tbar: toctoolbar, title: OpenLayers.i18n('layerManagerTabTitle'), rootVisible: false, enableDD: true,
                                loader: new Ext.tree.TreeLoader({clearOnLoad: true}), root: {nodeType: "async", children: Ext.decode(treeConfig) },
                                listeners:{
	                                contextmenu:function(node,e){
                                        if ((node.attributes.nodeType != "gx_overlaylayercontainer") &&
                                             (node.attributes.nodeType != "gx_baselayercontainer"))
                                        {
                                            node.select();
                                            var c=node.getOwnerTree().contextMenu;
                                            if (node.parentNode.attributes.nodeType == "gx_baselayercontainer") {
                                                c.items.get("removeMenu").disable();
                                            } else {
                                                c.items.get("removeMenu").enable();
                                            }

                                            var layer = node.attributes.layer;

                                            if (layer && layer.dimensions && layer.dimensions.time) {
                                                c.items.get("wmsTimeMenu").enable();
                                            } else {
                                                c.items.get("wmsTimeMenu").disable();
                                            }

                                            if ((layer) && ((!layer.styles) || (layer.styles.length < 2))) {
                                                c.items.get("stylesMenu").disable();
                                            } else {
                                                c.items.get("stylesMenu").enable();
                                            }

                                            c.contextNode=node;
                                            c.showAt(e.getXY());
                                        }
	                            },scope:this},

	                            contextMenu:new Ext.menu.Menu({
                                    items:[{
                                        text:OpenLayers.i18n("removeButtonText"),
                                        id: "removeMenu",
                                        handler: removeLayerHandlerContextMenu
                                    },
                                    {
                                        text: OpenLayers.i18n("opacityButtonText"),
                                        id: "opacityMenu",
                                        handler: opacityLayerHandlerContextMenu
                                    },

                                    {
                                        text: OpenLayers.i18n("metadataButtonText"),
                                        id: "metadataMenu",
                                        handler: metadataLayerHandlerContextMenu
                                    },
                                    {
                                        text: OpenLayers.i18n('WMSTimeWindowTitle'),
                                        id: "wmsTimeMenu",
                                        disabled: true,
                                        handler: wmsTimeHandlerContextMenu
                                    },

                                    {
                                        text: "Styles",
                                        id: "stylesMenu",
                                        handler: stylesLayerHandlerContextMenu
                                    }

                                    ]})
                            },
                            {title: OpenLayers.i18n('legendTabTitle'),  id: 'legendwms', autoScroll: true, xtype: 'gn_legendpanel', bodyStyle: 'padding:5px', ascending: false},
                            {
                                xtype: 'print-simple',
                                title: OpenLayers.i18n("mf.print.print"),
                                bodyStyle: 'padding: 7px;',
                                formConfig: {
                                    labelWidth: 65,
                                    defaults: {
                                        width: 140,
                                        listWidth: 140
                                    }/*,
                                     items: [
                                     {
                                     xtype: 'textfield',
                                     fieldLabel:  OpenLayers.i18n("mf.print.mapTitle"),
                                     name: 'mapTitle',
                                     value: 'Map title'
                                     },
                                     {
                                     xtype: 'textarea',
                                     fieldLabel:  OpenLayers.i18n("mf.print.comment"),
                                     name: 'comment',
                                     height: 100,
                                     value: 'Some comments'
                                     }
                                     ] */
                                },
                                border: false,
                                map: map,
                                configUrl: printConfigUrl
                            }
                        ]
                        }]
                }
                ,{
                    region: 'center',
                    layout: 'fit',
                    frame: false,
                    border: true,
                    margins: '0 0 0 0',
                    items: [{
                        id: 'mappanel',
                        xtype: 'gx_mappanel',
                        map: map,
                        tbar: toolbar,
                        border: false,
                        center: [155000, 463000],
                        zoom: 2
                    }]
                },{
                    region: 'south',
                    id: 'statusBar',
                    border: false,
                    height: 25,
                    margins: '5 0 0 0',
                    xtype: 'panel',
                    layout: 'column',
                    items: [
                        {border: false, layout: 'form', columnWidth: .25, items: [{xtype: 'field', hideLabel: true, hidden: true}]},
                        /*{border: false, layout: 'form', labelWidth: 80, columnWidth: 0.3, items: [{xtype: 'gn_projectionselector', projections: GeoNetwork.ProjectionList, fieldLabel: OpenLayers.i18n("projectionTitle"), map: map}]},*/
                        {border: false, layout: 'form', labelWidth: 25, columnWidth:.2, items:
                                [{xtype: 'textfield', fieldLabel: OpenLayers.i18n('xTitle'), name: 'mousex-field', id: 'mousex-field',
                                    enableKeyEvents: true,
                                    listeners: {'keydown': function(field, event)
                                    {
                                        // We let copy text
                                        if (!(event.getKey() == 67 && event.ctrlKey)){
                                            event.stopEvent();
                                        }
                                    }
                         }}]},
                        {border: false, layout: 'form', labelWidth: 25, columnWidth:.2, items:
                                [{xtype: 'textfield', fieldLabel: OpenLayers.i18n('yTitle'), name: 'mousey-field', id: 'mousey-field',
                                    enableKeyEvents: true,
                                    listeners: {'keydown': function(field, event)
                                    {
                                        // We let copy text
                                        if (!(event.getKey() == 67 && event.ctrlKey)){
                                            event.stopEvent();
                                        }
                                    }
                        }}]},
                        {border: false, layout: 'form', labelWidth: 50, columnWidth:.2, items: [{xtype: 'gn_scalefield', map: map, fieldLabel: OpenLayers.i18n('scaleTitle'), name: 'scale', id: 'scale'}]},
                        {border: false, html: OpenLayers.i18n('copyrightMap')}
                    ]
                }
            ]
        });
    };

    var setToolbarContent = function() {

        tocbbar.add({text: OpenLayers.i18n("addWMSButtonText"), handler: function() {
                GeoNetwork.WindowManager.showWindow("addwms");
            }
        });

        toctoolbar.add({id: "tbRemoveButton", text: OpenLayers.i18n("removeButtonText"), handler: removeLayerHandlerToolbar});

        toctoolbar.add({id: "tbOpacityButton", text: OpenLayers.i18n("opacityButtonText"), handler: opacityLayerHandlerToolbar});

        toctoolbar.add({id: "tbMetadataButton", text: OpenLayers.i18n("metadataButtonText"), handler: metadataLayerHandlerToolbar});

        toctoolbar.add({id: "tbStylesButton", text: "Styles", handler: stylesLayerHandlerToolbar});

        toctoolbar.add({id: "tbWmsTimeButton", text: "WMS Time", handler: wmsTimeHandlerToolbar



        });

        addSeparator();

        toolbar.addControl(
                new OpenLayers.Control.ZoomToMaxExtent({
                    map: map
                }), {
            tooltip: {title: OpenLayers.i18n("zoomToMaxExtentTooltipTitle"), text: OpenLayers.i18n("zoomToMaxExtentTooltipText")},
            iconCls: 'zoomfull',
            toggleGroup: 'map'
        }
                );

         var buttonZoomToExtent = new Ext.Toolbar.Button({
            iconCls: 'zoomlayer',
            id: 'btnZoomToExtent',
            tooltip: {title: OpenLayers.i18n("zoomlayerTooltipTitle"), text: OpenLayers.i18n("zoomlayerTooltipText")},
            handler: function() {
                var node = activeNode;
                var layer;

                if (node) {
                    layer = node.attributes.layer;
                    if (layer) {
                        if (layer.llbbox) {
                            // store info as wgs84
                            var mapProj = map.getProjectionObject();
                            var wgs84 = new OpenLayers.Projection("WGS84");

                            var minMapxy = new OpenLayers.LonLat(layer.llbbox[0], layer.llbbox[1]).transform(wgs84, mapProj);
                            var maxMapxy = new OpenLayers.LonLat(layer.llbbox[2], layer.llbbox[3]).transform(wgs84, mapProj);

                            var extent = new OpenLayers.Bounds();
                            extent.left = minMapxy.lon;
                            extent.right = maxMapxy.lon;
                            extent.top = maxMapxy.lat;
			                extent.bottom = minMapxy.lat;

                            map.zoomToExtent(extent);

                        // If layer has no boundingbox info, use full extent
                        } else {
                            map.zoomToMaxExtent();
                        }
                    } else {
                        Ext.MessageBox.alert(OpenLayers.i18n("zoomlayer.selectLayerTitle"),
                            OpenLayers.i18n("zoomlayer.selectLayerText"));
                    }
                } else {
                     Ext.MessageBox.alert(OpenLayers.i18n("zoomlayer.selectLayerTitle"),
                            OpenLayers.i18n("zoomlayer.selectLayerText"));
                }

            }
        });

        toolbar.add(buttonZoomToExtent);

        addSeparator();

        toolbar.addControl(
                new OpenLayers.Control.ZoomBox(), {
            tooltip: {title: OpenLayers.i18n("zoominTooltipTitle"), text: OpenLayers.i18n("zoominTooltipText")},
            iconCls: 'zoomin',
            toggleGroup: 'map'
        }
                );

        toolbar.addControl(
                new OpenLayers.Control.ZoomBox({
                    displayClass: 'ZoomOut',
                    out: true
                }), {
            tooltip: {title: OpenLayers.i18n("zoomoutTooltipTitle"), text: OpenLayers.i18n("zoomoutTooltipText")},
            iconCls: 'zoomout',
            toggleGroup: 'map'
        }
                );

        toolbar.addControl(
                new OpenLayers.Control.DragPan({
                    isDefault: true
                }), {
            tooltip: {title: OpenLayers.i18n("dragTooltipTitle"), text: OpenLayers.i18n("dragTooltipText")},
            iconCls: 'pan',
            toggleGroup: 'map'
        }
                );

        featureinfo = new OpenLayers.Control.WMSGetFeatureInfo({drillDown: true, infoFormat: 'application/vnd.ogc.gml'});

        var moveLayerToTop = function(layertomove) {
            var idx = -1;
            for (var i=0, len = map.layers.length; i<len; i++) {
                var layer = map.layers[i];
                if (layer != layertomove) {
                    idx = Math.max(map.getLayerIndex(
                        map.layers[i]), idx);
                }
            }
            if (map.getLayerIndex(layertomove) < idx) {
                map.setLayerIndex(layertomove, idx+1);
            }
        };

        var featureinfolayer = new OpenLayers.Layer.Vector("Feature info", {displayInLayerSwitcher: false,
            styleMap: new OpenLayers.StyleMap({
                externalGraphic: OpenLayers.Util.getImagesLocation() + "marker.png",
                pointRadius: 12
            })
        });
        map.addLayer(featureinfolayer);

        featureinfo.events.on({'getfeatureinfo': function(evt) {
            var lonlat = map.getLonLatFromViewPortPx(evt.xy);
            var point = new OpenLayers.Geometry.Point(lonlat.lon, lonlat.lat);
            featureinfolayer.destroyFeatures();
            featureinfolayer.addFeatures(new OpenLayers.Feature.Vector(point));
            moveLayerToTop(featureinfolayer);
                GeoNetwork.WindowManager.showWindow("featureinfo");
            GeoNetwork.WindowManager.getWindow("featureinfo").setMap(map);
            GeoNetwork.WindowManager.getWindow("featureinfo").setFeatures(evt.features);
        }, 'deactivate': function() { featureinfolayer.destroyFeatures();
        }});

        addSeparator();

        toolbar.addControl(featureinfo,
        {toggleGroup: 'map', iconCls: 'query',
            tooltip: {title: OpenLayers.i18n('featureInfoTooltipTitle'), text: OpenLayers.i18n('featureInfoTooltipText') } });

        addSeparator();

        var nav = new OpenLayers.Control.NavigationHistory();
        map.addControl(nav);
        nav.activate();

        var buttonPrevious = new Ext.Toolbar.Button({
            iconCls: 'back',
            tooltip: {title: OpenLayers.i18n("previousTooltipTitle"), text: OpenLayers.i18n("previosTooltipText")},
            disabled: true,
            handler: nav.previous.trigger
        });

        var buttonNext = new Ext.Toolbar.Button({
            iconCls: 'next',
            tooltip: {title: OpenLayers.i18n("nextTooltipTitle"), text: OpenLayers.i18n("nextTooltipText")},
            disabled: true,
            handler: nav.next.trigger
        });

        toolbar.add(buttonPrevious);
        toolbar.add(buttonNext);

        nav.previous.events.register(
                "activate",
                buttonPrevious,
                function() {
                    this.setDisabled(false);
                }
                );

        nav.previous.events.register(
                "deactivate",
                buttonPrevious,
                function() {
                    this.setDisabled(true);
                }
                );

        nav.next.events.register(
                "activate",
                buttonNext,
                function() {
                    this.setDisabled(false);
                }
                );

        nav.next.events.register(
                "deactivate",
                buttonNext,
                function() {
                    this.setDisabled(true);
                }
                );

        addSeparator();

        var buttonSaveWMC = new Ext.Toolbar.Button({
            iconCls: 'savewmc',
            tooltip: {title: OpenLayers.i18n("savewmcTooltipTitle"), text: OpenLayers.i18n("savewmcTooltipText")},
            handler: function() {
                GeoNetwork.WMCManager.saveContext(map);
            }
        });

        toolbar.add(buttonSaveWMC);


        var buttonLoadWMC = new Ext.Toolbar.Button({
            iconCls: 'loadwmc',
            tooltip: {title: OpenLayers.i18n("loadwmcTooltipTitle"), text: OpenLayers.i18n("loadwmcTooltipText")},
            handler: function() {
                GeoNetwork.WindowManager.showWindow("loadwmc");
            }
        });

        toolbar.add(buttonLoadWMC);

        addSeparator();

        var buttonResults = new Ext.Toolbar.Button({
            cls: 'toolbar-text-button',
            text: OpenLayers.i18n("metadataResults.buttonText"),
            tooltip: {title: OpenLayers.i18n("metadataResults.tooltipTitle"), text: OpenLayers.i18n("metadataResults.tooltipText")},
            handler: function() {
                var origin = $("origin").innerHTML;
                var originmetadata = $("originmetadata").innerHTML;

                if (originmetadata.indexOf("|") > -1) {
                    hideMap();
                    selectTabMenu("zoeken-tab-tekst");
                    var id = originmetadata.split("|")[1];
                    gn_showSingleResult(id);
                } else {

                    if (origin == 'searchresults') {
                        hideMap();
                        selectTabMenu("zoeken-tab-tekst");
                        gn_present(document.getElementById('results-from').innerHTML, document.getElementById('results-to').innerHTML);
                    } else {
                        Ext.MessageBox.alert(OpenLayers.i18n("metadataResults.alertTitle"),
                            OpenLayers.i18n("metadataResults.alertText"));

                    }
                }
            }
        });

        toolbar.add(buttonResults);

	/*
	Thijs Brentjens, PDOK: Temporarily don't use the geocoder button, see issue 603	
	*/
	
        addSeparator();


        var buttonGazetteer = new Ext.Toolbar.Button({
            text: OpenLayers.i18n("GazetteerWindowTitle"),
            tooltip: {title: OpenLayers.i18n("gazetteerTooltipTitle"), text: OpenLayers.i18n("gazetteerTooltipText")},
            handler: function() {
                GeoNetwork.WindowManager.showWindow("gazetteer");
            }
        });

        toolbar.add(buttonGazetteer);
	
    }

    // public space:
    return {
        init: function() {
            createMap();
            //createDummyBaseLayer();

           // 2011-02-04: Thijs Brentjens, PDOK. Use the PDOK BRT Achtergrondkaart
           createWmsLayer('BRT Achtergrondkaart',
                'http://geodata.nationaalgeoregister.nl/wmsc?',
                {'layers': 'brtachtergrondkaart', 'format': 'image/png'},
                {'isBaseLayer': true, 'buffer':1,'opacity' : 0.5}
           );

           // 2011-02-18: Thijs Brentjens, PDOK. Use the NLT ASTER Layer as 2nd background
           createWmsLayer('NLR Nederland Aster mosaic',
                'http://gdsc.nlr.nl/wms/aster_all?',
                {'layers': 'aster_all', 'format': 'image/jpeg'},
                {'isBaseLayer': true, 'buffer':1, visibility: false}
           );

           /* createWmsLayer('Landsat5',
                'http://geoserver.nl/tiles/tilecache.aspx?',
                {'layers': 'nllandsat5_xl', 'format': 'image/png', 'userid': userid},
                {'isBaseLayer': true, 'buffer':1}
           ); */

           /* createWmsLayer('Plaatsen',
                'http://geoserver.nl/tiles/tilecache.aspx?',
                {'layers': 'nlreferentietransparant_xl', 'format': 'image/png', 'userid': userid},
                {'isBaseLayer': false, 'buffer':1, visibility: false}
           ); */

            // Fix for the toctree to get the correct mappanel (i
            GeoExt.MapPanel.guess = function() {
                return Ext.getCmp('mappanel');
            };
            
            createToolbars();
            setToolbarContent();
            createViewport();


            Ext.getCmp("toctree").on({
                "insert": registerRadio,
                "append": registerRadio,
                "click": function(node) {
                    if (node.ui.radio) {
                        node.ui.radio.checked = true;
                        node.ui.fireEvent("radiochange", node);

                    }

                    refreshTocToolbar(node);

                },
                scope: this
            });


            var rootNode = Ext.getCmp("toctree").getRootNode();
            addRadioNodesListeners(rootNode);


            addMapControls();

            toolbar.activate();

            refreshTocToolbar(activeNode);

            Ext.getCmp("toctree").on("nodedragover", function(evt) {
                // Only allow to move layers in the gx_overlaylayercontainer (user layers)
                if ((evt.dropNode.parentNode.attributes.nodeType == "gx_baselayercontainer") ||  // restrict move baselayers
                    (evt.target.attributes.nodeType == "gx_baselayercontainer") ||               // restrict move layers to baselayer container
                    (evt.target.parentNode.attributes.nodeType == "gx_baselayercontainer") ||
                    (evt.target.parentNode == evt.tree.root))  {                                 // restrict move layers to outside of layercontainers
                     evt.cancel=true;
                }
            });

            GeoNetwork.WindowManager.registerWindow("loadwmc", GeoNetwork.LoadWmcWindow, {map: map, id:"loadwmc"});
            GeoNetwork.WindowManager.registerWindow("addwms", GeoNetwork.AddWmsLayerWindow, {map: map, id:"addwms"});
            GeoNetwork.WindowManager.registerWindow("opacity", GeoNetwork.OpacityWindow, {map: map, id:"opacity", selMode:  Ext.getCmp('toctree').getSelectionModel()});
            GeoNetwork.WindowManager.registerWindow("wmsinfo", GeoNetwork.WmsLayerMetadataWindow, {map: map, id:"wmsinfo"});
            GeoNetwork.WindowManager.registerWindow("featureinfo", GeoNetwork.FeatureInfoWindow, {map: map, id:"featureinfo", control: featureinfo});
            GeoNetwork.WindowManager.registerWindow("gazetteer", GeoNetwork.GazetteerWindow, {map: map, id:"gazetteer"});
            GeoNetwork.WindowManager.registerWindow("layerstyles", GeoNetwork.LayerStylesWindow, {map: map, id:"layerstyles"});
            GeoNetwork.WindowManager.registerWindow("wmstime", GeoNetwork.WMSTimeWindow, {map: map, id:"wmstime"});


        },

        /**
         * Add a list of WMS layers to the map
         *
         * @param layers    List of layers to load
         *                  [[name, url, layer, metadata_id], [name, url, layer, metadata_id], ....]
         */
        addWMSLayer:  function(layers) {
            GeoNetwork.CatalogueInterface.addLayers(layers);
        },
        
        /**
         * Method: addSOSLayer
         * Adds a vector layer displaying the locations of a Sensor Observation Service
         *
         * Parameters:
         * url - {String} The online resource of the SOS service
         * metadata_id - {String} The metadata identifier
         */
        addSOSLayer: function(url, metadata_id) {
            var sos = new OpenLayers.SOSClient({map: map, url: url, metadata_id: metadata_id});
        },

        refreshViewport: function() {
            // IE shows the west panel hidden when the map is shown after a window resize
            Ext.get("west_panel").setWidth(westPanelWidth);

            viewport.doLayout();
        }
    };
}(); // end of app

Ext.namespace('Ext.ux.plugins');
Ext.ux.plugins.FitToParent = Ext.extend(Object, {
    constructor: function(parent) {
        this.parent = parent;
    },
    init: function(c) {
        c.on('render', function(c) {
            c.fitToElement = Ext.get(this.parent ||
                                     c.getDomPositionEl().dom.parentNode);
            if (!c.doLayout) {
                this.fitSizeToParent();
                Ext.EventManager.onWindowResize(this.fitSizeToParent, this);
            }
        }, this, {single: true});
        if (c.doLayout) {
            c.monitorResize = true;
            c.doLayout = c.doLayout.createInterceptor(this.fitSizeToParent);
        }
    },
    fitSizeToParent: function() {
        var pos = this.getPosition(true), size =
                this.fitToElement.getViewSize();

        //this.setSize(size.width - pos[0], size.height - pos[1]);
        this.setSize(Ext.get("header").getViewSize().width, Ext.get("geonovum-body").getViewSize().height - pos[1] - Ext.get("header").getViewSize().height);
    }
});