About | Contact | SUBMIT PRESS | Advertise | FAQ
Newsletters | Twitter |
Software | Spotlights on Geospatial Data | Webmaps and Web Services | IMAGING | Hardware | Social Media  

Top Geo News
Put Your News here! 

Updated Whale Alert iPad, iPhone app invites public to contribute to protection of West Coast whales

Got news? TELL US...
submit press to GISuser

Social Connect

GISuser Sponsor

Recent Site Additions
GISuser Sponsor

GISuser Videos

See also SpatialVideos Youtube

GISuser Sponsor

Home arrow Articles arrow Web Services arrow Gmaps 101 - An Introduction to Google Maps & The Google Maps API V2 (Part 2)     

post a GIS job * THE NEW GEOJOBS.BIZ!!! *  NEW CAREERS at Esri
See THOUSANDS of jobs on GeoJobs.Biz
Submit News/tips to press @gisuser.com
Gmaps 101 - An Introduction to Google Maps & The Google Maps API V2 (Part 2) PDF Print E-mail
Written by Eric Pimpler   
28 April 2006
In this second article of a three part series we will cover the Google Maps API Version 2 in greater detail including the most commonly used classes such as GMap2, GMarker, GLatLng and many others.  We’ll also explore the various map controls that can be placed on a Google Map including panning, zooming, and overview controls. 

In addition, we’ll also cover various events that you can use in your code to respond to user initiated actions.  In Part 1 of the series we gave an overview of the fundamental programming constructs for developing web mapping applications with the hottest web mapping application development tool. 

The Google Maps API

Now that you’ve seen how simple it is to create a Google Maps application let’s dive into the details of the Google Maps API so that you can get a much deeper understanding of how you can manipulate the API in your web mapping applications.

In Figure 1 you will see a visual depiction of some of the more commonly used objects in the Google Maps API.  Obviously all Google Maps applications will have a map as the main display object.  This map is represented in the API by the GMap2 object.  A number of map navigation controls can be added to the map including GLargeMapControl, GSmallMapControl, GMapTypeControl, and the newly released GOverviewMapControl.  These controls are used to zoom in and out, pan the map, enable the display of aerial photography, streets, and other background information, and provide the ability to include an overview map.  GMarker refers to a geographic point of some type and is represented with an icon.  You can use the default icons provided by Google or define your own custom icons.  Typically, these markers refer to an address stored in a database or XML file.  Info Windows are often used in conjunction with GMarker to display attribute information about the marker.  For instance, in a real estate application you might display a photo of a home along with other relevant details such as the sales price, square footage, number of bedrooms and baths.  These are some of the most commonly used objects, but there are others that we will explore as well throughout this course.



Although the old map class, GMap, will continue to exist in Version 2 of the API all the new features provided by Google will be attached to the new Version 2 class called GMap2.
Like the original GMap class, the GMap2 class enables you to create map instances.  You can create as many map instances as necessary for your application although most commonly this will only be a single instance.  Maps are typically embedded within an HTML container called a <div> tag.  The size of the map will default to the size specified in your <div> tag.  Once you’ve generated an instance of GMap2 you can use the various methods and properties available on this object to manipulate other aspects of the map such as the controls included, the display of points of interest or polylines, and many other things.  Everything in Google Maps flows through an instance of the GMap2 class.


 GMap2 can also respond to a whole host of events.  Events are simply an external stimulus to the map triggered by the user.  Typical events might include the user dragging the map or clicking the map, an overlay marker being added to the map, or the map type changing from regular to aerial.  You can write code that responds to any of these and other events.  For instance, you might want to add a marker at the point where the user clicks the map, or perhaps you could display the latitude, longitude coordinates of the center of the map after a pan event has occurred. 

The constructor for GMap2 takes a container as it’s only required argument.  In addition, several optional arguments can also be supplied including a list of map types to include with the map and the width and height of the map. 

Notice in the code example above that we use the HTML document object model to find our <div> tag that has been given the name “map”.

We can control the map types that are displayed in our map through the use of a second argument.  By default, all map types (Satellite, Hybrid, and Normal) will be available.  However, you can control the available map types through a list that is provided in the GMap2 constructor. 

