Java example source code file (AquaUtilControlSize.java)

This example Java source code file (AquaUtilControlSize.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

aquaborder, bean, border, class, float, font, gui, insets, insetsuiresource, javabean, jcomponent, object, propertysizelistener, reflection, size, sizeable, sizedescriptor, sizevariant, string, swing

The AquaUtilControlSize.java Java example source code

/*
 * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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 in the LICENSE file that
 * accompanied this code).
 *
 * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.apple.laf;

import java.awt.*;
import java.beans.*;
import java.lang.reflect.Method;

import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.plaf.*;

import apple.laf.*;
import apple.laf.JRSUIConstants.*;

import com.apple.laf.AquaUtils.RecyclableSingleton;
import com.apple.laf.AquaUtils.RecyclableSingletonFromDefaultConstructor;

public class AquaUtilControlSize {
    protected final static String CLIENT_PROPERTY_KEY = "JComponent.sizeVariant";
    protected final static String SYSTEM_PROPERTY_KEY = "swing.component.sizevariant";

    interface Sizeable {
        void applySizeFor(final JComponent c, final Size size);
    }

    protected static final RecyclableSingleton<PropertySizeListener> sizeListener = new RecyclableSingletonFromDefaultConstructor(PropertySizeListener.class);
    protected static PropertySizeListener getSizeListener() {
        return sizeListener.get();
    }

    protected static void addSizePropertyListener(final JComponent c) {
        c.addPropertyChangeListener(CLIENT_PROPERTY_KEY, getSizeListener());
        PropertySizeListener.applyComponentSize(c, c.getClientProperty(CLIENT_PROPERTY_KEY));
    }

    protected static void removeSizePropertyListener(final JComponent c) {
        c.removePropertyChangeListener(CLIENT_PROPERTY_KEY, getSizeListener());
    }

    private static JRSUIConstants.Size getSizeFromString(final String name) {
        if ("regular".equalsIgnoreCase(name)) return Size.REGULAR;
        if ("small".equalsIgnoreCase(name)) return Size.SMALL;
        if ("mini".equalsIgnoreCase(name)) return Size.MINI;
        if ("large".equalsIgnoreCase(name)) return Size.LARGE;
        return null;
    }

    private static Size getDefaultSize() {
        final String sizeProperty = java.security.AccessController.doPrivileged(new sun.security.action.GetPropertyAction(SYSTEM_PROPERTY_KEY));
        final JRSUIConstants.Size size = getSizeFromString(sizeProperty);
        if (size != null) return size;
        return JRSUIConstants.Size.REGULAR;
    }

    protected final static JRSUIConstants.Size defaultSize = getDefaultSize();
    protected static JRSUIConstants.Size getUserSizeFrom(final JComponent c) {
        final Object sizeProp = c.getClientProperty(CLIENT_PROPERTY_KEY);
        if (sizeProp == null) return defaultSize;
        final Size size = getSizeFromString(sizeProp.toString());
        if (size == null) return Size.REGULAR;
        return size;
    }

    protected static JRSUIConstants.Size applySizeForControl(final JComponent c, final AquaPainter<? extends JRSUIState> painter) {
        final JRSUIConstants.Size sizeFromUser = getUserSizeFrom(c);
        final JRSUIConstants.Size size = sizeFromUser == null ? JRSUIConstants.Size.REGULAR : sizeFromUser;
        painter.state.set(size);
        return size;
    }

    protected static Font getFontForSize(final Component c, final JRSUIConstants.Size size) {
        final Font initialFont = c.getFont();

        if (size == null || !(initialFont instanceof UIResource)) return initialFont;

        if (size == JRSUIConstants.Size.MINI) return initialFont.deriveFont(AquaFonts.getMiniControlTextFont().getSize2D());
        if (size == JRSUIConstants.Size.SMALL) return initialFont.deriveFont(AquaFonts.getSmallControlTextFont().getSize2D());

        return initialFont.deriveFont(AquaFonts.getControlTextFont().getSize2D());
    }

    private static void applyBorderForSize(final JComponent c, final Size size) {
        final Border border = c.getBorder();
        if (!(border instanceof AquaBorder)) return;
        final AquaBorder aquaBorder = (AquaBorder)border;

        if (aquaBorder.sizeVariant.size == size) return;
        final AquaBorder derivedBorder = aquaBorder.deriveBorderForSize(size);
        if (derivedBorder == null) return;

        c.setBorder(derivedBorder);
    }

    // call JComponent.getUI() if it exists, then call Sizeable.applySizeFor() if the UI is "Sizeable"
    // next best thing to -respondsToSelector: :-P
    private static void applyUISizing(final JComponent c, final Size size) {
        try {
            // see if this component has a "getUI" method
            final Class<? extends JComponent> clazz = c.getClass();
            final Method getUIMethod = clazz.getMethod("getUI", new Class[0]);

            // see if that UI is one of ours that understands sizing
            final Object ui = getUIMethod.invoke(c, new Object[0]);
            if (!(ui instanceof Sizeable)) return;

            // size it!
            final Sizeable sizeable = (Sizeable)ui;
            sizeable.applySizeFor(c, size);
        } catch (final Throwable e) { return; }
    }

    protected static class PropertySizeListener implements PropertyChangeListener {
        public void propertyChange(final PropertyChangeEvent evt) {
            final String key = evt.getPropertyName();
            if (!CLIENT_PROPERTY_KEY.equalsIgnoreCase(key)) return;

            final Object source = evt.getSource();
            if (!(source instanceof JComponent)) return;

            final JComponent c = (JComponent)source;
            applyComponentSize(c, evt.getNewValue());
        }

        protected static void applyComponentSize(final JComponent c, final Object value) {
            Size size = getSizeFromString(value == null ? null : value.toString());
            if (size == null) {
                size = getUserSizeFrom(c);
                if (size == Size.REGULAR) return;
            }

            applyBorderForSize(c, size);

            applyUISizing(c, size);

            final Font priorFont = c.getFont();
            if (!(priorFont instanceof FontUIResource)) return;
            c.setFont(getFontForSize(c, size));
        }
    }

    public static class SizeDescriptor {
        SizeVariant regular;
        SizeVariant small;
        SizeVariant mini;

        public SizeDescriptor(final SizeVariant variant) {
            regular = deriveRegular(variant);
            small = deriveSmall(new SizeVariant(regular));
            mini = deriveMini(new SizeVariant(small));
        }

        public SizeVariant deriveRegular(final SizeVariant v) {
            v.size = Size.REGULAR;
            return v;
        }

        public SizeVariant deriveSmall(final SizeVariant v) {
            v.size = Size.SMALL;
            return v;
        }

        public SizeVariant deriveMini(final SizeVariant v) {
            v.size = Size.MINI;
            return v;
        }

        public SizeVariant get(final JComponent c) {
            if (c == null) return regular;
            return get(getUserSizeFrom(c));
        }

        public SizeVariant get(final Size size) {
            if (size == Size.REGULAR) return regular;
            if (size == Size.SMALL) return small;
            if (size == Size.MINI) return mini;
            return regular;
        }

        public String toString() {
            return "regular[" + regular + "] small[" + small + "] mini[" + mini + "]";
        }
    }

    public static class SizeVariant {
        Size size = Size.REGULAR;
        Insets insets = new InsetsUIResource(0, 0, 0, 0);
        Insets margins = new InsetsUIResource(0, 0, 0, 0);
        Float fontSize;
        int w = 0;
        int h = 0;
    //    Integer textBaseline;

        public SizeVariant() { }

        public SizeVariant(final int minWidth, final int minHeight) {
            this.w = minWidth;
            this.h = minHeight;
        }

        public SizeVariant(final SizeVariant desc){
            this.size = desc.size;
            this.insets = new InsetsUIResource(desc.insets.top, desc.insets.left, desc.insets.bottom, desc.insets.right);
            this.margins = new InsetsUIResource(desc.margins.top, desc.margins.left, desc.margins.bottom, desc.margins.right);
            this.fontSize = desc.fontSize;
            this.w = desc.w;
            this.h = desc.h;
    //        this.textBaseline = desc.textBaseline;
        }

        public SizeVariant replaceInsets(final String insetName) {
            this.insets = UIManager.getInsets(insetName);
            return this;
        }

        public SizeVariant replaceInsets(final Insets i) {
            this.insets = new InsetsUIResource(i.top, i.left, i.bottom, i.right);
            return this;
        }

        public SizeVariant alterInsets(final int top, final int left, final int bottom, final int right) {
            insets = generateInsets(insets, top, left, bottom, right);
            return this;
        }

        public SizeVariant replaceMargins(final String marginName) {
            this.margins = UIManager.getInsets(marginName);
            return this;
        }

        public SizeVariant alterMargins(final int top, final int left, final int bottom, final int right) {
            margins = generateInsets(margins, top, left, bottom, right);
            return this;
        }

        public SizeVariant alterFontSize(final float newSize) {
            final float oldSize = fontSize == null ? 0.0f : fontSize.floatValue();
            fontSize = new Float(newSize + oldSize);
            return this;
        }

        public SizeVariant alterMinSize(final int width, final int height) {
            this.w += width; this.h += height;
            return this;
        }

//        public SizeVariant alterTextBaseline(final int baseline) {
//            final int oldSize = textBaseline == null ? 0 : textBaseline.intValue();
//            textBaseline = new Integer(baseline + oldSize);
//            return this;
//        }

        static Insets generateInsets(final Insets i, final int top, final int left, final int bottom, final int right) {
            if (i == null) return new InsetsUIResource(top, left, bottom, right);
            i.top += top;
            i.left += left;
            i.bottom += bottom;
            i.right += right;
            return i;
        }

        public String toString() {
            return "insets:" + insets + ", margins:" + margins + ", fontSize:" + fontSize;// + ", textBaseline:" + textBaseline;
        }
    }
}