<repositories>
  <repository>
    <id>amateurinmotion</id>
    <name>amateurinmotion m2 repository</name>
    <url>http://www.amateurinmotion.com/repository</url>
  </repository>
</repositories>

<dependency>
  <groupId>com.ampatspell.places</groupId>
  <artifactId>places-client</artifactId>
  <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
  <groupId>com.ampatspell.places</groupId>
  <artifactId>places-client</artifactId>
  <version>1.0-SNAPSHOT</version>
  <classifier>sources</classifier>
  <scope>compile</scope>
</dependency>

<module>
  <inherits name="com.ampatspell.bones.core.Core"/>
  <inherits name="com.ampatspell.places.Places"/>
</module>

public class ExampleGinModule extends AbstractGinModule {

  @Override
  protected void configure() {
    // Bones (optional)
    install(new BonesCoreGinModule());
    bind(DispatchServiceAsync.class).to(DispatchServiceAsyncImpl.class);
    
    // Places Service
    install(new PlaceServiceModule());
    bind(PlacesLogger.class).to(GWTPlacesLogger.class);
    bind(EventBus.class).to(BaseEventBus.class); // or your EventBus implementation
  }
  
  @Provides
  @Singleton
  public List<Place> providePlaces() {
    List<Place> places = new ArrayList<Place>();
    return places;
  }  

}

public interface Place {

  /**
   * History token url sub-pattern for this {@link Place}.
   *
   * @return string pattern for {@link Place}. May be blank or null
   */
  String getPattern();

  /**
   * Returns if {@link Place#getPattern()} overrides it's parent pattern.
   *
   * @return <code>true</code> if pattern overrides parent, <code>false</code> otherwise
   */
  boolean overridesParent();

  /**
   * @return parent {@link Place} or null
   */
  Place getParent();

  /**
   * Parameters which will be added to token
   *
   * @return additional parameter names or null
   */
  String[] getAdditionalParameters();

  /**
   * Called before first place is invoked
   *
   * @param binding binding context for moving to next {@link Place} and 
   *                for registering event handlers
   */
  void bind(PlaceBindingContext binding);

  void unbind();

  /**
   * Called when History token matches given {@link Place} ir one of the 
   * child {@link Place}s.
   * <p/>
   * Note: {@code invocation.invoke()} <b>must</b> be called in each invoke call
   *
   * @param invocation context for getting current parameters (from pattern or from 
   *                   additional parameters) and continuing invocation chain
   */
  void invoke(PlaceInvocationContext invocation);

}

// BasePlace
String title = invocation.get("title", "Places Example");
invocation.fireEvent(new SetTitleEvent(title));
invocation.proceed();

// PersonPlace
invocation.fireEvent(new WorkspaceSetContentEvent(people, new Command() {
  public void execute() {
    invocation.fireEvent(new MenuSetActiveEvent("people"));
    invocation.proceed();
  }
}));

// PersonKeyPlace
String key = invocation.get("key");
invocation.fireEvent(new ListSetActiveEvent(key));
invocation.proceed();

// ShowPersonPlace
final String key = invocation.get("key");
invocation.fireEvent(new PeopleSetContentEvent(show, new Command() {
  public void execute() {
    invocation.fireEvent(new PersonShowEvent(key));
  }
}));

binding.addHandler(PersonShowPlaceEvent.getType(), new PersonShowPlaceHandler() {
  public void onPersonShowPlace(PersonShowPlaceEvent event) {
    binding.state().set("key", event.getKey()).invoke();
  }
});

/person/{key}/show
/person/zeeba/show

@Singleton
public class BasePlace extends AbstractPlace {

  @Inject
  protected BasePlace() {
    addAdditionalParameter("title");
  }

  @Override
  public void onBind(final PlaceBindingContext binding) {
    binding.addHandler(SetTitlePlaceEvent.getType(), new SetTitlePlaceHandler() {
      public void onSetTitlePlace(SetTitlePlaceEvent event) {
        binding.state().set("title", event.getTitle()).invoke();
      }
    });
  }

