• Home
• com.github.mvysny.karibu-tools
• karibu-tools
• 0.21
• source code

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

ysny.karibu-tools.karibu-tools.0.21.source-code.GridUtils.kt Maven / Gradle / Ivy

package com.github.mvysny.kaributools

import com.vaadin.flow.component.Component
import com.vaadin.flow.component.grid.*
import com.vaadin.flow.component.grid.Grid.Column
import com.vaadin.flow.component.treegrid.TreeGrid
import com.vaadin.flow.data.provider.QuerySortOrder
import com.vaadin.flow.data.provider.SortDirection
import com.vaadin.flow.data.provider.hierarchy.HierarchicalQuery
import com.vaadin.flow.data.renderer.ComponentRenderer
import com.vaadin.flow.data.renderer.Renderer
import com.vaadin.flow.data.selection.SelectionEvent
import com.vaadin.flow.data.selection.SelectionModel
import com.vaadin.flow.shared.util.SharedUtil
import java.lang.reflect.Field
import java.lang.reflect.Method
import kotlin.reflect.KProperty1
import kotlin.streams.toList

/**
 * Refreshes the Grid and re-polls for data.
 */
public fun Grid<*>.refresh() {
    dataProvider.refreshAll()
}

/**
 * Checks whether the grid is configured as multi-select. Returns false if the
 * grid is single-select or the selection is disabled.
 */
public val Grid<*>.isMultiSelect: Boolean get() = selectionModel.isMultiSelect
/**
 * Checks whether the grid is configured as single-select. Returns false if the
 * grid is multi-select or the selection is disabled.
 */
public val Grid<*>.isSingleSelect: Boolean get() = selectionModel.isSingleSelect

/**
 * Checks whether this model is multi-select.
 */
public val SelectionModel<*, *>.isMultiSelect: Boolean get() = this is SelectionModel.Multi<*, *>
/**
 * Checks whether this model is single-select.
 */
public val SelectionModel<*, *>.isSingleSelect: Boolean get() = this is SelectionModel.Single<*, *>

/**
 * Checks whether this is either [isMultiSelect] or [isSingleSelect].
 */
public val SelectionModel<*, *>.isSelectionAllowed: Boolean get() = isMultiSelect || isSingleSelect

/**
 * Sets or returns the current [Grid.SelectionMode].
 */
public var Grid<*>.selectionMode: Grid.SelectionMode
    get() = when {
        isSingleSelect -> Grid.SelectionMode.SINGLE
        isMultiSelect -> Grid.SelectionMode.MULTI
        else -> Grid.SelectionMode.NONE
    }
    set(value) {
        setSelectionMode(value)
    }

/**
 * Checks whether this is either [isMultiSelect] or [isSingleSelect].
 */
public val Grid<*>.isSelectionAllowed: Boolean get() = selectionModel.isSelectionAllowed

/**
 * If true, nothing is selected.
 */
public val GridSelectionModel<*>.isEmpty: Boolean get() = !firstSelectedItem.isPresent

/**
 * If true, nothing is selected.
 */
public val Grid<*>.isSelectionEmpty: Boolean get() = selectionModel.isEmpty

/**
 * Checks whether the new selection is empty.
 */
public val SelectionEvent<*, *>.isSelectionEmpty: Boolean get() = !firstSelectedItem.isPresent

/**
 * Adds a column for given [property]. The column key is set to the property name, so that you can look up the column
 * using [getColumnBy]. The column is also by default set to sortable
 * unless the [sortable] parameter is set otherwise.
 *
 * The header title is set to the property name, converted from camelCase to Human Friendly.
 *
 * WARNING: if an in-memory data provider is used, the sorting will be performed according to the
 * outcome of the [converter]. This may not be wanted, e.g. when the converter converts
 * date to a string. In this case, it's better to use the `addColumnFor(renderer)`.
 * @param converter optionally converts the property value [V] to something else,
 * typically to a String. Use this for formatting of the value. By default, simply returns the
 * value of the property.
 * @param T the type of the bean stored in the Grid
 * @param V the value that the column will display, deduced from the type of the [property].
 * @return the newly created column
 */
