Java 类com.google.gwt.user.client.ui.LayoutPanel 实例源码

@Inject
public EditorMultiPartStackViewImpl(
    SplitEditorPartViewFactory splitEditorPartViewFactory,
    EmptyEditorsPanel emptyEditorsPanel,
    EditorPlaceholderWidget editorPlaceholderWidget) {
  this.splitEditorPartViewFactory = splitEditorPartViewFactory;
  this.emptyEditorsPanel = emptyEditorsPanel;
  this.splitEditorParts = HashBiMap.create();
  this.editorPlaceholderWidget = editorPlaceholderWidget;

  contentPanel = new LayoutPanel();
  contentPanel.setSize("100%", "100%");
  contentPanel.ensureDebugId("editorMultiPartStack-contentPanel");
  initWidget(contentPanel);
  contentPanel.add(emptyEditorsPanel);
}

/**
 * Entry point for the application.
 */
@Override
public void onModuleLoad() {
  projectService = GWT.create(ProjectRpc.class);
  userService = GWT.create(UserRpc.class);
  dataService = GWT.create(DataRpc.class);

  contentPanel = new LayoutPanel();
  RootLayoutPanel.get().add(contentPanel);

  // Handle history changes. (Such as clicking a navigation hyperlink.)
  History.addValueChangeHandler(new ValueChangeHandler<String>() {
    @Override
    public void onValueChange(ValueChangeEvent<String> event) {
      String historyToken = event.getValue();
      handleUrl(historyToken);
    }
  });

  handleUrl(History.getToken());
}

/**
 * Constructor
 * 
 * @param parent
 *            a widget which will be the parent of the new instance (cannot
 *            be null)
 * @param style
 *            the style of widget to construct
 * @see Composite#Composite(org.eclipse.swt.widgets.Composite, int)
 */
// public GwtRulerComposite(Composite parent, int style) {
// super(parent, style);
// addDisposeListener(new DisposeListener() {
// public void widgetDisposed(DisposeEvent e) {
// disposeResources();
// }
// });
// }

public GwtRulerComposite(LayoutPanel element) {
    super(null, SWT.NONE);
    this.rootElement = element;
    // create dock panel here with rulers
    dockLayoutPanel = new DockLayoutPanel(Unit.PX);
    dockLayoutPanel.getElement().setId("INNER_DOCK_LAYOUT_PANEL");
    rootElement.add(dockLayoutPanel);

    northPanel = new DockLayoutPanel(Unit.PX);
    northPanel.getElement().setId("NORTH_DOCK_LAYOUT_PANEL");
    dockLayoutPanel.addNorth(northPanel, 19);

    northPanel.addWest(createPickle(), 19);

    topPartInDockPanel = new Composite(null, SWT.NONE);
    LayoutPanel topPanel = (LayoutPanel) topPartInDockPanel
            .getNativeWidget();
    topPanel.getElement().setId("TOP_RULER");
    northPanel.add(topPanel);
    northPanel.forceLayout();

    westPartInDockPanel = new Composite(null, SWT.NONE);
    westPanel = (LayoutPanel) westPartInDockPanel.getNativeWidget();
    westPanel.getElement().setId("LEFT_RULER");
    dockLayoutPanel.addWest(westPanel, 19);

    view = (LayoutPanel) getGwtWidget();
    dockLayoutPanel.add(view);
    dockLayoutPanel.forceLayout();
}

@Override
public void onResize() {
    final Element realParent = (Element) ((LayoutPanel) canvas.getParent())
            .getWidgetContainerElement(canvas);

    int pw = realParent.getClientWidth();
    int ph = realParent.getClientHeight();

    // in case of trouble :)
    // canvas.setPixelSize(pw, ph);

    canvas.setCoordinateSpaceWidth(pw);
    canvas.setCoordinateSpaceHeight(ph);

    canvas.getElement().getStyle().setProperty("DIRTY", "dirty");

    IFigure rootFigure = getLightweightSystem().getRootFigure();
    rootFigure.revalidate();
    rootFigure.repaint();
}

