@Override public void layout() { if (!vertical) calculateHorizBoundsAndPositions(); else calculateVertBoundsAndPositions(); Actor firstWidget = this.firstWidget; if (firstWidget != null) { Rectangle firstWidgetBounds = this.firstWidgetBounds; firstWidget.setBounds( firstWidgetBounds.x, firstWidgetBounds.y, firstWidgetBounds.width, firstWidgetBounds.height); if (firstWidget instanceof Layout) ((Layout) firstWidget).validate(); } Actor secondWidget = this.secondWidget; if (secondWidget != null) { Rectangle secondWidgetBounds = this.secondWidgetBounds; secondWidget.setBounds( secondWidgetBounds.x, secondWidgetBounds.y, secondWidgetBounds.width, secondWidgetBounds.height); if (secondWidget instanceof Layout) ((Layout) secondWidget).validate(); } }
private void computeSize(Array<Node> nodes, float indent) { float ySpacing = this.ySpacing; for (int i = 0, n = nodes.size; i < n; i++) { Node node = nodes.get(i); float rowWidth = indent + iconSpacing; Actor actor = node.actor; if (actor instanceof Layout) { Layout layout = (Layout) actor; rowWidth += layout.getPrefWidth(); node.height = layout.getPrefHeight(); layout.pack(); } else { rowWidth += actor.getWidth(); node.height = actor.getHeight(); } if (node.icon != null) { rowWidth += iconSpacing * 2 + node.icon.getMinWidth(); node.height = Math.max(node.height, node.icon.getMinHeight()); } prefWidth = Math.max(prefWidth, rowWidth); prefHeight -= node.height + ySpacing; if (node.expanded) computeSize(node.children, indent + indentSpacing); } }
private void invalidateChildren(WidgetGroup group) { SnapshotArray<Actor> children = group.getChildren(); Actor actor; for (int i = 0; i < children.size; i++) { actor = children.get(i); if (actor instanceof Layout) { // UIWidgets are the best! :D ((Layout) actor).invalidate(); } if (actor instanceof WidgetGroup) { // If it's a group, recurse invalidateChildren((WidgetGroup) actor); } } group.invalidate(); }
public void layout() { final Drawable bg = style.background; final Drawable hScrollKnob = style.hScrollKnob; final Drawable vScrollKnob = style.vScrollKnob; float bgLeftWidth = 0, bgRightWidth = 0, bgTopHeight = 0, bgBottomHeight = 0; if (bg != null) { bgLeftWidth = bg.getLeftWidth(); bgRightWidth = bg.getRightWidth(); bgTopHeight = bg.getTopHeight(); bgBottomHeight = bg.getBottomHeight(); } float width = getWidth(); float height = getHeight(); float scrollbarHeight = 0; if (hScrollKnob != null) scrollbarHeight = hScrollKnob.getMinHeight(); if (style.hScroll != null) scrollbarHeight = Math.max(scrollbarHeight, style.hScroll.getMinHeight()); float scrollbarWidth = 0; if (vScrollKnob != null) scrollbarWidth = vScrollKnob.getMinWidth(); if (style.vScroll != null) scrollbarWidth = Math.max(scrollbarWidth, style.vScroll.getMinWidth()); // Get available space size by subtracting background's padded area. areaWidth = width - bgLeftWidth - bgRightWidth; areaHeight = height - bgTopHeight - bgBottomHeight; if (widget == null) return; // Get widget's desired width. float widgetWidth, widgetHeight; if (widget instanceof Layout) { Layout layout = (Layout) widget; widgetWidth = layout.getPrefWidth(); widgetHeight = layout.getPrefHeight(); } else { widgetWidth = widget.getWidth(); widgetHeight = widget.getHeight(); } // Determine if horizontal/vertical scrollbars are needed. scrollX = forceScrollX || (widgetWidth > areaWidth && !disableX); scrollY = forceScrollY || (widgetHeight > areaHeight && !disableY); boolean fade = fadeScrollBars; if (!fade) { // Check again, now taking into account the area that's taken up by any enabled scrollbars. if (scrollY) { areaWidth -= scrollbarWidth; if (!scrollX && widgetWidth > areaWidth && !disableX) { scrollX = true; } } if (scrollX) { areaHeight -= scrollbarHeight; if (!scrollY && widgetHeight > areaHeight && !disableY) { scrollY = true; areaWidth -= scrollbarWidth; } } } // Set the widget area bounds. widgetAreaBounds.set(bgLeftWidth, bgBottomHeight, areaWidth, areaHeight); if (fade) { // Make sure widget is drawn under fading scrollbars. if (scrollX) areaHeight -= scrollbarHeight; if (scrollY) areaWidth -= scrollbarWidth; } else { if (scrollbarsOnTop) { // Make sure widget is drawn under non-fading scrollbars. if (scrollX) widgetAreaBounds.height += scrollbarHeight; if (scrollY) widgetAreaBounds.width += scrollbarWidth; } else { // Offset widget area y for horizontal scrollbar. if (scrollX) { if (hScrollOnBottom) { widgetAreaBounds.y += scrollbarHeight; } else { widgetAreaBounds.y = 0; } } // Offset widget area x for vertical scrollbar. if (scrollY) { if (vScrollOnRight) { widgetAreaBounds.x = 0; } else { widgetAreaBounds.x += scrollbarWidth; } } } } // If the widget is smaller than the available space, make it take up the available space. widgetWidth = disableX ? width : Math.max(areaWidth, widgetWidth); widgetHeight = disableY ? height : Math.max(areaHeight, widgetHeight); maxX = widgetWidth - areaWidth; maxY = widgetHeight - areaHeight; if (fade) { // Make sure widget is drawn under fading scrollbars. if (scrollX) maxY -= scrollbarHeight; if (scrollY) maxX -= scrollbarWidth; } scrollX(MathUtils.clamp(amountX, 0, maxX)); scrollY(MathUtils.clamp(amountY, 0, maxY)); // Set the bounds and scroll knob sizes if scrollbars are needed. if (scrollX) { if (hScrollKnob != null) { float hScrollHeight = style.hScroll != null ? style.hScroll.getMinHeight() : hScrollKnob.getMinHeight(); // the small gap where the two scroll bars intersect might have to flip from right to left float boundsX, boundsY; if (vScrollOnRight) { boundsX = bgLeftWidth; } else { boundsX = bgLeftWidth + scrollbarWidth; } // bar on the top or bottom if (hScrollOnBottom) { boundsY = bgBottomHeight; } else { boundsY = height - bgTopHeight - hScrollHeight; } hScrollBounds.set(boundsX, boundsY, areaWidth, hScrollHeight); hKnobBounds.width = Math.max( hScrollKnob.getMinWidth(), (int) (hScrollBounds.width * areaWidth / widgetWidth)); hKnobBounds.height = hScrollKnob.getMinHeight(); hKnobBounds.x = hScrollBounds.x + (int) ((hScrollBounds.width - hKnobBounds.width) * getScrollPercentX()); hKnobBounds.y = hScrollBounds.y; } else { hScrollBounds.set(0, 0, 0, 0); hKnobBounds.set(0, 0, 0, 0); } } if (scrollY) { if (vScrollKnob != null) { float vScrollWidth = style.vScroll != null ? style.vScroll.getMinWidth() : vScrollKnob.getMinWidth(); // the small gap where the two scroll bars intersect might have to flip from bottom to top float boundsX, boundsY; if (hScrollOnBottom) { boundsY = height - bgTopHeight - areaHeight; } else { boundsY = bgBottomHeight; } // bar on the left or right if (vScrollOnRight) { boundsX = width - bgRightWidth - vScrollWidth; } else { boundsX = bgLeftWidth; } vScrollBounds.set(boundsX, boundsY, vScrollWidth, areaHeight); vKnobBounds.width = vScrollKnob.getMinWidth(); vKnobBounds.height = Math.max( vScrollKnob.getMinHeight(), (int) (vScrollBounds.height * areaHeight / widgetHeight)); if (vScrollOnRight) { vKnobBounds.x = width - bgRightWidth - vScrollKnob.getMinWidth(); } else { vKnobBounds.x = bgLeftWidth; } vKnobBounds.y = vScrollBounds.y + (int) ((vScrollBounds.height - vKnobBounds.height) * (1 - getScrollPercentY())); } else { vScrollBounds.set(0, 0, 0, 0); vKnobBounds.set(0, 0, 0, 0); } } widget.setSize(widgetWidth, widgetHeight); if (widget instanceof Layout) ((Layout) widget).validate(); }
public void layout() { Table table = getTable(); float width = table.getWidth(); float height = table.getHeight(); super.layout(0, 0, width, height); java.util.List<Cell> cells = getCells(); if (round) { for (int i = 0, n = cells.size(); i < n; i++) { Cell c = cells.get(i); if (c.getIgnore()) continue; float widgetWidth = Math.round(c.getWidgetWidth()); float widgetHeight = Math.round(c.getWidgetHeight()); float widgetX = Math.round(c.getWidgetX()); float widgetY = height - Math.round(c.getWidgetY()) - widgetHeight; c.setWidgetX(widgetX); c.setWidgetY(widgetY); c.setWidgetWidth(widgetWidth); c.setWidgetHeight(widgetHeight); Actor actor = (Actor) c.getWidget(); if (actor != null) { actor.setX(widgetX); actor.setY(widgetY); if (actor.getWidth() != widgetWidth || actor.getHeight() != widgetHeight) { actor.setWidth(widgetWidth); actor.setHeight(widgetHeight); if (actor instanceof Layout) ((Layout) actor).invalidate(); } } } } else { for (int i = 0, n = cells.size(); i < n; i++) { Cell c = cells.get(i); if (c.getIgnore()) continue; float widgetWidth = c.getWidgetWidth(); float widgetHeight = c.getWidgetHeight(); float widgetX = c.getWidgetX(); float widgetY = height - c.getWidgetY() - widgetHeight; c.setWidgetX(widgetX); c.setWidgetY(widgetY); c.setWidgetWidth(widgetWidth); c.setWidgetHeight(widgetHeight); Actor actor = (Actor) c.getWidget(); if (actor != null) { actor.setX(widgetX); actor.setY(widgetY); if (actor.getWidth() != widgetWidth || actor.getHeight() != widgetHeight) { actor.setWidth(widgetWidth); actor.setHeight(widgetHeight); if (actor instanceof Layout) ((Layout) actor).invalidate(); } } } } // Validate children separately from sizing actors to ensure actors without a cell are // validated. Array<Actor> children = table.getChildren(); for (int i = 0, n = children.size; i < n; i++) { Actor child = children.get(i); if (child instanceof Layout) ((Layout) child).validate(); } }