gtkparser.java

来自「JAVA的一些源码 JAVA2 STANDARD EDITION DEVELO」· Java 代码 · 共 1,864 行 · 第 1/5 页

/*
 * @(#)GTKParser.java	1.88 04/08/10
 *
 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package com.sun.java.swing.plaf.gtk;

import java.util.*;
import java.io.*;
import java.awt.*;
import java.util.regex.PatternSyntaxException;
import javax.swing.plaf.ColorUIResource;
import java.security.AccessController;
import sun.security.action.GetPropertyAction;
import javax.swing.plaf.synth.SynthConstants;

/**
 * @author  Shannon Hickey
 * @version 1.88 08/10/04
 */
class GTKParser {
    
    private ArrayList freeScanners = new ArrayList();
    
    private HashMap namedStyles = new HashMap();
    
    private ArrayList assignments = new ArrayList();

    private HashMap settings = new HashMap();

    private File[] pixmapPaths = null;
    
    private ArrayList dirStack = new ArrayList();
    
    private HashMap engineParsers = new HashMap();

    // Register parsers here for now. Later we can add methods to register
    // new parser classes.
    {
        engineParsers.put("pixmap", "com.sun.java.swing.plaf.gtk.PixmapEngineParser");
        engineParsers.put("bluecurve", "com.sun.java.swing.plaf.gtk.BluecurveEngineParser");
        engineParsers.put("wonderland", "com.sun.java.swing.plaf.gtk.BluecurveEngineParser");
        engineParsers.put("blueprint", "com.sun.java.swing.plaf.gtk.BlueprintEngineParser");
    }
    
    private GTKScanner scanner;

    private final String CWD = (String)AccessController.doPrivileged(
                                           new GetPropertyAction("user.dir"));

    static class Symbol {
        
        public String name;
        public int val;
        
        public Symbol(String name, int val) {
            this.name = name;
            this.val = val;
        }
    }