  @Override
  public void onInvoke(PlaceInvocationContext invocation) {
    String title = invocation.get("title", "Places Example");
    invocation.fireEvent(new SetTitleEvent(title));
    invocation.proceed();
  }

}

import com.ampatspell.places.client.api.PlacesService;
import com.ampatspell.places.client.ui.places.PlacesPresenter;

public class Example implements EntryPoint {

  public void onModuleLoad() {
    ExampleGinjector injector = GWT.create(ExampleGinjector.class);

    PlacesService placeService = injector.getPlacesService();
    placeService.bind();

    PlacesPresenter placesPresenter = injector.getPlacesPresenter();
    placesPresenter.bind();
    RootPanel.get().add(placesPresenter.getView().getViewWidget());
    placesPresenter.show();
  }

}

__hg_ps1 ()
{
  if [ "$(hg root 2> /dev/null)" ]; then
    printf "$1" "$(hg branch)"
  fi
}

export PS1='\u:\w$(__hg_ps1 " (%s)\$ '

export PS1='\u:\w$(__hg_ps1 " \[\033[1;31m\](%s)\[\033[0m\]")\$ '

@Singleton
public class SimpleHistoryManager implements ValueChangeHandler<String> {

  private final EventBus eventBus;

  @Inject
  public SimpleHistoryManager(EventBus eventBus) {
    this.eventBus = eventBus;
  }

  public void bind() {
    History.addValueChangeHandler(this);
    History.fireCurrentHistoryState();
  }

  public void onValueChange(ValueChangeEvent<String> stringValueChangeEvent) {
    String token = stringValueChangeEvent.getValue();
    onTokenChanged(token);
  }

  private void onTokenChanged(String token) {
    if (token.equals("/index") || token.equals("")) {
      showIndexSection();
    } else if (token.equals("/people")) {
      showPeopleSection();
    } else if (token.startsWith("/person/")) {
      String[] array = token.split("/");
      String key = array[2];
      String action = array[3];

      if (action.equals("/show")) {
        showPerson(key);
      } else if (action.equals("/edit")) {
        showEditPerson(key);
      }
    }
  }

  private void showIndexSection() {
  }

  private void showPeopleSection() {
  }

  private void showPerson(String key) {
  }

  private void showEditPerson(String key) {
  }

}

eventBus.fireEvent(new MenuSetActiveEvent("index"));

BasePresenter<?> indexPresenter = ...;
eventBus.fireEvent(new WorkspaceSetContentEvent(indexPresenter));

public void onWorkspaceSetContent(final WorkspaceSetContentEvent event) {
  setContent(event.getPresenter());
}

public void setPresenter(BasePresenter<?> presenter) {
  presenter.bind();
  view.setContentView(presenter.getView());
  presenter.show();
}

eventBus.addHandler(WorkspaceSetContentEvent.getType(), new WorkspaceSetContentHandler() {
  public void onWorkspaceSetContent(WorkspaceSetContentEvent event) {

    // this handler will handle PersonShowEvent only after this 
    // WorkspaceSetContentEvent handler will return
    eventBus.addHandler(PersonShowEvent.getType(), new PersonShowHandler() {
      public void onPersonShow(PersonShowEvent event) {
      }
    });

    // this event won't be handled by previous handler
    eventBus.fireEvent(new PersonShowEvent("foo"));
  }
});

public class WorkspaceSetContentEvent extends GwtEvent<WorkspaceSetContentHandler> {

  // TYPE, ivars removed -- less noise

  public WorkspaceSetContentEvent(PresenterProvider<?> presenter, Command callback) {
    this.presenter = presenter;
    this.callback = callback;
  }

  public PresenterProvider<?> getPresenter() {
    return presenter;
  }

  public Command getCallback() {
    return callback;
  }

}

private void showIndexSection() {
  fireMenuSetActive("index");
  fireWorkspaceSetContent(indexPresenterProvider, null);
}

private void showPeopleSection() {
  showPeopleSection(blankPresenterProvider, null, null);
}