public Text(Composite parent, int style) {
    this(new TextArea(), parent, style);
    textArea = (TextArea) getGwtWidget();
    panel = (LayoutPanel) getParent().getGwtWidget().getParent();
    panel.add(textArea);
    textArea.addBlurHandler(new BlurHandler() {

        @Override
        public void onBlur(BlurEvent event) {
            setText(textArea.getText());
            textArea.removeFromParent();
            sendEvent(SWT.Modify);
            sendEvent(SWT.FocusOut);
        }
    });
}

public ViewWithToolbar(final PartStackUIResources resources) {
    container = new DockLayoutPanel(Style.Unit.PX);
    initWidget(container);
    container.setSize("100%", "100%");
    toolBar = new LayoutPanel();
    toolBar.addStyleName(resources.partStackCss().ideBasePartToolbar());
    container.addNorth(toolBar, 20);

    // this hack used for adding box shadow effect to toolbar
    toolBar.getElement().getParentElement().getStyle().setOverflow(Style.Overflow.VISIBLE);
}

@Test
public void testPanels() throws Exception {
  invokeAllAccessibleMethods(new AbsolutePanel() {});
  invokeAllAccessibleMethods(new CellPanel() {});
  invokeAllAccessibleMethods(new ComplexPanel() {});
  invokeAllAccessibleMethods(new DeckLayoutPanel() {});
  invokeAllAccessibleMethods(new DeckPanel() {});
  invokeAllAccessibleMethods(new DecoratorPanel() {});
  invokeAllAccessibleMethods(new DockLayoutPanel(Unit.PX) {});
  invokeAllAccessibleMethods(new DockPanel() {});
  invokeAllAccessibleMethods(new FlowPanel() {});
  invokeAllAccessibleMethods(new FocusPanel() {});
  invokeAllAccessibleMethods(new HorizontalPanel() {});
  invokeAllAccessibleMethods(new HTMLPanel("") {});
  invokeAllAccessibleMethods(new LayoutPanel() {});
  invokeAllAccessibleMethods(new PopupPanel() {});
  invokeAllAccessibleMethods(new RenderablePanel("") {});
  invokeAllAccessibleMethods(new ResizeLayoutPanel() {});
  invokeAllAccessibleMethods(new SimpleLayoutPanel() {});
  invokeAllAccessibleMethods(new SimplePanel() {});
  invokeAllAccessibleMethods(new SplitLayoutPanel() {});
  invokeAllAccessibleMethods(new StackPanel() {});
  invokeAllAccessibleMethods(new VerticalPanel() {});
}

public Timeline(Canvas canvas, ScrollPanel scroll, LayoutPanel viewPanel) {
    logger.setLevel(Level.INFO);

    this.canvas = canvas;
    this.scroll = scroll;
    this.viewPanel = viewPanel;

    landmarks = new Vector<Landmark>();
    landmarkbars = new Vector<LandmarkBar>();

    startTime = new Date();
    currentTime = new Date();

    lenghtOfAMinute = 1000;

    color = CssColor.make("rgba(" + 0 + ", " + 0 + "," + 255 + ", " + 1
            + ")");

    canvas.setWidth(minWidth + "px");
    canvas.setCoordinateSpaceWidth(minWidth);

    canvas.setHeight(minHeight + "px");
    canvas.setCoordinateSpaceHeight(minHeight);

    timer = new Timer() {
        @Override
        public void run() {
            updateTime();
            drawTimeline();
        }
    };
    timer.scheduleRepeating(5000);

    updateTime();
    drawTimeline();
}

