com.pietschy.gwt.pectin.client.value.DelegatingValueModel.java Source code

Introduction

Here is the source code for com.pietschy.gwt.pectin.client.value.DelegatingValueModel.java

Source

/*
 * Copyright 2009 Andrew Pietsch 
 *
 * 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.pietschy.gwt.pectin.client.value;

import com.google.gwt.event.logical.shared.HasValueChangeHandlers;
import com.google.gwt.event.logical.shared.ValueChangeEvent;
import com.google.gwt.event.logical.shared.ValueChangeHandler;
import com.google.gwt.event.shared.GwtEvent;
import com.google.gwt.event.shared.HandlerManager;
import com.google.gwt.event.shared.HandlerRegistration;

/**
 *
 */
public class DelegatingValueModel<T> implements MutableValueModel<T>, HasValueChangeHandlers<T> {
    /**
     * Convenience method to create a new instance.
     *
     * @return a new instance;
     */
    public static <T> DelegatingValueModel<T> create() {
        return new DelegatingValueModel<T>();
    }

    /**
     * Convenience method to create a new instance.
     *
     * @param defaultValue the default value for cases where the deleget is null.
     * @return a new instance;
     */
    public static <T> DelegatingValueModel<T> create(T defaultValue) {
        return new DelegatingValueModel<T>(defaultValue);
    }

    /**
     * Convenience method to create a new instance that is preconigured with
     * the specified delegate.
     *
     * @param delegate the delegate.
     * @return a new instance;
     */
    public static <T> DelegatingValueModel<T> create(ValueModel<T> delegate) {
        return new DelegatingValueModel<T>(delegate);
    }

    private HandlerManager handlerManager = new HandlerManager(this);
    private DelegateMonitor delegateChangeMonitor = new DelegateMonitor();

    private T defaultValue;
    private ValueModel<T> delegate;
    private HandlerRegistration registration;

    public DelegatingValueModel() {
    }

    public DelegatingValueModel(T defaultValue) {
        this.defaultValue = defaultValue;
    }

    public DelegatingValueModel(ValueModel<T> delegate) {
        setDelegate(delegate);
    }

    public void setDelegate(ValueModel<T> delegate) {
        if (registration != null) {
            registration.removeHandler();
            // we have to nuke it as we don't create a new one if the delegate
            // is null, and calling removeHandler() twice will barf.
            registration = null;
        }

        this.delegate = delegate;

        if (this.delegate != null) {
            registration = delegate.addValueChangeHandler(delegateChangeMonitor);
        }

        fireValueChanged();
    }

    protected ValueModel<T> getDelegate() {
        return delegate;
    }

    public T getDefaultValue() {
        return defaultValue;
    }

    public T getValue() {
        return delegate == null ? defaultValue : delegate.getValue();
    }

    public void setValue(T value) {
        if (delegate == null) {
            throw new IllegalStateException("delegate is null");
        }

        if (delegate instanceof MutableValueModel) {
            ((MutableValueModel) delegate).setValue(value);
        } else {
            throw new IllegalStateException("delegate doesn't implement MutableValueModel");
        }
    }

    private void fireValueChanged() {
        ValueChangeEvent.fire(DelegatingValueModel.this, getValue());
    }

    public HandlerRegistration addValueChangeHandler(ValueChangeHandler<T> handler) {
        return handlerManager.addHandler(ValueChangeEvent.getType(), handler);
    }

    public void fireEvent(GwtEvent<?> event) {
        handlerManager.fireEvent(event);
    }

    private class DelegateMonitor implements ValueChangeHandler<T> {
        public void onValueChange(ValueChangeEvent<T> event) {
            fireValueChanged();
        }
    }
}