Implementing Custom Form Controls

If the built-in form controls are not sufficient for your needs, you can implement custom form controls in Java.

You can specify them using the following properties:

rendererClassName - the name of the class that draws the edited value. It must be an implementation of ro.sync.ecss.extensions.api.editor.InplaceRenderer. The renderer has to be a SWING implementation and can be used both in the standalone and Eclipse distributions.
swingEditorClassName - you can use this property for the standalone (Swing-based) distribution to specify the name of the class used for editing. It is a Swing implementation of ro.sync.ecss.extensions.api.editor.InplaceEditor.
swtEditorClassName - you can use this property for the Eclipse plug-in distribution to specify the name of the class used for editing. It is a SWT implementation of the ro.sync.ecss.extensions.api.editor.InplaceEditor.
classpath - you can use this property to specify the location of the classes used for a custom form control. The value of the classpath property is an enumeration of URLs separated by comma.
edit - if your form control edits the value of an attribute or the text value of an element, you can use the @attribute_name and #text predefined values and oxygen will perform the commit logic by itself. You can use the custom value to perform the commit logic yourself.

Custom Form Control Implementation

Sample Java code for a custom combo box form control implementation that inserts an XML element in the content when the editing stops:

public class ComboBoxEditor  extends AbstractInplaceEditor {
  /**
   * @see ro.sync.ecss.extensions.api.editor.InplaceEditor#stopEditing()
   */
  @Override
   public void stopEditing() {
     Runnable customCommit =  new Runnable() {
      @Override
       public void run() {
        AuthorDocumentController documentController = context.getAuthorAccess().getDocumentController();
        documentController.insertXMLFragment( "<custom/>", offset);
      }
    };
    EditingEvent event =  new EditingEvent(customCommit,  true);
    fireEditingStopped(event);
  }

If the custom form control is intended to work in the Oxygen XML Editor standalone distribution, the declaration of swtEditorClassName is not required. The renderer (the class that draws the value) and the editor (the class that edits the value) have different properties because you can present a value in one way and edit it in another.

The custom form controls can use any of the predefined properties of the oxy_editor function, as well as specified custom properties. This is an example of how to specify a custom form control:

myElement {
    content: oxy_editor(
        rendererClassName, "com.custom.editors.CustomRenderer",
        swingEditorClassName, "com.custom.editors.SwingCustomEditor",
        swtEditorClassName, "com.custom.editors.SwtCustomEditor",
        edit, "@my_attr",
        customProperty1, "customValue1",
        customProperty2, "customValue2"
    )
}

Note: Add these custom Java implementations in the classpath of the document type associated with the document you are editing. To get you started, the Java sources for the SimpleURLChooserEditor are available in the Oxygen SDK.

The oxy_editor function can receive other functions as parameters for obtaining complex behaviors.

The following example shows how the combo box editor can obtain its values from the current XML file by calling the oxy_xpath function:

link:before{
      content: "Managed by:"
        oxy_editor(
            type, combo, 
            edit, "@manager",
            values, oxy_xpath('string-join(//@id , ",") '));