//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation and others.
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// Contributors:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.authoring.ui.properties;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.edit.provider.ItemProviderAdapter;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.epf.authoring.ui.dialogs.ItemsFilterDialog;
import org.eclipse.epf.authoring.ui.filters.ProcessGuidanceFilter;
import org.eclipse.epf.library.edit.IFilter;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.command.ChangeUdtCommand;
import org.eclipse.epf.library.edit.command.IActionManager;
import org.eclipse.epf.library.edit.configuration.GuidanceItemProvider;
import org.eclipse.epf.library.edit.itemsfilter.FilterConstants;
import org.eclipse.epf.library.edit.itemsfilter.FilterInitializer;
import org.eclipse.epf.library.edit.process.IBSItemProvider;
import org.eclipse.epf.library.edit.process.command.AddGuidanceToBreakdownElementCommand;
import org.eclipse.epf.library.edit.util.DescriptorPropUtil;
import org.eclipse.epf.library.edit.util.LibraryEditUtil;
import org.eclipse.epf.library.edit.util.PracticePropUtil;
import org.eclipse.epf.library.edit.util.ProcessScopeUtil;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.Checklist;
import org.eclipse.epf.uma.Concept;
import org.eclipse.epf.uma.Descriptor;
import org.eclipse.epf.uma.EstimationConsiderations;
import org.eclipse.epf.uma.Example;
import org.eclipse.epf.uma.Guidance;
import org.eclipse.epf.uma.Guideline;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Practice;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.Report;
import org.eclipse.epf.uma.ReusableAsset;
import org.eclipse.epf.uma.SupportingMaterial;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.Template;
import org.eclipse.epf.uma.ToolMentor;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableFontProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Table;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage;
/**
* The breakdown element guidance section. It list all available guidances for an breakdown element
*
* @author Shilpa Toraskar
* @since 1.0
*
*/
public class BreakdownElementGuidanceSection extends AbstractSection {
private FormToolkit toolkit;
private Button ctrl_add_1, ctrl_remove_1;
private Table ctrl_table_1;
private TableViewer viewer_1;
// element
private BreakdownElement element;
// action manager
private IActionManager actionMgr;
public final String tabName = FilterConstants.GUIDANCE;
private IFilter generalGuidanceFilter = null;
private DescriptorPropUtil propUtil;
/**
* Get General guidance filter
*
*/
public IFilter getGeneralGuidanceFilter() {
if (generalGuidanceFilter == null) {
generalGuidanceFilter = new ProcessGuidanceFilter(
getConfiguration(), null, tabName) {
public boolean childAccept(Object obj) {
if (super.childAccept(obj))
return true;
if (obj instanceof GuidanceItemProvider) {
if (((GuidanceItemProvider) obj).getChildren(obj)
.isEmpty())
return false;
else
return true;
}
Class cls = FilterInitializer.getInstance()
.getClassForType(helper.getFilterTypeStr());
if (cls != null) {
if (cls.isInstance(obj)) {
return true;
} else {
return false;
}
}
if ((obj instanceof Checklist) || (obj instanceof Concept)
|| (obj instanceof Example)
|| (obj instanceof Guideline)
|| (obj instanceof ReusableAsset)
|| (obj instanceof SupportingMaterial)
|| (obj instanceof Template)
|| (obj instanceof Report)
|| (obj instanceof ToolMentor)
|| (obj instanceof EstimationConsiderations))
return true;
if (obj instanceof Practice) {
if (PracticePropUtil.getPracticePropUtil().isUdtType((Practice) obj)) {
return true;
}
}
return false;
}
};
}else {
((ProcessGuidanceFilter) generalGuidanceFilter).setMethodConfiguration(getConfiguration());
}
return generalGuidanceFilter;
}
/**
* @see org.eclipse.epf.authoring.ui.properties.AbstractSection#createControls(org.eclipse.swt.widgets.Composite, org.eclipse.ui.views.properties.tabbed.TabbedPropertySheetPage)
*/
public void createControls(Composite parent,
TabbedPropertySheetPage tabbedPropertySheetPage) {
super.createControls(parent, tabbedPropertySheetPage);
init();
parent.setLayout(new GridLayout());
parent.setLayoutData(new GridData(GridData.FILL_BOTH));
// create guidance section
createGuidanceSection(parent);
// add listeners
addListeners();
// update controls
updateControls();
}
/**
* Initialize
*/
private void init() {
// get activity object
element = (BreakdownElement) getElement();
// get toolkit
toolkit = getWidgetFactory();
// get action manager
actionMgr = EPFPropertySheetPage.getActionManager();
propUtil = DescriptorPropUtil.getDesciptorPropUtil(actionMgr);
}
/**
* Update controls based on editable flag. Controls can become editable or un-editable
*/
public void updateControls() {
ctrl_add_1.setEnabled(editable);
IStructuredSelection selection = (IStructuredSelection) viewer_1
.getSelection();
if (selection.size() > 0 && editable) {
ctrl_remove_1.setEnabled(true);
} else {
ctrl_remove_1.setEnabled(false);
}
}
/**
* @see org.eclipse.ui.views.properties.tabbed.AbstractPropertySection#refresh()
*/
public void refresh() {
try {
if (getElement() instanceof BreakdownElement) {
element = (BreakdownElement) getElement();
initContentProvider();
initLabelProvider();
viewer_1.refresh();
// hide/show controls
updateControls();
}
} catch (Exception ex) {
logger.logError("Error refreshing activity guidance section: ", ex); //$NON-NLS-1$
}
}
/**
* @see org.eclipse.epf.authoring.ui.properties.AbstractSection#dispose()
*/
public void dispose() {
super.dispose();
}
/**
* Create guidance section on the given composite
* @param composite
*/
private void createGuidanceSection(Composite composite) {
int tableHeight = 50;
String sectionTitle = null;
String sectionDesc = null;
String tableTitle = null;
// GENERAL GUIDANCE
{
sectionTitle = PropertiesResources.Activity_GeneralGuidanceTitle;
sectionDesc = PropertiesResources.Activity_GeneralGuidanceDescription;
tableTitle = PropertiesResources.Activity_Selected_GeneralGuidance;
if (isSyncFree()) {
sectionDesc = sectionDesc + " " + PropertiesResources.Process_SyncFree_FontStyle; //$NON-NLS-1$
}
Section section = FormUI.createSection(toolkit, composite,
sectionTitle, sectionDesc);
// create composite
Composite sectionComposite = FormUI.createComposite(toolkit,
section, 2, false);
Composite pane1 = FormUI.createComposite(toolkit, sectionComposite,
GridData.FILL_BOTH);
FormUI.createLabel(toolkit, pane1, tableTitle);
ctrl_table_1 = FormUI.createTable(toolkit, pane1, tableHeight);
viewer_1 = new TableViewer(ctrl_table_1);
initContentProvider();
initLabelProvider();
viewer_1.setInput(element);
// create buttons for table2
Composite pane2 = FormUI.createComposite(toolkit, sectionComposite,
GridData.VERTICAL_ALIGN_CENTER
| GridData.HORIZONTAL_ALIGN_CENTER);
ctrl_add_1 = FormUI.createButton(toolkit, pane2,
PropertiesResources.Process_Add);
ctrl_remove_1 = FormUI.createButton(toolkit, pane2,
PropertiesResources.Process_Remove);
toolkit.paintBordersFor(pane1);
}
}
protected void initContentProvider() {
IStructuredContentProvider contentProvider = new AdapterFactoryContentProvider(
getAdapterFactory()) {
public Object[] getElements(Object object) {
List<MethodElement> elements = new ArrayList<MethodElement>();
elements.addAll(getSelectedGuidances());
if (element instanceof Descriptor) {
Descriptor des = (Descriptor) element;
if (isSyncFree() && !propUtil.isNoAutoSyn(des)) {
elements.addAll((des).getGuidanceExclude());
}
MethodElement linkedElement = ProcessUtil
.getAssociatedElement(des);
if (linkedElement != null) {
Process process = ProcessUtil.getProcess(des
.getSuperActivities());
if (ProcessScopeUtil.getInstance().isConfigFree(process)) {
Map<EReference, EReference> refMap = LibraryEditUtil.getInstance().getGuidanceRefMap(
linkedElement.eClass());
Set<Object> set = new HashSet<Object>();
if (refMap != null) {
for (EReference ref : refMap.keySet()) {
// Object value = linkedElement.eGet(ref);
Object value = propUtil.eGet(linkedElement, ref, false);
if (value instanceof List) {
set.addAll((List) value);
}
List<Guidance> locals = des.getGuidanceAdditional();
if (locals != null && !locals.isEmpty()) {
set.addAll(locals);
}
}
}
elements.retainAll(set);
}
}
}
return getFilteredList(elements).toArray();
}
};
viewer_1.setContentProvider(contentProvider);
}
protected void initLabelProvider() {
ILabelProvider labelProvider = null;
if (isSyncFree()) {
labelProvider = new GuidanceSyncFreeLabelProvider(
TngAdapterFactory.INSTANCE.getNavigatorView_ComposedAdapterFactory(),
(Descriptor)element, getConfiguration());
} else {
labelProvider = new AdapterFactoryLabelProvider(
TngAdapterFactory.INSTANCE.getNavigatorView_ComposedAdapterFactory());
}
viewer_1.setLabelProvider(labelProvider);
}
/**
* Add listeners
*
*/
private void addListeners() {
ItemProviderAdapter adapter = (ItemProviderAdapter) getAdapter();
Object parent = null;
if (adapter instanceof IBSItemProvider) {
IBSItemProvider bsItemProvider = (IBSItemProvider) adapter;
parent = bsItemProvider.getTopItem();
} else {
logger
.logError("ActivityGuidanceSection::addListeners - IBSItemProvider is null"); //$NON-NLS-1$
return;
}
{
ctrl_table_1.addFocusListener(new FocusAdapter() {
public void focusGained(FocusEvent e) {
IStructuredSelection selection = (IStructuredSelection) viewer_1
.getSelection();
if ((selection.size() > 0) && editable)
ctrl_remove_1.setEnabled(true);
}
});
viewer_1
.addSelectionChangedListener(new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
IStructuredSelection selection = (IStructuredSelection) viewer_1
.getSelection();
if ((selection.size() > 0) && editable) {
if (isSyncFree()) {
syncFreeUpdateBtnStatus(selection);
} else {
ctrl_remove_1.setEnabled(true);
}
}
}
});
ctrl_add_1.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (isSyncFree()) {
IStructuredSelection selection = (IStructuredSelection) viewer_1.getSelection();
if (syncFreeAdd(selection)) {
viewer_1.refresh();
return;
}
}
IFilter filter = getGeneralGuidanceFilter();
List existingElements = null;
if (isSyncFree()) {
existingElements = getSelectedGuidances();
if (! propUtil.isNoAutoSyn((Descriptor)element)) {
existingElements.addAll(((Descriptor)element).getGuidanceExclude());
}
} else {
existingElements = getSelectedGuidances();
}
ItemsFilterDialog fd = new ItemsFilterDialog(PlatformUI
.getWorkbench().getActiveWorkbenchWindow()
.getShell(), filter, element,
FilterConstants.GUIDANCE, existingElements);
fd.setTitle(FilterConstants.GUIDANCE);
fd.setInput(UmaUtil.getMethodLibrary((EObject) element));
fd.setBlockOnOpen(true);
fd.setTypes(getFilterTypes());
fd.setEnableProcessScope(true);
fd.setSection(getSection());
fd.open();
addGuidances(fd.getSelectedItems());
viewer_1.refresh();
}
});
ctrl_remove_1.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (isSyncFree()) {
IStructuredSelection selection = (IStructuredSelection) viewer_1.getSelection();
if (syncFreeRemove(selection)) {
viewer_1.refresh();
ctrl_remove_1.setEnabled(false);
return;
}
}
IStructuredSelection selection = (IStructuredSelection) viewer_1
.getSelection();
if (selection.size() > 0) {
// update the model
ArrayList rmItems = new ArrayList();
rmItems.addAll(selection.toList());
removeGuidances(rmItems);
viewer_1.refresh();
// clear the selection
viewer_1.setSelection(null, true);
}
ctrl_remove_1.setEnabled(false);
}
});
}
}
private void addGuidances(List<Guidance> addItems) {
addGuidances(addItems, false);
}
/**
* Add guidances to the element
* @param addItems
* list of guidances to add
*/
private void addGuidances(List<Guidance> addItems, boolean calledForExculded) {
// update the model
AddGuidanceToBreakdownElementCommand command = new AddGuidanceToBreakdownElementCommand(
element, addItems, calledForExculded);
actionMgr.execute(command);
}
private void removeGuidances(List<Guidance> rmItems) {
removeGuidances(rmItems, true);
}
/**
* Remove guidances from the element
* @param rmItems
* list of guidances to remove
*/
private void removeGuidances(List<Guidance> rmItems, boolean localUse) {
// update the model
List<Practice> utdItems = new ArrayList<Practice>();
if (!rmItems.isEmpty()) {
for (Iterator it = rmItems.iterator(); it.hasNext();) {
Guidance item = (Guidance) it.next();
// guidances for activity
if (item instanceof Checklist) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_Checklists(),
item, -1);
} else if (item instanceof Concept) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_Concepts(), item,
-1);
} else if (item instanceof Example) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_Examples(), item,
-1);
} else if (item instanceof SupportingMaterial) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE
.getBreakdownElement_SupportingMaterials(), item,
-1);
} else if (item instanceof Guideline) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_Guidelines(),
item, -1);
} else if (item instanceof ReusableAsset) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_ReusableAssets(),
item, -1);
}else if (item instanceof Template) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_Templates(),
item, -1);
}else if (item instanceof Report) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_Reports(),
item, -1);
}else if (item instanceof ToolMentor) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_Toolmentor(),
item, -1);
}else if (item instanceof EstimationConsiderations) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getBreakdownElement_Estimationconsiderations(),
item, -1);
} else if (item instanceof Practice) {
if (PracticePropUtil.getPracticePropUtil().isUdtType((Practice) item)) {
utdItems.add((Practice) item);
}
} else {
logger
.logError("Can't remove Guidance: " + item.getType().getName() + ":" + item.getName()); //$NON-NLS-1$ //$NON-NLS-2$
}
if (! utdItems.isEmpty()) {
actionMgr.execute(new ChangeUdtCommand(element, utdItems, true));
}
if (isSyncFree()) {
if (localUse) {
actionMgr.doAction(IActionManager.REMOVE, element,
UmaPackage.eINSTANCE.getDescriptor_GuidanceAdditional(),
item, -1);
if (element instanceof TaskDescriptor) {
TaskDescriptor td = (TaskDescriptor) element;
TaskDescriptor greenParent = (TaskDescriptor) propUtil.getGreenParentDescriptor(td);
if (greenParent != null) {
EReference aRef = UmaPackage.eINSTANCE.getDescriptor_GuidanceAdditional();
List<Guidance> parentAdditionalList = (List<Guidance>) greenParent.eGet(aRef);
propUtil.removeGreenRefDelta(td, item, aRef, true);
if (parentAdditionalList != null && parentAdditionalList.contains(item)) {
propUtil.addGreenRefDelta(td, item, aRef, false);
}
}
}
} else {
actionMgr.doAction(IActionManager.ADD, element,
UmaPackage.eINSTANCE.getDescriptor_GuidanceExclude(),
item, -1);
//for Green parent
Descriptor parent = propUtil.getGreenParentDescriptor((Descriptor)element);
if ((parent != null) && (parent instanceof TaskDescriptor)) {
TaskDescriptor greenParent = (TaskDescriptor)parent;
EReference ref = propUtil.getGuidanceEReference(item);
EReference eRef = LibraryEditUtil.getInstance().getExcludeFeature(ref);
List<MethodElement> parentExecludeList = (List<MethodElement>) greenParent.eGet(eRef);
propUtil.removeGreenRefDelta((Descriptor) element, item, eRef, false);
if (parentExecludeList != null && !parentExecludeList.contains(item)) {
propUtil.addGreenRefDelta((Descriptor) element, item, eRef, true);
}
}
}
}
}
}
}
/**
* Get selected guidances
* @return
* list of existing selected guidances
*/
private List<Guidance> getSelectedGuidances() {
List<Guidance> itemList = new ArrayList();
itemList.addAll(element.getChecklists());
itemList.addAll(element.getConcepts());
itemList.addAll(element.getExamples());
itemList.addAll(element.getGuidelines());
itemList.addAll(element.getReusableAssets());
itemList.addAll(element.getSupportingMaterials());
itemList.addAll(element.getTemplates());
itemList.addAll(element.getReports());
itemList.addAll(element.getEstimationconsiderations());
itemList.addAll(element.getToolmentor());
if (propUtil.hasUdtList(element)) {
itemList.addAll(propUtil.getUdtList(element, false));
}
return itemList;
}
/**
* Return list of filter types
*/
protected String[] getFilterTypes() {
String[] str = new String[12];
int i = 0;
str[i++] = FilterConstants.GUIDANCE;
str[i++] = FilterConstants.space + FilterConstants.CHECKLISTS;
str[i++] = FilterConstants.space + FilterConstants.CONCEPTS;
str[i++] = FilterConstants.space
+ FilterConstants.ESTIMATE_CONSIDERATIONS;
str[i++] = FilterConstants.space + FilterConstants.EXAMPLES;
str[i++] = FilterConstants.space + FilterConstants.GUIDELINES;
str[i++] = FilterConstants.space + FilterConstants.REPORTS;
str[i++] = FilterConstants.space + FilterConstants.REUSABLE_ASSETS;
str[i++] = FilterConstants.space + FilterConstants.SUPPORTING_MATERIALS;
str[i++] = FilterConstants.space + FilterConstants.TEMPLATES;
str[i++] = FilterConstants.space + FilterConstants.TOOL_MENTORS;
str[i++] = FilterConstants.space + FilterConstants.WHITE_PAPERS;
return str;
}
protected boolean isSyncFree() {
return propUtil.isDescriptor(element) && ProcessUtil.isSynFree();
}
protected boolean syncFreeAdd(IStructuredSelection selection) {
if (selection.size() == 0) {
return false;
}
boolean result = propUtil.CheckSelectionForGuidance(selection.toList(), (Descriptor)element, getConfiguration());
if (! result) {
return true;
}
Object testObj = selection.getFirstElement();
EReference ref = propUtil.getGuidanceEReference((Guidance)testObj);
if (propUtil.isDynamicAndExclude(testObj, (Descriptor)element, ref, getConfiguration())) {
addGuidances(selection.toList(), true);
return true;
}
return false;
}
protected boolean syncFreeRemove(IStructuredSelection selection) {
if (selection.size() == 0) {
return true;
}
boolean result = propUtil.CheckSelectionForGuidance(selection.toList(), (Descriptor)element, getConfiguration());
if (! result) {
return true;
}
Object testObj = selection.getFirstElement();
EReference ref = propUtil.getGuidanceEReference((Guidance)testObj);
if (propUtil.isDynamicAndExclude(testObj, (Descriptor)element, ref, getConfiguration())) {
return true;
}
if (propUtil.isGuidanceDynamic(testObj, (Descriptor)element, getConfiguration())) {
removeGuidances(selection.toList(), false);
return true;
}
return false;
}
protected void syncFreeUpdateBtnStatus(IStructuredSelection selection) {
boolean result = propUtil.CheckSelectionForGuidance(selection.toList(), (Descriptor)element, getConfiguration());
if (!result) {
ctrl_add_1.setEnabled(false);
ctrl_remove_1.setEnabled(false);
} else {
Object testObj = selection.getFirstElement();
EReference ref = propUtil.getGuidanceEReference((Guidance)testObj);
if (propUtil.isDynamicAndExclude(testObj, (Descriptor)element, ref, getConfiguration())) {
ctrl_add_1.setEnabled(true);
ctrl_remove_1.setEnabled(false);
} else {
ctrl_add_1.setEnabled(true);
ctrl_remove_1.setEnabled(true);
}
}
}
public class GuidanceSyncFreeLabelProvider extends AdapterFactoryLabelProvider implements ITableFontProvider {
private DescriptorPropUtil propUtil = DescriptorPropUtil.getDesciptorPropUtil();
private Font systemFont = Display.getCurrent().getSystemFont();
private Font boldFont = null;
private Font boldAndItalicFont = null;
private Descriptor desc;
private MethodConfiguration config;
public GuidanceSyncFreeLabelProvider(AdapterFactory adapterFactory, Descriptor desc, MethodConfiguration config) {
super(adapterFactory);
this.desc = desc;
this.config = config;
boldFont = createFont(SWT.BOLD);
boldAndItalicFont = createFont(SWT.BOLD | SWT.ITALIC);
}
public Font getFont(Object obj, int columnIndex) {
if (propUtil.isGuidanceFromGreenParentLocalList(obj, desc, config)) {
return boldAndItalicFont;
}
if (!propUtil.isGuidanceDynamic(obj, desc, config)) {
return boldFont;
}
return systemFont;
}
public String getColumnText(Object obj, int columnIndex) {
String original = super.getColumnText(obj, columnIndex);
EReference ref = propUtil.getGuidanceEReference((Guidance)obj);
if (propUtil.isDynamicAndExclude(obj, desc, ref, config)) {
return "--<" + original + ">"; //$NON-NLS-1$ //$NON-NLS-2$
}
return original;
}
public void dispose() {
super.dispose();
if (boldFont != null) {
boldFont.dispose();
}
if (boldAndItalicFont != null) {
boldAndItalicFont.dispose();
}
}
private Font createFont(int style) {
FontData[] fontdata = systemFont.getFontData();
for (FontData data : fontdata) {
data.setStyle(style);
}
return new Font(Display.getCurrent(), fontdata);
}
}
}