Notice in the code example above that we are restricting the map types that can be displayed to hybrid and satellite only, the Map button will be suppressed as seen in the figure below.


 The final optional parameters control the width and height of the map.  If these arguments are not included in the constructor, the map will default to the size specified in your container.  These numeric parameters specify the pixel height and width of the map.

Once you’ve created a map object you will have access to a number of methods that can be used to control the configuration, state, controls, overlays, info windows, and events that can be associated with a map.  We’ll explore many of these methods throughout the course.

GPoint and GLatLng

Prior to Version 2 of the Google Maps API, the GPoint class was used to represent a single, 2-dimensional longitude/latitude point of interest somewhere on the face of the earth.  However, with Version 2, geographic coordinates are now being represented by a new class: GLatLng.  GPoint now represents a point on a map by its pixel coordinates.  This is a significant change that will need to be incorporated by existing Google Maps Version 1 sites and will necessitate changes to those applications.

The GLatLng constructor takes two required parameters;  y and x.  The y parameter represents latitude while the x parameter represents longitude. 

In this code example, -96.340264 represents the x or longitude value while 30.609682 represents the y or latitude value.

GLatLng is normally used for two different yet important functions in Google Maps.  The first reason for using GLatLng is to set the center point of your map.  In the code example below you’ll see an example of using GLatLng to set the center point of your map.  The setCenter( ) method on GMap2 takes a parameter that centers the map at a given longitude/latitude coordinate.  setCenter( ) also takes a second parameter that sets the zoom level of your map.  This will be a numeric value between 0 and 17.  However, it’s the GLatLng object that is used to set the center of your map.

GLatLng is also used in conjunction with GMarker to create points of interest that are displayed as markers on your map.  GMarker must have a coordinate defined by GLatLng to know where to place itself on the map.  Notice how GMarker uses an instance of GLatLng in the code example below.

Let’s examine the GMarker class in more detail to get a better understanding of how it works with GLatLng to create markers on your Google Map.


The GMarker class is used to create icons showing points of interest on your Google Map. 
GMarker takes a single required parameter in it’s constructor.  This parameter is an instance of GLatLng which we saw in the last code example.  A second, optional parameter can be specified in the event that you need to display custom icons.  By default, Google will display the icon shown here: 

However, if you’d like to display custom icon markers you’ll need to obtain the custom icons and then use the GIcon class to specify how these icons should be displayed on the map.  We’ll explore this subject in detail later in the book. 


A polyline represents a vector line drawn on the map.  GPolyline uses two or more instances of GLatLng to create a vector line between the two points.  The vector lines generated by GPolyline can be created in various colors, weights, and transparency. 

Let’s examine the code above to get a better understanding of how to create polylines in Google Maps.  The first parameter in the GPolyline constructor is an array of GPoint objects.  For our purposes you can think of an array as a list.  You must include at least two points in the array so that GPolyline can create the vector line between the points.  Typically you’ll also include a number of points between the start and end point.  The rest of the parameters are optional and include the ability to specify the line color, width of the line, and transparency of the line.  The color is specified as a hex HTML color such as #ff0000 for blue.  The width of the line is specified as a numeric value that controls the size of the line in pixels.  Finally, you can control the transparency of the line by including a float value between 0 and 1 with a value of 1 indicating full transparency.   

 If you want to show polylines on your map you need to include the VML namespace and some CSS code in your XHTML document to make everything work properly in IE. The beginning of your XHTML document should look something like this for IE browsers:

A Word About Polygons

At this time, Google Maps does not provide the ability to generate true polygons, but I suspect that this will change in the near future as the API becomes more robust.  However, a third-party developer, XMaps, provides this functionality in its XMaps Library which is a Google Maps API Extension.  This library is in pre-release and can be downloaded from their site.  Furthermore, you can simulate a polygon through the use of the GPolyline class by making the start and end points the same so that it appears as if the line has closed on itself to create a polygon.


The GSize class represents a two-dimensional size in pixels and is used when defining custom icons.  We’ll take a closer look at this class later in the book when we examine custom icons.


The GLatLngBounds class represents a box or envelope that contains the current geographic extent of the map.  This extent is represented by minimum and maximum x (longitude) and y (latitude) values whose values change each time a pan or zoom action occurs.  The map.getBounds( ) method returns a GLatLngBounds object.  This object is frequently used to constrain the points of interest shown on a map when an application has access to large amounts of data that could potentially decrease the performance of the application if drawn all at once.