    private static final Symbol SYMBOL_INVALID = new Symbol("invalid", GTKScanner.TOKEN_LAST);
    private static final Symbol SYMBOL_INCLUDE = new Symbol("include", SYMBOL_INVALID.val + 1);
    private static final Symbol SYMBOL_NORMAL = new Symbol("NORMAL", SYMBOL_INCLUDE.val + 1);
    private static final Symbol SYMBOL_ACTIVE = new Symbol("ACTIVE", SYMBOL_NORMAL.val + 1);
    private static final Symbol SYMBOL_PRELIGHT = new Symbol("PRELIGHT", SYMBOL_ACTIVE.val + 1);
    private static final Symbol SYMBOL_SELECTED = new Symbol("SELECTED", SYMBOL_PRELIGHT.val + 1);
    private static final Symbol SYMBOL_INSENSITIVE = new Symbol("INSENSITIVE", SYMBOL_SELECTED.val + 1);
    private static final Symbol SYMBOL_FG = new Symbol("fg", SYMBOL_INSENSITIVE.val + 1);
    private static final Symbol SYMBOL_BG = new Symbol("bg", SYMBOL_FG.val + 1);
    private static final Symbol SYMBOL_TEXT = new Symbol("text", SYMBOL_BG.val + 1);
    private static final Symbol SYMBOL_BASE = new Symbol("base", SYMBOL_TEXT.val + 1);
    private static final Symbol SYMBOL_XTHICKNESS = new Symbol("xthickness", SYMBOL_BASE.val + 1);
    private static final Symbol SYMBOL_YTHICKNESS = new Symbol("ythickness", SYMBOL_XTHICKNESS.val + 1);
    private static final Symbol SYMBOL_FONT = new Symbol("font", SYMBOL_YTHICKNESS.val + 1);
    private static final Symbol SYMBOL_FONTSET = new Symbol("fontset", SYMBOL_FONT.val + 1);
    private static final Symbol SYMBOL_FONT_NAME = new Symbol("font_name", SYMBOL_FONTSET.val + 1);
    private static final Symbol SYMBOL_BG_PIXMAP = new Symbol("bg_pixmap", SYMBOL_FONT_NAME.val + 1);
    private static final Symbol SYMBOL_PIXMAP_PATH = new Symbol("pixmap_path", SYMBOL_BG_PIXMAP.val + 1);
    private static final Symbol SYMBOL_STYLE = new Symbol("style", SYMBOL_PIXMAP_PATH.val + 1);
    private static final Symbol SYMBOL_BINDING = new Symbol("binding", SYMBOL_STYLE.val + 1);
    private static final Symbol SYMBOL_BIND = new Symbol("bind", SYMBOL_BINDING.val + 1);
    private static final Symbol SYMBOL_WIDGET = new Symbol("widget", SYMBOL_BIND.val + 1);
    private static final Symbol SYMBOL_WIDGET_CLASS = new Symbol("widget_class", SYMBOL_WIDGET.val + 1);
    private static final Symbol SYMBOL_CLASS = new Symbol("class", SYMBOL_WIDGET_CLASS.val + 1);
    private static final Symbol SYMBOL_LOWEST = new Symbol("lowest", SYMBOL_CLASS.val + 1);
    private static final Symbol SYMBOL_GTK = new Symbol("gtk", SYMBOL_LOWEST.val + 1);
    private static final Symbol SYMBOL_APPLICATION = new Symbol("application", SYMBOL_GTK.val + 1);
    private static final Symbol SYMBOL_THEME = new Symbol("theme", SYMBOL_APPLICATION.val + 1);
    private static final Symbol SYMBOL_RC = new Symbol("rc", SYMBOL_THEME.val + 1);
    private static final Symbol SYMBOL_HIGHEST = new Symbol("highest", SYMBOL_RC.val + 1);
    private static final Symbol SYMBOL_ENGINE = new Symbol("engine", SYMBOL_HIGHEST.val + 1);
    private static final Symbol SYMBOL_MODULE_PATH = new Symbol("module_path", SYMBOL_ENGINE.val + 1);
    private static final Symbol SYMBOL_IM_MODULE_PATH = new Symbol("im_module_path", SYMBOL_MODULE_PATH.val + 1);
    private static final Symbol SYMBOL_IM_MODULE_FILE = new Symbol("im_module_file", SYMBOL_IM_MODULE_PATH.val + 1);
    private static final Symbol SYMBOL_STOCK = new Symbol("stock", SYMBOL_IM_MODULE_FILE.val + 1);
    private static final Symbol SYMBOL_LTR = new Symbol("LTR", SYMBOL_STOCK.val + 1);
    private static final Symbol SYMBOL_RTL = new Symbol("RTL", SYMBOL_LTR.val + 1);
    private static final Symbol SYMBOL_LAST = new Symbol("last", SYMBOL_RTL.val + 1);
    
    private static final Symbol[] symbols = {
        SYMBOL_INCLUDE, SYMBOL_NORMAL, SYMBOL_ACTIVE, SYMBOL_PRELIGHT,
        SYMBOL_SELECTED, SYMBOL_INSENSITIVE, SYMBOL_FG, SYMBOL_BG,
        SYMBOL_TEXT, SYMBOL_BASE, SYMBOL_XTHICKNESS, SYMBOL_YTHICKNESS,
        SYMBOL_FONT, SYMBOL_FONTSET, SYMBOL_FONT_NAME, SYMBOL_BG_PIXMAP,
        SYMBOL_PIXMAP_PATH, SYMBOL_STYLE, SYMBOL_BINDING, SYMBOL_BIND,
        SYMBOL_WIDGET, SYMBOL_WIDGET_CLASS, SYMBOL_CLASS, SYMBOL_LOWEST,
        SYMBOL_GTK, SYMBOL_APPLICATION, SYMBOL_THEME, SYMBOL_RC,
        SYMBOL_HIGHEST, SYMBOL_ENGINE, SYMBOL_MODULE_PATH,
        SYMBOL_IM_MODULE_FILE, SYMBOL_STOCK, SYMBOL_LTR, SYMBOL_RTL
    };
    
