Github user dashorst commented on a diff in the pull request:
https://github.com/apache/wicket/pull/151#discussion_r48417286
--- Diff:
wicket-extensions/src/main/java/org/apache/wicket/extensions/ajax/markup/html/AjaxLazyLoadPanel.java
---
@@ -139,56 +182,176 @@ protected void handleCallbackScript(final
IHeaderResponse response,
@Override
protected void onBeforeRender()
{
- if (state == 0)
+ if (state == LoadingState.WAITING_FOR_LAZY_COMPONENT)
{
add(getLoadingComponent(LAZY_LOAD_COMPONENT_ID));
- setState((byte)1);
+ setState(LoadingState.REPLACING_LAZY_COMPONENT);
}
super.onBeforeRender();
}
+ @Override
+ public void onEvent(IEvent<?> event)
+ {
+ super.onEvent(event);
+
+ if (state == LoadingState.REPLACING_LAZY_COMPONENT)
+ {
+ if (isReadyForReplacement())
+ {
+ // create the lazy load component
+ Component component =
getLazyLoadComponent(LAZY_LOAD_COMPONENT_ID);
+
+ // replace the spinner with the new component
+ AjaxLazyLoadPanel.this.replace(component);
+
+ // mark replacement as done
+ setState(LoadingState.REPLACEMENT_COMPLETED);
+
+ // remove ourselves from the timer
+ getLazyLoadTimer().removeLazyLoadPanel(this);
+
+ AjaxRequestTarget target =
getRequestCycle().find(AjaxRequestTarget.class);
+
+ // notify our subclasses of the updated
component
+ onComponentLoaded(component, target);
+
+ // repaint our selves if there's an AJAX
request in play, otherwise let the page
+ // redraw itself
+ if (target != null)
+ {
+ target.add(AjaxLazyLoadPanel.this);
+ }
+ }
+ }
+ }
+
+ @Override
+ protected void onRemove()
+ {
+ super.onRemove();
+
+ // mark replacement as done
+ setState(LoadingState.REPLACEMENT_COMPLETED);
+
+ // remove ourselves from the timer
+ AjaxLazyLoadTimer timer = getLazyLoadTimer();
+ if (timer != null)
+ {
+ timer.removeLazyLoadPanel(this);
+ }
+ }
+
/**
+ * Sets the new LoadingState for this panel.
*
- * @param state
+ * @param newState
*/
- private void setState(final byte state)
+ private void setState(final LoadingState newState)
{
- this.state = state;
+ this.state = newState;
getPage().dirty();
}
/**
+ * Gets the central lazy load timer from the page if one is registered
*
- * @param markupId
- * The components markupid.
- * @return The component that must be lazy created. You may call
setRenderBodyOnly(true) on this
- * component if you need the body only.
+ * @return the central lazy load timer or {@code null}
*/
- public abstract Component getLazyLoadComponent(String markupId);
+ private AjaxLazyLoadTimer getLazyLoadTimer()
+ {
+ return getPage().getMetaData(AJAX_LAZY_LOAD_TIMER);
+ }
/**
- * Called when the placeholder component is replaced with the lazy
loaded one.
- *
- * @param component
- * The lazy loaded component
- * @param target
- * The Ajax request handler
+ * Sets the central lazy load timer on the page
+ *
+ * @param timer
+ * the timer to set
*/
- protected void onComponentLoaded(Component component, AjaxRequestTarget
target)
+ private void setLazyLoadTimer(AjaxLazyLoadTimer timer)
{
+ getPage().setMetaData(AJAX_LAZY_LOAD_TIMER, timer);
}
/**
- * @param markupId
- * The components markupid.
- * @return The component to show while the real component is being
created.
+ * @deprecated No longer called as the AjaxLazyLoadPanel uses a central
AJAX timer, and it
+ * doesn't make sense to modify the single timer from
multiple panels
*/
- public Component getLoadingComponent(final String markupId)
+ @SuppressWarnings("javadoc")
+ @Deprecated
+ protected void updateAjaxAttributes(AjaxRequestAttributes attributes)
{
- IRequestHandler handler = new ResourceReferenceRequestHandler(
- AbstractDefaultAjaxBehavior.INDICATOR);
- return new Label(markupId, "<img alt=\"Loading...\" src=\"" +
- RequestCycle.get().urlFor(handler) +
"\"/>").setEscapeModelStrings(false);
}
+ /**
+ * Allows subclasses to change the callback script if needed.
+ *
+ * @param response
+ * the current response that writes to the header
+ * @param callbackScript
+ * the JavaScript to write in the header
+ * @param component
+ * the component which produced the callback script
+ */
+ protected void handleCallbackScript(final IHeaderResponse response,
+ final CharSequence callbackScript, final Component component)
+ {
+ response.render(OnDomReadyHeaderItem.forScript(callbackScript));
+ }
+
+ /**
+ * The AJAX timer for updating the AjaxLazyLoadPanel. Is designed to be
a page-local singleton
+ * keeping track of multiple LazyLoadPanels using reference counting.
+ */
+ private static class AjaxLazyLoadTimer extends AbstractAjaxTimerBehavior
+ {
+ private static final long serialVersionUID = 1L;
+
+ private final List<AjaxLazyLoadPanel> lazyLoadPanels = new
ArrayList<>();
+
+ public AjaxLazyLoadTimer()
+ {
+ super(Duration.ONE_SECOND);
--- End diff --
Can't. The timer is a single instance for all ALLP's on a page. The reason
for using just one timer is that when you have more, you get a barrage of
events fired at your server and you don't want that (I've seen the horror). A
single timer is the best compromise for this. I've thought about increasing the
timer the longer the wait takes, but decided against it because as a user you
want direct feedback. A timer of a second is a rather nice compromise between
request pressure on the server and wait time for the user.
---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at [email protected] or file a JIRA ticket
with INFRA.
---
