gradle_tooling_api_sample.groovy

@GrabResolver('http://repo.gradle.org/gradle/libs/')
@Grab('org.gradle:gradle-tooling-api:1.0')
import org.gradle.tooling.GradleConnector
import org.gradle.tooling.ProgressListener
import org.gradle.tooling.model.GradleProject
import org.gradle.tooling.model.GradleTask
import groovy.swing.*
import groovy.ui.SystemOutputInterceptor;
import javax.swing.*
import javax.swing.tree.*
import java.awt.BorderLayout as BL
import groovy.beans.Bindable
import javax.swing.JFileChooser as JFC

def node(value, children=[]) {
    children.inject(new DefaultMutableTreeNode(value)) { root, child ->
        root.add((child instanceof TreeNode) ? child : node(child)); root
    }
}

def handleProject(project, parentNode) {
    project.children.each {
        def child = node(it)
        it.tasks.each { task ->
            child << node(task)
        }
        parentNode << child
        handleProject(it, child)
    }
}

def r = new DefaultTreeCellRenderer()
def cellRenderer = [
    getTreeCellRendererComponent: { JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row,boolean hasFocus ->
        r.getTreeCellRendererComponent(tree, value.userObject.name, sel, expanded, leaf, row, hasFocus)
    }
] as DefaultTreeCellRenderer

class Model {
    @Bindable String status = ''
    File projectRoot
    @Bindable def treeModel
}
def model = new Model()

new SwingBuilder().edt { frame(show:true, size:[800,600]) {
    def doGradle = { c ->
        doOutside {
            edt { progressBar.visible = true }
            def connector = GradleConnector.newConnector()
            connector.forProjectDirectory(model.projectRoot)
            def connection
            try {
                connection = connector.connect()
                c(connection)
            } finally {
                connection?.close()
                doLater { progressBar.visible = false }
            }
        }
    }
    popupMenu(id:'contextMenu') {
        menuItem 'Run task', actionPerformed: { e ->
            def task = tree.lastSelectedPathComponent.userObject
            doGradle { conn ->
                def launcher = conn.newBuild()
                launcher.forTasks(task)
                launcher.addProgressListener({ progress ->
                    doLater {
                        model.status = progress.description
                    }
                } as ProgressListener)
                doLater {
                    console.text = ''
                }
                def interceptor = new SystemOutputInterceptor({str ->
                    doLater {
                        console.append str
                    }
                    false
                })
                interceptor.start()
                launcher.run()
            }

        }
    }
    fileChooser(id:'fc', dialogTitle:'Open Gradle project', fileSelectionMode:JFC.DIRECTORIES_ONLY)
    menuBar {
        menu 'File', {
            menuItem 'Open Gradle project', actionPerformed: {
                if (fc.showOpenDialog() != JFC.CANCEL_OPTION) {
                    model.projectRoot = fc.selectedFile
                    doGradle { conn ->
                        def project = conn.getModel(GradleProject)
                        def rootNode = node(project)
                        handleProject(project, rootNode)
                        project.tasks.each {
                            rootNode << node(it)
                        }
                        model.treeModel = new DefaultTreeModel(rootNode)
                    }
                }
            }
        }
    }
    splitPane(dividerLocation:300, constraints:BL.CENTER) {
        scrollPane {
            tree(id:'tree', model:bind('treeModel', source:model), cellRenderer:cellRenderer,
                mousePressed: { e ->
                    if (e.popupTrigger && tree.selectionCount == 1) {
                        def path = tree.getPathForLocation(e.x, e.y)
                        tree.selectionPath = path
                        def uo = path.lastPathComponent.userObject
                        if (uo in GradleTask) {
                            contextMenu.show(e.source, e.x, e.y)
                        }
                    }
                },
                valueChanged: { e ->
                    model.status = tree.selectionPaths*.lastPathComponent*.userObject*.path?.join(', ')
                })
        }
        scrollPane {
            textArea(id:'console', editable:false)
        }
    }
    panel(constraints:BL.SOUTH) {
        gridLayout(rows:1, cols:2)
        label(text:bind('status', source:model))
        progressBar(id:'progressBar', visible:false, indeterminate:true)
    }
}}