    private static class StyleInfo {
        String name;
        
        static final int NUM_STATES = 5;
        
        static final int NORMAL = 0;
        static final int PRELIGHT = 1;
        static final int ACTIVE = 2;
        static final int INSENSITIVE = 3;
        static final int SELECTED = 4;
        
        Color[] fg = new Color[NUM_STATES];
        Color[] bg = new Color[NUM_STATES];
        Color[] text = new Color[NUM_STATES];
        Color[] base = new Color[NUM_STATES];
        String[] bgPixmapName = new String[NUM_STATES];
        
        Font font = null;
        
        int xThickness = GTKStyle.UNDEFINED_THICKNESS;
        int yThickness = GTKStyle.UNDEFINED_THICKNESS;

        // An array of HashMaps. The first HashMap is for stock
        // icons defined in this style. The other elements are
        // those inherited from parent.
        ArrayList stocks = null;
        
        CircularIdentityList props = null;
        
        EngineInfo engineInfo = null;

        private GTKStyle cachedStyle = null;
        private static GTKStyle EMPTY_STYLE = new GTKStyle();
        
        StyleInfo(String name) {
            this.name = name;
        }
        
        private void initStocksIfNecessary() {
            if (stocks == null) {
                stocks = new ArrayList();
                // for stock icons defined in this style
                stocks.add(new HashMap());
            }
        }

        void addStockItem(String id, GTKStyle.GTKIconSource[] sources) {
            initStocksIfNecessary();
            
            GTKStyle.GTKStockIconInfo iconInfo = new GTKStyle.GTKStockIconInfo(id, sources);
            
            HashMap map = (HashMap)stocks.get(0);
            map.put(id, iconInfo);                
        }
        
        void addProperty(String klass, String prop, Object value) {
            if (props == null) {
                props = new CircularIdentityList();
            }
            
            CircularIdentityList subList = (CircularIdentityList)props.get(klass);
            
            if (subList == null) {
                subList = new CircularIdentityList();
                props.set(klass, subList);
            }
            
            subList.set(prop, value);
        }
        
        void copyDataFrom(StyleInfo other) {
            for (int i = 0; i < NUM_STATES; i++) {
                fg[i] = other.fg[i];
                bg[i] = other.bg[i];
                text[i] = other.text[i];
                base[i] = other.base[i];
                bgPixmapName[i] = other.bgPixmapName[i];
            }

            xThickness = other.xThickness;
            yThickness = other.yThickness;
            font = other.font;
            
            if (other.stocks != null) {
                initStocksIfNecessary();
                stocks.addAll(other.stocks);
            }
            
            if (props == null) {
                props = GTKStyle.cloneClassSpecificValues(other.props);
            } else {
                GTKStyle.addClassSpecificValues(other.props, props);
            }
        }
        
