Java LayoutRow类代码示例

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
public void load(LayoutTemplate layoutTemplate,
                 String emptyTitleText,
                 String emptySubTitleText) {
    this.layoutTemplate = layoutTemplate;
    this.layoutName = layoutTemplate.getName();
    this.pageStyle = layoutTemplate.getStyle();
    this.emptyTitleText = emptyTitleText;
    this.emptySubTitleText = emptySubTitleText;
    this.rows.forEach(this::destroy);
    this.rows.clear();
    if (!layoutTemplate.isEmpty()) {
        this.properties = layoutTemplate.getLayoutProperties();
        for (LayoutRow layoutRow : layoutTemplate.getRows()) {
            rows.add(load(layoutRow));
        }
        updateView();
    } else {
        clearView();
        createEmptyDropRow();
    }
    setupResizeRows();
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
private void extractColumnWithComponents(LayoutColumn layoutColumn) {
    for (LayoutRow row : layoutColumn.getRows()) {
        Integer columnWidth = new Integer(layoutColumn.getSpan());
        final ColumnWithComponents columnWithComponents = createColumnWithComponentsInstance();

        columnWithComponents
                .init(id,
                      columnWidth,
                      pageStyle,
                      dropCommand(),
                      removeComponentCommand,
                      removeColumnCommand(),
                      currentLayoutTemplateSupplier,
                      getHeight(layoutColumn.getHeight()));

        for (LayoutColumn column : row.getLayoutColumns()) {
            ComponentColumn newComponentColumn = getComponentColumn(column);
            newComponentColumn.setColumnHeight(getHeight(column.getHeight()));
            columnWithComponents.withComponents(newComponentColumn);
        }

        this.columns.add(columnWithComponents);
    }
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
public boolean hasNavigationComponents(LayoutRow row) {
    for (LayoutColumn column : row.getLayoutColumns()) {

        for (LayoutComponent component : column.getLayoutComponents()) {
            NavDragComponentType dragType = NavDragComponentType.getByClassName(component.getDragTypeName());
            if (dragType != null && ALL_NAV_GROUP_COMPONENTS.contains(dragType)) {
                return true;
            }
        }

        for (LayoutRow childRow : column.getRows()) {
            boolean hasNavComps = hasNavigationComponents(childRow);
            if (hasNavComps) {
                return true;
            }
        }
    }
    return false;
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
protected void addFieldsToTemplate(LayoutTemplate template,
                                   List<FieldDefinition> fields,
                                   String formId) {
    fields.forEach(field -> {
        LayoutComponent layoutComponent = new LayoutComponent(getDraggableType());
        layoutComponent.addProperty(FormLayoutComponent.FORM_ID,
                                    formId);
        layoutComponent.addProperty(FormLayoutComponent.FIELD_ID,
                                    field.getId());

        LayoutColumn column = new LayoutColumn("12");
        column.add(layoutComponent);

        LayoutRow row = new LayoutRow();
        row.add(column);

        template.addRow(row);
    });
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
@Override
public LayoutInstance build(LayoutTemplate layoutTemplate) {
    HTMLElement container = createContainer(layoutTemplate);
    container.getClassList().add("uf-perspective-container");
    container.getClassList().add("uf-perspective-rendered-container");

    LayoutInstance layoutInstance = new LayoutInstance(container);
    List<LayoutRow> rows = layoutTemplate.getRows();
    generateRows(layoutTemplate, layoutInstance, rows, container);
    return layoutInstance;
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
private void generateRows(LayoutTemplate layoutTemplate,
                          LayoutInstance layoutInstance,
                          List<LayoutRow> rows,
                          HTMLElement parentWidget) {
    for (LayoutRow layoutRow : rows) {
        HTMLElement row = createRow(layoutRow);

        if (layoutTemplate.isPageStyle()) {
            row.getClassList().add(RowSizeBuilder.buildRowSize(layoutRow.getHeight()));
            row.getClassList().add("uf-le-overflow");
        }
        for (LayoutColumn layoutColumn : layoutRow.getLayoutColumns()) {
            HTMLElement column = createColumn(layoutColumn);

            if (layoutTemplate.isPageStyle() && layoutColumn.getHeight().isEmpty()) {
                column.getClassList().add("uf-perspective-col");
            }
            if (columnHasNestedRows(layoutColumn)) {
                if (layoutTemplate.isPageStyle() && layoutColumn.getHeight().isEmpty()) {
                    column.getClassList().add("uf-perspective-col");
                } else if (!layoutColumn.getHeight().isEmpty()) {
                    column.getClassList().add("uf-perspective-row-" + layoutColumn.getHeight());
                }
                generateRows(layoutTemplate,
                             layoutInstance,
                             layoutColumn.getRows(),
                             column);
            } else {
                generateComponents(layoutTemplate,
                                   layoutInstance,
                                   layoutColumn,
                                   column);
            }
            column.getClassList().add("uf-perspective-rendered-col");
            row.appendChild(column);
        }
        row.getClassList().add("uf-perspective-rendered-row");
        parentWidget.appendChild(row);
    }
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
private static void extractRows(List<Row> rows,
                                LayoutTemplate layoutTemplate) {
    for (Row row : rows) {
        LayoutRow layoutRow = new LayoutRow(row.getHeight().toString());
        extractColumns(row.getColumns(),
                       layoutRow);
        layoutTemplate.addRow(layoutRow);
    }
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
private static void extractColumns(List<Column> columns,
                                   LayoutRow layoutRow) {
    for (Column col : columns) {
        LayoutColumn layoutColumn = new LayoutColumn(col.getColumnWidth().toString(),
                                                     col.getColumnHeight().toString());
        if (col.hasInnerRows()) {
            extractColumnWithComponents(col,
                                        layoutColumn);
        } else {
            extractComponents(col,
                              layoutColumn);
        }
        layoutRow.add(layoutColumn);
    }
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
private static void extractColumnWithComponents(Column col,
                                                LayoutColumn layoutColumn) {
    if (col instanceof ColumnWithComponents) {
        ColumnWithComponents columnWithComponents = (ColumnWithComponents) col;
        LayoutRow layoutRow = new LayoutRow(Row.ROW_DEFAULT_HEIGHT.toString());
        extractColumns(columnWithComponents.getRow().getColumns(),
                       layoutRow);
        layoutColumn.addRow(layoutRow);
    }
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
public void load(ParameterizedCommand<RowDrop> dropOnRowCommand,
                 LayoutRow layoutRow,
                 ParameterizedCommand<Row> removeCommand,
                 ParameterizedCommand<ColumnDrop> removeComponentCommand,
                 Supplier<LayoutTemplate> currentLayoutTemplateSupplier) {
    this.dropOnRowCommand = dropOnRowCommand;
    this.removeRowCommand = removeCommand;
    this.removeComponentCommand = removeComponentCommand;
    this.currentLayoutTemplateSupplier = currentLayoutTemplateSupplier;
    this.height = getHeight(layoutRow.getHeight());
    setupPageLayout(height);
    extractColumns(layoutRow);
    setupColumnResizeActions();
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
private void extractColumns(LayoutRow layoutRow) {
    for (LayoutColumn layoutColumn : layoutRow.getLayoutColumns()) {
        if (isColumnWithComponents(layoutColumn)) {
            extractColumnWithComponents(layoutColumn);
        } else {
            extractComponentColumn(layoutColumn);
        }
    }
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
public static List<String> list(LayoutTemplate layout) {
    List<String> ids = new ArrayList<>();
    List<LayoutRow> rows = layout.getRows();
    searchForComponents(rows,
                        ids);
    return ids;
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
private static void searchForComponents(List<LayoutRow> rows,
                                        List<String> ids) {
    for (LayoutRow layoutRow : rows) {
        for (LayoutColumn layoutColumn : layoutRow.getLayoutColumns()) {
            if (columnHasNestedRows(layoutColumn)) {
                searchForComponents(layoutColumn.getRows(),
                                    ids);
            } else {
                extractTargetDiv(layoutColumn.getLayoutComponents(),
                                 ids);
            }
        }
    }
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
public boolean analyzeRecursion(LayoutTemplate layoutTemplate, LayoutRecursionIssue issue, LayoutTemplateContext layoutCtx) {
    for (LayoutRow row : layoutTemplate.getRows()) {
        boolean hasIssue = analyzeRecursion(row, issue, layoutCtx);
        if (hasIssue) {
            return true;
        }
    }
    return false;
}
 

import org.uberfire.ext.layout.editor.api.editor.LayoutRow; //导入依赖的package包/类
public LayoutTemplate build() {
    LayoutTemplate template = new LayoutTemplate();

    rows.stream()
            .filter(row -> !row.cells.isEmpty())
            .forEach(row -> {
                LayoutRow layoutRow = new LayoutRow();

                template.addRow(layoutRow);

                row.cells.forEach(cell -> {
                    LayoutColumn layoutColumn = new LayoutColumn(String.valueOf(cell.horizontalSpan));
                    layoutRow.add(layoutColumn);

                    if (cell.getComponentsCount() == 0) {
                        return;
                    } else if (cell.getComponentsCount() == 1) {
                        layoutColumn.add(cell.components.get(0));
                    } else {
                        cell.components.forEach(component -> {
                            LayoutRow nestedRow = new LayoutRow();
                            layoutColumn.addRow(nestedRow);
                            LayoutColumn nestedColumn = new LayoutColumn(String.valueOf(MAX_SPAN));
                            nestedRow.add(nestedColumn);
                            nestedColumn.add(component);
                        });
                    }
                });
            });

    return template;
}