Application: gvSIG desktop » gvSIG scripting

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	DefaultExampleManager class.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.scripting.impl.DefaultExampleManager">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

#set( $symbol_pound = '#' )

#set( $symbol_dollar = '$' )

#set( $symbol_escape = '\' )

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

#set( $symbol_pound = '#' )

#set( $symbol_dollar = '$' )

#set( $symbol_escape = '\' )

For each class you are going to test, create one Test class with the same

name as the class to test, ending with Test.

For example, the unit tests of the "ExampleLibrary" class are performed

by the "ExampleLibraryTest" class.

// jEdit settings:

// :tabSize=4:indentSize=4:noTabs=true:folding=explicit:collapseFolds=1:

package thinletcommons;

import java.io.BufferedInputStream;

import java.io.FileInputStream;

import java.io.InputStream;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import thinlet.FrameLauncher;

import thinlet.Thinlet;

public class ThinletTester

{

    private static String file = null;

    private static String thinletClassname = "thinlet.Thinlet";

    private static String handlerClassname = null;

    public static void main(String[] args) throws Throwable

    {

        getArgs(args);

        run();

    }

    private static void getArgs(String[] args)

    {

        if(args.length < 1 || args.length > 5)

            usage();

        for(int i = 0; i < args.length; ++i)

        {

            if(args[i].equals("--help"))

                usage();

            else if(args[i].equals("--thinlet"))

            {

                if(i == args.length - 1)

                    usage();

                else

                    thinletClassname = args[++i];

            }

            else if(args[i].equals("--handler"))

            {

                if(i == args.length - 1)

                    usage();

                else

                    handlerClassname = args[++i];

            }

            else if(file == null)

                file = args[i];

            else

                usage();

        }

        if(file == null)

            usage();

    }

    private static void usage()

    {

        System.out.println("ThinletTester, version 1.0");

        System.out.println();

        System.out.println("Usage: java [-cp <classpath>] thinletcommons.ThinletTester [--thinlet <classname>]");

        System.out.println("         [--handler <classname>] thinletfile.xml");

        System.out.println();

        System.out.println("  --thinlet  Thinlet classname, e.g. thinlet.Thinlet");

        System.out.println("  --handler  Handler classname, e.g. foo.bar.MyHandler");

        System.out.println();

        System.out.println("  The classpath must include both the Thinlet class and the handler class (if");

        System.out.println("  given on the commandline) as well as thinlet.jar.");

        System.out.println("  The specified Thinlet class and Handler class must have a default");

        System.out.println("  constructor.");

        System.out.println();

        System.exit(1);

    }

    private static void run() throws Throwable

    {

        // create Thinlet instance

        Class thinletClass = Class.forName(thinletClassname);

        Object thinlet = thinletClass.newInstance();

        if(!Thinlet.class.isInstance(thinlet))

        {

            System.err.println("error: " + thinletClassname + " is not a Thinlet class.");

            System.exit(2);

        }

        System.out.println("using thinlet class: " + thinletClass.getName());

        // create Handler instance

        Object handler = thinlet;

        if(handlerClassname != null)

        {

            Class handlerClass = Class.forName(handlerClassname);

            handler = handlerClass.newInstance();

            System.out.println("using handler class: " + handlerClass.getName());

        }

        InputStream is = getInputStream(file);

        System.out.println("parsing file " + file + " ...");

        // "Object result = thinlet.parse(is, handler);"

        Method parseMethod = thinletClass.getMethod("parse", new Class[] { InputStream.class, Object.class });

        Object result;

        try

        {

            result = parseMethod.invoke(thinlet, new Object[] { is, handler });

        }

        catch(InvocationTargetException e)

        {

            throw e.getTargetException();

        }

        // "thinlet.add(result);"

        Method addMethod = thinletClass.getMethod("add", new Class[] { Object.class });

        try

        {

            addMethod.invoke(thinlet, new Object[] { result });

        }

        catch(InvocationTargetException e)

        {

            throw e.getTargetException();

        }

        System.out.println("showing frame...");

        /*FrameLauncher frame = new FrameLauncher("ThinletTester", null, (Thinlet)thinlet, 400, 400, false);

        frame.pack();

        frame.setVisible(true);

*/

        System.out.println("done.");

    }

    private static InputStream getInputStream(String filename) throws Exception

    {

        return new BufferedInputStream(new FileInputStream(filename));

    }

}

// jEdit settings:

// :tabSize=4:indentSize=4:noTabs=true:folding=explicit:collapseFolds=1:

package thinletcommons;

import java.awt.Dialog;

import java.awt.Frame;

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.io.File;

import java.text.Collator;

import java.util.Arrays;

import java.util.Comparator;

