Changes between Version 2 and Version 3 of MapGuideTutorial

Timestamp:

Mar 12, 2008, 5:20:34 AM (16 years ago)

Author:

pagameba

Comment:

--

MapGuideTutorial

@@ -204 +204 @@
 The Fusion application object provides two specific events that can be used by applications to get notification of when Fusion initialization has completed and when an error occurs anywhere in Fusion.  These events are:
 
-FUSION_INITIALIZED:
+{{{Fusion.Event.FUSION_INITIALIZED}}}:
   This is triggered when Fusion's initialization is complete and the application is running.  This signals that it is safe for the application to communicate with specific widgets.  Note that the Map widget, specifically, will be ready but may not have actually loaded the map.  There is a separate event for that (see the Map widget in the Command API reference).  Applications should register for this event before calling Fusion.initialize().
-FUSION_ERROR:
+{{{Fusion.Event.FUSION_ERROR}}}:
   This is triggered when an internal error happens.  Details on the error are passed to the callback function.  Applications should register for this event before calling {{{Fusion.initialize()}}} to ensure that they receive errors that happen during initialization.
 
@@ -219 +219 @@
 The Map widget API is probably the most used one in Fusion.  It is completely documented in the Command API reference, but the most used methods are described here.
 
-loadMap(mapDefinition):
+{{{loadMap(mapDefinition):}}}
   This causes the Map widget to load the specified MapDefinition.
-reloadMap():
+{{{reloadMap():}}}
   This causes the Map widget to reload the current MapDefinition.  This is necessary when the map state has changed in certain ways (adding or removing layers in the map, for instance) and is primarily an internal function.
 setExtents(minx, miny, maxx, maxy).  This is used to set the map extents to a particular bounding box programmatically.
-drawMap():
+{{{drawMap():}}}
   This is used to render a map image and load it in the browser.  Normally, this is called automatically as required, but occasionally it may be required to be called programmatically when the state of the map has changed on the server without the knowledge of the Map widget.
-query(options):
+{{{query(options):}}}
   This is described more completely in the Command API Reference, but the query method is used to query the Map in some way and create (or modify) a selection.
-getSessionId():
-
-When a Map is defined in the ApplicationDefinition file, it can have a default MapDefinition that is automatically loaded when the application is loaded.  But it is not mandatory to specify a default map.  When no default map is specified, the Map widget is still initialized.  Loading of a MapDefinition is then done in response to a widget (such as the MapMenu widget) or some application-specific code.  Regardless of how it happens, when a MapDefinition has been loaded, the Map widget will trigger a MAP_LOADED event.  Most widgets are not useful if there is no map loaded, so they use the MAP_LOADED event to determine when they should be enabled.  This means that most widgets will appear initially disabled until the map has been loaded.  There are some notable exceptions, including the Map Menu widget which is used to provide a drop-down menu of MapDefinitions that the user can pick from.
+{{{getSessionId():}}}
+  This returns the session id that is used with the server side support scripts for this map.
+  
+When a Map is defined in the ApplicationDefinition file, it can have a default !MapDefinition that is automatically loaded when the application is loaded.  But it is not mandatory to specify a default map.  When no default map is specified, the Map widget is still initialized.  Loading of a !MapDefinition is then done in response to a widget (such as the MapMenu widget) or some application-specific code.  Regardless of how it happens, when a !MapDefinition has been loaded, the Map widget will trigger a {{{Fusion.Event.MAP_LOADED}}} event.  Most widgets are not useful if there is no map loaded, so they use the {{{Fusion.Event.MAP_LOADED}}} event to determine when they should be enabled.  This means that most widgets will appear initially disabled until the map has been loaded.  There are some notable exceptions, including the Map Menu widget which is used to provide a drop-down menu of !MapDefinitions that the user can pick from.
 
 Once the Map is loaded, many events may be triggered, including:
 
