Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright 2010 Google Inc.
*
* 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.google.gwt.editor.client.impl;
import com.google.gwt.editor.client.CompositeEditor;
import com.google.gwt.editor.client.Editor;
import com.google.gwt.editor.client.EditorDelegate;
import com.google.gwt.editor.client.EditorError;
import com.google.gwt.editor.client.EditorVisitor;
import com.google.gwt.event.shared.HandlerRegistration;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* A base implementation of EditorDelegate for use by generated types.
*
* @param the type of object being edited
* @param the type of editor
*/
public abstract class AbstractEditorDelegate> implements
EditorDelegate {
/**
* The machinery for attaching and detaching editors from the hierarchy via a
* {@link CompositeEditor}. An instance of a Chain is only created when
* necessary for a given hierarchy type.
*
* @param the component element type
* @param the component editor type
*/
protected class Chain> implements
CompositeEditor.EditorChain {
private final CompositeEditor composedEditor;
private final Class composedElementType;
private final Map> map = new LinkedHashMap>();
/**
* Constructed via
* {@link AbstractEditorDelegate#createChain(CompositeEditor)}.
*/
Chain(CompositeEditor composedEditor, Class composedElementType) {
this.composedEditor = composedEditor;
this.composedElementType = composedElementType;
}
public void accept(EditorVisitor visitor) {
for (AbstractEditorDelegate delegate : map.values()) {
traverse(visitor, delegate);
}
}
public void attach(R object, S subEditor) {
AbstractEditorDelegate subDelegate = map.get(subEditor);
String subPath = path + composedEditor.getPathElement(subEditor);
if (subDelegate == null) {
@SuppressWarnings("unchecked")
AbstractEditorDelegate temp = (AbstractEditorDelegate) createComposedDelegate();
subDelegate = temp;
map.put(subEditor, subDelegate);
addSubDelegate(subDelegate, subPath, subEditor);
} else {
subDelegate.path = subPath;
}
subDelegate.setObject(ensureMutable(object));
traverse(createInitializerVisitor(), subDelegate);
}
public void detach(S subEditor) {
map.remove(subEditor);
}
public R getValue(S subEditor) {
AbstractEditorDelegate subDelegate = map.get(subEditor);
if (subDelegate == null) {
return null;
}
return subDelegate.getObject();
}
void traverse(EditorVisitor visitor, AbstractEditorDelegate delegate) {
R object = delegate.getObject();
new RootEditorContext(delegate, composedElementType, object).traverse(
visitor, delegate);
}
}
protected static String appendPath(String prefix, String path) {
if ("".equals(prefix)) {
return path;
} else {
return prefix + "." + path;
}
}
private boolean dirty;
private Chain editorChain;
private List errors;
private String path;
public abstract void accept(EditorVisitor visitor);
public abstract T getObject();
public String getPath() {
return path;
}
/**
* Just returns the last value passed to {@link #setDirty(boolean)}.
*/
public boolean isDirty() {
return dirty;
}
public void recordError(String message, Object value, Object userData) {
EditorError error = new SimpleError(this, message, value, userData);
errors.add(error);
}
public void recordError(String message, Object value, Object userData,
String extraPath, Editor leafEditor) {
EditorError error = new SimpleError(this, message, value, userData,
extraPath, leafEditor);
errors.add(error);
}
public void setDirty(boolean dirty) {
this.dirty = dirty;
}
public abstract HandlerRegistration subscribe();
/**
* Initialize a sub-delegate whenever one is added to the editor hierarchy.
*/
protected > void addSubDelegate(
AbstractEditorDelegate subDelegate, String path, S subEditor) {
subDelegate.initialize(path, subEditor);
}
protected String appendPath(String path) {
if (path.length() == 0) {
return this.path;
}
return appendPath(this.path, path);
}
protected > void createChain(
Class composedElementType) {
@SuppressWarnings("unchecked")
CompositeEditor editor = (CompositeEditor) getEditor();
editorChain = new Chain(editor, composedElementType);
}
/**
* Only implemented by delegates for a {@link CompositeEditor}.
*/
protected AbstractEditorDelegate createComposedDelegate() {
throw new IllegalStateException();
}
protected EditorVisitor createInitializerVisitor() {
return new Initializer();
}
protected Q ensureMutable(Q object) {
return object;
}
protected abstract E getEditor();
protected Chain getEditorChain() {
return editorChain;
}
protected List getErrors() {
return errors;
}
protected void initialize(String pathSoFar, E editor) {
this.path = pathSoFar;
setEditor(editor);
errors = new ArrayList();
initializeSubDelegates();
}
protected abstract void initializeSubDelegates();
protected abstract void setEditor(E editor);
protected abstract void setObject(T object);
/**
* Indicates whether or not calls to {@link #flush} are expected as part of
* normal operation.
*/
protected boolean shouldFlush() {
return true;
}
}
