# Eclipse Plugins mit Scala



## Thomas Darimont (24. Juni 2008)

Hallo,

hier mal ein Beispiel wie man mit Scala Eclipse Plugins schreiben kann.

Dazu installieren wir uns zunächst einmal das neue Scala Plugin und starten unser Eclpse neu.
http://www.scala-lang.org/tools/eclipse/index.html
Update site URL: http://scala-lang.org/downloads/scala-plugin-beta

Wir legen ein Eclipse Plugin Projekt mit dem Namen: de.tutorials.scala.eclipse, lassen alle sonstigen Einstellungen
unverändert und wählen das Hello, World Template aus. Aktivator brauchen wir in dem Fall keinen. Wir können den Eintrag im Plugin.xml und die Klasse getrost löschen.

Nun schließen wir eclipse und editieren die .project und .classpath Datein unseres Plug-in Projektes:
Unsere neue .project Datei sollte so ausschauen:

```
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
    <name>de.tutorials.scala.eclipse</name>
    <comment></comment>
    <projects>
    </projects>
    <buildSpec>
            <buildCommand>
            <name>ch.epfl.lamp.sdt.core.scalabuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
        <buildCommand>
            <name>org.eclipse.jdt.core.javabuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
        <buildCommand>
            <name>org.eclipse.pde.ManifestBuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
        <buildCommand>
            <name>org.eclipse.pde.SchemaBuilder</name>
            <arguments>
            </arguments>
        </buildCommand>

    </buildSpec>
    <natures>
        <nature>org.eclipse.pde.PluginNature</nature>
        <nature>org.eclipse.jdt.core.javanature</nature>
        <nature>ch.epfl.lamp.sdt.core.scalanature</nature>
    </natures>
</projectDescription>
```

Unsere neue .classpath Datei so:

```
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
        <classpathentry kind="con" path="ch.epfl.lamp.sdt.launching.SCALA_CONTAINER"/>
    <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
    <classpathentry kind="src" path="src"/>
    <classpathentry kind="output" path="bin"/>
</classpath>
```

Anschließend fügen wir im plugin.xml bei den Dependencies bei Required Plug-ins noch scala.library (2.7.1) hinzu.

Nur erstellen wir uns eine Action mit scala:
Unsere Scala Action:

```
package de.tutorials.scala.eclipse.actions

import org.eclipse.jface.action.IAction
import org.eclipse.jface.viewers.ISelection
import org.eclipse.ui.IWorkbenchWindow
import org.eclipse.ui.IWorkbenchWindowActionDelegate
import org.eclipse.jface.dialogs.MessageDialog

class ScalaSampleAction extends IWorkbenchWindowActionDelegate  {
    var window :IWorkbenchWindow = null
    
    /**
     * The action has been activated. The argument of the
     * method represents the 'real' action sitting
     * in the workbench UI.
     * @see IWorkbenchWindowActionDelegate#run
     */
    override def run(action:IAction) {
        MessageDialog.openInformation(
            window.getShell,
            "Eclipse Plug-in",
            "Hello, Eclipse & Scala world")
    }

    /**
     * Selection in the workbench has been changed. We 
     * can change the state of the 'real' action here
     * if we want, but this can only happen after 
     * the delegate has been created.
     * @see IWorkbenchWindowActionDelegate#selectionChanged
     */
    override def selectionChanged(action:IAction, selection:ISelection) {
    }

    /**
     * We can use this method to dispose of any system
     * resources we previously allocated.
     * @see IWorkbenchWindowActionDelegate#dispose
     */
    override def dispose() {
    }

    /**
     * We will cache window object in order to
     * be able to provide parent shell for the message dialog.
     * @see IWorkbenchWindowActionDelegate#init
     */
    override def init(window:IWorkbenchWindow ) {
        this.window = window
    }
}
```

Nun wechseln wir ins plugin.xml zu den Extensions und stellen dort bei der Sample Action unter 
class: de.tutorials.scala.eclipse.actions.ScalaSampleAction ein.

Anschließend können wir die Anwendung ausprobieren. Dazu klicken wir einfach unser Projektverzeichnis an 
und wählen im Kontextmenü Run As -> Eclipse Application aus.

Nun sollte man in der Menuleiste einen Samplemenu-Eintrag sehen.
Das scala Plugin hat manchmal noch ein paar macken... so wird ein Scala File manchmal partout nicht kompiliert.
Wenn ihr also in euerem Projektverzeichnis
de.tutorials.scala.eclipse\bin\de\tutorials\scala\eclipse\actions nur eine ScalaSampleAction.scala und keine
ScalaSampleAction.class seht, dann müsst könnt ihr euch auch mit einem Ant Build Script behelfen welches die 
Scala-Dateien explizit kompiliert.

Dazu kann man ganz einfach die in Scala enthaltenen Ant Tasks verwenden:
http://www.scala-lang.org/tools/ant/index.html

Gruß Tom


----------