-MAP_SESSION_CREATED.  The Map widget is responsible for creating and maintaining a session with the server.  When the session has been created, this event is triggered.  Nothing can happen until this event has been triggered.
-MAP_LOADING.  The Map widget triggers this event when it is starting to load a new Map.  This is primarily used by widgets to prepare themselves for the new map by discarding their current state and temporarily disabling themselves.
-MAP_LOADED.  The Map widget triggers this event when a map has been loaded and is ready.
-MAP_EXTENTS_CHANGED.  The Map widget triggers this event for any navigation that changes the current extents.
-MAP_BUSY_CHANGED.  The Map widget maintains a reference count of asynchronous events as they start and finish.  An application can use this event to display a processing image so that the user is aware that some asynchronous activitity is happening.
-MAP_RESIZED.  The Map widget triggers this event when the size of the map is changed.
-MAP_SELECTION_ON.  The Map widget triggers this event when a new selection has been created.
-MAP_SELECTION_OFF.  The Map widget triggers this event when the current selection has been cleared.
-MAP_ACTIVE_LAYER_CHANGED.  The Map widget allows for a single layer to be marked as active by the application.  This event is triggered when the active layer is changed.
-MAP_GENERIC_EVENT.  Most widgets rely directly on their Map widget for everything.  In some cases, though, widgets need to be informed of changes in other widgets.  In these cases, the Map widget can act as a broker for events through the MAP_GENERIC_EVENT.  Widgets that employ the MAP_GENERIC_EVENT normally do so for a specific internal purpose, and the application should not normally register for this event.
-
-Working with Selections
+{{{Fusion.Event.MAP_SESSION_CREATED}}}:
+  The Map widget is responsible for creating and maintaining a session with the server.  When the session has been created, this event is triggered.  Nothing can happen until this event has been triggered.
+{{{Fusion.Event.MAP_LOADING}}}:
+  The Map widget triggers this event when it is starting to load a new Map.  This is primarily used by widgets to prepare themselves for the new map by discarding their current state and temporarily disabling themselves.
+{{{Fusion.Event.MAP_LOADED}}}:
+  The Map widget triggers this event when a map has been loaded and is ready.
+{{{Fusion.Event.MAP_EXTENTS_CHANGED}}}:
+  The Map widget triggers this event for any navigation that changes the current extents.
+{{{Fusion.Event.MAP_BUSY_CHANGED}}}:
+  The Map widget maintains a reference count of asynchronous events as they start and finish.  An application can use this event to display a processing image so that the user is aware that some asynchronous activitity is happening.
+{{{Fusion.Event.MAP_RESIZED}}}:
+  The Map widget triggers this event when the size of the map is changed.
+{{{Fusion.Event.MAP_SELECTION_ON}}}:
+  The Map widget triggers this event when a new selection has been created.
+{{{Fusion.Event.MAP_SELECTION_OFF}}}:
+  The Map widget triggers this event when the current selection has been cleared.
+{{{Fusion.Event.MAP_ACTIVE_LAYER_CHANGED}}}:
+  The Map widget allows for a single layer to be marked as active by the application.  This event is triggered when the active layer is changed.
+{{{Fusion.Event.MAP_GENERIC_EVENT}}}:
+  Most widgets rely directly on their Map widget for everything.  In some cases, though, widgets need to be informed of changes in other widgets.  In these cases, the Map widget can act as a broker for events through the MAP_GENERIC_EVENT.  Widgets that employ the {{{Fusion.Event.MAP_GENERIC_EVENT}}} normally do so for a specific internal purpose, and the application should not normally register for this event.
+
+== Working with Selections ==
 
 There are several widgets in Fusion that allow the user to interactively select features on the Map.  Fusion takes care of updating the Map image with the current selection, if necessary, but does not display attributes of the selected features to the user.  That is up to the application.
@@ -251 +262 @@
 Regardless of how the features are selected, the Map widget provides the API for an application to retrieve and work with the user's selection.  There are two events that can be used by an application to know when the user selection has changed:
 
