• Home
• org.apache.pivot
• pivot-wtk-terra
• 1.5.2
• source code
• TerraTreeViewSkin.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.apache.pivot.wtk.skin.terra.TerraTreeViewSkin Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.pivot.wtk.skin.terra;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Transparency;
import java.awt.geom.GeneralPath;
import java.util.Iterator;
import java.util.NoSuchElementException;

import org.apache.pivot.collections.ArrayList;
import org.apache.pivot.collections.Dictionary;
import org.apache.pivot.collections.List;
import org.apache.pivot.collections.Sequence;
import org.apache.pivot.collections.Sequence.Tree.Path;
import org.apache.pivot.util.Filter;
import org.apache.pivot.wtk.Bounds;
import org.apache.pivot.wtk.Button;
import org.apache.pivot.wtk.Checkbox;
import org.apache.pivot.wtk.Component;
import org.apache.pivot.wtk.GraphicsUtilities;
import org.apache.pivot.wtk.Keyboard;
import org.apache.pivot.wtk.Mouse;
import org.apache.pivot.wtk.Orientation;
import org.apache.pivot.wtk.Platform;
import org.apache.pivot.wtk.Theme;
import org.apache.pivot.wtk.TreeView;
import org.apache.pivot.wtk.TreeViewBranchListener;
import org.apache.pivot.wtk.TreeViewListener;
import org.apache.pivot.wtk.TreeViewNodeListener;
import org.apache.pivot.wtk.TreeViewNodeStateListener;
import org.apache.pivot.wtk.TreeViewSelectionListener;
import org.apache.pivot.wtk.skin.ComponentSkin;

/**
 * Tree view skin.
 */
public class TerraTreeViewSkin extends ComponentSkin implements TreeView.Skin,
    TreeViewListener, TreeViewBranchListener, TreeViewNodeListener,
    TreeViewNodeStateListener, TreeViewSelectionListener{

    /**
     * Node info visitor interface.
     */
    protected interface NodeInfoVisitor {
        /**
         * Visits the specified node info.
         *
         * @param nodeInfo
         * The object to visit
         */
        public void visit(NodeInfo nodeInfo);
    }

    /**
     * Iterates through the visible nodes. For callers who wish to know the
     * path of each visible node, using this iterator will be much more
     * efficient than manually iterating over the visible nodes and calling
     * getPath() on each node.
     */
    protected final class VisibleNodeIterator implements Iterator {
        private int index;
        private int end;

        private Path path = null;
        private NodeInfo previous = null;

        public VisibleNodeIterator() {
            this(0, visibleNodes.getLength() - 1);
        }

        /**
         * Creates a new visible node iterator that will iterate over a portion
         * of the visible nodes list (useful during painting).
         *
         * @param start
         * The start index, inclusive
         *
         * @param end
         * The end index, inclusive
         */
        public VisibleNodeIterator(int start, int end) {
            if (start < 0
                || end >= visibleNodes.getLength()) {
                throw new IndexOutOfBoundsException();
            }

            this.index = start;
            this.end = end;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public boolean hasNext() {
            return (index <= end);
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public NodeInfo next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }

            NodeInfo next = visibleNodes.get(index++);

            if (path == null) {
                // First iteration
                path = next.getPath();
            } else if (next.parent == previous) {
                // Child of previous visible node
                path.add(0);
            } else {
                int n = path.getLength();
                while (next.parent != previous.parent) {
                    path.remove(--n, 1);
                    previous = previous.parent;
                }

                int tail = path.get(n - 1);
                path.update(n - 1, tail + 1);
            }

            previous = next;

            return next;
        }

        /**
         * This operation is not supported by this iterator.
         *
         * @throws UnsupportedOperationException
         */
        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

        /**
         * Gets the index of the node last returned by a call to
         * {@link #next()}, as seen in the current visible nodes list. Note
         * that as branches are expanded and collapsed, the row index of any
         * given node in the tree will change.
         *
         * @return
         * The row index of the current node, or -1 if next()
         * has not yet been called.
         */
        public int getRowIndex() {
            return (path == null ? -1 : index - 1);
        }

        /**
         * Gets the path of the node last returned by a call to {@link #next()}.
         *
         * @return
         * The path to the node, or null if next() has not
         * yet been called.
         */
        public Path getPath() {
            return path;
        }
    }

    /**
     * An internal data structure that keeps track of skin-related metadata
     * for a tree node. The justification for the existence of this class lies
     * in the visibleNodes data structure, which is a flat list of
     * nodes that are visible at any given time. In this context, visible means
     * that their parent hierarchy is expanded, not that they are being
     * painted. This list, combined with getNodeHeight(), enables us
     * to quickly determine which nodes to paint given a graphics clip rect.
     * It also enables us to quickly traverse the tree view when handling key
     * events.
     * 

     * NOTE: some of this data is managed by TreeView and cached here
     * to provide further optimizations during painting and user input.
     */
    protected static class NodeInfo {
        // Core metadata
        final TreeView treeView;
        final BranchInfo parent;
        final Object data;
        final int depth;

        // Cached fields. Note that this is maintained as a bitmask in favor of
        // separate properties because it allows us to easily clear any cached
        // field for all nodes in one common method. See #clearField(byte)
        byte fields = 0;

        public static final byte HIGHLIGHTED_MASK = 1 << 0;
        public static final byte SELECTED_MASK = 1 << 1;
        public static final byte DISABLED_MASK = 1 << 2;
        public static final byte CHECKMARK_DISABLED_MASK = 1 << 3;
        public static final byte CHECK_STATE_CHECKED_MASK = 1 << 4;
        public static final byte CHECK_STATE_MIXED_MASK = 1 << 5;

        public static final byte CHECK_STATE_MASK = CHECK_STATE_CHECKED_MASK
            | CHECK_STATE_MIXED_MASK;

        @SuppressWarnings("unchecked")
        private NodeInfo(TreeView treeView, BranchInfo parent, Object data) {
            this.treeView = treeView;
            this.parent = parent;
            this.data = data;

            depth = (parent == null) ? 0 : parent.depth + 1;

            // Newly created nodes are guaranteed to not be selected or checked,
            // but they may be disabled or have their checkmarks disabled, so
            // we set those flags appropriately here.

            Filter