/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.taeconfigurator.editors.ui;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import org.apache.uima.resource.metadata.ConfigurationGroup;
import org.apache.uima.resource.metadata.ConfigurationParameter;
import org.apache.uima.resource.metadata.ConfigurationParameterDeclarations;
import org.apache.uima.resource.metadata.ConfigurationParameterSettings;
import org.apache.uima.taeconfigurator.InternalErrorCDE;
import org.apache.uima.taeconfigurator.Messages;
import org.apache.uima.taeconfigurator.editors.MultiPageEditor;
import org.apache.uima.taeconfigurator.model.ConfigGroup;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
/**
*/
public abstract class AbstractSectionParm extends AbstractSection {
public final static String NOT_IN_ANY_GROUP = Messages
.getString("AbstractSectionParm.notInAnyGroup"); //$NON-NLS-1$
public final static String COMMON_GROUP = Messages.getString("AbstractSectionParm.common"); //$NON-NLS-1$
// maintainers note: names below have extra trailing blanks to get them to approximately line up
// where possible
protected final static String DELEGATE_HEADER = Messages
.getString("AbstractSectionParm.delegateKeyName"); //$NON-NLS-1$
protected final static String FLOWCTLR_HEADER = "Flow Controller Key Name: ";
protected final static String GROUP_HEADER = Messages
.getString("AbstractSectionParm.headerGroupNames"); //$NON-NLS-1$
protected final static String COMMON_GROUP_HEADER = Messages
.getString("AbstractSectionParm.headerCommon"); //$NON-NLS-1$
protected final static String NOT_IN_ANY_GROUP_HEADER = Messages
.getString("AbstractSectionParm.headerNotInAnyGroup"); //$NON-NLS-1$
protected final String OVERRIDE_HEADER = Messages.getString("AbstractSectionParm.overrides"); // nonstatic
// for
// easy
// ref
// in
// subclass
// //$NON-NLS-1$
protected final static String MULTI_VALUE_INDICATOR = "Multi "; //$NON-NLS-1$
protected final static String SINGLE_VALUE_INDICATOR = "Single "; //$NON-NLS-1$
protected final static String OPTIONAL_INDICATOR = "Opt "; //$NON-NLS-1$
protected final static String REQUIRED_INDICATOR = "Req "; //$NON-NLS-1$
protected final String nameHeader = " Name: "; //$NON-NLS-1$
protected final static Map typeNamesW = new HashMap(4);
static { // map extra spaces to get these to take the same
typeNamesW.put("Boolean", "Boolean"); //$NON-NLS-1$ //$NON-NLS-2$
typeNamesW.put("Float", "Float "); //$NON-NLS-1$ //$NON-NLS-2$
typeNamesW.put(Messages.getString("AbstractSectionParm.16"), "Integer "); //$NON-NLS-1$ //$NON-NLS-2$
typeNamesW.put("String", "String "); //$NON-NLS-1$ //$NON-NLS-2$
}
protected Tree tree;
protected Tree parameterSectionTree = null;
protected boolean showOverrides;
protected boolean splitGroupNames;
protected ConfigurationParameter[] commonParms;
protected Map groupParms;
protected ConfigurationParameterDeclarations cpd;
// settings set by other page when it is created
protected ParameterSettingsSection settings = null;
protected Tree settingsTree = null;
public void setSettings(ParameterSettingsSection v) {
settings = v;
settingsTree = v.getTree();
}
/**
* @param editor
* @param parent
* @param hasDescription
*/
public AbstractSectionParm(MultiPageEditor aEditor, Composite parent, String header,
String description) {
super(aEditor, parent, header, description);
}
/*
* (non-Javadoc)
*
* @see org.apache.uima.taeconfigurator.editors.ui.AbstractSection#enable()
*/
public void enable() {
}
/*
* (non-Javadoc)
*
* @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
*/
public abstract void handleEvent(Event event);
/*************************************************************************************************
* methods shared with multiple param pages ****************************************
*/
/**
* Two modes: settingsDisplayMode - if true, shows groups one name at a time, and puts all
* <common> parms in other groups
*/
protected void clearAndRefillTree(boolean usingGroups) {
cpd = getConfigurationParameterDeclarations();
tree.removeAll();
// when filling ParameterSection, it might or might not have
// settings tree set, depending on which panel is shown first
// Filling parmaterSection on initial refresh should not update, in any case, the
// the settings page; it has its own refresh.
// To prevent this, we turn off the settingsTree reference while filling
// and restore it at the end
Tree savedSettingsTree = settingsTree;
settingsTree = null;
groupParms = new TreeMap();
try {
// tree has 2 dummy groups
// first is the <Not in any group>, 2nd is the <Common>
if (null == cpd.getConfigurationParameters())
cpd.setConfigurationParameters(configurationParameterArray0);
fillGroup(cpd.getConfigurationParameters(), NOT_IN_ANY_GROUP, null);
if (null == cpd.getCommonParameters())
cpd.setCommonParameters(configurationParameterArray0);
if (usingGroups) {
fillGroup(cpd.getCommonParameters(), COMMON_GROUP, null);
}
ConfigurationGroup[] groups = cpd.getConfigurationGroups();
for (int i = 0; i < groups.length; i++) {
ConfigurationParameter[] cps = groups[i].getConfigurationParameters();
if (null == cps)
groups[i].setConfigurationParameters(cps = configurationParameterArray0);
fillGroup(groups[i].getConfigurationParameters(), groups[i].getNames(), groups[i]);
}
if (splitGroupNames)
fillGroupsFromGroupParms();
expandAllItems(tree.getItems()); // expand for overrides or groups
} finally {
settingsTree = savedSettingsTree;
groupParms = null;
}
}
private void expandAllItems(TreeItem[] items) {
TreeItem[] containedItems;
for (int i = 0; i < items.length; i++) {
items[i].setExpanded(true);
containedItems = items[i].getItems();
if (null != containedItems)
expandAllItems(containedItems);
}
}
/**
* Called by refresh; add a normal named group and a set of parmaters
*/
private void fillGroup(ConfigurationParameter[] parms, String[] names, ConfigurationGroup modelCG) {
fillGroup(parms, groupNameArrayToString(names), modelCG);
}
/**
* called by refresh() for <Common> and refresh() for named, via another path with names as array
* first converted to concatenated string.
*
* @param parms
* @param names
*/
private void fillGroup(ConfigurationParameter[] parms, String names, ConfigurationGroup modelCG) {
if (splitGroupNames) {
if (names.equals(COMMON_GROUP)) {
commonParms = parms;
} else {
String[] nameArray = groupNamesToArray(names);
if (nameArray.length == 1 && nameArray[0].equals(NOT_IN_ANY_GROUP)) {
TreeItem groupItem = addGroupToGUI(nameArray[0], modelCG);
fill(parms, groupItem);
} else
for (int i = 0; i < nameArray.length; i++) {
List g = (List) groupParms.get(nameArray[i]);
if (null == g) {
g = new ArrayList();
groupParms.put(nameArray[i], g);
}
g.add(new Object[] { modelCG, parms });
}
}
} else {
if (names.equals(COMMON_GROUP))
commonParms = parms;
TreeItem groupItem = addGroupToGUI(names, modelCG);
fill(parms, groupItem);
}
}
private void fillGroupsFromGroupParms() {
for (Iterator grpInfo = groupParms.entrySet().iterator(); grpInfo.hasNext();) {
Map.Entry entry = (Map.Entry) grpInfo.next();
String key = (String) entry.getKey();
List pairs = (List) entry.getValue();
TreeItem groupItem = addGroupToGUI(key, null); // modelCG not available, but not used
for (Iterator pi = pairs.iterator(); pi.hasNext();) {
Object[] v = (Object[]) pi.next();
ConfigurationParameter[] parms = (ConfigurationParameter[]) v[1];
fill(parms, groupItem);
}
fill(commonParms, groupItem);
}
}
/**
* called by refresh() when no groups, just plain parm sets, also for group case
*
* @param parms
* @param group
* <Not in any group> if not in a group, otherwise the group tree item
*/
protected void fill(ConfigurationParameter[] parms, TreeItem group) {
if (parms == null)
return;
for (int i = 0; i < parms.length; i++) {
addNewConfigurationParameterToGUI(parms[i], group);
}
}
public static String groupNameArrayToString(String[] strings) {
StringBuffer b = new StringBuffer();
for (int i = 0; i < strings.length; i++) {
if (i > 0)
b.append(" "); //$NON-NLS-1$
b.append(strings[i]);
}
return b.toString();
}
protected String[] groupNamesToArray(String names) {
if (names.equals(NOT_IN_ANY_GROUP))
return new String[] { names };
AbstractList items = new ArrayList();
int start = 0;
int end;
while (start < names.length() && (names.charAt(start) == ' '))
start++;
for (; start < names.length();) {
end = names.indexOf(' ', start);
if (end == -1) {
items.add(names.substring(start));
break;
}
items.add(names.substring(start, end));
start = end;
while (start < names.length() && names.charAt(start) == ' ')
start++;
}
return (String[]) items.toArray(stringArray0);
}
/**
* Takes an existing model parm and fills a pre-allocated treeItem. 3 callers:
* addNewConfigurationParameter, alterExistingConfigurationParamater (editing), fill (bulk update
* from refresh)
*
* @param item
* @param parm
*/
protected void fillParmItem(TreeItem item, ConfigurationParameter parm) {
item.setText(parmGuiString(parm));
// // set data if tree == parmsection tree
// if (item.getParent() == parameterSectionTree)
// back link used to find corresponding model parm decl from tree item
item.setData(parm);
}
protected String parmGuiString(ConfigurationParameter parm) {
return ((parm.isMultiValued()) ? MULTI_VALUE_INDICATOR : SINGLE_VALUE_INDICATOR)
+ ((parm.isMandatory()) ? REQUIRED_INDICATOR : OPTIONAL_INDICATOR)
+ typeNamesW.get(parm.getType()) + " " + nameHeader + //$NON-NLS-1$
(parm.getName());
}
protected void setGroupText(TreeItem groupItem, String names) {
if (names.equals(COMMON_GROUP))
groupItem.setText(COMMON_GROUP_HEADER);
else if (names.equals(NOT_IN_ANY_GROUP))
groupItem.setText(NOT_IN_ANY_GROUP_HEADER);
else
// next line formats the names with the right number of spaces and makes it
// possible to do future equal compares
groupItem.setText(GROUP_HEADER + groupNameArrayToString(groupNamesToArray(names)));
}
protected TreeItem addGroupToGUI(String names, ConfigurationGroup cg) {
TreeItem groupItem = new TreeItem(tree, SWT.NONE);
setGroupText(groupItem, names);
ConfigGroup mcg;
if (names.equals(COMMON_GROUP))
mcg = new ConfigGroup(cpd, ConfigGroup.COMMON);
else if (names.equals(NOT_IN_ANY_GROUP))
mcg = new ConfigGroup(cpd, ConfigGroup.NOT_IN_ANY_GROUP);
else
mcg = new ConfigGroup(cpd, cg);
groupItem.setData(mcg);
String[] nameArray = groupNamesToArray(names);
if (null != settingsTree) {
for (int i = 0; i < nameArray.length; i++) {
TreeItem[] settingsItems = settingsTree.getItems();
if (!containsGroup(nameArray[i], settingsItems)) {
TreeItem settingsItem = new TreeItem(settingsTree, SWT.NONE);
setGroupText(settingsItem, nameArray[i]);
settingsItem.setData(null);
fill(commonParms, settingsItem);
}
}
}
return groupItem;
}
private boolean containsGroup(String groupName, final TreeItem[] settingsItems) {
for (int i = 0; i < settingsItems.length; i++) {
if (groupName.equals(getName(settingsItems[i])))
return true;
}
return false;
}
/**
* This is called sometimes with Settings group
*
* @param newCP
* @param group -
* is never null. May be <Not in any group>, indicate no groups; may be the "<Common>"
* group; or may be a regular group with a set of group names
*/
protected void addNewConfigurationParameterToGUI(ConfigurationParameter newCP, TreeItem group) {
if (null == group)
throw new InternalErrorCDE("invalid state"); //$NON-NLS-1$
// is part of group but could be NOT_IN_ANY_GROUP
if (null != settingsTree) {
boolean isCommonOrNotInAnyGrp = COMMON_GROUP.equals(getName(group))
|| NOT_IN_ANY_GROUP.equals(getName(group));
TreeItem[] groups = getSettingsGroups(group);
for (int i = 0; i < groups.length; i++) {
// this next test tries to add parms so that common ones come at the end,
// and non-common ones come before the start of common ones.
TreeItem newParmGuiItem = (isCommonOrNotInAnyGrp) ? new TreeItem(groups[i], SWT.NONE)
: new TreeItem(groups[i], SWT.NONE, 0);
fillParmItem(newParmGuiItem, newCP);
}
}
// next only done for non-setting page
if (group.getParent() != settingsTree) {
TreeItem newItem;
fillParmItem(newItem = new TreeItem(group, SWT.NONE), newCP);
if (showOverrides) {
fillOverrides(newItem, newCP);
}
}
}
// this is overriden where needed
// here just make above fn compile OK
protected void fillOverrides(TreeItem parent, ConfigurationParameter modelCP) {
}
protected boolean isOverride(TreeItem item) {
return (item.getText().startsWith(OVERRIDE_HEADER));
}
protected boolean isParameter(TreeItem item) {
String s = item.getText();
return (!isGroup(item) && !s.startsWith(DELEGATE_HEADER) && !s.startsWith(FLOWCTLR_HEADER) && !item
.getText().startsWith(OVERRIDE_HEADER));
}
// Note: rest of code considers NOT_IN_ANY_GROUP to be a kind of group
protected boolean isGroup(TreeItem item) {
String s = item.getText();
return s.startsWith(GROUP_HEADER) || s.startsWith(COMMON_GROUP_HEADER)
|| s.startsWith(NOT_IN_ANY_GROUP_HEADER);
}
protected boolean isNOT_IN_ANY_GROUP(TreeItem item) {
return item.getText().startsWith(NOT_IN_ANY_GROUP_HEADER);
}
protected boolean isCommonGroup(TreeItem item) {
return item.getText().startsWith(COMMON_GROUP_HEADER);
}
protected boolean isDelegate(TreeItem item) {
return item.getText().startsWith(DELEGATE_HEADER) || item.getText().startsWith(FLOWCTLR_HEADER);
}
protected boolean isGroupSelection() {
return isGroup(tree.getSelection()[0]);
}
protected boolean isCommonGroupSelection() {
return isCommonGroup(tree.getSelection()[0]);
}
protected boolean isOverrideSelection() {
return isOverride(tree.getSelection()[0]);
}
protected boolean isParmSelection() {
return isParameter(tree.getSelection()[0]);
}
protected String getName(TreeItem item) {
return getName(item.getText());
}
protected String getName(String s) {
if (s.startsWith(NOT_IN_ANY_GROUP_HEADER))
return NOT_IN_ANY_GROUP;
if (s.startsWith(COMMON_GROUP_HEADER))
return COMMON_GROUP;
if (s.startsWith(GROUP_HEADER))
return s.substring(GROUP_HEADER.length());
if (s.startsWith(OVERRIDE_HEADER))
return s.substring(OVERRIDE_HEADER.length());
// parameter
return s.substring(s.indexOf(nameHeader) + nameHeader.length());
}
protected int getItemIndex(TreeItem parent, TreeItem child) {
return getItemIndex(parent.getItems(), child);
}
protected int getItemIndex(Tree parent, TreeItem child) {
return getItemIndex(parent.getItems(), child);
}
/**
* Works between parameter tree and settings tree We don't use any relative index offsets.
* Instead, we search for the item with the same parameter name.
*
*
* @param containingGroup
* in parm section; if null = means all groups (common parms)
* @return
*/
protected TreeItem[] getSettingsParameter(TreeItem containingGroup, String sourceItemName) {
if (null == settingsTree)
return null;
if (null != containingGroup && isNOT_IN_ANY_GROUP(containingGroup))
return new TreeItem[] { findMatchingParm(settingsTree.getItems()[0], sourceItemName) };
TreeItem[] groups = getSettingsGroups((null == containingGroup) ? tree.getItems()[1] // use
// common
// group,
// will
// return
// all
// groups
// in
// settings
// pg
: containingGroup);
TreeItem[] results = new TreeItem[groups.length];
for (int i = 0; i < groups.length; i++) {
results[i] = findMatchingParm(groups[i], sourceItemName);
}
return results;
}
private TreeItem findMatchingParm(TreeItem group, String name) {
final TreeItem[] items = group.getItems();
for (int i = 0; i < items.length; i++) {
if (name.equals(getName(items[i])))
return items[i];
}
throw new InternalErrorCDE("invalid state");
}
/**
* get set of settings group from settingsTree that correspond to parmsection group
*
* @param group
* @return
*/
protected TreeItem[] getSettingsGroups(TreeItem group) {
if (null == settingsTree)
return null;
if (isNOT_IN_ANY_GROUP(group))
return new TreeItem[] { settingsTree.getItems()[0] };
AbstractList results = new ArrayList();
String[] groupNamesArray = groupNamesToArray(getName(group.getText()));
TreeItem[] items = settingsTree.getItems();
if (groupNamesArray.length == 1 && groupNamesArray[0].equals(COMMON_GROUP)) {
// add parm to all groups except <Not in any group>
TreeItem[] result = new TreeItem[items.length - 1];
System.arraycopy(items, 1, result, 0, result.length);
return result;
}
for (int itemIndex = 0; itemIndex < items.length; itemIndex++) {
String name = getName(items[itemIndex].getText());
for (int i = 0; i < groupNamesArray.length; i++) {
if (name.equals(groupNamesArray[i]))
results.add(items[itemIndex]);
}
}
return (TreeItem[]) results.toArray(treeItemArray0);
}
/**
* find settings tree item for group name
*
* @param name
* @return
*/
protected TreeItem getSettingsGroupTreeItemByName(String name) {
TreeItem[] items = settingsTree.getItems();
for (int i = 0; i < items.length; i++) {
if (name.equals(getName(items[i].getText())))
return items[i];
}
throw new InternalErrorCDE("invalid state"); //$NON-NLS-1$
}
protected ConfigurationParameter getCorrespondingModelParm(TreeItem item) {
if (!isParameter(item))
throw new InternalErrorCDE("invalid argument"); //$NON-NLS-1$
return (ConfigurationParameter) item.getData();
}
protected ConfigGroup getCorrespondingModelGroup(TreeItem item) {
if (!isGroup(item))
throw new InternalErrorCDE("invalid argument"); //$NON-NLS-1$
return (ConfigGroup) item.getData();
}
public ConfigurationParameterSettings getConfigurationParameterSettings() {
return editor.getAeDescription().getMetaData().getConfigurationParameterSettings();
}
/*************************************************************************************************
* * methods affecting the parameter settings. * These run whether or not the settings page has
* been instantiated. * If the settings page is instantiated, that GUI is also updated.
* *******************************************************************
*/
public ConfigurationParameterSettings getModelSettings() {
return getAnalysisEngineMetaData().getConfigurationParameterSettings();
}
/**
* Remove a parameter from all groups it lives in the Settings. If settings page is shown, also
* update the GUI.
*
* @param treeItem
* in ParameterSection of parameter belonging to (multiple) groups
*/
public void removeParmSettingFromMultipleGroups(TreeItem parmItem, boolean removeFromGUI) {
if (!isParameter(parmItem))
throw new InternalErrorCDE("invalid argument"); //$NON-NLS-1$
ConfigurationParameterSettings modelSettings = getModelSettings();
String parmName = getName(parmItem);
TreeItem parent = parmItem.getParentItem();
String groupName = getName(parent.getText());
if (!groupName.equals(NOT_IN_ANY_GROUP)) {
String[] groupNames = (getName(parent.getText()).equals(COMMON_GROUP)) ? getAllGroupNames()
: getCorrespondingModelGroup(parent).getNameArray();
for (int i = 0; i < groupNames.length; i++) {
modelSettings.setParameterValue(groupNames[i], parmName, null);
}
} else {
modelSettings.setParameterValue(parmName, null);
}
if (null != settings) {
if (removeFromGUI) {
TreeItem[] settingsTreeParms = getSettingsParameter(parent, parmName);
for (int i = 0; i < settingsTreeParms.length; i++) {
settingsTreeParms[i].dispose();
}
} else { // leave parm but remove value
editor.getSettingsPage().getValueSection().refresh();
}
}
}
public void updateParmInSettingsGUI(ConfigurationParameter existingCP, TreeItem existingTreeItem,
String prevName) {
if (null != settings) {
TreeItem[] settingsTreeParms = getSettingsParameter(existingTreeItem.getParentItem(),
prevName);
for (int i = 0; i < settingsTreeParms.length; i++) {
fillParmItem(settingsTreeParms[i], existingCP);
}
}
}
protected String[] getAllGroupNames() {
return getAllGroupNames(cpd);
}
/**
*
* @param aCpd
* @return all named groups, excludes <Common> and <Not in any group>
*/
protected String[] getAllGroupNames(ConfigurationParameterDeclarations aCpd) {
ConfigurationGroup[] cgs = aCpd.getConfigurationGroups();
Set results = new TreeSet();
for (int i = 0; i < cgs.length; i++) {
String[] names = cgs[i].getNames();
for (int j = 0; j < names.length; j++) {
results.add(names[j]);
}
}
return (String[]) results.toArray(stringArray0);
}
public void removeCommonParmSettingsFromMultipleGroups() {
ConfigurationParameterSettings modelSettings = getModelSettings();
String[] allGroupNames = getAllGroupNames();
// TreeItem [] items = new TreeItem[0]; // done to avoid may not have been initialized msg
// int offset = 0;
commonParms = cpd.getCommonParameters();
for (int i = 0; i < allGroupNames.length; i++) {
// if (null != settings) {
// items = getSettingsGroupTreeItemByName(allGroupNames[i]).getItems();
// offset = items.length - commonParms.length;
// }
for (int j = 0; j < commonParms.length; j++) {
modelSettings.setParameterValue(allGroupNames[i], commonParms[j].getName(), null);
}
}
if (null != settings) {
for (int j = 0; j < commonParms.length; j++) {
TreeItem[] settingsParms = getSettingsParameter(null, commonParms[j].getName());
for (int k = 0; k < settingsParms.length; k++) {
settingsParms[k].dispose();
}
}
}
}
/**
* Remove some of the parameter settings associated with this particular group, not all the
* parameters for that group name (some parameters may be associated with other instances of a
* particular group name.) If no other group-set contains a particular individual group name, in
* the Settings: remove the common parameters, and remove the individual group itself. Remove the
* particular group-set definition. Note that a group may be defined in more than one group-set.
*
* Method: for the group-set, get the parms. Remove just those parms from all groups. Remove the
* group on the settings page (together with common parms for it) if no other group-set has this
* group name Remove the group-set.
*
* @param groupNames
* @param cps
*/
public void removeIncludedParmSettingsFromMultipleGroups(String[] groupNames,
ConfigurationParameter[] cps) {
for (int j = 0; j < groupNames.length; j++) {
removeIncludedParmSettingsFromSingleGroup(groupNames[j], cps);
}
}
/**
*
* @param treeItem
* in ParameterSection of items an array of tree items to remove Can be all items under a
* particular group, or a set of items from different groups
*/
public void removeIncludedParmSettingsFromSingleGroup(String groupName,
ConfigurationParameter[] cps) {
ConfigurationParameterSettings modelSettings = getModelSettings();
// modelSettings.setParameterValue()
if (groupName.equals(COMMON_GROUP))
throw new InternalErrorCDE("invalid state"); //$NON-NLS-1$
if (groupName.equals(NOT_IN_ANY_GROUP)) {
modelSettings.setParameterSettings(nameValuePairArray0);
} else {
for (int i = 0; i < cps.length; i++)
modelSettings.setParameterValue(groupName, cps[i].getName(), null);
}
if (null != settings) {
TreeItem settingGroup = getSettingsGroupTreeItemByName(groupName);
if (groupName.equals(COMMON_GROUP) || groupName.equals(NOT_IN_ANY_GROUP)) {
disposeAllChildItems(settingGroup);
} else {
if (getConfigurationParameterDeclarations().getConfigurationGroupDeclarations(groupName).length == 1) {
settingGroup.dispose();
} else {
for (int i = 0; i < cps.length; i++) {
findMatchingParm(settingGroup, cps[i].getName()).dispose();
}
}
}
}
}
public void disposeAllChildItems(TreeItem parent) {
TreeItem[] items = parent.getItems();
for (int j = 0; j < items.length; j++) {
items[j].dispose();
}
}
protected void showDescriptionAsToolTip(Event event) {
TreeItem item = tree.getItem(new Point(event.x, event.y));
if (null != item && isParameter(item)) {
setToolTipText(tree, getCorrespondingModelParm(item).getDescription());
} else
tree.setToolTipText(""); //$NON-NLS-1$
}
}