public fun  Grid.addColumnFor(
    property: KProperty1,
    sortable: Boolean = true,
    key: String = property.name,
    converter: (V?) -> Any? = { it }
): Grid.Column =
    addColumn { converter(property.get(it)) }.apply {
        this.key = key
        if (sortable) sortProperty = property
        setHeader(SharedUtil.camelCaseToHumanFriendly(property.name))
    }

/**
 * Adds a column for given [property], using given [renderer]. The column key is
 * set to the property name, so that you can look up the column
 * using [getColumnBy]. The column is also by default set to sortable
 * unless the [sortable] parameter is set otherwise. The header title is set to
 * the property name, converted from camelCase to Human Friendly.
 * @param renderer the renderer used to create the grid cell structure
 * @param T the type of the bean stored in the Grid
 * @param V the value that the column will display, deduced from the type of the [property].
 * @return the newly created column
 */
public fun  Grid.addColumnFor(
    property: KProperty1,
    renderer: Renderer,
    sortable: Boolean = true,
    key: String = property.name,
): Grid.Column =
    addColumn(renderer).apply {
        this.key = key
        if (sortable) sortProperty = property
        setHeader(SharedUtil.camelCaseToHumanFriendly(property.name))
    }

/**
 * Sets the property by which this column will sort. Setting this property will automatically make the column sortable.
 * You can use the [addColumnFor] which also sets the column by default to sortable.
 *
 * Example of usage:
 * ```
 * grid {
 *     addColumn({ it.name }).apply {
 *         setHeader("Name")
 *         sortProperty = Person::name
 *     }
 * }
 * ```
 */
public var  Grid.Column.sortProperty: KProperty1
    @Deprecated("Cannot read this property", level = DeprecationLevel.ERROR)
    get() = throw UnsupportedOperationException("Unsupported")
    set(value) {
        setSortProperty(value.name)
    }

/**
 * Retrieves the column for given [property]; it matches [Grid.Column.getKey] to [KProperty1.name].
 * @throws IllegalArgumentException if no such column exists.
 */
public fun  Grid.getColumnBy(property: KProperty1): Grid.Column =
    getColumnByKey(property.name)
            ?: throw IllegalArgumentException("No column with key $property; available column keys: ${columns.mapNotNull { it.key }}")

/**
 * Adds a column for given [propertyName]. The column key is set to the property name, so that you can look up the column
 * using [getColumnBy]. The column is also by default set to sortable
 * unless the [sortable] parameter is set otherwise. The header title is set to
 * the property name, converted from camelCase to Human Friendly.
 *
 * This method should only be used when you have a Grid backed by a Java class
 * which does not have properties exposed as [KProperty1]; for Kotlin
 * class-backed Grids you should use `addColumnFor(KProperty1)`
 *
 * WARNING: if an in-memory data provider is used, the sorting will be performed according to the
 * outcome of the [converter]. This may not be wanted, e.g. when the converter converts
 * date to a string. In this case, it's better to use the `addColumnFor(renderer)`.
 * @param converter optionally converts the property value [V] to something else,
 * typically to a String. Use this for formatting of the value. By default, simply returns the
 * value of the property.
 * @param T the type of the bean stored in the Grid
 * @param V the value that the column will display.
 * @return the newly created column
 */
public inline fun  Grid.addColumnFor(
    propertyName: String,
    sortable: Boolean = true,
    key: String = propertyName,
    noinline converter: (V?) -> Any? = { it }
): Grid.Column {
    val getter: Method = T::class.java.getGetter(propertyName)
    val column: Grid.Column = addColumn { converter(V::class.java.cast(getter.invoke(it))) }
    return column.apply {
        this.key = key
        if (sortable) {
            setSortProperty(propertyName)
        }
        setHeader(SharedUtil.camelCaseToHumanFriendly(propertyName))
    }
}

/**
 * Adds a column for given [propertyName], using given [renderer]. The column key is set to the property name, so that you can look up the column
 * using [getColumnBy]. The column is also by default set to sortable
 * unless the [sortable] parameter is set otherwise. The header title is set to the property name, converted from camelCase to Human Friendly.
 *
 * This method should only be used when you have a Grid backed by a Java class which does not have properties exposed as [KProperty1]; for Kotlin
 * class-backed Grids you should use `addColumnFor(KProperty1)`
 * @param renderer the renderer used to create the grid cell structure
 * @param T the type of the bean stored in the Grid
 * @param V the value that the column will display, deduced from the type of the [propertyName].
 * @return the newly created column
 */