private void showPerson(final String key) {
  showPeopleSection(showPresenterProvider, key, new Command() {
    public void execute() {
      eventBus.fireEvent(new PersonShowEvent(key));
    }
  });
}

private void showEditPerson(final String key) {
  showPeopleSection(editPresenterProvider, key, new Command() {
    public void execute() {
      eventBus.fireEvent(new PersonEditEvent(key));
    }
  });
}

private void showPeopleSection(final PresenterProvider<?> content, final String key, 
    final Command command) {
    
  fireMenuSetActive("people");
  fireWorkspaceSetContent(peoplePresenterProvider, new Command() {
    public void execute() {
      eventBus.fireEvent(new ListSetActiveEvent(key));
      eventBus.fireEvent(new PeopleSetContentEvent(content, command));
    }
  });
}

private void fireMenuSetActive(String key) {
  eventBus.fireEvent(new MenuSetActiveEvent(key));
}

private void fireWorkspaceSetContent(PresenterProvider<?> presenter, Command command) {
  eventBus.fireEvent(new WorkspaceSetContentEvent(presenter, command));
}

public void onWorkspaceSetContent(final WorkspaceSetContentEvent event) {
  content.set(event.getPresenter(), event.getCallback());
}

private void showPerson(final String key) {
  showPeopleSection(showPresenterProvider, new Command() {
    public void execute() {
      eventBus.fireEvent(new PersonShowEvent(key));
    }
  });
}

private void showEditPerson(final String key) {
  showPeopleSection(editPresenterProvider, new Command() {
    public void execute() {
      eventBus.fireEvent(new PersonEditEvent(key));
    }
  });
}

private void showPeopleSection(final PresenterProvider<?> content, final Command command) {
  fireMenuSetActive("people");
  fireWorkspaceSetContent(peoplePresenterProvider, new Command() {
    public void execute() {
      eventBus.fireEvent(new PeopleSetContentEvent(content, command));
    }
  });
}

public interface Provider<T> {
  T get();
}

public interface PresenterProvider<P extends BasePresenter<?>> 
  extends Provider<P>, HasInstanceClass {
}

public interface HasInstanceClass {
  Class<?> getInstanceClass();
}

private Class<?> currentPresenterInstanceClass;

public void onAnySetContentEvent(AnySetContentEvent event) {
  PresenterProvider<?> presenterProvider = event.getPresenter();

  Class<?> nextInstanceClass = presenterProvider.getInstanceClass();
  if (currentPresenterInstanceClass != nextInstanceClass) {
    BasePresenter<?> next = presenterProvider.get();
    currentPresenterInstanceClass = nextInstanceClass;
    // unbind previous presenter
    // bind, view.setSomethingView(next.getView()), show
    // DeferredCommand.addCommand(event.getCallback());
  }
}

public class PresenterSwitch {

  public interface SwitchCallback {
    void onSetView(BasePresenter<?> presenter);
  }

  private SwitchCallback callback;
  private Class<?> presenterClass;
  private BasePresenter<?> presenter;

  public void bind(SwitchCallback callback) {
    this.callback = callback;
  }

  public void unbind() {
    callback = null;
    presenterClass = null;
    if (presenter != null) {
      presenter.unbind();
      presenter = null;
    }
  }

  public void set(PresenterProvider<?> provider, Command onBoundCommand) {
    Class<?> instance = provider != null ? provider.getInstanceClass() : null;
    if (presenterClass != instance) {
      final BasePresenter<?> next = provider != null ? provider.get() : null;

      if (presenter != null) {
        presenter.unbind();
      }

      presenter = next;
      presenterClass = instance;

      if (next != null) {
        next.bind();
        callback.onSetView(next);
        next.show();
        if (onBoundCommand != null)
          addDeferredCommand(onBoundCommand);
      } else {
        callback.onSetView(null);
        if (onBoundCommand != null)
          onBoundCommand.execute();
      }
    } else {
      if (onBoundCommand != null)
        onBoundCommand.execute();
    }
  }

  private void addDeferredCommand(Command command) {
    DeferredCommand.addCommand(command);
  }

}

