| /******************************************************************************* |
| * Copyright (c) 2010 BSI Business Systems Integration AG. |
| * 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: |
| * BSI Business Systems Integration AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.scout.sdk.ui.internal.wizard.newproject; |
| |
| import java.beans.PropertyChangeListener; |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.MultiStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.scout.commons.StringUtility; |
| import org.eclipse.scout.sdk.Texts; |
| import org.eclipse.scout.sdk.compatibility.PlatformVersionUtility; |
| import org.eclipse.scout.sdk.extensions.runtime.classes.IRuntimeClasses; |
| import org.eclipse.scout.sdk.operation.project.AbstractScoutProjectNewOperation; |
| import org.eclipse.scout.sdk.operation.project.CreateTargetProjectOperation; |
| import org.eclipse.scout.sdk.operation.project.IScoutProjectNewOperation; |
| import org.eclipse.scout.sdk.ui.extensions.bundle.ScoutBundleExtensionPoint; |
| import org.eclipse.scout.sdk.ui.extensions.bundle.ScoutBundleUiExtension; |
| import org.eclipse.scout.sdk.ui.fields.StyledTextField; |
| import org.eclipse.scout.sdk.ui.fields.TextField; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.CheckableTree; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.ICheckStateListener; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.ITreeNode; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.ITreeNodeFilter; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.NodeFilters; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.TreeNode; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.TreeUtility; |
| import org.eclipse.scout.sdk.ui.fields.proposal.ContentProposalEvent; |
| import org.eclipse.scout.sdk.ui.fields.proposal.IProposalAdapterListener; |
| import org.eclipse.scout.sdk.ui.fields.proposal.ProposalTextField; |
| import org.eclipse.scout.sdk.ui.fields.proposal.SimpleLabelProvider; |
| import org.eclipse.scout.sdk.ui.fields.proposal.SimpleProposal; |
| import org.eclipse.scout.sdk.ui.fields.proposal.SimpleProposalProvider; |
| import org.eclipse.scout.sdk.ui.internal.ScoutSdkUi; |
| import org.eclipse.scout.sdk.ui.wizard.project.AbstractProjectNewWizardPage; |
| import org.eclipse.scout.sdk.ui.wizard.project.IScoutProjectWizardPage; |
| import org.eclipse.scout.sdk.util.NamingUtility; |
| import org.eclipse.scout.sdk.util.PropertyMap; |
| import org.eclipse.scout.sdk.util.ScoutUtility; |
| import org.eclipse.scout.sdk.util.jdt.JdtUtility; |
| import org.eclipse.scout.sdk.util.resources.ResourceUtility; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.layout.FormAttachment; |
| import org.eclipse.swt.layout.FormData; |
| import org.eclipse.swt.layout.FormLayout; |
| 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.Control; |
| import org.eclipse.swt.widgets.Group; |
| import org.eclipse.swt.widgets.Label; |
| import org.osgi.framework.Version; |
| |
| /** |
| * <h3>ScoutProjectNewWizardPage</h3> |
| * |
| * @author Andreas Hoegger |
| * @since 1.0.8 06.03.2010 |
| */ |
| |
| public class ScoutProjectNewWizardPage extends AbstractProjectNewWizardPage implements IScoutProjectWizardPage { |
| private static final String TYPE_BUNDLE = "bundle"; |
| |
| private static final String PROP_CURR_TARGET = "curr"; |
| private static final String PROP_RECOMMENDED_TARGET = "recomm"; |
| private static final String PROP_KEEP_CURRENT = "keep"; |
| private static final String PROP_PLATFORM_VERSION = "vers"; |
| |
| protected StyledTextField m_projectNameField; |
| protected StyledTextField m_postFixField; |
| protected CheckableTree m_bundleTree; |
| protected ITreeNode m_invisibleRootNode; |
| |
| protected ProposalTextField m_eclipseTargetPlatform; |
| protected Button m_useDefaultScoutPreferences; |
| protected StyledTextField m_projectAliasNameField; |
| |
| public ScoutProjectNewWizardPage() { |
| super(ScoutProjectNewWizardPage.class.getName()); |
| setTitle(Texts.get("CreateAScoutProject")); |
| setDescription(Texts.get("CreateScoutProjectHelpMsg")); |
| setUseDefaultJdtPrefsInternal(true); |
| } |
| |
| @Override |
| protected void createContent(Composite parent) { |
| m_projectNameField = getFieldToolkit().createStyledTextField(parent, Texts.get("ProjectName")); |
| m_projectNameField.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| try { |
| setStateChanging(true); |
| setProjectNameInternal(m_projectNameField.getText()); |
| updateBundleNames(); |
| } |
| finally { |
| setStateChanging(false); |
| } |
| } |
| }); |
| |
| m_postFixField = getFieldToolkit().createStyledTextField(parent, Texts.get("ProjectPostfix")); |
| m_postFixField.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| try { |
| setStateChanging(true); |
| setProjectNamePostfixInternal(m_postFixField.getText()); |
| updateBundleNames(); |
| } |
| finally { |
| setStateChanging(false); |
| } |
| } |
| }); |
| m_invisibleRootNode = buildBundleTree(); |
| m_bundleTree = new CheckableTree(parent, m_invisibleRootNode); |
| |
| m_bundleTree.addCheckSelectionListener(new ICheckStateListener() { |
| @Override |
| public void fireNodeCheckStateChanged(ITreeNode node, boolean checkState) { |
| setProperty(PROP_SELECTED_BUNDLES, m_bundleTree.getCheckedNodes()); |
| if (!node.isEnabled()) { |
| checkState = false; |
| } |
| ScoutBundleUiExtension ext = (ScoutBundleUiExtension) node.getData(); |
| if (ext != null) { |
| ext.getNewScoutBundleHandler().bundleSelectionChanged(getWizard(), checkState); |
| } |
| |
| pingStateChanging(); |
| } |
| }); |
| |
| m_bundleTree.setChecked(TreeUtility.findNodes(m_invisibleRootNode, new P_InitialCheckNodesFilter())); |
| |
| for (ScoutBundleUiExtension e : ScoutBundleExtensionPoint.getExtensions()) { |
| e.getNewScoutBundleHandler().init(getWizard(), e); |
| } |
| |
| Control aliasGroup = createPropertiesGroup(parent); |
| m_projectNameField.setFocus(); |
| // layout |
| parent.setLayout(new GridLayout(1, true)); |
| |
| m_projectNameField.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL)); |
| m_postFixField.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL)); |
| m_bundleTree.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.GRAB_VERTICAL | GridData.FILL_BOTH)); |
| aliasGroup.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL)); |
| } |
| |
| private ITreeNode buildBundleTree() { |
| ITreeNode rootNode = new TreeNode(CheckableTree.TYPE_ROOT, "root"); |
| rootNode.setVisible(false); |
| |
| for (ScoutBundleUiExtension e : ScoutBundleExtensionPoint.getExtensions()) { |
| TreeUtility.createNode(rootNode, TYPE_BUNDLE, e.getBundleName(), e.getIcon(), e.getOrderNumber(), e, false); |
| } |
| return rootNode; |
| } |
| |
| private void updateBundleNames() { |
| for (ITreeNode node : TreeUtility.findNodes(m_invisibleRootNode, NodeFilters.getVisible())) { |
| ScoutBundleUiExtension ext = (ScoutBundleUiExtension) node.getData(); |
| if (ext != null && node.isEnabled()) { |
| node.setText(AbstractScoutProjectNewOperation.getPluginName(getProjectName(), getProjectNamePostfix(), ext.getBundleName())); |
| } |
| } |
| |
| m_bundleTree.getTreeViewer().refresh(); |
| String alias = ""; |
| if (getProjectName() != null) { |
| int dotIndex = getProjectName().lastIndexOf('.'); |
| if (dotIndex > 0 && dotIndex < getProjectName().length() - 1) { |
| alias = getProjectName().substring(dotIndex + 1); |
| } |
| } |
| String pf = getProjectNamePostfix(); |
| if (pf != null) { |
| pf = pf.trim(); |
| if (pf.length() > 1) { |
| alias += NamingUtility.ensureStartWithUpperCase(pf); |
| } |
| } |
| m_projectAliasNameField.setText(alias); |
| } |
| |
| protected SimpleProposal[] getTargetPlatformProposals() { |
| final String RECOMMENDED_VERSION = "3.8"; |
| final String[][] supportedPlatforms = new String[][]{{"Indigo", "3.7"}, {"Juno", "3.8"}, {"Mars", "4.5"}}; |
| ArrayList<SimpleProposal> ret = new ArrayList<SimpleProposal>(supportedPlatforms.length); |
| for (String[] platform : supportedPlatforms) { |
| String codeName = platform[0]; |
| String ver = platform[1]; |
| boolean isCurrent = isCurrentPlatform(ver); |
| boolean isRecommended = Boolean.valueOf(RECOMMENDED_VERSION.equals(ver)); |
| |
| StringBuilder txt = new StringBuilder("New Eclipse "); |
| txt.append(codeName).append(" Target (").append(ver); |
| if (isCurrent) { |
| txt.append(", ").append(Texts.get("current")); |
| } |
| if (isRecommended) { |
| txt.append(", ").append(Texts.get("recommended")); |
| } |
| txt.append(")"); |
| SimpleProposal prop = new SimpleProposal(txt.toString(), null); |
| prop.setData(PROP_CURR_TARGET, Boolean.valueOf(isCurrent)); |
| prop.setData(PROP_RECOMMENDED_TARGET, isRecommended); |
| prop.setData(PROP_PLATFORM_VERSION, ver); |
| prop.setData(PROP_KEEP_CURRENT, Boolean.FALSE); |
| ret.add(prop); |
| } |
| |
| // keep current target |
| if (JdtUtility.getNewestBundleInActiveTargetPlatform(IRuntimeClasses.ScoutClientBundleId) != null && JdtUtility.getNewestBundleInActiveTargetPlatform(IRuntimeClasses.ScoutServerBundleId) != null |
| && JdtUtility.getNewestBundleInActiveTargetPlatform(IRuntimeClasses.ScoutSharedBundleId) != null && JdtUtility.getNewestBundleInActiveTargetPlatform(IRuntimeClasses.ScoutUiSwingBundleId) != null |
| && JdtUtility.getNewestBundleInActiveTargetPlatform(IRuntimeClasses.ScoutUiSwtBundleId) != null) { |
| String ver = null; |
| Version targetPlatformVersion = JdtUtility.getTargetPlatformVersion(); |
| if (targetPlatformVersion == null) { |
| ver = RECOMMENDED_VERSION; |
| } |
| else { |
| ver = targetPlatformVersion.getMajor() + "." + targetPlatformVersion.getMinor(); |
| } |
| |
| SimpleProposal prop = new SimpleProposal(Texts.get("KeepCurrentTarget", ver), null); |
| prop.setData(PROP_CURR_TARGET, Boolean.FALSE); |
| prop.setData(PROP_RECOMMENDED_TARGET, Boolean.FALSE); |
| prop.setData(PROP_KEEP_CURRENT, Boolean.TRUE); |
| prop.setData(PROP_PLATFORM_VERSION, ver); |
| ret.add(prop); |
| } |
| |
| return ret.toArray(new SimpleProposal[ret.size()]); |
| } |
| |
| protected boolean isCurrentPlatform(String ver) { |
| String curPlatform = PlatformVersionUtility.getPlatformVersion().toString(); |
| return curPlatform.startsWith(ver); |
| } |
| |
| protected void setTargetPlatformDefaultSelection(SimpleProposal[] targetPlatformProposals) { |
| SimpleProposal recommended = null; |
| SimpleProposal current = null; |
| for (SimpleProposal p : targetPlatformProposals) { |
| Boolean reco = (Boolean) p.getData(PROP_RECOMMENDED_TARGET); |
| if (reco.booleanValue()) { |
| recommended = p; |
| } |
| Boolean curr = (Boolean) p.getData(PROP_CURR_TARGET); |
| if (curr.booleanValue()) { |
| current = p; |
| } |
| } |
| if (current != null) { |
| m_eclipseTargetPlatform.acceptProposal(current); |
| setTargetPlatformVersionInternal((String) current.getData(PROP_PLATFORM_VERSION)); |
| } |
| else if (recommended != null) { |
| m_eclipseTargetPlatform.acceptProposal(recommended); |
| setTargetPlatformVersionInternal((String) recommended.getData(PROP_PLATFORM_VERSION)); |
| } |
| } |
| |
| protected Control createPropertiesGroup(Composite parent) { |
| Group group = new Group(parent, SWT.SHADOW_IN); |
| group.setText(Texts.get("ProjectProperties")); |
| |
| SimpleProposal[] targetPlatformProposals = getTargetPlatformProposals(); |
| SimpleProposalProvider provider = new SimpleProposalProvider(targetPlatformProposals); |
| m_eclipseTargetPlatform = getFieldToolkit().createProposalField(group, Texts.get("EclipsePlatform"), SWT.NONE); |
| m_eclipseTargetPlatform.setContentProvider(provider); |
| m_eclipseTargetPlatform.setLabelProvider(new SimpleLabelProvider()); |
| m_eclipseTargetPlatform.addProposalAdapterListener(new IProposalAdapterListener() { |
| @Override |
| public void proposalAccepted(ContentProposalEvent event) { |
| SimpleProposal proposal = (SimpleProposal) event.proposal; |
| if (proposal != null) { |
| setTargetPlatformVersionInternal((String) proposal.getData(PROP_PLATFORM_VERSION)); |
| Object keepCurrent = proposal.getData(PROP_KEEP_CURRENT); |
| if (keepCurrent instanceof Boolean) { |
| setKeepCurrentTarget(((Boolean) keepCurrent).booleanValue()); |
| } |
| else { |
| setKeepCurrentTarget(false); |
| } |
| } |
| else { |
| setTargetPlatformVersionInternal(null); |
| setKeepCurrentTarget(false); |
| } |
| pingStateChanging(); |
| } |
| }); |
| setTargetPlatformDefaultSelection(targetPlatformProposals); |
| |
| Composite prefButton = createPreferencesButton(group); |
| |
| m_projectAliasNameField = getFieldToolkit().createStyledTextField(group, Texts.get("ProjectAlias")); |
| m_projectAliasNameField.addModifyListener(new ModifyListener() { |
| @Override |
| public void modifyText(ModifyEvent e) { |
| setProjectAliasInternal(m_projectAliasNameField.getText()); |
| pingStateChanging(); |
| } |
| }); |
| Composite infoLabel = createInfoLabel(group); |
| |
| // layout |
| group.setLayout(new GridLayout(1, true)); |
| |
| infoLabel.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL)); |
| m_eclipseTargetPlatform.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL)); |
| m_projectAliasNameField.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL)); |
| prefButton.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL)); |
| |
| return group; |
| } |
| |
| protected Composite createPreferencesButton(Composite p) { |
| Composite parent = new Composite(p, SWT.NONE); |
| Label lbl = new Label(parent, SWT.NONE); |
| |
| // layout |
| parent.setLayout(new FormLayout()); |
| FormData labelData = new FormData(); |
| labelData.top = new FormAttachment(0, 4); |
| labelData.left = new FormAttachment(0, 0); |
| labelData.right = new FormAttachment(TextField.DEFAULT_LABEL_PERCENTAGE, 0); |
| labelData.bottom = new FormAttachment(100, 0); |
| lbl.setLayoutData(labelData); |
| |
| m_useDefaultScoutPreferences = new Button(parent, SWT.CHECK); |
| m_useDefaultScoutPreferences.setText(Texts.get("UseDefaultScoutJDTPreferences")); |
| m_useDefaultScoutPreferences.setSelection(isUseDefaultJdtPrefs()); |
| m_useDefaultScoutPreferences.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| setUseDefaultJdtPrefsInternal(m_useDefaultScoutPreferences.getSelection()); |
| pingStateChanging(); |
| } |
| }); |
| |
| FormData textData = new FormData(); |
| textData.top = new FormAttachment(0, 0); |
| textData.left = new FormAttachment(lbl, 5); |
| textData.right = new FormAttachment(100, 0); |
| textData.bottom = new FormAttachment(100, 0); |
| m_useDefaultScoutPreferences.setLayoutData(textData); |
| return parent; |
| } |
| |
| protected Composite createInfoLabel(Composite p) { |
| Composite parent = new Composite(p, SWT.NONE); |
| Label lbl = new Label(parent, SWT.NONE); |
| |
| // layout |
| parent.setLayout(new FormLayout()); |
| FormData labelData = new FormData(); |
| labelData.top = new FormAttachment(0, 4); |
| labelData.left = new FormAttachment(0, 0); |
| labelData.right = new FormAttachment(TextField.DEFAULT_LABEL_PERCENTAGE, 0); |
| labelData.bottom = new FormAttachment(100, 0); |
| lbl.setLayoutData(labelData); |
| |
| Label label = new Label(parent, SWT.NONE); |
| label.setText(Texts.get("ProjectAliasHelp")); |
| FormData textData = new FormData(); |
| textData.top = new FormAttachment(0, 0); |
| textData.left = new FormAttachment(lbl, 5); |
| textData.right = new FormAttachment(100, 0); |
| textData.bottom = new FormAttachment(100, 0); |
| label.setLayoutData(textData); |
| return parent; |
| } |
| |
| @Override |
| public void putProperties(PropertyMap properties) { |
| // put properties of the text fields of this page (project name, etc) |
| String postfix = getProjectNamePostfix(); |
| if (postfix != null) { |
| postfix = postfix.trim(); |
| if (postfix.length() == 0) { |
| postfix = null; |
| } |
| } |
| properties.setProperty(IScoutProjectNewOperation.PROP_PROJECT_NAME, getProjectName().trim()); |
| properties.setProperty(IScoutProjectNewOperation.PROP_PROJECT_NAME_POSTFIX, postfix); |
| properties.setProperty(IScoutProjectNewOperation.PROP_PROJECT_ALIAS, getProjectAlias().trim()); |
| properties.setProperty(IScoutProjectNewOperation.PROP_TARGET_PLATFORM_VERSION, new Version(getTargetPlatformVersion())); |
| properties.setProperty(IScoutProjectNewOperation.PROP_USE_DEFAULT_JDT_PREFS, isUseDefaultJdtPrefs()); |
| properties.setProperty(IScoutProjectNewOperation.PROP_KEEP_CURRENT_TARGET, isKeepCurrentTarget()); |
| |
| // go through all node extensions and put properties which node has been checked |
| ITreeNode[] nodes = TreeUtility.findNodes(m_invisibleRootNode, NodeFilters.getAcceptAll()); |
| HashSet<String> checkedNodeExtensionIds = new HashSet<String>(nodes.length); |
| for (ITreeNode node : nodes) { |
| ScoutBundleUiExtension ext = (ScoutBundleUiExtension) node.getData(); |
| if (ext != null) { |
| if (m_bundleTree.isChecked(node) && node.isEnabled() && node.isVisible()) { |
| checkedNodeExtensionIds.add(ext.getBundleId()); |
| } |
| ext.getNewScoutBundleHandler().putProperties(getWizard(), properties); |
| } |
| } |
| properties.setProperty(IScoutProjectNewOperation.PROP_PROJECT_CHECKED_NODES, checkedNodeExtensionIds); |
| } |
| |
| @Override |
| public void performHelp() { |
| //TODO: remove external link and use eclipse help instead |
| ResourceUtility.showUrlInBrowser("https://wiki.eclipse.org/Scout/HowTo/5.0/Create_a_new_project#Step_1"); |
| } |
| |
| @Override |
| public ScoutProjectNewWizard getWizard() { |
| return (ScoutProjectNewWizard) super.getWizard(); |
| } |
| |
| @Override |
| protected void validatePage(MultiStatus multiStatus) { |
| multiStatus.add(getStatusProjectName()); |
| multiStatus.add(getStatusProjectPostfix()); |
| multiStatus.add(getStatusProjectAlias()); |
| multiStatus.add(getStatusTargetPlatform()); |
| multiStatus.add(getStatusTargetProject()); |
| for (ITreeNode node : TreeUtility.findNodes(m_invisibleRootNode, NodeFilters.getVisible())) { |
| if (m_bundleTree.isChecked(node)) { |
| ScoutBundleUiExtension ext = (ScoutBundleUiExtension) node.getData(); |
| if (ext != null) { |
| multiStatus.add(ext.getNewScoutBundleHandler().getStatus(getWizard())); |
| } |
| } |
| } |
| } |
| |
| protected IStatus getStatusTargetPlatform() { |
| if (StringUtility.isNullOrEmpty(getTargetPlatformVersion())) { |
| return new Status(IStatus.ERROR, ScoutSdkUi.PLUGIN_ID, Texts.get("PleaseChooseATargetPlatform")); |
| } |
| |
| SimpleProposal p = (SimpleProposal) m_eclipseTargetPlatform.getSelectedProposal(); |
| |
| // info that current platform is used |
| boolean keepCurrent = ((Boolean) p.getData(PROP_KEEP_CURRENT)).booleanValue(); |
| if (keepCurrent) { |
| return new Status(IStatus.WARNING, ScoutSdkUi.PLUGIN_ID, Texts.get("TheCurrentlyActiveTargetPlatformWillBeUsed")); |
| } |
| |
| // info that platform will be downloaded |
| boolean isCurrent = ((Boolean) p.getData(PROP_CURR_TARGET)).booleanValue(); |
| if (!isCurrent) { |
| return new Status(IStatus.INFO, ScoutSdkUi.PLUGIN_ID, Texts.get("ACompleteEclipsePlatformWillBeDownloaded")); |
| } |
| return Status.OK_STATUS; |
| } |
| |
| protected IStatus getStatusProjectPostfix() { |
| if (StringUtility.isNullOrEmpty(getProjectNamePostfix())) { |
| return Status.OK_STATUS; |
| } |
| else if (getProjectNamePostfix().matches("[a-zA-Z]{1}[a-zA-Z0-9]*[a-zA-Z]{1}")) { |
| return Status.OK_STATUS; |
| } |
| else { |
| return new Status(IStatus.ERROR, ScoutSdkUi.PLUGIN_ID, Texts.get("ProjectPostfixIsNotValid")); |
| } |
| } |
| |
| protected IStatus getStatusTargetProject() { |
| String targetPluginName = AbstractScoutProjectNewOperation.getPluginName(getProjectName(), getProjectNamePostfix(), CreateTargetProjectOperation.TARGET_PROJECT_NAME_SUFFIX); |
| return ScoutUtility.validateNewBundleName(targetPluginName); |
| } |
| |
| protected IStatus getStatusProjectName() { |
| for (ITreeNode node : TreeUtility.findNodes(m_invisibleRootNode, NodeFilters.getVisible())) { |
| if (node.isEnabled() && m_bundleTree.isChecked(node)) { |
| IStatus s = ScoutUtility.validateNewBundleName(node.getText()); |
| if (!s.isOK()) { |
| return s; |
| } |
| } |
| } |
| return Status.OK_STATUS; |
| } |
| |
| protected IStatus getStatusProjectAlias() { |
| if (StringUtility.isNullOrEmpty(getProjectAlias())) { |
| return new Status(IStatus.ERROR, ScoutSdkUi.PLUGIN_ID, Texts.get("ProjectAliasMissing")); |
| } |
| if (getProjectAlias().matches("[a-zA-Z]{1}[a-zA-Z0-9]*[a-zA-Z]{1}")) { |
| return Status.OK_STATUS; |
| } |
| else { |
| return new Status(IStatus.ERROR, ScoutSdkUi.PLUGIN_ID, "Project alias is not valid."); |
| } |
| } |
| |
| @Override |
| public void addPropertyChangeListener(PropertyChangeListener listener) { |
| super.addPropertyChangeListener(listener); |
| } |
| |
| @Override |
| public void removePropertyChangeListener(PropertyChangeListener listener) { |
| super.removePropertyChangeListener(listener); |
| } |
| |
| @Override |
| public boolean isBundleNodesSelected(String... extensionIds) { |
| ITreeNode[] nodes = TreeUtility.findNodes(m_invisibleRootNode, new P_NodeByExtensionIdFilter(extensionIds)); |
| for (ITreeNode n : nodes) { |
| if (!m_bundleTree.isChecked(n)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public void setBundleNodeSelected(boolean selected, String... extensionIds) { |
| ITreeNode[] nodes = TreeUtility.findNodes(m_invisibleRootNode, new P_NodeByExtensionIdFilter(extensionIds)); |
| for (ITreeNode n : nodes) { |
| m_bundleTree.setChecked(n, selected); |
| } |
| } |
| |
| @Override |
| public void setBundleNodeAvailable(boolean enabled, boolean visible, String... extensionIds) { |
| ITreeNode[] nodes = TreeUtility.findNodes(m_invisibleRootNode, new P_NodeByExtensionIdFilter(extensionIds)); |
| for (ITreeNode n : nodes) { |
| n.setEnabled(enabled); |
| n.setVisible(visible); |
| } |
| } |
| |
| @Override |
| public boolean hasSelectedBundle(String... types) { |
| ITreeNode[] nodes = TreeUtility.findNodes(m_invisibleRootNode, new P_NodeByBundleTypeFilter(types)); |
| for (ITreeNode n : nodes) { |
| if (m_bundleTree.isChecked(n)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public String getTargetPlatformVersion() { |
| return getPropertyString(PROP_ECLIPSE_TARGET_PLATFORM); |
| } |
| |
| private void setTargetPlatformVersionInternal(String version) { |
| setPropertyString(PROP_ECLIPSE_TARGET_PLATFORM, version); |
| } |
| |
| public boolean isKeepCurrentTarget() { |
| return getPropertyBool(PROP_KEEP_CURRENT_TARGET); |
| } |
| |
| private void setKeepCurrentTarget(boolean v) { |
| setPropertyBool(PROP_KEEP_CURRENT_TARGET, v); |
| } |
| |
| @Override |
| public String getProjectName() { |
| return getPropertyString(PROP_PROJECT_NAME); |
| } |
| |
| public void setProjectName(String projectName) { |
| try { |
| setStateChanging(true); |
| setProjectNameInternal(projectName); |
| if (isControlCreated()) { |
| m_projectNameField.setText(projectName); |
| } |
| } |
| finally { |
| setStateChanging(false); |
| } |
| } |
| |
| private void setProjectNameInternal(String projectName) { |
| setPropertyString(PROP_PROJECT_NAME, projectName); |
| } |
| |
| @Override |
| public String getProjectNamePostfix() { |
| return getPropertyString(PROP_PROJECT_NAME_POSTFIX); |
| } |
| |
| public void setProjectNamePostfix(String projectPostfix) { |
| try { |
| setStateChanging(true); |
| setProjectNamePostfixInternal(projectPostfix); |
| if (isControlCreated()) { |
| m_postFixField.setText(projectPostfix); |
| } |
| } |
| finally { |
| setStateChanging(false); |
| } |
| } |
| |
| private void setProjectNamePostfixInternal(String projectPostfix) { |
| setPropertyString(PROP_PROJECT_NAME_POSTFIX, projectPostfix); |
| } |
| |
| @Override |
| public String getProjectAlias() { |
| return getPropertyString(PROP_PROJECT_ALIAS); |
| } |
| |
| public void setProjectAlias(String projectAlias) { |
| try { |
| setStateChanging(true); |
| setProjectAliasInternal(projectAlias); |
| if (isControlCreated()) { |
| m_projectAliasNameField.setText(projectAlias); |
| } |
| } |
| finally { |
| setStateChanging(false); |
| } |
| } |
| |
| private void setProjectAliasInternal(String alias) { |
| setPropertyString(PROP_PROJECT_ALIAS, alias); |
| } |
| |
| public boolean isUseDefaultJdtPrefs() { |
| return getPropertyBool(PROP_USE_DEFAULT_JDT_PREFS); |
| } |
| |
| public void setUseDefaultJdtPrefs(boolean useDefaultJdtPrefs) { |
| try { |
| setStateChanging(true); |
| setUseDefaultJdtPrefsInternal(useDefaultJdtPrefs); |
| if (isControlCreated()) { |
| m_useDefaultScoutPreferences.setSelection(useDefaultJdtPrefs); |
| } |
| } |
| finally { |
| setStateChanging(false); |
| } |
| } |
| |
| private void setUseDefaultJdtPrefsInternal(boolean useDefaultJdtPrefs) { |
| setPropertyBool(PROP_USE_DEFAULT_JDT_PREFS, useDefaultJdtPrefs); |
| } |
| |
| private class P_InitialCheckNodesFilter implements ITreeNodeFilter { |
| @Override |
| public boolean accept(ITreeNode node) { |
| return TYPE_BUNDLE.equals(node.getType()); |
| } |
| } // end class P_InitialCheckNodesFilter |
| |
| private class P_NodeByExtensionIdFilter implements ITreeNodeFilter { |
| private final HashSet<String> m_ids = new HashSet<String>(); |
| |
| public P_NodeByExtensionIdFilter(String... extensionIds) { |
| if (extensionIds != null) { |
| for (String s : extensionIds) { |
| m_ids.add(s); |
| } |
| } |
| } |
| |
| @Override |
| public boolean accept(ITreeNode node) { |
| ScoutBundleUiExtension extension = (ScoutBundleUiExtension) node.getData(); |
| if (extension != null) { |
| return m_ids.contains(extension.getBundleId()); |
| } |
| return false; |
| } |
| } |
| |
| private class P_NodeByBundleTypeFilter implements ITreeNodeFilter { |
| |
| private final HashSet<String> m_types = new HashSet<String>(); |
| |
| public P_NodeByBundleTypeFilter(String... types) { |
| if (types != null) { |
| for (String s : types) { |
| m_types.add(s); |
| } |
| } |
| } |
| |
| @Override |
| public boolean accept(ITreeNode node) { |
| ScoutBundleUiExtension extension = (ScoutBundleUiExtension) node.getData(); |
| if (extension != null) { |
| return m_types.contains(extension.getBundleType()); |
| } |
| return false; |
| } |
| } |
| } |