Map Controls

The ability to interact with a map is a core function provided by any web mapping application.  Google Maps provides this functionality through the use of map controls which allow the user to pan, zoom in or out, and change the map type. 


By default, every Google Map that you create in your application has the ability to pan.  Panning simply gives you the ability to move the map in any direction by “dragging” in that direction.  Google provides a number of ways to accomplish this task.  Panning is most commonly performed simply by using the mouse to drag the map in a particular direction.  In addition, Google provides a map control that can be used for panning the map.

Simply clicking one of the directional arrows will pan the map in the direction selected.

Panning can also be controlled programmatically.  As mentioned, panning is enabled automatically, but through the use of the map.disableDragging( ) method you can disable the ability to pan.  Panning is not typically disabled in most applications, but there are times when you may have a need to turn off this functionality.  For instance, if you are using an overview map in your application it probably makes sense to disable panning in the overview map while allowing panning to remain enabled in the main map. 

The Google Maps API can also be used to programmatically pan a map.  You can use the panTo(GLatLng) method on GMap2 to programmatically pan the map to a latitude/longitude coordinate.  The panBy(distance) method on GMap2 is used to programmatically pan the map by a specified distance.  Finally, the panDirection(dx, dy ) method is to programmatically pan the map in a direction specified by dx and dy.


The Google Maps API provides the ability to attach zoom controls to your application thereby giving your users control over the zoom level at which they view your map.  The zoom controls are automatically added to the left side of your map.  You have three choices available when coding your application.  The default map control provided by maps.google.com is the GLargeMapControl object.  GLargeMapControl shows all 18 levels of zoom on the slider along with a plus and minus button at the top and bottom of the slider.  In addition to clicking the various levels on the control you can also drag the slider to the desired level. 

If you need to conserve real estate in your application, you can use the GSmallMapControl which discards the full slider in favor of the plus/minus zoom buttons.  It also provides the pan buttons.

Finally, the smallest possible control available is the GSmallZoomControl which displays only the plus/minus buttons without the zoom slider or pan controls.

To add any of the three map controls to your application, simply use the addControl( ) method on GMap2 along with the name of the control.  For instance, this code example shows how to add GLargeMapControl to a map:

In the figure below you see an example of all three zoom controls.

 GLargeMapControl GSmallMapControl GSmallZoomControl


 Map Type Controls

Map type controls can be added to your Google Maps to allow users to change the background data displayed by the map.  By default, the Normal mode is displayed showing vector, line drawings of streets, water bodies, parks, and other points of interest.  In addition to the default Normal mode, two other map types are available: Satellite, and Hybrid.  Satellite mode shows aerial imagery of the area while Hybrid mode displays streets and labels semi-transparently over a satellite image. 

By default, all three map types are displayed similar to what you see below with the Normal mode being the default type.

As mentioned earlier in the book, you have control over which map types are displayed in your application through the mapTypes argument on the GMap2 constructor.  The mapTypes argument is an array containing the map types you’d like to display.  An array in Javascript is similar to a list.  Notice that the creation of the array is specified with opening and closing brackets. 

In the code example above, only the Hybrid and Satellite map types will be displayed. 

Several additional methods on GMap2 can be used manipulate map types.  The map.setMapType(map_type) method is used to specify the currently visible map type.  For instance, the following code example would set the current map type to Hybrid.

In addition to the G_HYBRID_MAP you may also specify values for Satellite (G_SATELLITE_MAP) and Map (G_NORMAL_MAP). 

The map.getCurrentMapType( ) method can be used to get the active map type while map.getMapTypes( ) returns an array containing all the map types available in the map.  Now, the interesting thing with both these methods is that neither method returns a descriptive string for the map types.  They both return objects and neither object contains helper functions that return the textual name of the map type(s).  You will have to write a simple helper function to return this information in a human readable format.  I am including just such a function in the code sample below.


OverView Map Control

New to Google Maps Version 2 is the ability to add an overview map to your application.  As is the case with the other types of map controls, GOverviewMapControl can be added through the addControl( ) method on GMap2 as you see in the code sample below.

This will add a collapsible overview map to the corner of the screen which displays the geographic extent of the main map.  The geographic extent of the main map can be controlled by dragging the rectangular extent in the overview map.  See Figure 5 for an example of an application with an overview map included.


