com.github.gwtbootstrap.client.ui.base.AlertBase Maven / Gradle / Ivy

Go to download
/*
 *  Copyright 2012 GWT-Bootstrap
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package com.github.gwtbootstrap.client.ui.base;

import com.github.gwtbootstrap.client.ui.Close;
import com.github.gwtbootstrap.client.ui.constants.AlertType;
import com.github.gwtbootstrap.client.ui.constants.Constants;
import com.github.gwtbootstrap.client.ui.constants.DismissType;
import com.github.gwtbootstrap.client.ui.event.ClosedEvent;
import com.github.gwtbootstrap.client.ui.event.ClosedHandler;
import com.github.gwtbootstrap.client.ui.event.HasCloseHandlers;
import com.google.gwt.dom.client.Element;
import com.google.gwt.event.logical.shared.CloseEvent;
import com.google.gwt.event.logical.shared.CloseHandler;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.safehtml.shared.SafeHtmlUtils;
import com.google.gwt.user.client.ui.HTMLPanel;
import com.google.gwt.user.client.ui.HasWidgets;

/**
 * Base class for Alert widgets.
 * 
 * @author Dominik Mayer
 * @author Carlos Alexandro Becker
 * 
 * @see Bootstrap documentation
 * 
 * @since 2.0.4.0
 */
public abstract class AlertBase extends HtmlWidget implements IsAnimated,
		HasCloseHandlers, HasType {
	
	private Close close;
	
	private HTMLPanel closeReplacement = new HTMLPanel("span", "");
	
	private HTMLPanel headingContainer = new HTMLPanel("span", "");
	
	private HTMLPanel container;
	
	private boolean fade;
	
	private boolean hasClose;
	
	/**
	 * Initializes an Alert with a close icon.
	 */
	public AlertBase() {
		this("", true);
	}
	
	/**
	 * Initializes an Alert with a inner HTML.
	 * 
	 * @param html
	 *           inner HTML
	 */
	public AlertBase(String html) {
		this(html, true);
	}
	
	/**
	 * Initializes an Alert with an optional close icon.
	 * 
	 * @param html
	 *           inner HTML
	 * @param hasClose
	 *           whether the Alert should have a close icon.
	 */
	public AlertBase(String html, boolean hasClose) {
		super("div", "");
		
		super.add(closeReplacement);
		super.add(headingContainer);
		container = new HTMLPanel("span", html);
		super.add(container);
		super.setStyleName(Constants.ALERT);
		setClose(hasClose);
	}
	
	/**
	 * Initializes an Alert of given Type with a close icon.
	 * 
	 * @param type
	 *           of the Alert
	 */
	public AlertBase(AlertType type) {
		this();
		setType(type);
	}
	
	/**
	 * Sets whether the Alert has a close icon or not.
	 * 
	 * @param hasClose
	 *           false if you don't want to have a close icon.
	 *           Default: true
	 */
	public void setClose(boolean hasClose) {
		
		this.hasClose = hasClose;
		
		if (!isAttached()) {
			return;
		}
		
		if (hasClose) {
			if (close == null) {
				close = new Close(DismissType.ALERT);
				getElement().replaceChild(close.getElement(), closeReplacement.getElement());
			}
		} else {
			if (close != null) {
				getElement().replaceChild(closeReplacement.getElement(), close.getElement());
				close = null;
			}
		}
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void onAttach() {
		super.onAttach();
		setClose(hasClose);
		configure(getElement());
		setHandlerFunctions(getElement());
	}
	
	/**
	 * has Close
	 * 
	 * @return true:has close false:does not has close
	 */
	public boolean hasClose() {
		return hasClose;
	}
	
	/**
	 * Gets heading's container widget
	 * 
	 * @return heading's container
	 */
	protected HasWidgets getHeadingContainer() {
		return headingContainer;
	}
	
	/**
	 * This method is called immediately when the widget's close method is
	 * executed.
	 */
	// TODO: Get the source element from javascript
	protected void onClose() {
		CloseEvent.fire(this, this);
	}
	
	/**
	 * This method is called once the widget is completely closed.
	 */
	// TODO: Get the source element from javascript
	protected void onClosed() {
		ClosedEvent.fire(this, this);
	}
	
	/**
	 * Sets the type of the Alert.
	 * 
	 * @param type
	 */
	public void setType(AlertType type) {
		StyleHelper.changeStyle(this, type, AlertType.class);
	}
	
	/**
	 * Sets the text of an optional heading. The implementation depends on the
	 * subclass.
	 * 
	 * @param text
	 *           the new heading
	 */
	public void setHeading(String text) {
		headingContainer.clear();
		headingContainer.add(new HTMLPanel("span", text));
	}
	
	/**
	 * Sets whether the Alert should be animated.
	 * 
	 * @param animated
	 *           true if the Alert should fade out. Default: false
	 */
	public void setAnimation(boolean animated) {
		this.fade = animated;
		setFade();
	}
	
	/**
	 * {@inheritDoc}
	 */
	public boolean getAnimation() {
		return fade;
	}
	
	/**
	 * Delete the whole content of the Alert. This includes text, heading and
	 * close icon.
	 */
	@Override
	public void clear() {
		container.clear();
	}
	
	/**
	 * Sets the classes that define whether the Alert fades or not.
	 */
	private void setFade() {
		if (fade) {
			addStyleName("fade");
			addStyleName("in");
		} else {
			removeStyleName("fade");
			removeStyleName("in");
		}
	}
	
	/**
	 * {@inheritDoc}
	 */
	public String getText() {
		return container.getElement().getInnerText();
	}
	
	/**
	 * {@inheritDoc}
	 */
	public void setText(String text) {
		setHTML(SafeHtmlUtils.htmlEscape(text));
	}
	
	/**
	 * {@inheritDoc}
	 */
	public String getHTML() {
		return container.getElement().getInnerHTML();
	}
	
	public void setHTML(String html) {
		container.clear();
		container.add(new HTMLPanel("span", html));
	}
	
	/**
	 * Close this alert.
	 */
	public void close() {
		close(getElement());
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	public HandlerRegistration addCloseHandler(CloseHandler handler) {
		return addHandler(handler, CloseEvent.getType());
	}
	
	/**
	 * {@inheritDoc}
	 */
	@Override
	public HandlerRegistration addClosedHandler(ClosedHandler handler) {
		return addHandler(handler, ClosedEvent.getType());
	}
	
	//@formatter:off

    /**
     * Adds the Java functions that fire the Events to document. It is a
     * convenience method to have a cleaner code later on.
     */
    // TODO: Add autoTriggered feature in order to support autoClosed events. See {@link Modal}.
    private void setHandlerFunctions(Element e) {
   	 
    }
    /*-{
        var that = this;
        var $e = $wnd.jQuery(e);
        $e.bind('close', function () {
                [email protected]::onClose()();
        });
        $e.bind('closed', function () {
                [email protected]::onClosed()();
        });
    }-*/;

    private void configure(Element e) {
   	 
    }
    /*-{
        $wnd.jQuery(e).alert(e);
    }-*/;

    private void close(Element e) {
   	 // no-op
    }
    /*-{
        $wnd.jQuery(e).alert('close');
    }-*/;
    //@formatter:on
	
}