@Override
public void onLoad() {

    LayoutPanel layoutPanel = new LayoutPanel();
    controller = new ReportingController(eventBus, rpcService);
    layoutPanel.add(controller.createView());
    ReportingPresenter reportingPresenter = controller.getPresenter();
    reportingPresenter.bind();

    final RootPanel rootPanel = new RootPanel(layoutPanel, rpcService);

    rootPanel.getHeader().addTab("Batch Class Management", "BatchClassManagement.html", false);
    rootPanel.getHeader().addTab("Batch Instance Management", "BatchInstanceManagement.html", false);
    rootPanel.getHeader().addTab("Workflow Management", "CustomWorkflowManagement.html", false);
    rootPanel.getHeader().addTab("Folder Management", "FolderManager.html", false);
    rootPanel.getHeader().addNonClickableTab("Reports", "Reporting.html");
    rootPanel.getHeader().getTabBar().selectTab(4);
    rootPanel.addStyleName("set_position");
    rootPanel.getHeader().setEventBus(eventBus);

    rpcService.getUserName(new EphesoftAsyncCallback<String>() {

        @Override
        public void onSuccess(final String userName) {
            rootPanel.getHeader().setUserName(userName);
        }

        @Override
        public void customFailure(final Throwable arg0) {
            // Username cannot be set if the call failed.
        }
    });

    RootLayoutPanel rootLayoutPanel = RootLayoutPanel.get();
    rootLayoutPanel.clear();
    rootLayoutPanel.add(rootPanel);

}

public SplitLayoutPanelView() {
    layout = new SplitLayoutPanel(2);

    centerPanel = new LayoutPanel();
    westPanel = new LayoutPanel();

    // TODO (hbraun): the actual width should become meta data. i.e. passed through the position object
    layout.addWest(westPanel,
                   217);
    layout.add(centerPanel);
}

/**
 * Create a new GWTPTabPanel.
 * 
 * @param placeManager the place manager to use when processing tab
 *            selections.
 */
public GWTPTabPanel(final PlaceManager placeManager) {
    _layout = new LayoutPanel();
    _layout.addStyleName("fill-layout"); //$NON-NLS-1$

    _tabBar = new DefaultTabLayoutPanel(40, Unit.PX);
    // _tabBar = new TabBar();
    _tabBar.addSelectionHandler(new SelectionHandler<Integer>() {
        @Override
        public void onSelection(SelectionEvent<Integer> event) {
            if (_modifyingTabs) {
                // add/remove tab may change the selection
                return;
            }
            if (event.getSelectedItem() < 0) {
                // TODO: WHAT????
                return;
            }
            final PlaceRequest current = placeManager.getCurrentPlaceRequest();
            final String selectedToken = _tabs.get(event.getSelectedItem()).getTargetHistoryToken();
            final String currentToken = current == null ? null : current.getNameToken();
            if (!selectedToken.equals(currentToken)) {
                placeManager.revealPlace(new PlaceRequest(selectedToken));
            }
        }
    });

    _content = new LayoutPanel();
    _content.setStyleName("fill-layout"); //$NON-NLS-1$

    _layout.add(_tabBar);
    _layout.add(_content);

    ((LayoutPanel) _layout).setWidgetTopHeight(_tabBar, 0, Unit.PX, 40, Unit.PX);
    ((LayoutPanel) _layout).setWidgetTopHeight(_content, 40, Unit.PX, 100, Unit.PCT);
}

private LayoutPanel createPickle() {
    LayoutPanel pickle = new LayoutPanel();
    pickle.getElement().setId("PICKLE");
    pickle.setPixelSize(19, 19);
    Style style = pickle.getElement().getStyle();
    style.setBackgroundColor("rgb(230,230,230)");
    return pickle;
}