Scale Control

Also new to Version 2 is the Scale Control which provides a scale for your map.  This control is added to your application in the same way as any other map control and provides a visual depiction of distance. 

Adding User Data

We briefly touched on the subject of adding application specific data in a previous chapter, but let’s delve into this subject in greater detail in this section.  As we mentioned, the ability to add user specific application data has been one of the main drivers in the widespread use of Google Maps for the development of web mapping applications.  In this chapter we’ll take a look at the various objects that you can use to add user data and info windows to your Google Maps application.


The GMarker class is used to create icons showing points of interest on your Google Map.  In the Google Maps API chapter we introduced GMarker, and we said that GMarker is used in conjunction with GLatLng to plot points of interest on a map.  Let’s provide a bit of a refresher on the GLatLng object before going into more detail on GMarker.  Remember that GLatLng stores a longitude/latitude coordinate representing the geographic coordinates of a point of interest. 

However, GLatLng does not provide the capability of plotting points on a map.  This functionality is provided by the GMarker object which uses an instance of GLatLng to plot an icon at the coordinates specified in an instance of GLatLng.  The constructor for GMarker takes a single required parameter containing an instance of GLatLng. 

GMarker will display the default icon provided by Google Maps if you do not specify the second (optional) parameter in the GMarker constructor. 

 Once you’ve created an instance of GMarker you need to call the map.addOverlay( ) method to actually plot the icon on the map. 

Icons can be removed from a map through the use of one of two methods provided on GMap2.  The map.removeOverlay(marker) method can be used to remove a single instance of GMarker while map.clearOverlays( ) is used to remove all markers that have been added to a map. 

One thing that you will want to keep in mind is that although you can theoretically add an unlimited number of markers to your map you will find that performance starts to suffer when you attempt to add more than a couple hundred markers.  There are a number hacks that you can use to deal with situations where you have hundreds or even thousands of potential markers that can be placed on a map.  We cover these in more detail in our “Google Maps For Your Apps!” virtual training course.


In many instances you may not want to use the default marker icon provided by Google Maps.  Perhaps you have your own set of icons that accurately represent the user data you are attempting to present in your application.  In Figure 6 you will see an sample of an application that was created using custom GIcons.  Fortunately, Google Maps provides the ability to customize the look and feel of the user data in your application.  Through the use of the GIcon object your can attach any PNG file to create a custom marker.  Theoretically your icon files can be of any size, but for practical purposes you should keep the size between 20-30 square pixels.  For example, the default marker provided by Google Maps is 24x30. Anything larger makes the icons appear too large in relation to the map.   It is beyond the scope of this book to go into great detail on how to create these icons, but we’ll show you how to use them once you (or a graphic artist) create them.

Many additional customizations of your icons are possible.  Most custom icons also come with an additional icon that represents the shadow of an icon.  Through the use of the icon.shadow( ) and icon.shadowSize( ) methods you can add these shadow files to your icons.  At a minimum you should specify the icon, iconSize, shadow, and shadowSize properties as you see in the code example below.

In addition to these properties the icon.iconAnchor and icon.infoWindowAnchor properties can be used to specify anchor points.  The icon.iconAnchor property is used to specify the exact pixel that will be attached to the instance of GLatLng.  For example, if you want the upper left hand corner of an icon to be placed at the point of interest you specify a value of 0,0.  When your application is going to use Info Windows you will also want to specify the icon.infoWindowAnchor property which will be used as the origination point of the Info Window.

For browser compatibility reasons, specifying custom icons can become very complex and there are a number of other properties that can be set to account for the differences in browser types.  For more details on these additional properties please see the Google Maps API Documentation for the printImage, mozPrintImage, printShadow, transparent, and imageMap properties on GIcon.



 Info Windows

Info Windows are used to display attribute information about points.  You can display an Info Window through the use of one of the openInfoWindow methods on GMap2.  Normally, Info Windows are opened just above a marker, but can be placed anywhere on a map.  Usually, Info Windows hold HTML information such as text, links, and images. 

The openInfoWindowHtml( ) method can be called from either an instance of GMap2 or GMarker, and simply takes a string containing HTML markup and displays it in an Info Window.  Let’s take a look at how to use this method with both GMap2 and GMarker.  With GMarker you can use openInfoWindowHtml( ) to open an Info Window directly above the marker. 