import java.util.Stack;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.filechooser.FileSystemView;

import thinlet.Thinlet;

/**

 * A Thinlet directory chooser dialog.

 *

 * <p>

 * The dialog is modal and blocks the calling frame/dialog. It is therefore

 * displayed in a separate window.

 *

 * <p>

 * <b>TODO:</b>

 * <ul>

 *   <li>Button "Create directory"</li>

 * </ul>

 *

 * <p>

 * <b>Implementation note:</b> This implementation uses

 * <code>javax.swing.filechooser.FileSystemView</code>, because it provides

 * directory information that looks more "native". This introduces a dependency

 * on Swing, but since ThinG requires JDK 1.4, Swing should be there anyway.

 * Only a minimal set of Swing classes is loaded while using

 * <code>javax.swing.filechooser.FileSystemView</code>; alas, the loading

 * of <code>javax.swing.UIManager</code> and <code>javax.swing.LookAndFeel</code>

 * can <i>not</i> be avoided, although no Swing beans are actually used.

 *

 * @author Dirk Moebius

 */

public class DirChooser

{

    //{{{ logging

    private static final Logger log = Logger.getLogger("thinletcommons");

    private static final boolean debug() { return log.isLoggable(Level.FINE); }

    //}}}

    private ThinletDialog dialog;

    private Thinlet thinlet;

    private File selectedDir;

    private File expandDir;

    private boolean isInitialized = false;

    private FileSystemView fsv = FileSystemView.getFileSystemView();

    public DirChooser(Frame owner, String title)

    {

        this.dialog = new ThinletDialog(owner, title);

        init();

    }

    public DirChooser(Dialog owner, String title)

    {

        this.dialog = new ThinletDialog(owner, title);

        init();

    }

    private void init()

    {

        thinlet = new AntiAliasedThinlet();

        try

        {

            Object panel = thinlet.parse("/thinletcommons/dirchooser.xml", this);

            thinlet.add(panel);

        }

        catch(Exception e)

        {

            log.log(Level.SEVERE, "Error parsing dirchooser.xml", e);

        }

        dialog.setContent(thinlet);

    }

    /**

     * Show the modal dialog.

     * This halts the application until the user dismisses the dialog.

     */

    public void show()

    {

        selectedDir = null;

        if(expandDir != null)

        {

            expandTreeTo(expandDir);

            expandDir = null;

        }

        dialog.pack();

        dialog.setLocationRelativeTo(dialog.getOwner());

        dialog.setVisible(true);

    }

    public void setSelectedDirectory(File dir)

    {

        this.expandDir = dir;

    }

    public File getSelectedDirectory()

    {

        return selectedDir;

    }

    //{{{ callbacks for dirchooser.xml

    /** Thinlet callback. */

    public void init(Object tree)

    {

        if(debug()) log.fine("in init()");

        if(!isInitialized)

        {

            addFiles(fsv.getRoots(), tree);

            isInitialized = true;

        }

    }

    /** Thinlet callback. */

    public void ok(Object tree)

    {

        Object node = thinlet.getSelectedItem(tree);

        if(node != null)

            selectedDir = (File) thinlet.getProperty(node, "file");

        close();

    }

    /** Thinlet callback. */

    public void close()

    {

        dialog.setVisible(false);

    }

    /** Thinlet callback. */

    public void nodeExpanded(Object tree, Object node)

    {

        File file = (File) thinlet.getProperty(node, "file");

        // remove all existing nodes below the selected node (including

        // dummy placeholder nodes)

        thinlet.removeAll(node);

        // re-add subdirectory nodes below current node

        File[] files = fsv.getFiles(file, false);

        addFiles(files, node);

    }

    //}}}

    //{{{ private methods

    private void addFiles(File[] files, Object parent)

    {

        sort(files);

        for(int i = 0; i < files.length; ++i)

        {

            File file = files[i];

            if(fsv.isTraversable(file).booleanValue())

            {

                // it's  directory; create a node for it

                Object node = createNode(file);

                thinlet.setBoolean(node, "expanded", false);

                thinlet.add(parent, node);

                // create a placeholder node for the (possible) children of

                // the directory

                Object placeholder = Thinlet.create("node");

                thinlet.setBoolean(placeholder, "expanded", false);

                thinlet.setString(placeholder, "text", "#Placeholder#");

                thinlet.add(node, placeholder);

                //thinlet.putProperty(node, "hasDummyChild", Boolean.TRUE);

            }

        }

    }

    private Object createNode(File file)

    {

        Object node = Thinlet.create("node");

        thinlet.setString(node, "text", fsv.getSystemDisplayName(file));

        Icon icon = fsv.getSystemIcon(file);

        if(icon != null)

            thinlet.setIcon(node, "icon", convertIconToImage(thinlet, icon));

        thinlet.putProperty(node, "file", file);

        return node;

    }