@Override
public void propertyChange(PropertyChangeEvent evt) {
    com.google.gwt.canvas.client.Canvas canvas = (com.google.gwt.canvas.client.Canvas) getNativeWidget();
    LayoutPanel canvasParent = (LayoutPanel) canvas.getParent();
    if (isInPalette(canvas)) {
        return;
    }
    int defWidth = canvasParent.getOffsetWidth();
    RangeModel model = (RangeModel) evt.getSource();
    int maxVal = model.getMaximum();
    int minVal = model.getMinimum();
    int value = model.getValue();
    int size = maxVal - minVal;
    LayoutPanel simplePanel = getSimplePanel();
    simplePanel.setWidth(size + "px");
    ScrollPanel parent = (ScrollPanel) simplePanel.getParent();
    Element canvasContainerElement = canvasParent
            .getWidgetContainerElement(canvas);
    if ((minVal < 0 || maxVal > defWidth) && defWidth > 0
            && scrollbarsVisible == false) {
        canvasContainerElement.getStyle().setBottom(SCROLL_SIZE,
                Unit.PX);
        onResize();
        scrollbarsVisible = true;
    } else if (minVal >= 0 && maxVal <= defWidth
            && scrollbarsVisible == true) {
        canvasContainerElement.getStyle().setBottom(0, Unit.PX);
        onResize();
        scrollbarsVisible = false;
    }
    parent.setHorizontalScrollPosition(value - minVal);
    // There is a missing event that isn't sent:
    scroll(parent);
    getLightweightSystem().getRootFigure().repaint();
}

@Override
public void propertyChange(PropertyChangeEvent evt) {
    com.google.gwt.canvas.client.Canvas canvas = (com.google.gwt.canvas.client.Canvas) getNativeWidget();
    LayoutPanel canvasParent = (LayoutPanel) canvas.getParent();
    if (isInPalette(canvas)) {
        return;
    }
    int defHeight = canvasParent.getOffsetHeight();
    RangeModel model = (RangeModel) evt.getSource();
    int maxVal = model.getMaximum();
    int minVal = model.getMinimum();
    int size = maxVal - minVal;
    LayoutPanel simplePanel = getSimplePanel();
    simplePanel.setHeight(size + "px");
    ScrollPanel parent = (ScrollPanel) simplePanel.getParent();
    parent.setVerticalScrollPosition(model.getValue() - minVal);
    Element canvasContainerElement = canvasParent
            .getWidgetContainerElement(canvas);
    if ((minVal < 0 || maxVal > defHeight && defHeight > 0)
            && scrollbarsVisible == false) {
        canvasContainerElement.getStyle()
        .setRight(SCROLL_SIZE, Unit.PX);
        onResize();
        scrollbarsVisible = true;
    } else if (minVal >= 0 && maxVal <= defHeight
            && scrollbarsVisible == true) {
        canvasContainerElement.getStyle().setRight(0, Unit.PX);
        onResize();
        scrollbarsVisible = false;
    }
    // There is a missing event that isn't sent:
    scroll(parent);
    getLightweightSystem().getRootFigure().repaint();
}

public MenuOneLevelView(LayoutPanel parent, int level, boolean hiddenMenu) {
    this.hiddenMenu = hiddenMenu;
    getElement().setId("OneLevel-" + level);
    parent.add(this);
    menu.addStyleName(ResourceHelper.getRes().style().menu());
    menuBorder.addStyleName(ResourceHelper.getRes().style().menuBorder());
    menu.getElement().setId("OneLevel-" + level + "-Menu");
    getElement().getStyle().setOverflow(Overflow.VISIBLE);
    init();
}

/**
  * Creates an empty tab panel.
  *
  * @param barHeight the size of the tab bar
  * @param barUnit the unit in which the tab bar size is specified
  */
 public TabLayoutPanelCopy(double barHeight, Unit barUnit) {
   LayoutPanel panel = new LayoutPanel();
   initWidget(panel);

   // Add the tab bar to the panel.
   panel.add(tabBar);
   panel.setWidgetLeftRight(tabBar, 0, Unit.PX, 0, Unit.PX);
   panel.setWidgetTopHeight(tabBar, 0, Unit.PX, barHeight, barUnit);
   panel.setWidgetVerticalPosition(tabBar, Alignment.END);

   // Add the deck panel to the panel.
   // CHANGE4: styles again: deckPanel.addStyleName(CONTENT_CONTAINER_STYLE);
   panel.add(deckPanel);
   panel.setWidgetLeftRight(deckPanel, 0, Unit.PX, 0, Unit.PX);
   panel.setWidgetTopBottom(deckPanel, barHeight, barUnit, 0, Unit.PX);

   // Make the tab bar extremely wide so that tabs themselves never wrap.
   // (Its layout container is overflow:hidden)

// CHANGE5: Adapt the TabBar Style element to our needs
   Style tabBarStyle = tabBar.getElement().getStyle();
   tabBarStyle.setHeight(barHeight, barUnit);
   tabBarStyle.setWidth(BIG_ENOUGH_TO_NOT_WRAP, Unit.PX);

// CHANGE6: We don't want the standard GWT styles
   // tabBar.setStyleName("gwt-TabLayoutPanelTabs");
   // setStyleName("gwt-TabLayoutPanel");
 }