-MAP_SELECTION_ON.  The Map widget triggers this event when a new selection has been created.
-MAP_SELECTION_OFF.  The Map widget triggers this event when the current selection has been cleared.
-
-When the application receives a MAP_SELECTION_ON event from the Map widget, it can use the following functions to work with the selection:
-
-hasSelection().  This method returns a boolean value which indicates if there is currently a selection or not
-getSelection(callback).  This method retrieves the current selection.  Retrieving the selection is potentially an asynchronous operation and so the callee provides a callback function that is called when the selection is ready.  The callback function is passed a single argument, a Selection object, described below.
-clearSelection().  This method is used to clear the current selection.  This removes the selection from the map and invalidates the current selection object.
+{{{Fusion.Event.MAP_SELECTION_ON}}}:
+  The Map widget triggers this event when a new selection has been created.
+{{Fusion.Event.{MAP_SELECTION_OFF}}}:
+  The Map widget triggers this event when the current selection has been cleared.
+
+When the application receives a {{{Fusion.Event.MAP_SELECTION_ON}}} event from the Map widget, it can use the following functions to work with the selection:
+
+{{{hasSelection()}}}:
+  This method returns a boolean value which indicates if there is currently a selection or not
+{{{getSelection(callback)}}}:
+  This method retrieves the current selection.  Retrieving the selection is potentially an asynchronous operation and so the callee provides a callback function that is called when the selection is ready.  The callback function is passed a single argument, a Selection object, described below.
+{{{clearSelection()}}}:
+  This method is used to clear the current selection.  This removes the selection from the map and invalidates the current selection object.
 
 An application will typically call getSelection() in response to the MAP_SELECTION_ON event.  Typical code for this might look like:
 
+{{{
 window.onload=function() {
-    Fusion.registerForEvent(FUSION_INITIALIZED, onInitialized);
+    Fusion.registerForEvent(Fusion.Event.FUSION_INITIALIZED, onInitialized);
     Fusion.initialize();
 }
@@ -270 +287 @@
 function onInitialized() {
     theMap = Fusion.getWidgetById('Map');
-    theMap.registerForEvent(MAP_SELECTION_ON, selectionOn);
-    theMap.registerForEvent(MAP_SELECTION_OFF, selectionOff);
+    theMap.registerForEvent(Fusion.Event.MAP_SELECTION_ON, selectionOn);
+    theMap.registerForEvent(Fusion.Event.MAP_SELECTION_OFF, selectionOff);
 }
 
@@ -286 +303 @@
     //clear the selection results
 }
+}}}
 
 A Selection object is used to access the selection results.  It provides the following API:
 
-getNumLayers() returns the number of layers that have features selected
-getNumElements() returns the total number of features that are selected
-getLowerLeftCoord() returns the lower, left coordinate of the bounding box of all selected features
-getUpperRightCoord() returns the upper, right coordinate of the bounding box of all selected features
-getLayerByName(name) gets the layer selection object for a layer from the name of the layer.  This returns null if there is no layer with the requested name in the selection results
-getLayer(index) gets the layer selection object for the requested layer where index is between 0 and one less that the value returned by getNumLayers().
+{{{getNumLayers()}}}:
+ returns the number of layers that have features selected
+{{{getNumElements()}}}:
+ returns the total number of features that are selected
+{{{getLowerLeftCoord()}}}:
+ returns the lower, left coordinate of the bounding box of all selected features
+{{{getUpperRightCoord()}}}:
+ returns the upper, right coordinate of the bounding box of all selected features
+{{{getLayerByName(name)}}}:
+ gets the layer selection object for a layer from the name of the layer.  This returns null if there is no layer with the requested name in the selection results
+{{{getLayer(index)}}}:
+ gets the layer selection object for the requested layer where index is between 0 and one less that the value returned by {{{getNumLayers()}}}.
 
 An application will typically loop over the layers in a selection and retrieve individual results using the Layer Selection object returned by getLayer() or getLayerByName().  Layer selection objects have the following API
 
-getName() returns the name of the layer that the selected features are in
-getNumElements() returns the number of features selected in this layer
-getNumProperties() returns the number of data properties, or attributes, of the features in this layer
-getPropertyNames() returns an array of the names of each of the properties
-getPropertyTypes() returns an array of the types of the properties
-getElementValue(elementIndex, propertyIndex) returns the actual value of a given property for a given element
-
-       
+{{{getName()}}}:
+ returns the name of the layer that the selected features are in
+{{{getNumElements()}}}:
+ returns the number of features selected in this layer
+{{{getNumProperties()}}}:
+ returns the number of data properties, or attributes, of the features in this layer
+{{{getPropertyNames()}}}:
+ returns an array of the names of each of the properties
+{{{getPropertyTypes()}}}:
+ returns an array of the types of the properties
+{{{getElementValue(elementIndex, propertyIndex)}}}:
+ returns the actual value of a given property for a given element
+
 The following code is an example of how to use the Selection and Layer Selection objects to create a tabular display of selected features.
 
+{{{
 function displaySelection(selection) {
     //display the selection to the user in some way ...
@@ -352 +382 @@
     }
 }
-
+}}}