    private void sort(File[] files)

    {

        if(files.length == 0)

            return;

        // don't sort if first file is a special (non-disc) file

        File firstFile = files[0];

        if(fsv.isComputerNode(firstFile) || fsv.isDrive(firstFile)

            || fsv.isFileSystemRoot(firstFile) || fsv.isFloppyDrive(firstFile)

            || fsv.isRoot(firstFile))

            return;

        Arrays.sort(files, new Comparator()

        {

            private  Collator collator = Collator.getInstance();

            public int compare(Object obj1, Object obj2)

            {

                return collator.compare(

                    fsv.getSystemDisplayName((File)obj1),

                    fsv.getSystemDisplayName((File)obj2)

                );

            }

            public boolean equals(Object other)

            {

                // unused

                return false;

            }

        });

    }

    private void expandTreeTo(File file)

    {

        Stack stack = new Stack();

        stack.push(file);

        File root = null;

        File parent = file;

        // find root, fill stack

        do

        {

            parent = fsv.getParentDirectory(parent);

            if(parent != null)

            {

                stack.push(parent);

                root = parent;

            }

        } while(parent != null);

        if(root == null)

        {

            log.warning("cannot expand to directory '" + file + "' because parent not found!");

            return;

        }

        Object tree = thinlet.find("tree");

        _expandTreeTo(tree, stack);

    }

    private void _expandTreeTo(Object node, Stack stack)

    {

        File currentDir = (File) stack.pop();

        Object[] nodes = thinlet.getItems(node);

        boolean found = false;

        for(int i = 0; i < nodes.length; ++i)

        {

            Object subnode = nodes[i];

            File file = (File) thinlet.getProperty(subnode, "file");

            if(!found && file.equals(currentDir))

            {

                thinlet.removeAll(subnode);

                File[] subfiles = fsv.getFiles(file, false);

                addFiles(subfiles, subnode);

                if(stack.empty())

                    thinlet.setBoolean(subnode, "selected", true);

                else

                {

                    thinlet.setBoolean(subnode, "expanded", true);

                    _expandTreeTo(subnode, stack);

                    found = true;

                }

            }

        }

    }

    private static Image convertIconToImage(Thinlet thinlet, Icon icon)

    {

        BufferedImage image = new BufferedImage(icon.getIconWidth(),

            icon.getIconHeight(), BufferedImage.TYPE_INT_ARGB);

        icon.paintIcon(thinlet, image.getGraphics(), 0, 0);

        return image;

    }

    //}}}

}

// jEdit settings:

// :tabSize=4:indentSize=4:noTabs=true:folding=explicit:collapseFolds=1:

package thinletcommons;

import java.awt.Color;

import java.awt.Dialog;

import java.awt.Frame;

import java.util.logging.Level;

import java.util.logging.Logger;

import thinlet.Thinlet;

/**

 * A Thinlet color chooser dialog.

 *

 * <p>

 * The dialog is modal and blocks the calling frame/dialog. It is therefore

 * displayed in a separate window.

 *

 * @author Dirk Moebius

 */

public class ColorChooser

{

    //{{{ logging

    private static final Logger log = Logger.getLogger("thinletcommons");

    private static final boolean debug() { return log.isLoggable(Level.FINE); }

    //}}}

    private ThinletDialog dialog;

    private Thinlet thinlet;

    private Color selectedColor;

    // components

    private Object sl_red, sl_green, sl_blue;

    private Object sb_red, sb_green, sb_blue;

    private Object tf_hue, tf_saturation, tf_brightness;

    private Object pb_hue, pb_saturation, pb_brightness;

    private Object rgb_label;

    public ColorChooser(Frame owner, String title)

    {

        this.dialog = new ThinletDialog(owner, title);

        init();

    }

    public ColorChooser(Dialog owner, String title)

    {

        this.dialog = new ThinletDialog(owner, title);

        init();

    }

    private void init()

    {

        thinlet = new AntiAliasedThinlet();

        try

        {

            Object panel = thinlet.parse("/thinletcommons/colorchooser.xml", this);

            thinlet.add(panel);

        }

        catch(Exception e)

        {

            log.log(Level.SEVERE, "Error parsing colorchooser.xml", e);

        }

        dialog.setContent(thinlet);

    }

    /**

     * Show the modal dialog.

     * This halts the application until the user dismisses the dialog.

     */

    public void show()

    {

        if(debug()) log.fine("in show");

        dialog.pack();

        dialog.setResizable(false);

        dialog.setLocationRelativeTo(dialog.getOwner());

        dialog.setVisible(true);

    }

