In my earlier articles on animation, I discussed various slide, grow and flip transitions for items and containers. In this article I want to discuss
a fade animation and specifically the use of fades and auto-dismissal for informational dialogs. If you use
a Mac, you may be familiar with Growl as
a notification system, and the nice way that messages that are informational just fade out after
a few seconds. So in this blog entry I wanted to discuss how we could make an ADF popup behave in the same way. This can be an effective way of communicating information to the user without "getting in the way" with modal alerts. This of course, has been done before, but everything I've seen previously requires something like JQuery to be in the mix when we don't really need it to be.
The solution I've put together is nice and generic and will work with either <af:panelWindow> or <af:dialog> as
a the child of the popup. In terms of usage it's pretty simple to use we just need to ensure that the popup itself has clientComponent is set to true and includes the animation JavaScript (animateFadingPopup) on
a popupOpened event:
<af:popup id="pop1" clientComponent="true">
<af:panelWindow title="
A Fading Message...">
...
</af:panelWindow>
<af:clientListener method="animateFadingPopup" type="popupOpened"/>
</af:popup>
The popup can be invoked in the normal way using showPopupBehavior or JavaScript, no special code is required there.
As
a further twist you can include an additional clientAttribute called preFadeDelay to define
a delay before the fade itself starts (the default is 5 seconds) . To set the delay to just 2 seconds for example:
<af:popup ...>
...
<af:clientAttribute name="preFadeDelay" value="2"/>
<af:clientListener method="animateFadingPopup" type="popupOpened"/>
</af:popup>
The Animation Styles
As before, we have
a couple of CSS Styles which define the animation, I've put these into the skin in my case, and, as in the other articles, I've only defined the transitions for WebKit browsers (Chrome, Safari) at the moment. In this case, the fade is timed at 5 seconds in duration.
.popupFadeReset {
opacity: 1;
}
.popupFadeAnimate {
opacity: 0;
-webkit-transition: opacity 5s ease-in-out;
}
As you can see here, we are achieving the fade by simply setting the CSS opacity property.
The JavaScript
The final part of the puzzle is, of course, the JavaScript, there are four functions, these are generic (apart from the Style names which, if you've changed above, you'll need to reflect here):
The initial function invoked from the popupOpened event, animateFadingPopup which starts
a timer and provides the initial delay before we start to fade the popup.
The function that applies the fade animation to the popup - initiatePopupFade.
The callback function - closeFadedPopup used to reset the style class and correctly hide the popup so that it can be invoked again and again.
A utility function - findFadeContainer, which is responsible for locating the correct child component of the popup to actually apply the style to.
Function - animateFadingPopup
This function, as stated is the one hooked up to the popupOpened event via
a clientListener. Because of when the code is called it does not actually matter how you launch the popup, or if the popup is re-used from multiple places. All usages will get the fade behavior.
/**
* Client listener which will kick off the animation to fade the dialog and register
*
a callback to correctly reset the popup once the animation is complete
* @param event
*/
function animateFadingPopup(event) {
var fadePopup = event.getSource();
var fadeCandidate = false;
//Ensure that the popup is initially Opaque
//This handles the situation where the user has dismissed
//the popup whilst it was in the process of fading
var fadeContainer = findFadeContainer(fadePopup);
if (fadeContainer != null) {
fadeCandidate = true;
fadeContainer.setStyleClass("popupFadeReset");
}
//Only continue if we can actually fade this popup
if (fadeCandidate) {
//See if
a delay has been specified
var waitTimeSeconds = event.getSource().getProperty('preFadeDelay');
//Default to 5 seconds if not supplied
if (waitTimeSeconds == undefined) {
waitTimeSeconds = 5;
}
// Now call the fade after the specified time
var fadeFunction = function () {
initiatePopupFade(fadePopup);
};
var fadeDelayTimer = setTimeout(fadeFunction, (waitTimeSeconds * 1000));
}
}
The things to note about this function is the initial check that we have to do to ensure that the container is currently visible and reset it's style to ensure that it is. This is to handle the situation where the popup has begun the fade, and yet the user has still explicitly dismissed the popup before it's complete and in doing so has prevented the callback function (described later) from executing. In this particular situation the initial display of the dialog will be (apparently) missing it's normal animation but at least it becomes visible to the user (and most users will probably not notice this difference in any case).
You'll notice that the style that we apply to reset the opacity - popupFadeReset, is not applied to the popup component itself but rather the dialog or panelWindow within it. More about that in the description of the next function findFadeContainer().
Finally, assuming that we have
a suitable candidate for fading,
a JavaScript timer is started using the specified preFadeDelay wait time (or 5 seconds if that was not supplied). When this timer expires then the main animation styleclass will be applied using the initiatePopupFade() function
Function - findFadeContainer
As
a component, the <af:popup> does not support styleClass attribute, so we can't apply the animation style directly. Instead we have to look for the container within the popup which defines the window object that can have
a style attached. This is achieved by the following code:
/**
* The thing we actually fade will be the only child
* of the popup assuming that this is
a dialog or window
* @param popup
* @return the component, or null if this is not valid for fading
*/
function findFadeContainer(popup) {
var children = popup.getDescendantComponents();
var fadeContainer = children[0];
if (fadeContainer != undefined) {
var compType = fadeContainer.getComponentType();
if (compType == "oracle.adf.RichPanelWindow"
|| compType == "oracle.adf.RichDialog") {
return fadeContainer;
}
}
return null;
}
So what we do here is to grab the first child component of the popup and check its type. Here I decided to limit the fade behaviour to only <af:dialog> and <af:panelWindow>. This was deliberate. If we apply the fade to say an <af:noteWindow> you would see the text inside the balloon fade, but the balloon itself would hang around until the fade animation was over and then hide. It would of course be possible to make the code smarter to walk up the DOM tree to find the correct <div> to apply the style to in order to hide the whole balloon, however, that means that this JavaScript would then need to have knowledge of the generated DOM structure, something which may change from release to release, and certainly something to avoid. So, all in all, I think that this is an OK restriction and frankly it's windows and dialogs that I wanted to fade anyway, not balloons and menus. You could of course extend this technique and handle the other types should you really want to.
One thing to note here is the selection of the first (children[0]) child of the popup. It does not matter if there are non-visible children such as clientListener before the <af:dialog> or <af:panelWindow> within the popup, they are not included in this array, so picking the first element in this way seems to be fine, no matter what the underlying ordering is within the JSF source. If you wanted
a super-robust version of the code you might want to iterate through the children array of the popup to check for the right type, again it's up to you.
Function - initiatePopupFade
On to the actual fading. This is actually very simple and at it's heart, just the application of the popupFadeAnimate style to the correct component and then registering
a callback to execute once the fade is done.
/**
* Function which will kick off the animation to fade the dialog and register
*
a callback to correctly reset the popup once the animation is complete
* @param popup the popup we are animating
*/
function initiatePopupFade(popup) {
//Only continue if the popup has not already been dismissed
if (popup.isPopupVisible()) {
//The skin styles that define the animation
var fadeoutAnimationStyle = "popupFadeAnimate";
var fadeAnimationResetStyle = "popupFadeReset";
var fadeContainer = findFadeContainer(popup);
if (fadeContainer != null) {
var fadeContainerReal = AdfAgent.AGENT.getElementById(fadeContainer.getClientId());
//Define the callback this will correctly reset the popup once it's disappeared
var fadeCallbackFunction = function (event) {
closeFadedPopup(popup, fadeContainer, fadeAnimationResetStyle);
event.target.removeEventListener("webkitTransitionEnd", fadeCallbackFunction);
};
//Initiate the fade
fadeContainer.setStyleClass(fadeoutAnimationStyle);
//Register the callback to execute once fade is done
fadeContainerReal.addEventListener("webkitTransitionEnd", fadeCallbackFunction, false);
}
}
}
I've added some extra checks here though. First of all we only start the whole process if the popup is still visible. It may be that the user has closed the popup before the delay timer has finished so there is no need to start animating in that case. Again we use the findFadeContainer() function to locate the correct component to apply the style to, and additionally we grab the DOM id that represents that container. This physical ID is required for the registration of the callback function. The closeFadedPopup() call is then registered on the callback so as to correctly close the now transparent (but still there) popup.
Function - closeFadedPopup
The final function just cleans things up:
/**
* Callback function to correctly cancel and reset the style in the popup
* @param popup id of the popup so we can close it properly
* @param contatiner the window / dialog within the popup to actually style
* @param resetStyle the syle that sets the opacity back to solid
*/
function closeFadedPopup(popup, container, resetStyle) {
container.setStyleClass(resetStyle);
popup.cancel();
}
First of all we reset the style to make the popup contents opaque again and then we cancel the popup. This will ensure that any of your user code that is waiting for
a popup cancelled event will actually get the event, additionally if you have done this as
a modal window / dialog it will ensure that the glasspane is dismissed and you can interact with the UI again.
What's Next?
There are several ways in which this technique could be used, I've been working on
a popup here, but you could apply the same approach to in-line messages. As this code (in the popup case) is generic it will make s pretty nice declarative component and maybe, if I get time, I'll look at constructing
a formal Growl component using
a combination of this technique, and active data push. Also, I'm sure the above code can be improved
a little too. Specifically things like registering
a popup cancelled listener to handle the style reset so that we don't loose the subtle animation that takes place when the popup is opened in that situation where the user has closed the in-fade dialog.
