/// <summary>
/// Draw a table from the columns' settings, the path for the corresponding properties and a selector function
/// that takes a SerializedProperty and returns the TableCell to put in the corresponding cell.
/// </summary>
/// <returns>The updated table state.</returns>
/// <param name="rect">The table's containing rectangle.</param>
/// <param name="tableState">The Table state.</param>
/// <param name="collectionProperty">The serialized property of the collection.</param>
/// <param name="columns">The Selector Columns.</param>
/// <param name="options">The table options.</param>
public static GUITableState DrawTable(
Rect rect,
GUITableState tableState,
SerializedProperty collectionProperty,
List <SelectorColumn> columns,
params GUITableOption[] options)
{
GUITableEntry tableEntry = new GUITableEntry(options);
List <List <TableCell> > rows = new List <List <TableCell> >();
for (int i = 0; i < collectionProperty.arraySize; i++)
{
SerializedProperty sp = collectionProperty.FindPropertyRelative(SerializationHelpers.GetElementAtIndexRelativePath(i));
if (tableEntry.filter != null && !tableEntry.filter(sp))
{
continue;
}
List <TableCell> row = new List <TableCell>();
foreach (SelectorColumn col in columns)
{
row.Add(col.GetCell(sp));
}
rows.Add(row);
}
return(DrawTable(rect, tableState, columns.Select((col) => (TableColumn)col).ToList(), rows, collectionProperty, options));
}
/// <summary>
/// Draw a table completely manually.
/// Each cell has to be created and given as parameter in cells.
/// </summary>
/// <returns>The updated table state.</returns>
/// <param name="tableState">The Table state.</param>
/// <param name="columns">The Columns of the table.</param>
/// <param name="cells">The Cells as a list of rows.</param>
/// <param name="collectionProperty">The SerializeProperty of the collection. This is useful for reorderable tables.</param>
/// <param name="options">The table options.</param>
public static GUITableState DrawTable(
GUITableState tableState,
List <TableColumn> columns,
List <List <TableCell> > cells,
SerializedProperty collectionProperty,
params GUITableOption[] options)
{
GUITableEntry tableEntry = new GUITableEntry(options);
if (tableState == null)
{
tableState = new GUITableState();
tableState.CheckState(columns, tableEntry, float.MaxValue);
}
float requiredHeight = GUITable.TableHeight(tableEntry, cells.Count) + 10;
if (tableEntry.allowScrollView && tableState.totalWidth + 19 > Screen.width / EditorGUIUtility.pixelsPerPoint)
{
requiredHeight += EditorGUIUtility.singleLineHeight;
}
Rect position = GUILayoutUtility.GetRect(
tableEntry.allowScrollView ? Screen.width / EditorGUIUtility.pixelsPerPoint - 40 : tableState.totalWidth,
requiredHeight);
if (Event.current.type == EventType.Layout)
{
return(tableState);
}
else
{
return(GUITable.DrawTable(position, tableState, columns, cells, collectionProperty, options));
}
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
if (!IsFirstElementQuickCheck(property.propertyPath))
{
if (!IsCollectionQuickCheck(property.propertyPath))
{
return(EditorGUIUtility.singleLineHeight);
}
return(0);
}
string collectionPath, index;
if (!IsCollectionFullCheck(property.propertyPath, out index, out collectionPath))
{
return(EditorGUIUtility.singleLineHeight);
}
if (index != "0")
{
return(0);
}
GUITableEntry tableEntry = new GUITableEntry(tableOptions);
SerializedProperty collectionProperty = property.serializedObject.FindProperty(collectionPath);
return(collectionProperty.arraySize * (GUITable.RowHeight(tableEntry) - 2) + EditorGUIUtility.singleLineHeight + GUITable.HeadersHeight(tableEntry) + GUITable.ExtraHeight(tableEntry));
}
public void CheckState(List <TableColumn> columns, GUITableEntry tableEntry, float availableWidth)
{
if (columnSizes == null || columnSizes.Count < columns.Count)
{
columnSizes = columns.Select((column) => column.GetDefaultWidth()).ToList();
}
if (columnVisible == null || columnVisible.Count < columns.Count)
{
columnVisible = columns.Select((column) => column.entry.visibleByDefault).ToList();
}
if (totalWidth < availableWidth && !isBeingResized)
{
List <int> expandableColumns = new List <int> ();
for (int i = 0; i < columns.Count; i++)
{
if (columns[i].entry.expandWidth && columnSizes[i] < columns[i].entry.maxWidth)
{
expandableColumns.Add(i);
}
}
float addWidth = (availableWidth - totalWidth) / expandableColumns.Count;
foreach (int i in expandableColumns)
{
columnSizes[i] += addWidth;
}
}
for (int i = 0; i < columns.Count; i++)
{
columnSizes[i] = Mathf.Clamp(columnSizes[i], columns[i].entry.minWidth, columns[i].entry.maxWidth);
}
if (reorderableList != null)
{
reorderableList.draggable = sortByColumnIndex < 0;
}
}
public void CheckState(List <TableColumn> columns, GUITableEntry tableEntry, float availableWidth)
{
if (tableEntry.defaultColumnWidth > 0f)
{
columns.ForEach(c => { if (c.entry.defaultWidth == 0f)
{
c.entry.defaultWidth = tableEntry.defaultColumnWidth;
}
});
}
if (columnSizes == null || columnSizes.Count != columns.Count)
{
columnSizes = columns.Select((column) => column.GetDefaultWidth()).ToList();
}
if (columnVisible == null || columnVisible.Count != columns.Count)
{
columnVisible = columns.Select((column) => column.entry.visibleByDefault).ToList();
}
if (totalWidth < availableWidth && !isBeingResized)
{
List <int> expandableColumns = new List <int> ();
for (int i = 0; i < columns.Count; i++)
{
if (columns[i].entry.expandWidth && columnSizes[i] < columns[i].entry.maxWidth)
{
expandableColumns.Add(i);
}
}
float addWidth = (availableWidth - totalWidth) / expandableColumns.Count;
foreach (int i in expandableColumns)
{
columnSizes[i] += addWidth;
}
}
absoluteColumnSizes = columnSizes.Select((columnSize, i) =>
Mathf.Clamp(
columns[i].entry.relative ? columnSize * GUIHelpers.GetViewWidth() : columnSize,
columns[i].entry.minWidth,
columns[i].entry.maxWidth))
.ToList();
if (reorderableList != null)
{
reorderableList.draggable = sortByColumnIndex < 0;
}
}
public static float TableHeight(GUITableEntry tableEntry, int nbRows)
{
return((tableEntry.rowHeight + (tableEntry.reorderable ? 5 : 0)) * Mathf.Max(1, nbRows)
+ EditorGUIUtility.singleLineHeight * (tableEntry.reorderable ? 2 : 1));
}
/// <summary>
/// Draw a table completely manually.
/// Each cell has to be created and given as parameter in cells.
/// </summary>
/// <returns>The updated table state.</returns>
/// <param name="rect">The table's containing rectangle.</param>
/// <param name="tableState">The Table state.</param>
/// <param name="columns">The Columns of the table.</param>
/// <param name="cells">The Cells as a list of rows.</param>
/// <param name="collectionProperty">The SerializeProperty of the collection. This is useful for reorderable tables.</param>
/// <param name="options">The table options.</param>
public static GUITableState DrawTable(
Rect rect,
GUITableState tableState,
List <TableColumn> columns,
List <List <TableCell> > cells,
SerializedProperty collectionProperty,
params GUITableOption[] options)
{
GUITableEntry tableEntry = new GUITableEntry(options);
if (tableState == null)
{
tableState = new GUITableState();
}
if (tableEntry.reorderable)
{
if (collectionProperty == null)
{
Debug.LogError("The collection's serialized property is needed to draw a reorderable table.");
return(tableState);
}
staticCells = cells;
if (tableState.reorderableList == null)
{
ReorderableList list = new ReorderableList(
collectionProperty.serializedObject,
collectionProperty,
true, true, true, true);
list.drawElementCallback = (Rect r, int index, bool isActive, bool isFocused) => {
DrawLine(tableState, columns, orderedRows[index], r.xMin + (list.draggable ? 0 : 14), r.yMin, tableEntry.rowHeight);
};
list.elementHeight = tableEntry.rowHeight;
list.drawHeaderCallback = (Rect r) => {
DrawHeaders(r, tableState, columns, r.xMin + 12, r.yMin);
};
list.onRemoveCallback = (l) =>
{
l.serializedProperty.DeleteArrayElementAtIndex(staticCells.IndexOf(orderedRows[l.index]));
};
tableState.SetReorderableList(list);
}
}
tableState.CheckState(columns, tableEntry, rect.width);
orderedRows = cells;
if (tableState.sortByColumnIndex >= 0)
{
if (tableState.sortIncreasing)
{
orderedRows = cells.OrderBy(row => row [tableState.sortByColumnIndex]).ToList();
}
else
{
orderedRows = cells.OrderByDescending(row => row [tableState.sortByColumnIndex]).ToList();
}
}
if (tableEntry.reorderable)
{
tableState.reorderableList.DoList(new Rect(rect.x, rect.y, tableState.totalWidth + 23f, rect.height));
collectionProperty.serializedObject.ApplyModifiedProperties();
return(tableState);
}
float rowHeight = tableEntry.rowHeight;
float currentX = rect.x;
float currentY = rect.y + 5;
bool displayScrollView = tableState.totalWidth > rect.width && tableEntry.allowScrollView;
tableState.RightClickMenu(columns, rect);
DrawHeaders(rect, tableState, columns, currentX - tableState.scrollPos.x, currentY);
GUI.enabled = true;
currentY += EditorGUIUtility.singleLineHeight;
if (tableEntry.allowScrollView)
{
tableState.scrollPos = GUI.BeginScrollView(
new Rect(currentX, currentY, rect.width, TableHeight(tableEntry, cells.Count)),
tableState.scrollPos,
new Rect(0f, 0f, tableState.totalWidth, tableEntry.rowHeight * cells.Count));
currentX = 0f;
currentY = 0f;
}
if (orderedRows.Count == 0)
{
currentX = tableEntry.allowScrollView ? 0 : rect.x;
GUIHelpers.DrawRect(new Rect(currentX, currentY, tableState.totalWidth, rowHeight), TABLE_BG_COLOR);
GUI.Label(new Rect(currentX + 5, currentY, rect.width, rowHeight), "Collection is empty");
}
else
{
foreach (List <TableCell> row in orderedRows)
{
currentX = tableEntry.allowScrollView ? 0 : rect.x;
DrawLine(tableState, columns, row, currentX, currentY, rowHeight);
currentY += rowHeight;
}
}
GUI.enabled = true;
if (tableEntry.allowScrollView)
{
GUI.EndScrollView();
}
tableState.Save();
return(tableState);
}
public static float ExtraHeight(GUITableEntry tableEntry)
{
return(tableEntry.reorderable ? EditorGUIUtility.singleLineHeight : 0f);
}
public static float RowHeight(GUITableEntry tableEntry)
{
return(tableEntry.rowHeight + (tableEntry.reorderable ? 5 : 0));
}
public static float RowsHeight(GUITableEntry tableEntry, int nbRows)
{
return(RowHeight(tableEntry) * Mathf.Max(1, nbRows));
}
public static float HeadersHeight(GUITableEntry tableEntry)
{
return(tableEntry.rotateHeaders ? 70f : EditorGUIUtility.singleLineHeight);
}
public static float TableHeight(GUITableEntry tableEntry, int nbRows)
{
return(HeadersHeight(tableEntry) + RowsHeight(tableEntry, nbRows) + ExtraHeight(tableEntry));
}
