The following post is a portion of the D3 Tips and Tricks document which it free to download. To use this post in context, consider it with the others in the blog or just
download the pdf and / or the examples from the
downloads page:-)
--------------------------------------------------------
Tooltips have a marvelous duality. They are on one hand a pretty darned useful thing that aids in giving context and information where required and on the other hand, if done with a bit of care, they can look very stylish :-).
Technically, they represent a slight move from what we have been playing with so far into a mildly more complex arena of 'transitions' and 'events'. You can take this one of two ways. Either accept that it just works and implement it as shown, or you will know what s going on and feel free to deride my efforts as those of a rank amateur :-).
The source for the implementation was taken from Mike Bostock's example here;
http://bl.ocks.org/1087001. This was combined with a few other bit's and pieces (the trickiest being working out how to format the displayed date correctly and inserting a line break in the tooltip (which I found here;
https://groups.google.com/forum/?fromgroups=#!topic/d3-js/GgFTf24ltjc (well done to all those participating in that discussion)). I make the assumption that any or all errors that occur in the implementation will be mine, whereas, any successes will be down to the original contributors.
So, just in case there is some degree of confusion, a tooltip (one word or two?) is a discrete piece of information that will pop into view when the mouse is hovered over somewhere specific. Most of us have seen and used them, but I suppose we all tend to call them different things such as 'infotip', 'hint' or 'hover box' I don't know if there's a right name for them, but here's an example of what we're trying to achieve;
You can see the mouse has hovered over one of the scatter plot circles and a tip has appeared that provides the user with the exact date and value for that point.
Now, you may also notice that there's a certain degree of 'fancy' here as the information is bound by a rectangular shape whit rounded corners and a slight opacity. The other piece of 'fancy' which you don't see in a pdf is that when these tool tips appear and disappear, they do so in an elegant fade-in, fade-out way. Purty.
Now, before we get started describing how the code goes together, let's take a quick look at the two technique specifics that I mentioned earlier, 'transitions' and 'events'.
Transitions
From the main d3.js web page (d3js.org) transitions are described as gradually interpolating styles and attributes over time. So what I take that to mean is that if you want to change an object, you can do so be simply specifying the attribute / style end point that you want it to end up with and the time you want it to take and go!
Of course, it's not quite that simple, but luckily, smarter people than I have done some fantastic work describing different aspects of transitions so please see the following for a more complete description of the topic;
Hopefully observing the mouseover and mouseout transitions in the tooltips example will whet your appetite for more!
Events
The other technique is related to mouse 'events'. This describes the browser watching for when 'something' happens with the mouse on the screen and when it does, it takes a specified action. A (probably non-comprehensive) list of the types of events are the following;
mousedown: Triggered by an element when a mouse button is pressed down over it
mouseup: Triggered by an element when a mouse button is released over it
mouseover: Triggered by an element when the mouse comes over it
mouseout: Triggered by an element when the mouse goes out of it
mousemove: Triggered by an element on every mouse move over it.
click: Triggered by a mouse click: mousedown and then mouseup over an element
contextmenu: Triggered by a right-button mouse click over an element.
dblclick: Triggered by two clicks within a short time over an element
How many of these are valid to use within d3 I'm not sure, but I'm willing to bet that there are probably more than those here as well. Please go to
http://javascript.info/tutorial/mouse-events for a far better description of the topic if required.
Get tipping
So, bolstered with a couple of new concepts to consider, let's see how they are enacted in practice.
If we start with our simple-scatter plot graph there are 4 areas in it that we will want to modify (it may be easier to check the tooltips.html file in the example files in the downloads section on d3noob.org).
The first area is the CSS. The following code should be added just before the </style> tag;
div.tooltip {
position: absolute;
text-align: center;
width: 60px;
height: 28px;
padding: 2px;
font: 12px sans-serif;
background: lightsteelblue;
border: 0px;
border-radius: 8px;
pointer-events: none;
}
These styles are defining how our tooltip will appear . Most of them are fairly straight forward. The position of the tooltip is done in absolute measurements, not relative. The text is centre aligned, the height, width and colour of the rectangle is 28px, 60px and lightsteelblue respectively. The 'padding' is an interesting feature that provides a neat way to grow a shape by a fixed amount from a specified size.
We set the boarder to 0px so that it doesn't show up and a neat style (attribute?) called border-radius provides the nice rounded corners on the rectangle.
Lastly, but by no means least, the 'pointer-events: none' line is in place to instruct the mouse event to go "through" the element and target whatever is "underneath" that element instead (Read more here;
https://developer.mozilla.org/en-US/docs/CSS/pointer-events). That means that even if the tooltip partly obscures the circle, the code will stll act as if the mouse is over only the circle.
The second addition is a simple one-liner that should (for forms sake) be placed under the 'parseData' variable declaration;
var formatTime = d3.time.format("%e %B");
This line formats the date when it appears in our tooltip. Without it, the time would default to a disturbingly long combination of temporal details. In the case here we have declared that we want to see the day of the month (
%e) and the full month name(
%B).
The third block of code is the function declaration for 'div'.
var div = d3.select("body").append("div")
.attr("class", "tooltip")
.style("opacity", 0);
We can place that just after the 'valueline' definition in the JavaScript. Again there's not too much here that's surprising. We tell it to attach 'div' to the body element, we set the class to the tooltip class (from the CSS) and we set the opacity to zero. It might sound strange to have the opacity set to zero, but remember, that's the natural state of a tooltip. It will live unseen until it's moment of revelation arrives and it pops up!
The final block of code is slightly more complex and could be described as a mutant version of the neat little bit of code that we used to do the drawing of the dots for the scatter plot. That's because the tooltips are all about the scatter plot circles. Without a circle to 'mouseover', the tooltip never appears :-).
So here's the code that includes the scatter plot drawing (it's included since it's pretty much integral);
svg.selectAll("dot")
.data(data)
.enter().append("circle")
.attr("r", 5)
.attr("cx", function(d) { return x(d.date); })
.attr("cy", function(d) { return y(d.close); })
.on("mouseover", function(d) {
div.transition()
.duration(200)
.style("opacity", .9);
div .html(formatTime(d.date) + "<br/>" + d.close)
.style("left", (d3.event.pageX) + "px")
.style("top", (d3.event.pageY - 28) + "px");
})
.on("mouseout", function(d) {
div.transition()
.duration(500)
.style("opacity", 0);
});
Before we start going through the code, the
example file for tooltips that is on d3noob.org includes a brief
series of comments for the lines that are added or changed from the
scatter plot, so if you want to compare what is going on in context,
that is an option.
The first six lines of the code are a repeat of
the scatter plot drawing script. The only changes are that we've
increased the radius of the circle from 3.5 to 5 (just to make it
easier to mouse over the object) and we've removed the semicolon from
the 'cy' attribute line since the code now has to carry on.
So the additions are broken into to areas that
correspond to the two events. 'mouseover' and 'mouseout'. When the
mouse moves over any of the circles in the scatter plot, the
mouseover code is executed on the 'div' element. When the mouse is
moved off the circle a different set of instructions are executed.
It would be a mistake to think of tooltips in the
plural because there aren't a whole series of individual tooltips
just waiting to appear for their specific circle. There is only one
tooltip that will appear when the mouse moves over a circle. And
depending on what circle it's over, the properties of the tooltip
will alter slightly (in terms of its position and contents).
on.mouseover
The .on("mouseover"
line initiates the introduction of the tooltip. Then we declare the
element we will be introducing ('div') and that we will be applying a
transition to it's introduction (.transition()).
The next two lines describe the transition. It will take 200
milliseconds (.duration(200))
and will result in changing the elements opacity to .9
(.style("opacity",
.9);).
Given that the natural state of our tooltip is an opacity of 0, this
make sense for something appearing, but it doesn't go all the way to
a solid object and it retains a slight transparency just to make it
look less permanent.
The following three lines format our tooltip. The
first one adds an html element that contains our x and y information
(the date and the d.close value). Now this is done in a slightly
strange way. Other tooltips that I have seen have used a '.text'
element instead of a '.html' one, but I have used '.html' in this
case because I wanted to include the line break tag “<br/>”
to separate the date and value. I'm sure there are other ways to do
it, but this worked for me. The other interesting part of this line
is that this is where we call our time formatting function that we
described earlier. The next two lines position the tooltip on the
screen and to do this they grab the x and y coordinates of the mouse
when the event takes place (with the d3.event.pageX and
d3.event.pageY snippets) and apply a correction in the case of the y
coordinate to raise the tooltip up by the same amount as its height
(28 pixels).
on.mouseout
The .on("mouseout"
section is slightly simpler in that it doesn't have to do any fancy
text / html / coordinate stuff. All it has to do is to fade out the
'div' element. And that is done by simply reversing the opacity back
to 0 and setting the duration for the transition to 500 milliseconds
(being slightly longer than the fade-in makes it look slightly cooler
IMHO).
Right, there you go. As a description it's ended
up being a bit of a wall of text I'm afraid. But hopefully between
the explanation and the example code you will get the idea. Please
take the time to fiddle with the settings described here to find the
ones that work for you and in the process you will reinforce some of
the principles that help D3 do it's thing.
I've placed a copy of the file for drawing the
tooltips into the downloads section on d3noob.org with the general
examples as tooltips.html.
Edit: 2014-05-02: After an interesting question below I have added a new post on including an HTML link in out tooltips and
it can be found here.
