org.ioc.commons.impl.gwt.client.ui.HasPendingOperationsLoaderWrapper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ioc-commons-gwt-impl Show documentation
GWT implementation for ioc-commons artifacts.
There is a newer version: 1.2.1
package org.ioc.commons.impl.gwt.client.ui;

import org.ioc.commons.ui.HasPendingOperationsLoader;
import org.ioc.commons.ui.HasStorage;

import com.google.gwt.user.client.ui.HasVisibility;

/**
 * Wrapper for GWT components into {@link HasPendingOperationsLoader}. Similar
 * to {@link HasLoaderWrapper} but for being used in several proccesses at the
 * same time. It counts how many operation are pending (loading) and keeps
 * visible the loader until all of them have finished.
 * 
 * @author Jesús Lunar Pérez
 * 
 */
public class HasPendingOperationsLoaderWrapper implements HasPendingOperationsLoader {

	private boolean[] previousVisibility;

	private HasVisibility[] notLoadingArray;
	private HasVisibility[] loadingArray;

	private int pendingOps;

	private HasPendingOperationsLoaderWrapper(HasVisibility[] notLoading, HasVisibility[] loading) {
		this.notLoadingArray = notLoading;
		this.loadingArray = loading;
	}

	@Override
	public void clearPendingOperations() {
		setPendingOps(0);
	}

	protected void setPendingOps(int pendingOps) {
		if (pendingOps < 0) {
			pendingOps = 0;
		}
		this.pendingOps = pendingOps;
		boolean loading = this.isLoading();

		if (notLoadingArray != null) {
			for (int i = 0; i < notLoadingArray.length; i++) {
				HasVisibility notLoadingV = notLoadingArray[i];

				if (loading) {
					if (previousVisibility == null || previousVisibility.length != notLoadingArray.length) {
						previousVisibility = new boolean[notLoadingArray.length];
					}

					previousVisibility[i] = notLoadingV.isVisible();

					notLoadingV.setVisible(false);
				} else if (previousVisibility != null && previousVisibility.length == notLoadingArray.length) {
					notLoadingV.setVisible(previousVisibility[i]);
				} else {
					notLoadingV.setVisible(true);
				}
			}
		}

		if (loadingArray != null) {
			for (HasVisibility loadingV : loadingArray) {
				loadingV.setVisible(loading);
			}
		}
	}

	@Override
	public boolean isLoading() {
		return this.pendingOps > 0;
	}

	@Override
	public int getPendingOpCount() {
		return this.pendingOps;
	}

	@Override
	public void operationBeginning() {
		setPendingOps(this.pendingOps + 1);
	}

	@Override
	public void operationFinished() {
		setPendingOps(this.pendingOps - 1);
	}

	/**
	 * It returns an {@link HasPendingOperationsLoader} instance which will turn
	 * into visible an indicator when is loading and will hide it when is not.
	 * 
	 * @param indicator
	 *            The indicator which will appear/disappear
	 * 
	 * @return The {@link HasPendingOperationsLoader} instance
	 */
	public static HasPendingOperationsLoader fromVisible(HasVisibility indicator) {
		return fromVisibles((HasVisibility[]) null, new HasVisibility[] { indicator });
	}

	/**
	 * It returns an {@link HasPendingOperationsLoader} instance which will show
	 * an indicator when is loading and another one when is not.
	 * 
	 * @param notLoadingIndicator
	 *            The visible indicator when is not loading
	 * @param loadingIndicator
	 *            The visible indicator when is loading
	 * 
	 * @return The {@link HasPendingOperationsLoader} instance
	 */
	public static HasPendingOperationsLoader fromVisibles(HasVisibility notLoadingIndicator,
			HasVisibility loadingIndicator) {
		return fromVisibles(new HasVisibility[] { notLoadingIndicator }, new HasVisibility[] { loadingIndicator });
	}

	/**
	 * It returns an {@link HasPendingOperationsLoader} instance which will show
	 * an indicator when is loading and others when is not.
	 * 
	 * @param notLoadingIndicator
	 *            The visible indicator when is not loading
	 * @param loadingIndicators
	 *            The visible indicators when is loading
	 * 
	 * @return The {@link HasPendingOperationsLoader} instance
	 */
	public static HasPendingOperationsLoader fromVisibles(HasVisibility notLoadingIndicator,
			HasVisibility[] loadingIndicators) {
		return fromVisibles(new HasVisibility[] { notLoadingIndicator }, loadingIndicators);
	}

	/**
	 * It returns an {@link HasPendingOperationsLoader} instance which will show
	 * some indicators when is loading and another one when is not.
	 * 
	 * @param notLoadingIndicators
	 *            The visible indicators when is not loading
	 * @param loadingIndicator
	 *            The visible indicator when is loading
	 * 
	 * @return The {@link HasPendingOperationsLoader} instance
	 */
	public static HasPendingOperationsLoader fromVisibles(HasVisibility[] notLoadingIndicators,
			HasVisibility loadingIndicator) {
		return fromVisibles(notLoadingIndicators, new HasVisibility[] { loadingIndicator });
	}

	/**
	 * It returns an {@link HasPendingOperationsLoader} instance which will show
	 * some indicators when is loading and others when is not.
	 * 
	 * @param notLoadingIndicators
	 *            The visible indicators when is not loading
	 * @param loadingIndicators
	 *            The visible indicators when is loading
	 * 
	 * @return The {@link HasPendingOperationsLoader} instance
	 */
	public static HasPendingOperationsLoader fromVisibles(HasVisibility[] notLoadingIndicators,
			HasVisibility[] loadingIndicators) {
		return new HasPendingOperationsLoaderWrapper(notLoadingIndicators, loadingIndicators);
	}

	/**
	 * It returns an {@link HasPendingOperationsLoader} instance which will turn
	 * into visible an indicator when is loading and will hide it when is not.
	 * 
	 * @param indicator
	 *            The indicator which will appear/disappear
	 * 
	 * @return The {@link HasPendingOperationsLoader} instance
	 */
	public static HasPendingOperationsLoader fromVisible(HasVisibility indicator, HasStorage cache) {
		Object cached = cache.retrieve(indicator);
		HasPendingOperationsLoader hasLoader = (cached instanceof HasPendingOperationsLoader) ? (HasPendingOperationsLoader) cached
				: null;
		if (hasLoader == null) {
			hasLoader = fromVisible(indicator);
			cache.store(indicator, hasLoader);
		}

		return hasLoader;
	}

}