@@ -71,7 +71,7 @@ | |||
<!-- <disableClassMetadata>true</disableClassMetadata> --> | |||
<disableCastChecking>true</disableCastChecking> | |||
<modules> | |||
<module>gwtquery.jsquery.JsQueryXs</module> | |||
<module>com.google.gwt.query.jsquery.JsQueryApi</module> | |||
</modules> | |||
</configuration> | |||
<executions> |
@@ -0,0 +1,834 @@ | |||
/* | |||
* Copyright 2007 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.dev.javac; | |||
import com.google.gwt.core.ext.Generator; | |||
import com.google.gwt.core.ext.GeneratorContext; | |||
import com.google.gwt.core.ext.GeneratorContextExt; | |||
import com.google.gwt.core.ext.GeneratorExt; | |||
import com.google.gwt.core.ext.GeneratorExtWrapper; | |||
import com.google.gwt.core.ext.PropertyOracle; | |||
import com.google.gwt.core.ext.TreeLogger; | |||
import com.google.gwt.core.ext.UnableToCompleteException; | |||
import com.google.gwt.core.ext.linker.Artifact; | |||
import com.google.gwt.core.ext.linker.ArtifactSet; | |||
import com.google.gwt.core.ext.linker.GeneratedResource; | |||
import com.google.gwt.core.ext.linker.impl.StandardGeneratedResource; | |||
import com.google.gwt.core.ext.typeinfo.JClassType; | |||
import com.google.gwt.core.ext.typeinfo.TypeOracle; | |||
import com.google.gwt.dev.cfg.ModuleDef; | |||
import com.google.gwt.dev.javac.rebind.CachedRebindResult; | |||
import com.google.gwt.dev.javac.rebind.RebindResult; | |||
import com.google.gwt.dev.javac.rebind.RebindRuleResolver; | |||
import com.google.gwt.dev.javac.rebind.RebindStatus; | |||
import com.google.gwt.dev.resource.ResourceOracle; | |||
import com.google.gwt.dev.util.DiskCache; | |||
import com.google.gwt.dev.util.Util; | |||
import com.google.gwt.dev.util.collect.HashSet; | |||
import com.google.gwt.dev.util.collect.IdentityHashMap; | |||
import com.google.gwt.dev.util.log.speedtracer.CompilerEventType; | |||
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger; | |||
import com.google.gwt.dev.util.log.speedtracer.SpeedTracerLogger.Event; | |||
import com.google.gwt.util.tools.Utility; | |||
import java.io.ByteArrayOutputStream; | |||
import java.io.File; | |||
import java.io.FileOutputStream; | |||
import java.io.IOException; | |||
import java.io.OutputStream; | |||
import java.io.PrintWriter; | |||
import java.io.StringWriter; | |||
import java.util.ArrayList; | |||
import java.util.Collection; | |||
import java.util.HashMap; | |||
import java.util.List; | |||
import java.util.Map; | |||
import java.util.Map.Entry; | |||
import java.util.Set; | |||
import java.util.SortedSet; | |||
/** | |||
* Manages generators and generated units during a single compilation. | |||
*/ | |||
public class StandardGeneratorContext implements GeneratorContextExt { | |||
/** | |||
* Extras added to {@link GeneratedUnit}. | |||
*/ | |||
private static interface Generated extends GeneratedUnit { | |||
void abort(); | |||
void commit(TreeLogger logger); | |||
/** | |||
* Returns the strong hash of the source. | |||
*/ | |||
String getStrongHash(); | |||
String getTypeName(); | |||
} | |||
/** | |||
* This generated unit acts as a normal generated unit as well as a buffer | |||
* into which generators can write their source. A controller should ensure | |||
* that source isn't requested until the generator has finished writing it. | |||
* This version is backed by {@link StandardGeneratorContext#diskCache}. | |||
*/ | |||
private static class GeneratedUnitImpl implements Generated { | |||
/** | |||
* A token to retrieve this object's bytes from the disk cache. | |||
*/ | |||
protected long sourceToken = -1; | |||
private long creationTime; | |||
private String strongHash; // cache so that refreshes work correctly | |||
private StringWriter sw; | |||
private final String typeName; | |||
public GeneratedUnitImpl(StringWriter sw, String typeName) { | |||
this.typeName = typeName; | |||
this.sw = sw; | |||
} | |||
public void abort() { | |||
sw = null; | |||
} | |||
/** | |||
* Finalizes the source and adds this generated unit to the host. | |||
*/ | |||
public void commit(TreeLogger logger) { | |||
String source = sw.toString(); | |||
System.out.println(">>>>> \n" + source); | |||
strongHash = Util.computeStrongName(Util.getBytes(source)); | |||
sourceToken = diskCache.writeString(source); | |||
sw = null; | |||
creationTime = System.currentTimeMillis(); | |||
} | |||
public long creationTime() { | |||
return creationTime; | |||
} | |||
public String getSource() { | |||
if (sw != null) { | |||
throw new IllegalStateException("source not committed"); | |||
} | |||
return diskCache.readString(sourceToken); | |||
} | |||
public long getSourceToken() { | |||
if (sw != null) { | |||
throw new IllegalStateException("source not committed"); | |||
} | |||
return sourceToken; | |||
} | |||
public String getStrongHash() { | |||
return strongHash; | |||
} | |||
public String getTypeName() { | |||
return typeName; | |||
} | |||
public String optionalFileLocation() { | |||
return null; | |||
} | |||
} | |||
/** | |||
* This generated unit acts as a normal generated unit as well as a buffer | |||
* into which generators can write their source. A controller should ensure | |||
* that source isn't requested until the generator has finished writing it. | |||
* This version is backed by an explicit generated file. | |||
*/ | |||
private static class GeneratedUnitWithFile extends GeneratedUnitImpl { | |||
private final File file; | |||
public GeneratedUnitWithFile(File file, StringWriter pw, String typeName) { | |||
super(pw, typeName); | |||
this.file = file; | |||
} | |||
@Override | |||
public void commit(TreeLogger logger) { | |||
super.commit(logger); | |||
FileOutputStream fos = null; | |||
try { | |||
fos = new FileOutputStream(file); | |||
diskCache.transferToStream(sourceToken, fos); | |||
} catch (IOException e) { | |||
logger.log(TreeLogger.WARN, "Error writing out generated unit at '" | |||
+ file.getAbsolutePath() + "': " + e); | |||
} finally { | |||
Utility.close(fos); | |||
} | |||
} | |||
@Override | |||
public String optionalFileLocation() { | |||
return file.exists() ? file.getAbsolutePath() : null; | |||
} | |||
} | |||
/** | |||
* Manages a resource that is in the process of being created by a generator. | |||
*/ | |||
private static class PendingResource extends OutputStream { | |||
private ByteArrayOutputStream baos = new ByteArrayOutputStream(); | |||
private final String partialPath; | |||
public PendingResource(String partialPath) { | |||
this.partialPath = partialPath; | |||
} | |||
public void abort() { | |||
baos = null; | |||
} | |||
public String getPartialPath() { | |||
return partialPath; | |||
} | |||
public byte[] takeBytes() { | |||
byte[] result = baos.toByteArray(); | |||
baos = null; | |||
return result; | |||
} | |||
@Override | |||
public void write(byte[] b) throws IOException { | |||
if (baos == null) { | |||
throw new IOException("stream closed"); | |||
} | |||
baos.write(b); | |||
} | |||
@Override | |||
public void write(byte[] b, int off, int len) throws IOException { | |||
if (baos == null) { | |||
throw new IOException("stream closed"); | |||
} | |||
baos.write(b, off, len); | |||
} | |||
@Override | |||
public void write(int b) throws IOException { | |||
if (baos == null) { | |||
throw new IOException("stream closed"); | |||
} | |||
baos.write(b); | |||
} | |||
} | |||
private static DiskCache diskCache = DiskCache.INSTANCE; | |||
private static final Map<String, CompilerEventType> eventsByGeneratorType = | |||
new HashMap<String, CompilerEventType>(); | |||
static { | |||
eventsByGeneratorType.put( | |||
"com.google.gwt.resources.rebind.context.InlineClientBundleGenerator", | |||
CompilerEventType.GENERATOR_CLIENT_BUNDLE); | |||
eventsByGeneratorType.put("com.google.gwt.i18n.rebind.LocalizableGenerator", | |||
CompilerEventType.GENERATOR_I18N); | |||
eventsByGeneratorType.put("com.google.gwt.i18n.rebind.LocaleInfoGenerator", | |||
CompilerEventType.GENERATOR_I18N); | |||
eventsByGeneratorType.put("com.google.gwt.i18n.rebind.CurrencyListGenerator", | |||
CompilerEventType.GENERATOR_I18N); | |||
eventsByGeneratorType.put("com.google.gwt.i18n.rebind.CustomDateTimeFormatGenerator", | |||
CompilerEventType.GENERATOR_I18N); | |||
eventsByGeneratorType.put("com.google.gwt.user.rebind.rpc.ServiceInterfaceProxyGenerator", | |||
CompilerEventType.GENERATOR_RPC); | |||
eventsByGeneratorType.put("com.google.gwt.rpc.rebind.RpcServiceGenerator", | |||
CompilerEventType.GENERATOR_RPC); // deRPC | |||
eventsByGeneratorType.put("com.google.gwt.uibinder.rebind.UiBinderGenerator", | |||
CompilerEventType.GENERATOR_UIBINDER); | |||
eventsByGeneratorType.put("com.google.gwt.inject.rebind.GinjectorGenerator", | |||
CompilerEventType.GENERATOR_GIN); | |||
} | |||
private final ArtifactSet allGeneratedArtifacts; | |||
private final Map<String, GeneratedUnit> committedGeneratedCups = | |||
new HashMap<String, GeneratedUnit>(); | |||
private CompilationState compilationState; | |||
private Class<? extends Generator> currentGenerator; | |||
private final File genDir; | |||
private final Map<Class<? extends Generator>, Generator> generators = | |||
new IdentityHashMap<Class<? extends Generator>, Generator>(); | |||
private final ModuleDef module; | |||
private ArtifactSet newlyGeneratedArtifacts = new ArtifactSet(); | |||
private final Set<String> newlyGeneratedTypeNames = new HashSet<String>(); | |||
private final Map<String, PendingResource> pendingResources = | |||
new HashMap<String, PendingResource>(); | |||
private transient PropertyOracle propOracle; | |||
private RebindRuleResolver rebindRuleResolver; | |||
private final Map<PrintWriter, Generated> uncommittedGeneratedCupsByPrintWriter = | |||
new IdentityHashMap<PrintWriter, Generated>(); | |||
private CachedRebindResult cachedRebindResult = null; | |||
private boolean generatorResultCachingEnabled = false; | |||
private List<String> cachedTypeNamesToReuse = null; | |||
private boolean isProdMode; | |||
/** | |||
* Normally, the compiler host would be aware of the same types that are | |||
* available in the supplied type oracle although it isn't strictly required. | |||
*/ | |||
public StandardGeneratorContext(CompilationState compilationState, ModuleDef module, File genDir, | |||
ArtifactSet allGeneratedArtifacts, boolean isProdMode) { | |||
this.compilationState = compilationState; | |||
this.module = module; | |||
this.genDir = genDir; | |||
this.allGeneratedArtifacts = allGeneratedArtifacts; | |||
this.isProdMode = isProdMode; | |||
} | |||
/** | |||
* Adds a generated unit to the context if not already present, but will not | |||
* overwrite an existing unit. | |||
*/ | |||
public void addGeneratedUnit(GeneratedUnit gu) { | |||
if (!committedGeneratedCups.containsKey(gu.getTypeName())) { | |||
committedGeneratedCups.put(gu.getTypeName(), gu); | |||
} | |||
} | |||
/** | |||
* Adds generated units to the context, but will not overwrite any existing | |||
* units that might already be present. | |||
*/ | |||
public void addGeneratedUnits(Collection<GeneratedUnit> generatedUnits) { | |||
for (GeneratedUnit gu : generatedUnits) { | |||
addGeneratedUnit(gu); | |||
} | |||
} | |||
/** | |||
* Adds all available cached generated units to the context. Existing units | |||
* for a given type will not be overwritten. | |||
*/ | |||
public void addGeneratedUnitsFromCache() { | |||
if (cachedRebindResult != null && cachedRebindResult.getGeneratedUnits() != null) { | |||
addGeneratedUnits(cachedRebindResult.getGeneratedUnits()); | |||
} | |||
} | |||
/** | |||
* Adds cached generated units to the context that have been marked for reuse. | |||
* Existing units for a given type will not be overwritten. | |||
*/ | |||
public void addGeneratedUnitsMarkedForReuseFromCache() { | |||
if (cachedTypeNamesToReuse != null && cachedRebindResult != null) { | |||
for (String typeName : cachedTypeNamesToReuse) { | |||
GeneratedUnit gu = cachedRebindResult.getGeneratedUnit(typeName); | |||
if (gu != null) { | |||
addGeneratedUnit(gu); | |||
} | |||
} | |||
} | |||
} | |||
/** | |||
* Checks whether a rebind rule is available for a given sourceTypeName. | |||
*/ | |||
public boolean checkRebindRuleAvailable(String sourceTypeName) { | |||
if (rebindRuleResolver != null) { | |||
return rebindRuleResolver.checkRebindRuleResolvable(sourceTypeName); | |||
} else { | |||
return false; | |||
} | |||
} | |||
/** | |||
* Frees memory used up by compilation state. | |||
*/ | |||
public void clear() { | |||
compilationState = null; | |||
generators.clear(); | |||
} | |||
/** | |||
* Commits a pending generated type. | |||
*/ | |||
public final void commit(TreeLogger logger, PrintWriter pw) { | |||
Generated gcup = uncommittedGeneratedCupsByPrintWriter.get(pw); | |||
if (gcup != null) { | |||
gcup.commit(logger); | |||
uncommittedGeneratedCupsByPrintWriter.remove(pw); | |||
committedGeneratedCups.put(gcup.getTypeName(), gcup); | |||
} else { | |||
logger.log(TreeLogger.WARN, "Generator attempted to commit an unknown PrintWriter", null); | |||
} | |||
} | |||
/** | |||
* Adds an Artifact to the context's ArtifactSets. This will replace a | |||
* pre-existing entry in allGeneratedArtifacts, but will not overwrite an | |||
* entry in the newlyGeneratedArtifacts (since it is assumed by convention | |||
* that only new entries will ever be inserted here for a given generator | |||
* run). | |||
*/ | |||
public void commitArtifact(TreeLogger logger, Artifact<?> artifact) { | |||
allGeneratedArtifacts.replace(artifact); | |||
newlyGeneratedArtifacts.add(artifact); | |||
} | |||
/** | |||
* Commits all available cached Artifacts to the context. | |||
*/ | |||
public void commitArtifactsFromCache(TreeLogger logger) { | |||
if (cachedRebindResult != null && cachedRebindResult.getArtifacts() != null) { | |||
for (Artifact<?> art : cachedRebindResult.getArtifacts()) { | |||
commitArtifact(logger, art); | |||
} | |||
} | |||
} | |||
public GeneratedResource commitResource(TreeLogger logger, OutputStream os) | |||
throws UnableToCompleteException { | |||
PendingResource pendingResource = null; | |||
String partialPath = null; | |||
if (os instanceof PendingResource) { | |||
pendingResource = (PendingResource) os; | |||
partialPath = pendingResource.getPartialPath(); | |||
// Make sure it's ours by looking it up in the map. | |||
if (pendingResource != pendingResources.get(partialPath)) { | |||
pendingResource = null; | |||
} | |||
} | |||
if (pendingResource == null) { | |||
logger.log(TreeLogger.WARN, "Generator attempted to commit an unknown OutputStream", null); | |||
throw new UnableToCompleteException(); | |||
} | |||
// Add the GeneratedResource to the ArtifactSet | |||
GeneratedResource toReturn = | |||
new StandardGeneratedResource(currentGenerator, partialPath, pendingResource.takeBytes()); | |||
commitArtifact(logger, toReturn); | |||
pendingResources.remove(pendingResource.getPartialPath()); | |||
return toReturn; | |||
} | |||
/** | |||
* Call this whenever generators are known to not be running to clear out | |||
* uncommitted compilation units and to force committed compilation units to | |||
* be parsed and added to the type oracle. | |||
* | |||
* @return any newly generated artifacts since the last call | |||
*/ | |||
public final ArtifactSet finish(TreeLogger logger) { | |||
abortUncommittedResources(logger); | |||
try { | |||
TreeLogger branch; | |||
if (!committedGeneratedCups.isEmpty()) { | |||
// Assimilate the new types into the type oracle. | |||
// | |||
String msg = "Assimilating generated source"; | |||
branch = logger.branch(TreeLogger.DEBUG, msg, null); | |||
TreeLogger subBranch = null; | |||
if (branch.isLoggable(TreeLogger.DEBUG)) { | |||
subBranch = branch.branch(TreeLogger.DEBUG, "Generated source files...", null); | |||
} | |||
for (GeneratedUnit gcup : committedGeneratedCups.values()) { | |||
String qualifiedTypeName = gcup.getTypeName(); | |||
if (subBranch != null) { | |||
subBranch.log(TreeLogger.DEBUG, qualifiedTypeName, null); | |||
} | |||
} | |||
compilationState.addGeneratedCompilationUnits(logger, committedGeneratedCups.values()); | |||
} | |||
return newlyGeneratedArtifacts; | |||
} finally { | |||
// Remind the user if there uncommitted cups. | |||
if (!uncommittedGeneratedCupsByPrintWriter.isEmpty()) { | |||
String msg = | |||
"For the following type(s), generated source was never committed (did you forget to call commit()?)"; | |||
logger = logger.branch(TreeLogger.WARN, msg, null); | |||
for (Generated unit : uncommittedGeneratedCupsByPrintWriter.values()) { | |||
logger.log(TreeLogger.WARN, unit.getTypeName(), null); | |||
} | |||
} | |||
uncommittedGeneratedCupsByPrintWriter.clear(); | |||
committedGeneratedCups.clear(); | |||
newlyGeneratedTypeNames.clear(); | |||
newlyGeneratedArtifacts = new ArtifactSet(); | |||
cachedRebindResult = null; | |||
cachedTypeNamesToReuse = null; | |||
} | |||
} | |||
public Set<String> getActiveLinkerNames() { | |||
return module.getActiveLinkerNames(); | |||
} | |||
/** | |||
* Gets newly committed artifacts. | |||
*/ | |||
public ArtifactSet getArtifacts() { | |||
return new ArtifactSet(newlyGeneratedArtifacts); | |||
} | |||
/** | |||
* Gets the previously cached rebind result for the current generator. | |||
*/ | |||
public CachedRebindResult getCachedGeneratorResult() { | |||
return cachedRebindResult; | |||
} | |||
public GeneratorContext getCanonicalContext() { | |||
return this; | |||
} | |||
public CompilationState getCompilationState() { | |||
return compilationState; | |||
} | |||
/** | |||
* Gets all committed Java units. | |||
*/ | |||
public Map<String, GeneratedUnit> getGeneratedUnitMap() { | |||
return committedGeneratedCups; | |||
} | |||
public final PropertyOracle getPropertyOracle() { | |||
return propOracle; | |||
} | |||
public ResourceOracle getResourcesOracle() { | |||
return module.getResourcesOracle(); | |||
} | |||
public final TypeOracle getTypeOracle() { | |||
return compilationState.getTypeOracle(); | |||
} | |||
public boolean isGeneratorResultCachingEnabled() { | |||
return generatorResultCachingEnabled; | |||
} | |||
public boolean isProdMode() { | |||
return isProdMode; | |||
} | |||
/** | |||
* Adds a type name to the list of types to be reused from cache, if | |||
* available. | |||
* | |||
* @param typeName The fully qualified name of a type. | |||
* | |||
* @return true, if the type is available in the cache and was successfully | |||
* added to the list for reuse, false otherwise. | |||
*/ | |||
public boolean reuseTypeFromCacheIfAvailable(String typeName) { | |||
if (!isGeneratorResultCachingEnabled() || cachedRebindResult == null | |||
|| !cachedRebindResult.isTypeCached(typeName)) { | |||
return false; | |||
} | |||
if (cachedTypeNamesToReuse == null) { | |||
cachedTypeNamesToReuse = new ArrayList<String>(); | |||
} | |||
cachedTypeNamesToReuse.add(typeName); | |||
return true; | |||
} | |||
/** | |||
* This method is maintained for backwards compatibility. | |||
* {@link #runGeneratorIncrementally} should be used instead. | |||
*/ | |||
public String runGenerator(TreeLogger logger, Class<? extends Generator> generatorClass, | |||
String typeName) throws UnableToCompleteException { | |||
RebindResult result = runGeneratorIncrementally(logger, generatorClass, typeName); | |||
return result.getReturnedTypeName(); | |||
} | |||
/** | |||
* Runs a generator incrementally, with support for managing the returned | |||
* {@link RebindResult} object, which can contain status and cached results. | |||
* This is a replacement for the {@link #runGenerator} method. | |||
* <p> | |||
* If the passed in generatorClass is an instance of {@link GeneratorExt}, | |||
* it's {@link GeneratorExt#generateIncrementally} method will be called. | |||
* <p> | |||
* Otherwise, for backwards compatibility, the generatorClass will be wrapped | |||
* in a {@link GeneratorExt} instance, and it's {@link Generator#generate} | |||
* method will be called. | |||
* | |||
* @param logger | |||
* @param generatorClass | |||
* @param typeName | |||
* @return a RebindResult | |||
* @throws UnableToCompleteException | |||
*/ | |||
public RebindResult runGeneratorIncrementally(TreeLogger logger, | |||
Class<? extends Generator> generatorClass, String typeName) throws UnableToCompleteException { | |||
String msg = "Invoking generator " + generatorClass.getName(); | |||
logger = logger.branch(TreeLogger.DEBUG, msg, null); | |||
Generator generator = generators.get(generatorClass); | |||
if (generator == null) { | |||
try { | |||
generator = generatorClass.newInstance(); | |||
generators.put(generatorClass, generator); | |||
} catch (Throwable e) { | |||
logger.log(TreeLogger.ERROR, "Unexpected error trying to instantiate Generator '" | |||
+ generatorClass.getName() + "'", e); | |||
throw new UnableToCompleteException(); | |||
} | |||
} | |||
setCurrentGenerator(generatorClass); | |||
// Avoid call to System.currentTimeMillis() if not logging DEBUG level | |||
boolean loggable = logger.isLoggable(TreeLogger.DEBUG); | |||
long before = loggable ? System.currentTimeMillis() : 0L; | |||
String generatorClassName = generator.getClass().getName(); | |||
CompilerEventType type = eventsByGeneratorType.get(generatorClassName); | |||
if (type == null) { | |||
type = CompilerEventType.GENERATOR_OTHER; | |||
} | |||
Event generatorEvent = | |||
SpeedTracerLogger.start(type, "class", generatorClassName, "type", typeName); | |||
try { | |||
GeneratorExt generatorExt; | |||
if (generator instanceof GeneratorExt) { | |||
generatorExt = (GeneratorExt) generator; | |||
} else { | |||
generatorExt = GeneratorExtWrapper.newInstance(generator); | |||
} | |||
RebindResult result; | |||
result = generatorExt.generateIncrementally(logger, this, typeName); | |||
if (loggable) { | |||
if (result.getResultStatus() == RebindStatus.USE_EXISTING) { | |||
msg = "Generator did not return a new class, type will be used as is"; | |||
} else { | |||
msg = "Generator returned class '" + result.getReturnedTypeName() + "'"; | |||
} | |||
long after = System.currentTimeMillis(); | |||
msg += "; in " + (after - before) + " ms"; | |||
logger.log(TreeLogger.DEBUG, msg, null); | |||
} | |||
return result; | |||
} catch (AssertionError e) { | |||
// Catch and log the assertion as a convenience to the developer | |||
logger.log(TreeLogger.ERROR, "Generator '" + generatorClass.getName() | |||
+ "' failed an assertion while rebinding '" + typeName + "'", e); | |||
throw new UnableToCompleteException(); | |||
} catch (RuntimeException e) { | |||
logger.log(TreeLogger.ERROR, "Generator '" + generatorClass.getName() | |||
+ "' threw an exception while rebinding '" + typeName + "'", e); | |||
throw new UnableToCompleteException(); | |||
} finally { | |||
generatorEvent.end(); | |||
} | |||
} | |||
/** | |||
* Set previously cached rebind result for currently active generator. | |||
*/ | |||
public void setCachedGeneratorResult(CachedRebindResult cachedRebindResult) { | |||
this.cachedRebindResult = cachedRebindResult; | |||
} | |||
public void setCurrentGenerator(Class<? extends Generator> currentGenerator) { | |||
this.currentGenerator = currentGenerator; | |||
} | |||
public void setGeneratorResultCachingEnabled(boolean enabled) { | |||
this.generatorResultCachingEnabled = enabled; | |||
} | |||
/** | |||
* Sets the current transient property oracle to answer current property | |||
* questions. | |||
*/ | |||
public void setPropertyOracle(PropertyOracle propOracle) { | |||
this.propOracle = propOracle; | |||
} | |||
public void setRebindRuleResolver(RebindRuleResolver resolver) { | |||
this.rebindRuleResolver = resolver; | |||
} | |||
public final PrintWriter tryCreate(TreeLogger logger, String packageName, String simpleTypeName) { | |||
String typeName; | |||
if (packageName.length() == 0) { | |||
typeName = simpleTypeName; | |||
} else { | |||
typeName = packageName + '.' + simpleTypeName; | |||
} | |||
// Is type already known to the host? | |||
JClassType existingType = getTypeOracle().findType(packageName, simpleTypeName); | |||
if (existingType != null) { | |||
if (logger.isLoggable(TreeLogger.DEBUG)) { | |||
logger.log(TreeLogger.DEBUG, "Type '" + typeName | |||
+ "' already exists and will not be re-created ", null); | |||
} | |||
return null; | |||
} | |||
// Type recently generated? | |||
if (newlyGeneratedTypeNames.contains(typeName)) { | |||
return null; | |||
} | |||
// The type isn't there, so we can let the caller create it. Remember that | |||
// it is pending so another attempt to create the same type will fail. | |||
Generated gcup; | |||
StringWriter sw = new StringWriter(); | |||
PrintWriter pw = new PrintWriter(sw, true) { | |||
/** | |||
* Overridden to force unix-style line endings for consistent behavior | |||
* across platforms. | |||
*/ | |||
@Override | |||
public void println() { | |||
super.print('\n'); | |||
super.flush(); | |||
} | |||
}; | |||
if (this.genDir == null) { | |||
gcup = new GeneratedUnitImpl(sw, typeName); | |||
} else { | |||
File dir = new File(genDir, packageName.replace('.', File.separatorChar)); | |||
// No need to check mkdirs result because an IOException will occur anyway | |||
dir.mkdirs(); | |||
File srcFile = new File(dir, simpleTypeName + ".java"); | |||
if (srcFile.exists()) { | |||
srcFile.delete(); | |||
} | |||
gcup = new GeneratedUnitWithFile(srcFile, sw, typeName); | |||
} | |||
uncommittedGeneratedCupsByPrintWriter.put(pw, gcup); | |||
newlyGeneratedTypeNames.add(typeName); | |||
return pw; | |||
} | |||
public OutputStream tryCreateResource(TreeLogger logger, String partialPath) | |||
throws UnableToCompleteException { | |||
logger = | |||
logger.branch(TreeLogger.DEBUG, "Preparing pending output resource '" + partialPath + "'", | |||
null); | |||
// Disallow null or empty names. | |||
if (partialPath == null || partialPath.trim().equals("")) { | |||
logger.log(TreeLogger.ERROR, "The resource name must be a non-empty string", null); | |||
throw new UnableToCompleteException(); | |||
} | |||
// Disallow absolute paths. | |||
if (new File(partialPath).isAbsolute()) { | |||
logger | |||
.log( | |||
TreeLogger.ERROR, | |||
"Resource paths are intended to be relative to the compiled output directory and cannot be absolute", | |||
null); | |||
throw new UnableToCompleteException(); | |||
} | |||
// Disallow backslashes (to promote consistency in calling code). | |||
if (partialPath.indexOf('\\') >= 0) { | |||
logger.log(TreeLogger.ERROR, | |||
"Resource paths must contain forward slashes (not backslashes) to denote subdirectories", | |||
null); | |||
throw new UnableToCompleteException(); | |||
} | |||
// Check for public path collision. | |||
if (module.findPublicFile(partialPath) != null) { | |||
logger.log(TreeLogger.WARN, "Cannot create resource '" + partialPath | |||
+ "' because it already exists on the public path", null); | |||
return null; | |||
} | |||
// See if the file is already committed. | |||
SortedSet<GeneratedResource> resources = allGeneratedArtifacts.find(GeneratedResource.class); | |||
for (GeneratedResource resource : resources) { | |||
if (partialPath.equals(resource.getPartialPath())) { | |||
return null; | |||
} | |||
} | |||
// See if the file is pending. | |||
if (pendingResources.containsKey(partialPath)) { | |||
// It is already pending. | |||
logger.log(TreeLogger.WARN, "The file '" + partialPath + "' is already a pending resource", | |||
null); | |||
return null; | |||
} | |||
PendingResource pendingResource = new PendingResource(partialPath); | |||
pendingResources.put(partialPath, pendingResource); | |||
return pendingResource; | |||
} | |||
private void abortUncommittedResources(TreeLogger logger) { | |||
if (pendingResources.isEmpty()) { | |||
// Nothing to do. | |||
return; | |||
} | |||
// Warn the user about uncommitted resources. | |||
logger = | |||
logger | |||
.branch( | |||
TreeLogger.WARN, | |||
"The following resources will not be created because they were never committed (did you forget to call commit()?)", | |||
null); | |||
for (Entry<String, PendingResource> entry : pendingResources.entrySet()) { | |||
logger.log(TreeLogger.WARN, entry.getKey()); | |||
entry.getValue().abort(); | |||
} | |||
pendingResources.clear(); | |||
} | |||
} |
@@ -0,0 +1,8 @@ | |||
<module> | |||
<inherits name='com.google.gwt.query.Query' /> | |||
<entry-point class="com.google.gwt.query.jsquery.client.JsQuery" /> | |||
<inherits name='org.timepedia.exporter.Exporter' /> | |||
<set-property name="export" value="yes" /> | |||
</module> | |||
@@ -0,0 +1,40 @@ | |||
<!-- | |||
This Module creates a javascript library able to replace jquery.js | |||
--> | |||
<module rename-to='jsquery'> | |||
<inherits name='com.google.gwt.query.jsquery.JsQuery' /> | |||
<entry-point class="com.google.gwt.query.jsquery.client.JsQueryApi" /> | |||
<!-- Minimize JS --> | |||
<set-property name="compiler.stackMode" value="strip"/> | |||
<!-- cross-site --> | |||
<add-linker name="xsiframe"/> | |||
<!-- | |||
Hack to put code into the jsquery.nocache.js so as $ is available early | |||
and we can handle the $().ready method which is widely used in jquery pages. | |||
Otherwise $ wont be available until the async loading of the gwt permutation | |||
which happens after the page was ready. | |||
--> | |||
<define-property name="onload" values="default, foo"/> | |||
<property-provider name="onload"> | |||
<![CDATA[ | |||
$wnd.JsQuery = { | |||
onLoadArray: [], | |||
onLoad: function() { | |||
for (i in $wnd.JsQuery.onLoadArray) | |||
$wnd.JsQuery.onLoadArray[i](); | |||
}, | |||
ready: function(f) { | |||
$wnd.JsQuery.onLoadArray.push(f); | |||
} | |||
}; | |||
$wnd._$_ = $wnd.$; | |||
$wnd.$ = function() {return $wnd.JsQuery;} | |||
return 'default'; | |||
]]> | |||
</property-provider> | |||
</module> | |||
@@ -0,0 +1,397 @@ | |||
package com.google.gwt.query.jsquery.client; | |||
import org.timepedia.exporter.client.Export; | |||
import org.timepedia.exporter.client.ExportAfterCreateMethod; | |||
import org.timepedia.exporter.client.ExportClosure; | |||
import org.timepedia.exporter.client.ExportInstanceMethod; | |||
import org.timepedia.exporter.client.ExportJsInitMethod; | |||
import org.timepedia.exporter.client.ExportOverlay; | |||
import org.timepedia.exporter.client.ExportPackage; | |||
import org.timepedia.exporter.client.ExportStaticMethod; | |||
import org.timepedia.exporter.client.ExporterUtil; | |||
import com.google.gwt.core.client.JavaScriptObject; | |||
import com.google.gwt.dom.client.Element; | |||
import com.google.gwt.dom.client.Node; | |||
import com.google.gwt.dom.client.NodeList; | |||
import com.google.gwt.query.client.Function; | |||
import com.google.gwt.query.client.GQuery; | |||
import com.google.gwt.query.client.GQuery.Offset; | |||
import com.google.gwt.query.client.Predicate; | |||
import com.google.gwt.query.client.Properties; | |||
import com.google.gwt.query.client.js.JsUtils; | |||
import com.google.gwt.query.client.plugins.Effects; | |||
import com.google.gwt.query.client.plugins.effects.PropertiesAnimation; | |||
import com.google.gwt.user.client.Event; | |||
/** | |||
* Class used to expose GQuery methods and object to Javascript using | |||
* gwt-exporter annotations. | |||
* | |||
* We prefer to overlay the original GQuery object instead of adding | |||
* the gwt-exporter dependency to the project. | |||
* | |||
* Because of the differences between java and js apis, we need to | |||
* override some methods in order to deal with complex cases. | |||
* | |||
*/ | |||
@ExportPackage("JsQuery") | |||
@Export(value="fn", all=false) | |||
public class GQueryOverlay implements ExportOverlay<GQuery> { | |||
@ExportPackage("JsQuery") | |||
@Export("jFunction") | |||
@ExportClosure() | |||
public interface FunctionOverlay extends ExportOverlay<Function> { | |||
public void f(); | |||
public boolean f(Event e); | |||
public Object f(Element e, int i); | |||
} | |||
@ExportPackage("JsQuery") | |||
@Export("jPredicate") | |||
@ExportClosure() | |||
public interface PredicateOverlay extends ExportOverlay<Predicate> { | |||
public boolean f(Element e, int i); | |||
} | |||
private GQueryOverlay(){} | |||
/** | |||
* In js a GQuery object represents a Nodelist. | |||
* gwt-exporter will use the object returned by get() to wrap | |||
* the GQuery object | |||
*/ | |||
@ExportJsInitMethod | |||
public NodeList<Element> get() {return null;} | |||
/** | |||
* Customized JS code to execute after GQuery has been exported. | |||
*/ | |||
@ExportAfterCreateMethod | |||
public static native void afterCreate() /*-{ | |||
$ = $wnd.$; | |||
window = $wnd; | |||
document = $doc; | |||
}-*/; | |||
@ExportStaticMethod("$wnd.$") | |||
public static GQuery $(Object o) { | |||
return JsQueryUtils.dollar(o); | |||
} | |||
@ExportStaticMethod("$wnd.$") | |||
public static GQuery $(String s, Element ctx) { | |||
return GQuery.$(s, ctx); | |||
} | |||
@ExportStaticMethod("$wnd.$.extend") | |||
public static JavaScriptObject extend(Object...objs) { | |||
return JsQueryUtils.extend(objs); | |||
} | |||
@ExportStaticMethod("$wnd.$.each") | |||
public static JavaScriptObject[] each(JavaScriptObject[] objs, Function f) { | |||
return JsQueryUtils.each(objs, f); | |||
} | |||
@ExportStaticMethod("$wnd.$.inArray") | |||
public static int inArray(Object o, Object arr) { | |||
return JsQueryUtils.inArray(o, arr); | |||
} | |||
@ExportStaticMethod("$wnd.$.isArray") | |||
public static boolean isArray(JavaScriptObject o) { | |||
return JsUtils.isArray(o); | |||
} | |||
@ExportInstanceMethod | |||
public static GQuery ready(GQuery g, Function f) { | |||
f.fe(); | |||
return g; | |||
} | |||
@ExportInstanceMethod | |||
// TODO: normally plugins adds new easing functions to jquery.easing array | |||
public static GQuery animate(GQuery g, Object stringOrProperties, int duration, String easing, Function... funcs) { | |||
return g.animate(stringOrProperties, duration, | |||
"linear".equalsIgnoreCase(easing) | |||
? PropertiesAnimation.Easing.LINEAR | |||
: PropertiesAnimation.Easing.SWING, funcs); | |||
} | |||
@ExportInstanceMethod | |||
public static Object css(GQuery g, Object o) { | |||
if (o instanceof String) { | |||
return g.css((String)o, false); | |||
} else { | |||
return ExporterUtil.wrap(g.css((Properties)o)); | |||
} | |||
} | |||
@ExportInstanceMethod | |||
public static GQuery css(GQuery g, String k, Object v) { | |||
return g.css(k, String.valueOf(v)); | |||
} | |||
@ExportInstanceMethod | |||
public static JavaScriptObject offset(GQuery instance) { | |||
Offset o = instance.offset(); | |||
return Properties.create("left: " + o.left + ", top:" + o.top); | |||
} | |||
@ExportInstanceMethod | |||
public static GQuery unbind(GQuery g, String s, Function o) { | |||
return g.unbind(s); | |||
} | |||
public String toString() {return null;} | |||
public GQuery add(GQuery previousObject) {return null;} | |||
public GQuery add(String selector) {return null;} | |||
public GQuery addClass(String... classes) {return null;} | |||
public GQuery after(GQuery query) {return null;} | |||
public GQuery after(Node n) {return null;} | |||
public GQuery after(String html) {return null;} | |||
public GQuery andSelf() {return null;} | |||
// public GQuery animate(Object stringOrProperties, int duration, Easing easing, Function... funcs) {return null;} | |||
public GQuery animate(Object stringOrProperties, Function... funcs) {return null;} | |||
public GQuery animate(Object stringOrProperties, int duration, Function... funcs) {return null;} | |||
// public GQuery attr(Properties properties) {return null;} | |||
public String attr(String name) {return null;} | |||
// public GQuery attr(String key, Function closure) {return null;} | |||
public GQuery attr(String key, Object value) {return null;} | |||
public int size() {return 0;} | |||
public GQuery append(GQuery query) {return null;} | |||
public GQuery append(Node n) {return null;} | |||
public GQuery append(String html) {return null;} | |||
public GQuery appendTo(GQuery other) {return null;} | |||
public GQuery appendTo(Node n) {return null;} | |||
public GQuery appendTo(String html) {return null;} | |||
public <T extends GQuery> T as(Class<T> plugin) {return null;} | |||
public GQuery before(GQuery query) {return null;} | |||
public GQuery before(Node n) {return null;} | |||
public GQuery before(String html) {return null;} | |||
// public GQuery bind(int eventbits, Object data, Function... funcs) {return null;} | |||
// public GQuery bind(String eventType, Object data, Function... funcs) {return null;} | |||
@ExportInstanceMethod | |||
public static GQuery bind(GQuery g, String events, Function func) { | |||
return g.bind(events, null, func); | |||
} | |||
public GQuery blur(Function... f) {return null;} | |||
public GQuery change(Function... f) {return null;} | |||
public GQuery children() {return null;} | |||
public GQuery children(String... filters) {return null;} | |||
public GQuery clearQueue() {return null;} | |||
public GQuery clone() {return null;} | |||
public GQuery clearQueue(String queueName) {return null;} | |||
public GQuery click(Function... f) {return null;} | |||
public GQuery closest(String selector) {return null;} | |||
// public JsNamedArray<NodeList<Element>> closest(String[] selectors) {return null;} | |||
// public JsNamedArray<NodeList<Element>> closest(String[] selectors, Node context) {return null;} | |||
public GQuery closest(String selector, Node context) {return null;} | |||
public GQuery contains(String text) {return null;} | |||
public GQuery contents() {return null;} | |||
// public GQuery css(Properties properties) {return null;} | |||
// public String css(String name) {return null;} | |||
// public String css(String name, boolean force) {return null;} | |||
public GQuery css(String prop, String val) {return null;} | |||
public double cur(String prop) {return 0;} | |||
public double cur(String prop, boolean force) {return 0;} | |||
public Object data(String name) {return null;} | |||
// public <T> T data(String name, Class<T> clz) {return null;} | |||
public GQuery data(String name, Object value) {return null;} | |||
public GQuery dblclick(Function... f) {return null;} | |||
@ExportInstanceMethod | |||
public static GQuery delay(GQuery g, int milliseconds) { | |||
System.out.println("DDDDD"); | |||
return g.delay(milliseconds); | |||
} | |||
public GQuery delay(int milliseconds, Function... f) {return null;} | |||
public GQuery delay(int milliseconds, String queueName, Function... f) {return null;} | |||
public GQuery delegate(String selector, String eventType, Function... handlers) {return null;} | |||
public GQuery delegate(String selector, String eventType, Object data, Function... handlers) {return null;} | |||
public GQuery delegate(String selector, int eventbits, Function... handlers) {return null;} | |||
public GQuery delegate(String selector, int eventbits, Object data, Function... handlers) {return null;} | |||
public GQuery dequeue() {return null;} | |||
public GQuery dequeue(String queueName) {return null;} | |||
public GQuery detach() {return null;} | |||
public GQuery detach(String filter) {return null;} | |||
public GQuery die() {return null;} | |||
public GQuery die(String eventName) {return null;} | |||
// public GQuery die(int eventbits) {return null;} | |||
public GQuery each(Function... f) {return null;} | |||
public Element[] elements() {return null;} | |||
public GQuery empty() {return null;} | |||
// public GQuery end() {return null;} | |||
public GQuery eq(int pos) {return null;} | |||
public GQuery error(Function... f) {return null;} | |||
public GQuery fadeIn(Function... f) {return null;} | |||
public GQuery fadeIn(int millisecs, Function... f) {return null;} | |||
public GQuery fadeOut(Function... f) {return null;} | |||
public GQuery fadeOut(int millisecs, Function... f) {return null;} | |||
public Effects fadeToggle(int millisecs, Function... f) {return null;} | |||
public GQuery filter(Predicate filterFn) {return null;} | |||
// public GQuery filter(String... filters) {return null;} | |||
public GQuery find(String... filters) {return null;} | |||
public GQuery first() {return null;} | |||
public GQuery focus(Function... f) {return null;} | |||
public Element get(int i) {return null;} | |||
public Node getContext() {return null;} | |||
public GQuery getPreviousObject() {return null;} | |||
public String getSelector() {return null;} | |||
public GQuery gt(int pos) {return null;} | |||
public boolean hasClass(String... classes) {return false;} | |||
public int height() {return 0;} | |||
public GQuery height(int height) {return null;} | |||
public GQuery height(String height) {return null;} | |||
public GQuery hide() {return null;} | |||
public GQuery hover(Function fover, Function fout) {return null;} | |||
public String html() {return null;} | |||
public GQuery html(String html) {return null;} | |||
public String id() {return null;} | |||
public GQuery id(String id) {return null;} | |||
public int index(Element element) {return 0;} | |||
public int innerHeight() {return 0;} | |||
public int innerWidth() {return 0;} | |||
public GQuery insertAfter(Element elem) {return null;} | |||
public GQuery insertAfter(GQuery query) {return null;} | |||
public GQuery insertAfter(String selector) {return null;} | |||
public GQuery insertBefore(Element item) {return null;} | |||
public GQuery insertBefore(GQuery query) {return null;} | |||
public GQuery insertBefore(String selector) {return null;} | |||
public boolean is(String... filters) {return false;} | |||
public boolean isEmpty() {return false;} | |||
public GQuery keydown(Function... f) {return null;} | |||
public GQuery keydown(int key) {return null;} | |||
public GQuery keypress(Function... f) {return null;} | |||
public GQuery keypress(int key) {return null;} | |||
public GQuery keyup(Function... f) {return null;} | |||
public GQuery keyup(int key) {return null;} | |||
public GQuery last() {return null;} | |||
public int left() {return 0;} | |||
public int length() {return 0;} | |||
public GQuery live(String eventName, Function... funcs) {return null;} | |||
// public GQuery live(int eventbits, Function... funcs) {return null;} | |||
// public GQuery live(int eventbits, Object data, Function... funcs) {return null;} | |||
public GQuery live(String eventName, Object data, Function... funcs) {return null;} | |||
// public GQuery load(Function f) {return null;} | |||
public GQuery lt(int pos) {return null;} | |||
// public <W> List<W> map(Function f) {return null;} | |||
public GQuery mousedown(Function... f) {return null;} | |||
public GQuery mousemove(Function... f) {return null;} | |||
public GQuery mouseout(Function... f) {return null;} | |||
public GQuery mouseover(Function... f) {return null;} | |||
public GQuery mouseup(Function... f) {return null;} | |||
public GQuery next() {return null;} | |||
public GQuery next(String... selectors) {return null;} | |||
public GQuery nextAll() {return null;} | |||
public GQuery nextUntil(String selector) {return null;} | |||
public GQuery not(Element elem) {return null;} | |||
public GQuery not(GQuery gq) {return null;} | |||
public GQuery not(String... filters) {return null;} | |||
public GQuery offsetParent() {return null;} | |||
public GQuery one(int eventbits, Object data, Function f) {return null;} | |||
public int outerHeight() {return 0;} | |||
public int outerHeight(boolean includeMargin) {return 0;} | |||
public int outerWidth() {return 0;} | |||
public int outerWidth(boolean includeMargin) {return 0;} | |||
public GQuery parent() {return null;} | |||
public GQuery parent(String... filters) {return null;} | |||
public GQuery parents() {return null;} | |||
public GQuery parents(String... filters) {return null;} | |||
public GQuery parentsUntil(String selector) {return null;} | |||
// public Offset position() {return null;} | |||
public GQuery prepend(GQuery query) {return null;} | |||
public GQuery prepend(Node n) {return null;} | |||
public GQuery prepend(String html) {return null;} | |||
public GQuery prependTo(GQuery other) {return null;} | |||
public GQuery prependTo(Node n) {return null;} | |||
public GQuery prependTo(String html) {return null;} | |||
public GQuery prev() {return null;} | |||
public GQuery prev(String... selectors) {return null;} | |||
public GQuery prevAll() {return null;} | |||
public GQuery prevUntil(String selector) {return null;} | |||
public boolean prop(String key) {return false;} | |||
public GQuery prop(String key, boolean value) {return null;} | |||
public GQuery prop(String key, Function closure) {return null;} | |||
public int queue() {return 0;} | |||
public int queue(String queueName) {return 0;} | |||
public GQuery queue(Function... f) {return null;} | |||
public GQuery queue(String queueName, Function... f) {return null;} | |||
public GQuery remove() {return null;} | |||
public GQuery remove(String filter) {return null;} | |||
public GQuery removeAttr(String key) {return null;} | |||
public GQuery removeClass(String... classes) {return null;} | |||
public GQuery removeData(String name) {return null;} | |||
public GQuery replaceAll(Element elem) {return null;} | |||
public GQuery replaceAll(GQuery target) {return null;} | |||
public GQuery replaceAll(String selector) {return null;} | |||
public GQuery replaceWith(Element elem) {return null;} | |||
public GQuery replaceWith(GQuery target) {return null;} | |||
public GQuery replaceWith(String html) {return null;} | |||
public GQuery resize(Function... f) {return null;} | |||
public void restoreCssAttrs(String... cssProps) {} | |||
public void resize(Function f) {} | |||
public void saveCssAttrs(String... cssProps) {} | |||
public GQuery scroll(Function... f) {return null;} | |||
public GQuery scrollIntoView() {return null;} | |||
public GQuery scrollIntoView(boolean ensure) {return null;} | |||
public int scrollLeft() {return 0;} | |||
public GQuery scrollLeft(int left) {return null;} | |||
public GQuery scrollTo(int left, int top) {return null;} | |||
public int scrollTop() {return 0;} | |||
public GQuery scrollTop(int top) {return null;} | |||
public GQuery select() {return null;} | |||
public GQuery setArray(NodeList<Element> list) {return null;} | |||
public void setPreviousObject(GQuery previousObject) {} | |||
public GQuery setSelector(String selector) {return null;} | |||
public GQuery show() {return null;} | |||
public GQuery siblings() {return null;} | |||
public GQuery siblings(String... selectors) {return null;} | |||
public GQuery slice(int start, int end) {return null;} | |||
public Effects slideDown(Function... f) {return null;} | |||
public Effects slideDown(int millisecs, Function... f) {return null;} | |||
public Effects slideToggle(int millisecs, Function... f) {return null;} | |||
public Effects slideUp(Function... f) {return null;} | |||
public Effects slideUp(int millisecs, Function... f) {return null;} | |||
public GQuery stop() {return null;} | |||
public GQuery stop(boolean clearQueue) {return null;} | |||
public GQuery stop(boolean clearQueue, boolean jumpToEnd) {return null;} | |||
public GQuery submit(Function... funcs) {return null;} | |||
public String text() {return null;} | |||
public GQuery text(String txt) {return null;} | |||
public GQuery toggle() {return null;} | |||
public GQuery toggle(Function... fn) {return null;} | |||
public GQuery toggleClass(String... classes) {return null;} | |||
public GQuery toggleClass(String clz, boolean addOrRemove) {return null;} | |||
public int top() {return 0;} | |||
public String toString(boolean pretty) {return null;} | |||
// public GQuery trigger(int eventbits, int... keys) {return null;} | |||
// public GQuery unbind(int eventbits) {return null;} | |||
public GQuery undelegate() {return null;} | |||
public GQuery undelegate(String selector) {return null;} | |||
public GQuery undelegate(String selector, String eventName) {return null;} | |||
public GQuery undelegate(String selector, int eventBit) {return null;} | |||
// public JsNodeArray unique(NodeList<Element> result) {return null;} | |||
public GQuery unwrap() {return null;} | |||
public String val() {return null;} | |||
public GQuery val(String... values) {return null;} | |||
public String[] vals() {return null;} | |||
public boolean isVisible() {return false;} | |||
public int width() {return 0;} | |||
public GQuery width(int width) {return null;} | |||
public GQuery wrap(Element elem) {return null;} | |||
public GQuery wrap(GQuery query) {return null;} | |||
public GQuery wrap(String html) {return null;} | |||
public GQuery wrapAll(Element elem) {return null;} | |||
public GQuery wrapAll(GQuery query) {return null;} | |||
public GQuery wrapAll(String html) {return null;} | |||
public GQuery wrapInner(Element elem) {return null;} | |||
public GQuery wrapInner(GQuery query) {return null;} | |||
public GQuery wrapInner(String html) {return null;} | |||
} |
@@ -0,0 +1,54 @@ | |||
package com.google.gwt.query.jsquery.client; | |||
import java.util.logging.Logger; | |||
import com.google.gwt.core.client.EntryPoint; | |||
import com.google.gwt.core.client.GWT; | |||
import com.google.gwt.query.jsquery.client.GQueryOverlay.FunctionOverlay; | |||
import com.google.gwt.query.jsquery.client.GQueryOverlay.PredicateOverlay; | |||
public class JsQuery implements EntryPoint { | |||
public void onModuleLoad() { | |||
GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() { | |||
Logger l = Logger.getLogger("JsQuery"); | |||
public void onUncaughtException(Throwable e) { | |||
String r = ""; | |||
for (StackTraceElement s :e.getStackTrace()) { | |||
r += s + "\n"; | |||
} | |||
l.info(r); | |||
} | |||
}); | |||
// We just export the api, but we do not call GQueryOverlay.onLoad() so as | |||
// apps and plugins could load their stuff before calling it | |||
export(); | |||
// Un comment for testing stuff below | |||
// testJs(); | |||
} | |||
public static void export() { | |||
GWT.create(FunctionOverlay.class); | |||
GWT.create(PredicateOverlay.class); | |||
GWT.create(GQueryOverlay.class); | |||
} | |||
public static native void onLoad() /*-{ | |||
$wnd.onJsQueryLoad && $wnd.onJsQueryLoad(); | |||
$wnd.JsQuery && $wnd.JsQuery.onLoad && $wnd.JsQuery.onLoad(); | |||
}-*/; | |||
/** | |||
* Used to paste jquery code and test it in dev mode | |||
*/ | |||
private native static void testJs() /*-{ | |||
var l = @com.google.gwt.query.jsquery.client.JsQueryUtils::log(Ljava/lang/Object;); | |||
window = $wnd; | |||
document = $doc; | |||
$ = $wnd.$; | |||
// Paste jquery code here | |||
}-*/; | |||
} |
@@ -0,0 +1,10 @@ | |||
package com.google.gwt.query.jsquery.client; | |||
import com.google.gwt.core.client.EntryPoint; | |||
public class JsQueryApi implements EntryPoint { | |||
public void onModuleLoad() { | |||
JsQuery.onLoad(); | |||
} | |||
} |
@@ -0,0 +1,135 @@ | |||
package com.google.gwt.query.jsquery.client; | |||
import java.util.ArrayList; | |||
import java.util.List; | |||
import com.google.gwt.core.client.JavaScriptObject; | |||
import com.google.gwt.dom.client.Element; | |||
import com.google.gwt.dom.client.Node; | |||
import com.google.gwt.query.client.Function; | |||
import com.google.gwt.query.client.GQuery; | |||
import com.google.gwt.query.client.js.JsCache; | |||
import com.google.gwt.query.client.js.JsNodeArray; | |||
import com.google.gwt.query.client.js.JsUtils; | |||
/** | |||
* These are a set of utility methods needed in jsquery because | |||
* either they are not in the GQuery core yet, or they are already | |||
* there but we need to modify their behavior. | |||
* Most of them should be moved to the GQuery core api. | |||
* | |||
*/ | |||
public abstract class JsQueryUtils { | |||
private native static String dumpObject(JavaScriptObject o) /*-{ | |||
var s = ""; | |||
for (k in o) | |||
s += " " + k; | |||
return s; | |||
}-*/; | |||
public static GQuery dollar(Object o) { | |||
if (o instanceof String) { | |||
return GQuery.$((String) o); | |||
} else if (o instanceof JavaScriptObject) { | |||
JavaScriptObject jso = (JavaScriptObject) o; | |||
if (JsUtils.isFunction(jso)) { | |||
new JsUtils.JsFunction(jso).fe(); | |||
} else { | |||
GQuery r = GQuery.$(jso); | |||
if (!JsUtils.isWindow(jso) && !JsUtils.isElement(jso) && JsUtils.isArray(jso)) { | |||
JsCache c = jso.cast(); | |||
JsNodeArray elms = JsNodeArray.create(); | |||
for (int i = 0; i < c.length(); i++) { | |||
Object obj = c.get(i); | |||
if (obj instanceof Node) { | |||
elms.addNode((Node) obj); | |||
} | |||
} | |||
r = GQuery.$(elms); | |||
} | |||
return r; | |||
} | |||
} | |||
return GQuery.$(); | |||
} | |||
public static GQuery dollar(String s, Element ctx) { | |||
return GQuery.$(s, ctx); | |||
} | |||
public static void ready(Function f) { | |||
f.f(); | |||
} | |||
public static int inArray(Object object, Object array) { | |||
if (array instanceof List) { | |||
return ((List<?>)array).indexOf(object); | |||
} else if (object instanceof JavaScriptObject | |||
&& JsUtils.isElement((JavaScriptObject) object)) { | |||
return dollar(array).index((Element) object); | |||
} else if (array instanceof JavaScriptObject | |||
&& JsUtils.isArray((JavaScriptObject) array)) { | |||
return ((JsCache) array).indexOf(object); | |||
} | |||
return -1; | |||
} | |||
public static JavaScriptObject extend(Object... objs) { | |||
int i = 0, l = objs.length; | |||
boolean deep = false; | |||
JavaScriptObject ctx = null; | |||
Object target = objs[i]; | |||
if (target instanceof Boolean) { | |||
deep = (Boolean) target; | |||
if (l == 1) | |||
return ctx; | |||
target = objs[i++]; | |||
} | |||
if (l - i == 1) { | |||
i--; | |||
} else { | |||
ctx = (JavaScriptObject) target; | |||
} | |||
for (++i; i < l; i++) { | |||
if (objs[i] != null) { | |||
ctx = extendImpl(deep, ctx, objs[i]); | |||
} | |||
} | |||
return ctx; | |||
} | |||
private static native JavaScriptObject getDefaultPrototype() /*-{ | |||
return $wnd.JsQuery && $wnd.JsQuery.fn | |||
? $wnd.JsQuery.fn.prototype | |||
: null; | |||
}-*/; | |||
private static native JavaScriptObject extendImpl(boolean deep, | |||
JavaScriptObject ctx, Object s) /*-{ | |||
var d = ctx ? ctx : $wnd.JsQuery.fn.prototype || {}; | |||
for (k in s) { | |||
d[k] = s[k]; | |||
if (!ctx) | |||
$wnd.$[k] = s[k]; | |||
} | |||
return d; | |||
}-*/; | |||
public static JavaScriptObject[] each(JavaScriptObject[] objs, Function f) { | |||
ArrayList<Object> ret = new ArrayList<Object>(); | |||
for (Object o : objs) { | |||
f.setDataObject(o); | |||
if (f.fe(null, o)) { | |||
ret.add(o); | |||
} | |||
} | |||
return ret.toArray(new JavaScriptObject[0]); | |||
} | |||
public static void log(Object l) { | |||
System.out.println(l); | |||
} | |||
} |
@@ -0,0 +1,20 @@ | |||
<!doctype html> | |||
<html> | |||
<head> | |||
<title>JsQuery</title> | |||
<script src="jsquery.nocache.js" ></script> | |||
</head> | |||
<body> | |||
<div id='hello' style='display: none'>Hello</div> | |||
<script> | |||
onJsQueryLoad = function(){ | |||
$('#hello').show().attr("width", true); | |||
$('#hello').fadeOut(1000).text("Hello word").fadeIn(); | |||
} | |||
if (window.$) { | |||
$(document).ready(onJsQueryLoad); | |||
onJsQueryLoad = null; | |||
} | |||
</script> | |||
</body> | |||
</html> |
@@ -0,0 +1,7 @@ | |||
<module rename-to='jsmenu'> | |||
<inherits name='com.google.gwt.query.jsquery.JsQuery' /> | |||
<entry-point class="gwtquery.jsplugins.menu.client.JsQueryMenu" /> | |||
</module> | |||
@@ -1,4 +1,4 @@ | |||
package gwtquery.jsquery.client.plugins.menu; | |||
package gwtquery.jsplugins.menu.client; | |||
/** | |||
* | |||
@@ -10,7 +10,7 @@ package gwtquery.jsquery.client.plugins.menu; | |||
public abstract class JsMenu { | |||
public static native void loadPlugin() /*-{ | |||
var l = @gwtquery.jsquery.client.utils.JsQueryUtils::log(Ljava/lang/Object;); | |||
var l = @com.google.gwt.query.jsquery.client.JsQueryUtils::log(Ljava/lang/Object;); | |||
var window = $wnd; | |||
var document = $doc; | |||
var jQuery = $wnd.$; |
@@ -0,0 +1,12 @@ | |||
package gwtquery.jsplugins.menu.client; | |||
import com.google.gwt.core.client.EntryPoint; | |||
import com.google.gwt.query.jsquery.client.JsQuery; | |||
public class JsQueryMenu implements EntryPoint { | |||
public void onModuleLoad() { | |||
JsMenu.loadPlugin(); | |||
JsQuery.onLoad(); | |||
} | |||
} |
@@ -4,7 +4,7 @@ | |||
<head> | |||
<title>jQuery menu plugin demo page</title> | |||
<link rel="stylesheet" type="text/css" href="style.css" /> | |||
<script src="../../dev.nocache.js" ></script> | |||
<script src="jsmenu.nocache.js" ></script> | |||
<script type="text/javascript"> | |||
// JsQuery will run this function after it is asynchronously loaded |
@@ -11,8 +11,8 @@ | |||
} | |||
</script> | |||
<ul> | |||
<li><a href="javascript:goTo('dev/JsQuery.html')">JsQuery.html</a></li> | |||
<li><a href="javascript:goTo('dev/plugins/menu/demo.html')">jquery.menu.html</a></li> | |||
<li><a href="javascript:goTo('jsquery/JsQuery.html')">JsQuery.html</a></li> | |||
<li><a href="javascript:goTo('jsmenu/demo.html')">jquery.menu.html</a></li> | |||
</ul> | |||
</body> | |||
</html> |