// // 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.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;
}
/**
* 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);
}
protected void setSelectionInViewer(CloudSpace selectedSpace) {
// Now set the cloud space in the tree
Tree tree = orgsSpacesViewer.getTree();
TreeItem[] orgItems = tree.getItems();
if (orgItems != null) {
TreeItem orgItem = null;
// Find the tree item corresponding to the cloud space's
// org
for (TreeItem item : orgItems) {
Object treeObj = item.getData();
if (treeObj instanceof CloudOrganization
&& ((CloudOrganization) treeObj)
.getName()
.equals(selectedSpace.getOrganization().getName())) {
orgItem = item;
break;
}
}
if (orgItem != null) {
TreeItem[] children = orgItem.getItems();
if (children != null) {
for (TreeItem childItem : children) {
Object treeObj = childItem.getData();
if (treeObj instanceof CloudSpace
&& ((CloudSpace) treeObj).getName().equals(selectedSpace.getName())) {
tree.select(childItem);
break;
}
}
}
}
}
}
@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;
}
@Override
public void performDragOver(DropTargetEvent event) {
if (!ArtifactTransfer.getInstance().isSupportedType(event.currentDataType)) {
event.detail = DND.DROP_NONE;
return;
}
final ArtifactData artData = ArtifactTransfer.getInstance().nativeToJava(event.currentDataType);
if (artData == null) {
event.detail = DND.DROP_NONE;
return;
}
for (Artifact art : artData.getArtifacts()) {
if (art.isOfType(CoreArtifactTypes.UniversalGroup)) {
event.detail = DND.DROP_NONE;
return;
}
}
Tree tree = treeViewer.getTree();
TreeItem dragOverTreeItem = tree.getItem(treeViewer.getTree().toControl(event.x, event.y));
event.feedback = DND.FEEDBACK_EXPAND;
event.detail = DND.DROP_NONE;
// Set as COPY if drag item over group (copy versus move will be determined on drop
if (dragOverTreeItem != null
&& ((GroupExplorerItem) dragOverTreeItem.getData()).isUniversalGroup()) {
event.detail = DND.DROP_COPY;
tree.setInsertMark(null, false);
}
// Handle re-ordering within same group
else if (dragOverTreeItem != null
&& !((GroupExplorerItem) dragOverTreeItem.getData()).isUniversalGroup()) {
GroupExplorerItem dragOverGroupItem = (GroupExplorerItem) dragOverTreeItem.getData();
IStructuredSelection selectedItem = (IStructuredSelection) treeViewer.getSelection();
Object obj = selectedItem.getFirstElement();
if (obj instanceof GroupExplorerItem) {
GroupExplorerItem droppingGroupItem = (GroupExplorerItem) obj;
// the group to move must belong to the same group as the member to insert before/after
if (dragOverGroupItem.getParentItem().equals(droppingGroupItem.getParentItem())) {
if (isFeedbackAfter) {
event.feedback = DND.FEEDBACK_INSERT_AFTER;
} else {
event.feedback = DND.FEEDBACK_INSERT_BEFORE;
}
event.detail = DND.DROP_MOVE;
}
} else {
if (isFeedbackAfter) {
event.feedback = DND.FEEDBACK_INSERT_AFTER;
} else {
event.feedback = DND.FEEDBACK_INSERT_BEFORE;
}
event.detail = DND.DROP_COPY;
}
} else {
tree.setInsertMark(null, false);
}
}
public void checkItems(TreeItem[] items, List<TreeItem> toSelect, List<?> sobj) {
if (items == null) return;
for (TreeItem ti : items) {
for (Object obj : sobj) {
if (obj != null && ti.getData() != null) {
if (obj == ti.getData()) toSelect.add(ti);
else if (obj instanceof EditPart && ti.getData() instanceof EditPart) {
if (((EditPart) obj).getModel() == ((EditPart) ti.getData()).getModel())
toSelect.add(ti);
}
}
}
checkItems(ti.getItems(), toSelect, sobj);
}
}
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();
}
public Object getSelectedFromMainTree() {
TreeItem item = getSelectedItemFromMainTree();
if (item == null) {
return null;
}
return item.getData();
}
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 XModelObject getObjectByItem(TreeItem i) {
Object data = i.getData();
if (data instanceof XModelObject) return (XModelObject) data;
if (data instanceof IAdaptable)
return (XModelObject) ((IAdaptable) data).getAdapter(XModelObject.class);
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
*/
@Override
public void widgetSelected(SelectionEvent arg0) {
if ((arg0.detail & SWT.CHECK) == SWT.CHECK) {
try {
TreeItem tree = (TreeItem) arg0.item;
ICPEType cpc = (ICPEType) tree.getData();
cpc.setEnabled(tree.getChecked());
System.out.println("Selection: " + arg0.item + " -> " + cpc.isEnabled());
TreeItem parentItem = tree.getParentItem();
if (!tree.getChecked()) {
if (parentItem.getChecked()) {
parentItem.setGrayed(true);
} else {
}
} else {
tree.setGrayed(false);
}
updateChildCheckboxes(tree);
makeChecksConsistentWithChildren();
} catch (ClassCastException e) {
e.printStackTrace();
}
}
}
/**
* 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;
}
/** 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);
}
}
protected void changeSelection(final TreeItem item, final boolean select) {
SelectableFeature feature = (SelectableFeature) item.getData();
if (feature.getAutomatic() == Selection.UNDEFINED) {
switch (feature.getManual()) {
case SELECTED:
set(feature, (select) ? Selection.UNDEFINED : Selection.UNSELECTED);
break;
case UNSELECTED:
set(feature, (select) ? Selection.SELECTED : Selection.UNDEFINED);
break;
case UNDEFINED:
set(feature, (select) ? Selection.SELECTED : Selection.UNSELECTED);
break;
default:
set(feature, Selection.UNDEFINED);
}
if (!dirty) {
setDirty();
}
if (configurationEditor.isAutoSelectFeatures()) {
computeTree(false);
// updateInfoLabel();
} else {
refreshItem(item, feature);
if (configurationEditor.getConfiguration().canBeValid()) {
invalidFeatures.clear();
} else {
invalidFeatures.add(feature);
}
// updateInfoLabel();
}
}
}
/**
* 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);
}
}
// --------------------------------------------------------------------------------
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);
}
private static EmptyElement locateEmptyElement(TreeItem[] items, Object data) {
for (TreeItem item : items) {
if (item.getData() instanceof EmptyElement) {
EmptyElement empty = (EmptyElement) item.getData();
if (empty.getRepresentedMissingElement().equals(data)) {
return empty;
}
} else {
EmptyElement empty = locateEmptyElement(item.getItems(), data);
if (empty != null) {
return empty;
}
}
}
return null;
}
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;
}
public Rectangle buildHighlightRectangle(
TreeItem item,
boolean includeChildren,
GC gc,
boolean includeHeaderHeight,
boolean adjustHeight) {
TreeItem parentItem = item.getParentItem();
Rectangle bounds = item.getBounds();
if (parentItem != null) {
bounds = parentItem.getBounds(0);
}
Rectangle itemBounds = item.getBounds();
int x = bounds.x;
int width = itemBounds.width + itemBounds.x - bounds.x;
if (parentItem == null) {
x = 0;
width = bounds.width + bounds.x;
}
Rectangle highlight = new Rectangle(x, itemBounds.y, width, getTree().getItemHeight());
// expand for column text
String columnText = ((ITableLabelProvider) getLabelProvider()).getColumnText(item.getData(), 1);
if (columnText != null) {
Point textExtent = gc.textExtent(columnText);
int textWidth = textExtent.x;
Rectangle columnBounds = item.getBounds(1);
highlight.width = (columnBounds.x + textWidth) - highlight.x;
// increase width to account for space where icon would be
// later we will need to account for the icons directly (currently
// there are no icons for the second column)
highlight.width = highlight.width + 16;
}
// expand for children if necessary
if (includeChildren) {
TreeItem[] children = item.getItems();
if (children.length != 0) {
expandHighlightRectangleForChildren(highlight, children, gc);
}
}
// shrink the rectangle by one pixel so that back to back
// highlights do not overlap
if (adjustHeight) {
int itemSpace = item.getBounds().height - getTree().getItemHeight();
itemSpace = Math.abs(itemSpace);
highlight.height = highlight.height - itemSpace;
}
if (SWT.getPlatform().equals("gtk") && item.getParentItem() != null) { // $NON-NLS-1$
// GTK puts expansion handles directly
// at the location of the parent bounds
// we use that location to start the box
// to allow better looking highlights
// increase the size a bit for linux
highlight.x = highlight.x - 5;
highlight.width = highlight.width + 5;
}
if (includeHeaderHeight) {
highlight.y = highlight.y + getTree().getHeaderHeight();
}
return highlight;
}
private void updateTreeCheckboxesForItem(TreeItem item) {
ICheckboxTreeContentProvider contentProvider = contentProvider();
while (item != null) {
item.setChecked(contentProvider.isChecked(item.getData()));
item = ((TreeViewerAccess) treeViewer).getNextItem(item, true);
}
}
public static TreeItem getTreeItem(Tree tree, Object data) {
for (TreeItem item : tree.getItems()) {
if (item.getData() == data) {
return item;
}
}
return null;
}
public static List<Object> getAllData(Tree tree) {
List<TreeItem> items = new ArrayList<TreeItem>();
collectTreeItemsInView(tree.getItems(), items);
List<Object> dataList = new ArrayList<Object>();
for (TreeItem item : items) {
dataList.add(item.getData());
}
return dataList;
}
/**
* Calculates the index of the TreeItem at given point.
*
* @param pt the Point in the Viewer
* @return the index of the TreeItem
*/
protected final int findIndexOfTreeItemAt(org.eclipse.draw2d.geometry.Point pt) {
int index = -1;
TreeItem item = findTreeItemAt(pt);
if (item != null) {
index = getHost().getChildren().indexOf(item.getData());
if (index >= 0 && !isInUpperHalf(item.getBounds(), pt)) index++;
}
return index;
}
private void collectElementsInBranch(
TreeItem item, Collection treeItems, Collection testElements) {
treeItems.add(item);
testElements.add(item.getData());
TreeItem[] children = item.getItems();
for (int i = 0; i < children.length; i++) {
collectElementsInBranch(children[i], treeItems, testElements);
}
}
/**
* Update the test results tabs.
*
* @param selectedTreeItem
* @param selectedTab
*/
public void updateView(TreeItem selectedTreeItem, String selectedTab) {
if (Utils.isEmpty(selectedTreeItem)
|| Utils.isEmpty(selectedTab)
|| Utils.isEmpty(runTestComposite)) {
return;
}
// Only clear the right side because user will either select an item from the results tree
// or a tab. We do not want to clear the tree (on the left side).
runTestComposite.clearTabs();
ApexTestResult testResult = (ApexTestResult) selectedTreeItem.getData(TREEDATA_TEST_RESULT);
// If there is no test result, there is nothing to do on the right hand side so just
// show the test file
if (Utils.isEmpty(testResult)) {
// Get the code location and open the file
ApexCodeLocation location =
(ApexCodeLocation) selectedTreeItem.getData(TREEDATA_CODE_LOCATION);
highlightLine(location);
return;
}
// If there is an ApexTestResult to work with, then check which tab is in focus
// so we can update lazily.
switch (selectedTab) {
case RunTestViewComposite.STACK_TRACE:
showStackTrace(testResult.getMessage(), testResult.getStackTrace());
break;
case RunTestViewComposite.SYSTEM_LOG:
String systemLogId = testResult.getApexLogId();
String systemApexLog = tryToGetApexLog(selectedTreeItem, systemLogId);
showSystemLog(systemApexLog);
break;
case RunTestViewComposite.USER_LOG:
String userLogId = testResult.getApexLogId();
String userApexLog = tryToGetApexLog(selectedTreeItem, userLogId);
showUserLog(selectedTreeItem, userApexLog);
break;
}
// Show the file after updating the right hand side
ApexCodeLocation location = (ApexCodeLocation) selectedTreeItem.getData(TREEDATA_CODE_LOCATION);
highlightLine(location);
}
/**
* This method is called when 'Finish' button is pressed in the wizard. We will create an
* operation and run it using wizard as execution context.
*/
public boolean performFinish() {
logger.debug("IN");
TreeItem[] selectedItems = page.getTree().getSelection();
if (selectedItems == null) {
logger.warn("Error; no models selected");
} else {
// cycle on selected items
for (int i = 0; i < selectedItems.length; i++) {
TreeItem selectedItem = selectedItems[i];
TreeItem folderItem = selectedItem;
// gets the folder and file name selected
if (selectedItem.getData().toString().endsWith(".sbimodel")) {
folderItem = selectedItem.getParentItem();
if (folderItem == null) {
logger.warn("Error; no models selected");
MessageDialog.openError(
getShell(), "Warning", "Choose a folder and a model file to continue.");
return false;
}
String folderName = folderItem.getText();
String modelName = selectedItem.getText();
if (folderName != null
&& !folderName.equals("")
&& modelName != null
&& !modelName.equals("")
&& modelName.endsWith(".sbimodel")) {
downloadModel(folderName, modelName);
} else {
logger.warn("Could not download model,not a right element was selected!");
MessageDialog.openError(
getShell(), "Warning", "Choose a folder and a model file to continue.");
return false;
}
}
}
// print messages on file that could not be written
if (messages.size() > 0) {
String message =
"Following models could not be added because already exist in project with the same name. You must delete firstly the existing ones: ";
for (Iterator iterator = messages.iterator(); iterator.hasNext(); ) {
String msg = (String) iterator.next();
message += msg;
if (iterator.hasNext()) {
message += ", ";
}
}
MessageDialog.openWarning(page.getShell(), "Warning", message);
messages = new Vector<String>();
}
doFinish();
}
logger.debug("OUT");
return true;
}
@Override
protected void onExit() {
final XmlNode root = configurer.getRoot();
root.removeChildren(ConfigAnimations.ANIMATION);
for (final TreeItem item : animationList.getTree().getItems()) {
final Animation animation = (Animation) item.getData();
final XmlNode nodeAnim = ConfigAnimations.createNode(animation);
root.add(nodeAnim);
}
configurer.save();
}
/**
* Adds the view infos.
*
* @param root the root
* @param infos the infos
*/
protected void addViewInfos(TreeItem root, Collection<Integer> infos) {
for (TreeItem item : root.getItems()) {
if (item.getChecked() == false) {
Object data = item.getData();
if (data instanceof ViewInfo) {
infos.add(((ViewInfo) data).getVisualID());
}
}
addViewInfos(item, infos);
}
}
private int calculateWorkUnits(TreeItem[] items) {
int count = 0;
for (TreeItem item : items) {
Object data = item.getData();
if (data instanceof PackageRecord) {
count += ((PackageRecord) data).getChildren().length;
} else if (data instanceof FileRecord) {
count++;
}
}
return count;
}
