Table Overview: Add state, plan changed and empty table liste

java/bundles/org.eclipse.set.feature.table/OSGI-INF/l10n/bundle.properties

@@ -18,6 +18,9 @@ TableOverviewPart_OpenAllWithErrors=Alle öffnen
 TableOverviewPart_CalculateMissingTask=Überprüfe Tabellen...
 TableOverviewPart_DebugModeHint=Debug-Mode: Tabellen können immer wieder neu überprüft werden
 TableOverviewPart_NonTransformableTable=Nicht generierbar:
+TableOverviewPart_WithStateChanges=Enthalten Rot-/Gelb-Einträge:
+TableOverviewPart_WithPlanChanges=Enthalten besondere Änderungsmarkierungen:
+TableOverviewPart_EmptyTable=Leere Tabellen:
 
 TableErrorTableColumns_Index=Lfd. Nr.
 TableErrorTableColumns_LeadingObject=Führendes Objekt

java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/ToolboxTableView.java

@@ -98,6 +98,7 @@
 import org.eclipse.set.services.export.TableCompileService;
 import org.eclipse.set.services.table.TableService;
 import org.eclipse.set.services.table.TableService.TableRendererUtil;
+import org.eclipse.set.services.table.TableStatus;
 import org.eclipse.set.utils.BasePart;
 import org.eclipse.set.utils.RefreshAction;
 import org.eclipse.set.utils.SelectableAction;
