Wrap viewer in CheckboxTablePart within a FilteredTable

By using the FilteredTable, we get a quick-filter for all extending
parts for free. This includes:

- The Cross-platform page of the "Deployable features" export wizard.
- The Update Java Classpath page of the "Update classpath..." action
- The Template Selection page of the "Plug-in Project" page.

Together with the quick-filter comes a caching of the checked table
items. Those elements remain checked, even if currently hidden by the
filter and will be restored once they become visible again.

Author: ptziegler

ui/org.eclipse.pde.ui/.settings/.api_filters

@@ -120,6 +120,14 @@
             </message_arguments>
         </filter>
     </resource>
+    <resource path="src/org/eclipse/pde/internal/ui/shared/CachedCheckboxTableViewer.java" type="org.eclipse.pde.internal.ui.shared.CachedCheckboxTableViewer">
+        <filter comment="Extends CheckboxTableViewer to match CachedCheckboxTreeviewer" id="571473929">
+            <message_arguments>
+                <message_argument value="CheckboxTableViewer"/>
+                <message_argument value="CachedCheckboxTableViewer"/>
+            </message_arguments>
+        </filter>
+    </resource>
     <resource path="src/org/eclipse/pde/internal/ui/shared/target/EditTargetContainerPage.java" type="org.eclipse.pde.internal.ui.shared.target.EditTargetContainerPage">
         <filter id="640712815">
             <message_arguments>

ui/org.eclipse.pde.ui/META-INF/MANIFEST.MF

@@ -77,6 +77,7 @@ Require-Bundle:
  org.eclipse.pde.core;bundle-version="[3.17.200,4.0.0)";visibility:=reexport,
  org.eclipse.core.runtime;bundle-version="[3.29.0,4.0.0)",
  org.eclipse.e4.core.services;bundle-version="[2.4.200,3.0.0)",
+ org.eclipse.e4.ui.dialogs;bundle-version="[1.6.0,2.0.0)",
  org.eclipse.ui.ide;bundle-version="[3.21.200,4.0.0)",
  org.eclipse.ui.views;bundle-version="[3.12.100,4.0.0)",
  org.eclipse.jface.text;bundle-version="[3.24.200,4.0.0)",

ui/org.eclipse.pde.ui/src/org/eclipse/pde/internal/ui/parts/CheckboxTablePart.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- *  Copyright (c) 2000, 2018 IBM Corporation and others.
+ *  Copyright (c) 2000, 2025 IBM Corporation and others.
  *
  *  This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License 2.0
@@ -13,15 +13,17 @@
  *******************************************************************************/
 package org.eclipse.pde.internal.ui.parts;
 
-import org.eclipse.jface.viewers.CheckboxTableViewer;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.viewers.StructuredViewer;
+import org.eclipse.pde.internal.ui.shared.CachedCheckboxTableViewer;
+import org.eclipse.pde.internal.ui.shared.FilteredCheckboxTable;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.ui.forms.widgets.FormToolkit;
 
 public class CheckboxTablePart extends StructuredViewerPart {
+
 	public CheckboxTablePart(String[] buttonLabels) {
 		super(buttonLabels);
 	}
@@ -34,15 +36,16 @@ protected StructuredViewer createStructuredViewer(Composite parent, int style, F
 		} else {
 			style |= toolkit.getBorderStyle();
 		}
-		CheckboxTableViewer tableViewer = CheckboxTableViewer.newCheckList(parent, style);
+		FilteredCheckboxTable filteredTable = new FilteredCheckboxTable(parent, toolkit, style);
+		CachedCheckboxTableViewer tableViewer = filteredTable.getViewer();
 		tableViewer
 				.addSelectionChangedListener(e -> CheckboxTablePart.this.selectionChanged(e.getStructuredSelection()));
 		tableViewer.addCheckStateListener(event -> elementChecked(event.getElement(), event.getChecked()));
 		return tableViewer;
 	}
 