public fun  Grid.addColumnFor(
    propertyName: String,
    renderer: Renderer,
    sortable: Boolean = true,
    key: String = propertyName,
): Grid.Column =
    addColumn(renderer).apply {
        this.key = key
        if (sortable) {
            setSortProperty(propertyName)
        }
        setHeader(SharedUtil.camelCaseToHumanFriendly(propertyName))
    }

/**
 * Returns `com.vaadin.flow.component.grid.AbstractColumn`
 */
@Suppress("ConflictingExtensionProperty")  // conflicting property is "protected"
internal val HeaderRow.HeaderCell.column: Any
    get() = _AbstractCell_getColumn.invoke(this)

private val abstractCellClass: Class<*> = Class.forName("com.vaadin.flow.component.grid.AbstractRow\$AbstractCell")
private val abstractColumnClass: Class<*> = Class.forName("com.vaadin.flow.component.grid.AbstractColumn")
private val _AbstractCell_getColumn: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
    val m: Method = abstractCellClass.getDeclaredMethod("getColumn")
    m.isAccessible = true
    m
}

/**
 * Returns `com.vaadin.flow.component.grid.AbstractColumn`
 */
@Suppress("ConflictingExtensionProperty")  // conflicting property is "protected"
private val FooterRow.FooterCell.column: Any
    get() = _AbstractCell_getColumn.invoke(this)

/**
 * Retrieves the cell for given [property]; it matches [Grid.Column.getKey] to [KProperty1.name].
 * @return the corresponding cell
 * @throws IllegalArgumentException if no such column exists.
 */
public fun HeaderRow.getCell(property: KProperty1<*, *>): HeaderRow.HeaderCell {
    val cell: HeaderRow.HeaderCell? = cells.firstOrNull { it.column.columnKey == property.name }
    require(cell != null) { "This grid has no property named ${property.name}: $cells" }
    return cell
}

private val _AbstractColumn_getBottomLevelColumn: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
    val method: Method = abstractColumnClass.getDeclaredMethod("getBottomLevelColumn")
    method.isAccessible = true
    method
}

private val Any.columnKey: String?
get() {
    abstractColumnClass.cast(this)
    val gridColumn: Grid.Column<*> = _AbstractColumn_getBottomLevelColumn.invoke(this) as Grid.Column<*>
    return gridColumn.key
}

/**
 * Retrieves the cell for given [property]; it matches [Grid.Column.getKey] to [KProperty1.name].
 * @return the corresponding cell
 * @throws IllegalArgumentException if no such column exists.
 */
public fun FooterRow.getCell(property: KProperty1<*, *>): FooterRow.FooterCell {
    val cell: FooterRow.FooterCell? = cells.firstOrNull { it.column.columnKey == property.name }
    require(cell != null) { "This grid has no property named ${property.name}: $cells" }
    return cell
}

private val _AbstractColumn_getHeaderRenderer: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
    val method: Method = abstractColumnClass.getDeclaredMethod("getHeaderRenderer")
    method.isAccessible = true
    method
}

/**
 * Returns the renderer which renders the contents of a cell. Only works for Vaadin 23 and lower.
 */
public val HeaderRow.HeaderCell.renderer: Renderer<*>?
    get() {
        check(VaadinVersion.get.major < 24) { "Vaadin 24+ cells do not have Renderer" }
        val renderer: Any = _AbstractColumn_getHeaderRenderer.invoke(column)
        return renderer as Renderer<*>?
    }

private val _AbstractColumn_getFooterRenderer: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
    val method: Method = abstractColumnClass.getDeclaredMethod("getFooterRenderer")
    method.isAccessible = true
    method
}

/**
 * Returns the renderer which renders the contents of a cell.
 */
public val FooterRow.FooterCell.renderer: Renderer<*>?
    get() {
        check(VaadinVersion.get.major < 24) { "Vaadin 24+ cells do not have Renderer" }
        val renderer = _AbstractColumn_getFooterRenderer.invoke(column)
        return renderer as Renderer<*>?
    }