public class WorkspacePresenterImpl extends AbstractBasePresenter<WorkspaceView> 
  implements WorkspacePresenter, WorkspaceSetContentHandler {

  private final PresenterSwitch content = new PresenterSwitch();

  @Inject
  public WorkspacePresenterImpl(WorkspaceView view, EventBus eventBus) {
    super(view, eventBus);
  }

  @Override
  public void onBind() {
    register(eventBus.addHandler(WorkspaceSetContentEvent.getType(), this));
    content.bind(new SwitchCallback() {
      public void onSetView(BasePresenter<?> presenter) {
        view.setContentView(presenter != null ? presenter.getView() : null);
      }
    });
  }

  @Override
  public void onUnbind() {
    content.unbind();
  }

  @Override
  public void onShow() {
  }

  public void onWorkspaceSetContent(final WorkspaceSetContentEvent event) {
    content.set(event.getPresenter(), event.getCallback());
  }

}

public interface PresenterProviderFactory {

  <P extends BasePresenter<?>> PresenterProvider<P> create(Class<?> clazz, 
                                                           Provider<P> provider);

}

private final EventBus eventBus;
private final PresenterProvider<IndexPresenter> indexPresenterProvider;
private final PresenterProvider<PeoplePresenter> peoplePresenterProvider;
private final PresenterProvider<BlankPresenter> blankPresenterProvider;
private final PresenterProvider<ShowPresenter> showPresenterProvider;
private final PresenterProvider<EditPresenter> editPresenterProvider;

@Inject
public SimpleHistoryManager(EventBus eventBus, PresenterProviderFactory f,
                            Provider<IndexPresenter> indexPresenterProvider,
                            Provider<PeoplePresenter> peoplePresenterProvider,
                            Provider<BlankPresenter> blankPresenterProvider,
                            Provider<ShowPresenter> showPresenterProvider,
                            Provider<EditPresenter> editPresenterProvider) {
  this.eventBus = eventBus;

  this.indexPresenterProvider = f.create(IndexPresenter.class, indexPresenterProvider);
  this.peoplePresenterProvider = f.create(PeoplePresenter.class, peoplePresenterProvider);
  this.blankPresenterProvider = f.create(BlankPresenter.class, blankPresenterProvider);
  this.showPresenterProvider = f.create(ShowPresenter.class, showPresenterProvider);
  this.editPresenterProvider = f.create(EditPresenter.class, editPresenterProvider);
}

String key = ...;
eventBus.fireEvent(new MenuClickEvent(key)); 

public void bind() {
  History.addValueChangeHandler(this);
  History.fireCurrentHistoryState();

  bindHandlers();
}

private void bindHandlers() {
  eventBus.addHandler(PeopleShowPlaceEvent.getType(), new PeopleShowPlaceHandler() {
    public void onPeopleShowPlace(PeopleShowPlaceEvent event) {
      newItem("/people");
    }
  });
  eventBus.addHandler(PersonEditPlaceEvent.getType(), new PersonEditPlaceHandler() {
    public void onPersonEditPlace(PersonEditPlaceEvent event) {
      newItem("/person/" + event.getKey() + "/edit");
    }
  });
  eventBus.addHandler(PersonShowPlaceEvent.getType(), new PersonShowPlaceHandler() {
    public void onPersonShowPlace(PersonShowPlaceEvent event) {
      newItem("/person/" + event.getKey() + "/show");
    }
  });
  eventBus.addHandler(MenuClickEvent.getType(), new MenuClickHandler() {
    public void onMenuClick(MenuClickEvent event) {
      newItem("/" + event.getKey());
    }
  });
}

private void newItem(String token) {
  History.newItem(token);
}

mvn archetype:generate -DarchetypeCatalog=http://www.amateurinmotion.com/repository

Choose archetype:
1: http://www.amateurinmotion.com/repository -> google-quickstart-archetype (Google GWT & AppEngine Web App)
2: http://www.amateurinmotion.com/repository -> bones-google-quickstart-archetype (Google GWT & AppEngine Web App With Bones and Gaeds)
Choose a number:  (1/2): 2
Define value for groupId: : som.something
Define value for artifactId: : something
Define value for version:  1.0-SNAPSHOT: : 
Define value for package:  som.something: : 
Confirm properties configuration:
groupId: som.something
artifactId: something
version: 1.0-SNAPSHOT
package: som.something
 Y: : y