-	public CheckboxTableViewer getTableViewer() {
-		return (CheckboxTableViewer) getViewer();
+	public CachedCheckboxTableViewer getTableViewer() {
+		return (CachedCheckboxTableViewer) getViewer();
 	}
 
 	@Override

ui/org.eclipse.pde.ui/src/org/eclipse/pde/internal/ui/parts/WizardCheckboxTablePart.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- *  Copyright (c) 2000, 2015 IBM Corporation and others.
+ *  Copyright (c) 2000, 2025 IBM Corporation and others.
  *
  *  This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License 2.0
@@ -14,9 +14,11 @@
 package org.eclipse.pde.internal.ui.parts;
 
 import org.eclipse.jface.viewers.CheckboxTableViewer;
+import org.eclipse.jface.viewers.IStructuredContentProvider;
 import org.eclipse.jface.viewers.StructuredViewer;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.pde.internal.ui.PDEUIMessages;
+import org.eclipse.pde.internal.ui.shared.CachedCheckboxTableViewer;
 import org.eclipse.pde.internal.ui.util.SWTUtil;
 import org.eclipse.pde.internal.ui.wizards.ListUtil;
 import org.eclipse.swt.SWT;
@@ -33,7 +35,6 @@ public class WizardCheckboxTablePart extends CheckboxTablePart {
 	private int selectIndex = -1;
 	private int deselectIndex = -1;
 	private final String tableName;
-	private int counter;
 	private Label counterLabel;
 
 	/**
@@ -92,7 +93,7 @@ public Object[] getSelection() {
 	public void setSelection(Object[] selected) {
 		CheckboxTableViewer viewer = getTableViewer();
 		viewer.setCheckedElements(selected);
-		updateCounter(viewer.getCheckedElements().length);
+		updateCounterLabel();
 	}
 
 	public void createControl(Composite parent) {
@@ -105,7 +106,7 @@ public void createControl(Composite parent, int span) {
 		GridData gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING | GridData.HORIZONTAL_ALIGN_FILL);
 		gd.horizontalSpan = span;
 		counterLabel.setLayoutData(gd);
-		updateCounter(0);
+		updateCounterLabel();
 	}
 
 	public void createControl(Composite parent, int span, boolean multiselect) {
@@ -118,7 +119,7 @@ public void createControl(Composite parent, int span, boolean multiselect) {
 		GridData gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING | GridData.HORIZONTAL_ALIGN_FILL);
 		gd.horizontalSpan = span;
 		counterLabel.setLayoutData(gd);
-		updateCounter(0);
+		updateCounterLabel();
 	}
 
 	@Override
@@ -147,24 +148,19 @@ protected void createMainLabel(Composite parent, int span, FormToolkit toolkit)
 		label.setLayoutData(gd);
 	}
 
-	protected void updateCounter(int amount) {
-		counter = amount;
-		updateCounterLabel();
-	}
-
-	public void updateCount(int amount) {
-		updateCounter(amount);
-	}
-
-	protected void updateCounterLabel() {
+	public void updateCounterLabel() {
 		String number = "" + getSelectionCount(); //$NON-NLS-1$
 		String totalNumber = "" + getTotalCount(); //$NON-NLS-1$
 		String message = NLS.bind(PDEUIMessages.WizardCheckboxTablePart_counter, (new String[] {number, totalNumber}));
 		counterLabel.setText(message);
 	}
 
 	public int getSelectionCount() {
-		return counter;
+		CachedCheckboxTableViewer viewer = getTableViewer();
+		if (viewer == null) {
+			return 0;
+		}
+		return viewer.getUnfilteredCheckedCount();
 	}
 
 	public void selectAll(boolean select) {
@@ -173,19 +169,21 @@ public void selectAll(boolean select) {
 
 	private int getTotalCount() {
 		CheckboxTableViewer viewer = getTableViewer();
-		return viewer.getTable().getItemCount();
+		if (viewer == null) {
+			return 0;
+		}
+
+		IStructuredContentProvider contentProvider = (IStructuredContentProvider) viewer.getContentProvider();
+		if (contentProvider == null) {
+			return 0;
+		}
+		return contentProvider.getElements(viewer.getInput()).length;
 	}
 
 	protected void handleSelectAll(boolean select) {
 		CheckboxTableViewer viewer = getTableViewer();
 		viewer.setAllChecked(select);
-		int selected;
-		if (!select) {
-			selected = 0;
-		} else {
-			selected = getTotalCount();
-		}
-		updateCounter(selected);
+		updateCounterLabel();
 	}
 
 	protected void handleSelect(boolean select) {
@@ -195,14 +193,13 @@ protected void handleSelect(boolean select) {
 			for (TableItem selectedItem : selected) {
 				selectedItem.setChecked(select);
 			}
-			updateCounter(viewer.getCheckedElements().length);
+			updateCounterLabel();
 		}
 	}
 
 	@Override
 	protected void elementChecked(Object element, boolean checked) {
-		int count = getSelectionCount();
-		updateCounter(checked ? count + 1 : count - 1);
+		updateCounterLabel();
 	}
 
 	public Label getCounterLabel() {

ui/org.eclipse.pde.ui/src/org/eclipse/pde/internal/ui/shared/CachedCheckboxTableViewer.java

@@ -0,0 +1,156 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Patrick Ziegler and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Patrick Ziegler - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.pde.internal.ui.shared;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.eclipse.jface.viewers.CheckboxTableViewer;
+import org.eclipse.jface.viewers.CheckboxTreeViewer;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.Tree;
+
+/**
+ * Counterpart of the {@link CachedCheckboxTreeViewer} which is specialized for
+ * use with {@link FilteredCheckboxTable}. This viewer caches the check state of
+ * the table items. When a filter is applied the cache stores which nodes are
+ * checked. When a filter is removed the viewer can be told to restore check
+ * state from the cache.
+ * <p>
+ * Note: If duplicate items are added to the table the cache will treat them as
+ * a single entry.
+ * </p>
+ */
+public class CachedCheckboxTableViewer extends CheckboxTableViewer {
+
+	private Set<Object> checkState = new HashSet<>();
+	private static final Object[] NO_ELEMENTS = new Object[0];
+
+	/**
+	 * Constructor for ContainerCheckedTreeViewer.
+	 * @see CheckboxTreeViewer#CheckboxTreeViewer(Tree)
+	 */
+	protected CachedCheckboxTableViewer(Table table) {
+		super(table);
+		addCheckStateListener(event -> updateCheckState(event.getElement(), event.getChecked()));
+		setUseHashlookup(true);
+	}
+
+	protected void updateCheckState(Object element, boolean state) {
+		if (state) {
+			checkState.add(element);
+		} else {
+			checkState.remove(element);
+		}
+	}
+
+	/**
+	 * Restores the checked state of items based on the cached check state.No
+	 * events will be fired.
+	 */
+	public void restoreCachedState() {
+		getTable().setRedraw(false);
+		// Call the super class so we don't mess up the cache
+		super.setCheckedElements(NO_ELEMENTS);
+		setGrayedElements(NO_ELEMENTS);
+		// Now we are only going to set the check state of the leaf nodes
+		// and rely on our container checked code to update the parents properly.
+		super.setCheckedElements(checkState.toArray());
+		getTable().setRedraw(true);
+	}
+
+	@Override
+	protected void preservingSelection(Runnable updateCode) {
+		super.preservingSelection(updateCode);
+		// The super class implementation will preserve a root element's check
+		// mark but that can cause newly unfiltered children to become check
+		// marked.
+		// See https://github.com/eclipse-pde/eclipse.pde/issues/62
+		restoreCachedState();
+	}
+
+	/**
+	 * Returns the contents of the cached check state.  The contents will be all
+	 * checked leaf nodes ignoring any filters.
+	 *
+	 * @return checked leaf elements
+	 */
+	public Object[] getUnfilteredCheckedElements() {
+		return checkState.toArray(Object[]::new);
+	}
+
+	/**
+	 * Returns the number of checked nodes. This method uses its internal check
+	 * state cache to determine what has been checked, not what is visible in
+	 * the viewer. The cache does not count duplicate items in the table.
+	 *
+	 * @return number of elements checked according to the cached check state
+	 */
+	public int getUnfilteredCheckedCount() {
+		return checkState.size();
+	}
+
+	/**
+	 * Returns whether {@code element} is checked. This method uses its internal
+	 * check state cache to determine what has been checked, not what is visible
+	 * in the viewer.
+	 */
+	public boolean isCheckedElement(Object element) {
+		return checkState.contains(element);
+	}
+
+	@Override
+	public boolean setChecked(Object element, boolean state) {
+		updateCheckState(element, state);
+		return super.setChecked(element, state);
+	}
+
+	@Override
+	public void setCheckedElements(Object[] elements) {
+		checkState.clear();
+		Collections.addAll(checkState, elements);
+		super.setCheckedElements(elements);
+	}
+
+	@Override
+	public void setAllChecked(boolean state) {
+		super.setAllChecked(state);
+		if (state) {
+			// Find all visible children and check them
+			Object[] visible = getFilteredChildren(getRoot());
+			Collections.addAll(checkState, visible);
+		} else {
+			// Remove any item in the check state that is visible (passes the filters)
+			Object[] visible = filter(checkState.toArray());
+			for (Object visibleObject : visible) {
+				checkState.remove(visibleObject);
+			}
+		}
+	}
+
+	@Override
+	public void remove(Object[] elements) {
+		for (Object element : elements) {
+			updateCheckState(element, false);
+		}
+		super.remove(elements);
+	}
+
+	@Override
+	public void remove(Object element) {
+		updateCheckState(element, false);
+		super.remove(element);
+	}
+}