Attachment 94521 Details for Bug 223944 – Allows testing TreeItem#setImage through loading Files into a Tree

Allows testing TreeItem#setImage through loading Files into a Tree

FolderTree.java (text/plain), 16.53 KB, created by Lubomir Marinov

on 2008-04-02 08:13:16 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Lubomir Marinov

Created: 2008-04-02 08:13:16 EDT

Size: 16.53 KB

patch

obsolete

>/*******************************************************************************
> * Copyright (c) 2004, 2008 Alternative Ideas Corporation. All rights reserved.
> * This program and the accompanying materials are protected by United
> * States and International copyright laws. They may not be inspected,
> * copied, modified, transmitted, executed, or used in any way without
> * the express written permission of the copyright holder.
> *******************************************************************************/
>package com.deltopia.ui.tests.internal;
>
>import java.io.File;
>import java.util.ArrayList;
>import java.util.HashMap;
>import java.util.List;
>import java.util.Map;
>
>import org.eclipse.swt.SWT;
>import org.eclipse.swt.graphics.Image;
>import org.eclipse.swt.graphics.ImageData;
>import org.eclipse.swt.layout.GridData;
>import org.eclipse.swt.layout.GridLayout;
>import org.eclipse.swt.program.Program;
>import org.eclipse.swt.widgets.Button;
>import org.eclipse.swt.widgets.Composite;
>import org.eclipse.swt.widgets.Control;
>import org.eclipse.swt.widgets.DirectoryDialog;
>import org.eclipse.swt.widgets.Event;
>import org.eclipse.swt.widgets.Listener;
>import org.eclipse.swt.widgets.ScrollBar;
>import org.eclipse.swt.widgets.Text;
>import org.eclipse.swt.widgets.Tree;
>import org.eclipse.swt.widgets.TreeColumn;
>import org.eclipse.swt.widgets.TreeItem;
>import org.eclipse.swt.widgets.Widget;
>
>public class FolderTree extends Composite {
>    private static final boolean REDRAW_WHILE_CREATING_TREE_ITEMS = false;
>
>    private static final int STATS_CREATE_TREE_ITEMS_INVOCATIONS = 1;
>
>    private static final int STATS_CREATE_TREE_ITEMS_TIME = 0;
>
>    private static final int STATS_EXPANDED_FALSE = 2;
>
>    private static final int STATS_EXPANDED_TIME = 0;
>
>    private static final int STATS_EXPANDED_TRUE = 1;
>
>    private static final int STATS_SET_IMAGE_INVOCATIONS = 2;
>
>    /*
>     * Two TreeColumns reproduce our scenario of using TreeItem#setImage.
>     * However, a greater number of TreeColumns better depicts the effect of the
>     * optimization of Tree#imageIndex because it easily increases the number of
>     * TreeItem#setImage(int,Image) calls for TreeColumns with non-zero index.
>     */
>    private static final int TREE_COLUMN_COUNT = 2;
>
>    private Text browseText;
>
>    /**
>     * The <code>Image</code> to be used for file and folders that don't have
>     * an association through <code>Program</code>.
>     * <p>
>     * Allows close reproduction of a specific number
>     * <code>TreeItem#setImage</code> calls that doesn't vary on the
>     * <code>Program</code> associations of the machine running the test.
>     * </p>
>     */
>    private final Image defaultImage;
>
>    private final Map extension2Image = new HashMap();
>
>    private final Tree tree;
>
>    public FolderTree(Composite parent, int style) {
>        super(parent, style);
>
>        Control inputControls = createInputControls(this, style);
>        if (inputControls != null) {
>            inputControls.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING,
>                    true, false));
>        }
>        Control commandControls = createCommandControls(this, style);
>        if (commandControls != null) {
>            commandControls.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING,
>                    true, false));
>        }
>
>        tree = new Tree(this, SWT.BORDER);
>        tree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
>
>        for (int columnIx = 0; columnIx < TREE_COLUMN_COUNT; columnIx++) {
>            TreeColumn column = new TreeColumn(tree, SWT.NONE);
>            column.setText(Integer.toString(tree.indexOf(column)));
>        }
>        if (tree.getColumnCount() > 0) {
>            tree.setHeaderVisible(true);
>        }
>
>        setLayout(new GridLayout(1, false));
>
>        defaultImage = new Image(getDisplay(), 16, 16);
>    }
>
>    private Control createCommandControls(Composite parent, int style) {
>        Composite commandControls = new Composite(parent, SWT.NONE);
>        int numColumns = 0;
>
>        final Button expandAllButton = new Button(commandControls, SWT.PUSH);
>        expandAllButton.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER,
>                false, false));
>        expandAllButton.setText("Expand All");
>        numColumns++;
>
>        final Button collapseAllButton = new Button(commandControls, SWT.PUSH);
>        collapseAllButton.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER,
>                false, false));
>        collapseAllButton.setText("Collapse All");
>        numColumns++;
>
>        final Button getExpandedButton = new Button(commandControls, SWT.PUSH);
>        getExpandedButton.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER,
>                false, false));
>        getExpandedButton.setText("TreeItem.getExpanded()");
>        numColumns++;
>
>        final Button setTopItemButton = new Button(commandControls, SWT.PUSH);
>        setTopItemButton.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER,
>                false, false));
>        setTopItemButton.setText("Tree.setTopItem(TreeItem)");
>        numColumns++;
>
>        final Listener listener = new Listener() {
>            public void handleEvent(Event e) {
>                final Widget widget = e.widget;
>
>                if (widget == expandAllButton) {
>                    setExpanded(null, true);
>                } else if (widget == collapseAllButton) {
>                    setExpanded(null, false);
>                } else if (widget == getExpandedButton) {
>                    final long[] stats = new long[3];
>                    getExpanded(null, stats);
>                    System.out
>                            .println("TreeItem.getExpanded()= { invocations= { true= "
>                                    + stats[STATS_EXPANDED_TRUE]
>                                    + ", false= "
>                                    + stats[STATS_EXPANDED_FALSE]
>                                    + " }, time= "
>                                    + stats[STATS_EXPANDED_TIME]
>                                    + " }");
>                } else if (widget == setTopItemButton) {
>                    handleSetTopItemButtonSelection();
>                }
>            }
>        };
>        expandAllButton.addListener(SWT.Selection, listener);
>        collapseAllButton.addListener(SWT.Selection, listener);
>        getExpandedButton.addListener(SWT.Selection, listener);
>        setTopItemButton.addListener(SWT.Selection, listener);
>
>        if (numColumns > 0) {
>            GridLayout commandControlsLayout = new GridLayout();
>            commandControlsLayout.makeColumnsEqualWidth = false;
>            commandControlsLayout.marginHeight = 0;
>            commandControlsLayout.marginWidth = 0;
>            commandControlsLayout.numColumns = numColumns;
>            commandControls.setLayout(commandControlsLayout);
>        } else {
>            commandControls.dispose();
>            commandControls = null;
>        }
>        return commandControls;
>    }
>
>    private Control createInputControls(Composite parent, int style) {
>        final Composite inputControls = new Composite(parent, SWT.NONE);
>
>        browseText = new Text(inputControls, SWT.BORDER | SWT.MULTI
>                | SWT.READ_ONLY | SWT.WRAP);
>        browseText.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
>
>        final Button browseButton = new Button(inputControls, SWT.PUSH);
>        browseButton.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING,
>                false, false));
>        browseButton.setText("Browse...");
>
>        final Listener listener = new Listener() {
>            public void handleEvent(Event e) {
>                final Widget widget = e.widget;
>
>                if (widget == browseText) {
>                    switch (e.type) {
>                    case SWT.Modify:
>                        setFolder(browseText.getText());
>                        break;
>
>                    default:
>                        throw new IllegalArgumentException("e.type"); //$NON-NLS-1$
>                    }
>
>                } else if (widget == browseButton) {
>                    switch (e.type) {
>                    case SWT.Selection:
>                        DirectoryDialog dialog = new DirectoryDialog(
>                                browseButton.getShell());
>                        String selection = dialog.open();
>                        if (selection != null) {
>                            browseText.setText(selection);
>                        }
>                        break;
>
>                    default:
>                        throw new IllegalArgumentException("e.type"); //$NON-NLS-1$
>                    }
>
>                } else {
>                    throw new IllegalArgumentException("e.widget"); //$NON-NLS-1$
>                }
>            }
>        };
>        browseText.addListener(SWT.Modify, listener);
>        browseButton.addListener(SWT.Selection, listener);
>
>        GridLayout inputControlsLayout = new GridLayout();
>        inputControlsLayout.makeColumnsEqualWidth = false;
>        inputControlsLayout.marginHeight = 0;
>        inputControlsLayout.marginWidth = 0;
>        inputControlsLayout.numColumns = 2;
>        inputControls.setLayout(inputControlsLayout);
>        return inputControls;
>    }
>
>    private void createTreeItems(TreeItem parentItem, File file, long[] stats) {
>        if (parentItem == null) {
>            tree.removeAll();
>        } else {
>            parentItem.removeAll();
>        }
>
>        File[] files = file.listFiles();
>        if (files != null) {
>            final int style = SWT.NONE;
>            for (int fileIx = 0; fileIx < files.length; fileIx++) {
>                final long start = System.currentTimeMillis();
>                TreeItem item = (parentItem == null) ? new TreeItem(tree, style)
>                        : new TreeItem(parentItem, style);
>                final long time = System.currentTimeMillis() - start;
>                stats[STATS_CREATE_TREE_ITEMS_TIME] += time;
>                stats[STATS_CREATE_TREE_ITEMS_INVOCATIONS]++;
>
>                file = files[fileIx];
>                item.setText(file.getName());
>                setImage(item, file, stats);
>
>                if (file.isDirectory()) {
>                    createTreeItems(item, file, stats);
>                }
>            }
>        }
>    }
>
>    private void getExpanded(TreeItem item, long[] stats) {
>        TreeItem[] items;
>        if (item == null) {
>            items = tree.getItems();
>        } else {
>            items = item.getItems();
>        }
>        for (int itemIx = 0; itemIx < items.length; itemIx++) {
>            item = items[itemIx];
>            final long start = System.currentTimeMillis();
>            boolean expanded = item.getExpanded();
>            final long time = System.currentTimeMillis() - start;
>            stats[STATS_EXPANDED_TIME] += time;
>            final int index = expanded ? STATS_EXPANDED_TRUE
>                    : STATS_EXPANDED_FALSE;
>            stats[index]++;
>            getExpanded(item, stats);
>        }
>    }
>
>    private void getViewableTreeItems(TreeItem item, List result) {
>        TreeItem[] items;
>        if (item == null) {
>            items = tree.getItems();
>        } else {
>            items = item.getItems();
>        }
>        for (int itemIx = 0; itemIx < items.length; itemIx++) {
>            item = items[itemIx];
>            result.add(item);
>            if (item.getExpanded()) {
>                getViewableTreeItems(item, result);
>            }
>        }
>    }
>
>    private void handleSetTopItemButtonSelection() {
>        ScrollBar verticalBar = tree.getVerticalBar();
>
>        List items = new ArrayList();
>        getViewableTreeItems(null, items);
>        int itemCount = items.size();
>
>        int minimum = verticalBar.getMinimum();
>        int range = verticalBar.getMaximum() - minimum;
>        int newSelection = verticalBar.getSelection() + range / 10;
>        int topItemIndex = (int) ((newSelection - minimum) * (itemCount / (double) range));
>        if ((0 <= topItemIndex) && (topItemIndex < itemCount)) {
>            tree.setTopItem((TreeItem) items.get(topItemIndex));
>        }
>    }
>
>    private void setExpanded(TreeItem item, boolean expanded) {
>        TreeItem[] items;
>        if (item == null) {
>            items = tree.getItems();
>        } else {
>            items = item.getItems();
>        }
>        for (int itemIx = 0; itemIx < items.length; itemIx++) {
>            item = items[itemIx];
>            if (expanded) {
>                item.setExpanded(expanded);
>                setExpanded(item, expanded);
>            } else {
>                setExpanded(item, expanded);
>                item.setExpanded(expanded);
>            }
>        }
>    }
>
>    public void setFolder(String folder) {
>        if (folder == null) {
>            folder = ""; //$NON-NLS-1$
>        }
>        if ((browseText != null) && (browseText.isDisposed() == false)
>                && (browseText.getText().equals(folder) == false)) {
>            browseText.setText(folder);
>        }
>
>        if (REDRAW_WHILE_CREATING_TREE_ITEMS == false) {
>            tree.setRedraw(false);
>        }
>        try {
>            final long[] stats = new long[3];
>            TreeItem.setImage_invocations = 0;
>            TreeItem.setImage_time = 0;
>            createTreeItems(null, new File(folder), stats);
>            System.out.println("new TreeItem= { invocations= "
>                    + stats[STATS_CREATE_TREE_ITEMS_INVOCATIONS] + ", time= "
>                    + stats[STATS_CREATE_TREE_ITEMS_TIME] + " }");
>            System.out.println("TreeItem#setImage invocations in FolderTree= "
>                    + stats[STATS_SET_IMAGE_INVOCATIONS]);
>            System.out.println("TreeItem#setImage= { invocations= "
>                    + TreeItem.setImage_invocations + ", time= "
>                    + TreeItem.setImage_time + " }");
>
>            /*
>             * Size the TreeColumns not for the sake of performance testing but
>             * in the name of visibility.
>             */
>            final int columnCount = tree.getColumnCount();
>            if (columnCount > 0) {
>                int width = tree.computeTrim(0, 0, 0, 0).width;
>                for (int columnIx = columnCount - 1; columnIx > 0; columnIx--) {
>                    TreeColumn column = tree.getColumn(columnIx);
>                    column.pack();
>                    width += column.getWidth();
>                }
>                width = tree.getClientArea().width - width;
>                TreeColumn column = tree.getColumn(0);
>                if (width > 0) {
>                    column.setWidth(width);
>                } else {
>                    column.pack();
>                }
>            }
>        } finally {
>            if (REDRAW_WHILE_CREATING_TREE_ITEMS == false) {
>                tree.setRedraw(true);
>            }
>        }
>    }
>
>    private void setImage(TreeItem item, File file, long[] stats) {
>
>        /*
>         * The image of a TreeItem representing a specific File is the image
>         * associated with the File extension.
>         */
>        String fileName = file.getName();
>        int extensionPos = fileName.lastIndexOf('.');
>        if (-1 != extensionPos) {
>            String extension = fileName.substring(extensionPos).toLowerCase();
>
>            /*
>             * Not that it's used in the tests but cache the images in order to
>             * get better performance and not run out of Image handles.
>             */
>            Image image = (Image) extension2Image.get(extension);
>            if (image == null) {
>                Program program = Program.findProgram(extension);
>                if (program != null) {
>                    ImageData imageData = program.getImageData();
>                    if (imageData != null) {
>                        image = new Image(item.getDisplay(), imageData);
>                        extension2Image.put(extension, image);
>                    }
>                }
>                if (image == null) {
>                    image = defaultImage;
>                }
>            }
>
>            /*
>             * Invoke TreeItem#setImage in order to benchmark it. The column
>             * with index 0 is intentionally special-cased in order to invoke
>             * TreeItem#setImage(Image) and not TreeItem#setImage(int,Image) and
>             * thus have Widget#checkWidget() called twice per a
>             * TreeItem#setImage call (in case the situation is of interest).
>             */
>            final int columnCount = tree.getColumnCount();
>            for (int columnIx = 0; columnIx < columnCount; columnIx++) {
>                if (columnIx == 0) {
>                    item.setImage(image);
>                } else {
>                    item.setImage(columnIx, image);
>                }
>                stats[STATS_SET_IMAGE_INVOCATIONS]++;
>            }
>        }
>    }
>}

Actions: View

Attachments on bug 223944: 93466 | 94521 | 94629