/**
* This file Copyright (c) 2005-2008 Aptana, Inc. This program is
* dual-licensed under both the Aptana Public License and the GNU General
* Public license. You may elect to use one or the other of these licenses.
*
* This program is distributed in the hope that it will be useful, but
* AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
* NONINFRINGEMENT. Redistribution, except as permitted by whichever of
* the GPL or APL you select, is prohibited.
*
* 1. For the GPL license (GPL), you can redistribute and/or modify this
* program under the terms of the GNU General Public License,
* Version 3, as published by the Free Software Foundation. You should
* have received a copy of the GNU General Public License, Version 3 along
* with this program; if not, write to the Free Software Foundation, Inc., 51
* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Aptana provides a special exception to allow redistribution of this file
* with certain Eclipse Public Licensed code and certain additional terms
* pursuant to Section 7 of the GPL. You may view the exception and these
* terms on the web at http://www.aptana.com/legal/gpl/.
*
* 2. For the Aptana Public License (APL), this program and the
* accompanying materials are made available under the terms of the APL
* v1.0 which accompanies this distribution, and is available at
* http://www.aptana.com/legal/apl/.
*
* You may view the GPL, Aptana's exception and additional terms, and the
* APL in the file titled license.html at the root of the corresponding
* plugin containing this source file.
*
* Any modifications to this file must keep this entire header intact.
*/
package com.aptana.ide.logging;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.StringTokenizer;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.resource.ColorRegistry;
import org.eclipse.jface.resource.FontRegistry;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWTError;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Display;
import com.aptana.ide.core.IdeLog;
import com.aptana.ide.editors.unified.LanguageRegistry;
import com.aptana.ide.editors.unified.colorizer.ColorizerReader;
import com.aptana.ide.editors.unified.colorizer.LanguageColorizer;
import com.aptana.ide.logging.coloring.TokenTypes;
import com.aptana.ide.logging.preferences.ILoggingPreferenceListener;
import com.aptana.ide.logging.preferences.LoggingStructureProvider;
/**
* Logging preferences.
* @author Denis Denisenko
*/
public class LoggingPreferences
{
public static class Rule
{
/**
* Rule name.
*/
private String name;
/**
* Rule content.
*/
private String rule;
/**
* Whether content is regexp.
*/
private boolean isRegexp;
/**
* Whether rule is case insensitive.
*/
private boolean isCaseInsensitive;
/**
* Rule constructor.
* @param name - rule name.
* @param rule - rule content.
* @param isRegexp - whether rule is regexp.
* @param isCaseInsensitive - whether rule is case insensetive.
*/
public Rule(String name, String rule, boolean isRegexp, boolean isCaseInsensitive)
{
this.name = name;
this.rule = rule;
this.isRegexp = isRegexp;
this.isCaseInsensitive = isCaseInsensitive;
}
/**
* Gets rule name.
* @return the name
*/
public String getName()
{
return name;
}
/**
* Gets rule content.
* @return the rule
*/
public String getRule()
{
return rule;
}
/**
* Gets whether rule content is regexp.
* @return the isRegexp
*/
public boolean isRegexp()
{
return isRegexp;
}
/**
* Sets new rule. Does not update any dependencies.
* @param rule - rule to set.
*/
public void setRule(String rule)
{
this.rule = rule;
}
/**
* Gets whether rule is case insensitive.
* @return whether rule is case insensitive.
*/
public boolean isCaseInsensitive()
{
return isCaseInsensitive;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
/**
* {@inheritDoc}
*/
@Override
public boolean equals(Object obj)
{
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Rule other = (Rule) obj;
if (name == null)
{
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
/**
* {@inheritDoc}
*/
@Override
public String toString()
{
return name;
}
}
/**
* Modifiable rules list.
* @author Denis Denisenko
*/
private class RulesList extends AbstractList<Rule>
{
/**
* Base.
*/
private List<Rule> base;
/**
* RulesList constructor.
* @param base - list to base on.
*/
public RulesList(List<Rule> base)
{
this.base = base;
}
/**
* {@inheritDoc}
*/
@Override
public Rule get(int index)
{
return base.get(index);
}
/**
* {@inheritDoc}
*/
@Override
public int size()
{
return base.size();
}
/**
* {@inheritDoc}
*/
@Override
public void add(int index, Rule element)
{
if (base.contains(element))
{
return;
}
base.add(index, element);
saveRules(base);
notifyRulesChanged();
}
/**
* {@inheritDoc}
*/
@Override
public Rule remove(int index)
{
Rule toReturn = base.remove(index);
saveRules(base);
notifyRulesChanged();
return toReturn;
}
/**
* {@inheritDoc}
*/
@Override
public void clear()
{
base.clear();
saveRules(base);
notifyRulesChanged();
}
/**
* {@inheritDoc}
*/
@Override
public boolean addAll(int index, Collection<? extends Rule> c)
{
boolean added = base.addAll(index, c);
saveRules(base);
return added;
}
}
/**
* Colorizer ID.
*/
public static final String COLORIZER_ID = "com.aptana.ide.logging.coloring.colorizer"; //$NON-NLS-1$
/**
* Base preference key.
*/
private static final String BASE_KEY = "com.aptana.ide.logging.preferences.LoggingPreferences"; //$NON-NLS-1$
/**
* Default rules extension point ID.
*/
public static final String DEFAULT_RULES_POINT_ID = "com.aptana.ide.logging.defaultRules"; //$NON-NLS-1$
/**
* Rules list length key.
*/
private static final String LENGTH_KEY = BASE_KEY + "_length"; //$NON-NLS-1$
/**
* Rules list name key.
*/
private static final String NAME_KEY = BASE_KEY + "_name"; //$NON-NLS-1$
/**
* Rules list content key.
*/
private static final String CONTENT_KEY = BASE_KEY + "_content"; //$NON-NLS-1$
/**
* Rules list isRegexp key.
*/
private static final String REGEXP_KEY = BASE_KEY + "_isregexp"; //$NON-NLS-1$
/**
* Rules list isRegexp key.
*/
private static final String CASEINSENSITIVE_KEY = BASE_KEY + "_iscasesensitive"; //$NON-NLS-1$
/**
* Autobolding key.
*/
private static final String AUTOBOLDING_KEY = BASE_KEY + "_autobolding"; //$NON-NLS-1$
/**
* Wrapping key.
*/
private static final String WRAPPING_KEY = BASE_KEY + "_wrapping"; //$NON-NLS-1$
/**
* Key for main text font.
*/
public static final String MAIN_TEXT_FONT_KEY = BASE_KEY + ".maintextfont"; //$NON-NLS-1$
/**
* Key for preference of whether to color cursor line.
*/
public static final String CURSORLINE_KEY = BASE_KEY + ".cursorline"; //$NON-NLS-1$
/**
* Key for cursor line color.
*/
public static final String CURSORLINE_COLOR_KEY = BASE_KEY + ".cursorlinecolor"; //$NON-NLS-1$
/**
* Key for text color.
*/
public static final String TEXT_COLOR_KEY = BASE_KEY + ".textcolor"; //$NON-NLS-1$
/**
* Key for read timeout.
*/
public static final String READ_TIMEOUT_KEY = BASE_KEY + ".readtimeout"; //$NON-NLS-1$
/**
* Key for read buffer.
*/
public static final String READ_BUFFER_KEY = BASE_KEY + ".readbuffer"; //$NON-NLS-1$
/**
* Key for default encoding.
*/
public static final String DEFAULT_ENCODING_KEY = BASE_KEY + ".defaultencoding"; //$NON-NLS-1$
/**
* Backlog lines key.
*/
private static final String BACKLOG_LINES_KEY = BASE_KEY + ".backloglines"; //$NON-NLS-1$
/**
* Default font size for windows.
*/
private static final int WINDOWS_DEFAULT_FONT_SIZE = 9;
/**
* Default font size for MacOS.
*/
private static final int MAC_OS_DEFAULT_FONT_SIZE = 10;
/**
* Default font size for Linux.
*/
private static final int LINUX_DEFAULT_FONT_SIZE = 10;
/**
* DEFAULT_FONT_FAMILY
*/
private static final String DEFAULT_FONT_FAMILY = "Courier"; //$NON-NLS-1$
/**
* Rule element name.
*/
private static final Object RULE_ELEMENT = "rule"; //$NON-NLS-1$
/**
* Rule name attribute.
*/
private static final String NAME_ATTRIBVUTE = "name"; //$NON-NLS-1$
/**
* Rule content attribute.
*/
private static final String CONTENT_ATTRIBUTE = "content"; //$NON-NLS-1$
/**
* Rule isRegexp attribute.
*/
private static final String ISREGEXP_ATTRIBUTE = "regexp"; //$NON-NLS-1$
/**
* Rule isCaseInsensitive attribute.
*/
private static final String ISCASEINSENSITIVE_ATTRIBUTE = "caseInsensitive"; //$NON-NLS-1$
/**
* Rule isBold attribute.
*/
private static final String BOLD_ATTRIBUTE = "bold"; //$NON-NLS-1$
/**
* Rule isItalic attribute.
*/
private static final String ITALIC_ATTRIBUTE = "italic"; //$NON-NLS-1$
/**
* Rule isUnderline attribute.
*/
private static final String UNDERLINE_ATTRIBUTE = "underline"; //$NON-NLS-1$
/**
* Rule isColor attribute.
*/
private static final String COLOR_ATTRIBUTE = "color"; //$NON-NLS-1$
/**
* Rules.
*/
private RulesList rules;
/**
* Listeners.
*/
private List<ILoggingPreferenceListener> listeners = new ArrayList<ILoggingPreferenceListener>();
/**
* Listeners, pending to be added.
*/
private List<ILoggingPreferenceListener> pendingToAddListeners = new ArrayList<ILoggingPreferenceListener>();
/**
* Listeners, pending to be removed.
*/
private List<ILoggingPreferenceListener> pendingToRemoveListeners = new ArrayList<ILoggingPreferenceListener>();
/**
* Autobolding.
*/
private Boolean autoBolding;
/**
* Wrapping.
*/
private Boolean wrapping;
/**
* Font registry.
*/
private FontRegistry fontRegistry = new FontRegistry(Display.getCurrent());
/**
* Whether main font is initialized.
*/
private boolean mainFontLoaded = false;
/**
* Color registry.
*/
private ColorRegistry colorRegistry = new ColorRegistry(Display.getCurrent());
/**
* Read timeout.
*/
private Integer readTimeout;
/**
* Read buffer.
*/
private Integer readBuffer;
/**
* Defautl encoding.
*/
private String defaultEncoding;
/**
* Backlog lines.
*/
private Integer backLogLines;
/**
* Gets the modifiable list of the names of the regexp-based rules.
* @return names of the regexp-based rules.
*/
public List<Rule> getRules()
{
if (rules == null)
{
final List<Rule> base = loadRules();
rules = new RulesList(base);
}
return rules;
}
/**
* Initializes preferences.
*/
public void initializePreferences()
{
IPreferenceStore store = getPreferenceStore();
store.setDefault(WRAPPING_KEY, false);
store.setDefault(AUTOBOLDING_KEY, true);
store.setDefault(CURSORLINE_KEY, true);
PreferenceConverter.setDefault(store, CURSORLINE_COLOR_KEY, new RGB(233, 233, 235));
PreferenceConverter.setDefault(store, TEXT_COLOR_KEY, new RGB(128,128,128));
store.setDefault(READ_TIMEOUT_KEY, 100);
store.setDefault(READ_BUFFER_KEY, 1024 * 32);
store.setDefault(DEFAULT_ENCODING_KEY, "UTF-8"); //$NON-NLS-1$
store.setDefault(BACKLOG_LINES_KEY, 750);
initializeDefaultFont();
//if no colorization info is available, writting defaults
if (store.getString(LENGTH_KEY).length() == 0)
{
initializeDefaultRules();
}
}
/**
* Gets whether "auto-bolding" on new data is on.
* @return whether "auto-bolding" on new data is on.
*/
public boolean getAutoBolding()
{
if (autoBolding == null)
{
loadAutoBolding();
}
return autoBolding;
}
/**
* Sets autobolding value.
* @param autobolding - autobolding to set.
*/
public void setAutoBolding(boolean autobolding)
{
this.autoBolding = autobolding;
saveAutoBolding();
}
/**
* Gets read timeout.
* @return read timeout.
*/
public int getReadTimeout()
{
if (readTimeout == null)
{
loadReadTimeout();
}
return readTimeout;
}
/**
* Sets autobolding value.
* @param autobolding - autobolding to set.
*/
public void setReadTimeout(int readtimeout)
{
this.readTimeout = readtimeout;
saveReadTimeout();
}
/**
* Gets read timeout.
* @return read timeout.
*/
public int getReadBuffer()
{
if (readBuffer == null)
{
loadReadBuffer();
}
return readBuffer;
}
/**
* Sets readbuffer value.
* @param readbuffer - readbuffer to set.
*/
public void setReadBuffer(int readbuffer)
{
this.readBuffer = readbuffer;
saveReadBuffer();
}
/**
* Gets whether wrapping is on.
* @return whether wrapping is on.
*/
public boolean getWrapping()
{
if (wrapping == null)
{
loadWrapping();
}
return wrapping;
}
/**
* Sets wrap value.
* @param wrapping - true if wrapping is on, false otherwise.
*/
public void setWrapping(boolean wrapping)
{
this.wrapping = wrapping;
saveWrapping();
notifyWrappingChanged(wrapping);
}
/**
* Gets backlog lines.
* @return
*/
public int getBacklogLines()
{
if (backLogLines == null)
{
loadBacklogLines();
}
return backLogLines;
}
/**
* Sets backlog lines.
* @param lines - lines to set.
*/
public void setBacklogLines(int lines)
{
backLogLines = lines;
saveBacklogLines();
}
/**
* Sets cursor line color.
* @param rgb - RGB to set.
*/
public void setCursorLineColor(RGB rgb)
{
PreferenceConverter.setValue(getPreferenceStore(), CURSORLINE_COLOR_KEY, rgb);
}
/**
* Gets cursor line color.
* @return cursor line color.
*/
public RGB getCursorLineColor()
{
return PreferenceConverter.getColor(getPreferenceStore(), CURSORLINE_COLOR_KEY);
}
/**
* Gets text color.
* @return cursor line color.
*/
public RGB getTextColorRGB()
{
RGB color = colorRegistry.getRGB(TEXT_COLOR_KEY);
if (color == null)
{
RGB rgb = PreferenceConverter.getColor(getPreferenceStore(), TEXT_COLOR_KEY);
colorRegistry.put(TEXT_COLOR_KEY, rgb);
color = colorRegistry.getRGB(TEXT_COLOR_KEY);
}
return color;
}
/**
* Gets text color.
* @return cursor line color.
*/
public Color getTextColor()
{
Color color = colorRegistry.get(TEXT_COLOR_KEY);
if (color == null)
{
RGB rgb = PreferenceConverter.getColor(getPreferenceStore(), TEXT_COLOR_KEY);
colorRegistry.put(TEXT_COLOR_KEY, rgb);
color = colorRegistry.get(TEXT_COLOR_KEY);
}
return color;
}
/**
* Sets text color.
* @param rgb - RGB to set.
*/
public void setTextColor(RGB rgb)
{
PreferenceConverter.setValue(getPreferenceStore(), TEXT_COLOR_KEY, rgb);
colorRegistry.put(TEXT_COLOR_KEY, rgb);
notifyForegroundColorChanged(colorRegistry.get(TEXT_COLOR_KEY));
}
/**
* Gets font data.
* @return font data.
*/
public FontData[] getFontData()
{
synchronized (fontRegistry)
{
loadMainFont();
return fontRegistry.getFontData(MAIN_TEXT_FONT_KEY);
}
}
/**
* Gets font.
* @return main font.
*/
public Font getFont()
{
synchronized (fontRegistry)
{
loadMainFont();
return fontRegistry.get(MAIN_TEXT_FONT_KEY);
}
}
/**
* Sets font data.
* @param data - data to set.
*/
public void setFontData(FontData[] data)
{
synchronized (fontRegistry)
{
PreferenceConverter.setValue(getPreferenceStore(), MAIN_TEXT_FONT_KEY, data);
fontRegistry.put(MAIN_TEXT_FONT_KEY, data);
notifyFontChanged(fontRegistry.get(MAIN_TEXT_FONT_KEY));
mainFontLoaded = true;
}
}
//////////////////////////
/**
* Gets whether "auto-bolding" on new data is on.
* @return whether "auto-bolding" on new data is on.
*/
public boolean getDefaultAutoBolding()
{
IPreferenceStore store = getPreferenceStore();
return store.getDefaultBoolean(AUTOBOLDING_KEY);
}
/**
* Gets default backlog lines.
* @return default backlog lines.
*/
public int getDefaultBacklogLines()
{
IPreferenceStore store = getPreferenceStore();
return store.getDefaultInt(BACKLOG_LINES_KEY);
}
/**
* Gets read timeout.
* @return read timeout.
*/
public int getDefaultReadTimeout()
{
IPreferenceStore store = getPreferenceStore();
return store.getDefaultInt(READ_TIMEOUT_KEY);
}
/**
* Gets read timeout.
* @return read timeout.
*/
public int getDefaultReadBuffer()
{
IPreferenceStore store = getPreferenceStore();
return store.getDefaultInt(READ_BUFFER_KEY);
}
/**
* Gets whether wrapping is on.
* @return whether wrapping is on.
*/
public boolean getDefaultWrapping()
{
IPreferenceStore store = getPreferenceStore();
return store.getDefaultBoolean(WRAPPING_KEY);
}
/**
* Gets default cursor line color.
* @return cursor line color.
*/
public RGB getDefaultCursorLineColor()
{
return PreferenceConverter.getDefaultColor(getPreferenceStore(), CURSORLINE_COLOR_KEY);
}
/**
* Gets default text color.
* @return text color.
*/
public RGB getDefaultTextColor()
{
return PreferenceConverter.getDefaultColor(getPreferenceStore(), TEXT_COLOR_KEY);
}
/**
* Gets font data.
* @return font data.
*/
public FontData[] getDefaultFont()
{
return PreferenceConverter.getDefaultFontDataArray(getPreferenceStore(), MAIN_TEXT_FONT_KEY);
}
/**
* @return
*/
public String getDefaultDefaultEncoding()
{
IPreferenceStore store = getPreferenceStore();
return store.getDefaultString(DEFAULT_ENCODING_KEY);
}
//////////////////////////
/**
* Adds logging preference listener.
* @param listener - listener to add.
*/
public void addPreferenceListener(ILoggingPreferenceListener listener)
{
pendingToAddListeners.add(listener);
}
/**
* Removes logging preference listener.
* @param listener - listener to remove.
*/
public void removePreferenceListener(ILoggingPreferenceListener listener)
{
pendingToRemoveListeners.add(listener);
}
/**
* @param defaultEncoding
*/
public void setDefaultEncoding(String defaultEncoding)
{
this.defaultEncoding = defaultEncoding;
saveDefaultEncoding();
}
/**
* @return
*/
public String getDefaultEncoding()
{
if (defaultEncoding == null)
{
loadDefaultEncoding();
}
return defaultEncoding;
}
/**
* Creates language colorizer.
*/
public static void createLanguageColorizer()
{
ColorizerReader reader = new ColorizerReader(TokenTypes.getTokenList());
LanguageColorizer lc = reader.loadColorization(LoggingPreferences.COLORIZER_ID, true);
if (lc != null)
{
LanguageRegistry.registerLanguageColorizer(TokenTypes.LANGUAGE, lc);
}
if (lc == null)
{
lc = new LanguageColorizer(TokenTypes.LANGUAGE);
LanguageRegistry.registerLanguageColorizer(TokenTypes.LANGUAGE, lc);
LanguageRegistry.setPreferenceId(TokenTypes.LANGUAGE, LoggingPreferences.COLORIZER_ID);
}
}
/**
* Gets maximum number of lines single regexp may match.
* @return max regexp lines.
*/
public int getRegexpMaxLines()
{
return 1;
}
/**
* Fills default coloring rules.
*/
public void initializeDefaultRules()
{
createLanguageColorizer();
LoggingStructureProvider provider = new LoggingStructureProvider();
fillDefaultRules(provider);
provider.buildLanguageColorizer(
LanguageRegistry.getLanguageColorizer(TokenTypes.LANGUAGE),
LoggingPreferences.COLORIZER_ID);
provider.applyChanges();
}
/**
* Reads rules from preferences.
* @return rules.
*/
private List<Rule> loadRules()
{
IPreferenceStore store = getPreferenceStore();
int length = store.getInt(LENGTH_KEY);
List<Rule> result = new ArrayList<Rule>();
for (int i = 0; i < length; i++)
{
String ruleName = store.getString(NAME_KEY + i);
String ruleContent = store.getString(CONTENT_KEY + i);
Boolean ruleIsRegexp = store.getBoolean(REGEXP_KEY + i);
Boolean isCaseInsensitive = store.getBoolean(CASEINSENSITIVE_KEY + i);
Rule rule = new Rule(ruleName, ruleContent, ruleIsRegexp, isCaseInsensitive);
result.add(rule);
}
return result;
}
/**
* Writes rules to preferences.
* @param rules - rules to write.
*/
private void saveRules(List<Rule> rules)
{
//clearing previous values
clearList();
//saving
IPreferenceStore store = getPreferenceStore();
store.setValue(LENGTH_KEY, rules.size());
for (int i = 0; i < rules.size(); i++)
{
Rule rule = rules.get(i);
store.setValue(NAME_KEY + i, rule.getName());
store.setValue(CONTENT_KEY + i, rule.getRule());
store.setValue(REGEXP_KEY + i, rule.isRegexp());
store.setValue(CASEINSENSITIVE_KEY + i, rule.isCaseInsensitive());
}
}
/**
* Clears list in preferences.
*/
private void clearList()
{
IPreferenceStore store = getPreferenceStore();
int length = store.getDefaultInt(LENGTH_KEY);
for (int i = 0; i < length; i++)
{
store.setValue(NAME_KEY + i, ""); //$NON-NLS-1$
store.setValue(CONTENT_KEY + i, ""); //$NON-NLS-1$
store.setValue(REGEXP_KEY + i, false);
store.setValue(CASEINSENSITIVE_KEY + i, false);
}
}
/**
* Gets preference store.
* @return preference store.
*/
private IPreferenceStore getPreferenceStore()
{
return LoggingPlugin.getDefault().getPreferenceStore();
}
/**
* Notifies listeners that rules are changed.
*/
private void notifyRulesChanged()
{
for (ILoggingPreferenceListener listener : getListeners())
{
listener.rulesChanged();
}
}
/**
* Notifies listeners that wrapping mode is changed.
* @param wrapping - new wrapping value.
*/
private void notifyWrappingChanged(boolean wrapping)
{
for (ILoggingPreferenceListener listener : getListeners())
{
listener.wrappingChanged(wrapping);
}
}
/**
* Notifies listeners that font is changed.
* @param font - new font value.
*/
private void notifyFontChanged(Font font)
{
for (ILoggingPreferenceListener listener : getListeners())
{
listener.fontChanged(font);
}
}
/**
* Notifies listeners that text foreground color is changed.
* @param color - new color value.
*/
private void notifyForegroundColorChanged(Color color)
{
for (ILoggingPreferenceListener listener : getListeners())
{
listener.textForegroundColorChanged(color);
}
}
/**
* Gets current listeners.
* @return current listeners.
*/
private List<ILoggingPreferenceListener> getListeners()
{
listeners.addAll(pendingToAddListeners);
listeners.removeAll(pendingToRemoveListeners);
pendingToAddListeners.clear();
pendingToRemoveListeners.clear();
return listeners;
}
/**
* Saves autobolding.
*/
private void saveAutoBolding()
{
if(autoBolding != null)
{
IPreferenceStore store = getPreferenceStore();
store.setValue(AUTOBOLDING_KEY, autoBolding);
}
}
/**
* Loads autobolding.
*/
private void loadAutoBolding()
{
IPreferenceStore store = getPreferenceStore();
autoBolding = store.getBoolean(AUTOBOLDING_KEY);
}
/**
* Saves read timeout.
*/
private void saveReadTimeout()
{
if(readTimeout != null)
{
IPreferenceStore store = getPreferenceStore();
store.setValue(READ_TIMEOUT_KEY, readTimeout);
}
}
/**
* Loads read timeout.
*/
private void loadReadTimeout()
{
IPreferenceStore store = getPreferenceStore();
readTimeout = store.getInt(READ_TIMEOUT_KEY);
}
/**
* Saves read buffer.
*/
private void saveReadBuffer()
{
if(readBuffer != null)
{
IPreferenceStore store = getPreferenceStore();
store.setValue(READ_BUFFER_KEY, readBuffer);
}
}
/**
* Loads read buffer.
*/
private void loadReadBuffer()
{
IPreferenceStore store = getPreferenceStore();
readBuffer = store.getInt(READ_BUFFER_KEY);
}
/**
* Saves wrapping.
*/
private void saveWrapping()
{
if(wrapping != null)
{
IPreferenceStore store = getPreferenceStore();
store.setValue(WRAPPING_KEY, wrapping);
}
}
/**
* Loads wrapping.
*/
private void loadWrapping()
{
IPreferenceStore store = getPreferenceStore();
wrapping = store.getBoolean(WRAPPING_KEY);
}
/**
* Saves default encoding.
*/
private void saveDefaultEncoding()
{
IPreferenceStore store = getPreferenceStore();
store.setValue(DEFAULT_ENCODING_KEY, defaultEncoding);
}
/**
* Loads default encoding.
*/
private void loadDefaultEncoding()
{
IPreferenceStore store = getPreferenceStore();
defaultEncoding = store.getString(DEFAULT_ENCODING_KEY);
}
/**
* Saves backlog lines.
*/
private void saveBacklogLines()
{
IPreferenceStore store = getPreferenceStore();
store.setValue(BACKLOG_LINES_KEY, backLogLines);
}
/**
* Load backlog lines.
*/
private void loadBacklogLines()
{
IPreferenceStore store = getPreferenceStore();
backLogLines = store.getInt(BACKLOG_LINES_KEY);
}
/**
* Fills default coloring rules.
* @param provider - structure provider.
*/
public void fillDefaultRules(LoggingStructureProvider provider)
{
loadRulesFromExtensions(provider);
//provider.addRule("Jaxer-TRACE", "^\d\d\:\d\d\:\d\d\ .{10}\ \[\s*\d+\]\[TRACE\]", true, true, new RGB(60,132,96), false, false, false);
//provider.addRule("Jaxer-DEBUG", "^\d\d\:\d\d\:\d\d\ .{10}\ \[\s*\d+\]\[DEBUG\]", true, true, new RGB(0,0,255), false, false, false);
//provider.addRule("Jaxer-INFO", "^\d\d\:\d\d\:\d\d\ .{10}\ \[\s*\d+\]\[INFO\]", true, true, new RGB(128,64,0), false, false, false);
//provider.addRule("Jaxer-WARN", "^\\d\\d\\:\\d\\d\\:\\d\\d\\ .{10}\\ \\[\\s*\\d+\\]\\[WARNING\\]", true, true, new RGB(255,128,0), false, false, false);
//provider.addRule("Jaxer-FATAL", "^\d\d\:\d\d\:\d\d\ .{10}\ \[\s*\d+\]\[FATAL\ ERROR\]", true, true, new RGB(255,0,0), true, false, false);
//provider.addRule("Jaxer-ERROR", "^\d\d\:\d\d\:\d\d\ .{10}\ \[\s*\d+\]\[ERROR", true, true, new RGB(255, 0, 0), false, false, false);
//provider.addRule("ApacheError-emerg", "^\\[(\\w|\\ |\\:)+\\]\\ \\[emerg\\]\\ ", true, true, new RGB(255, 0, 0), true, true, true);
//provider.addRule("ApacheError-alert", "^\[(\w|\ |\:)+\]\ \[alert\]\ ", true, true, new RGB(255, 0, 0), true, true, false);
//provider.addRule("ApacheError-crit", "^\[(\w|\ |\:)+\]\ \[crit\]\ ", true, true, new RGB(255, 0, 0), true, false, false);
//provider.addRule("ApacheError-error", "^\[(\w|\ |\:)+\]\ \[error\]\ ", true, true, new RGB(255, 0, 0), false, false, false);
//provider.addRule("ApacheError-warn", "^\[(\w|\ |\:)+\]\ \[warn\]\ ", true, true, new RGB(255, 128, 0), false, false, false);
//provider.addRule("ApacheError-notice", "^\[(\w|\ |\:)+\]\ \[notice\]\ ", true, true, new RGB(128, 0, 255), false, false, false);
//provider0.addRule("ApacheError-info", "^\[(\w|\ |\:)+\]\ \[info\]\ ", true, true, new RGB(128, 64, 64), false, false, false);
//provider.addRule("ApacheError-debug", "^\[(\w|\ |\:)+\]\ \[debug\]\ ", true, true, new RGB(0, 0, 255), false, false, false);
//provider.addRule("Default", ".*", true, true, new RGB(128,128,128), false, false, false);
}
/**
* Loads rules from plug-in extensions.
* @param provider - provider to contribute rules to.
*/
private void loadRulesFromExtensions(LoggingStructureProvider provider)
{
IExtensionRegistry registry = Platform.getExtensionRegistry();
IExtensionPoint ep = registry.getExtensionPoint(DEFAULT_RULES_POINT_ID);
if (ep != null)
{
IExtension[] extensions = ep.getExtensions();
for (int i = 0; i < extensions.length; i++)
{
IExtension extension = extensions[i];
IConfigurationElement[] elements = extension.getConfigurationElements();
for (int j = 0; j < elements.length; j++)
{
IConfigurationElement element = elements[j];
String elementName = element.getName();
if (elementName.equals(RULE_ELEMENT))
{
String name = element.getAttribute(NAME_ATTRIBVUTE);
String content = element.getAttribute(CONTENT_ATTRIBUTE);
boolean isRegexp = getBooleanAttribute(element, ISREGEXP_ATTRIBUTE, true);
boolean isCaseSensitive = getBooleanAttribute(element, ISCASEINSENSITIVE_ATTRIBUTE, false);
boolean isBold = getBooleanAttribute(element, BOLD_ATTRIBUTE, false);
boolean isItalic = getBooleanAttribute(element, ITALIC_ATTRIBUTE, false);
boolean isUnderline = getBooleanAttribute(element, UNDERLINE_ATTRIBUTE, false);
String colorString = element.getAttribute(COLOR_ATTRIBUTE);
RGB color = new RGB(0, 0, 0);
try
{
color = getRGB(colorString);
}
catch (IllegalArgumentException ex)
{
IdeLog.logError(LoggingPlugin.getDefault(), Messages.getString("LoggingPreferences.ERR_WrongFormat") + colorString); //$NON-NLS-1$
}
provider.addRule(name, content, isRegexp, isCaseSensitive, color, isBold, isItalic, isUnderline);
}
}
}
}
}
/**
* Gets RGB from string.
* @param colorString - color string
* @return RGB.
* @throws IllegalArgumentException if string is not a legal RGB representation.
*/
private RGB getRGB(String colorString) throws IllegalArgumentException
{
if (colorString == null)
{
throw new IllegalArgumentException("Null is not a valid RGB"); //$NON-NLS-1$
}
StringTokenizer tokenizer = new StringTokenizer(colorString, ","); //$NON-NLS-1$
try
{
String red = tokenizer.nextToken().trim();
String green = tokenizer.nextToken().trim();
String blue = tokenizer.nextToken().trim();
int rval = 0, gval = 0, bval = 0;
rval = Integer.parseInt(red);
gval = Integer.parseInt(green);
bval = Integer.parseInt(blue);
return new RGB(rval, gval, bval);
}
catch (Throwable e)
{
throw new IllegalArgumentException(e.getMessage());
}
}
/**
* Initializes default font.
*/
private void initializeDefaultFont()
{
Font defaultFont = JFaceResources.getDefaultFont();
FontData[] data = defaultFont.getFontData();
String osName = System.getProperty("os.name", "Windows"); //$NON-NLS-1$ //$NON-NLS-2$
int height = data[0].getHeight();
if (data != null && data.length > 0)
{
if (osName.startsWith("Windows")) //$NON-NLS-1$
{
height = WINDOWS_DEFAULT_FONT_SIZE;
}
else if (osName.startsWith("Linux")) //$NON-NLS-1$
{
height = LINUX_DEFAULT_FONT_SIZE;
}
else if (osName.startsWith("Mac OS")) //$NON-NLS-1$
{
height = MAC_OS_DEFAULT_FONT_SIZE;
}
}
data[0].setHeight(height);
if (supports(DEFAULT_FONT_FAMILY, height))
{
data[0].setName(DEFAULT_FONT_FAMILY);
}
PreferenceConverter.setDefault(getPreferenceStore(), MAIN_TEXT_FONT_KEY, data);
}
/**
* Cheks whether font is supported.
* @param name - font name.
* @param height - font size.
* @return true if supports, false otherwise.
*/
private boolean supports(String name, int height)
{
try
{
Font font = new Font(Display.getCurrent(), name, height, 0);
font.dispose();
return true;
}
catch(SWTError error)
{
return false;
}
}
/**
* Gets boolean attribute.
* @param element - element.
* @param name - attribute name.
* @param defaultValue - default value to use.
* @return attribute value.
*/
private boolean getBooleanAttribute(IConfigurationElement element, String name, boolean defaultValue)
{
String attributeString = element.getAttribute(name);
if (attributeString == null)
{
return defaultValue;
}
return Boolean.parseBoolean(attributeString);
}
/**
* Loads main font.
*/
private void loadMainFont()
{
if (!mainFontLoaded)
{
FontData[] data = PreferenceConverter.getFontDataArray(getPreferenceStore(),
MAIN_TEXT_FONT_KEY);
fontRegistry.put(MAIN_TEXT_FONT_KEY, data);
mainFontLoaded = true;
}
}
/**
* LoggingPreferences private constructor.
*/
LoggingPreferences()
{
}
}