public LayoutPanel getLayoutPanel() {
    return layoutPanel;
}

public void setLayoutPanel(LayoutPanel layoutPanel) {
    this.layoutPanel = layoutPanel;
}

public LayoutPanel getReportTablePanel() {
    return reportTablePanel;
}

/**
 * @return the layoutPanel
 */
public LayoutPanel getLayoutPanel() {
    return layoutPanel;
}

@Inject
public LayoutPanelView() {
    layout = new LayoutPanel();
    layout.setStyleName("fill-layout");
}

public LayoutPanel getSimplePanel() {
    return simplePanel;
}

public void setSimplePanel(LayoutPanel simplePanel) {
    this.simplePanel = simplePanel;
}

public DialogBoxForLayoutWidget( String title, IsWidget content )
{
    int m = 50;
    ImageResource closeImage = ImageResources.INSTANCE.close();
    int titleSize = Math.max( closeImage.getHeight(), closeImage.getWidth() ) + 5;

    dock = new LayoutPanel();

    Glass glass = new Glass();
    dock.add( glass );

    DivWidget backGround = new DivWidget();
    backGround.addStyleName( ResizablePanel.CSS.bkgnd() );
    dock.add( backGround );
    dock.setWidgetLeftRight( backGround, m, Unit.PX, m, Unit.PX );
    dock.setWidgetTopBottom( backGround, m, Unit.PX, m, Unit.PX );

    DivWidget titleWidget = new DivWidget();
    titleWidget.addStyleName( ResizablePanel.CSS.title() );
    titleWidget.getElement().setInnerText( title );
    dock.add( titleWidget );
    dock.setWidgetLeftRight( titleWidget, m, Unit.PX, m + titleSize, Unit.PX );
    dock.setWidgetTopHeight( titleWidget, m, Unit.PX, titleSize, Unit.PX );

    closeWidget = new Image( closeImage );
    dock.add( closeWidget );
    dock.setWidgetRightWidth( closeWidget, m, Unit.PX, titleSize, Unit.PX );
    dock.setWidgetTopHeight( closeWidget, m, Unit.PX, titleSize, Unit.PX );

    SimpleLayoutPanel contentPanel = new SimpleLayoutPanel();
    contentPanel.setWidget( content.asWidget() );
    contentPanel.addStyleName( ResizablePanel.CSS.content() );
    dock.add( contentPanel );
    dock.setWidgetLeftRight( contentPanel, m, Unit.PX, m, Unit.PX );
    dock.setWidgetTopBottom( contentPanel, m + titleSize, Unit.PX, m, Unit.PX );

    closeWidget.addClickHandler( new ClickHandler()
    {
        @Override
        public void onClick( ClickEvent event )
        {
            if( isAutoHide )
                hide();
        }
    } );
}