    public void setSelectedColor(Color color)

    {

        int red = 0, green = 0, blue = 0;

        if(color != null)

        {

            red = color.getRed();

            green = color.getGreen();

            blue = color.getBlue();

            thinlet.setInteger(sl_red, "value", red);

            thinlet.setInteger(sl_green, "value", green);

            thinlet.setInteger(sl_blue, "value", blue);

            thinlet.setString(sb_red, "text", String.valueOf(red));

            thinlet.setString(sb_green, "text", String.valueOf(green));

            thinlet.setString(sb_blue, "text", String.valueOf(blue));

            hsbChanged();

        }

    }

    public Color getSelectedColor()

    {

        return selectedColor;

    }

    //{{{ callbacks for colorchooser.xml

    /** Thinlet callback. */

    public void init(Object sl_red, Object sl_green, Object sl_blue,

        Object sb_red, Object sb_green, Object sb_blue,

        Object tf_hue, Object tf_saturation, Object tf_brightness,

        Object pb_hue, Object pb_saturation, Object pb_brightness,

        Object rgb_label)

    {

        if(debug()) log.fine("in init");

        this.sl_red = sl_red;

        this.sl_green = sl_green;

        this.sl_blue = sl_blue;

        this.sb_red = sb_red;

        this.sb_green = sb_green;

        this.sb_blue = sb_blue;

        this.tf_hue = tf_hue;

        this.tf_saturation = tf_saturation;

        this.tf_brightness = tf_brightness;

        this.pb_hue = pb_hue;

        this.pb_saturation = pb_saturation;

        this.pb_brightness = pb_brightness;

        this.rgb_label = rgb_label;

    }

    /** Thinlet callback. */

    public void sliderChanged(int value, Object spinbox)

    {

        thinlet.setString(spinbox, "text", String.valueOf(value));

        hsbChanged();

    }

    /** Thinlet callback. */

    public void spinboxChanged(String text, Object slider)

    {

        try

        {

            int value = Integer.parseInt(text);

            if(value >= 0 && value <= 255)

            {

                thinlet.setInteger(slider, "value", value);

                hsbChanged();

            }

        }

        catch (NumberFormatException ignore)

        {

        }

    }

    /** Thinlet callback. */

    public void ok()

    {

        int red = thinlet.getInteger(sl_red, "value");

        int green = thinlet.getInteger(sl_green, "value");

        int blue = thinlet.getInteger(sl_blue, "value");

        this.selectedColor = new Color(red, green, blue);

        dialog.setVisible(false);

    }

    /** Thinlet callback. */

    public void close()

    {

        dialog.setVisible(false);

    }

    //}}}

    //{{{ private methods

    private void hsbChanged()

    {

        int red = thinlet.getInteger(sl_red, "value");

        int green = thinlet.getInteger(sl_green, "value");

        int blue = thinlet.getInteger(sl_blue, "value");

        float[] hsb = Color.RGBtoHSB(red, green, blue, null);

        thinlet.setColor(rgb_label, "background", new Color(red, green, blue));

        thinlet.setString(tf_hue, "text", String.valueOf(hsb[0]));

        thinlet.setString(tf_saturation, "text", String.valueOf(hsb[1]));

        thinlet.setString(tf_brightness, "text", String.valueOf(hsb[2]));

        thinlet.setInteger(pb_hue, "value", (int) (100f * hsb[0]));

        thinlet.setInteger(pb_saturation, "value", (int) (100f * hsb[1]));

        thinlet.setInteger(pb_brightness, "value", (int) (100f * hsb[2]));

    }

    //}}}

}

// jEdit settings:

// :tabSize=4:indentSize=4:noTabs=true:folding=explicit:collapseFolds=1:

package thinletcommons;

import java.awt.Dialog;

import java.awt.Frame;

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.io.File;

import java.text.Collator;

import java.text.DateFormat;

import java.text.DecimalFormat;

import java.util.Arrays;

import java.util.Comparator;

import java.util.Date;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.filechooser.FileSystemView;

import thinlet.Thinlet;

/**

 * A Thinlet file chooser dialog.

 *

 * <p>

 * The dialog is modal and blocks the calling frame/dialog. It is therefore

 * displayed in a separate window.

 *

 * <p>

 * <b>TODO:</b>

 * <ul>

 *   <li>For mode OPEN: multiple selection</li>

 *   <li>Button "Create directory"</li>

 * </ul>

 *

 * <p>

 * <b>Implementation note:</b> This implementation uses

 * <code>javax.swing.filechooser.FileSystemView</code>, because it provides

 * directory information that looks more "native". This introduces a dependency

 * on Swing, but since ThinG requires JDK 1.4, Swing should be there anyway.

 * Only a minimal set of Swing classes is loaded while using

 * <code>javax.swing.filechooser.FileSystemView</code>; alas, the loading

 * of <code>javax.swing.UIManager</code> and <code>javax.swing.LookAndFeel</code>

 * can <i>not</i> be avoided, although no Swing beans are actually used.

 *

 * @author Dirk Moebius

 */

