maincontainerpbp11.java

来自「cqME :java framework for TCK test.」· Java 代码 · 共 202 行

/*
 * $Id$
 *
 * Copyright 1996-2007 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 *
 */

package com.sun.tck.xlet.agent;

import java.awt.Container;
import java.awt.DefaultFocusTraversalPolicy;
import java.awt.FocusTraversalPolicy;
import java.awt.Frame;
import java.awt.KeyboardFocusManager;
import java.awt.GraphicsEnvironment;
import java.awt.HeadlessException;
import java.util.Set;

/**
 * Class-holder of the only visible root Container, available for
 * Personal Basis Profile 1.1 Xlet applications.
 */

public class MainContainerPbp11 extends MainContainerPbp10 {

    /**
     * Constructs a new MainContainer PBP 1.1 implementation.
     */
    public MainContainerPbp11() {
        super();
    }

    /**
     *  Acquires a java.awt.Container with headless mode check.
     *  @throws InterruptedException if the thread is interrupted while waiting
     *          for the Container to become available.
     */
    public synchronized Container acquireContainer()
            throws InterruptedException {
        checkHeadless();
        return super.acquireContainer();
    } 
                                      
    /**
     *  Acquires a java.awt.Frame with headless mode check.
     *  @throws InterruptedException if the thread is interrupted while waiting
     *          for the Frame to become available.
     */
    public synchronized Frame acquireFrame()
            throws InterruptedException {
        checkHeadless();
        return super.acquireFrame();
    }

    /**
     * Checks headless mode. If it's headless, throws HeadlessException.
     */
    protected void checkHeadless() {
        if (headlessMode) {
            throw new HeadlessException("Headless Mode");
        }
    }

    protected void setInitialState(Container container) {

        super.setInitialState(container);
        
        container.setFocusTraversalKeys(
            KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, 
            currentKFM.getDefaultFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS));
        container.setFocusTraversalKeys(
            KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, 
            currentKFM.getDefaultFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS));
        container.setFocusTraversalKeys(
            KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, 
            currentKFM.getDefaultFocusTraversalKeys(KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS));
        container.setFocusTraversalKeys(
            KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS,  
            currentKFM.getDefaultFocusTraversalKeys(KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS));
        container.setFocusTraversalPolicy(dfFocusTPolicy);
        container.setFocusCycleRoot(true);
    }    

    protected void setInitialState(Frame frame) {
        super.setInitialState(frame);
        frame.setFocusableWindowState(true);
    }

    protected synchronized void saveFrameState(Frame frame) {
        super.saveFrameState(frame);
        savedFocusableWindowState = frame.getFocusableWindowState();       
    }
 
    protected void saveCommonState(Container container, int type) {
        super.saveCommonState(container, type);

        savedForwardKeys[type] = container.getFocusTraversalKeys(
                                        KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
        savedBackwardKeys[type] = container.getFocusTraversalKeys(
                                        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS);
        savedUpCycleKeys[type] = container.getFocusTraversalKeys(
                                        KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS);
        savedDownCycleKeys[type] = container.getFocusTraversalKeys(
                                        KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS);
        savedFocusTPolicy[type] = container.getFocusTraversalPolicy();
    }

    protected synchronized void restoreFrameState(Frame frame) {
        restoreCommonState(frame, MainContainerPbp10.FRAME_TYPE);
        super.restoreFrameState(frame);
        frame.setFocusableWindowState(savedFocusableWindowState);
    }

    protected void restoreCommonState(Container container, int type) {
        // restores previously saved stuff, do as much as possible
        // with layout manager set to null, to minimize side effects
        super.restoreCommonState(container, type);

        container.setFocusTraversalKeys(
                     KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, savedForwardKeys[type]);
        container.setFocusTraversalKeys(
                     KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, savedBackwardKeys[type]);
        container.setFocusTraversalKeys(
                     KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, savedUpCycleKeys[type]);
        container.setFocusTraversalKeys(
                     KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS, savedDownCycleKeys[type]);
        container.setFocusTraversalPolicy(savedFocusTPolicy[type]);
    }
    

    /**
     * If true, this environment cannot support a display, keyboard, and mouse.
     * @see GraphicsEnvironment#isHeadless()
     */
    protected boolean headlessMode = GraphicsEnvironment.isHeadless();

    /**
     * Default traversal policy.
     */
    protected DefaultFocusTraversalPolicy dfFocusTPolicy = 
                                      new DefaultFocusTraversalPolicy();

    /**
     * Current KeyboardFocusManager instance for the calling thread's context.
     */
    protected KeyboardFocusManager currentKFM = 
                   KeyboardFocusManager.getCurrentKeyboardFocusManager();
    
    /**
     * Focusable window state property of current frame.
     */
    protected boolean savedFocusableWindowState;

    /**
     * Focus traversal policy that will manage keyboard traversal of current 
     * Container's children.
     */
    protected FocusTraversalPolicy[] savedFocusTPolicy = new FocusTraversalPolicy[2];

    /**
     * Set of focus traversal keys for normal forward keyboard traversal 
     * for current Container.
     */
    protected Set[] savedForwardKeys = new Set[2];

    /**
     * Set of focus traversal keys for normal reverse keyboard traversal 
     * for current Container.
     */
    protected Set[] savedBackwardKeys = new Set[2];

    /**
     * Set of focus traversal keys for up cycle for current Container.
     */
    protected Set[] savedUpCycleKeys = new Set[2];

    /**
     * Set of focus traversal keys for down cycle for current Container.
     */
    protected Set[] savedDownCycleKeys = new Set[2];
}