@Inject
DefaultIneFrameMasterPageView(
    IneFrameHeader.View header,
    MenuRenderer.View menu,
    MessagePanelWidget messagePanel,
    NavigationDrawer navigationDrawer) {
    this.header = header;
    this.menu = menu;
    this.navigationDrawer = navigationDrawer;
    this.messagePanel = messagePanel;

    messagePanel.getElement().setId("MessagePanel");
    messagePanel.addStyleName(Res.INST.get().style().MessagePanel());
    getElement().setId("MasterPage");
    setSize("100%", "100%");
    setStyleName(Res.INST.get().style().MasterPage());

    clickHandlerLayout = new ClickableFlowPanel();
    clickHandlerLayout.getElement().setId("ClickHandler");
    clickHandlerLayout.setSize("100%", "100%");

    clickHandlerLayout.addClickHandler(new ClickHandler() {

        @Override
        public void onClick(ClickEvent event) {
            closeNavigationDrawer();
        }
    });

    headerAndPageRoot = new ResizeLayoutPanel();
    headerAndPageRoot.getElement().setId("HeaderAndPageRoot");
    headerAndPageRoot.setSize("100%", "100%");
    headerAndPageRoot.setStyleName(Res.INST.get().style().HeaderAndPageRoot());

    headerAndPage = new LayoutPanel();
    headerAndPage.getElement().setId("HeaderAndPage");
    headerAndPage.setStyleName(Res.INST.get().style().HeaderAndPage());

    headerAndPage.add(header.asWidget());
    headerAndPage.add(menu.asWidget());
    header.asWidget().asWidget().getElement().setId("Header");
    menu.asWidget().asWidget().getElement().setId("Menu");

    headerAndPage.setWidgetTopHeight(
        header.asWidget(),
        0,
        Unit.PX,
        DesignConstants.base() + borderWidth,
        Unit.PX);
    headerAndPage.setWidgetTopBottom(
        menu.asWidget(),
        DesignConstants.base() + borderWidth,
        Unit.PX,
        0,
        Unit.PX);

    headerAndPageRoot.setWidget(headerAndPage);

    navigationDrawer.asWidget().setSize(DesignConstants.b5WithUnit(), "100%");
    navigationDrawer.asWidget().getElement().setId("NavigationDrawer");
    navigationDrawer.asWidget().addStyleName(Res.INST.get().style().NavigationDrawer());

    add(messagePanel);
    add(navigationDrawer);
    add(headerAndPageRoot);

}

public LayoutPanel getTarget() {
    return target;
}

public VisualCellContainer(ViewContext viewContext, ViewConfig config)
{       
    m_viewContext = viewContext;

    m_scrollContainer.addStyleName("sm_cell_scroll_container");

    m_magnifier = new Magnifier(viewContext, config.magnifierTickCount, config.magFadeInTime_seconds);

    m_splashGlass.addStyleName("sm_splash_glass");
    m_cellContainerInner.addStyleName("sm_cell_container_inner");
    this.addStyleName("sm_cell_container");

    E_ZIndex.CELL_SPLASH_GLASS.assignTo(m_splashGlass);

    Window.addResizeHandler(this);

    //smU_UI.toggleSelectability(this.getElement(), false);

    final LayoutPanel magnifierContainer = new LayoutPanel();
    magnifierContainer.setSize("100%", "100%");
    magnifierContainer.add(m_magnifier);
    magnifierContainer.setWidgetRightWidth(m_magnifier, 8, Unit.PX, 34, Unit.PX);
    magnifierContainer.setWidgetTopHeight(m_magnifier, 8, Unit.PX, 196, Unit.PX);

    for( int i = 0; i < m_cropper.length; i++ )
    {
        m_cropper[i] = new VisualCellCropper();
        m_cellContainerInner.add(m_cropper[i]);
    }

    this.add(magnifierContainer);
    m_scrollContainer.add(m_cellContainerInner);
    m_scrollContainer.add(m_splashGlass);

    this.add(m_scrollContainer);

    m_statusAlignment.setPosition(E_AlignmentType.MASTER_ANCHOR_HORIZONTAL, E_AlignmentPosition.RIGHT_OR_BOTTOM);
    m_statusAlignment.setPosition(E_AlignmentType.MASTER_ANCHOR_VERTICAL, E_AlignmentPosition.RIGHT_OR_BOTTOM);
    m_statusAlignment.setPosition(E_AlignmentType.SLAVE_ANCHOR_HORIZONTAL, E_AlignmentPosition.RIGHT_OR_BOTTOM);
    m_statusAlignment.setPosition(E_AlignmentType.SLAVE_ANCHOR_VERTICAL, E_AlignmentPosition.RIGHT_OR_BOTTOM);
    m_statusAlignment.setPadding(E_AlignmentType.SLAVE_ANCHOR_HORIZONTAL, S_UI.ADDRESS_STATUS_TOOL_TIP_PADDING);
    m_statusAlignment.setPadding(E_AlignmentType.SLAVE_ANCHOR_VERTICAL, S_UI.ADDRESS_STATUS_TOOL_TIP_PADDING);

    m_snapTargetAlignment.setPosition(E_AlignmentType.MASTER_ANCHOR_HORIZONTAL, E_AlignmentPosition.LEFT_OR_TOP);
    m_snapTargetAlignment.setPosition(E_AlignmentType.MASTER_ANCHOR_VERTICAL, E_AlignmentPosition.RIGHT_OR_BOTTOM);
    m_snapTargetAlignment.setPosition(E_AlignmentType.SLAVE_ANCHOR_HORIZONTAL, E_AlignmentPosition.LEFT_OR_TOP);
    m_snapTargetAlignment.setPosition(E_AlignmentType.SLAVE_ANCHOR_VERTICAL, E_AlignmentPosition.RIGHT_OR_BOTTOM);
    m_snapTargetAlignment.setPadding(E_AlignmentType.SLAVE_ANCHOR_HORIZONTAL, S_UI.ADDRESS_STATUS_TOOL_TIP_PADDING);
    m_snapTargetAlignment.setPadding(E_AlignmentType.SLAVE_ANCHOR_VERTICAL, S_UI.ADDRESS_STATUS_TOOL_TIP_PADDING);
}