        GTKStyle toGTKStyle() {
            if (cachedStyle != null) {
                return cachedStyle;
            }
            
            ArrayList stateInfos = new ArrayList();
            
            for (int i = 0; i < NUM_STATES; i++) {
                Color[] colors = null;

                if (fg[i] != null
                        || bg[i] != null
                        || text[i] != null
                        || base[i] != null) {
                    colors = new Color[GTKColorType.MAX_COUNT];
                    colors[GTKColorType.FOREGROUND.getID()] = fg[i];
                    colors[GTKColorType.BACKGROUND.getID()] = bg[i];
                    colors[GTKColorType.TEXT_FOREGROUND.getID()] = text[i];
                    colors[GTKColorType.TEXT_BACKGROUND.getID()] = base[i];
                }
                
                if (colors != null || bgPixmapName[i] != null) {
                    GTKStyle.GTKStateInfo stateInfo =
                        new GTKStyle.GTKStateInfo(toSynthState(i),
                                                  null, colors, bgPixmapName[i]);
                    stateInfos.add(stateInfo);
                }
            }
            
            GTKStyle.GTKStateInfo[] infoArray = null;
            if (stateInfos.size() != 0) {
                infoArray = new GTKStyle.GTKStateInfo[stateInfos.size()];
                infoArray = (GTKStyle.GTKStateInfo[])stateInfos.toArray(infoArray);
            }

            GTKStyle.GTKStockIconInfo[] stockArray = stocksToArray();

            // if this style has engine information, delegate the creation
            if (engineInfo != null) {
                cachedStyle = engineInfo.constructGTKStyle(infoArray,
                                                           props,
                                                           font,
                                                           xThickness,
                                                           yThickness,
                                                           stockArray);
            // otherwise, create a regular GTKStyle
            } else if (infoArray != null
                           || stockArray != null
                           || props != null
                           || font != null
                           || xThickness != GTKStyle.UNDEFINED_THICKNESS
                           || yThickness != GTKStyle.UNDEFINED_THICKNESS) {
                cachedStyle = new GTKStyle(infoArray,
                                           props,
                                           font,
                                           xThickness,
                                           yThickness,
                                           stockArray);
            } else {
                cachedStyle = EMPTY_STYLE;
            }

            return cachedStyle;
        }

        private GTKStyle.GTKStockIconInfo[] stocksToArray() {
            if (stocks == null) {
                return null;
            }
            
            ArrayList tmpList = new ArrayList();
            
            HashMap[] maps = new HashMap[stocks.size()];
            maps = (HashMap[])stocks.toArray(maps);
            
            for (int i = 0; i < maps.length; i++) {
                tmpList.addAll(maps[i].values());
            }
            
            GTKStyle.GTKStockIconInfo[] retVal = new GTKStyle.GTKStockIconInfo[tmpList.size()];
            retVal = (GTKStyle.GTKStockIconInfo[])tmpList.toArray(retVal);
            
            return retVal;
        }

        private static int toSynthState(int ourState) {
            switch(ourState) {
                case NORMAL: return SynthConstants.ENABLED;
                case PRELIGHT: return SynthConstants.MOUSE_OVER;
                case ACTIVE: return SynthConstants.PRESSED;
                case INSENSITIVE: return SynthConstants.DISABLED;
                case SELECTED: return SynthConstants.SELECTED;
            }
            
            // should not happen
            return SynthConstants.ENABLED;
        }
    }

    static abstract class EngineInfo {
        private String engineName;
        
        abstract GTKStyle constructGTKStyle(GTKStyle.GTKStateInfo[] infoArray,
                                            CircularIdentityList props,
                                            Font font,
                                            int xThickness,
                                            int yThickness,
                                            GTKStyle.GTKStockIconInfo[] stockArray);
    }

    private static class Assignment {
        int type;
        String pattern;
        StyleInfo info;
        
        Assignment(int type, String pattern, StyleInfo info) {
            this.type = type;
            this.pattern = pattern;
            this.info = info;
        }
        
        public String toString() {
            String sVal = "";
            
            switch(type) {
                case GTKStyleFactory.WIDGET: sVal = "widget, "; break;
                case GTKStyleFactory.WIDGET_CLASS: sVal = "widget_class, "; break;
                case GTKStyleFactory.CLASS: sVal = "class, "; break;
            }
            
            sVal += pattern + ", ";
            sVal += info.name;
            
            return sVal;
        }
    }

    private static Symbol getSymbol(int symbol) {
        if (symbol > SYMBOL_INVALID.val && symbol < SYMBOL_LAST.val) {
            for (int i = 0; i < symbols.length; i++) {
                if (symbols[i].val == symbol) {
                    return symbols[i];
                }
            }
        }
        
        return null;
    }

    public GTKParser() {
        freeScanners.add(createScanner());
    }
    
    public void parseString(String str) throws IOException {
        StringReader reader = new StringReader(str);
        parseReader(reader, "-");
    }
    
    public void parseFile(File file, String name) throws IOException {
        if (!file.canRead() || !file.isFile()) {
            return;
        }
        
        File parent = file.getParentFile();