public class FileChooser

{

    //{{{ logging

    private static final Logger log = Logger.getLogger("thinletcommons");

    private static final boolean debug() { return log.isLoggable(Level.FINE); }

    //}}}

    public static final int MODE_OPEN = 0;

    public static final int MODE_SAVE = 1;

    private static final FileSystemView fsv = FileSystemView.getFileSystemView();

    private static final DecimalFormat decimalFormat = new DecimalFormat("#,##0.0");

    private static final DecimalFormat integerFormat = new DecimalFormat("###,###,###,###,###,###,###,###,###,###");

    private static final DateFormat dateFormat = DateFormat.getInstance();

    private ThinletDialog dialog;

    private Thinlet thinlet;

    private File selectedFile;

    private File showFile;

    private File currentDir;

    private int mode;

    private boolean showHiddenFiles = false;

    private int sortColumn = 0;

    private boolean sortAscending = true;

    private FileFilter[] filters;

    private FileFilter selectedFilter;

    // components

    private Object cbPath, bUp, bShowHidden, tbFilelist, tFilename, bOk, cbFilter;

    public FileChooser(Frame owner, String title, int mode)

    {

        this.dialog = new ThinletDialog(owner, title);

        this.mode = mode;

        init();

    }

    public FileChooser(Dialog owner, String title, int mode)

    {

        this.dialog = new ThinletDialog(owner, title);

        this.mode = mode;

        init();

    }

    private void init()

    {

        thinlet = new AntiAliasedThinlet();

        try

        {

            Object panel = thinlet.parse("/thinletcommons/filechooser.xml", this);

            thinlet.add(panel);

        }

        catch(Exception e)

        {

            log.log(Level.SEVERE, "Error parsing filechooser.xml", e);

        }

        tbFilelist = thinlet.find("tbFilelist");

        cbPath = thinlet.find("cbPath");

        bUp = thinlet.find("bUp");

        bShowHidden = thinlet.find("bShowHidden");

        bOk = thinlet.find("bOk");

        tFilename = thinlet.find("tFilename");

        cbFilter = thinlet.find("cbFilter");

        dialog.setContent(thinlet);

    }

    /**

     * Show the modal dialog.

     * This halts the application until the user dismisses the dialog.

     */

    public void show()

    {

        selectedFile = null;

        setupFileFilters();

        if(showFile == null || !showFile.exists())

            showFile = fsv.getHomeDirectory();

        addFiles(showFile);

        showFile = null;

        thinlet.setString(thinlet.find("bOk"), "text", mode == MODE_OPEN ? "Open" : "Save");

        thinlet.setBoolean(thinlet.find("bShowHidden"), "selected", showHiddenFiles);

        thinlet.requestFocus(thinlet.find("tbFilelist"));

        dialog.pack();

        dialog.setLocationRelativeTo(dialog.getOwner());

        dialog.setVisible(true);

    }

    public void setSelectedFile(File file)

    {

        this.showFile = file;

    }

    public File getSelectedFile()

    {

        return selectedFile;

    }

    public void setShowHiddenFiles(boolean showHiddenFiles)

    {

        this.showHiddenFiles = showHiddenFiles;

    }

    public boolean getShowHiddenFiles()

    {

        return showHiddenFiles;

    }

    /**

     * Set the list of choosable file filters.

     * <p>

     * This replaces the default filter "All files", so care must be taken to

     * include an all file filter in the list, if you don't want the "All files"

     * filter to be removed.

     * <p>

     * To restore the "All files" filter and remove all custom filter, call

     * this method with argument <code>null</code>.

     *

     * @param filters  the list of choosable file filters, or <code>null</code>.

     */

    public void setFileFilters(FileFilter[] filters)

    {

        this.filters = filters;

    }

    public FileFilter getSelectedFileFilter()

    {

        return selectedFilter;

    }

    //{{{ callbacks for filechooser.xml

    /** Thinlet callback. */

    public void ok()

    {

        String filename = thinlet.getString(tFilename, "text");

        if(filename == null || filename.trim().length() == 0)

            new MessageDialog(dialog, "No selection", "Please select a file.").show();

        else

        {

            File file = new File(currentDir, filename);

            if(fsv.isTraversable(file).booleanValue())

                addFiles(file);

            else

            {

                selectedFile = file;

                close();

            }

        }

    }

