/*******************************************************************************
* Copyright (c) 2004, 2016 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.intro.impl.model;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.help.UAContentFilter;
import org.eclipse.help.internal.UAElementFactory;
import org.eclipse.help.internal.util.ProductPreferences;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.internal.intro.impl.FontSelection;
import org.eclipse.ui.internal.intro.impl.IntroPlugin;
import org.eclipse.ui.internal.intro.impl.model.loader.IntroContentParser;
import org.eclipse.ui.internal.intro.impl.model.loader.ModelLoaderUtil;
import org.eclipse.ui.internal.intro.impl.model.util.BundleUtil;
import org.eclipse.ui.internal.intro.impl.model.util.ModelUtil;
import org.eclipse.ui.internal.intro.impl.util.IntroEvaluationContext;
import org.eclipse.ui.internal.intro.impl.util.Log;
import org.eclipse.ui.internal.intro.impl.util.StringUtil;
import org.eclipse.ui.intro.config.IntroConfigurer;
import org.osgi.framework.Bundle;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
/**
* The root class for the OOBE model. It loads the configuration into the
* appropriate classes.
*
* Model rules:
* <ol>
* <li>if an attribute is not included in the markup, its value will be null in
* the model.</li>
* <li>Resources in plugin.xml are not implicitly resolved against $nl$.
* Resources in pages are implicitly resolved against $nl$
* <li>the current page id is set silently when loading the model. You do not
* need the event notification on model load.</li>
* <li>Children of a given parent (ie: model root, page, or group) *must* have
* distinctive IDs otherwise resolving includes and extensions may fail.</li>
* <li>Containers have the concept of loading children and resolving children.
* At the model root level, resolving children means resolving ALL extensions of
* model. At the container level, resolving children means resolving includes.
* </li>
* <li>Extensions are resolved before includes at the container level to avoid
* race conditions. eg: if a page includes a shared group and an extension
* extends this shared group, you want the include to get the extended group and
* not the original group.</li>
* <li>Resolving extensions should not resolve includes. No need to load other
* models when we dont have to. Plus, extensions can only reference anchors, and
* so no need to resolve includes.</li>
* <li>Extensions can not target containers *after* they are resolved. For
* example, an extension can not target a shared group after it has been
* included in a page. It can target the initial shared group as a path, but not
* the group in the page as a path. Again this is because extensions extends
* anchors that already have a path, not a resolved path.</li>
* <li>Pages and shared groups that are contributed through extensions become
* children of the atrget configuration, and so any includes they may have will
* be resolved correctly.</li>
* <li>An infinite loop can occur if page A includes from page B and page B in
* turn includes from page A. ie: cyclic includes. For performnace, accept.
* </li>
* <li>When resolving includes, if the target is a container, it must be
* resolved to resolve its includes correctly. Otherwise, included includes will
* fail due to reparenting.</li>
* <li>unresolved includes are left as children of the parent container.</li>
* <li>Unresolved extensions are left as children of the targetted model.</li>
* <li>For dynamic awarness, the model is nulled and then reloaded. However, we
* need to preserve the presentation instance since the UI is already loaded.
* This is done by reloading the model, and directly resetting the presentation
* to what it was.</li>
* <li>Model classes should not have DOM classes as instance vars, and if this
* is a must, null the DOM class instance the minute you are done. This is
* because you want the VM to garbage collect the DOM model. Keeping a reference
* to the DOM model from the Intro model will prevent that.</li>
* </ol>
* <li>(since 3.0.2) several passes are used to resolve contributions to
* anchors that themselves where contributed through an extension. Each time a
* contribution is resolved, the model tries to resolve all unresolved
* contribution, recursively.
* </ul>
*/
public class IntroModelRoot extends AbstractIntroContainer {
/**
* Model constants that fire property change event when they are changed in
* the model.
*/
public static final int CURRENT_PAGE_PROPERTY_ID = 1;
private static final String ATT_CONTENT = "content"; //$NON-NLS-1$
private static final String ATT_CONFIGURER = "configurer"; //$NON-NLS-1$
private static final String VAR_THEME = "theme"; //$NON-NLS-1$
private static final String VAR_DIRECTION = "direction"; //$NON-NLS-1$
// False if there is no valid contribution to the
// org.eclipse.ui.intro.config extension point. Start off with true, and set
// to false whenever something bad happens.
private boolean hasValidConfig = true;
private IntroConfigurer configurer;
private IntroTheme theme;
private IntroPartPresentation introPartPresentation;
private IntroHomePage rootPage;
private String currentPageId;
private String startPageId;
private AbstractIntroPage standbyPage;
private AbstractIntroPage homePage;
private String modelStandbyPageId;
// the config extensions for this model.
private IConfigurationElement[] configExtensionElements;
// maintain listener list for model changes.
public ListenerList<IPropertyListener> propChangeListeners = new ListenerList<>();
// a list to hold all loaded DOMs until resolving all configExtensions
// is done.
private List<ExtensionContent> unresolvedConfigExt = new ArrayList<>();
private class ExtensionContent {
Element element;
IConfigurationElement configExtElement;
ExtensionContent(Element element,
IConfigurationElement configExtElement) {
this.element = element;
this.configExtElement = configExtElement;
}
}
/**
* Model root. Takes a configElement that represents <config>in the
* plugin.xml markup AND all the extension contributed to this model through
* the configExtension point.
*/
public IntroModelRoot(IConfigurationElement configElement,
IConfigurationElement[] configExtensionElements) {
// the config element that represents the correct model root.
super(configElement);
this.configExtensionElements = configExtensionElements;
}
public void loadModel() {
getChildren();
determineHomePage();
}
/**
* Loads the full model. The children of a model root are the presentation,
* followed by all pages, and all shared groups. Then if the model has
* extension, its the unresolved container extensions, followed by all
* extension pages and groups. The presentation is loaded from the
* IConfiguration element representing the config. All else is loaded from
* xml content file.
*
*/
@Override
protected void loadChildren() {
children = new Vector<>();
if (Log.logInfo)
Log.info("Creating Intro plugin model...."); //$NON-NLS-1$
// load presentation first and create the model class for it. If there
// is more than one presentation, load first one, and log rest.
IConfigurationElement presentationElement = loadPresentation();
if (presentationElement == null) {
// no presentations at all, exit.
setModelState(true, false);
Log.warning("Could not find presentation element in intro config."); //$NON-NLS-1$
return;
}
loadTheme();
loadConfigurer();
introPartPresentation = new IntroPartPresentation(presentationElement);
children.add(introPartPresentation);
// set parent.
introPartPresentation.setParent(this);
// now load all children of the config. There should only be pages and
// groups here. And order is not important. These elements are loaded
// from the content file DOM.
Document document = loadDOM(getCfgElement());
if (document == null) {
// we failed to parse the content file. Intro Parser would have
// logged the fact. Parser would also have checked to see if the
// content file has the correct root tag.
setModelState(true, false);
return;
}
// set base for this model.
this.base = getBase(getCfgElement());
// now load content.
loadPages(document, getBundle());
loadSharedGroups(document, getBundle());
// Attributes of root page decide if we have a static or dynamic case.
setModelState(true, true);
if (configurer != null) {
// The configurer may vary its returned results based on the theme
// properties
configurer.bind(this);
}
}
/**
* Sets the presentation to the given presentation. The model always has the
* presentation as the first child, so use that fact. This method is used
* for dynamic awarness to enable replacing the new presentation with the
* existing one after a model refresh.
*
* @param presentation
*/
public void setPresentation(IntroPartPresentation presentation) {
this.introPartPresentation = presentation;
presentation.setParent(this);
children.set(0, presentation);
}
/**
* Resolve contributions into this container's children.
*/
@Override
protected void resolveChildren() {
// now handle config extension.
resolveConfigExtensions();
resolved = true;
}
private IConfigurationElement loadPresentation() {
// If there is more than one presentation, load first one, and log
// rest.
IConfigurationElement[] presentationElements = getCfgElement()
.getChildren(IntroPartPresentation.TAG_PRESENTATION);
IConfigurationElement presentationElement = ModelLoaderUtil
.validateSingleContribution(presentationElements,
IntroPartPresentation.ATT_HOME_PAGE_ID);
return presentationElement;
}
private void loadConfigurer() {
String cname = getCfgElement().getAttribute(ATT_CONFIGURER);
if (cname!=null) {
try {
Object obj = getCfgElement().createExecutableExtension(ATT_CONFIGURER);
if (obj instanceof IntroConfigurer) {
configurer = (IntroConfigurer)obj;
}
}
catch (CoreException e) {
Log.error("Error loading intro configurer", e); //$NON-NLS-1$
}
}
}
private void determineHomePage() {
String pid = Platform.getProduct().getId();
startPageId = getProcessPreference("INTRO_START_PAGE", pid); //$NON-NLS-1$
String homePagePreference = getProcessPreference("INTRO_HOME_PAGE", pid); //$NON-NLS-1$
homePage = rootPage; // Default, may be overridden
if (homePagePreference.length() != 0) {
AbstractIntroPage page = (AbstractIntroPage) findChild(homePagePreference,
ABSTRACT_PAGE);
if (page != null) {
homePage = page;
if(startPageId.length() == 0) {
startPageId = homePagePreference;
}
}
}
String standbyPagePreference = getProcessPreference("INTRO_STANDBY_PAGE", pid); //$NON-NLS-1$
modelStandbyPageId = getPresentation().getStandbyPageId();
if (standbyPagePreference.length() != 0) {
standbyPage = (AbstractIntroPage) findChild(standbyPagePreference,
ABSTRACT_PAGE);
}
if (standbyPage == null && modelStandbyPageId != null && modelStandbyPageId.length() != 0) {
standbyPage = (AbstractIntroPage) findChild(modelStandbyPageId,
ABSTRACT_PAGE);
}
if (standbyPage != null) {
standbyPage.setStandbyPage(true);
}
}
private void loadTheme() {
String pid = Platform.getProduct().getId();
String themeId = getProcessPreference("INTRO_THEME", pid); //$NON-NLS-1$
IConfigurationElement [] elements = Platform.getExtensionRegistry().getConfigurationElementsFor("org.eclipse.ui.intro.configExtension"); //$NON-NLS-1$
IConfigurationElement themeElement=null;
for (int i=0; i<elements.length; i++) {
if (elements[i].getName().equals("theme")) { //$NON-NLS-1$
String id = elements[i].getAttribute("id"); //$NON-NLS-1$
if (themeId!=null) {
if (id!=null && themeId.equals(id)) {
// use this one
themeElement = elements[i];
break;
}
}
else {
// see if this one is the default
String value = elements[i].getAttribute("default"); //$NON-NLS-1$
if (value!=null && value.equalsIgnoreCase("true")) { //$NON-NLS-1$
themeElement = elements[i];
break;
}
}
}
}
if (themeElement!=null) {
theme = new IntroTheme(themeElement);
}
}
/**
* Loads all pages defined in this config from the xml content file.
*/
private void loadPages(Document dom, Bundle bundle) {
String rootPageId = getPresentation().getHomePageId();
Element[] pages = ModelUtil.getElementsByTagName(dom,
AbstractIntroPage.TAG_PAGE);
for (int i = 0; i < pages.length; i++) {
Element pageElement = pages[i];
if (pageElement.getAttribute(AbstractIntroIdElement.ATT_ID).equals(
rootPageId)) {
// Create the model class for the Root Page.
rootPage = new IntroHomePage(pageElement, bundle, base);
rootPage.setParent(this);
currentPageId = rootPage.getId();
children.add(rootPage);
} else {
// Create the model class for an intro Page.
IntroPage page = new IntroPage(pageElement, bundle, base);
page.setParent(this);
children.add(page);
}
}
}
/**
* Loads all shared groups defined in this config, from the DOM.
*/
private void loadSharedGroups(Document dom, Bundle bundle) {
Element[] groups = ModelUtil.getElementsByTagName(dom,
IntroGroup.TAG_GROUP);
for (int i = 0; i < groups.length; i++) {
IntroGroup group = new IntroGroup(groups[i], bundle, base);
group.setParent(this);
children.add(group);
}
}
/**
* Handles all the configExtensions to this current model. Resolving
* configExts means finding target anchor and inserting extension content at
* target. Also, several passes are used to resolve as many extensions as
* possible. This allows for resolving nested anchors (ie: anchors to
* anchors in contributions).
*/
private void resolveConfigExtensions() {
for (int i = 0; i < configExtensionElements.length; i++) {
processConfigExtension(configExtensionElements[i]);
}
tryResolvingExtensions();
// At this stage all pages will be resolved, some contributions may not be
// now add all unresolved extensions as model children and log fact.
Iterator keys = unresolvedConfigExt.iterator();
while (keys.hasNext()) {
ExtensionContent extension = (ExtensionContent) keys.next();
Element configExtensionElement = extension.element;
IConfigurationElement configExtConfigurationElement = extension.configExtElement;
Bundle bundle = BundleUtil
.getBundleFromConfigurationElement(configExtConfigurationElement);
String base = getBase(configExtConfigurationElement);
children.add(new IntroExtensionContent(configExtensionElement,
bundle, base, configExtConfigurationElement));
// INTRO: fix log strings.
Log
.warning("Could not resolve the following configExtension: " //$NON-NLS-1$
+ ModelLoaderUtil.getLogString(bundle,
configExtensionElement,
IntroExtensionContent.ATT_PATH));
}
}
private void processConfigExtension(IConfigurationElement configExtElement) {
// This call will extract the parent folder if needed.
Document dom = loadDOM(configExtElement);
if (dom == null)
// we failed to parse the content file. Intro Parser would
// have logged the fact. Parser would also have checked to
// see if the content file has the correct root tag.
return;
processConfigExtension(dom, configExtElement);
}
private void processConfigExtension(Document dom,
IConfigurationElement configExtElement) {
// Find the target of this container extension, and add all its
// children to target. Make sure to pass correct bundle and base to
// propagate to all children.
String base = getBase(configExtElement);
Element[] extensionContentElements = loadExtensionContent(dom,
configExtElement, base);
for (int i = 0; i < extensionContentElements.length; i++) {
Element extensionContentElement = extensionContentElements[i];
unresolvedConfigExt.add(new ExtensionContent(extensionContentElement,
configExtElement));
}
// Now load all pages and shared groups
// from this config extension. Get the bundle from the extensions since they are
// defined in other plugins.
Bundle bundle = BundleUtil
.getBundleFromConfigurationElement(configExtElement);
Element[] pages = ModelUtil.getElementsByTagName(dom,
AbstractIntroPage.TAG_PAGE);
for (int j = 0; j < pages.length; j++) {
// Create the model class for an intro Page.
if (!UAContentFilter.isFiltered(UAElementFactory.newElement(pages[j]), IntroEvaluationContext.getContext())) {
IntroPage page = new IntroPage(pages[j], bundle, base);
page.setParent(this);
children.add(page);
}
}
}
private void tryResolvingExtensions() {
int previousSize;
do {
previousSize = unresolvedConfigExt.size();
List<ExtensionContent> stillUnresolved = new ArrayList<>();
for (ExtensionContent content : unresolvedConfigExt) {
Element extensionContentElement = content.element;
IConfigurationElement configExtElement = content.configExtElement;
Bundle bundle = BundleUtil.getBundleFromConfigurationElement(configExtElement);
String elementBase = getBase(configExtElement);
processOneExtension(configExtElement, elementBase, bundle, extensionContentElement);
if (extensionContentElement.hasAttribute("failed")) { //$NON-NLS-1$
stillUnresolved.add(content);
}
}
unresolvedConfigExt = stillUnresolved;
} while (unresolvedConfigExt.size() < previousSize);
}
/**
* load the extension content of this configExtension into model classes,
* and insert them at target. A config extension can have only ONE extension
* content. This is because if the extension fails, we need to be able to
* not include the page and group contributions as part of the model. If
* extension content has XHTML content (ie: content attribute is defined) we
* load extension DOM into target page dom.
*
* note: the extension Element is returned to enable creating a child model
* element on failure.
*
* @param
* @return
*/
private Element[] loadExtensionContent(Document dom,
IConfigurationElement configExtElement, String base) {
// get the bundle from the extensions since they are defined in
// other plugins.
List<Element> elements = new ArrayList<>();
Element[] extensionContents = ModelUtil.getElementsByTagName(dom,
IntroExtensionContent.TAG_CONTAINER_EXTENSION);
Element[] replacementContents = ModelUtil.getElementsByTagName(dom,
IntroExtensionContent.TAG_CONTAINER_REPLACE);
addUnfilteredExtensions(elements, extensionContents);
addUnfilteredExtensions(elements, replacementContents);
return (Element[])elements.toArray(new Element[elements.size()]);
}
private void addUnfilteredExtensions(List<Element> elements, Element[] extensionContents) {
for (int i = 0; i < extensionContents.length; i++) {
Element extensionContentElement = extensionContents[i];
if (!UAContentFilter.isFiltered(UAElementFactory.newElement(extensionContentElement), IntroEvaluationContext.getContext())) {
elements.add(extensionContentElement);
}
}
}
private void processOneExtension(IConfigurationElement configExtElement, String base, Bundle bundle,
Element extensionContentElement) {
// Create the model class for extension content.
IntroExtensionContent extensionContent = new IntroExtensionContent(
extensionContentElement, bundle, base, configExtElement);
boolean success = false;
if (extensionContent.isXHTMLContent())
success = loadXHTMLExtensionContent(extensionContent);
else
success = load3_0ExtensionContent(extensionContent);
if (success) {
if (extensionContentElement.hasAttribute("failed")) //$NON-NLS-1$
extensionContentElement.removeAttribute("failed"); //$NON-NLS-1$
} else
extensionContentElement.setAttribute("failed", "true"); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* Insert the extension content into the target.
*
* @param extensionContent
* @return
*/
private boolean loadXHTMLExtensionContent(
IntroExtensionContent extensionContent) {
String path = extensionContent.getPath();
// path must be pageId/anchorID in the case of anchors in XHTML pages.
String[] pathSegments = StringUtil.split(path, "/"); //$NON-NLS-1$
if (pathSegments.length != 2)
// path does not have correct format.
return false;
AbstractIntroPage targetPage = (AbstractIntroPage) findChild(
pathSegments[0], ABSTRACT_PAGE);
if (targetPage == null)
// target could not be found. Signal failure.
return false;
// Insert all children of this extension before the target element. Anchors need
// to stay in DOM, even after all extensions have been resolved, to enable other
// plugins to contribute. Find the target node.
Document pageDom = targetPage.getDocument();
Element targetElement = targetPage.findDomChild(pathSegments[1], "*"); //$NON-NLS-1$
if (targetElement == null)
return false;
// get extension content
Element[] elements = extensionContent.getElements();
// insert all children before anchor in page body.
for (int i = 0; i < elements.length; i++) {
Node targetNode = pageDom.importNode(elements[i], true);
// update the src attribute of this node, if defined by w3
// specs.
ModelUtil.updateResourceAttributes((Element) targetNode,
extensionContent);
targetElement.getParentNode().insertBefore(targetNode, targetElement);
}
if (extensionContent.getExtensionType() == IntroExtensionContent.TYPE_REPLACEMENT) {
targetElement.getParentNode().removeChild(targetElement);
}
// now handle style inheritance.
// Update the parent page styles. skip style if it is null;
String[] styles = extensionContent.getStyles();
if (styles != null) {
for (int i = 0; i < styles.length; i++)
ModelUtil.insertStyle(pageDom, styles[i]);
}
return true;
}
/**
* Insert the extension content (3.0 format) into the target.
*
* @param extensionContent
* @return
*/
private boolean load3_0ExtensionContent(IntroExtensionContent extensionContent) {
String path = extensionContent.getPath();
int type = extensionContent.getExtensionType();
AbstractIntroElement target = findTarget(this, path, extensionContent.getId());
if (target != null && target.isOfType(AbstractIntroElement.ANCHOR) == (type == IntroExtensionContent.TYPE_CONTRIBUTION)) {
// insert all children of this extension before the target element/anchor.
insertExtensionChildren(target, extensionContent, extensionContent.getBundle(), extensionContent.getBase());
// anchors need to stay around to receive other contributions
if (type == IntroExtensionContent.TYPE_REPLACEMENT) {
AbstractIntroContainer parent = (AbstractIntroContainer)target.getParent();
parent.removeChild(target);
}
handleExtensionStyleInheritence(target, extensionContent);
return true;
}
// appropriate target could not be found. Signal failure.
return false;
}
private void insertExtensionChildren(AbstractIntroElement target,
IntroExtensionContent extensionContent, Bundle bundle, String base) {
AbstractIntroContainer parent = (AbstractIntroContainer)target.getParent();
// insert the elements of the extension before the target
String mixinStyle = getMixinStyle(extensionContent);
Element [] children = extensionContent.getChildren();
parent.insertElementsBefore(children, bundle, base, target, mixinStyle);
}
private String getMixinStyle(IntroExtensionContent extensionContent) {
String path = extensionContent.getPath();
if (!path.endsWith("/@")) //$NON-NLS-1$
return null;
String pageId = path.substring(0, path.length()-2);
IntroModelRoot modelRoot = getModelRoot();
if (modelRoot==null)
return null;
IntroConfigurer configurer = modelRoot.getConfigurer();
if (configurer==null)
return null;
String extensionId = extensionContent.getId();
// if this is a replace, take the mixin style as what is being replaced
if (extensionContent.getExtensionType() == IntroExtensionContent.TYPE_REPLACEMENT) {
IPath ipath = new Path(extensionContent.getPath());
String s2 = ipath.segment(1);
if (s2 != null && s2.startsWith("@") && s2.length() > 1) { //$NON-NLS-1$
extensionId = s2.substring(1);
}
}
return configurer.getMixinStyle(pageId, extensionId);
}
/**
* Updates the inherited styles based on the style attribtes defined in the
* configExtension. If we are extending a shared group do nothing. For
* inherited alt-styles, we have to cache the bundle from which we inherited
* the styles to be able to access resources in that plugin.
*
* @param include
* @param target
*/
private void handleExtensionStyleInheritence(AbstractIntroElement target,
IntroExtensionContent extension) {
AbstractIntroContainer targetContainer = (AbstractIntroContainer)target.getParent();
if (targetContainer.getType() == AbstractIntroElement.GROUP
&& targetContainer.getParent().getType() == AbstractIntroElement.MODEL_ROOT)
// if we are extending a shared group, defined under a config, we
// can not include styles.
return;
// Update the parent page styles. skip style if it is null;
String[] styles = extension.getStyles();
if (styles != null)
targetContainer.getParentPage().addStyles(styles);
// for alt-style cache bundle for loading resources.
Map<String, Bundle> altStyles = extension.getAltStyles();
if (altStyles != null)
targetContainer.getParentPage().addAltStyles(altStyles);
}
/**
* Sets the model state based on all the model classes.
*/
private void setModelState(boolean loaded, boolean hasValidConfig) {
this.loaded = loaded;
this.hasValidConfig = hasValidConfig;
}
/**
* Returns true if there is a valid contribution to
* org.eclipse.ui.intro.config extension point, with a valid Presentation,
* and pages.
*
* @return Returns the hasValidConfig.
*/
public boolean hasValidConfig() {
return hasValidConfig;
}
/**
* @return Returns the introPartPresentation.
*/
public IntroPartPresentation getPresentation() {
return introPartPresentation;
}
public IntroConfigurer getConfigurer() {
return configurer;
}
/**
* @return Returns the home Page.
*/
public AbstractIntroPage getHomePage() {
return homePage;
}
/**
* @return Returns the root Page.
*/
public IntroHomePage getRootPage() {
return rootPage;
}
/**
* @return Returns the standby Page. May return null if standby page is not
* defined.
*/
public AbstractIntroPage getStandbyPage() {
return standbyPage;
}
/**
* @return all pages *excluding* the Home Page. If all pages are needed,
* call <code>(AbstractIntroPage[])
* getChildrenOfType(IntroElement.ABSTRACT_PAGE);</code>
*/
public IntroPage[] getPages() {
return (IntroPage[]) getChildrenOfType(AbstractIntroElement.PAGE);
}
/**
* @return Returns the isdynamicIntro.
*/
public boolean isDynamic() {
if ("swt".equals(getPresentation().getImplementationKind())) { //$NON-NLS-1$
return rootPage != null && rootPage.isDynamic();
}
return true;
}
/**
* @return Returns the currentPageId.
*/
public String getCurrentPageId() {
return currentPageId;
}
/**
* Sets the current page. If the model does not have a page with the passed
* id, the message is logged, and the model retains its old current page.
*
* @param currentPageId
* The currentPageId to set. *
* @param fireEvent
* flag to indicate if event notification is needed.
* @return true if the model has a page with the passed id, false otherwise.
* If the method fails, the current page remains the same as the
* last state.
*/
public boolean setCurrentPageId(String pageId, boolean fireEvent) {
if (pageId.equals(currentPageId))
// setting to the same page does nothing. Return true because we did
// not actually fail. just a no op.
return true;
AbstractIntroPage page = (AbstractIntroPage) findChild(pageId,
ABSTRACT_PAGE);
if (page == null) {
// not a page. Test for root page.
if (!pageId.equals(rootPage.getId())) {
// not a page nor the home page.
Log
.warning("Could not set current page to Intro page with id: " + pageId); //$NON-NLS-1$
return false;
}
}
currentPageId = pageId;
if (fireEvent)
firePropertyChange(CURRENT_PAGE_PROPERTY_ID);
return true;
}
public boolean setCurrentPageId(String pageId) {
return setCurrentPageId(pageId, true);
}
public void addPropertyListener(IPropertyListener l) {
propChangeListeners.add(l);
}
/**
* Fires a property changed event. Made public because it can be used to
* trigger a UI refresh.
*
* @param propertyId
* the id of the property that changed
*/
public void firePropertyChange(final int propertyId) {
Object[] array = propChangeListeners.getListeners();
for (int i = 0; i < array.length; i++) {
final IPropertyListener l = (IPropertyListener) array[i];
SafeRunner.run(new SafeRunnable() {
@Override
public void run() {
l.propertyChanged(this, propertyId);
}
@Override
public void handleException(Throwable e) {
super.handleException(e);
// If an unexpected exception happens, remove it
// to make sure the workbench keeps running.
propChangeListeners.remove(l);
}
});
}
}
public void removePropertyListener(IPropertyListener l) {
propChangeListeners.remove(l);
}
/**
* @return Returns the currentPage. return null if page is not found, or if
* we are not in a dynamic intro mode.
*/
public AbstractIntroPage getCurrentPage() {
if (!isDynamic())
return null;
AbstractIntroPage page = (AbstractIntroPage) findChild(currentPageId,
ABSTRACT_PAGE);
if (page != null)
return page;
// not a page. Test for root page.
if (currentPageId.equals(rootPage.getId()))
return rootPage;
// return null if page is not found.
return null;
}
@Override
public int getType() {
return AbstractIntroElement.MODEL_ROOT;
}
/**
* Assumes that the passed config element has a "content" attribute. Reads
* it and loads a DOM based on that attribute value. It does not explicitly
* resolve the resource because this method only loads the introContent and
* the configExt content files. ie: in plugin.xml. <br>
* This method also sets the base attribute on the root element in the DOM
* to enable resolving all resources relative to this DOM.
*
* @return
*/
protected Document loadDOM(IConfigurationElement cfgElement) {
String content = cfgElement.getAttribute(ATT_CONTENT);
// To support jarring, extract parent folder of where the intro content
// file is. It is expected that all intro content is in that one parent
// folder. This works for both content files and configExtension content
// files.
Bundle domBundle = BundleUtil
.getBundleFromConfigurationElement(cfgElement);
ModelUtil.ensureFileURLsExist(domBundle, content);
// Resolve.
content = BundleUtil.getResourceLocation(content, cfgElement);
Document document = new IntroContentParser(content).getDocument();
return document;
}
private String getBase(IConfigurationElement configElement) {
String content = configElement.getAttribute(ATT_CONTENT);
return ModelUtil.getParentFolderToString(content);
}
public String resolveVariables(String text) {
if (text==null) return null;
if (text.indexOf('$')== -1)
return text;
// resolve
boolean inVariable=false;
StringBuffer buf = new StringBuffer();
int vindex=0;
for (int i=0; i<text.length(); i++) {
char c = text.charAt(i);
if (c=='$') {
if (!inVariable) {
inVariable=true;
vindex=i+1;
continue;
}
inVariable=false;
String variable=text.substring(vindex, i);
String value = getVariableValue(variable);
if (value==null)
value = "$"+variable+"$"; //$NON-NLS-1$ //$NON-NLS-2$
buf.append(value);
continue;
}
else if (!inVariable)
buf.append(c);
}
return buf.toString();
}
private String getVariableValue(String variable) {
if (variable.equals(VAR_THEME)) {
if (theme!=null)
return theme.getPath();
}
if (variable.equals(FontSelection.VAR_FONT_STYLE)) {
return FontSelection.getFontStyle();
}
if (variable.equals(VAR_DIRECTION)) {
if (ProductPreferences.isRTL()) {
return "rtl"; //$NON-NLS-1$
} else {
return "ltr"; //$NON-NLS-1$
}
}
if (configurer!=null)
return configurer.getVariable(variable);
return null;
}
public String resolvePath(String extensionId, String path) {
if (configurer==null) return null;
return configurer.resolvePath(extensionId, path);
}
public IntroTheme getTheme() {
return theme;
}
public String getStartPageId() {
return startPageId;
}
private String getProcessPreference(String key, String pid) {
String result = Platform.getPreferencesService().getString
(IntroPlugin.PLUGIN_ID, pid + '_' + key, "", null); //$NON-NLS-1$
if (result.length() == 0) {
result = Platform.getPreferencesService().getString
(IntroPlugin.PLUGIN_ID, key, "", null); //$NON-NLS-1$
}
return result;
}
}