/**
 * Returns or sets the component in grid's footer cell.
 * Returns `null` if the cell contains String, something else than a component or
 * nothing at all.
 */
public var FooterRow.FooterCell.component: Component?
    get() {
        if (VaadinVersion.get.major >= 24) {
            return abstractCellClass.getDeclaredMethod("getComponent").invoke(this) as Component?
        }
        val cr: ComponentRenderer<*, *> = (renderer as? ComponentRenderer<*, *>) ?: return null
        return cr.createComponent(null)
    }
    set(value) {
        setComponent(value)
    }

private val gridSorterComponentRendererClass: Class<*>? = try {
    Class.forName("com.vaadin.flow.component.grid.GridSorterComponentRenderer")
} catch (e: ClassNotFoundException) {
    // Vaadin 18.0.3+ and Vaadin 14.5.0+ doesn't contain this class anymore and simply uses ComponentRenderer
    null
}
private val _GridSorterComponentRenderer_component: Field? =
    if (gridSorterComponentRendererClass == null) { null } else {
        val field = gridSorterComponentRendererClass.getDeclaredField("component")
        field.isAccessible = true
        field
    }

/**
 * Returns or sets the component in grid's header cell.
 * Returns `null` if the cell contains String, something else than a component or
 * nothing at all.
 */
@Suppress("UNCHECKED_CAST")
public var HeaderRow.HeaderCell.component: Component?
    get() {
        if (VaadinVersion.get.major >= 24) {
            return abstractCellClass.getDeclaredMethod("getComponent").invoke(this) as Component?
        }
        val r: Renderer<*>? = renderer
        if (gridSorterComponentRendererClass != null && gridSorterComponentRendererClass.isInstance(r)) {
            return _GridSorterComponentRenderer_component!!.get(r) as Component?
        }
        if (r is ComponentRenderer<*, *>) {
            return (r as ComponentRenderer<*, Any?>).createComponent(null)
        }
        return null
    }
    set(value) {
        setComponent(value)
    }

/**
 * Forces a defined sort [order] for the columns in the Grid. Setting
 * empty list resets the ordering of all columns.
 * Columns not mentioned in the list are reset to the unsorted state.
 *
 * For Grids with multi-sorting, the index of a given column inside the list
 * defines the sort priority. For example, the column at index 0 of the list
 * is sorted first, then on the index 1, and so on.
 *
 * Exampe of usage:
 * ```
 * grid {
 *   val nameColumn = addColumnFor(Person::name)
 *   sort(nameColumn.asc)
 * }
 * ```
 * @param order
 *            the list of sort orders to set on the client, or
 *            null to reset any sort orders.
 * @see [Grid.setMultiSort]
 * @see [Grid.getSortOrder]
*/
public fun  Grid.sort(vararg order: GridSortOrder) {
    sort(order.toList())
}

/**
 * Alias for [sort]. A setter which merely accompanies the [Grid.getSortOrder] getter.
 */
public fun  Grid.setSortOrder(order: List>) {
    sort(order)
}

/**
 * Forces a defined sort [criteria] for the columns in the Grid. Setting
 * empty list resets the ordering of all columns.
 * Columns not mentioned in the list are reset to the unsorted state.
 *
 * For Grids with multi-sorting, the index of a given column inside the list
 * defines the sort priority. For example, the column at index 0 of the list
 * is sorted first, then on the index 1, and so on.
 *
 * Exampe of usage:
 * ```
 * grid {
 *   addColumnFor(Person::name)
 *   sort(Person::name.asc)
 * }
 * ```
 */
public fun  Grid.sort(vararg criteria: QuerySortOrder) {
    // check that columns are sortable
    val crit: List> = criteria.map { sortOrder ->
        val col: Grid.Column = getColumnBySortOrder(sortOrder)
        require(col.isSortable) { "Column for ${sortOrder.sorted} is not marked sortable" }
        GridSortOrder(col, sortOrder.direction)
    }

    sort(crit)
}

/**
 * Returns Grid column having [QuerySortOrder.sorted] as one of its sort properties.
 *
 * By default, column's sort property is set to [Column.getKey] but can be changed via [Column.setSortProperty].
 * @throws IllegalArgumentException if there's no such column.
 */
