root/branches/landgate/Vespucci/Application.js @ 798

Vespucci.Application = OpenLayers.Class({

    /** 
     * API Method.
     * Initialize the map.  
     */
    initialize: function(configuration) {
        this.configuration = configuration;
    },
    
    map: null,
    configuration: null, 
    
    wfsLayer: null,

    panZoomBar: null,
    navigationControl: null,
    selectControl: null,
        moveControl: {},
        drawControl: {},
    permalinkControl: null,
    selectionArgParser: null, 
    
    editingToolbar: null,
    
    sidebar: null,
    topbar: null,
    loginScreen: null,
    loginHandler: null,
    
    requestQueue: null,
    
    isEditing: false,
    
    // Specify template div ids. During template loading,
    // these strings will be replaced with actual Vespucci Templates.
    templates: {
        notesPopupEditTemplate: "notes-popup-edit-template",                                          
        notesPopupViewTemplate: "notes-popup-view-template",
        notesPopupMoveTemplate: "notes-popup-move-template",
        notesPopupPermalinkTemplate: "notes-popup-permalink-template",
        sidebarCommentsTemplate: "sidebar-comments-template",
        sidebarFeatureHistoryTemplate: "sidebar-feature-history-template",
        sidebarFeatureDiffTemplate: "sidebar-feature-diff-template",
        sidebarHistoryFeedTemplate: "sidebar-historyfeed-template",
        sidebarHistoryTemplate: "sidebar-history-template",
        sidebarHelpTemplate: "sidebar-help-template",
        sidebarLoadingTemplate: "sidebar-loading-template",
        topbarTemplate: "topbar-template",
        loginScreenTemplate: "login-screen-template",
                sidebarAddNoteTemplate: "sidebar-add-notes-template"
    },        
   
    /** 
     * API Method.
     * Initialize the map, and all its pieces.
     */
    load: function() {
        
        // Set OpenLayers specific data.
        OpenLayers.ProxyHost = this.configuration.proxy;
        OpenLayers.ImgPath = Vespucci.ImgPath;
        OpenLayers.IMAGE_RELOAD_ATTEMPTS = this.configuration.imageReloadAttempts;
        OpenLayers.Popup.POPUP_MARGIN = this.configuration.popupMargins;
        
        // Set the class name of the map div so all items within the map
        // get Vespucci specific CSS styles.
        var map = document.getElementById(this.configuration.mapDivId);
        map.className = this.configuration.mainVespucciCSSClass + " " + map.className;        
        
        this.loadImages();
        this.loadRequestQueue();
        this.loadTemplates();
        this.loadMap();
        this.loadLayers();
        this.loadLoginHandler();
        
        if (this.configuration.defaultZoomLevel) {
            this.map.zoomTo(this.configuration.defaultZoomLevel);
        } else {
            this.map.zoomToMaxExtent();
        }
        
        var application = this;
        
        var finishLoading = function() {
            application.loadTopbar();
            application.loadControls();
            application.loadSidebar();
               
            // Start the map in view mode.
            if (application.configuration.startInViewMode) {
                application.switchToViewMode();
            } else {
                application.switchToEditMode();
            }
            
            application.showHome();
        };
        
        var keepWaiting = function(){
            return !application.templatesLoaded();
        };
        
        Vespucci.Util.wait(keepWaiting, finishLoading);
    },
    
    loadImages: function() {
        for (var index = 0; index < this.configuration.icons.length; index++) {
            
            var src = this.configuration.icons[index];
            var image = new Image();
            
            image.onerror = function() {
                OpenLayers.Console.error("Trouble preloading image '" + src + "'.");
            };
            
            image.src = src;
        }
    },
    
    loadRequestQueue: function() {
        this.requestQueue = new Vespucci.RequestQueue();  
    },
    
    loadTemplates: function() {
        
        var application = this;
        
        /* 
         * Should we refactor a Request to handle more than simply
         * WFS requests? See onFailure below.
         */
        function onSuccess(response) {
            
            var templateContainer = document.createElement("DIV");
            templateContainer.className = application.configuration.templateContainerCSSClass;
            
            templateContainer.innerHTML = response.responseText;
            
            // Use the document to turn the HTML markup into DOM elements, turn
            // turn those DOM elements into Jugl templates, then finally remove
            // the DOM elements from the body. 
            document.body.appendChild(templateContainer);
            
            for (var name in application.templates) {
                var id = application.templates[name];
                var element = document.getElementById(id);
                
                application.templates[name] = new Jugl.Template(element);
            }
            
            document.body.removeChild(templateContainer);
        }
        
        function onFailure(response) {
            OpenLayers.Console.error("Could not retrieve template file.");
        }
        
        var request = new OpenLayers.Ajax.Request(this.configuration.templateFile,
                                    {
                                        method: "get",
                                        onSuccess: onSuccess,
                                        onFailure: onFailure
                                    });
    }, 
    
    loadMap: function() {
        
        var restrictedExtent = (this.configuration.restrictExtent ? this.configuration.maxExtent : null);
        
        var options = {
            projection: this.configuration.projection,
            units: "m",
            maxExtent: this.configuration.maxExtent,
            restrictedExtent: restrictedExtent,
            maxResolution: this.configuration.maxResolution,
            controls: [],
            numZoomLevels: this.configuration.numZoomLevels,
            theme: Vespucci._getScriptLocation() + "Vespucci/Theme/map.css"
        };
        
        this.map = new OpenLayers.Map(this.configuration.mapDivId, options);
    },
    
    loadLayers: function() {
        var wms = new OpenLayers.Layer.WMS(
            this.configuration.wmsLayerName,
            this.configuration.wmsUrl,
            this.configuration.wmsOptions
        );        
        
        var styleMap = this.createStyleMap();

        this.wfsLayer = new Vespucci.WFSVFilterLayer(this.configuration, 
                                               this.configuration.wfsLayerName,
                                               this.configuration.wfsvUrl,
                                               {
                                                    typename: this.getWFSTypeString(),
                                                    featureNS : this.configuration.namespaceUri,
                                                    srsName: this.configuration.projection
                                               },
                                               {
                                                    extractAttributes: true,
                                                    yOrdering: true,
                                                    styleMap: styleMap
                                               });
        
        this.map.addLayers([wms, this.wfsLayer]);    
    },
    
    createStyleMap: function(){
        
        var rules = [];
        
        for(type in this.configuration.featureStyles){
            rules.push(new Vespucci.Rule.FeatureTypeRule(type,this.configuration.featureStyles[type]));
            
            if(this.configuration.subtypes[type]){
                
                for(var i = 0; i < this.configuration.subtypes[type].length; i++){
                    rules.push(new Vespucci.Rule.SubtypeRule(type, this.configuration.subtypes[type][i]));
                }
            }
            
        }
        
        var style = new OpenLayers.Style();
        
        style.addRules(rules);
        
        var styleMap = new OpenLayers.StyleMap({'default' : style, 'select' : {}});
        
        return styleMap;
    },
        
    
    loadControls: function() {
        
        var application = this;
        
        var selectOptions = {
            onSelect: function(feature) {feature.selected(application);}
        };
        
                this.map.events.register("zoomend", application, function(){
            var popup = this.getPopup();
            if(popup){
                this.map.setCenter(popup.lonlat);
            }
        });

                for(var name in application.configuration.moveControls){
                        var moveHandler = application.configuration.moveControls[name];
                        
                        moveStyle = OpenLayers.Util.extend({}, application.configuration.featureStyles[name]);
            
                var moveControlOptions = {
                handlerOptions: {
                        layer: this.wfsLayer,
                        style: moveStyle
                }
                };
                        
                        this.moveControl[name] = new Vespucci.MoveFeature(this.wfsLayer, moveHandler, moveControlOptions);              
                                      
                this.moveControl[name].featureMoved = function(feature){
                                // Deactivate the draw control, since a feature was just added.
                                this.deactivate();
                                                
                                // Go straight into editing after moving the feature.
                                feature.edit(application);
                        }                               
                }
                
                
                for (var type in application.configuration.addControls) {
                        // Remember: This is just the handler class. DrawFeature takes care of
                        // instantiating it for us.
                        var handler = application.configuration.addControls[type];
                        
                        var style = null;
                        if (application.configuration.featureStyles[type]) {
                                style = OpenLayers.Util.extend({}, application.configuration.featureStyles[type]);
                        }
                        
                        var controlOptions = {
                                handlerOptions: {
                                        layer: application.wfsLayer,
                                        style: style
                                }
                        };
                        
                        this.drawControl[type] = new Vespucci.DrawVespucciFeature(type,application.configuration, application.wfsLayer, handler, controlOptions);
                        
                        this.drawControl[type].featureAdded = function(feature){
                                feature.state = OpenLayers.State.INSERT;
                                
                                // Go straight into editing after adding the feature.
                                feature.edit(application);
                        };
                        
                        // Slight hack, but it allows us to referecnce controls by name.
            // EDIT: Do we need this now that we can reference draw controls by type?   
                        this.drawControl[type].name = type;
                }
                
        this.panZoomBar = new OpenLayers.Control.PanZoomBar();
        this.selectControl = new OpenLayers.Control.SelectFeature(this.wfsLayer, selectOptions);
        this.navigationControl = new OpenLayers.Control.Navigation();
        this.selectionParser = new Vespucci.SelectionArgParser(this);     
        this.permalinkControl = new Vespucci.FeaturePermalink();
        
        this.map.addControl(this.panZoomBar);
        this.map.addControl(this.navigationControl);
                this.map.addControl(this.selectControl);
                for(var name in this.moveControl){
                this.map.addControl(this.moveControl[name]);
                }
                for(type in this.drawControl){
                        this.map.addControl(this.drawControl[type]);
                }               
        this.map.addControl(this.selectionParser);
        this.map.addControl(this.permalinkControl);
    },
    
    loadSidebar: function() {
        this.sidebar = new Vespucci.Sidebar(this);  
    },
    
    loadTopbar: function() {
        this.topbar = new Vespucci.Topbar(this);
    },
    
    loadLoginHandler: function() {
        this.loginHandler = new this.configuration.loginHandlerClass(this);  
    },
    
    templatesLoaded: function() {
        for (var name in this.templates) {
            if (typeof this.templates[name] == "string") {
                return false;
            }
        }
        
        return true;
    },
    
    /**
     * Switch the map into edit mode. Those shows the editing toolbar, allows features to be dragged,
     * and allows access to the editing popup.
     */
        //Do we need this?  Check with Cholmes to see if this is something we should
        //care about.
    switchToEditMode: function() {
                this.selectControl.deactivate();
        this.selectControl.activate();
        this.isEditing = true;           
    },
    
    /**
     * Switch from the edit mode to the viewing mode. This code assumes that the application is in the
     * edit state before calling.
     */
    switchToViewMode: function() {
        this.isEditing = false;   
        
        this.navigationControl.activate();
        this.selectControl.activate();
    },
    
    /** 
     * Method: updateMargins
     * Called by other classes to let the application know the
     * margins have changed.
     */
    updateMargins: function() {
        var margins = this.configuration.margins;
        
        // Set this in case the panZoomBar isn't loaded yet.
        OpenLayers.Control.PanZoom.Y = this.configuration.margins.top;
        
        if (this.panZoomBar) {
            this.panZoomBar.moveTo(new OpenLayers.Pixel(margins.left, margins.top));
        }
        
        if (this.sidebar) {
            this.sidebar.calculatePosition();
        }
    },
    
    getWFSTypeString: function() {
        var output = "";
        for (var typeIndex = 0; typeIndex < this.configuration.wfsLayerTypes.length; typeIndex++) {
            if (output != "") output += ",";
            output = this.configuration.namespace 
                + ":" + this.configuration.wfsLayerTypes[typeIndex];
        }
        return output;
    },
    
    getWFSParams: function(index){
        index = index || 0;
        
        return {
            featureNS : this.configuration.namespaceUri,
            featureType : this.configuration.wfsLayerTypes[index],
            featurePrefix : this.configuration.namespace
        }    
    },
    
    addPopup: function(popup) {
        
        // This is here because the map's removePopup() function
        // doesn't call the popups hide() command.
        for(var i=0; i < this.map.popups.length; i++) {
            this.map.popups[i].close();
        }
        
        this.map.addPopup(popup,true);
    },        
    
    /**
     * Method: getPopup
     * 
     * Get the currently opened popup. Returns null if a popup
     * is not opened.
     */
    getPopup: function() {
        return this.map.popups[0];
    },
        
    // Request related functions.
    
    // TODO: Make these work through the vector layer's Save(?) strategy.
    //     
    
    updateFeature: function(feature, onSuccess, onFailureOrCancel) {
        /*
        var request = new Vespucci.Request.UpdateFeatureRequest(this, feature);
        request.send(onSuccess, onFailureOrCancel, onFailureOrCancel);
        */
        feature.state = OpenLayers.State.UPDATE;
        this.wfsLayer.commitFeature(feature, onSuccess, onFailureOrCancel);
    },
    
    insertFeature: function(feature, onSuccess, onFailureOrCancel) {
        /*
        var request = new Vespucci.Request.InsertFeatureRequest(this, feature);
        request.send(onSuccess, onFailureOrCancel, onFailureOrCancel);
        */
       
           //BROKEN because of the callbacks
        feature.state = OpenLayers.State.INSERT;
        this.wfsLayer.commitFeature(feature, onSuccess, onFailureOrCancel);
    },
    
    deleteFeature: function(feature, onSuccess, onFailureOrCancel) {
        feature.state = OpenLayers.State.DELETE;
        this.wfsLayer.commitFeature(feature, onSuccess, onFailureOrCancel);
    },

    rollback: function(feature, options, onSuccess, onFailureOrCancel){
        this.wfsLayer.rollback(feature, options, onSuccess, onFailureOrCancel);
    },

    // Window functions (encapsulation of dialogs/dialog-type classes).

    showSidebar: function() {
        this.sidebar.show();
    },

        showHistoryFeed : function(){
        this.loadView(new Vespucci.SidebarView.HistoryFeedView(this)); 
        
        // Always show the sidebar for the history feed.
        this.showSidebar();
    },
    
    showHome: function() {
        this.loadHomeViewInSidebar();

        // Always show the sidebar when showing help.
        this.showSidebar();  
    },
    
    loadHomeViewInSidebar: function() {
        this.loadView(new Vespucci.SidebarView.HelpView(this));
    },
    
    contextualShowHome: function(){
        //messy for now
        if(this.sidebar.view.hasFeatureContext()){
            this.loadHomeViewInSidebar();
        }  
    },
        
        showAddFeature: function(type) {
                this.loadView(new Vespucci.SidebarView.AddFeatureView(this, type, this.drawControl[type]));
                this.showSidebar();
        },
    
    showHistory: function() {
        this.loadView(new Vespucci.SidebarView.HistoryView(this));  
    },
    
    showLoginScreen: function(onSuccess, onCancel) {
        
        var application = this;
        
        // If there is a successful login, ever, we want to update the topbar.
        var updateTopBarOnSuccess = function() {
            application.topbar.updateLoginLinkText();
            if (onSuccess) {
                onSuccess();
            }
        }
        if(!this.loginScreen){
            this.loginScreen = new Vespucci.LoginScreen(this, updateTopBarOnSuccess, onCancel);    
        }
    },
    
    loadCommentsInSidebar: function(feature, scrollPosition){
        this.loadView(new Vespucci.SidebarView.CommentsView(this, feature, scrollPosition));
    },
    
    loadFeatureHistoryInSidebar: function(feature, scrollPosition){
        this.loadView(new Vespucci.SidebarView.FeatureHistoryView(this, feature, scrollPosition));
    },
       
    loadFeatureDiff: function(feature, fromFeatureVersion, toFeatureVersion){
        this.loadView(new Vespucci.SidebarView.FeatureDiffView(this, feature, fromFeatureVersion, toFeatureVersion));
    },
    
    /**
     * Load a given view into the sidebar.
     */
    loadView: function(view) {
        this.sidebar.loadView(view);
    },
        
        // Login functions (encapsulation of this.loginHandler).
        
        login: function(username, password, onValidate, onInvalid) {
                this.loginHandler.validate(username, password, onValidate, onInvalid);
        },
        
        logout: function() {
                this.loginHandler.logout();
        this.topbar.updateLoginLinkText();
        },
        
        isLoggedIn: function() {
        return this.loginHandler.isLoggedIn();
    },
    
    showPleaseLoginError: function() {
        //alert("You do not have permission to perform this action. Please login and try again.")  
    },
    
    showForbiddenError: function() {
        alert("You do not have permission to perform that action. If you feel you have received this message in error please contact an administrator.")  
    },

    // Functions for enabling/disabling the zoom wheel.
        
    /**
     * Enable the wheel handler of the navigation control.
     */
    enableZoomWheel: function(){
        this.navigationControl.enableZoomWheel();
    },
    
    /**
     * Disable the wheel handler of the navigation control.
     * This allows the wheel to be used for scrolling (for instance,
     * in the sidebar).
     */
    disableZoomWheel : function(){
        this.navigationControl.disableZoomWheel();
    },  
    
        // Layer functions.
        
    refreshFeatures: function() {
        this.wfsLayer.redraw();
    },
    
    unselectFeature: function(feature) {
        if(feature.geometry){
            this.selectControl.unselect(feature);
        }
    },
    
    removeFeatures : function(features){
        this.wfsLayer.removeFeatures(features);  
    },
    
    addFeatures: function(features) {
        this.wfsLayer.addFeatures(features);
    },
            
    getFeatureByFid: function(fid) {
        return this.wfsLayer.getFeatureByFid(fid);
    },
    
    hasFeature: function(feature) {
        return this.getFeatureByFid(feature.getFID()) != null;
    },
        
        //Control activation functions
        
        moveFeature: function(feature){
                this.wfsLayer.eraseFeatures([feature]);
                this.moveControl[feature.type].activate(feature);
        },
    
    // Permalinking
    
    /**
     * Method: getPermalink
     * Get the current permalink. If a feature is passed, the permalink
     * will be centered around the feature, and, when accessed, the feature
     * will be selected.
     * 
     * {<Vespucci.Feature>} feature
     */
    getPermalink: function(feature) {
        var title = document.title;
        
        if (feature) {
            title = feature.getTitle();
        }
        
        var url = this.permalinkControl.createUrl(feature);
        
        return url;
    },

    CLASS_NAME: "Vespucci.Application"
});