    /** Thinlet callback. */

    public void close()

    {

        dialog.setVisible(false);

    }

    /** Thinlet callback. */

    public void goUp()

    {

        if(currentDir != null)

        {

            File parent = fsv.getParentDirectory(currentDir);

            if(parent != null)

                addFiles(parent);

        }

    }

    /** Thinlet callback. */

    public void goHome()

    {

        // Workaround: FileSystemView.getHomeDirectory() returns wrong directory

        // on Windows; using system property "user.home" instead:

        //File home = fsv.getHomeDirectory();

        File home = new File(System.getProperty("user.home"));

        addFiles(home);

    }

    /** Thinlet callback. */

    public void toggleShowHiddenFiles(boolean showHidden)

    {

        this.showHiddenFiles = showHidden;

        addFiles(currentDir);

    }

    /** Thinlet callback. */

    public void tableRowDoubleClicked()

    {

        File file = getSelectedTableRowFile();

        if(file != null && fsv.isTraversable(file).booleanValue())

            addFiles(file);

        else

        {

            selectedFile = file;

            close();

        }

    }

    /** Thinlet callback. */

    public void tableRowSelected()

    {

        thinlet.setString(tFilename, "text", getSelectedTableRowFilename());

    }

    /** Thinlet callback. */

    public void tableHeaderChanged(Object colName, Object colType, Object colSize, Object colMod)

    {

        final Object[] column = { colName, colType, colSize, colMod };

        for(int i = 0; i < column.length; ++i)

        {

            String sort = thinlet.getChoice(column[i], "sort");

            if(!sort.equals("none"))

            {

                this.sortColumn = i;

                this.sortAscending = sort.equals("ascent");

                break;

            }

        }

        addFiles(currentDir);

    }

    /** Thinlet callback. */

    public void cbPathChanged()

    {

        Object item = thinlet.getSelectedItem(cbPath);

        if(item != null)

        {

            File dir = (File) thinlet.getProperty(item, "file");

            addFiles(dir);

        }

    }

    /** Thinlet callback. */

    public void cbFilterChanged(int index)

    {

        if(filters != null)

        {

            selectedFilter = filters[index];

            addFiles(currentDir);

        }

    }

    //}}}

    //{{{ private methods

    private void addFiles(File file)

    {

        currentDir = file;

        if(fsv.isTraversable(file).booleanValue())

            thinlet.setString(tFilename, "text", "");

        else

        {

            thinlet.setString(tFilename, "text", fsv.getSystemDisplayName(file));

            currentDir = fsv.getParentDirectory(file);

        }

        // fill table

        File[] files = fsv.getFiles(currentDir, false);

        sort(files, sortColumn, sortAscending);

        thinlet.removeAll(tbFilelist);

        for(int i = 0; i < files.length; ++i)

            if(acceptFile(files[i]))

                thinlet.add(tbFilelist, createTableRow(files[i]));

        // fill path combobox

        thinlet.removeAll(cbPath);

        File dir = currentDir;

        while(dir != null)

        {

            Object item = Thinlet.create("choice");

            thinlet.setString(item, "text", fsv.getSystemDisplayName(dir));

            thinlet.putProperty(item, "file", dir);

            setFileIcon(item, dir);

            thinlet.add(cbPath, item, 0);

            dir = fsv.getParentDirectory(dir);

        }

        thinlet.setInteger(cbPath, "selected", thinlet.getCount(cbPath) - 1);

        // configure "Up" button

        thinlet.setBoolean(bUp, "enabled", fsv.getParentDirectory(currentDir) != null);

    }

    private boolean acceptFile(File file)

    {

        // don't show hidden files

        if(!showHiddenFiles && fsv.isHiddenFile(file)) return false;

        // always show directories

        if(fsv.isTraversable(file).booleanValue()) return true;

        // "All files" filter accepts all

        if(selectedFilter == null) return true;

        // Use selected file filter

        return selectedFilter.accept(file);

    }

    private void setupFileFilters()

    {

        thinlet.removeAll(cbFilter);

        if(filters == null)

        {

            addFileFilter("All files (*.*)");

            selectedFilter = null;

        }

        else

        {

            for(int i = 0; i < filters.length; ++i)

                addFileFilter(filters[i].getDescription());

            selectedFilter = filters[0];

        }

        thinlet.setInteger(cbFilter, "selected", 0);

    }

    private void addFileFilter(String description)

    {

        Object choice = Thinlet.create("choice");

        thinlet.setString(choice, "text", description);

        thinlet.add(cbFilter, choice);

    }

    private Object createTableRow(File file)

