bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/registry/ImportExportPespectiveHandler.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2015 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.ui.internal.registry;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.inject.Inject;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;
 import org.eclipse.e4.core.contexts.ContextInjectionFactory;
 import org.eclipse.e4.core.contexts.IEclipseContext;
 import org.eclipse.e4.core.di.extensions.Preference;
 import org.eclipse.e4.core.services.events.IEventBroker;
 import org.eclipse.e4.core.services.log.Logger;
 import org.eclipse.e4.ui.internal.workbench.E4XMIResourceFactory;
 import org.eclipse.e4.ui.model.application.MAddon;
 import org.eclipse.e4.ui.model.application.MApplication;
 import org.eclipse.e4.ui.model.application.ui.MUIElement;
 import org.eclipse.e4.ui.model.application.ui.advanced.MPerspective;
 import org.eclipse.e4.ui.workbench.modeling.EModelService;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.ui.IPerspectiveDescriptor;
 import org.eclipse.ui.WorkbenchException;
 import org.eclipse.ui.XMLMemento;
 import org.eclipse.ui.internal.e4.compatibility.ModeledPageLayout;
 import org.eclipse.ui.internal.e4.migration.PerspectiveBuilder;
 import org.eclipse.ui.internal.e4.migration.PerspectiveReader;
 import org.eclipse.ui.internal.wizards.preferences.PreferencesExportWizard;
 import org.eclipse.ui.internal.wizards.preferences.PreferencesImportWizard;
 import org.osgi.service.event.Event;
 import org.osgi.service.event.EventHandler;

 @SuppressWarnings("restriction")
 public class ImportExportPespectiveHandler {

 	private static final String PERSPECTIVE_SUFFIX_4X = "_e4persp"; //$NON-NLS-1$

 	private static final String PERSPECTIVE_SUFFIX_3X = "_persp"; //$NON-NLS-1$

 	private static final String ASCII_ENCODING = "ASCII"; //$NON-NLS-1$

 	private static final String TRIMS_KEY = "trims"; //$NON-NLS-1$

 	@Inject
 	private EModelService modelService;

 	@Inject
 	private MApplication application;

 	@Inject
 	private IEventBroker eventBroker;

 	@Inject
 	private Logger logger;

 	@Inject @Preference(nodePath="org.eclipse.ui.workbench")
 	private IEclipsePreferences preferences;

 	@Inject
 	private IEclipseContext context;

 	@Inject
 	private PerspectiveRegistry perspectiveRegistry;

 	private EventHandler importPreferencesEnd;
 	private EventHandler exportPreferencesBegin;
 	private EventHandler exportPreferencesEnd;
 	private IPreferenceChangeListener preferenceListener;
 	private boolean ignoreEvents;

 	private List<MPerspective> exportedPersps = new ArrayList<>();
 	private List<String> importedPersps = new ArrayList<>();
 	private Map<String, String> minMaxPersistedState;

 	private static Boolean impExpEnabled;

 	@PostConstruct
 	private void init() {
 		if (!isImpExpEnabled()) {
 			return;
 		}

 		initializeEventHandlers();
 		preferences.addPreferenceChangeListener(preferenceListener);
 		eventBroker.subscribe(PreferencesExportWizard.EVENT_EXPORT_BEGIN, exportPreferencesBegin);
 		eventBroker.subscribe(PreferencesExportWizard.EVENT_EXPORT_END, exportPreferencesEnd);
 		eventBroker.subscribe(PreferencesImportWizard.EVENT_IMPORT_END, importPreferencesEnd);
 	}

 	@PreDestroy
 	private void dispose() {
 		if (!isImpExpEnabled()) {
 			return;
 		}

 		preferences.removePreferenceChangeListener(preferenceListener);
 		eventBroker.unsubscribe(exportPreferencesBegin);
 		eventBroker.unsubscribe(exportPreferencesEnd);
 		eventBroker.unsubscribe(importPreferencesEnd);
 	}

 	private void importPerspective4x(PreferenceChangeEvent event) {
 		importedPersps.add(event.getKey());
 		MPerspective perspective = null;
 		try {
 			perspective = perspFromString((String) event.getNewValue());
 			addShowInTags(perspective);
 		} catch (IOException e) {
 			logError(event, e);
 		}
 		addPerspectiveToWorkbench(perspective);
 	}

 	private void addShowInTags(MPerspective perspective) {
 		if (perspective != null) {
 			String targetId = getOriginalId(perspective.getElementId());
 			ArrayList<String> showInTags = PerspectiveBuilder.getShowInPartFromRegistry(targetId);
 			if (showInTags != null) {
 				List<String> newTags = new ArrayList<>();
 				for (String showIn : showInTags) {
 					newTags.add(ModeledPageLayout.SHOW_IN_PART_TAG + showIn);
 				}
 				perspective.getTags().addAll(newTags);
 			}
 		}
 	}

 	private String getOriginalId(String id) {
 		int index = id.lastIndexOf('.');
 		if (index == -1)
 			return id;
 		return id.substring(0, index);
 	}

 	private void importPerspective3x(PreferenceChangeEvent event) {
 		importedPersps.add(event.getKey());
 		StringReader reader = new StringReader((String) event.getNewValue());
 		MPerspective perspective = null;
 		IEclipseContext childContext = context.createChild();
 		try {
 			childContext.set(PerspectiveReader.class, new PerspectiveReader(XMLMemento.createReadRoot(reader)));
 			perspective = ContextInjectionFactory.make(PerspectiveBuilder.class, childContext).createPerspective();
 		} catch (WorkbenchException e) {
 			logError(event, e);
 		} finally {
 			reader.close();
 			childContext.dispose();
 		}
 		addPerspectiveToWorkbench(perspective);
 	}

 	private void addPerspectiveToWorkbench(MPerspective perspective) {
 		if (perspective == null) {
 			return;
 		}

 		IPerspectiveDescriptor perspToOverwrite = perspectiveRegistry.findPerspectiveWithLabel(perspective.getLabel());

 		// a new perspective
 		if (perspToOverwrite == null) {
 			perspectiveRegistry.addPerspective(perspective);
 			importToolbarsLocation(perspective);
 			return;
 		}

 		String perspToOverwriteId = perspToOverwrite.getId();
 		// a perspective with the same label exists, but has different ID
 		if (!perspective.getElementId().equals(perspToOverwriteId)) {
 			perspective.setElementId(perspToOverwriteId);
 		}
 		perspectiveRegistry.deletePerspective(perspToOverwrite);
 		perspectiveRegistry.addPerspective(perspective);
 		importToolbarsLocation(perspective);
 	}

 	private void logError(PreferenceChangeEvent event, Exception e) {
 		logger.error(e, String.format("Cannot read perspective \"%s\" from preferences", event.getKey())); //$NON-NLS-1$
 	}

 	private void copyPerspToPreferences(MPerspective persp) throws IOException {
 		MPerspective perspClone = (MPerspective) modelService.cloneElement(persp, null);
 		exportToolbarsLocation(perspClone);
 		String perspAsString = perspToString(perspClone);
 		preferences.put(perspClone.getLabel() + PERSPECTIVE_SUFFIX_4X, perspAsString);
 	}

 	private void exportToolbarsLocation(MPerspective persp) {
 		Map<String, String> minMaxPersState = getMinMaxPersistedState();
 		if (minMaxPersState == null) {
 			return;
 		}
 		String trimsData = minMaxPersState.get(persp.getElementId());
 		persp.getPersistedState().put(TRIMS_KEY, trimsData);
 	}

 	private void importToolbarsLocation(MPerspective persp) {
 		String trimsData = persp.getPersistedState().get(TRIMS_KEY);
 		if (trimsData == null || trimsData.trim().isEmpty()) {
 			return;
 		}
 		persp.getPersistedState().remove(TRIMS_KEY);
 		Map<String, String> minMaxPersState = getMinMaxPersistedState();
 		if (minMaxPersState == null) {
 			return;
 		}
 		minMaxPersState.put(persp.getElementId(), trimsData);
 	}

 	private Map<String, String> getMinMaxPersistedState() {
 		if (minMaxPersistedState != null) {
 			return minMaxPersistedState;
 		}
 		for (MAddon addon : application.getAddons()) {
 			if ("MinMax Addon".equals(addon.getElementId())) { //$NON-NLS-1$
 				minMaxPersistedState = addon.getPersistedState();
 				break;
 			}
 		}
 		return minMaxPersistedState;
 	}

 	private String perspToString(MPerspective persp) throws IOException {
 		Resource resource = new E4XMIResourceFactory().createResource(null);
 		resource.getContents().add((EObject) persp);
 		ByteArrayOutputStream output = new ByteArrayOutputStream();
 		try {
 			resource.save(output, null);
 		} finally {
 			try {
 				output.close();
 			} catch (IOException e) {
 				logger.error(e, "Cannot close output stream"); //$NON-NLS-1$
 			}
 		}
 		resource.getContents().clear();
 		return new String(output.toByteArray(), ASCII_ENCODING);
 	}

 	private MPerspective perspFromString(String perspAsString) throws IOException {
 		Resource resource = new E4XMIResourceFactory().createResource(null);
 		InputStream input = new ByteArrayInputStream(perspAsString.getBytes(ASCII_ENCODING));
 		try {
 			resource.load(input, null);
 		} finally {
 			try {
 				input.close();
 			} catch (IOException e) {
 				logger.error(e, "Cannot close input stream"); //$NON-NLS-1$
 			}
 		}
 		MPerspective perspective = (MPerspective) resource.getContents().get(0);
 		resource.getContents().clear();
 		return perspective;
 	}

 	private void copyPerspsToPreferences() {
 		for (MUIElement snippet : application.getSnippets()) {
 			if (snippet instanceof MPerspective) {
 				MPerspective persp = (MPerspective) snippet;
 				exportedPersps.add(persp);
 			}
 		}
 		ignoreEvents = true;
 		for (MPerspective persp : exportedPersps) {
 			try {
 				copyPerspToPreferences(persp);
 			} catch (IOException e) {
 				logger.error(e, String.format("Cannot save perspective \"%s\" to preferences", persp.getElementId())); //$NON-NLS-1$
 			}
 		}
 		ignoreEvents = false;
 	}

 	private void removeExportedPreferences() {
 		ignoreEvents = true;
 		for (MPerspective persp : exportedPersps) {
 			preferences.remove(persp.getLabel() + PERSPECTIVE_SUFFIX_4X);
 		}
 		ignoreEvents = false;
 		exportedPersps.clear();
 	}

 	private void removeImportedPreferences() {
 		ignoreEvents = true;
 		for (String key : importedPersps) {
 			preferences.remove(key);
 		}
 		ignoreEvents = false;
 		importedPersps.clear();

 		// remove unused preference imported from Eclipse 3.x
 		preferences.remove("perspectives"); //$NON-NLS-1$
 	}

 	private void initializeEventHandlers() {

 		importPreferencesEnd = new EventHandler() {
 			@Override
 			public void handleEvent(Event event) {
 				removeImportedPreferences();
 			}
 		};

 		exportPreferencesBegin = new EventHandler() {
 			@Override
 			public void handleEvent(Event event) {
 				copyPerspsToPreferences();
 			}
 		};

 		exportPreferencesEnd = new EventHandler() {
 			@Override
 			public void handleEvent(Event event) {
 				removeExportedPreferences();
 			}
 		};

 		preferenceListener = new IPreferenceChangeListener() {
 			@Override
 			public void preferenceChange(PreferenceChangeEvent event) {
 				if (ignoreEvents) {
 					return;
 				}

 				if (event.getKey().endsWith(PERSPECTIVE_SUFFIX_4X)) {
 					importPerspective4x(event);
 				} else if (event.getKey().endsWith(PERSPECTIVE_SUFFIX_3X)) {
 					importPerspective3x(event);
 				}
 			}
 		};

 	}

 	public static boolean isImpExpEnabled() {
 		if (impExpEnabled == null) {
 			String propertyStr = System.getProperty("e4.impExpPerspectiveEnabled"); //$NON-NLS-1$
 			if (propertyStr == null) {
 				impExpEnabled = true;
 			} else {
 				impExpEnabled = Boolean.parseBoolean(propertyStr);
 			}
 		}
 		return impExpEnabled;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2015 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.ui.internal.registry;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.StringReader;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Map;
	import javax.annotation.PostConstruct;
	import javax.annotation.PreDestroy;
	import javax.inject.Inject;
	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
	import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
	import org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent;
	import org.eclipse.e4.core.contexts.ContextInjectionFactory;
	import org.eclipse.e4.core.contexts.IEclipseContext;
	import org.eclipse.e4.core.di.extensions.Preference;
	import org.eclipse.e4.core.services.events.IEventBroker;
	import org.eclipse.e4.core.services.log.Logger;
	import org.eclipse.e4.ui.internal.workbench.E4XMIResourceFactory;
	import org.eclipse.e4.ui.model.application.MAddon;
	import org.eclipse.e4.ui.model.application.MApplication;
	import org.eclipse.e4.ui.model.application.ui.MUIElement;
	import org.eclipse.e4.ui.model.application.ui.advanced.MPerspective;
	import org.eclipse.e4.ui.workbench.modeling.EModelService;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.ui.IPerspectiveDescriptor;
	import org.eclipse.ui.WorkbenchException;
	import org.eclipse.ui.XMLMemento;
	import org.eclipse.ui.internal.e4.compatibility.ModeledPageLayout;
	import org.eclipse.ui.internal.e4.migration.PerspectiveBuilder;
	import org.eclipse.ui.internal.e4.migration.PerspectiveReader;
	import org.eclipse.ui.internal.wizards.preferences.PreferencesExportWizard;
	import org.eclipse.ui.internal.wizards.preferences.PreferencesImportWizard;
	import org.osgi.service.event.Event;
	import org.osgi.service.event.EventHandler;

	@SuppressWarnings("restriction")
	public class ImportExportPespectiveHandler {

	private static final String PERSPECTIVE_SUFFIX_4X = "_e4persp"; //$NON-NLS-1$

	private static final String PERSPECTIVE_SUFFIX_3X = "_persp"; //$NON-NLS-1$

	private static final String ASCII_ENCODING = "ASCII"; //$NON-NLS-1$

	private static final String TRIMS_KEY = "trims"; //$NON-NLS-1$

	@Inject
	private EModelService modelService;

	@Inject
	private MApplication application;

	@Inject
	private IEventBroker eventBroker;

	@Inject
	private Logger logger;

	@Inject @Preference(nodePath="org.eclipse.ui.workbench")
	private IEclipsePreferences preferences;

	@Inject
	private IEclipseContext context;

	@Inject
	private PerspectiveRegistry perspectiveRegistry;

	private EventHandler importPreferencesEnd;
	private EventHandler exportPreferencesBegin;
	private EventHandler exportPreferencesEnd;
	private IPreferenceChangeListener preferenceListener;
	private boolean ignoreEvents;

	private List<MPerspective> exportedPersps = new ArrayList<>();
	private List<String> importedPersps = new ArrayList<>();
	private Map<String, String> minMaxPersistedState;

	private static Boolean impExpEnabled;

	@PostConstruct
	private void init() {
	if (!isImpExpEnabled()) {
	return;
	}

	initializeEventHandlers();
	preferences.addPreferenceChangeListener(preferenceListener);
	eventBroker.subscribe(PreferencesExportWizard.EVENT_EXPORT_BEGIN, exportPreferencesBegin);
	eventBroker.subscribe(PreferencesExportWizard.EVENT_EXPORT_END, exportPreferencesEnd);
	eventBroker.subscribe(PreferencesImportWizard.EVENT_IMPORT_END, importPreferencesEnd);
	}

	@PreDestroy
	private void dispose() {
	if (!isImpExpEnabled()) {
	return;
	}

	preferences.removePreferenceChangeListener(preferenceListener);
	eventBroker.unsubscribe(exportPreferencesBegin);
	eventBroker.unsubscribe(exportPreferencesEnd);
	eventBroker.unsubscribe(importPreferencesEnd);
	}

	private void importPerspective4x(PreferenceChangeEvent event) {
	importedPersps.add(event.getKey());
	MPerspective perspective = null;
	try {
	perspective = perspFromString((String) event.getNewValue());
	addShowInTags(perspective);
	} catch (IOException e) {
	logError(event, e);
	}
	addPerspectiveToWorkbench(perspective);
	}

	private void addShowInTags(MPerspective perspective) {
	if (perspective != null) {
	String targetId = getOriginalId(perspective.getElementId());
	ArrayList<String> showInTags = PerspectiveBuilder.getShowInPartFromRegistry(targetId);
	if (showInTags != null) {
	List<String> newTags = new ArrayList<>();
	for (String showIn : showInTags) {
	newTags.add(ModeledPageLayout.SHOW_IN_PART_TAG + showIn);
	}
	perspective.getTags().addAll(newTags);
	}
	}
	}

	private String getOriginalId(String id) {
	int index = id.lastIndexOf('.');
	if (index == -1)
	return id;
	return id.substring(0, index);
	}

	private void importPerspective3x(PreferenceChangeEvent event) {
	importedPersps.add(event.getKey());
	StringReader reader = new StringReader((String) event.getNewValue());
	MPerspective perspective = null;
	IEclipseContext childContext = context.createChild();
	try {
	childContext.set(PerspectiveReader.class, new PerspectiveReader(XMLMemento.createReadRoot(reader)));
	perspective = ContextInjectionFactory.make(PerspectiveBuilder.class, childContext).createPerspective();
	} catch (WorkbenchException e) {
	logError(event, e);
	} finally {
	reader.close();
	childContext.dispose();
	}
	addPerspectiveToWorkbench(perspective);
	}

	private void addPerspectiveToWorkbench(MPerspective perspective) {
	if (perspective == null) {
	return;
	}

	IPerspectiveDescriptor perspToOverwrite = perspectiveRegistry.findPerspectiveWithLabel(perspective.getLabel());

	// a new perspective
	if (perspToOverwrite == null) {
	perspectiveRegistry.addPerspective(perspective);
	importToolbarsLocation(perspective);
	return;
	}

	String perspToOverwriteId = perspToOverwrite.getId();
	// a perspective with the same label exists, but has different ID
	if (!perspective.getElementId().equals(perspToOverwriteId)) {
	perspective.setElementId(perspToOverwriteId);
	}
	perspectiveRegistry.deletePerspective(perspToOverwrite);
	perspectiveRegistry.addPerspective(perspective);
	importToolbarsLocation(perspective);
	}

	private void logError(PreferenceChangeEvent event, Exception e) {
	logger.error(e, String.format("Cannot read perspective \"%s\" from preferences", event.getKey())); //$NON-NLS-1$
	}

	private void copyPerspToPreferences(MPerspective persp) throws IOException {
	MPerspective perspClone = (MPerspective) modelService.cloneElement(persp, null);
	exportToolbarsLocation(perspClone);
	String perspAsString = perspToString(perspClone);
	preferences.put(perspClone.getLabel() + PERSPECTIVE_SUFFIX_4X, perspAsString);
	}

	private void exportToolbarsLocation(MPerspective persp) {
	Map<String, String> minMaxPersState = getMinMaxPersistedState();
	if (minMaxPersState == null) {
	return;
	}
	String trimsData = minMaxPersState.get(persp.getElementId());
	persp.getPersistedState().put(TRIMS_KEY, trimsData);
	}

	private void importToolbarsLocation(MPerspective persp) {
	String trimsData = persp.getPersistedState().get(TRIMS_KEY);
	if (trimsData == null \|\| trimsData.trim().isEmpty()) {
	return;
	}
	persp.getPersistedState().remove(TRIMS_KEY);
	Map<String, String> minMaxPersState = getMinMaxPersistedState();
	if (minMaxPersState == null) {
	return;
	}
	minMaxPersState.put(persp.getElementId(), trimsData);
	}

	private Map<String, String> getMinMaxPersistedState() {
	if (minMaxPersistedState != null) {
	return minMaxPersistedState;
	}
	for (MAddon addon : application.getAddons()) {
	if ("MinMax Addon".equals(addon.getElementId())) { //$NON-NLS-1$
	minMaxPersistedState = addon.getPersistedState();
	break;
	}
	}
	return minMaxPersistedState;
	}

	private String perspToString(MPerspective persp) throws IOException {
	Resource resource = new E4XMIResourceFactory().createResource(null);
	resource.getContents().add((EObject) persp);
	ByteArrayOutputStream output = new ByteArrayOutputStream();
	try {
	resource.save(output, null);
	} finally {
	try {
	output.close();
	} catch (IOException e) {
	logger.error(e, "Cannot close output stream"); //$NON-NLS-1$
	}
	}
	resource.getContents().clear();
	return new String(output.toByteArray(), ASCII_ENCODING);
	}

	private MPerspective perspFromString(String perspAsString) throws IOException {
	Resource resource = new E4XMIResourceFactory().createResource(null);
	InputStream input = new ByteArrayInputStream(perspAsString.getBytes(ASCII_ENCODING));
	try {
	resource.load(input, null);
	} finally {
	try {
	input.close();
	} catch (IOException e) {
	logger.error(e, "Cannot close input stream"); //$NON-NLS-1$
	}
	}
	MPerspective perspective = (MPerspective) resource.getContents().get(0);
	resource.getContents().clear();
	return perspective;
	}

	private void copyPerspsToPreferences() {
	for (MUIElement snippet : application.getSnippets()) {
	if (snippet instanceof MPerspective) {
	MPerspective persp = (MPerspective) snippet;
	exportedPersps.add(persp);
	}
	}
	ignoreEvents = true;
	for (MPerspective persp : exportedPersps) {
	try {
	copyPerspToPreferences(persp);
	} catch (IOException e) {
	logger.error(e, String.format("Cannot save perspective \"%s\" to preferences", persp.getElementId())); //$NON-NLS-1$
	}
	}
	ignoreEvents = false;
	}

	private void removeExportedPreferences() {
	ignoreEvents = true;
	for (MPerspective persp : exportedPersps) {
	preferences.remove(persp.getLabel() + PERSPECTIVE_SUFFIX_4X);
	}
	ignoreEvents = false;
	exportedPersps.clear();
	}

	private void removeImportedPreferences() {
	ignoreEvents = true;
	for (String key : importedPersps) {
	preferences.remove(key);
	}
	ignoreEvents = false;
	importedPersps.clear();

	// remove unused preference imported from Eclipse 3.x
	preferences.remove("perspectives"); //$NON-NLS-1$
	}

	private void initializeEventHandlers() {

	importPreferencesEnd = new EventHandler() {
	@Override
	public void handleEvent(Event event) {
	removeImportedPreferences();
	}
	};

	exportPreferencesBegin = new EventHandler() {
	@Override
	public void handleEvent(Event event) {
	copyPerspsToPreferences();
	}
	};

	exportPreferencesEnd = new EventHandler() {
	@Override
	public void handleEvent(Event event) {
	removeExportedPreferences();
	}
	};

	preferenceListener = new IPreferenceChangeListener() {
	@Override
	public void preferenceChange(PreferenceChangeEvent event) {
	if (ignoreEvents) {
	return;
	}

	if (event.getKey().endsWith(PERSPECTIVE_SUFFIX_4X)) {
	importPerspective4x(event);
	} else if (event.getKey().endsWith(PERSPECTIVE_SUFFIX_3X)) {
	importPerspective3x(event);
	}
	}
	};

	}

	public static boolean isImpExpEnabled() {
	if (impExpEnabled == null) {
	String propertyStr = System.getProperty("e4.impExpPerspectiveEnabled"); //$NON-NLS-1$
	if (propertyStr == null) {
	impExpEnabled = true;
	} else {
	impExpEnabled = Boolean.parseBoolean(propertyStr);
	}
	}
	return impExpEnabled;
	}

	}