public fun  Grid.getColumnBySortOrder(sortOrder: QuerySortOrder): Column = getColumnBySortProperty(sortOrder.sorted)

/**
 * Returns Grid column having given [sortProperty].
 *
 * By default, column's sort property is set to [Column.getKey] but can be changed via [Column.setSortProperty].
 * @throws IllegalArgumentException if there's no such column.
 */
public fun  Grid.getColumnBySortProperty(sortProperty: String): Column {
    val column = columns.firstOrNull {  column ->
        column.getSortOrder(SortDirection.ASCENDING).anyMatch { it.sorted == sortProperty }
    }
    requireNotNull(column) {
        "No column with sort order '${sortProperty}'; available column sort orders: ${columns.map { column -> column.getSortOrder(SortDirection.ASCENDING).map { it.sorted } .toList() }}"
    }
    return column
}

/**
 * Creates a [GridSortOrder] sorting this column ascending.
 */
public val  Grid.Column.asc: GridSortOrder get() = GridSortOrder(this, SortDirection.ASCENDING)
/**
 * Creates a [GridSortOrder] sorting this column descending.
 */
public val  Grid.Column.desc: GridSortOrder get() = GridSortOrder(this, SortDirection.DESCENDING)

/**
 * Fetches the root items of a tree grid.
 */
public fun  TreeGrid.getRootItems(): List =
    dataProvider.fetch(HierarchicalQuery(null, null)).toList()

/**
 * Expands all nodes. May invoke massive data loading.
 */
@JvmOverloads
public fun  TreeGrid.expandAll(depth: Int = 100) {
    expandRecursively(getRootItems(), depth)
}

private fun Any.gridAbstractHeaderGetHeader(): String {
    check(VaadinVersion.get.major < 24) { "Vaadin 24+ cells do not have Renderer" }
    // nasty reflection. Added a feature request to have this: https://github.com/vaadin/vaadin-grid-flow/issues/567
    val e: Renderer<*>? = _AbstractColumn_getHeaderRenderer.invoke(this) as Renderer<*>?
    return e?.template ?: ""
}

private fun Component.gridColumnGetHeaderTextVaadin24(): String {
    val m = abstractColumnClass.getDeclaredMethod("getHeaderText")
    m.isAccessible = true
    return m.invoke(this) as String? ?: ""
}

/**
 * Sets and retrieves the column header as set by [Grid.Column.setHeader] (String).
 * The result value is undefined if a component has been set as the header.
 */
public var  Grid.Column.header2: String
    get() {
        if (VaadinVersion.get.major >= 24) {
            var result: String = gridColumnGetHeaderTextVaadin24()
            if (result.isBlank()) {
                // in case of grouped cells, the header is stored in a parent ColumnGroup.
                val parent: Component? = parent.orElse(null)
                if (parent != null && parent.javaClass.name == "com.vaadin.flow.component.grid.ColumnGroup" && parent.children.count() == 1L) {
                    result = parent.gridColumnGetHeaderTextVaadin24()
                }
            }
            return result
        }
        var result: String = gridAbstractHeaderGetHeader()
        if (result.isEmpty()) {
            // in case of grouped cells, the header is stored in a parent ColumnGroup.
            val parent: Component? = parent.orElse(null)
            if (parent != null && parent.javaClass.name == "com.vaadin.flow.component.grid.ColumnGroup" && parent.children.count() == 1L) {
                result = parent.gridAbstractHeaderGetHeader()
            }
        }
        return result
    }
    set(value) {
        setHeader(value)
    }

private val _Column_getInternalId: Method by lazy(LazyThreadSafetyMode.PUBLICATION) {
    val m = Grid.Column::class.java.getDeclaredMethod("getInternalId")
    m.isAccessible = true
    m
}

/**
 * Returns the column's Internal ID. Not related to [Grid.Column.getKey] in any way.
 * Auto-generated by the Grid. Not really useful; mostly used internally by Vaadin.
 */
public val Grid.Column<*>._internalId: String
    get() = _Column_getInternalId.invoke(this) as String

public val ItemClickEvent<*>.isDoubleClick: Boolean
    get() = clickCount >= 2