    {

        Object row = Thinlet.create("row");

        Object cellName = Thinlet.create("cell");

        Object cellType = Thinlet.create("cell");

        Object cellSize = Thinlet.create("cell");

        Object cellMod = Thinlet.create("cell");

        thinlet.add(row, cellName);

        thinlet.add(row, cellType);

        thinlet.add(row, cellSize);

        thinlet.add(row, cellMod);

        thinlet.setString(cellName, "text", fsv.getSystemDisplayName(file));

        thinlet.setString(cellType, "text", formatTypeString(file));

        thinlet.setString(cellMod, "text", formatDateString(file.lastModified()));

        thinlet.setString(cellSize, "text", fsv.isTraversable(file).booleanValue() ? "" : formatByteString(file.length()));

        thinlet.setChoice(cellSize, "alignment", "right");

        setFileIcon(cellName, file);

        thinlet.putProperty(row, "file", file);

        return row;

    }

    private static void sort(File[] files, int sortColumn, boolean sortAscending)

    {

        if(files.length == 0)

            return;

        // don't sort if first file is a special (non-disc) file

        File firstFile = files[0];

        if(fsv.isComputerNode(firstFile) || fsv.isDrive(firstFile)

            || fsv.isFileSystemRoot(firstFile) || fsv.isFloppyDrive(firstFile)

            || fsv.isRoot(firstFile))

            return;

        Arrays.sort(files, new FileComparator(sortColumn, sortAscending));

    }

    private File getSelectedTableRowFile()

    {

        Object row = thinlet.getSelectedItem(tbFilelist);

        if(row != null)

            return (File) thinlet.getProperty(row, "file");

        else

            return null;

    }

    private String getSelectedTableRowFilename()

    {

        File file = getSelectedTableRowFile();

        if(file != null)

            return fsv.getSystemDisplayName(file);

        else

            return "";

    }

    private void setFileIcon(Object component, File file)

    {

        Icon icon = fsv.getSystemIcon(file);

        if(icon != null)

            thinlet.setIcon(component, "icon", convertIconToImage(thinlet, icon));

    }

    private static String formatTypeString(File file)

    {

        String desc = fsv.getSystemTypeDescription(file);

        if(desc == null || desc.length() == 0)

        {

            if(fsv.isComputerNode(file))

                desc = "Computer";

            else if(fsv.isDrive(file))

                desc = "Disk";

            else if(fsv.isFloppyDrive(file))

                desc = "Floppy";

            else if(fsv.isTraversable(file).booleanValue())

                desc = "Directory";

            else

                desc = "Unknown";

        }

        return desc;

    }

    private static String formatByteString(long size)

    {

        double d = size;

        int magnitude = 0;

        for(; d >= 1024.0; ++magnitude)

            d = d / 1024.0;

        switch(magnitude)

        {

            case 1: return decimalFormat.format(d) + " KB";

            case 2: return decimalFormat.format(d) + " MB";

            case 3: return decimalFormat.format(d) + " GB";

            case 4: return decimalFormat.format(d) + " TB";

            default: return integerFormat.format(size);

        }

    }

    private static String formatDateString(long date)

    {

        return dateFormat.format(new Date(date));

    }

    private static Image convertIconToImage(Thinlet thinlet, Icon icon)

    {

        BufferedImage image = new BufferedImage(icon.getIconWidth(),

            icon.getIconHeight(), BufferedImage.TYPE_INT_ARGB);

        icon.paintIcon(thinlet, image.getGraphics(), 0, 0);

        return image;

    }

    //}}}

    //{{{ inner class FileComparator

    /** A comparator for files and directories. */

    private static class FileComparator implements Comparator

    {

        private Collator collator = Collator.getInstance();

        private int sortColumn;

        private boolean sortAscending;

        public FileComparator(int sortColumn, boolean sortAscending)

        {

            this.sortColumn = sortColumn;

            this.sortAscending = sortAscending;

        }

        /**

         * Compares the two objects assuming they are files (or

         * directories). Directories are always sorted before files.

         */

        public int compare(Object obj1, Object obj2)