cd something
mvn install

cd something-gwt
mvn google:gwt-run

cd something-war
mvn google:appengine-run

cd something-war
mvn google:appengine-deploy

// One actual "place" in app. This class can handle some events and `invoke` itself 
// then handle it's place request no matter if it comes from History string token or 
// place change in app.
@Singleton
public class ShowPersonPlace implements Place {

  private final PresenterProvider<PeoplePresenter> people;
  private final PresenterProvider<ShowPresenter> show;

  @Inject
  public ShowPersonPlace(PresenterProviderFactory f, Provider<PeoplePresenter> people, 
      Provider<ShowPresenter> show) {
    // PresenterProvider allows reuse of already bound presenter. More on this later.
    this.people = f.create(PeoplePresenter.class, people);
    this.show = f.create(ShowPresenter.class, show);
  }

  public String getPattern() {
    // matches for example "/person/show/zeeba" history token and 
    // creates that token from {"key"=>"zeeba"} parameters
    return "/person/show/{key}";
  }

  public boolean isPatternAbsolute() {
    // Will be useful when parent-child relationships will be implemented in Place.
    // Place will be able to use <parent pattern> + <this pattern> for matching.
    return true;
  }

  // The "application" side of history. When application fires some event this Place can
  // handle it and cause History.newItem be called.
  public void bind(final PlaceBindingContext binding) {
    binding.addHandler(ListClickEvent.getType(), new ListClickHandler() {
      public void onListClick(ListClickEvent event) {
        navigateTo(binding, event.getKey());
      }
    });

    binding.addHandler(ShowPersonEvent.getType(), new ShowPersonHandler() {
      public void onShowPerson(ShowPersonEvent event) {
        navigateTo(binding, event.getKey());
      }
    });
  }

  private void navigateTo(PlaceBindingContext binding, String key) {
    // Takes current history state (no matter if its this Place or some other) and 
    // overwrites parameter(s) then invokes it what calls History.newItem under the hood.
    binding.state().set("key", key).invoke();
  }

  public void unbind() {
    // binding.addHandler takes care of HandlerRegistration but if there's need to 
    // unbind something else, this can be done here.
  }

  // This method is called when History state has changed and requested 
  // token matches given Place.
  public void invoke(final PlaceInvocationContext invocation) {
    // if place pattern has parameters in it (/foo/{bar} -- bar is parameter)
    final String key = invocation.get("key");

    // Events with Command on completion (sometimes wraps DeferredCommand to 
    // escape current event execution stack).
    // fireEvent method is delegate to EventBus. here just to simplify things a little.
    invocation.fireEvent(new WorkspaceSetContentEvent(people, new Command() {
      public void execute() {
        // this "people" will come from somewhere when 
        // parent-child relationships will be implemented
        invocation.fireEvent(new MenuSetActiveEvent("people"));
        invocation.fireEvent(new PeopleSetContentEvent(show, new Command() {
          public void execute() {
            invocation.fireEvent(new ListSetActiveEvent(key));
            invocation.fireEvent(new PersonShowEvent(key));
          }
        }));
      }
    }));
  }

}

hg clone ssh://hg@bitbucket.org/cbarrett/guess-renames/

make tests

wget http://peak.telecommunity.com/dist/ez_setup.py
sudo python ./ez_setup.py

make tests
sudo python ./setup.py install

[extensions]
guessrenames.hgext=

hg addremove -g

public static class ShowSectionRoute implements Route {

  public Route getParent() {
    return null;
  }

  public String getPath() {
    return "/{section}";
  }

  public void handle(final HandleContext ctx) {
    ctx.register(ShowSectionEvent.getType(), new ShowSectionHandler() {
      public void onShowSection(ShowSectionEvent event) {
        ctx.param("section", event.getSection().name().toLowerCase());
      }
    });
  }

