Find Yourself with the Google Maps API

I don't think a day goes by that I don't use Google to find something, and
lately, I've seen an increasing number of businesses that post Google maps
to their locations on their Web sites. Sometimes, these companies even
go so far as to put little push-pins on the map indicating each of their
locations, which makes things very convenient for navigationally
challenged people like myself.

I guess it would be possible to take a screenshot of a Google map and post
it on a company Web site. I also guess you could open that image up in the
GIMP and manually add a bunch of push-pins. Additionally, I guess you could use
an image map to make the push-pins clickable and interactive. Yes, you could
do things this way, and in a pinch, it might make sense, but
it sure wouldn't be as much fun as using the Google Maps API and doing it
right.

With the Google Maps API, you can create a map centered at a particular
location. You can place colored push pins anywhere on the map, and you can
draw geometric shapes on the map. Perhaps you even want to draw borders around
delivery regions or school districts. The Google Maps API is incredibly
powerful, and I've scratched the only surface myself.

However, before you can get started, you need to get an API key by
registering with Google. This registration is free, and you receive your key
instantly. You do, however, have to agree to some usage restrictions. Most
of the restrictions seem reasonable. The only surprise is the Web site
that uses the Google Maps API must be publicly accessible; it can't be on
an intranet nor can it be password-protected. If you need to create an
application that will not be publicly accessible, you can make other
arrangements with Google. To sign up for a key, point a browser at
code.google.com/apis/maps/signup.html. You will be
asked for your Web site's
domain name, and you'll need a separate key for each domain.

Lines 1–14 are simple boilerplate HTML. Note that I include some in-line
styling for a div container called “map”. Here I'm mostly just
interested in setting the size of the resulting rectangle.

Lines 15–17 are where you load the Google Maps API. The section of the URI
that looks like “v=3” indicates that I'm using version 3 of the
API. This is also where you include the API key you obtained earlier.
Finally, you see the “sensor=false” section of the URI. This
indicates that I'm not using any type of location sensor, such as a GPS,
to select the appropriate map. Accurately configuring this field is
required by the Google Maps API EULA.

The JavaScript program that I wrote to load and manipulate the map is
loaded on line 19. On line 23, I arrange for an initialization function
that I wrote to be called when the page finishes loading and another
function, that Google provides, when I close the page. I discuss the
initialize() function shortly.

The rest of the HTML simply creates a container (mentioned earlier) to hold
the map and a few other containers to hold debugging information. You
might not want to display this information in a production
application, but it's instructional to see what type of information is
available from the API and what methods are available to the programmer for
keeping the display up to date as the user interacts with the map.

The rest of the map is created in JavaScript, so let's take a look at
Listing 2.

In lines 1 and 2, I create a global variable to hold the “map”
object that the API will create. I also configure the latitude and
longitude to point the map.

The initialize() function is found in lines 4–27 and does all the work
of creating the map. In lines 5–10, I test to make sure that the user's
Web client is able to display the map, and if so, I create the map object.
Lines 12–18 configure the map. First, I select the location for the
map to display. Then, I add the map type and map navigation controls. The
map type control allows the user to select between a simple map, satellite
map or hybrid map. The map navigation control allows the user to pan
the map around and to zoom in and out. Finally, I configure the map to
display as the hybrid map by default.

The update_gui() function referred to on lines 14, 20 and 26 simply
updates the debugging information below the map and probably wouldn't be
used in a production application. Line 20 is interesting because it
demonstrates how to have your application react when the user scrolls or
zooms the map to other locations. In this case, the application simply
updates the lat/long coordinates below the map. I discuss the
update_gui() function a bit more later.

At this point, if you did nothing else, you'd have a map that users could
interact with. They'd be able to select the type of map,
move it around and zoom in and out. But, let's
go a bit further.

The ajax_get() function called on lines 22 and 24 isn't included in Listing
2, but it's relatively easy to write. This function simply accepts a
URL and the name of a JavaScript function as parameters. Then, the function
makes an AJAX call and fetches the data at the given URL. This data is
assumed to be XML, which is passed to the indicated function.

The parse_markers() function referenced on line 22 accepts an XML string
that describes where to put markers on the map. This XML resembles Listing
3. As you can see, it's simply a list of assets; each asset has an ID, a
name, a description and a lat/long location.

As Linux continues to play an ever increasing role in corporate data centers and institutions, ensuring the integrity and protection of these systems must be a priority. With 60% of the world's websites and an increasing share of organization's mission-critical workloads running on Linux, failing to stop malware and other advanced threats on Linux can increasingly impact an organization's reputation and bottom line.

Most companies incorporate backup procedures for critical data, which can be restored quickly if a loss occurs. However, fewer companies are prepared for catastrophic system failures, in which they lose all data, the entire operating system, applications, settings, patches and more, reducing their system(s) to “bare metal.” After all, before data can be restored to a system, there must be a system to restore it to.

In this one hour webinar, learn how to enhance your existing backup strategies for better disaster recovery preparedness using Storix System Backup Administrator (SBAdmin), a highly flexible bare-metal recovery solution for UNIX and Linux systems.