Notice in this case that we first defined a variable called html that we use to define the HTML markup that will be displayed in the Info Window.  This isn’t absolutely necessary, but it’s perhaps a bit cleaner.  The marker.openInfoWindowHtml method is then called and the html variable is passed in as the only parameter.  You’ll also notice that we used a new class that we haven’t discussed up to this point.  The GEvent class is used to register event listeners.  We’ll go into much greater detail on the GEvent class in a later chapter, but for now you can think of events as user initiated actions.  In this case the event we are registering is a mouse click on the marker.  When the user clicks the marker the Info Window will be displayed with the contents of the html variable displayed inside the window as you see in the figure below.


  The map.openInfoWindowHtml( ) method also opens an Info Window containing an HTML string, but it differs slightly from marker.openInfoWindowHtml( ) in that you must pass in a point as the required first parameter along with an html string.  Several optional parameters are also available including a pixelOffset parameter that controls where the Info Window originates.  Basically this is the anchor of the Info Window.  The map.openInfoWindowHtml( ) method is normally used to automatically display an Info Window without any sort of user initiated event like a mouse click.  Take a look at the code below to see an example of how to use map.openInfoWindowHtml( ) to automatically open an Info Window when the map is displayed.

Notice that we use a GLatLng instance (pt) already defined elsewhere in our code along with an offset to automatically display the html code in an Info Window when the map is created.

Several other methods are also available through GMap2 and GMarker for displaying Info Windows.  These include the openInfoWindow( ) method which is used to display an HTML DOM element and openInfoWindowXslt( ) which displays XML in an Info Window.

One exciting new method introduced at Version 2 of the Google Maps API is the openInfoWindowTabsHtml( ) method.  openInfoWindowTabsHtml( ) gives you the ability to include tabs in your Info Windows through the GInfoWindowTab class similar to what you see in Figure 8. 



 The following code was used to produce this new, tabbed version of the Info Window.

The openInfoWindowTabsHtml( ) method is supplied with an array (infoTabs) of GInfoWinowTab objects that specify the tab name and HTML that will be included on each tab.

Should the need arise you can also suppress the display of Info Windows at the map level through the use of the map.disableInfoWindow( ) method.  By default, the display of Info Windows is enabled so you shouldn’t call this method unless you have a specific need to suppress their display.


For those of you new to programming, events can be described as actions that take place within an application.  Typically these actions are invoked by the user and could include things such as clicking a point on the map, dragging the map in an effort to pan, and changing map types from map to satellite.  These are all examples of user generated events.  In any case, an event is a user or system generated action.  You can write application code that responds to these events in some way.  For example, when the user clicks the map, you could add a GMarker at the point where the user clicked.  Another example could include displaying the latitude, longitude coordinates where the user clicked the map.  The GMap2 and GMarker classes in the Google Maps API have a list of events that they can respond to and we’ll examine these in more detail soon, but first let’s look at the mechanics of how you register an event.


All registration and handling of events occurs through the GEvent class which exposes a number of static methods for these purposes.  A static method is simply a method that is called on the class itself rather than an instance of the class.  In other words, you don’t need to create an instance of GEvent to call it’s methods. 

The addListener( ) method is used to register an event with the system.  For instance, the following code can be used to register the “click” event on GMarker. 

Three required parameters are included with the addListener( ) method.  The first parameter is the source or object that will be responding to the event.  The second parameter is the event that it will listen for.  In this case we’re registering the click event with a marker object.  Our final parameter is a function that will run in response to the event.  In our example, the marker will display an Info Window when clicked.

Removal of listeners can be accomplished through either the removeListener( ) method which removes an individual event or the clearListeners( ) method which will remove all currently active events.

In cases where you need to trigger an event without user input you can call the trigger( ) method which can be used to trigger the function for a particular event. 

Let’s now take a look at some of the more commonly used events associated with a couple  Google Maps classes.