  public void perform(final PerformContext ctx) {
    final Section section = Section.valueOf(ctx.param("section").toUpperCase());
    ctx.register(SectionShownEvent.getType(), new SectionShownHandler() {
      public void onSectionShown(SectionShownEvent event) {
        if (event.getSection() == section) {

          // invokes ShowPersonRoute as it is child route for this one
          ctx.next();
        }
      }
    });
    ctx.fire(new ShowSectionHistoryEvent(section));
  }

}

public static class ShowPersonRoute implements Route {

  private ShowSectionRoute parent;

  public ShowPersonRoute(ShowSectionRoute parent) {
    this.parent = parent;
  }

  public Route getParent() {
    return parent;
  }

  public String getPath() {
    return "/show/{key}";
  }

  public void handle(final HandleContext ctx) {
    ctx.register(ShowPersonEvent.getType(), new ShowPersonHandler() {
      public void onShowPerson(ShowPersonEvent event) {
        ctx.param("key", event.getKey()).run();
      }
    });
  }

  public void perform(final PerformContext ctx) {
    String key = ctx.param("key");
    ctx.fire(new ShowPersonHistoryEvent(key));
  }

}

// Some presenter fires event:
eventBus.fireEvent(new ShowPersonEvent(personKeyAsString));

// ShowPersonRoute handles it and updates route
// History.addItem with "/people/show/<personKey>" is set
// ShowPerson.getParent() route perform() is called what fires ShowSectionHistoryEvent after 
// section is visible (it can be behind GWT.runAsync) ctx.next() is called. 
// It invokes ShowPerson#handle() what fires ShowPersonHistoryEvent with the same person key

// some persenter handles event:
public void onShowPersonHistoryEvent(ShowPersonHistoryEvent e) {
  String key = e.getKey();
}

serve("/upload/finished").with(UploadFinishedServlet.class);

<servlet>
  <servlet-name>uploadFinished</servlet-name>
  <servlet-class>com.foo.servlet.UploadFinishedServlet</servlet-class>
</servlet>

<servlet-mapping>
  <servlet-name>uploadFinished</servlet-name>
  <url-pattern>/upload/finished</url-pattern>
</servlet-mapping>

// bound to "/upload/finished", see below
@Named("uploadFinishedPath") String uploadFinishedPath;

BlobStoreService bs = blobStoreServiceProvider.get();
String url = bs.createUploadUrl(uploadFinishedPath);

public class UploadFinishedServlet extends HttpServlet {

  public static final String REDIRECT_TO = "/upload/commit";
  public static final String KEY_PARAMETER = "key";
  public static final String FILE_FIELD = "file";

  @Override
  protected void service(HttpServletRequest req, HttpServletResponse resp) 
      throws ServletException, IOException {
      
    BlobStoreService blobStoreService = BlobstoreServiceFactory.getBlobstoreService();
    Map<String, BlobKey> keys = blobStoreService.getUploadedBlobs(req);
    BlobKey key = keys.get(FILE_FIELD);

    String parameters = getParameters(key);
    resp.sendRedirect(REDIRECT_TO + parameters);
  }

  private String getParameters(BlobKey key) {
    if (key != null) {
      return format("?%s=%s", KEY_PARAMETER, key.getKeyString());
    } else {
      return "";
    }
  }

}

bindConstant().annotatedWith(named("uploadFinishedPath")).to("/upload/finished");
bindConstant().annotatedWith(named("uploadFileField")).to(UploadFinishedServlet.FILE_FIELD);
serve(UploadedServlet.REDIRECT_TO).with(CommitUploadServlet.class);

@Singleton
public class CommitUploadServlet extends HttpServlet {

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
      throws ServletException, IOException {

    String key = req.getParameter(UploadFinishedServlet.KEY_PARAMETER);

    resp.setContentType("text/html");
    resp.setStatus(200);

    String result = key != null ? key : "";
    resp.getOutputStream().write(result.getBytes());
  }

}

package com.google.gwt.user.client.ui;

import com.google.gwt.dom.client.Style;

