* Copyright 2010 ArcBees 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.

*/

* @author Philippe Beaudoin

* @author Olivier Monaco

*/

  private static class ProxyEventDescription {

    public String eventFullName;

    public String functionName;

    public String handlerFullName;

    public String handlerMethodName;

  }

    public String functionName;

    public int gingectorParamIndex = -1;

    public boolean isStatic;

    public int placeRequestParamIndex = -1;

    public boolean returnString;

    public int setPlaceTitleHandlerParamIndex = -1;

  }

 

  private static class TabInfoFunctionDescription {

    public TabInfo annotation;

    public String functionName;

    public boolean hasGingectorParam;

    public boolean returnString; // Either returns a String or a TabInfo

  }

  private static final String asyncProviderClassName = AsyncProvider.class.getCanonicalName();

  private static final String baseGinjectorClassName = Ginjector.class.getCanonicalName();

  private static final String basePlaceClassName = Place.class.getCanonicalName();

  private static final String basePresenterClassName = Presenter.class.getCanonicalName();

  private static final String delayedBindClassName = DelayedBind.class.getCanonicalName();

  private static final String eventHandlerClassName = EventHandler.class.getCanonicalName();

  private static final String gatekeeperClassName = Gatekeeper.class.getCanonicalName();

  private static final String gwtEventClassName = GwtEvent.class.getCanonicalName();

  private static final String gwtEventTypeClassName = GwtEvent.Type.class.getCanonicalName();

  private static final String placeImplClassName = PlaceImpl.class.getCanonicalName();

  private static final String placeRequestClassName = PlaceRequest.class.getCanonicalName();

  private static final String placeWithGatekeeperClassName = PlaceWithGatekeeper.class.getCanonicalName();

  private static final String providerClassName = Provider.class.getCanonicalName();

  private static final String proxyImplClassName = ProxyImpl.class.getCanonicalName();

  private static final String proxyPlaceImplClassName = ProxyPlaceImpl.class.getCanonicalName();

  private static final String requestTabsHandlerClassName = RequestTabsHandler.class.getCanonicalName();

  private static final String revealContentHandlerClassName = RevealContentHandler.class.getCanonicalName();

  private static final String setPlaceTitleHandlerClassName = SetPlaceTitleHandler.class.getCanonicalName();

  private static final String tabContentProxyClassName = TabContentProxy.class.getCanonicalName();

  private static final String tabContentProxyImplClassName = TabContentProxyImpl.class.getCanonicalName();

  private static final String tabContentProxyPlaceImplClassName = TabContentProxyPlaceImpl.class.getCanonicalName();

  private static final String typeClassName = Type.class.getCanonicalName();

  private static final String tabDataClassName = TabData.class.getCanonicalName();

  private JGenericType asyncProviderClass;

  private JClassType baseGinjectorClass;

  private JClassType basePlaceClass;

  private JClassType basePresenterClass;

  private JClassType eventHandlerClass;

  private JClassType gatekeeperClass;

  private JGenericType gwtEventClass;

  private JGenericType gwtEventTypeClass;

  private JClassType placeRequestClass;

  private JGenericType providerClass;

  private JClassType requestTabsHandlerClass;

  private JClassType revealContentHandlerClass;

  private JClassType setPlaceTitleHandlerClass;

  private JClassType stringClass;

  private JClassType tabDataClass;

  private JClassType tabContentProxyClass;

  private JClassType typeClass;

  @Override

  public String generate(TreeLogger logger, GeneratorContext ctx,

      String requestedClass) throws UnableToCompleteException {

    findBaseTypes(ctx);

    TypeOracle oracle = ctx.getTypeOracle();

    // Find the requested class

    JClassType proxyInterface = oracle.findType(requestedClass);

    if (proxyInterface == null) {

      logger.log(TreeLogger.ERROR, "Unable to find metadata for type '"

          + requestedClass + "'", null);

      throw new UnableToCompleteException();

    }

    // If it's not an interface it's a custom user-made proxy class. Don't use

    // generator.

    if (proxyInterface.isInterface() == null) {

      return null;

    }

    ProxyStandard proxyStandardAnnotation = proxyInterface.getAnnotation(ProxyStandard.class);

    ProxyCodeSplit proxyCodeSplitAnnotation = proxyInterface.getAnnotation(ProxyCodeSplit.class);

    ProxyCodeSplitBundle proxyCodeSplitBundleAnnotation = proxyInterface.getAnnotation(ProxyCodeSplitBundle.class);

    int nbNonNullTags = 0;

    if (proxyStandardAnnotation != null) {

      nbNonNullTags++;

    }

    if (proxyCodeSplitAnnotation != null) {

      nbNonNullTags++;

    }

    if (proxyCodeSplitBundleAnnotation != null) {

      nbNonNullTags++;

    }

    // If there is no proxy tag, don't use generator.

    if (nbNonNullTags == 0) {

      return null;

    }

    // Make sure this proxy lies within a presenter

    JClassType presenterClass = proxyInterface.getEnclosingType();

    if (presenterClass == null

        || !presenterClass.isAssignableTo(basePresenterClass)) {

      logger.log(TreeLogger.ERROR,

          "Proxy must be enclosed in a class derived from '"

              + basePresenterClassName + "'", null);

      throw new UnableToCompleteException();

    }

    String presenterClassName = presenterClass.getName();

    // Watch out for more than one proxy tag

    if (nbNonNullTags > 1) {

      logger.log(TreeLogger.ERROR, "Proxy for '" + presenterClassName

          + "' has more than one @Proxy annotation.", null);

      throw new UnableToCompleteException();

    }

    // Find the package, build the generated class name.

    JPackage interfacePackage = proxyInterface.getPackage();

    String packageName = interfacePackage == null ? ""

        : interfacePackage.getName();

    String implClassName = presenterClassName

        + proxyInterface.getSimpleSourceName() + "Impl";

    String generatedClassName = packageName + "." + implClassName;

    // Create the printWriter

    PrintWriter printWriter = ctx.tryCreate(logger, packageName, implClassName);

    if (printWriter == null) {

      // We've already created it, so nothing to do

      return generatedClassName;

    }

    // Find ginjector

    String ginjectorClassName = null;

    try {

      ginjectorClassName = ctx.getPropertyOracle().getConfigurationProperty(

          "gin.ginjector").getValues().get(0);

    } catch (BadPropertyValueException e) {

      logger.log(TreeLogger.ERROR,

          "The required configuration property 'gin.ginjector' was not found.",

          e);

      throw new UnableToCompleteException();

    }

    JClassType ginjectorClass = oracle.findType(ginjectorClassName);

    if (ginjectorClass == null

        || !ginjectorClass.isAssignableTo(baseGinjectorClass)) {

      logger.log(TreeLogger.ERROR,

          "The configuration property 'gin.ginjector' is '"

              + ginjectorClassName + "' "

              + " which doesn't identify a type inheriting from 'Ginjector'.",

          null);

      throw new UnableToCompleteException();

    }

    // Check if this proxy is also a place.

    String nameToken = null;

    String newPlaceCode = null; // TODO Get rid of this when we remove @PlaceInstance

    String getGatekeeperMethod = null;

    String title = null;

    if (proxyInterface.isAssignableTo(basePlaceClass)) {

      NameToken nameTokenAnnotation = proxyInterface.getAnnotation(NameToken.class);

      if (nameTokenAnnotation == null) {

        logger.log(TreeLogger.ERROR,

            "The proxy for '" + presenterClassName

                + "' is a Place, but is not annotated with @' +"

                + NameToken.class.getSimpleName() + ".", null);

        throw new UnableToCompleteException();

      }

      nameToken = nameTokenAnnotation.value();

      UseGatekeeper gatekeeperAnnotation = proxyInterface.getAnnotation(UseGatekeeper.class);

      if (gatekeeperAnnotation != null) {

        String gatekeeperName = gatekeeperAnnotation.value().getCanonicalName();

        JClassType customGatekeeperClass = oracle.findType(gatekeeperName);

        if (customGatekeeperClass == null) {

          logger.log(TreeLogger.ERROR, "The class '" + gatekeeperName

              + "' provided to @" + UseGatekeeper.class.getSimpleName()

              + " can't be found.", null);

          throw new UnableToCompleteException();

        }

        if (!customGatekeeperClass.isAssignableTo(gatekeeperClass)) {

          logger.log(TreeLogger.ERROR, "The class '" + gatekeeperName

              + "' provided to @" + UseGatekeeper.class.getSimpleName()

              + " does not inherit from '" + gatekeeperClassName + "'.", null);

          throw new UnableToCompleteException();

        }

        // Find the appropriate get method in the Ginjector

        for (JMethod method : ginjectorClass.getMethods()) {

          JClassType returnType = method.getReturnType().isClassOrInterface();

          if (method.getParameters().length == 0 && returnType != null

              && returnType.isAssignableTo(customGatekeeperClass)) {

            getGatekeeperMethod = method.getName();

            break;

          }

        }

        if (getGatekeeperMethod == null) {

          logger.log(TreeLogger.ERROR,

              "The Ginjector '" + ginjectorClassName

                  + "' does not have a get() method returning '"

                  + gatekeeperName + "'. This is required when using @"

                  + UseGatekeeper.class.getSimpleName() + ".", null);

          throw new UnableToCompleteException();

        }

      }

      if (getGatekeeperMethod == null && newPlaceCode == null

          && proxyInterface.getAnnotation(NoGatekeeper.class) == null) {

        // No Gatekeeper specified, see if there is a DefaultGatekeeper defined

        // in the ginjector

        for (JMethod method : ginjectorClass.getMethods()) {

          if (method.getAnnotation(DefaultGatekeeper.class) != null) {

            JClassType returnType = method.getReturnType().isClassOrInterface();

            if (getGatekeeperMethod != null) {

              logger.log(TreeLogger.ERROR, "The Ginjector '"

                  + ginjectorClassName

                  + "' has more than one method annotated with @"

                  + DefaultGatekeeper.class.getSimpleName()

                  + ". This is not allowed.", null);

              throw new UnableToCompleteException();

            }

            if (method.getParameters().length != 0 || returnType == null

                || !returnType.isAssignableTo(gatekeeperClass)) {

              logger.log(

                  TreeLogger.ERROR,

                  "The method '"

                      + method.getName()

                      + "' in the Ginjector '"

                      + ginjectorClassName

                      + "' is annotated with @"

                      + DefaultGatekeeper.class.getSimpleName()

                      + " but has an invalid signature. It must not take any parameter and must return a class derived from '"

                      + gatekeeperClassName + "'.", null);

              throw new UnableToCompleteException();

            }

            getGatekeeperMethod = method.getName();

          }

        }

      }

      Title titleAnnotation = proxyInterface.getAnnotation(Title.class);

      if (titleAnnotation != null) {

        title = titleAnnotation.value();

      }

    }

    TitleFunctionDescription titleFunctionDescription = findTitleFunction(

        logger, presenterClass, presenterClassName, ginjectorClassName,

        ginjectorClass);

    if (titleFunctionDescription != null && title != null) {

      logger.log(TreeLogger.ERROR, "The proxy for '" + presenterClassName

          + "' is annotated with @' +" + Title.class.getSimpleName()

          + " and its presenter has a method annotated with @"

          + TitleFunction.class.getSimpleName() + ". This is not supported.",

          null);

      throw new UnableToCompleteException();

    }

    // Scan the containing class for @ProxyEvent annotated methods

    List<ProxyEventDescription> proxyEvents = findProxyEvents(logger,

        presenterClass, presenterClassName, ginjectorClassName, ginjectorClass);

    // Check if this proxy is also a TabContentProxy.

    JClassType tabContainerClass = null;

    String tabContainerClassName = null;

    Integer tabPriority = null;

    String tabLabel = null;

    TabInfoFunctionDescription tabInfoFunctionDescription = null;

    String tabNameToken = null;

    if (proxyInterface.isAssignableTo(tabContentProxyClass)) {

      TabInfo tabInfoAnnotation = proxyInterface.getAnnotation(TabInfo.class);

      tabInfoFunctionDescription = findTabInfoFunction(

          logger, presenterClass, presenterClassName, ginjectorClassName,

          ginjectorClass);

     

      // Ensure @TabInfo is there exactly once

      if (tabInfoAnnotation != null && tabInfoFunctionDescription != null) {

        logger.log(TreeLogger.ERROR, "Presenter " + presenterClassName

            + " contains both a proxy and a method annotated with @' +"

            + TabInfo.class.getSimpleName() + ". This is illegal.", null);

        throw new UnableToCompleteException();

      }

      if (tabInfoFunctionDescription != null) {

        tabInfoAnnotation = tabInfoFunctionDescription.annotation;

      }     

      if (tabInfoAnnotation == null) {

        logger.log(TreeLogger.ERROR, "The proxy for '" + presenterClassName

            + "' is a TabContentProxy, but is not annotated with @' +"

            + TabInfo.class.getSimpleName()

            + " and its presenter has no method annotated with it either.", null);

        throw new UnableToCompleteException();

      }

     

      // Extract the label if its in TabInfo

      if (tabInfoAnnotation.label().length() > 0) {

        tabLabel = tabInfoAnnotation.label();

      }

      if (tabLabel != null && tabInfoFunctionDescription != null) {

        logger.log(TreeLogger.ERROR, "The @" + TabInfo.class.getSimpleName()

            + " in " + presenterClassName + " defines the 'label' parameter and"

            + " annotates a method, this is not permitted.", null);

        throw new UnableToCompleteException();

      }

      if (tabLabel == null && tabInfoFunctionDescription == null) {

        logger.log(TreeLogger.ERROR, "The @" + TabInfo.class.getSimpleName()

            + " in " + presenterClassName + " does not define the 'label' parameter and"

            + " does not annotate a method, this is not permitted.", null);

        throw new UnableToCompleteException();

      }

      // Extract the label if its in TabInfo (it is a negative integer if not set)

      if (tabInfoAnnotation.priority() >= 0) {

        tabPriority = tabInfoAnnotation.priority();

      }

      if (tabPriority != null &&

          tabInfoFunctionDescription != null && !tabInfoFunctionDescription.returnString) {

        logger.log(TreeLogger.ERROR, "The @" + TabInfo.class.getSimpleName()

            + " in " + presenterClassName + " defines the 'priority' parameter and"

            + " annotates a method returning TabData, this is not permitted.", null);

        throw new UnableToCompleteException();

      }

      if (tabPriority == null &&

          (tabInfoFunctionDescription == null || tabInfoFunctionDescription.returnString)) {

        logger.log(TreeLogger.ERROR, "The @" + TabInfo.class.getSimpleName()

            + " in " + presenterClassName + " does not define the 'priority' parameter and"

            + " does not annotate a method returning TabData, this is not permitted.", null);

        throw new UnableToCompleteException();

      }

     

      // Find the container

      tabContainerClass = oracle.findType(tabInfoAnnotation.container().getCanonicalName());

      if (tabContainerClass == null) {

        logger.log(TreeLogger.ERROR, "The container '"

            + tabInfoAnnotation.container().getCanonicalName()

            + "' in the proxy annotation for '" + presenterClassName

            + "' was not found.", null);

        throw new UnableToCompleteException();

      }

      tabContainerClassName = tabContainerClass.getParameterizedQualifiedSourceName();

     

      // Find the name token to use when the tab is clicked

      if (tabInfoAnnotation.nameToken().length() > 0) {

        tabNameToken = tabInfoAnnotation.nameToken();

      }

      if (tabNameToken != null && nameToken != null) {

        logger.log(TreeLogger.ERROR, "The @" + TabInfo.class.getSimpleName()

            + " in " + presenterClassName + " defines the 'nameToken' parameter but"

            + " its proxy is a place, this is not permitted.", null);

        throw new UnableToCompleteException();

      }

      if (tabNameToken == null && nameToken == null) {

        logger.log(TreeLogger.ERROR, "The @" + TabInfo.class.getSimpleName()

            + " in " + presenterClassName + " does not define the 'nameToken' parameter and"

            + " its proxy is not a place, this is not permitted.", null);

        throw new UnableToCompleteException();

      }

    }

    // Start composing the class

    ClassSourceFileComposerFactory composerFactory = new ClassSourceFileComposerFactory(

        packageName, implClassName);

    // Setup required imports

    // TODO cleanup imports

    composerFactory.addImport(GWT.class.getCanonicalName());

    composerFactory.addImport(Inject.class.getCanonicalName()); // Obsolete?

    composerFactory.addImport(Provider.class.getCanonicalName());

    composerFactory.addImport(AsyncProvider.class.getCanonicalName());

    composerFactory.addImport(EventBus.class.getCanonicalName());

    composerFactory.addImport(StandardProvider.class.getCanonicalName());

    composerFactory.addImport(CodeSplitProvider.class.getCanonicalName());

    composerFactory.addImport(CodeSplitBundleProvider.class.getCanonicalName());

    composerFactory.addImport(ProxyFailureHandler.class.getCanonicalName());

    composerFactory.addImport(proxyImplClassName);

    composerFactory.addImport(proxyPlaceImplClassName);

    composerFactory.addImport(RevealContentHandler.class.getCanonicalName());

    composerFactory.addImport(delayedBindClassName);

    composerFactory.addImport(tabContentProxyPlaceImplClassName);

    composerFactory.addImport(DelayedBindRegistry.class.getCanonicalName());

    composerFactory.addImport(Ginjector.class.getCanonicalName());

    composerFactory.addImport(RevealContentEvent.class.getCanonicalName()); // Obsolete?

    composerFactory.addImport(Scheduler.class.getCanonicalName());

    composerFactory.addImport(Command.class.getCanonicalName());

    composerFactory.addImport(AsyncCallback.class.getCanonicalName());

    composerFactory.addImport(TabData.class.getCanonicalName());

    composerFactory.addImport(TabDataBasic.class.getCanonicalName());

    if (title != null || titleFunctionDescription != null) {

      composerFactory.addImport(GetPlaceTitleEvent.class.getCanonicalName());

      composerFactory.addImport(AsyncCallback.class.getCanonicalName());

      composerFactory.addImport(Throwable.class.getCanonicalName());

    }

    // Sets interfaces and superclass

    composerFactory.addImplementedInterface(proxyInterface.getParameterizedQualifiedSourceName());

    composerFactory.addImplementedInterface(delayedBindClassName);

    if (nameToken == null) {

      // Not a place

      if (tabContainerClass == null) {

        // Standard proxy (not a Place, not a TabContentProxy)

        composerFactory.setSuperclass(proxyImplClassName + "<"

            + presenterClassName + ">");

      } else {

        if (tabNameToken == null) {

          logger.log(TreeLogger.ERROR, "Class '" + presenterClassName

              + "' is not a Place, its @TabInfo needs to define nameToken.",

              null);

          throw new UnableToCompleteException();

        }

        // TabContentProxy (not a Place, but a TabContentProxy)

        composerFactory.setSuperclass(tabContentProxyImplClassName + "<"

            + presenterClassName + ">");

      }

    } else {

      // A place

      if (tabContainerClass == null) {

        // Place (but not a TabContentProxy)

        composerFactory.setSuperclass(proxyPlaceImplClassName + "<"

            + presenterClassName + ">");

      } else {

        if (tabNameToken != null) {

          logger.log(

              TreeLogger.ERROR,

              "Class '"

                  + presenterClassName

                  + "' has a @NameToken and its @TabInfo has a nameToken, unsupported.",

              null);

          throw new UnableToCompleteException();

        }

        // Place and TabContentProxy

        composerFactory.setSuperclass(tabContentProxyPlaceImplClassName + "<"

            + presenterClassName + ">");

      }

    }

    // Add all implemented handlers

    for (ProxyEventDescription desc : proxyEvents) {

      composerFactory.addImplementedInterface(desc.handlerFullName);

    }

    // Get a source writer

    SourceWriter writer = composerFactory.createSourceWriter(ctx, printWriter);

    // Private variable to store the gingector

    writer.println();

    writer.println("private " + ginjectorClassName + " ginjector;");

    if (nameToken == null) {

      // Not a place proxy

     

      if (tabContainerClass != null) {

        // A TabContentProxy

        writeGetTabDataInternalMethod(ginjectorClassName, presenterClassName,

            tabLabel, tabPriority, tabInfoFunctionDescription, writer);

      }

     

    } else {

      // Place proxy

      // BEGIN Enclosed proxy class

      writer.println();

      writer.println("public static class WrappedProxy");

      if (tabContainerClass == null) {

        writer.println("extends " + proxyImplClassName + "<"

            + presenterClassName + "> {");

      } else {

        writer.println("extends " + tabContentProxyImplClassName + "<"

            + presenterClassName + "> {");

      }

      writer.indent();

      if (tabContainerClass != null) {

        // A TabContentProxy

        writeGetTabDataInternalMethod(ginjectorClassName, presenterClassName,

            tabLabel, tabPriority, tabInfoFunctionDescription, writer);

      }

     

      // Enclosed proxy construcotr

      writer.println();

      writer.println("public WrappedProxy() {}");

      // BEGIN Enclosed proxy Bind method

      writer.println();

      writer.println("private void delayedBind(" + ginjectorClassName

          + " ginjector) {");

      writer.indent();

      if (tabContainerClass != null) {

        writeRequestTabHandler(logger, presenterClassName, nameToken,

            tabContainerClass, tabContainerClassName, tabPriority, tabLabel,

            tabInfoFunctionDescription, writer);

      }

     

      // Call ProxyImpl bind method.

      writer.println("bind(ginjector.getProxyFailureHandler(),ginjector.getEventBus());");

      writePresenterProvider(logger, ctx, writer, proxyCodeSplitAnnotation,

          proxyCodeSplitBundleAnnotation, ginjectorClass, ginjectorClassName,

          presenterClass, presenterClassName);

      writeSlotHandlers(logger, ctx, proxyCodeSplitAnnotation,

          proxyCodeSplitBundleAnnotation, presenterClass, presenterClassName,

          ginjectorClassName, ginjectorClass, writer);

      writer.outdent();

      writer.println("}");

      // END Enclosed proxy class

      writer.outdent();

      writer.println("}");

      // Check if title override if needed

      // Simple string title

      if (title != null) {

        writer.println();

        writer.println("protected void getPlaceTitle(GetPlaceTitleEvent event) {");

        writer.indent();

        writer.println("event.getHandler().onSetPlaceTitle( \"" + title

            + "\" );");

        writer.outdent();

        writer.println("}");

      }

      // Presenter static title method returning string

      if (titleFunctionDescription != null && titleFunctionDescription.isStatic

          && titleFunctionDescription.returnString) {

        writer.println();

        writer.println("protected void getPlaceTitle(GetPlaceTitleEvent event) {");

        writer.indent();

        writer.print("String title = " + presenterClassName + ".");

        writeTitleFunction(titleFunctionDescription, writer);

        writer.println();

        writer.println("event.getHandler().onSetPlaceTitle( title );");

        writer.outdent();

        writer.println("}");

      }

      // Presenter static title method taking a handler (not returning a string)

      if (titleFunctionDescription != null && titleFunctionDescription.isStatic

          && !titleFunctionDescription.returnString) {

        writer.println();

        writer.println("protected void getPlaceTitle(GetPlaceTitleEvent event) {");

        writer.indent();

        writer.print(presenterClassName + ".");

        writeTitleFunction(titleFunctionDescription, writer);

        writer.println();

        writer.println("}");

      }

      // Presenter non-static title method returning a string

      if (titleFunctionDescription != null

          && !titleFunctionDescription.isStatic

          && titleFunctionDescription.returnString) {

        writer.println();

        writer.println("protected void getPlaceTitle(final GetPlaceTitleEvent event) {");

        writer.indent();

        writer.println("getPresenter( new AsyncCallback<" + presenterClassName

            + ">(){");

        writer.indent();

        writer.indent();

        writer.println("public void onSuccess(" + presenterClassName + " p ) {");

        writer.indent();

        writer.print("String title = p.");

        writeTitleFunction(titleFunctionDescription, writer);

        writer.println();

        writer.println("event.getHandler().onSetPlaceTitle( title );");

        writer.outdent();

        writer.println(" }");

        writer.println("public void onFailure(Throwable t) { event.getHandler().onSetPlaceTitle(null); }");

        writer.outdent();

        writer.println("} );");

        writer.outdent();

        writer.println("}");

      }

      // Presenter non-static title method taking a handler (not returning a string)

      if (titleFunctionDescription != null

          && !titleFunctionDescription.isStatic

          && !titleFunctionDescription.returnString) {

        writer.println();

        writer.println("protected void getPlaceTitle(final GetPlaceTitleEvent event) {");

        writer.indent();

        writer.println("getPresenter( new AsyncCallback<" + presenterClassName

            + ">(){");

        writer.indent();

        writer.indent();

        writer.print("public void onSuccess(" + presenterClassName

            + " p ) { p.");

        writeTitleFunction(titleFunctionDescription, writer);

        writer.println(" }");

        writer.println("public void onFailure(Throwable t) { event.getHandler().onSetPlaceTitle(null); }");

        writer.outdent();

        writer.println("} );");

        writer.outdent();

        writer.println("}");

      }

    }

    // Constructor

    writer.println();

    writer.println("public " + implClassName + "() {");

    writer.indent();

    writer.println("DelayedBindRegistry.register(this);");

    writer.outdent();

    writer.println("}");

    // BEGIN Bind method

    writer.println();

    writer.println("@Override");

    writer.println("public void delayedBind(Ginjector baseGinjector) {");

    writer.indent();

    writeGinjector(writer, ginjectorClassName);

    if (nameToken == null) {

      // Standard proxy (not a Place)

      if (tabContainerClass != null) {

        writeRequestTabHandler(logger, presenterClassName, tabNameToken,

            tabContainerClass, tabContainerClassName, tabPriority, tabLabel,

            tabInfoFunctionDescription, writer);

      }

      // Call ProxyImpl bind method.

      writer.println("bind(ginjector.getProxyFailureHandler(),ginjector.getEventBus());");

      writePresenterProvider(logger, ctx, writer, proxyCodeSplitAnnotation,

          proxyCodeSplitBundleAnnotation, ginjectorClass, ginjectorClassName,

          presenterClass, presenterClassName);

      writeSlotHandlers(logger, ctx, proxyCodeSplitAnnotation,

          proxyCodeSplitBundleAnnotation, presenterClass, presenterClassName,

          ginjectorClassName, ginjectorClass, writer);

    } else {

      // Place proxy

      // Call ProxyPlaceAbstract bind method.

      writer.println("bind(ginjector.getProxyFailureHandler(), ");

      writer.println("    ginjector.getPlaceManager(),");

      writer.println("    ginjector.getEventBus());");

      writer.println("WrappedProxy wrappedProxy = GWT.create(WrappedProxy.class);");

      writer.println("wrappedProxy.delayedBind( ginjector ); ");

      writer.println("proxy = wrappedProxy; ");

      writer.println("String nameToken = \"" + nameToken + "\"; ");

      if (newPlaceCode == null) {

        if (getGatekeeperMethod == null) {

          writer.println("place = new " + placeImplClassName + "( nameToken );");

        } else {

          writer.println("place = new " + placeWithGatekeeperClassName

              + "( nameToken, ginjector." + getGatekeeperMethod + "() );");

        }

      } else {

        writer.println("place = " + newPlaceCode + ";");

      }

    }

    // Register all @ProxyEvent

    for (ProxyEventDescription desc : proxyEvents) {

      writer.println("getEventBus().addHandler( " + desc.eventFullName

          + ".getType(), this );");

    }

    // END Bind method

    writer.outdent();

    writer.println("}");

    // Write all handler methods

    for (ProxyEventDescription desc : proxyEvents) {

      writer.println("");

      writeHandlerMethod(presenterClassName, desc, writer);

    }

    writer.commit(logger);

    return generatedClassName;

  }

  private void writeGetTabDataInternalMethod(String ginjectorClassName,

      String presenterClassName, String tabLabel, Integer tabPriority,

      TabInfoFunctionDescription tabLabelFunctionDescription,

      SourceWriter writer) {

    if (tabLabel != null) {

      // Simple string tab label

      writer.println();

      writer.println("protected TabData getTabDataInternal(" + ginjectorClassName + " ginjector) {");

      writer.indent();

      writer.println("  return new TabDataBasic(\"" + tabLabel + "\", " + tabPriority + ");");

      writer.outdent();

      writer.println("}");

    } else if (tabLabelFunctionDescription.returnString) {

      // Presenter static method returning a string

      writer.println();

      writer.println("protected TabData getTabDataInternal(" + ginjectorClassName + " ginjector) {");

      writer.indent();

      writer.print("  return new TabDataBasic(");

      writer.print(presenterClassName + ".");

      writeTabInfoFunctionCall(tabLabelFunctionDescription, writer);

      writer.println(", " + tabPriority + ");");

      writer.outdent();

      writer.println("}");

    } else {

      // Presenter static method returning tab data

      writer.println();

      writer.println("protected TabData getTabDataInternal(" + ginjectorClassName + " ginjector) {");

      writer.indent();

      writer.print("  return ");

      writer.print(presenterClassName + ".");

      writeTabInfoFunctionCall(tabLabelFunctionDescription, writer);

      writer.println(";");

      writer.outdent();

      writer.println("}");

    }

  }

  /**

   * Make sure all the required base type information is known.

   *

   * @param ctx The generator context.

   */

  private void findBaseTypes(GeneratorContext ctx) {

    TypeOracle oracle = ctx.getTypeOracle();

    // Find the required base types

    stringClass = oracle.findType("java.lang.String");

    basePresenterClass = oracle.findType(basePresenterClassName);

    baseGinjectorClass = oracle.findType(baseGinjectorClassName);

    typeClass = oracle.findType(typeClassName);

    revealContentHandlerClass = oracle.findType(revealContentHandlerClassName);

    requestTabsHandlerClass = oracle.findType(requestTabsHandlerClassName);

    providerClass = oracle.findType(providerClassName).isGenericType();

    asyncProviderClass = oracle.findType(asyncProviderClassName).isGenericType();

    basePlaceClass = oracle.findType(basePlaceClassName);

    tabContentProxyClass = oracle.findType(tabContentProxyClassName);

    gatekeeperClass = oracle.findType(gatekeeperClassName);

    placeRequestClass = oracle.findType(placeRequestClassName);

    gwtEventClass = oracle.findType(gwtEventClassName).isGenericType();

    gwtEventTypeClass = oracle.findType(gwtEventTypeClassName).isGenericType();

    eventHandlerClass = oracle.findType(eventHandlerClassName);

    setPlaceTitleHandlerClass = oracle.findType(setPlaceTitleHandlerClassName);

    tabDataClass = oracle.findType(tabDataClassName);

  }

  private List<ProxyEventDescription> findProxyEvents(TreeLogger logger,

      JClassType presenterClass, String presenterClassName,

      String ginjectorClassName, JClassType ginjectorClass)

      throws UnableToCompleteException {

    // Look for @ProxyEvent methods in the parent presenter

    List<ProxyEventDescription> result = new ArrayList<ProxyEventDescription>();

    for (JMethod method : presenterClass.getMethods()) {

      ProxyEvent annotation = method.getAnnotation(ProxyEvent.class);

      if (annotation != null) {

        ProxyEventDescription desc = new ProxyEventDescription();

        desc.functionName = method.getName();

        JClassType methodReturnType = method.getReturnType().isClassOrInterface();

        if (methodReturnType != null

            || method.getReturnType().isPrimitive() != JPrimitiveType.VOID) {

          logger.log(

              TreeLogger.WARN,

              "In presenter "

                  + presenterClassName

                  + ", method "

                  + desc.functionName

                  + " annotated with @"

                  + ProxyEvent.class.getSimpleName()

                  + " returns something else than void. Return value will be ignored.");

        }

        if (method.getParameters().length != 1) {

          logger.log(

              TreeLogger.ERROR,

              "In presenter "

                  + presenterClassName

                  + ", method "

                  + desc.functionName

                  + " annotated with @"

                  + ProxyEvent.class.getSimpleName()

                  + " needs to have exactly 1 parameter of a type derived from GwtEvent.");

          throw new UnableToCompleteException();

        }

        JClassType eventType = method.getParameters()[0].getType().isClassOrInterface();

        if (eventType == null || !eventType.isAssignableTo(gwtEventClass)) {

          logger.log(TreeLogger.ERROR, "In presenter " + presenterClassName

              + ", method " + desc.functionName + " annotated with @"

              + ProxyEvent.class.getSimpleName()

              + ", the parameter must be derived from GwtEvent.");

          throw new UnableToCompleteException();

        }

        desc.eventFullName = eventType.getQualifiedSourceName();

        // Make sure the eventType has a static getType method

        JMethod getTypeMethod = eventType.findMethod("getType", new JType[0]);

        if (getTypeMethod == null || !getTypeMethod.isStatic()

            || getTypeMethod.getParameters().length != 0) {

          logger.log(TreeLogger.ERROR, "In presenter " + presenterClassName

              + ", method " + desc.functionName + " annotated with @"

              + ProxyEvent.class.getSimpleName() + ". The event class "

              + eventType.getName()

              + " does not have a static getType method with no parameters.");

          throw new UnableToCompleteException();

        }

        JClassType getTypeReturnType = getTypeMethod.getReturnType().isClassOrInterface();

        if (getTypeReturnType == null

            || !getTypeReturnType.isAssignableTo(gwtEventTypeClass)) {

          logger.log(TreeLogger.ERROR, "In presenter " + presenterClassName

              + ", method " + desc.functionName + " annotated with @"

              + ProxyEvent.class.getSimpleName() + ". The event class "

              + eventType.getName()

              + " getType() method  not return a GwtEvent.Type object.");

          throw new UnableToCompleteException();

        }

        // Find the handler class via the dispatch method

        JClassType handlerType = null;

        for (JMethod eventMethod : eventType.getMethods()) {

          if (eventMethod.getName().equals("dispatch")

              && eventMethod.getParameters().length == 1) {

            JClassType maybeHandlerType = eventMethod.getParameters()[0].getType().isClassOrInterface();

            if (maybeHandlerType != null

                && maybeHandlerType.isAssignableTo(eventHandlerClass)) {

              if (handlerType != null) {

                logger.log(TreeLogger.ERROR, "In presenter "

                    + presenterClassName + ", method " + desc.functionName

                    + " annotated with @" + ProxyEvent.class.getSimpleName()

                    + ". The event class " + eventType.getName()

                    + " has more than one potential 'dispatch' method.");

                throw new UnableToCompleteException();

              }

              handlerType = maybeHandlerType;

            }

          }

        }

        if (handlerType == null) {

          logger.log(TreeLogger.ERROR, "In presenter " + presenterClassName

              + ", method " + desc.functionName + " annotated with @"

              + ProxyEvent.class.getSimpleName() + ". The event class "

              + eventType.getName() + " has no valid 'dispatch' method.");

          throw new UnableToCompleteException();

        }

        desc.handlerFullName = handlerType.getQualifiedSourceName();

        // Find the handler method

        if (handlerType.getMethods().length != 1) {

          logger.log(TreeLogger.ERROR, "In presenter " + presenterClassName

              + ", method " + desc.functionName + " annotated with @"

              + ProxyEvent.class.getSimpleName() + ". The handler class "

              + handlerType.getName() + " has more than one method.");

          throw new UnableToCompleteException();

        }

        JMethod handlerMethod = handlerType.getMethods()[0];

        JClassType handlerMethodReturnType = handlerMethod.getReturnType().isClassOrInterface();

        if (handlerMethodReturnType != null

            || handlerMethod.getReturnType().isPrimitive() != JPrimitiveType.VOID) {

          logger.log(

              TreeLogger.WARN,

              "In presenter "

                  + presenterClassName

                  + ", method "

                  + desc.functionName

                  + " annotated with @"

                  + ProxyEvent.class.getSimpleName()

                  + ". The handler class "

                  + handlerType.getName()

                  + " method "

                  + handlerMethod.getName()

                  + " returns something else than void. Return value will be ignored.");

        }

        desc.handlerMethodName = handlerMethod.getName();

        // Warn if handlerMethodName is different

        if (!desc.handlerMethodName.equals(desc.functionName)) {

          logger.log(

              TreeLogger.WARN,

              "In presenter "

                  + presenterClassName

                  + ", method "

                  + desc.functionName

                  + " annotated with @"

                  + ProxyEvent.class.getSimpleName()

                  + ". The handler class "

                  + handlerType.getName()

                  + " method "

                  + handlerMethod.getName()

                  + " differs from the annotated method. You should use the same method name for easier reference.");

        }

        // Make sure that handler method name is not already used

        for (ProxyEventDescription prevDesc : result) {

          if (prevDesc.handlerMethodName.equals(desc.handlerMethodName)

              && prevDesc.eventFullName.equals(desc.eventFullName)) {

            logger.log(TreeLogger.ERROR, "In presenter " + presenterClassName

                + ", method " + desc.functionName + " annotated with @"

                + ProxyEvent.class.getSimpleName() + ". The handler method "

                + handlerMethod.getName() + " is already used by method "

                + prevDesc.functionName + ".");

            throw new UnableToCompleteException();

          }

        }

        result.add(desc);

      }

    }

    return result;

  }

  private TitleFunctionDescription findTitleFunction(TreeLogger logger,

      JClassType presenterClass, String presenterClassName,

      String ginjectorClassName, JClassType ginjectorClass)

      throws UnableToCompleteException {

    // Look for the title function in the parent presenter

    TitleFunctionDescription result = null;

    for (JMethod method : presenterClass.getMethods()) {

      TitleFunction annotation = method.getAnnotation(TitleFunction.class);

      if (annotation != null) {

        if (result != null) {

          logger.log(TreeLogger.ERROR, "At least two methods in presenter "

              + presenterClassName + "are annotated with @"

              + TitleFunction.class.getSimpleName() + ". This is illegal.");

          throw new UnableToCompleteException();

        }

        result = new TitleFunctionDescription();

        result.functionName = method.getName();

        result.isStatic = method.isStatic();

        JClassType classReturnType = method.getReturnType().isClassOrInterface();

        if (classReturnType != null && classReturnType == stringClass) {

          result.returnString = true;

        } else {

          result.returnString = false;

          JPrimitiveType primitiveReturnType = method.getReturnType().isPrimitive();

          if (primitiveReturnType == null

              || primitiveReturnType != JPrimitiveType.VOID) {

            logger.log(

                TreeLogger.WARN,

                "In presenter "

                    + presenterClassName

                    + ", method "

                    + result.functionName

                    + " annotated with @"

                    + TitleFunction.class.getSimpleName()

                    + " returns something else than void or String. Return value will be ignored and void will be assumed.");

          }

        }

        int i = 0;

        for (JParameter parameter : method.getParameters()) {

          JClassType parameterType = parameter.getType().isClassOrInterface();

          if (parameterType.isAssignableFrom(ginjectorClass)

              && result.gingectorParamIndex == -1) {

            result.gingectorParamIndex = i;

          } else if (parameterType.isAssignableFrom(placeRequestClass)

              && result.placeRequestParamIndex == -1) {

            result.placeRequestParamIndex = i;

          } else if (parameterType.isAssignableFrom(setPlaceTitleHandlerClass)

              && result.setPlaceTitleHandlerParamIndex == -1) {

            result.setPlaceTitleHandlerParamIndex = i;

          } else {

            logger.log(TreeLogger.ERROR, "In presenter " + presenterClassName

                + ", in method " + result.functionName + " annotated with @"

                + TitleFunction.class.getSimpleName() + " parameter " + i

                + " is invalid. Method can have at most one parameter of type "

                + ginjectorClassName + ", " + placeRequestClass.getName()

                + " or " + setPlaceTitleHandlerClass.getName());

            throw new UnableToCompleteException();

          }

          i++;

        }

        if (result.returnString && result.setPlaceTitleHandlerParamIndex != -1) {

          logger.log(

              TreeLogger.ERROR,

              "In presenter "

                  + presenterClassName

                  + ", the method "

                  + result.functionName

                  + " annotated with @"

                  + TitleFunction.class.getSimpleName()

                  + " returns a string and accepts a "

                  + setPlaceTitleHandlerClass.getName()

                  + " parameter. "

                  + "This is not supported, you can have only one or the other.");

          throw new UnableToCompleteException();

        }

        if (!result.returnString && result.setPlaceTitleHandlerParamIndex == -1) {

          logger.log(TreeLogger.ERROR, "In presenter " + presenterClassName

              + ", the method " + result.functionName + " annotated with @"

              + TitleFunction.class.getSimpleName()

              + " doesn't return a string and doesn't accept a "

              + setPlaceTitleHandlerClass.getName() + " parameter. "

              + "You need one or the other.");

          throw new UnableToCompleteException();

        }

      }

    }

    return result;

  }

  private TabInfoFunctionDescription findTabInfoFunction(TreeLogger logger,

      JClassType presenterClass, String presenterClassName,

      String ginjectorClassName, JClassType ginjectorClass)

      throws UnableToCompleteException {

    // Look for the title function in the parent presenter

    TabInfoFunctionDescription result = null;

    for (JMethod method : presenterClass.getMethods()) {

      TabInfo annotation = method.getAnnotation(TabInfo.class);

      if (annotation != null) {

        if (result != null) {

          logger.log(TreeLogger.ERROR, "At least two methods in presenter "

              + presenterClassName + "are annotated with @"

              + TabInfo.class.getSimpleName() + ". This is illegal.");

          throw new UnableToCompleteException();

        }

        result = new TabInfoFunctionDescription();

        result.annotation = annotation;

        result.functionName = method.getName();

        if (!method.isStatic()) {

          logger.log(

              TreeLogger.ERROR,

              "In presenter "

                  + presenterClassName

                  + ", method "

                  + result.functionName

                  + " annotated with @"

                  + TabInfo.class.getSimpleName()

                  + " is not static. This is illegal.");

          throw new UnableToCompleteException();

        }

        JClassType classReturnType = method.getReturnType().isClassOrInterface();

        if (classReturnType == stringClass) {

          result.returnString = true;

        } else if (classReturnType.isAssignableFrom(tabDataClass)) {

          result.returnString = false;

        } else {

          logger.log(

              TreeLogger.ERROR,

              "In presenter "

                  + presenterClassName

                  + ", method "

                  + result.functionName

                  + " annotated with @"

                  + TabInfo.class.getSimpleName()

                  + " must return either a String or a "

                  + TabData.class.getSimpleName());

          throw new UnableToCompleteException();

        }

        JParameter[] parameters = method.getParameters();

        if (parameters.length > 1) {

          logger.log(

              TreeLogger.ERROR,

              "In presenter "

                  + presenterClassName

                  + ", method "

                  + result.functionName

                  + " annotated with @"

                  + TabInfo.class.getSimpleName()

                  + " accepts more than one parameter. This is illegal.");

          throw new UnableToCompleteException();

        }

       

        if (parameters.length == 1) {

          JClassType parameterType = parameters[0].getType().isClassOrInterface();

          if (parameterType.isAssignableFrom(ginjectorClass)) {

              result.hasGingectorParam = true;

          } else {

            logger.log(

                TreeLogger.ERROR,

                "In presenter "

                    + presenterClassName

                    + ", method "

                    + result.functionName

                    + " annotated with @"

                    + TabInfo.class.getSimpleName()

                    + " has a parameter that is not of type "

                    + ginjectorClassName

                    + ". This is illegal.");

            throw new UnableToCompleteException();

          }

        }

      }

    }

    return result;

  }

  /**

   * Writes a local ginjector variable to the source writer.

   */

  private void writeGinjector(SourceWriter writer, String ginjectorClassName) {

    writer.println("ginjector = (" + ginjectorClassName + ")baseGinjector;");

  }

  private void writeHandlerMethod(String presenterClassName,

      ProxyEventDescription desc, SourceWriter writer) {

    writer.println("@Override");

    writer.println("public final void " + desc.handlerMethodName + "( final "

        + desc.eventFullName + " event ) {");

    writer.indent();

    writer.println("getPresenter( new AsyncCallback<" + presenterClassName

        + ">() {");

    writer.indent();

    writer.println("@Override");

    writer.println("public void onFailure(Throwable caught) {");

    writer.indent();

    writer.println("failureHandler.onFailedGetPresenter(caught);");

    writer.outdent();

    writer.println("}");

    writer.println("@Override");

    writer.println("public void onSuccess(final " + presenterClassName

        + " presenter) {");

    writer.indent();

    writer.println("Scheduler.get().scheduleDeferred( new Command() {");

    writer.indent();

    writer.println("@Override");

    writer.println("public void execute() {");

    writer.indent();

    writer.println("presenter." + desc.functionName + "( event );");

    writer.outdent();

    writer.println("}");

    writer.outdent();

    writer.println("} );");

    writer.outdent();

    writer.println("}");

    writer.outdent();

    writer.println("} );");

    writer.outdent();

    writer.println("}");

  }

  /**

   * Writes the provider for the presenter to the source writer.

   */

  private void writePresenterProvider(TreeLogger logger, GeneratorContext ctx,

      SourceWriter writer, ProxyCodeSplit proxyCodeSplitAnnotation,

      ProxyCodeSplitBundle proxyCodeSplitBundleAnnotation,

      JClassType ginjectorClass, String ginjectorClassName,

      JClassType presenterClass, String presenterClassName)

      throws UnableToCompleteException {

    TypeOracle oracle = ctx.getTypeOracle();

    // Create presenter provider and sets it in parent class

    if (proxyCodeSplitAnnotation == null

        && proxyCodeSplitBundleAnnotation == null) {

      // StandardProvider

      // Find the appropriate get method in the Ginjector

      String methodName = findGetMethod(providerClass, presenterClass,

          ginjectorClass);

      if (methodName == null) {

        logger.log(TreeLogger.ERROR, "The Ginjector '" + ginjectorClassName

            + "' does not have a get() method returning 'Provider<"

            + presenterClassName + ">'. This is required when using @"

            + ProxyStandard.class.getSimpleName() + ".", null);

        throw new UnableToCompleteException();

      }

      writer.println("presenter = new StandardProvider<" + presenterClassName

          + ">( ginjector." + methodName + "() );");

    } else if (proxyCodeSplitAnnotation != null) {

      // CodeSplitProvider

      // Find the appropriate get method in the Ginjector

      String methodName = findGetMethod(asyncProviderClass, presenterClass,

          ginjectorClass);

      if (methodName == null) {

        logger.log(TreeLogger.ERROR, "The Ginjector '" + ginjectorClassName

            + "' does not have a get() method returning 'AsyncProvider<"

            + presenterClassName + ">'. This is required when using @"

            + ProxyCodeSplit.class.getSimpleName() + ".", null);

        throw new UnableToCompleteException();

      }

      writer.println("presenter = new CodeSplitProvider<" + presenterClassName

          + ">( ginjector." + methodName + "() );");

    } else {

      // CodeSplitBundleProvider

      String bundleClassName = proxyCodeSplitBundleAnnotation.bundleClass().getCanonicalName();

      JClassType bundleClass = oracle.findType(bundleClassName);

      if (bundleClass == null) {

        logger.log(TreeLogger.ERROR,

            "Cannot find the bundle class '" + bundleClassName

                + ", used with @" + ProxyCodeSplitBundle.class.getSimpleName()

                + " on presenter '" + presenterClassName + "'.", null);