GMap2 Events

  • addmaptype
    • This event is fired when a map type is added to the map.
  • removemaptype
    • This event is fired when a map type is removed from the map.
  • click
    • Triggered when a user clicks the map or an overlay on the map.
  • move
    • Triggered when the map is moving.  This event is triggered continuously as the map is dragged.
  • movestart
    • Triggered at the beginning of the drag.
  • moveend
    • Triggered at the end of the drag
  • zoomend
    • This event is fired when the map reaches a new zoom level. The event handler receives the previous and the new zoom level as arguments.maptypechanged
  • infowindowopen
    • Triggered after the info window is displayed
  • infowindowclose
    • Triggered after the info window is closed
  • infowindowchanged
    • This event is fired when another map type is selected.
  • addoverlay
    • Triggered after an overlay is added to the map
  • removeoverlay
    • Triggered after an overlay is removed from the map
  • clearoverlays
    • Triggered after all overlays are cleared
  • mouseover
    • This event is fired when the user moves the mouse over the map from outside the map.
  • mouseout
    • This event is fired when the user moves the mouse off the map.
  • mousemove
    • This event is fired when the user moves the mouse inside the map.
  • dragstart
    • This event is fired when the user starts dragging the map.
  • drag
    • This event is repeatedly fired while the user drags the map.
  • dragend
    • This event is fired when the user stops dragging the map.


GMarker Events

  • click
    • The click event is frequently used to display an Info Window when the marker is clicked
    • For instance, in a real estate application you might display an Info Window showing an image of the property along with other pertinent information
  • infowindowopen
    • Triggered when the info window is opened above the marker
  • infowindowclose
    • Triggered when the info window above the marker is closed
  • dblclick
    • This event is fired when the marker icon was double-clicked. Notice that this event will not fire for the map, because the map centers on double-click as a hardwired behavior.
  • mousedown
    • This event is fired when the DOM mousedown event is fired on the marker icon. Notice that the marker will stop the mousedown DOM event, so that it doesn't cause the map to start dragging.
  • mouseup
    • This event is fired for the DOM mouseup on the marker. Notice that the marker will not stop the mousedown DOM event, because it will not confuse the drag handler of the map.
  • mouseover
    • This event is fired when the mouse enters the area of the marker icon.
  • mouseout
    • This event is fired when the mouse leaves the area of the marker icon.
  • remove
    • This event is fired when the marker is removed from the map.

 In the final article in this series we will cover AJAX (Asynchronous JavaScript + XML) and how it is revolutionizing the user experience of web mapping applications.  In addition, we’ll also cover various ways to geocode your data for Google Mapping applications.

Author Information
Mr. Pimpler is the owner of Geospatial Training & Consulting, LLC, a provider of virtual and instructor led GIS training opportunities and the author of its popular virtual training course “Google Maps For Your Apps!” and the new PDF book “Google Maps API: The New World of Web Mapping”.  For more information on the Google Maps API or any other training opportunity provided by GeoSpatial Training & Consulting, please visit our website at http://www.geospatialtraining.com

See An Introduction to Google Maps & The Google Maps API (Part 1)

Last Updated ( 02 May 2006 )
< Prev   Next >

 Did you enjoy this article/news and want to stay informed? 
Click to subscribe to the 2X A Week GISuser Today E-Newsletter

Submit Your GIS/Geo News/PR

blog comments powered by Disqus
Geo EDU Tip
To GISP or Not? What Does It Mean To You? 
HOT Devices
Video - Trimble Positions and the Geo Explorer 6000 XH
Social Media Tips
10 Map Services Your Business MUST Be Listed in
Featured Events
  • FOSS4G 2014 - Put on by OSGeo, FOSS4G is the international gathering of open source and geospatial tribes. Join us in Portland, Oregon, USA, Sept 8th-12th
  • Trimble Dimmensions - Trimble Dimensions User Conference is the premier event of the year for professionals wishing to stay on top of the most current information on a wide range of technologies. This educational, networking and hands-on training conference provides insight into how you can achieve greater success in your workplace. Nov 3-5, Las Vegas, NV.
  • InterGeo 2014 - INTERGEO is the world's leading conference trade fair for geodesy, geoinformation and land management. With over half a million event website users and over 16,000 visitors from 92 countries at INTERGEO itself, it is one of the key platforms for industry dialogue around the world - Oct 7-9, 2014, Berlin

 List Your Event Here 

THE GISuser Newsletter

See Recent edition

subscribe GISuser

We won't share your address!

Popular Stuff!

GISuser Site Sponsor

Partner Sites

lidar news



geojobs Geo jobs


A Spatial Media LLC property

Spatial Media, LLC ©2003 - 2013 All rights reserved / Privacy Statement