public LayoutPanel getToolBar() {
    return toolBar;
}

/**
 * Returns a collection of classes whose non-abstract methods should always be replaced with
 * no-ops. By default, this list includes {@link Composite}, {@link DOM} {@link UIObject},
 * {@link Widget}, {@link Image}, and most subclasses of {@link Panel}. It will also include any
 * classes specified via the {@link WithClassesToStub} annotation on the test class. This makes
 * it much safer to test code that uses or extends these types.
 * <p>
 * This list can be customized via {@link WithClassesToStub} or by defining a new test runner
 * extending {@link GwtMockitoTestRunner} and overriding this method. This allows users to
 * explicitly stub out particular classes that are causing problems in tests. If you override this
 * method, you will probably want to retain the classes that are stubbed here by doing something
 * like this:
 *
 * <pre>
 * &#064;Override
 * protected Collection&lt;Class&lt;?&gt;&gt; getClassesToStub() {
 *   Collection&lt;Class&lt;?&gt;&gt; classes = super.getClassesToStub();
 *   classes.add(MyBaseWidget.class);
 *   return classes;
 * }
 * </pre>
 *
 * @return a collection of classes whose methods should be stubbed with no-ops while running tests
 */
protected Collection<Class<?>> getClassesToStub() {
  Collection<Class<?>> classes = new LinkedList<Class<?>>();
  classes.add(Composite.class);
  classes.add(DOM.class);
  classes.add(UIObject.class);
  classes.add(Widget.class);

  classes.add(DataGrid.class);
  classes.add(HTMLTable.class);
  classes.add(Image.class);

  classes.add(AbsolutePanel.class);
  classes.add(CellList.class);
  classes.add(CellPanel.class);
  classes.add(CellTable.class);
  classes.add(ComplexPanel.class);
  classes.add(DeckLayoutPanel.class);
  classes.add(DeckPanel.class);
  classes.add(DecoratorPanel.class);
  classes.add(DockLayoutPanel.class);
  classes.add(DockPanel.class);
  classes.add(FlowPanel.class);
  classes.add(FocusPanel.class);
  classes.add(HorizontalPanel.class);
  classes.add(HTMLPanel.class);
  classes.add(LayoutPanel.class);
  classes.add(Panel.class);
  classes.add(PopupPanel.class);
  classes.add(RenderablePanel.class);
  classes.add(ResizeLayoutPanel.class);
  classes.add(SimpleLayoutPanel.class);
  classes.add(SimplePanel.class);
  classes.add(SplitLayoutPanel.class);
  classes.add(StackPanel.class);
  classes.add(VerticalPanel.class);
  classes.add(ValueListBox.class);

  WithClassesToStub annotation = unitTestClass.getAnnotation(WithClassesToStub.class);
  if (annotation != null) {
    classes.addAll(Arrays.asList(annotation.value()));
  }

  return classes;
}

