bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/provisional/style/AbstractLineStyleProvider.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * Copyright (c) 2001, 2008 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
  *     Jens Lukowski/Innoopract - initial renaming/restructuring
  *
  *******************************************************************************/
 package org.eclipse.wst.sse.ui.internal.provisional.style;

 import java.util.Collection;
 import java.util.HashMap;

 import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.jface.text.ITypedRegion;
 import org.eclipse.jface.text.TextAttribute;
 import org.eclipse.jface.text.source.ISourceViewer;
 import org.eclipse.jface.util.IPropertyChangeListener;
 import org.eclipse.jface.util.PropertyChangeEvent;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.StyleRange;
 import org.eclipse.swt.graphics.RGB;
 import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
 import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
 import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
 import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionCollection;
 import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
 import org.eclipse.wst.sse.core.internal.util.Debug;
 import org.eclipse.wst.sse.ui.internal.preferences.ui.ColorHelper;
 import org.eclipse.wst.sse.ui.internal.util.EditorUtility;


 public abstract class AbstractLineStyleProvider {
 	private class PropertyChangeListener implements IPropertyChangeListener {
 		/*
 		 * (non-Javadoc)
 		 *
 		 * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
 		 */
 		public void propertyChange(PropertyChangeEvent event) {
 			// have to do it this way so others can override the method
 			handlePropertyChange(event);
 		}
 	}

 	protected IStructuredDocument fDocument;
 	protected Highlighter fHighlighter;
 	private boolean fInitialized;
 	protected PropertyChangeListener fPreferenceListener = new PropertyChangeListener();

 	//private ISourceViewer fSourceViewer = null;
 	protected ReconcilerHighlighter fRecHighlighter = null;

 	/** Contains all text attributes pertaining to this line style provider */
 	private HashMap fTextAttributes = null;

 	// we keep track of LogMessage to avoid writing hundreds of messages,
 	// but still give a hint that something is wrong with attributeProviders
 	// and/or regions.
 	// It's only written in the case of a program error, but there's no use
 	// adding
 	// salt to the wound.
 	// private boolean wroteOneLogMessage;
 	/**
 	 */
 	protected AbstractLineStyleProvider() {
 	}

 	/**
 	 * Looks up the colorKey in the preference store and adds the style
 	 * information to list of TextAttributes
 	 *
 	 * @param colorKey
 	 */
 	protected void addTextAttribute(String colorKey) {
 		if (getColorPreferences() != null) {
 			String prefString = getColorPreferences().getString(colorKey);
 			String[] stylePrefs = ColorHelper.unpackStylePreferences(prefString);
 			if (stylePrefs != null) {
 				RGB foreground = ColorHelper.toRGB(stylePrefs[0]);
 				RGB background = ColorHelper.toRGB(stylePrefs[1]);
 				boolean bold = Boolean.valueOf(stylePrefs[2]).booleanValue();
 				boolean italic = Boolean.valueOf(stylePrefs[3]).booleanValue();
 				boolean strikethrough = Boolean.valueOf(stylePrefs[4]).booleanValue();
 				boolean underline = Boolean.valueOf(stylePrefs[5]).booleanValue();
 				int style = SWT.NORMAL;
 				if (bold) {
 					style = style | SWT.BOLD;
 				}
 				if (italic) {
 					style = style | SWT.ITALIC;
 				}
 				if (strikethrough) {
 					style = style | TextAttribute.STRIKETHROUGH;
 				}
 				if (underline) {
 					style = style | TextAttribute.UNDERLINE;
 				}

 				TextAttribute createTextAttribute = createTextAttribute(foreground, background, style);
 				getTextAttributes().put(colorKey, createTextAttribute);
 			}
 		}
 	}

 	protected void commonInit(IStructuredDocument document, Highlighter highlighter) {

 		fDocument = document;
 		fHighlighter = highlighter;
 	}

 	/**
 	 * this version does "trim" regions to match request
 	 */
 	private StyleRange createStyleRange(ITextRegionCollection flatNode, ITextRegion region, TextAttribute attr, int startOffset, int length) {
 		int start = flatNode.getStartOffset(region);
 		if (start < startOffset)
 			start = startOffset;

 		// Base the text end offset off of the, possibly adjusted, start
 		int textEnd = start + region.getTextLength();
 		int maxOffset = startOffset + length;

 		int end = flatNode.getEndOffset(region);
 		// Use the end of the text in the region to avoid applying background color to trailing whitespace
 		if(textEnd < end)
 			end = textEnd;
 		// instead of end-start?
 		if (end > maxOffset)
 			end = maxOffset;
 		StyleRange result = new StyleRange(start, end - start, attr.getForeground(), attr.getBackground(), attr.getStyle());
 		if((attr.getStyle() & TextAttribute.STRIKETHROUGH) != 0) {
 			result.strikeout = true;
 		}
 		if((attr.getStyle() & TextAttribute.UNDERLINE) != 0) {
 			result.underline = true;
 		}
 		return result;

 	}

 	protected TextAttribute createTextAttribute(RGB foreground, RGB background, boolean bold) {
 		return new TextAttribute((foreground != null) ? EditorUtility.getColor(foreground) : null, (background != null) ? EditorUtility.getColor(background) : null, bold ? SWT.BOLD : SWT.NORMAL);
 	}

 	protected TextAttribute createTextAttribute(RGB foreground, RGB background, int style) {
 		return new TextAttribute((foreground != null) ? EditorUtility.getColor(foreground) : null, (background != null) ? EditorUtility.getColor(background) : null, style);
 	}

 	abstract protected TextAttribute getAttributeFor(ITextRegion region);

 	protected TextAttribute getAttributeFor(ITextRegionCollection collection, ITextRegion region) {
 		return getAttributeFor(region);
 	}

 	abstract protected IPreferenceStore getColorPreferences();

 	protected IStructuredDocument getDocument() {
 		return fDocument;
 	}

 	public void setDocument(IStructuredDocument document) {
 		fDocument = document;
 	}

 	/**
 	 */
 	protected Highlighter getHighlighter() {
 		return fHighlighter;
 	}

 	/**
 	 * Returns the hashtable containing all the text attributes for this line
 	 * style provider. Lazily creates a hashtable if one has not already been
 	 * created.
 	 *
 	 * @return
 	 */
 	protected HashMap getTextAttributes() {
 		if (fTextAttributes == null) {
 			fTextAttributes = new HashMap();
 			loadColors();
 		}
 		return fTextAttributes;
 	}

 	protected void handlePropertyChange(PropertyChangeEvent event) {
 		// force a full update of the text viewer
 		if(fRecHighlighter != null)
 			fRecHighlighter.refreshDisplay();
 	}

 	public void init(IStructuredDocument structuredDocument, Highlighter highlighter) {

 		commonInit(structuredDocument, highlighter);

 		if (isInitialized())
 			return;

 		registerPreferenceManager();

 		setInitialized(true);
 	}

 	public void init(IStructuredDocument structuredDocument, ISourceViewer sourceViewer) {
 		init(structuredDocument, (Highlighter) null);
 	}

 	public void init(IStructuredDocument structuredDocument, ReconcilerHighlighter highlighter)	{
 		fDocument = structuredDocument;
 		fRecHighlighter = highlighter;

 		if(isInitialized())
 			return;

 		registerPreferenceManager();

 		setInitialized(true);
 	}

 	/**
 	 * @deprecated - left because it's public, but we aren't adapters any more
 	 */
 	public boolean isAdapterForType(java.lang.Object type) {
 		return type == LineStyleProvider.class;
 	}

 	/**
 	 * Returns the initialized.
 	 *
 	 * @return boolean
 	 */
 	public boolean isInitialized() {
 		return fInitialized;
 	}

 	abstract protected void loadColors();

 	public boolean prepareRegions(ITypedRegion typedRegion, int lineRequestStart, int lineRequestLength, Collection holdResults) {
 		final int partitionStartOffset = typedRegion.getOffset();
 		final int partitionLength = typedRegion.getLength();
 		IStructuredDocumentRegion structuredDocumentRegion = getDocument().getRegionAtCharacterOffset(partitionStartOffset);
 		boolean handled = false;

 		handled = prepareTextRegions(structuredDocumentRegion, partitionStartOffset, partitionLength, holdResults);

 		return handled;
 	}

 	/**
 	 * @param region
 	 * @param start
 	 * @param length
 	 * @param holdResults
 	 * @return
 	 */
 	private boolean prepareTextRegion(ITextRegionCollection blockedRegion, int partitionStartOffset, int partitionLength, Collection holdResults) {
 		boolean handled = false;
 		final int partitionEndOffset = partitionStartOffset + partitionLength - 1;
 		ITextRegion region = null;
 		ITextRegionList regions = blockedRegion.getRegions();
 		int nRegions = regions.size();
 		StyleRange styleRange = null;
 		for (int i = 0; i < nRegions; i++) {
 			region = regions.get(i);
 			TextAttribute attr = null;
 			TextAttribute previousAttr = null;
 			if (blockedRegion.getStartOffset(region) > partitionEndOffset)
 				break;
 			if (blockedRegion.getEndOffset(region) <= partitionStartOffset)
 				continue;

 			if (region instanceof ITextRegionCollection) {
 				handled = prepareTextRegion((ITextRegionCollection) region, partitionStartOffset, partitionLength, holdResults);
 			} else {

 				attr = getAttributeFor(blockedRegion, region);
 				if (attr != null) {
 					handled = true;
 					// if this region's attr is the same as previous one, then
 					// just adjust the previous style range
 					// instead of creating a new instance of one
 					// note: to use 'equals' in this case is important, since
 					// sometimes
 					// different instances of attributes are associated with a
 					// region, even the
 					// the attribute has the same values.
 					// TODO: this needs to be improved to handle readonly
 					// regions correctly
 					if ((styleRange != null) && (previousAttr != null) && (previousAttr.equals(attr))) {
 						styleRange.length += region.getLength();
 					} else {
 						styleRange = createStyleRange(blockedRegion, region, attr, partitionStartOffset, partitionLength);
 						holdResults.add(styleRange);
 						// technically speaking, we don't need to update
 						// previousAttr
 						// in the other case, because the other case is when
 						// it hasn't changed
 						previousAttr = attr;
 					}
 				} else {
 					previousAttr = null;
 				}
 			}
 		}
 		return handled;
 	}

 	private boolean prepareTextRegions(IStructuredDocumentRegion structuredDocumentRegion, int partitionStartOffset, int partitionLength, Collection holdResults) {
 		boolean handled = false;
 		final int partitionEndOffset = partitionStartOffset + partitionLength - 1;
 		while (structuredDocumentRegion != null && structuredDocumentRegion.getStartOffset() <= partitionEndOffset) {
 			ITextRegion region = null;
 			ITextRegionList regions = structuredDocumentRegion.getRegions();
 			int nRegions = regions.size();
 			StyleRange styleRange = null;
 			for (int i = 0; i < nRegions; i++) {
 				region = regions.get(i);
 				TextAttribute attr = null;
 				TextAttribute previousAttr = null;
 				if (structuredDocumentRegion.getStartOffset(region) > partitionEndOffset)
 					break;
 				if (structuredDocumentRegion.getEndOffset(region) <= partitionStartOffset)
 					continue;

 				if (region instanceof ITextRegionCollection) {
 					boolean handledCollection = (prepareTextRegion((ITextRegionCollection) region, partitionStartOffset, partitionLength, holdResults));
 					handled = (!handled) ? handledCollection : handled;
 				} else {

 					attr = getAttributeFor(structuredDocumentRegion, region);
 					if (attr != null) {
 						handled = true;
 						// if this region's attr is the same as previous one,
 						// then just adjust the previous style range
 						// instead of creating a new instance of one
 						// note: to use 'equals' in this case is important,
 						// since sometimes
 						// different instances of attributes are associated
 						// with a region, even the
 						// the attribute has the same values.
 						// TODO: this needs to be improved to handle readonly
 						// regions correctly
 						if ((styleRange != null) && (previousAttr != null) && (previousAttr.equals(attr))) {
 							styleRange.length += region.getLength();
 						} else {
 							styleRange = createStyleRange(structuredDocumentRegion, region, attr, partitionStartOffset, partitionLength);
 							holdResults.add(styleRange);
 							// technically speaking, we don't need to update
 							// previousAttr
 							// in the other case, because the other case is
 							// when it hasn't changed
 							previousAttr = attr;
 						}
 					} else {
 						previousAttr = null;
 					}
 				}

 				if (Debug.syntaxHighlighting && !handled) {
 					System.out.println("not handled in prepareRegions"); //$NON-NLS-1$
 				}
 			}
 			structuredDocumentRegion = structuredDocumentRegion.getNext();
 		}
 		return handled;
 	}

 	protected void registerPreferenceManager() {
 		IPreferenceStore pref = getColorPreferences();
 		if (pref != null) {
 			pref.addPropertyChangeListener(fPreferenceListener);
 		}
 	}

 	public void release() {
 		unRegisterPreferenceManager();
 		if (fTextAttributes != null) {
 			fTextAttributes.clear();
 			fTextAttributes = null;
 		}
 		setInitialized(false);
 	}

 	/**
 	 * Sets the initialized.
 	 *
 	 * @param initialized
 	 *            The initialized to set
 	 */
 	private void setInitialized(boolean initialized) {
 		this.fInitialized = initialized;
 	}

 	protected void unRegisterPreferenceManager() {
 		IPreferenceStore pref = getColorPreferences();
 		if (pref != null) {
 			pref.removePropertyChangeListener(fPreferenceListener);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2001, 2008 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
	* Jens Lukowski/Innoopract - initial renaming/restructuring
	*
	*******************************************************************************/
	package org.eclipse.wst.sse.ui.internal.provisional.style;

	import java.util.Collection;
	import java.util.HashMap;

	import org.eclipse.jface.preference.IPreferenceStore;
	import org.eclipse.jface.text.ITypedRegion;
	import org.eclipse.jface.text.TextAttribute;
	import org.eclipse.jface.text.source.ISourceViewer;
	import org.eclipse.jface.util.IPropertyChangeListener;
	import org.eclipse.jface.util.PropertyChangeEvent;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.StyleRange;
	import org.eclipse.swt.graphics.RGB;
	import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
	import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
	import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
	import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionCollection;
	import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
	import org.eclipse.wst.sse.core.internal.util.Debug;
	import org.eclipse.wst.sse.ui.internal.preferences.ui.ColorHelper;
	import org.eclipse.wst.sse.ui.internal.util.EditorUtility;


	public abstract class AbstractLineStyleProvider {
	private class PropertyChangeListener implements IPropertyChangeListener {
	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
	*/
	public void propertyChange(PropertyChangeEvent event) {
	// have to do it this way so others can override the method
	handlePropertyChange(event);
	}
	}

	protected IStructuredDocument fDocument;
	protected Highlighter fHighlighter;
	private boolean fInitialized;
	protected PropertyChangeListener fPreferenceListener = new PropertyChangeListener();

	//private ISourceViewer fSourceViewer = null;
	protected ReconcilerHighlighter fRecHighlighter = null;

	/** Contains all text attributes pertaining to this line style provider */
	private HashMap fTextAttributes = null;

	// we keep track of LogMessage to avoid writing hundreds of messages,
	// but still give a hint that something is wrong with attributeProviders
	// and/or regions.
	// It's only written in the case of a program error, but there's no use
	// adding
	// salt to the wound.
	// private boolean wroteOneLogMessage;
	/**
	*/
	protected AbstractLineStyleProvider() {
	}

	/**
	* Looks up the colorKey in the preference store and adds the style
	* information to list of TextAttributes
	*
	* @param colorKey
	*/
	protected void addTextAttribute(String colorKey) {
	if (getColorPreferences() != null) {
	String prefString = getColorPreferences().getString(colorKey);
	String[] stylePrefs = ColorHelper.unpackStylePreferences(prefString);
	if (stylePrefs != null) {
	RGB foreground = ColorHelper.toRGB(stylePrefs[0]);
	RGB background = ColorHelper.toRGB(stylePrefs[1]);
	boolean bold = Boolean.valueOf(stylePrefs[2]).booleanValue();
	boolean italic = Boolean.valueOf(stylePrefs[3]).booleanValue();
	boolean strikethrough = Boolean.valueOf(stylePrefs[4]).booleanValue();
	boolean underline = Boolean.valueOf(stylePrefs[5]).booleanValue();
	int style = SWT.NORMAL;
	if (bold) {
	style = style \| SWT.BOLD;
	}
	if (italic) {
	style = style \| SWT.ITALIC;
	}
	if (strikethrough) {
	style = style \| TextAttribute.STRIKETHROUGH;
	}
	if (underline) {
	style = style \| TextAttribute.UNDERLINE;
	}

	TextAttribute createTextAttribute = createTextAttribute(foreground, background, style);
	getTextAttributes().put(colorKey, createTextAttribute);
	}
	}
	}

	protected void commonInit(IStructuredDocument document, Highlighter highlighter) {

	fDocument = document;
	fHighlighter = highlighter;
	}

	/**
	* this version does "trim" regions to match request
	*/
	private StyleRange createStyleRange(ITextRegionCollection flatNode, ITextRegion region, TextAttribute attr, int startOffset, int length) {
	int start = flatNode.getStartOffset(region);
	if (start < startOffset)
	start = startOffset;

	// Base the text end offset off of the, possibly adjusted, start
	int textEnd = start + region.getTextLength();
	int maxOffset = startOffset + length;

	int end = flatNode.getEndOffset(region);
	// Use the end of the text in the region to avoid applying background color to trailing whitespace
	if(textEnd < end)
	end = textEnd;
	// instead of end-start?
	if (end > maxOffset)
	end = maxOffset;
	StyleRange result = new StyleRange(start, end - start, attr.getForeground(), attr.getBackground(), attr.getStyle());
	if((attr.getStyle() & TextAttribute.STRIKETHROUGH) != 0) {
	result.strikeout = true;
	}
	if((attr.getStyle() & TextAttribute.UNDERLINE) != 0) {
	result.underline = true;
	}
	return result;

	}

	protected TextAttribute createTextAttribute(RGB foreground, RGB background, boolean bold) {
	return new TextAttribute((foreground != null) ? EditorUtility.getColor(foreground) : null, (background != null) ? EditorUtility.getColor(background) : null, bold ? SWT.BOLD : SWT.NORMAL);
	}

	protected TextAttribute createTextAttribute(RGB foreground, RGB background, int style) {
	return new TextAttribute((foreground != null) ? EditorUtility.getColor(foreground) : null, (background != null) ? EditorUtility.getColor(background) : null, style);
	}

	abstract protected TextAttribute getAttributeFor(ITextRegion region);

	protected TextAttribute getAttributeFor(ITextRegionCollection collection, ITextRegion region) {
	return getAttributeFor(region);
	}

	abstract protected IPreferenceStore getColorPreferences();

	protected IStructuredDocument getDocument() {
	return fDocument;
	}

	public void setDocument(IStructuredDocument document) {
	fDocument = document;
	}

	/**
	*/
	protected Highlighter getHighlighter() {
	return fHighlighter;
	}

	/**
	* Returns the hashtable containing all the text attributes for this line
	* style provider. Lazily creates a hashtable if one has not already been
	* created.
	*
	* @return
	*/
	protected HashMap getTextAttributes() {
	if (fTextAttributes == null) {
	fTextAttributes = new HashMap();
	loadColors();
	}
	return fTextAttributes;
	}

	protected void handlePropertyChange(PropertyChangeEvent event) {
	// force a full update of the text viewer
	if(fRecHighlighter != null)
	fRecHighlighter.refreshDisplay();
	}

	public void init(IStructuredDocument structuredDocument, Highlighter highlighter) {

	commonInit(structuredDocument, highlighter);

	if (isInitialized())
	return;

	registerPreferenceManager();

	setInitialized(true);
	}

	public void init(IStructuredDocument structuredDocument, ISourceViewer sourceViewer) {
	init(structuredDocument, (Highlighter) null);
	}

	public void init(IStructuredDocument structuredDocument, ReconcilerHighlighter highlighter) {
	fDocument = structuredDocument;
	fRecHighlighter = highlighter;

	if(isInitialized())
	return;

	registerPreferenceManager();

	setInitialized(true);
	}

	/**
	* @deprecated - left because it's public, but we aren't adapters any more
	*/
	public boolean isAdapterForType(java.lang.Object type) {
	return type == LineStyleProvider.class;
	}

	/**
	* Returns the initialized.
	*
	* @return boolean
	*/
	public boolean isInitialized() {
	return fInitialized;
	}

	abstract protected void loadColors();

	public boolean prepareRegions(ITypedRegion typedRegion, int lineRequestStart, int lineRequestLength, Collection holdResults) {
	final int partitionStartOffset = typedRegion.getOffset();
	final int partitionLength = typedRegion.getLength();
	IStructuredDocumentRegion structuredDocumentRegion = getDocument().getRegionAtCharacterOffset(partitionStartOffset);
	boolean handled = false;

	handled = prepareTextRegions(structuredDocumentRegion, partitionStartOffset, partitionLength, holdResults);

	return handled;
	}

	/**
	* @param region
	* @param start
	* @param length
	* @param holdResults
	* @return
	*/
	private boolean prepareTextRegion(ITextRegionCollection blockedRegion, int partitionStartOffset, int partitionLength, Collection holdResults) {
	boolean handled = false;
	final int partitionEndOffset = partitionStartOffset + partitionLength - 1;
	ITextRegion region = null;
	ITextRegionList regions = blockedRegion.getRegions();
	int nRegions = regions.size();
	StyleRange styleRange = null;
	for (int i = 0; i < nRegions; i++) {
	region = regions.get(i);
	TextAttribute attr = null;
	TextAttribute previousAttr = null;
	if (blockedRegion.getStartOffset(region) > partitionEndOffset)
	break;
	if (blockedRegion.getEndOffset(region) <= partitionStartOffset)
	continue;

	if (region instanceof ITextRegionCollection) {
	handled = prepareTextRegion((ITextRegionCollection) region, partitionStartOffset, partitionLength, holdResults);
	} else {

	attr = getAttributeFor(blockedRegion, region);
	if (attr != null) {
	handled = true;
	// if this region's attr is the same as previous one, then
	// just adjust the previous style range
	// instead of creating a new instance of one
	// note: to use 'equals' in this case is important, since
	// sometimes
	// different instances of attributes are associated with a
	// region, even the
	// the attribute has the same values.
	// TODO: this needs to be improved to handle readonly
	// regions correctly
	if ((styleRange != null) && (previousAttr != null) && (previousAttr.equals(attr))) {
	styleRange.length += region.getLength();
	} else {
	styleRange = createStyleRange(blockedRegion, region, attr, partitionStartOffset, partitionLength);
	holdResults.add(styleRange);
	// technically speaking, we don't need to update
	// previousAttr
	// in the other case, because the other case is when
	// it hasn't changed
	previousAttr = attr;
	}
	} else {
	previousAttr = null;
	}
	}
	}
	return handled;
	}

	private boolean prepareTextRegions(IStructuredDocumentRegion structuredDocumentRegion, int partitionStartOffset, int partitionLength, Collection holdResults) {
	boolean handled = false;
	final int partitionEndOffset = partitionStartOffset + partitionLength - 1;
	while (structuredDocumentRegion != null && structuredDocumentRegion.getStartOffset() <= partitionEndOffset) {
	ITextRegion region = null;
	ITextRegionList regions = structuredDocumentRegion.getRegions();
	int nRegions = regions.size();
	StyleRange styleRange = null;
	for (int i = 0; i < nRegions; i++) {
	region = regions.get(i);
	TextAttribute attr = null;
	TextAttribute previousAttr = null;
	if (structuredDocumentRegion.getStartOffset(region) > partitionEndOffset)
	break;
	if (structuredDocumentRegion.getEndOffset(region) <= partitionStartOffset)
	continue;

	if (region instanceof ITextRegionCollection) {
	boolean handledCollection = (prepareTextRegion((ITextRegionCollection) region, partitionStartOffset, partitionLength, holdResults));
	handled = (!handled) ? handledCollection : handled;
	} else {

	attr = getAttributeFor(structuredDocumentRegion, region);
	if (attr != null) {
	handled = true;
	// if this region's attr is the same as previous one,
	// then just adjust the previous style range
	// instead of creating a new instance of one
	// note: to use 'equals' in this case is important,
	// since sometimes
	// different instances of attributes are associated
	// with a region, even the
	// the attribute has the same values.
	// TODO: this needs to be improved to handle readonly
	// regions correctly
	if ((styleRange != null) && (previousAttr != null) && (previousAttr.equals(attr))) {
	styleRange.length += region.getLength();
	} else {
	styleRange = createStyleRange(structuredDocumentRegion, region, attr, partitionStartOffset, partitionLength);
	holdResults.add(styleRange);
	// technically speaking, we don't need to update
	// previousAttr
	// in the other case, because the other case is
	// when it hasn't changed
	previousAttr = attr;
	}
	} else {
	previousAttr = null;
	}
	}

	if (Debug.syntaxHighlighting && !handled) {
	System.out.println("not handled in prepareRegions"); //$NON-NLS-1$
	}
	}
	structuredDocumentRegion = structuredDocumentRegion.getNext();
	}
	return handled;
	}

	protected void registerPreferenceManager() {
	IPreferenceStore pref = getColorPreferences();
	if (pref != null) {
	pref.addPropertyChangeListener(fPreferenceListener);
	}
	}

	public void release() {
	unRegisterPreferenceManager();
	if (fTextAttributes != null) {
	fTextAttributes.clear();
	fTextAttributes = null;
	}
	setInitialized(false);
	}

	/**
	* Sets the initialized.
	*
	* @param initialized
	* The initialized to set
	*/
	private void setInitialized(boolean initialized) {
	this.fInitialized = initialized;
	}

	protected void unRegisterPreferenceManager() {
	IPreferenceStore pref = getColorPreferences();
	if (pref != null) {
	pref.removePropertyChangeListener(fPreferenceListener);
	}
	}
	}