@@ -193,7 +194,7 @@ public class ToolboxTableView extends BasePart {
 
 	private TableModelInstanceBodyDataProvider bodyDataProvider;
 
-	private EventHandler secondaryPlanningLoadedHanlder;
+	private EventHandler secondaryPlanningLoadedHandler;
 	protected TableInfo tableInfo;
 
 	/**
@@ -307,9 +308,9 @@ public void accept(final SelectedControlAreaChangedEvent t) {
 				SelectedControlAreaChangedEvent.class,
 				selectionControlAreaHandler);
 
-		secondaryPlanningLoadedHanlder = this::comparePlaningLoadedHandler;
+		secondaryPlanningLoadedHandler = this::comparePlaningLoadedHandler;
 		getBroker().subscribe(Events.COMPARE_MODEL_LOADED,
-				secondaryPlanningLoadedHanlder);
+				secondaryPlanningLoadedHandler);
 	}
 
 	protected void comparePlaningLoadedHandler(final Event event) {
@@ -327,7 +328,7 @@ protected void preDestroy() {
 		ToolboxEvents.unsubscribe(getBroker(), tableSelectRowHandler);
 		ToolboxEvents.unsubscribe(getBroker(), tableDataChangeHandler);
 		ToolboxEvents.unsubscribe(getBroker(), selectionControlAreaHandler);
-		getBroker().unsubscribe(secondaryPlanningLoadedHanlder);
+		getBroker().unsubscribe(secondaryPlanningLoadedHandler);
 		getBroker().send(Events.CLOSE_PART, extractShortcut());
 	}
 
@@ -362,7 +363,7 @@ protected Table transformToTableModel() {
 
 	private void updateTableView(final List<Pt1TableCategory> tableCategories) {
 		tableService.updateTable(this, tableCategories, new TableRendererUtil(
-				() -> transformToTableModel(), transformedTable -> {
+				this::transformToTableModel, transformedTable -> {
 					if (transformedTable == null) {
 						return;
 					}
@@ -402,8 +403,10 @@ protected void createView(final Composite parent) {
 			return;
 		}
 		subcribeTriggerResortEvent();
-		if (tableService.getNonTransformableTables(tableInfo.category())
-				.contains(tableInfo)) {
+		final TableStatus status = tableService
+				.getTablesStatus(tableInfo.category())
+				.getOrDefault(tableInfo, null);
+		if (status == null || status.isNonTransformable()) {
 			getDialogService().error(getToolboxShell(),
 					messages.TableTransform_Error_Msg);
 		}

java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceContextFunction.java

@@ -202,10 +202,14 @@ public void handleEvent(final Event event) {
 					.getCacheService()
 					.getCache(schnitstelle,
 							ToolboxConstants.CacheId.DIRECTED_EDGE_TO_SUBPATH));
-			if (event.getTopic().equals(Events.MODEL_CHANGED)
-					&& tableService != null) {
-				tableService.clearInstance();
-			}
+		}
+
+		if (tableService == null) {
+			return;
+		}
+
+		if (event.getTopic().equals(Events.MODEL_CHANGED)) {
+			tableService.clearInstance();
 		}
 
 		if (event.getTopic().equals(Events.CLOSE_SESSION)
@@ -222,17 +226,16 @@ public void handleEvent(final Event event) {
 		if (event.getTopic().equals(TableDataChangeEvent.TOPIC)
 				&& tableService != null) {
 			final Object data = event.getProperty(IEventBroker.DATA);
-			if (data instanceof final TableDataChangeEvent changedEvent) {
-				if (!changedEvent.getProperties().isEmpty() && changedEvent
-						.getProperties()
-						.getFirst() instanceof Pt1TableChangeProperties) {
-					tableService.addChangedTableData(
-							changedEvent.getTableShortcut(),
-							changedEvent.getProperties()
-									.stream()
-									.map(Pt1TableChangeProperties.class::cast)
-									.toList());
-				}
+			if (data instanceof final TableDataChangeEvent changedEvent
+					&& !changedEvent.getProperties().isEmpty()
+					&& changedEvent.getProperties()
+							.getFirst() instanceof Pt1TableChangeProperties) {
+				tableService.addChangedTableData(
+						changedEvent.getTableShortcut(),
+						changedEvent.getProperties()
+								.stream()
+								.map(Pt1TableChangeProperties.class::cast)
+								.toList());
 			}
 
 		}

java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceImpl.java

@@ -16,10 +16,10 @@
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Queue;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -57,6 +57,8 @@
 import org.eclipse.set.feature.table.PlanPro2TableTransformationService;
 import org.eclipse.set.feature.table.messages.Messages;
 import org.eclipse.set.model.tablemodel.ColumnDescriptor;
+import org.eclipse.set.model.tablemodel.CompareStateCellContent;
+import org.eclipse.set.model.tablemodel.CompareTableCellContent;
 import org.eclipse.set.model.tablemodel.Footnote;
 import org.eclipse.set.model.tablemodel.RowGroup;
 import org.eclipse.set.model.tablemodel.Table;
@@ -72,6 +74,7 @@
 import org.eclipse.set.services.table.TableDiffService;
 import org.eclipse.set.services.table.TableDiffService.TableCompareType;
 import org.eclipse.set.services.table.TableService;
+import org.eclipse.set.services.table.TableStatus;
 import org.eclipse.set.utils.BasePart;
 import org.eclipse.set.utils.ToolboxConfiguration;
 import org.eclipse.set.utils.table.Pt1TableChangeProperties;
@@ -135,9 +138,8 @@ public final class TableServiceImpl implements TableService {
 	private final Map<TableCompareType, TableDiffService> diffServiceMap = new ConcurrentHashMap<>();
 	private static final Queue<Pair<BasePart, TableRendererUtil>> transformTableThreads = new LinkedList<>();
 	private final Map<String, Set<Footnote>> footnotesPerTable = new ConcurrentHashMap<>();
-	private static final Set<TableInfo> nonTransformableTables = new HashSet<>();
-
 	private static final Map<TableInfo, List<Pt1TableChangeProperties>> tableChangedData = new ConcurrentHashMap<>();
+	private static final Map<TableInfo, TableStatus> tablesStatus = new HashMap<>();
 
 	private CacheService getCacheService() {
 		return ToolboxConfiguration.isDebugMode() ? Services.getNoCacheService()
@@ -261,8 +263,8 @@ public TableNameInfo getTableNameInfo(final TableInfo tableInfo) {
 	public Collection<TableInfo> getAvailableTables() {
 		return modelServiceMap.keySet()
 				.stream()
-				.filter(tableInfo -> !nonTransformableTables
-						.contains(tableInfo))
+				.filter(tableInfo -> tablesStatus.get(tableInfo) == null
+						|| !tablesStatus.get(tableInfo).isNonTransformable())
 				.toList();
 	}
 
@@ -303,7 +305,17 @@ private void saveTableError(final TableInfo tableInfo,
 			final Collection<TableError> errors) {
 		final String shortName = getTableNameInfo(tableInfo).getShortName();
 		final String shortCut = tableInfo.shortcut();
+
 		errors.forEach(error -> error.setSource(shortName));
+
+		// Only considered table in main session
+		if (modelSession.getToolboxFile()
+				.getRole() == ToolboxFileRole.SESSION) {
+			final TableStatus tableStatus = tablesStatus
+					.computeIfAbsent(tableInfo, k -> new TableStatus());
+			tableStatus.setContainsErrors(!errors.isEmpty());
+		}
+
 		getCacheService()
 				.getCache(modelSession.getPlanProSchnittstelle(),
 						ToolboxConstants.CacheId.TABLE_ERRORS)
@@ -428,6 +440,7 @@ public Table transformToTable(final TableInfo tableInfo,
 		if (!(table instanceof Table)) {
 			return null;
 		}
+
 		if (tableType != TableType.DIFF && !controlAreaIds.isEmpty()
 				&& controlAreaIds.stream()
 						.noneMatch(area -> isContainerContainArea(
@@ -446,6 +459,14 @@ public Table transformToTable(final TableInfo tableInfo,
 						getModelService(tableInfo), controlAreaIds);
 		TableServiceUtils.clearEmptyRow(resultTable);
 		getModelService(tableInfo).addAdditionRow(stateTable, resultTable);
+		if (modelSession.getToolboxFile()
+				.getRole() == ToolboxFileRole.SESSION) {
+			final TableStatus status = tablesStatus.computeIfAbsent(tableInfo,
+					k -> new TableStatus());
+			status.setContainsStateChanged(
+					TableServiceUtils.isTableExistChangedCompareContent(
+							resultTable, CompareStateCellContent.class));
+		}
 		sortTable(resultTable, tableInfo, tableType);
 		return resultTable;
 	}
@@ -656,14 +677,12 @@ public Map<TableInfo, Table> transformTables(final IProgressMonitor monitor,
 			try {
 				final TableNameInfo nameInfo = getTableNameInfo(tableInfo);
 				monitor.subTask(nameInfo.getFullDisplayName());
-				final Table table = transformToTable(tableInfo, tableType,
-						sessionService.getLoadedSession(
-								ToolboxFileRole.SESSION),
+
+				final Table table = createDiffTable(tableInfo, tableType,
 						controlAreaIds);
 				while (!TableService.isTransformComplete(tableInfo, null)) {
 					Thread.sleep(2000);
 				}
-				storageFootnotes(ToolboxFileRole.SESSION, tableInfo, table);
 				result.put(tableInfo, table);
 				monitor.worked(1);
 			} catch (final Exception e) {
@@ -678,6 +697,9 @@ public Map<TableInfo, Table> transformTables(final IProgressMonitor monitor,
 	public Table createDiffTable(final TableInfo tableInfo,
 			final TableType tableType, final Set<String> controlAreaIds) {
 		Table mainSessionTable = null;
+		final TableStatus tableStatus = tablesStatus.computeIfAbsent(tableInfo,
+				k -> new TableStatus());
+		tableStatus.reset();
 		try {
 			mainSessionTable = transformToTable(tableInfo, tableType,
 					sessionService.getLoadedSession(ToolboxFileRole.SESSION),
@@ -686,6 +708,8 @@ public Table createDiffTable(final TableInfo tableInfo,
 					mainSessionTable);
 			if (sessionService.getLoadedSession(
 					ToolboxFileRole.COMPARE_PLANNING) == null) {
+				tableStatus.setEmpty(
+						TableExtensions.isTableEmpty(mainSessionTable));
 				return mainSessionTable;
 			}
 			// Waiting table compare transform, then create compare table
@@ -696,10 +720,12 @@ public Table createDiffTable(final TableInfo tableInfo,
 		} catch (final Exception e) {
 			logger.error("Transformation Error: {} : {}", //$NON-NLS-1$
 					tableInfo.shortcut(), e.getMessage());
-			nonTransformableTables.add(tableInfo);
+			tableStatus.setNonTransformable(true);
 			broker.post(Events.TABLEERROR_CHANGED, null);
 			// Give empty table back
 			return createEmptyTable(tableInfo);
+		} finally {
+			broker.post(Events.TABLEERROR_CHANGED, null);
 		}
 
 		if (mainSessionTable == null) {
@@ -718,13 +744,20 @@ public Table createDiffTable(final TableInfo tableInfo,
 					.get(TableCompareType.PROJECT)
 					.createDiffTable(mainSessionTable, compareSessionTable);
 			sortTable(compareTable, tableInfo, tableType);
-
+			tableStatus.setContainsPlanChanged(
+					TableServiceUtils.isTableExistChangedCompareContent(
+							compareTable, CompareTableCellContent.class));
+			tableStatus.setEmpty(TableExtensions.isTableEmpty(compareTable));
 			return compareTable;
 		} catch (final Exception e) {
 			dialogService.error(Display.getCurrent().getActiveShell(),
 					messages.TableTransform_Error,
 					messages.TableTransform_ComparePlanError_Msg, e);
+			tableStatus
+					.setEmpty(TableExtensions.isTableEmpty(mainSessionTable));
 			return mainSessionTable;
+		} finally {
+			broker.post(Events.TABLEERROR_CHANGED, null);
 		}
 	}
 
@@ -748,20 +781,23 @@ public TableRowGroupComparator getRowGroupComparator(
 	}
 
 	@Override
-	public Set<TableInfo> getNonTransformableTables(
+	public Map<TableInfo, TableStatus> getTablesStatus(
 			final Pt1TableCategory tableCategory) {
-		return nonTransformableTables.stream()
-				.filter(info -> info.category().equals(tableCategory))
-				.collect(Collectors.toSet());
+		return tablesStatus.entrySet()
+				.stream()
+				.filter(entry -> entry.getKey()
+						.category()
+						.equals(tableCategory))
+				.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
 	}
 
 	void clearInstance() {
 		transformTableThreads.clear();
-		nonTransformableTables.clear();
 		footnotesPerTable.clear();
 		modelServiceMap.values()
 				.forEach(transformService -> transformService.getTableErrors()
 						.clear());
+		tablesStatus.clear();
 	}
 
 	@Override

java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java

@@ -20,7 +20,6 @@
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Optional;
@@ -50,6 +49,7 @@
 import org.eclipse.set.model.tablemodel.CompareFootnoteContainer;
 import org.eclipse.set.model.tablemodel.CompareStateCellContent;
 import org.eclipse.set.model.tablemodel.CompareTableCellContent;
+import org.eclipse.set.model.tablemodel.PlanCompareRow;
 import org.eclipse.set.model.tablemodel.RowGroup;
 import org.eclipse.set.model.tablemodel.SimpleFootnoteContainer;
 import org.eclipse.set.model.tablemodel.StringCellContent;
@@ -195,8 +195,7 @@ public static Collection<TableInfo> getMissingTables(
 			final TableService tableService, final IModelSession modelSession,
 			final Set<String> controlAreaIds,
 			final Pt1TableCategory tableCategory) {
-		final Map<TableInfo, Collection<TableError>> computedErrors = tableService
-				.getTableErrors(modelSession, controlAreaIds, tableCategory);
+
 		final Collection<TableInfo> allTableInfos = tableService
 				.getAvailableTables()
 				.stream()
@@ -209,8 +208,10 @@ public static Collection<TableInfo> getMissingTables(
 		if (!ToolboxConfiguration.isDebugMode()) {
 			// in debug mode we want to be able to recompute the errors
 			// that's why we mark all as missing
-			missingTables
-					.removeIf(info -> computedErrors.keySet().contains(info));
+			missingTables.removeIf(
+					info -> tableService.getTablesStatus(tableCategory)
+							.keySet()
+							.contains(info));
 		}
 		return missingTables;
 	}
@@ -716,4 +717,31 @@ private static boolean equalsValues(final List<String> oldValues,
 				&& oldValues.stream().allMatch(newValues::contains);
 	}
 
+	/**
+	 * @param table
+	 *            the table
+	 * @param cellContentClass
+	 *            the compare cell content class {@link CompareStateCellContent}
+	 *            or {@link CompareTableCellContent}
+	 * @return true, if exist compare cell
+	 */
+	public static boolean isTableExistChangedCompareContent(final Table table,
+			final Class<? extends CellContent> cellContentClass) {
+		if (cellContentClass != CompareTableCellContent.class
+				&& cellContentClass != CompareStateCellContent.class) {
+			throw new IllegalArgumentException(
+					"CellContent isn't CompareCellContent"); //$NON-NLS-1$
+		}
+		final List<TableRow> tableRows = TableExtensions.getTableRows(table);
+		if (cellContentClass == CompareTableCellContent.class
+				&& tableRows.stream()
+						.anyMatch(PlanCompareRow.class::isInstance)) {
+			return true;
+		}
+		return tableRows.stream()
+				.flatMap(row -> row.getCells().stream())
+				.filter(Objects::nonNull)
+				.anyMatch(cell -> cell.getContent() != null
+						&& cellContentClass.isInstance(cell.getContent()));
+	}
 }