TreeItem getItemForDifference(TreeDifference difference) {
for (int i = difference.getPath().getSegmentCount() - 1; i >= 0; i--) {
Object segment = difference.getPath().getSegment(i);
TreeItem item = (TreeItem) findItem(ComparableProvider.getComparableTreeObject(segment));
// if item is null, check for a matching difference with
// element type of EmptyElement
if (item == null) {
if (difference.getMatchingDifference().getElement() instanceof EmptyElement) {
// if not found then locate the item for the empty element
item = (TreeItem) findItem(difference.getMatchingDifference().getElement());
}
}
if (item != null && !item.isDisposed()) {
TreeItem[] topItems = getTree().getItems();
for (TreeItem top : topItems) {
if (top == item) {
return item;
}
}
// else check for expanded state
if (item.getParentItem().getExpanded() && !item.getBounds().isEmpty()) {
return item;
}
}
}
return null;
}
/**
* Clear all sub items.
*
* @param item The item root.
*/
public void clear(TreeItem item) {
item.setData(null);
for (final TreeItem current : item.getItems()) {
clear(current);
}
item.dispose();
}
private void createWidgets() {
composite.setLayout(GridLayoutFactory.fillDefaults().create());
tree = new Tree(composite, SWT.NONE);
applySmallSize(tree);
tree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
composite.layout();
TreeItem item = new TreeItem(tree, SWT.NONE);
item.setText("Special street magic");
treeViewer = new TreeViewer(tree);
treeViewer.setLabelProvider(new FileLabelProvider());
treeViewer.setContentProvider(new FileContentProvider());
treeViewer.addFilter(
new ViewerFilter() {
@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
File file = (File) element;
return !isBogusFile(file.getName());
}
});
treeViewer.addPostSelectionChangedListener(
new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
IStructuredSelection selection = (IStructuredSelection) event.getSelection();
File file = (File) selection.getFirstElement();
if (file != null) if (!file.isDirectory()) callback.openFile(file);
}
});
}
/*
* Sets up in the GUI the subtree that stems from a block index
*/
private void setupBlockTree(
TreeItem topLevel,
Map<Integer, Map<Integer, List<TwoThreadInfo>>> warps,
int block,
String lowLevelLabel,
IProject project) {
final TreeItem blockTree = new TreeItem(topLevel, SWT.NONE);
blockTree.setText(Messages.BLOCK + block);
// sort the warps, as a map is not guaranteed to be sorted
final Set<Integer> keys = warps.keySet();
final int[] keysArray = new int[keys.size()];
final Iterator<Integer> iter = keys.iterator();
int j;
for (int i = 0; i < keysArray.length; i++) {
j = iter.next();
keysArray[i] = j;
}
Arrays.sort(keysArray);
// setup the each warp
for (final int warp : keysArray) {
setupWarpTree(blockTree, warps.get(warp), warp, lowLevelLabel, project);
}
}
// --------------------------------------------------------------------------------
private void drawItem(String parentFieldName, TreeItem parentItem, List data, boolean expand) {
for (int i = 0; i < data.size(); ++i) {
TreeItem newItem = new TreeItem(parentItem, SWT.NONE);
Object value = data.get(i);
newItem.setText(1, getClassName(value));
String fieldName = parentFieldName + "." + i;
if (fieldName.startsWith(".")) {
fieldName = fieldName.substring(1);
}
newItem.setData("fieldName", fieldName);
newItem.setData("value", value);
fieldNameTreeItemMap.put(fieldName, newItem);
if (value instanceof Map) {
newItem.setText("[" + i + "]");
newItem.setImage(mapImage);
drawItem(fieldName, newItem, (Map) value, expand);
} else if (value instanceof List) {
newItem.setText("[" + i + "]");
newItem.setImage(listImage);
drawItem(fieldName, newItem, (List) value, expand);
} else {
setItemInfo(newItem, "[" + i + "]", value);
}
if (expand) {
parentItem.setExpanded(expand);
newItem.setExpanded(expand);
}
}
}
/**
* Get the body of an ApexLog. If that fails, get the toString of an ApexLog.
*
* @param selectedTreeItem
* @param logId
* @return A string representation of an ApexLog
*/
public String tryToGetApexLog(TreeItem selectedTreeItem, String logId) {
if (Utils.isEmpty(forceProject) || Utils.isEmpty(selectedTreeItem) || Utils.isEmpty(logId))
return null;
// Do we already have the log body?
String apexLogBody = (String) selectedTreeItem.getData(TREEDATA_APEX_LOG_BODY);
if (Utils.isNotEmpty(apexLogBody)) {
return apexLogBody;
}
// Try to get the log body
apexLogBody = getApexLogBody(forceProject, logId);
if (Utils.isNotEmpty(apexLogBody)) {
// Save it for future uses
selectedTreeItem.setData(TREEDATA_APEX_LOG_BODY, apexLogBody);
return apexLogBody;
}
// There is no ApexLog body, so try to retrieve a saved ApexLog
ApexLog apexLog = (ApexLog) selectedTreeItem.getData(TREEDATA_APEX_LOG);
if (Utils.isNotEmpty(apexLog)) {
return apexLog.toString();
}
// Try to get the ApexLog object
apexLog = getApexLog(forceProject, logId);
selectedTreeItem.setData(TREEDATA_APEX_LOG, apexLog);
return (Utils.isNotEmpty(apexLog) ? apexLog.toString() : null);
}
@Override
public void start(String startMessage) {
if (ideaCommentTree == null) return;
TreeItem item = new TreeItem(ideaCommentTree, SWT.NONE);
item.setText(startMessage);
treeItems.push(item);
}
public Object getSelectedFromMainTree() {
TreeItem item = getSelectedItemFromMainTree();
if (item == null) {
return null;
}
return item.getData();
}
private void reanalyzeStackFileInfo() {
TreeItem item = getSelectedRootItemFromMainTree();
if (item == null) {
return;
}
StackFileInfo stackFileInfo = (StackFileInfo) item.getData();
if (stackFileInfo == null) {
return;
}
try {
ParserConfigReader reader =
new ParserConfigReader(stackFileInfo.getParserConfig().getConfigFilename());
ParserConfig config = reader.read();
StackParser.removeAllAnalyzedFile(stackFileInfo);
processStackFile(stackFileInfo, config, null, false, true);
} catch (RuntimeException ex) {
closeStackFileInfo();
throw ex;
}
item.removeAll();
item.setText(stackFileInfo.toTreeInfo());
addMainTreeSubItem(item, stackFileInfo.getStackAnalyzedInfoList());
item.setExpanded(true);
clearTable();
}
private void addRow(
TreeItem item,
List<String[]> rowData,
IXViewerLabelProvider labelProv,
List<XViewerColumn> showCols,
int level)
throws XViewerException {
List<String> cellData = new ArrayList<String>(showCols.size());
boolean firstCell = true;
for (XViewerColumn xCol : showCols) {
StringBuffer str = new StringBuffer();
if (firstCell) {
for (int y = 1; y < level; y++) {
str.append("__INSERT_TAB_HERE__"); // $NON-NLS-1$
}
firstCell = false;
}
str.append(labelProv.getColumnText(item.getData(), xColToColumnIndex.get(xCol)));
String html = HtmlUtil.textToHtml(str.toString());
html =
html.replaceAll(
"__INSERT_TAB_HERE__", " "); // $NON-NLS-1$ //$NON-NLS-2$
cellData.add(html);
}
rowData.add(cellData.toArray(new String[cellData.size()]));
if (item.getExpanded()) {
for (TreeItem i : item.getItems()) {
addRow(i, rowData, labelProv, showCols, level + 1);
}
}
}
private void fillTree(Composite parent) {
final HashMap<String, ExampleTab> exampleMap = new HashMap<String, ExampleTab>();
final BrowserNavigation navigation = RWT.getClient().getService(BrowserNavigation.class);
for (ExampleTab tab : createExampleTabs()) {
TreeItem item = new TreeItem(tree, SWT.NONE);
item.setText(tab.getName());
item.setData(tab);
tab.setData(item);
exampleMap.put(tab.getId(), tab);
}
tree.addListener(
SWT.Selection,
new Listener() {
public void handleEvent(Event event) {
ExampleTab tab = (ExampleTab) event.item.getData();
selectTab(tab);
navigation.pushState(tab.getId(), null);
}
});
navigation.addBrowserNavigationListener(
new BrowserNavigationListener() {
public void navigated(BrowserNavigationEvent event) {
ExampleTab tab = exampleMap.get(event.getState());
if (tab != null) {
tree.select((TreeItem) tab.getData());
tree.showSelection();
selectTab(tab);
}
}
});
selectTab((ExampleTab) tree.getItem(0).getData());
}
/**
* 刷新节点（供外部调用）
*
* @param explorerTreeView
* @param treeView
*/
public static void refreshNode(LFWExplorerTreeView explorerTreeView, Tree tree) {
TreeItem[] tis = tree.getSelection();
if (tis == null || tis.length == 0) return;
TreeItem ti = tis[0];
ti.removeAll();
explorerTreeView.refreshDirtoryTreeItem();
}
@Override
public boolean handleAltLeftClick(TreeColumn treeColumn, TreeItem treeItem) {
try {
if (treeItem.getData() instanceof Artifact) {
Artifact useArt = (Artifact) treeItem.getData();
if (useArt.isOfType(AtsArtifactTypes.Action)) {
if (ActionManager.getTeams(useArt).size() == 1) {
useArt = ActionManager.getFirstTeam(useArt);
} else {
return false;
}
}
if (!(useArt instanceof AbstractWorkflowArtifact)) {
return false;
}
AbstractWorkflowArtifact awa = (AbstractWorkflowArtifact) useArt;
boolean modified = promptChangeAssignees(Arrays.asList(awa), isPersistViewer());
XViewer xViewer = ((XViewerColumn) treeColumn.getData()).getTreeViewer();
if (modified && isPersistViewer(xViewer)) {
AtsChangeSet.execute("persist assignees via alt-left-click", awa);
}
if (modified) {
xViewer.update(awa, null);
return true;
}
}
} catch (OseeCoreException ex) {
OseeLog.log(Activator.class, OseeLevel.SEVERE_POPUP, ex);
}
return false;
}
/*
* Purpose - Handle events from the Listener interface
*/
@Override
public void handleEvent(Event event) {
switch (event.type) {
case SWT.Selection:
break;
case SWT.DefaultSelection:
// Double click of an item in a top level list
if (event.widget instanceof Table) {
// Table selection event
assert (event.item instanceof TableItem);
TableItem tableItem = (TableItem) event.item;
// Get object key from table
KeyFieldSet keyFieldSet = getKeyFromTableItem(tableItem);
// Have ApplicationController open object
applicationController.openObject(keyFieldSet);
} else if (event.widget instanceof Tree) {
// Tree selection event
assert (event.item instanceof TreeItem);
TreeItem treeItem = (TreeItem) event.item;
// Check if treeItem is a parent item
// If so does not contain object data, skip
if (treeItem.getItemCount() > 0) return;
// Get object key from table
KeyFieldSet keyFieldSet = getKeyFromTreeItem(treeItem);
// Have ApplicationController open object
applicationController.openObject(keyFieldSet);
}
break;
}
}
private static TreeItem retrieveTreeItem(final TreeItem[] items, IContextParameter param) {
if (items == null || param == null) {
return null;
}
for (TreeItem item : items) {
final Object data = item.getData();
if (data != null) {
if (data instanceof ContextVariableTabParentModel) {
ContextVariableTabParentModel parent = (ContextVariableTabParentModel) data;
if (parent.getContextParameter() != null
&& param.getName().equals(parent.getContextParameter().getName())) {
return item;
}
} else if (data instanceof ContextVariableTabChildModel) {
ContextVariableTabChildModel son = (ContextVariableTabChildModel) data;
if (son.getContextParameter() != null
&& param.getName().equals(son.getContextParameter().getName())) {
return item;
}
}
}
// search child item
TreeItem childItem = retrieveTreeItem(item.getItems(), param);
if (childItem != null) {
return childItem;
}
}
return null;
}
/**
* Update all the children TreeItems of the given parent to be the same check as the parent.
*
* @param parent the parent
*/
protected void updateChildCheckboxes(TreeItem parent) {
for (TreeItem child : parent.getItems()) {
child.setChecked(parent.getChecked());
child.setGrayed(false);
updateChildCheckboxes(child);
}
}
@Override
public void setSources(String... sources) {
TreeItem[] items = tree.getSelection();
if (items.length < 1) return;
TreeItem item = items[0];
if (lastSelectedItem == item) return;
if (lastSelectedItem != null && !lastSelectedItem.isDisposed()) {
lastSelectedItem.setBackground(new Color(getDisplay(), 255, 255, 255));
lastSelectedItem.setExpanded(false);
lastSelectedItem.removeAll();
}
lastSelectedItem = item;
lastSelectedItem.setBackground(new Color(getDisplay(), 190, 190, 255));
if (sources == null || sources.length < 1) return;
for (String source : sources) {
item = new TreeItem(lastSelectedItem, SWT.NONE);
item.setFont(UIDATA.FONT_9);
int idx = source.indexOf('.');
if (idx > -1) source = source.substring(idx + 1);
item.setText(source);
}
if (!lastSelectedItem.getExpanded()) lastSelectedItem.setExpanded(true);
}
/** Create contents of the dialog. */
private void createContents() {
this.shell = new Shell(this.getParent(), SWT.SHELL_TRIM | SWT.PRIMARY_MODAL);
this.shell.setSize(300, 275);
this.shell.setText("Columns");
this.shell.setLayout(new FillLayout(SWT.HORIZONTAL));
// ヘッダー
String[] header = this.dialog.getTableHeader();
// カラム設定を取得
boolean[] visibles =
AppConfig.get().getVisibleColumnMap().get(this.dialog.getClass().getName());
if ((visibles == null) || (visibles.length != header.length)) {
visibles = new boolean[header.length];
Arrays.fill(visibles, true);
AppConfig.get().getVisibleColumnMap().put(this.dialog.getClass().getName(), visibles);
}
Tree tree = new Tree(this.shell, SWT.BORDER | SWT.CHECK);
for (int i = 1; i < header.length; i++) {
TreeItem column = new TreeItem(tree, SWT.CHECK);
column.setText(header[i]);
column.setChecked(visibles[i]);
column.setExpanded(true);
}
this.shell.addShellListener(new TreeShellAdapter(tree, visibles, this.dialog));
}
/**
* Update the User Debug Log tab with a filtered log.
*
* @param selectedTreeItem
* @param log
*/
public void showUserLog(TreeItem selectedTreeItem, String log) {
if (Utils.isEmpty(selectedTreeItem) || Utils.isEmpty(runTestComposite)) {
return;
}
// Do we already have a filtered log?
String userDebugLog = (String) selectedTreeItem.getData(TREEDATA_APEX_LOG_USER_DEBUG);
if (Utils.isNotEmpty(userDebugLog)) {
runTestComposite.setUserLogsTextArea(userDebugLog);
return;
}
// Filter the given log with only DEBUG statements
if (Utils.isNotEmpty(log) && log.contains("DEBUG")) {
userDebugLog = "";
String[] newDateWithSperators = log.split("\\|");
for (int index = 0; index < newDateWithSperators.length; index++) {
String newDateWithSperator = newDateWithSperators[index];
if (newDateWithSperator.contains("USER_DEBUG")) {
String debugData = newDateWithSperators[index + 3];
debugData = debugData.substring(0, debugData.lastIndexOf('\n'));
userDebugLog += "\n" + debugData + "\n";
}
}
// Save it for future uses
selectedTreeItem.setData(TREEDATA_APEX_LOG_USER_DEBUG, userDebugLog);
// Update the tab
runTestComposite.setUserLogsTextArea(userDebugLog);
}
}
public void testFormalizedComponentNames() {
Component_c component =
Component_c.ComponentInstance(
modelRoot,
new ClassQueryInterface_c() {
public boolean evaluate(Object candidate) {
return ((Component_c) candidate).getName().equals(testDomain.getName());
}
});
assertNotNull(component);
if (!component.Isformal()) formalizeComponent(component);
TreeItem item = ExplorerUtil.findItem(component);
TreeItem fileFacade = item.getItem(0);
assertTrue(
"The file element in Model Explorer was not named correctly for a formal component.",
fileFacade.getText().equals(testDomain.getName() + ": Component Diagram"));
// open the component diagram
CanvasUtilities.openCanvasEditor(component);
GraphicalEditor ce =
((ModelEditor)
PlatformUI.getWorkbench()
.getActiveWorkbenchWindow()
.getActivePage()
.getActiveEditor())
.getGraphicalEditor();
assertTrue(
"The opened diagram does not represent the formal contents of the component.",
ce.getModel().getRepresents() instanceof Domain_c);
assertTrue(
"The editor title did not contain component diagram.",
((IEditorPart) ce).getTitle().indexOf("Component Diagram") != -1);
}
private static final TreeItem findTreeItem(
TreeItem grandParent, TreeItem parent, String parentName, String name) {
if (Const.isEmpty(parentName)) {
if (parent.getText().equalsIgnoreCase(name)) {
return parent;
}
} else {
if (grandParent != null && grandParent.getText().equalsIgnoreCase("OTHER")) {
System.out.println("Other");
}
if (grandParent != null
&& grandParent.getText().equalsIgnoreCase(parentName)
&& parent.getText().equalsIgnoreCase(name)) {
return parent;
}
}
TreeItem ti[] = parent.getItems();
for (int i = 0; i < ti.length; i++) {
TreeItem child = findTreeItem(parent, ti[i], parentName, name);
if (child != null) {
return child;
}
}
return null;
}
private void expandSelect() {
if (fPathToSelect == null) return;
if (fPathToSelect.isEmpty()) {
fPathToSelect = null;
fFileToSelect = null;
return;
}
do {
String name = fPathToSelect.getFirst();
if (name.length() == 0) {
fPathToSelect.removeFirst();
continue;
}
FileInfo info = findFileInfo(fLastSelectedFileInfo, name);
if (info == null) break;
TreeItem item = findItem(info);
if (item == null) break;
fPathToSelect.removeFirst();
if (fPathToSelect.isEmpty()) {
fileTree.setSelection(item);
fileTree.showItem(item);
} else {
item.setExpanded(true);
fileTree.showItem(item);
}
fLastSelectedFileInfo = info;
} while (!fPathToSelect.isEmpty());
}
// --------------------------------------------------------------------------------
private void onTreeItemSelect() {
TreeItem[] selectedItems = tree.getSelection();
if (selectedItems.length != 1) {
return;
}
TreeItem selectedItem = selectedItems[0];
if (selectedItem == tree.getItem(0)) // root
{
shell
.getDisplay()
.asyncExec(
new Runnable() {
public void run() { // *****
debug(Thread.currentThread());
nameText.setText("");
valueText.setText("");
typeCombo.select(0);
updateButton.setEnabled(false);
}
}); // *******
return;
}
String fieldName = (String) selectedItem.getData("fieldName");
executeAction("mj edit field " + fieldName);
}
/**
* Get the data that are currently displayed in the editor.<br>
*
* @param treeViewer TreeViewer
* @return Editor display data
*/
private List<JbmEditorMigrationRow> createEditorViewData(TreeViewer treeViewer) {
List<JbmEditorMigrationRow> list = new ArrayList<JbmEditorMigrationRow>();
for (TreeItem item : treeViewer.getTree().getItems()) {
list.add((JbmEditorMigrationRow) item.getData());
}
return list;
}
private void loaduserInterfaces() {
DOMUtil util = null;
File userInterfacesFile = null;
File dir = null;
Document interfacesDoc = null;
LinkedList children = null;
TreeItem item = null;
util = new DOMUtil();
dir = new File(System.getProperty("user.home"), FILE_TOOLBOXUSER_CONFIGURATIONS_DIRECTORY);
userInterfacesFile = new File(dir, PATH_INTERFACES_DEFINITION_XML);
try {
interfacesDoc = util.readerToDocument(new FileReader(userInterfacesFile));
children = DOMUtil.getChildrenByTagName(interfacesDoc.getDocumentElement(), "interface");
for (int i = 0; i < children.size(); i++) {
final String itemtext = this.createItemName((Element) children.get(i));
item = new TreeItem(this.interfaceTree, SWT.NULL);
item.setText(itemtext);
}
} catch (final Exception e) {
}
}
/** Populate tree. */
protected void populateTree() {
if (getTreeViewer() == null
|| getTreeViewer().getTree() == null
|| getViewInfo() == null
|| getDiagram() == null) {
return;
}
Diagram diagram = getDiagram();
Collection<Integer> filters = MDTUtil.getAllViewsToFilterFromDiagram(diagram);
for (TreeItem item : getTreeViewer().getTree().getItems()) {
Object data = item.getData();
if (data instanceof ViewInfo) {
ViewInfo info = (ViewInfo) data;
if (filters.contains(info.getVisualID())) {
item.setChecked(false);
} else {
item.setChecked(true);
}
if (((ViewInfo) data).isSelectable() == false) {
item.setForeground(ColorConstants.gray);
}
}
setChecked(item, filters);
}
}
private TreeItem findElement(TreeItem[] items, TreeItem[] toBeSkipped, boolean allowToGoUp) {
if (fStringMatcher == null) return items.length > 0 ? items[0] : null;
ILabelProvider labelProvider = (ILabelProvider) getfTreeViewer().getLabelProvider();
// First search at same level
/*for (int i= 0; i < items.length; i++) {
final TreeItem item= items[i];
IJavaElement element= (IJavaElement)item.getData();
if (element != null) {
String label= labelProvider.getText(element);
if (fStringMatcher.match(label))
return item;
}
}*/
// Go one level down for each item
for (int i = 0; i < items.length; i++) {
final TreeItem item = items[i];
TreeItem foundItem = findElement(selectItems(item.getItems(), toBeSkipped), null, false);
if (foundItem != null) return foundItem;
}
if (!allowToGoUp || items.length == 0) return null;
// Go one level up (parent is the same for all items)
TreeItem parentItem = items[0].getParentItem();
if (parentItem != null) return findElement(new TreeItem[] {parentItem}, items, true);
// Check root elements
return findElement(selectItems(items[0].getParent().getItems(), items), null, false);
}
// // testMethods2.cpp
// #include "testMethods.h"
// void MyClass::method2() {
// method3();
// }
// void MyClass::method1() {
// method3();
// }
public void testMultipleImplsForMethod() throws Exception {
CharSequence[] content = getContentsForTest(3);
String header = content[0].toString();
String source1 = content[1].toString();
String source2 = content[2].toString();
IFile headerFile = createFile(getProject(), "testMethods.h", header);
IFile sourceFile1 = createFile(getProject(), "testMethods1.cpp", source1);
IFile sourceFile2 = createFile(getProject(), "testMethods2.cpp", source2);
waitUntilFileIsIndexed(fIndex, sourceFile2);
CEditor editor = openEditor(sourceFile1);
editor.selectAndReveal(source1.indexOf("method3"), 2);
openCallHierarchy(editor);
TreeViewer tv = getCHTreeViewer();
TreeItem item = checkTreeNode(tv.getTree(), 0, "MyClass::method3() : void");
TreeItem item0 = checkTreeNode(tv.getTree(), 0, 0, "MyClass::method1() : void");
TreeItem item1 = checkTreeNode(tv.getTree(), 0, 1, "MyClass::method2() : void");
checkTreeNode(tv.getTree(), 0, 2, null);
item = null;
// method 1
tv.setExpandedState(item0.getData(), true);
checkTreeNode(item0, 0, null);
// method 2
tv.setExpandedState(item1.getData(), true);
TreeItem nextItem = checkTreeNode(item1, 0, "MyClass::method1() : void");
checkTreeNode(item1, 1, null);
item1 = nextItem;
tv.setExpandedState(item1.getData(), true);
checkTreeNode(item1, 0, null);
}
@Override
public boolean handleAltLeftClick(TreeColumn treeColumn, TreeItem treeItem) {
try {
if (treeItem.getData() instanceof Artifact) {
Artifact useArt = (Artifact) treeItem.getData();
if (!(useArt.isOfType(AtsArtifactTypes.AbstractWorkflowArtifact))) {
return false;
}
boolean modified = promptChangeSprint(useArt, isPersistViewer());
XViewer xViewer = ((XViewerColumn) treeColumn.getData()).getTreeViewer();
if (modified && isPersistViewer(xViewer)) {
useArt.persist("persist sprints via alt-left-click");
}
if (modified) {
xViewer.update(useArt, null);
return true;
}
}
} catch (OseeCoreException ex) {
OseeLog.log(Activator.class, OseeLevel.SEVERE_POPUP, ex);
}
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jface.viewers.CheckboxTreeViewer#setAllChecked(boolean)
*/
public void setAllChecked(boolean state) {
for (TreeItem item : super.getTree().getItems()) item.setChecked(state);
if (state) {
// Find all visible children, add only the visible leaf nodes to the check state cache
Object[] visible = getFilteredChildren(getRoot());
ITreeContentProvider contentProvider = null;
if (getContentProvider() instanceof ITreeContentProvider) {
contentProvider = (ITreeContentProvider) getContentProvider();
}
if (contentProvider == null) {
for (int i = 0; i < visible.length; i++) {
checkState.add(visible[i]);
}
} else {
Set<Object> toCheck = new HashSet<Object>();
for (int i = 0; i < visible.length; i++) {
addFilteredChildren(visible[i], contentProvider, toCheck);
}
checkState.addAll(toCheck);
}
} else {
// Remove any item in the check state that is visible (passes the filters)
if (checkState != null) {
Object[] visible = filter(checkState.toArray());
for (int i = 0; i < visible.length; i++) {
checkState.remove(visible[i]);
}
}
}
}
