/*******************************************************************************
* Copyright (c) 2000, 2011 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 API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.ui.preferences.formatter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.dialogs.ContainerCheckedTreeViewer;
import org.eclipse.ui.part.PageBook;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.preferences.formatter.WhiteSpaceOptions.InnerNode;
import org.eclipse.jdt.internal.ui.preferences.formatter.WhiteSpaceOptions.Node;
import org.eclipse.jdt.internal.ui.preferences.formatter.WhiteSpaceOptions.OptionNode;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
public class WhiteSpaceTabPage extends FormatterTabPage {
/**
* Encapsulates a view of the options tree which is structured by
* syntactical element.
*/
private final class SyntaxComponent implements ISelectionChangedListener, ICheckStateListener, IDoubleClickListener {
private final String PREF_NODE_KEY= JavaUI.ID_PLUGIN + "formatter_page.white_space_tab_page.node"; //$NON-NLS-1$
private final List<Node> fIndexedNodeList;
private final List<Node> fTree;
private ContainerCheckedTreeViewer fTreeViewer;
private Composite fComposite;
private Node fLastSelected= null;
public SyntaxComponent() {
fIndexedNodeList= new ArrayList<Node>();
fTree= new WhiteSpaceOptions().createAltTree(fWorkingValues);
WhiteSpaceOptions.makeIndexForNodes(fTree, fIndexedNodeList);
}
public void createContents(final int numColumns, final Composite parent) {
fComposite= new Composite(parent, SWT.NONE);
fComposite.setLayoutData(createGridData(numColumns, GridData.HORIZONTAL_ALIGN_FILL, SWT.DEFAULT));
fComposite.setLayout(createGridLayout(numColumns, false));
createLabel(numColumns, fComposite, FormatterMessages.WhiteSpaceTabPage_insert_space);
fTreeViewer= new ContainerCheckedTreeViewer(fComposite, SWT.SINGLE | SWT.BORDER | SWT.V_SCROLL);
fTreeViewer.setContentProvider(new ITreeContentProvider() {
public Object[] getElements(Object inputElement) {
return ((Collection<?>)inputElement).toArray();
}
public Object[] getChildren(Object parentElement) {
return ((Node)parentElement).getChildren().toArray();
}
public Object getParent(Object element) {
return ((Node)element).getParent();
}
public boolean hasChildren(Object element) {
return ((Node)element).hasChildren();
}
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
public void dispose() {}
});
fTreeViewer.setLabelProvider(new LabelProvider());
fTreeViewer.getControl().setLayoutData(createGridData(numColumns, GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL, SWT.DEFAULT));
fDefaultFocusManager.add(fTreeViewer.getControl());
}
public void initialize() {
fTreeViewer.addCheckStateListener(this);
fTreeViewer.addSelectionChangedListener(this);
fTreeViewer.addDoubleClickListener(this);
fTreeViewer.setInput(fTree);
restoreSelection();
refreshState();
}
public void refreshState() {
final ArrayList<OptionNode> checked= new ArrayList<OptionNode>(100);
for (Iterator<Node> iter= fTree.iterator(); iter.hasNext();)
iter.next().getCheckedLeafs(checked);
fTreeViewer.setGrayedElements(new Object[0]);
fTreeViewer.setCheckedElements(checked.toArray());
fPreview.clear();
if (fLastSelected != null) {
fPreview.addAll(fLastSelected.getSnippets());
}
doUpdatePreview();
}
public void selectionChanged(SelectionChangedEvent event) {
final IStructuredSelection selection= (IStructuredSelection)event.getSelection();
if (selection.isEmpty())
return;
final Node node= (Node)selection.getFirstElement();
if (node == fLastSelected)
return;
fDialogSettings.put(PREF_NODE_KEY, node.index);
fPreview.clear();
fPreview.addAll(node.getSnippets());
doUpdatePreview();
fLastSelected= node;
}
public void checkStateChanged(CheckStateChangedEvent event) {
final Node node= (Node)event.getElement();
node.setChecked(event.getChecked());
doUpdatePreview();
notifyValuesModified();
}
public void restoreSelection() {
int index;
try {
index= fDialogSettings.getInt(PREF_NODE_KEY);
} catch (NumberFormatException ex) {
index= -1;
}
if (index < 0 || index > fIndexedNodeList.size() - 1) {
index= 0;
}
final Node node= fIndexedNodeList.get(index);
if (node != null) {
fTreeViewer.expandToLevel(node, 0);
fTreeViewer.setSelection(new StructuredSelection(new Node [] {node}));
fLastSelected= node;
}
}
public void doubleClick(DoubleClickEvent event) {
final ISelection selection= event.getSelection();
if (selection instanceof IStructuredSelection) {
final Node node= (Node)((IStructuredSelection)selection).getFirstElement();
fTreeViewer.setExpandedState(node, !fTreeViewer.getExpandedState(node));
}
}
public Control getControl() {
return fComposite;
}
}
private final class JavaElementComponent implements ISelectionChangedListener, ICheckStateListener {
private final String PREF_INNER_INDEX= JavaUI.ID_PLUGIN + "formatter_page.white_space.java_view.inner"; //$NON-NLS-1$
private final String PREF_OPTION_INDEX= JavaUI.ID_PLUGIN + "formatter_page.white_space.java_view.option"; //$NON-NLS-1$
private final ArrayList<Node> fIndexedNodeList;
private final ArrayList<Node> fTree;
private InnerNode fLastSelected;
private TreeViewer fInnerViewer;
private CheckboxTableViewer fOptionsViewer;
private Composite fComposite;
public JavaElementComponent() {
fIndexedNodeList= new ArrayList<Node>();
fTree= new WhiteSpaceOptions().createTreeByJavaElement(fWorkingValues);
WhiteSpaceOptions.makeIndexForNodes(fTree, fIndexedNodeList);
}
public void createContents(int numColumns, Composite parent) {
fComposite= new Composite(parent, SWT.NONE);
fComposite.setLayoutData(createGridData(numColumns, GridData.HORIZONTAL_ALIGN_FILL, SWT.DEFAULT));
fComposite.setLayout(createGridLayout(numColumns, false));
createLabel(numColumns, fComposite, FormatterMessages.WhiteSpaceTabPage_insert_space, GridData.HORIZONTAL_ALIGN_BEGINNING);
final SashForm sashForm= new SashForm(fComposite, SWT.VERTICAL);
sashForm.setLayoutData(createGridData(numColumns, GridData.FILL_BOTH, SWT.DEFAULT));
fInnerViewer= new TreeViewer(sashForm, SWT.SINGLE | SWT.BORDER | SWT.V_SCROLL);
fInnerViewer.setContentProvider(new ITreeContentProvider() {
public Object[] getElements(Object inputElement) {
return ((Collection<?>)inputElement).toArray();
}
public Object[] getChildren(Object parentElement) {
final List<Node> children= ((Node)parentElement).getChildren();
final ArrayList<InnerNode> innerChildren= new ArrayList<InnerNode>();
for (final Iterator<Node> iter= children.iterator(); iter.hasNext();) {
final Object o= iter.next();
if (o instanceof InnerNode)
innerChildren.add((InnerNode) o);
}
return innerChildren.toArray();
}
public Object getParent(Object element) {
if (element instanceof InnerNode)
return ((InnerNode)element).getParent();
return null;
}
public boolean hasChildren(Object element) {
final List<Node> children= ((Node)element).getChildren();
for (final Iterator<Node> iter= children.iterator(); iter.hasNext();)
if (iter.next() instanceof InnerNode) return true;
return false;
}
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
public void dispose() {}
});
fInnerViewer.setLabelProvider(new LabelProvider());
final GridData innerGd= createGridData(numColumns, GridData.HORIZONTAL_ALIGN_FILL | GridData.FILL_VERTICAL, SWT.DEFAULT);
innerGd.heightHint= fPixelConverter.convertHeightInCharsToPixels(3);
fInnerViewer.getControl().setLayoutData(innerGd);
fOptionsViewer= CheckboxTableViewer.newCheckList(sashForm, SWT.SINGLE | SWT.BORDER | SWT.H_SCROLL);
fOptionsViewer.setContentProvider(new ArrayContentProvider());
fOptionsViewer.setLabelProvider(new LabelProvider());
final GridData optionsGd= createGridData(numColumns, GridData.HORIZONTAL_ALIGN_FILL | GridData.FILL_VERTICAL, SWT.DEFAULT);
optionsGd.heightHint= fPixelConverter.convertHeightInCharsToPixels(3);
fOptionsViewer.getControl().setLayoutData(optionsGd);
fDefaultFocusManager.add(fInnerViewer.getControl());
fDefaultFocusManager.add(fOptionsViewer.getControl());
fInnerViewer.setInput(fTree);
}
public void refreshState() {
if (fLastSelected != null) {
innerViewerChanged(fLastSelected);
}
}
public void initialize() {
fInnerViewer.addSelectionChangedListener(this);
fOptionsViewer.addSelectionChangedListener(this);
fOptionsViewer.addCheckStateListener(this);
restoreSelections();
refreshState();
}
private void restoreSelections() {
Node node;
final int innerIndex= getValidatedIndex(PREF_INNER_INDEX);
node= fIndexedNodeList.get(innerIndex);
if (node instanceof InnerNode) {
fInnerViewer.expandToLevel(node, 0);
fInnerViewer.setSelection(new StructuredSelection(new Object[] {node}));
fLastSelected= (InnerNode)node;
}
final int optionIndex= getValidatedIndex(PREF_OPTION_INDEX);
node= fIndexedNodeList.get(optionIndex);
if (node instanceof OptionNode) {
fOptionsViewer.setSelection(new StructuredSelection(new Object[] {node}));
}
}
private int getValidatedIndex(String key) {
int index;
try {
index= fDialogSettings.getInt(key);
} catch (NumberFormatException ex) {
index= 0;
}
if (index < 0 || index > fIndexedNodeList.size() - 1) {
index= 0;
}
return index;
}
public Control getControl() {
return fComposite;
}
public void selectionChanged(SelectionChangedEvent event) {
final IStructuredSelection selection= (IStructuredSelection)event.getSelection();
if (selection.isEmpty() || !(selection.getFirstElement() instanceof Node))
return;
final Node selected= (Node)selection.getFirstElement();
if (selected == null || selected == fLastSelected)
return;
if (event.getSource() == fInnerViewer && selected instanceof InnerNode) {
fLastSelected= (InnerNode)selected;
fDialogSettings.put(PREF_INNER_INDEX, selected.index);
innerViewerChanged((InnerNode)selected);
}
else if (event.getSource() == fOptionsViewer && selected instanceof OptionNode)
fDialogSettings.put(PREF_OPTION_INDEX, selected.index);
}
private void innerViewerChanged(InnerNode selectedNode) {
final List<Node> children= selectedNode.getChildren();
final ArrayList<OptionNode> optionsChildren= new ArrayList<OptionNode>();
for (final Iterator<Node> iter= children.iterator(); iter.hasNext();) {
final Object o= iter.next();
if (o instanceof OptionNode)
optionsChildren.add((OptionNode) o);
}
fOptionsViewer.setInput(optionsChildren.toArray());
for (final Iterator<OptionNode> iter= optionsChildren.iterator(); iter.hasNext();) {
final OptionNode child= iter.next();
fOptionsViewer.setChecked(child, child.getChecked());
}
fPreview.clear();
fPreview.addAll(selectedNode.getSnippets());
doUpdatePreview();
}
public void checkStateChanged(CheckStateChangedEvent event) {
final OptionNode option= (OptionNode)event.getElement();
if (option != null)
option.setChecked(event.getChecked());
doUpdatePreview();
notifyValuesModified();
}
}
/**
* This component switches between the two view and is responsible for delegating
* the appropriate update requests.
*/
private final class SwitchComponent extends SelectionAdapter {
private final String PREF_VIEW_KEY= JavaUI.ID_PLUGIN + "formatter_page.white_space_tab_page.view"; //$NON-NLS-1$
private final String [] fItems= new String [] {
FormatterMessages.WhiteSpaceTabPage_sort_by_java_element,
FormatterMessages.WhiteSpaceTabPage_sort_by_syntax_element
};
private Combo fSwitchCombo;
private PageBook fPageBook;
private final SyntaxComponent fSyntaxComponent;
private final JavaElementComponent fJavaElementComponent;
public SwitchComponent() {
fSyntaxComponent= new SyntaxComponent();
fJavaElementComponent= new JavaElementComponent();
}
@Override
public void widgetSelected(SelectionEvent e) {
final int index= fSwitchCombo.getSelectionIndex();
if (index == 0) {
fDialogSettings.put(PREF_VIEW_KEY, false);
fJavaElementComponent.refreshState();
fPageBook.showPage(fJavaElementComponent.getControl());
}
else if (index == 1) {
fDialogSettings.put(PREF_VIEW_KEY, true);
fSyntaxComponent.refreshState();
fPageBook.showPage(fSyntaxComponent.getControl());
}
}
public void createContents(int numColumns, Composite parent) {
fPageBook= new PageBook(parent, SWT.NONE);
fPageBook.setLayoutData(createGridData(numColumns, GridData.FILL_BOTH, SWT.DEFAULT));
fJavaElementComponent.createContents(numColumns, fPageBook);
fSyntaxComponent.createContents(numColumns, fPageBook);
fSwitchCombo= new Combo(parent, SWT.READ_ONLY);
SWTUtil.setDefaultVisibleItemCount(fSwitchCombo);
final GridData gd= createGridData(numColumns, GridData.HORIZONTAL_ALIGN_END, SWT.DEFAULT);
fSwitchCombo.setLayoutData(gd);
fSwitchCombo.setItems(fItems);
}
public void initialize() {
fSwitchCombo.addSelectionListener(this);
fJavaElementComponent.initialize();
fSyntaxComponent.initialize();
restoreSelection();
}
private void restoreSelection() {
final boolean selectSyntax= fDialogSettings.getBoolean(PREF_VIEW_KEY);
if (selectSyntax) {
fSyntaxComponent.refreshState();
fSwitchCombo.setText(fItems[1]);
fPageBook.showPage(fSyntaxComponent.getControl());
} else {
fJavaElementComponent.refreshState();
fSwitchCombo.setText(fItems[0]);
fPageBook.showPage(fJavaElementComponent.getControl());
}
}
}
private final SwitchComponent fSwitchComponent;
protected final IDialogSettings fDialogSettings;
protected SnippetPreview fPreview;
/**
* Create a new white space dialog page.
* @param modifyDialog
* @param workingValues
*/
public WhiteSpaceTabPage(ModifyDialog modifyDialog, Map<String, String> workingValues) {
super(modifyDialog, workingValues);
fDialogSettings= JavaPlugin.getDefault().getDialogSettings();
fSwitchComponent= new SwitchComponent();
}
@Override
protected void doCreatePreferences(Composite composite, int numColumns) {
fSwitchComponent.createContents(numColumns, composite);
}
@Override
protected void initializePage() {
fSwitchComponent.initialize();
}
@Override
protected JavaPreview doCreateJavaPreview(Composite parent) {
fPreview= new SnippetPreview(fWorkingValues, parent);
return fPreview;
}
@Override
protected void doUpdatePreview() {
super.doUpdatePreview();
fPreview.update();
}
}