Editor Language Overview

What is editor language?

Editor language is used in MPS to define presentation and editing aspects of the language (some aspects of editing can be specified in actions language, but it is possible to use only editor language for them). MPS editor is cell based i.e. nodes are shown as different kinds of nested cells. To create an editor in MPS you have to declare a ConceptEditorDeclaration instance for your concept. You can specify in it a template that describes how the concept will be presented.

Cells in editor

Almost everything that you see in an editor is build from cells. Cells which represent a node form a tree with a root cell representing a whole node and child cells which represent its referents, children, properties etc. Base interface for all cells is jetbrains.mps.nodeEditor.EditorCell. Every cell occupy a rectangle area of an editor and knows how to draw and layout itself and children if there are some (see the methods paint(Graphics g) and relayout()). For cells that can contain other cells there is a base class jetbrains.mps.nodeEditor.EditorCell_Collection, it can contain collection of children and has a layout manager that knows how to layout them. In MPS we has 3 layouts : horizontal layout, vertical layout and flow layout.

How to create simple editor

When you define a ConceptEditorDeclaration you describe how to create a cell (with children cells) that will represent instance of a concept. For this task we have template language in that you can easily describe how editor creation will be performed. Actually you define two editors: one editor that will be displayed in main editor component and another one that will be displayed in inspector. Usually main editor contains basic pieces of information about editor and inspector contain more specific ones. For example in editor language almost all presentation attributes are hidden in editor.

In ConceptEditorDeclaration process of editor creation described using meta cells. Each meta cell translated into one or many cells during concept creation. Most import of them are:

• Constant cell - use it to create some constant text. Example of this cell is a word 'class' in class's editor
• Horizontal collection is used to create collection cell that will have horizontal layout
• Vertical collection is used to create collection cell that will have vertical layout
• Property cell - use it to edit property. In this cell you have to specify which property you will edit and editor generator will then create a cell that will handle editing
• ref.node cell - use it if you want to use in your editor an editor for node that can be found via reference or agregation link of a current node
• ref.node list - this kind of cell is very similar to ref.node cell but allows many children to be inserted. this kind of meta cell can be horizontal or vertical.
• ref.cell - use it to create a cell for some members of linked (i.e. referenced or aggregated) node. Use it if you do not want to create a full editor for that node here (in some sense you may consider it being an anonymous editor declaration for the linked node)

Improving editor behaviour

When you are editing nodes in MPS it is possible to edit them in different ways. Most common of them are: completion menus that appear when you press control+space, and node insert and delete actions that are activated when you press enter, insert, delete. When you declare editor MPS generates sensible default editing actions but there are situations when you have to alter this default behaviour to improve your language usability. For example in Base Language we have local variables and local variable references. In editor for variable references MPS generates completion menu that shows all variables from this model and all imported models (it's a default behaviour) However, Base Language scoping rules restrict usage of the most of that variables. For instance, you can't reference local variable declared in one method in another methods. So if you want you editor to be more usable you have to override such defaults.

In MPS there are several parts of editor behaviour that you can override:

• KeyMaps - MPS editor key maps are sets of actions attached to a cell and executed on key press. They contain pairs of keystrokes and actions. To declare keymap you have to create KeyMap root node in your language's editor model. To attach keymap to a cell you can choose a keymap in the inspector
• Substitute actions - substitute actions specify a menu that will appear when you press control+space. You can use editor language to declare them but this feature is deprecated now. If you want to redefine them you have to use actions language
• Right transform actions - often people are typing code with a sequence of transformations. For example when you type 'a + b + c' you first type 'a' then type '+' then type 'b' and finally type 'c'. It is possible to type a code in MPS in such a way. An action that happens when you press '+' after 'a' is called right transform action. It is also recomended to redefine right transfrom actions through actions language