import static com.google.gwt.dom.client.Style.Overflow.HIDDEN;
import static com.google.gwt.dom.client.Style.Position.RELATIVE;
import static com.google.gwt.dom.client.Style.Unit.PCT;

/**
 * Widget what extends {@link com.google.gwt.user.client.ui.SimplePanel} and can be used as 
 * "host" for {@link com.google.gwt.user.client.ui.LayoutPanel} inside 
 * non-{@link com.google.gwt.layout.client.Layout} based UI.
 * <p/>
 * This widget forces {@link com.google.gwt.user.client.ui.LayoutPanel} to fill host 
 * dimensions by calling {@link com.google.gwt.layout.client.Layout#fillParent()} in
 * {@link com.google.gwt.user.client.ui.LayoutPanelHost#setWidget(Widget)}.
 *
 * @author ampatspell
 */
public class LayoutPanelHost extends SimplePanel implements RequiresResize {

  public LayoutPanelHost() {
    this(null);
  }

  /**
   * Child may be null
   *
   * @param child widget to set
   */
  public LayoutPanelHost(Widget child) {
    Style style = getElement().getStyle();
    style.setPosition(RELATIVE);
    style.setWidth(100, PCT);
    style.setHeight(100, PCT);
    // overflow: hidden is to hide ruler element what is added by Layout
    style.setOverflow(HIDDEN);

    if (child != null)
      setWidget(child);
  }

  /**
   * If widget is instanceof {@link com.google.gwt.user.client.ui.LayoutPanel},
   * {@link com.google.gwt.layout.client.Layout#fillParent()} is called for it.
   *
   * @param w any widget or null
   */
  @Override
  public void setWidget(Widget w) {
    LayoutPanel layoutPanel = cast(w);
    if (layoutPanel != null)
      layoutPanel.getLayout().fillParent();
    super.setWidget(w);
  }

  /**
   * Delegates call to {@link com.google.gwt.user.client.ui.LayoutPanel}.
   * Should be called whenever this Widget or some of its parents are resized. 
   * Normally {@link LayoutPanel#onResize()} is called automatically by GWT Layout API 
   * but here it is impossible as there is no way (except from polling) to get informed 
   * about Element dimension changes.
   *
   * Update: Is it really needed? LayoutImplIE6 adds js hook to onresize.
   */
  public void onResize() {
    LayoutPanel layoutPanel = cast(getWidget());
    if (layoutPanel != null)
      layoutPanel.onResize();
  }

  /**
   * Casts {@link com.google.gwt.user.client.ui.Widget} or 
   * {@link com.google.gwt.user.client.ui.Composite} child widget
   * to {@link com.google.gwt.user.client.ui.LayoutPanel} if widget is not null and
   * is instanceof {@link com.google.gwt.user.client.ui.LayoutPanel}.
   *
   * @param widget Widget
   * @return widget casted to LayoutPanel or null
   */
  private LayoutPanel cast(Widget widget) {
    Widget w = getActualWidget(widget);
    if (w != null && w instanceof LayoutPanel)
      return (LayoutPanel) w;
    return null;
  }

  private Widget getActualWidget(Widget widget) {
    if (widget != null && widget instanceof Composite) {
      return ((Composite) widget).getWidget();
    }
    return widget;
  }

}

FlowPanel base = new FlowPanel();
base.add(new LayoutPanelHost(content = new SomeLayoutPanel()));

FlowPanel base = new FlowPanel();
base.add(content = new SomeLayoutPanel());
content.setSize("100%", "100%");

<!-- Workspace.ui.xml -->
<g:LayoutPanel>
  <g:layer top="0px" height="30px">
    <!-- Some header or whatever -->
  </g:layer>
  <g:layer top="30px" bottom="0px">
    <g:LayoutPanelHost ui:field="content"/>
  </g:layer>
</g:LayoutPanel>

// WorkspacePresenterImpl
view.setContentView(presenter.getView());

<g:LayoutPanel>
  <g:layer top="0px" height="50px">
  </g:layer>
  <g:layer top="50px" bottom="0px">
  </g:layer>
</g:LayoutPanel>