AdaptiveTableLayout

The library is composed of three main parts that work in tandem to render and manage table data:

1. AdaptiveTableLayout (View): The primary UI component used in your XML layouts or programmatically to display the table.
2. LinkedAdaptiveTableAdapter (Adapter): The bridge between your data and the view. It manages how data is mapped to rows and columns.
3. ViewHolderImpl (ViewHolder): Handles the individual cell representations and recycling logic.

The library provides different adapter strategies depending on your data size and mutability requirements:

• BaseDataAdaptiveTableLayoutAdapter: A simple adapter for light data. Warning: Every time a row or column is switched, the original data is modified directly.
• LinkedAdaptiveTableAdapter: Designed for heavy data. It does not change the original data. Instead, it maintains a matrix of modifications using links. To extract the final state of the data, you must call AdaptiveTableLayout.getLinkedAdapterRowsModifications() and AdaptiveTableLayout.getLinkedAdapterColumnsModifications().

Important: For both adapter types, you must know all row/column widths, heights, and counts before setting the adapter to the AdaptiveTableLayout.

Add the following dependency to your build.gradle file to include the AdaptiveTableLayout library in your Android project.

dependencies {
    implementation "com.cleveroad:adaptivetablelayout:1.2.1"
}

The LinkedAdaptiveTableAdapter acts as a decorator (wrapper) for an existing AdaptiveTableAdapter. It allows you to visually reorder rows and columns in the table layout without actually modifying the underlying data source. It maintains internal mapping (redirection) between the original data indices and the new visual indices.

Key capabilities:

• Reorder Rows/Columns: Use changeRows and changeColumns to swap positions.
• Row Header Behavior: You can configure whether row headers are fixed to the specific row data or to the row number via the isSolidRowHeader parameter.
• State Persistence: It implements onSaveInstanceState and onRestoreInstanceState to preserve reordering after configuration changes (like screen rotation).

To determine which cell a user has interacted with based on touch coordinates, use the coordinate mapping methods. These methods automatically account for the header offsets (mHeaderRowWidth for X and mHeaderColumnHeight for Y).

• getRowByY(int y): Use this to find the row index for a given Y coordinate.
• getColumnByX(int x): Use this to find the column index for a given X coordinate.
• getRowByYWithShift(int y, int shiftEveryStep): Use this if your layout involves a consistent shift (e.g., spacing or padding) between rows.
• getColumnByXWithShift(int x, int shiftEveryStep): Use this if your layout involves a consistent shift between columns.

The AdaptiveTableManager is used to manage the dimensions (heights and widths) of rows and columns in an adaptive table.

Workflow:

1. Create an instance of AdaptiveTableManager.
2. Initialize it with the total number of rows and columns using init(int rowCount, int columnCount).
3. Define dimensions for specific rows and columns using putRowHeight(int row, int height) and putColumnWidth(int column, int width).
4. Call invalidate() to recalculate the total width and height of the table.

Note: If the total number of rows, columns, or the overall table width changes, you must re-run the initialization steps (steps 2 through 4).

To use the library in your code, find the view, initialize your adapter (e.g., a LinkedAdaptiveTableAdapter), set listeners, and attach it to the layout.

mTableLayout = (AdaptiveTableLayout) view.findViewById(R.id.tableLayout);
...
mTableAdapter = new SampleLinkedTableAdapter(getContext(), mCsvFileDataSource);
mTableAdapter.setOnItemClickListener(...);
mTableAdapter.setOnItemLongClickListener(...);
mTableLayout.setAdapter(mTableAdapter);
...
mTableLayout.setHeaderFixed(true);
mTableLayout.setSolidRowHeader(true);
mTableAdapter.notifyDataSetChanged();

You can define the table layout in your XML files using the com.cleveroad.adaptivetablelayout.AdaptiveTableLayout tag. Use the following attributes to control the table behavior:

• app:cellMargin: The margin between cells (e.g., 1dp).
• app:fixedHeaders: If true, headers will always be displayed in the corners.
• app:solidRowHeaders: If true, the row header will change its position when dragging a row.
• app:dragAndDropEnabled: If true, users can change column or row positions by long-pressing a header.

<com.cleveroad.adaptivetablelayout.AdaptiveTableLayout
        android:id="@+id/tableLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent"      
        app:cellMargin="1dp"
        app:fixedHeaders="true"
        app:solidRowHeaders="true"
        app:dragAndDropEnabled="true"/>

Use AdaptiveTableLayoutSettings to customize the appearance and behavior of the table layout. The class uses a builder-like pattern for most configuration methods, allowing you to chain calls to set dimensions, margins, and interaction modes.

Available configuration options:

• setLayoutWidth(int): Sets the layout width.
• setLayoutHeight(int): Sets the layout height.
• setHeaderFixed(boolean): If true, the header remains fixed during scrolling.
• setCellMargin(int): Sets the margin between cells.
• setSolidRowHeader(boolean):
  • If true: The row header is fixed to the data (the value of the row header is tied to the data).
  • If false: The row header is fixed to the row number (fixed to the index from 0 to n).
• setDragAndDropEnabled(boolean): If true, enables editing via drag and drop; otherwise, editing is disabled.

To change the visual order of rows or columns, use the following methods on your LinkedAdaptiveTableAdapter instance:

• changeColumns(int columnIndex, int columnToIndex): Swaps the visual position of a column.
• changeRows(int rowIndex, int rowToIndex, boolean solidRowHeader): Swaps the visual position of a row and allows you to set whether the row header is fixed to the data or the row number.

Note: The implementation internally handles the mapping so that your underlying data remains untouched.