Eclipse PDE: Everything about Editor Part 3

Syntax Highlighting

Part 3 of Eclipse PDE: Everything about Editor series deals with Syntax coloring. In previous post I have explained about all Eclipse Editor relegated concepts and document partition.

I have tried to explains Syntax highlighting in editor in this post. Syntax highlighting helps to provides different color and styles to different part of code. Eclipse provides a presentation reconciler, which divides the document into a set of tokens that define the background and foreground color, along with the font style for a section of text.

The document partitions define the content types within a document, while the presentation reconciler divided those individual content types into tokens for sets of characters that share the same color and font style. The presentation of the document must be maintained while the user continues to modify it. This is done through the use of a damager and a repairer.

A Damager takes the description of how the document was modified and returns a description of regions of the document that must be updated. For example, if a user types /*, all the text in the document up to */ must be repaired

The Repairer takes care of actually repairing the region of the document that the damager output by using the rules for dividing the region into tokens and the color and font information associated with the tokens.

Following steps explains process of defining syntax highlighter for custom editor.

1. Define Color provider

This class is responsible for providing color for specific set of tokens. 

public class MyColorProvider {
    public static final RGB MULTI_LINE_COMMENT = new RGB(128, 0, 0);
    public static final RGB SINGLE_LINE_COMMENT = new RGB(128, 128, 0);
    public static final RGB DEFAULT = new RGB(0, 0, 0);
    protected Map fColorTable = new HashMap(10);
 
    public void dispose() {
        Iterator e = fColorTable.values().iterator();
        while (e.hasNext())
            ((Color) e.next()).dispose();
    }
 
    public Color getColor(RGB rgb) {
        Color color = (Color) fColorTable.get(rgb);
        if (color == null) {
            color = new Color(Display.getCurrent(), rgb);
            fColorTable.put(rgb, color);
        }
        return color;
    }
}

2. Create rule for document scanner.



public class MyCodeScanner extends RuleBasedScanner {
 
    public MyCodeScanner(MyColorProvider provider) {
        IToken singleLineComment=
        new Token(new
        TextAttribute(provider.getColor(MyColorProvider.SINGLE_LINE_COMMENT)));
        IToken multiLineComment=
            new Token(new
            TextAttribute(provider.getColor(MyColorProvider.MULTI_LINE_COMMENT)));
        List rules= new ArrayList();
        // Add rule for single & multi line comments.
        rules.add(new EndOfLineRule("//", singleLineComment));
        rules.add(new MultiLineRule("/*","*/", multiLineComment));
        
        
        IRule[] result= new IRule[rules.size()];
        rules.toArray(result);
        setRules(result);
    }
}

3. Provide PresentationReconciler in SourceViewConfiguration, which defines damager & repairer for each segment of code.



@Override
    public IPresentationReconciler getPresentationReconciler(
            ISourceViewer sourceViewer) {
        PresentationReconciler rc = new PresentationReconciler();
        
        DefaultDamagerRepairer dr= new DefaultDamagerRepairer(getCodeScanner());
        rc.setDamager(dr, IDocument.DEFAULT_CONTENT_TYPE);
        rc.setRepairer(dr, IDocument.DEFAULT_CONTENT_TYPE);
 
        dr= new DefaultDamagerRepairer(getCodeScanner());
        rc.setDamager(dr, MyPartitionScanner.SINGLE_LINE_COMMENT);
        rc.setRepairer(dr, MyPartitionScanner.SINGLE_LINE_COMMENT);
        
        dr= new DefaultDamagerRepairer(getCodeScanner());
        rc.setDamager(dr, MyPartitionScanner.MULTI_LINE_COMMENT);
        rc.setRepairer(dr, MyPartitionScanner.MULTI_LINE_COMMENT);
        
        return rc;
    }
    
    public MyCodeScanner getCodeScanner(){
        if(cScanner == null){
            cScanner = new MyCodeScanner(new MyColorProvider());
        }
        return cScanner;
    }

 

Run the plug-in as Eclipse Application, create .properties file (As we have defined custom editor in previous post in this series) and try typing single line comment and multi line comment. You will notice , color of this comment will be different than normal code section as shown in figure below.

 

image

 

 

 

Comments

  1. Ian GrahamNovember 17, 2011 at 10:36 PM

    I'm not sure that the DefaultDamagerRepairer will correctly manage your multi-line comment and text following it. Try including some other text after it, and then delete the "*/" and type it in again. I think the following text won't be updated properly.

    If I'm correct, the easiest solution would be to set up the multi-line comment as its own partition, because edits that alter partitioning will result in repartitioning more of the following text. You can either use a deprecated constructor for DefaultDamagerRepairer(eep!) to set the color and font, or grab a copy of NonRuleBasedDamagerRepairer.java from one of the examples to do the same thing.

    ReplyDelete
  2. AnonymousJune 10, 2012 at 10:13 AM

    NonRuleBasedDamagerRepairer.java really helpful. thanks.

    ReplyDelete
  3. AnonymousSeptember 13, 2024 at 11:52 AM

    Respect and I have a neat supply: How Many Home Renovation Shows Are There green home remodeling

    ReplyDelete

Post a Comment

Popular posts from this blog

State Design Pattern by Example

Image
State pattern falls under the category of Behavioral patterns. State design pattern comes in picture when a system’s behavior is depends on its own state or some other resource’s state. If an implementation is depends on the states, we end up with snarl of conditional statement every where in code. A very neat approach to deal with such situation is to separate out every state’s behavior and use them where ever they are applicable. The state pattern allows an object to alter its behavior when is internal state changes . The object is appeared to change its class. State pattern is a way to implement the same. Class Diagram : As above class diagram shows, System class holds state instance. As state of system changes , all handle request delegated to respective State’s concrete implementation. Example : Have an example of Vending machine. Vending machine has following states No Coin Inserted Coin Inserted Dispensing Empty Following diagram explain behavior...
Read more

Eclipse command framework core expression: Property tester

Image
Addition to Eclipse command framework series, this post explains use of property tester to control command’s enable/visible properties. In earlier post we have tried declarative way to achieve same thing but property tester gives us more control. Property tester is associated with, tester class which implements PropertyTester.java, a namespace and set of property which it supports. We can refer this property tester using its namespace + a property name. It gives you call back to test() method with property name as parameter inside property tester class. We can configure property tester for type of input parameter. Here is sample declaration of property tester extension point < extension point ="org.eclipse.core.expressions.propertyTesters" > < propertyTester class ="com.example.advance.cmd.EditorTester" id ="com.example.advance.cmd.propertyTester1" namespace ="com.example.advance.cm...
Read more

Composite Design Pattern by example

Image
This post explains Composite design pattern with an example. When to use ? – Use Composite pattern when you have treat a collection of objects as they were once one thing. With Composite design pattern it is very easy to simplify operations over collection data structure. It reduces complexity of the code required if you were going to handle collection as special case. How to Use? - The Composite pattern consist of Component, Leaf and Composite Classes as shown below class diagram Component – Component declares the common interface that both the single and composite nodes will implements Leaf – The leaf class represent the singular atomic data type implementing he component interface.     Composite – Composite is an abstract entity which declares common functionality which are needed by concrete implementation for handling collection data. An Example -   Item.java public interface Item {     public double getPrice(); ...
Read more