        {

            File f1 = (File) obj1;

            File f2 = (File) obj2;

            boolean f1Traversable = fsv.isTraversable(f1).booleanValue();

            boolean f2Traversable = fsv.isTraversable(f2).booleanValue();

            if(f1Traversable && !f2Traversable)

                return sortAscending ? Integer.MIN_VALUE : Integer.MAX_VALUE;

            else if(!f1Traversable && f2Traversable)

                return sortAscending ? Integer.MAX_VALUE : Integer.MIN_VALUE;

            else

            {

                int retval = 0;

                switch(sortColumn)

                {

                    case 0: // Column "Name"

                        retval = collator.compare(

                            fsv.getSystemDisplayName(f1),

                            fsv.getSystemDisplayName(f2));

                        break;

                    case 1: // Column "Type"

                        retval = collator.compare(

                            fsv.getSystemTypeDescription(f1),

                            fsv.getSystemTypeDescription(f2));

                        break;

                    case 2: // Column "Size"

                        retval = f1.length() > f2.length() ? 1

                            : f1.length() < f2.length() ? -1 : 0;

                        break;

                    case 3: // Column "Last Modified"

                        retval = f1.lastModified() > f2.lastModified() ? 1

                            : f1.lastModified() < f2.lastModified() ? -1 : 0;

                        break;

                    default:

                        throw new IllegalArgumentException("unexpected column: " + sortColumn);

                }

                if(retval == 0 && sortColumn != 0)

                    retval = collator.compare(

                        fsv.getSystemDisplayName(f1),

                        fsv.getSystemDisplayName(f2));

                return sortAscending ? retval : (-1 * retval);

            }

        }

        /** not used; returns false. */

        public boolean equals(Object other)

        {

            return false;

        }

    }

    //}}}

    /**

     * Test method.

     */

    public static void main(String[] args)

    {

        FileChooser chooser = new FileChooser(new Frame(), "Choose File...", FileChooser.MODE_OPEN);

        if(args.length > 0)

            chooser.setSelectedFile(new File(args[0]));

        chooser.setFileFilters(new FileFilter[]

        {

            new ExtensionFileFilter("xml", "XML files (*.xml)"),

            new ExtensionFileFilter("java", "Java source code (*.java)"),

            new FileFilter()

            {

                public boolean accept(File file) { return true; }

                public String getDescription() { return "All files (*.*)"; }

            }

        });

        chooser.show();

        System.out.println("File selected: " + chooser.getSelectedFile());

        System.exit(0);

    }

}

// jEdit settings:

// :tabSize=4:indentSize=4:noTabs=true:folding=explicit:collapseFolds=1:

package thinletcommons;

import java.awt.BorderLayout;

import java.awt.Dialog;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.Frame;

import java.awt.Image;

import java.util.logging.Level;

import java.util.logging.Logger;

import thinlet.Thinlet;

import utils.AWTUtils;

/**

 * A Thinlet message dialog with configurable OK/CANCEL/YES/NO-Buttons.

 *

 * <p>

 * The dialog is modal and blocks the calling frame/dialog. It is therefore

 * displayed in a separate window.

 *

 * <p>

 * <b>TODO:</b>

 * <ul>

 *   <li>make message type configurable (ERROR/WARN/INFO)</li>

 * </ul>

 *

 * @author Dirk Moebius

 */

public class MessageDialog

{

    //{{{ logging

    private static final Logger log = Logger.getLogger("thinletcommons");

    private static final boolean debug() { return log.isLoggable(Level.FINE); }

    //}}}

    public static final int MODE_OK = 0;

    public static final int MODE_OK_CANCEL = 1;

    public static final int MODE_YES_NO = 2;

    public static final int MODE_YES_NO_CANCEL = 3;

    public static final int ACTION_OK = 0;

    public static final int ACTION_CANCEL = 1;

    public static final int ACTION_YES = 2;

    public static final int ACTION_NO = 3;

    private Thinlet thinlet;

    private ThinletDialog dialog;

    private String msg;

    private Image icon;

    private int mode;

    private int returnValue;

    /**

     * Show a simple message dialog with an "Ok" button.

     */

    public MessageDialog(Dialog owner, String title, String msg)

    {

        this.dialog = new ThinletDialog(owner, title);

        init(msg, null, MODE_OK);

    }

    /**

     * Show a simple message dialog with an "Ok" button and a custom icon.

     */

    public MessageDialog(Dialog owner, String title, Image icon, String msg)

    {

        this.dialog = new ThinletDialog(owner, title);

        init(msg, icon, MODE_OK);

    }

    /**

     * Show a simple message dialog with an "Ok" button.

     */

    public MessageDialog(Frame owner, String title, String msg)

    {

        this.dialog = new ThinletDialog(owner, title);

        init(msg, null, MODE_OK);

    }

    /**

     * Show a simple message dialog with an "Ok" button and a custom icon.

     */

    public MessageDialog(Frame owner, String title, Image icon, String msg)

    {

        this.dialog = new ThinletDialog(owner, title);

        init(msg, icon, MODE_OK);

    }

    public MessageDialog(Dialog owner, String title, String msg, int mode)

    {

        this.dialog = new ThinletDialog(owner, title);

        init(msg, null, mode);

    }

    public MessageDialog(Dialog owner, String title, Image icon, String msg, int mode)

    {

        this.dialog = new ThinletDialog(owner, title);

        init(msg, icon, mode);

    }