/**
 * To get Kv pp View Edit Plugin Panel.
 * 
 * @return LayoutPanel
 */
public LayoutPanel getKvppViewEditPluginPanel() {
    return kvppViewEditPluginPanel;
}

/**
 * To get Batch List Panel.
 * 
 * @return LayoutPanel
 */
public LayoutPanel getBatchListPanel() {
    return batchListPanel;
}

/**
 * To get View Edit Layout Panel.
 * 
 * @return LayoutPanel
 */
public LayoutPanel getViewEditLayoutPanel() {
    return viewEditLayoutPanel;
}

/**
 * To get Batch Class Field Layout Panel.
 * 
 * @return LayoutPanel
 */
public LayoutPanel getBatchClassFieldLayoutPanel() {
    return batchClassFieldLayoutPanel;
}

/**
 * To set Batch Class Field Layout Panel.
 * 
 * @param batchClassFieldLayoutPanel LayoutPanel
 */
public void setBatchClassFieldLayoutPanel(LayoutPanel batchClassFieldLayoutPanel) {
    this.batchClassFieldLayoutPanel = batchClassFieldLayoutPanel;
}

/**
 * Constructs a new instance of this class given its parent and a style
 * value describing its behavior and appearance.
 * <p>
 * The style value is either one of the style constants defined in class
 * <code>SWT</code> which is applicable to instances of this class, or must
 * be built by <em>bitwise OR</em>'ing together (that is, using the
 * <code>int</code> "|" operator) two or more of those <code>SWT</code>
 * style constants. The class description lists the style constants that are
 * applicable to the class. Style bits are also inherited from superclasses.
 * </p>
 * 
 * @param parent
 *            a widget which will be the parent of the new instance (cannot
 *            be null)
 * @param style
 *            the style of widget to construct
 * 
 * @exception IllegalArgumentException
 *                <ul>
 *                <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
 *                </ul>
 * @exception SWTException
 *                <ul>
 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
 *                thread that created the parent</li>
 *                </ul>
 * 
 * @see SWT#H_SCROLL
 * @see SWT#V_SCROLL
 * @see #getStyle()
 */
public ScrolledComposite(Composite parent, int style) {
    super(new LayoutPanel(), parent, style);
}

/**
 * Constructs a new instance of this class given its parent and a style
 * value describing its behavior and appearance.
 * <p>
 * The style value is either one of the style constants defined in class
 * <code>SWT</code> which is applicable to instances of this class, or must
 * be built by <em>bitwise OR</em>'ing together (that is, using the
 * <code>int</code> "|" operator) two or more of those <code>SWT</code>
 * style constants. The class description lists the style constants that are
 * applicable to the class. Style bits are also inherited from superclasses.
 * </p>
 * 
 * @param parent
 *            a widget which will be the parent of the new instance (cannot
 *            be null)
 * @param style
 *            the style of widget to construct
 * 
 * @exception IllegalArgumentException
 *                <ul>
 *                <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
 *                </ul>
 * @exception SWTException
 *                <ul>
 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
 *                thread that created the parent</li>
 *                </ul>
 * 
 * @see SWT#NO_BACKGROUND
 * @see SWT#NO_FOCUS
 * @see SWT#NO_MERGE_PAINTS
 * @see SWT#NO_REDRAW_RESIZE
 * @see SWT#NO_RADIO_GROUP
 * @see SWT#EMBEDDED
 * @see SWT#DOUBLE_BUFFERED
 * @see Widget#getStyle
 */
public Composite(Composite parent, int style) {
    this(new LayoutPanel(), parent, checkStyle(style));
}

public void forceLayout() {  ((LayoutPanel)getWidget()).forceLayout(); }