FileDocCategorySizeDatePackage
PixmapEngineParser.javaAPI DocJava SE 5 API27021Fri Aug 26 14:54:46 BST 2005com.sun.java.swing.plaf.gtk

PixmapEngineParser

public class PixmapEngineParser extends GTKEngineParser
A parser for the "pixmap" engine sections in GTK rc theme files.
author
Shannon Hickey
version
1.19 12/19/03

Fields Summary
private static final int
SYM_IMAGE
private static final int
SYM_FUNCTION
private static final int
SYM_FILE
private static final int
SYM_STRETCH
private static final int
SYM_RECOLORABLE
private static final int
SYM_BORDER
private static final int
SYM_DETAIL
private static final int
SYM_STATE
private static final int
SYM_SHADOW
private static final int
SYM_GAP_SIDE
private static final int
SYM_GAP_FILE
private static final int
SYM_GAP_BORDER
private static final int
SYM_GAP_START_FILE
private static final int
SYM_GAP_START_BORDER
private static final int
SYM_GAP_END_FILE
private static final int
SYM_GAP_END_BORDER
private static final int
SYM_OVERLAY_FILE
private static final int
SYM_OVERLAY_BORDER
private static final int
SYM_OVERLAY_STRETCH
private static final int
SYM_ARROW_DIRECTION
private static final int
SYM_ORIENTATION
private static final int
SYM_D_HLINE
private static final int
SYM_D_VLINE
private static final int
SYM_D_SHADOW
private static final int
SYM_D_POLYGON
private static final int
SYM_D_ARROW
private static final int
SYM_D_DIAMOND
private static final int
SYM_D_OVAL
private static final int
SYM_D_STRING
private static final int
SYM_D_BOX
private static final int
SYM_D_FLAT_BOX
private static final int
SYM_D_CHECK
private static final int
SYM_D_OPTION
private static final int
SYM_D_CROSS
private static final int
SYM_D_RAMP
private static final int
SYM_D_TAB
private static final int
SYM_D_SHADOW_GAP
private static final int
SYM_D_BOX_GAP
private static final int
SYM_D_EXTENSION
private static final int
SYM_D_FOCUS
private static final int
SYM_D_SLIDER
private static final int
SYM_D_ENTRY
private static final int
SYM_D_HANDLE
private static final int
SYM_D_STEPPER
private static final int
SYM_TRUE
private static final int
SYM_FALSE
private static final int
SYM_TOP
private static final int
SYM_UP
private static final int
SYM_BOTTOM
private static final int
SYM_DOWN
private static final int
SYM_LEFT
private static final int
SYM_RIGHT
private static final int
SYM_NORMAL
private static final int
SYM_ACTIVE
private static final int
SYM_PRELIGHT
private static final int
SYM_SELECTED
private static final int
SYM_INSENSITIVE
private static final int
SYM_NONE
private static final int
SYM_IN
private static final int
SYM_OUT
private static final int
SYM_ETCHED_IN
private static final int
SYM_ETCHED_OUT
private static final int
SYM_HORIZONTAL
private static final int
SYM_VERTICAL
private static final int[]
symbolVals
private static final String[]
symbolNames
private GTKScanner
scanner
private GTKParser
parser
private PixmapEngineInfo
engineInfo
Constructors Summary
Methods Summary
intparse(GTKScanner scanner, GTKParser parser, GTKParser.EngineInfo[] retVal)


        this.scanner = scanner;
        this.parser = parser;

        if (retVal[0] == null) {
            engineInfo = new PixmapEngineInfo();
        } else {
            engineInfo = (PixmapEngineInfo)retVal[0];
        }

        int oldScope = scanner.setScope(uniqueScopeID);
        registerSymbolsIfNecessary();

        PixmapStyle.Info info[] = new PixmapStyle.Info[1];

        int token;

        token = scanner.peekNextToken();
        while (token != GTKScanner.TOKEN_RIGHT_CURLY) {
            switch(token) {
                case SYM_IMAGE:
                    token = parseImage(info);
                    break;
                default:
                    scanner.getToken();
                    token = GTKScanner.TOKEN_RIGHT_CURLY;
                    break;
            }

            if (token != GTKScanner.TOKEN_NONE) {
                return token;
            }

            engineInfo.pInfos.add(info[0]);

            token = scanner.peekNextToken();
        }

        scanner.getToken();

        retVal[0] = engineInfo;

        scanner.setScope(oldScope);
        return GTKScanner.TOKEN_NONE;
private intparseArrowDirection(PixmapStyle.Info info)

        int token;
        
        token = scanner.getToken();
        if (token != SYM_ARROW_DIRECTION) {
            return SYM_ARROW_DIRECTION;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        switch(token) {
            case SYM_UP:
                info.arrowDirection = GTKConstants.ARROW_UP;
                break;
            case SYM_DOWN:
                info.arrowDirection = GTKConstants.ARROW_DOWN;
                break;
            case SYM_LEFT:
                info.arrowDirection = GTKConstants.ARROW_LEFT;
                break;
            case SYM_RIGHT:
                info.arrowDirection = GTKConstants.ARROW_RIGHT;
                break;
            default:
                return SYM_UP;
        }

        return GTKScanner.TOKEN_NONE;
private intparseBorder(java.awt.Insets[] retVal)

        int left = 0;
        int right = 0;
        int top = 0;
        int bottom = 0;
        
        scanner.getToken();
        
        if (scanner.getToken() != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        if (scanner.getToken() != GTKScanner.TOKEN_LEFT_CURLY) {
            return GTKScanner.TOKEN_LEFT_CURLY;
        }
        
        if (scanner.getToken() != GTKScanner.TOKEN_INT) {
            return GTKScanner.TOKEN_INT;
        }
        
        left = (int)scanner.currValue.longVal;
        
        if (scanner.getToken() != GTKScanner.TOKEN_COMMA) {
            return GTKScanner.TOKEN_COMMA;
        }
        
        if (scanner.getToken() != GTKScanner.TOKEN_INT) {
            return GTKScanner.TOKEN_INT;
        }
        
        right = (int)scanner.currValue.longVal;
        
        if (scanner.getToken() != GTKScanner.TOKEN_COMMA) {
            return GTKScanner.TOKEN_COMMA;
        }
        
        if (scanner.getToken() != GTKScanner.TOKEN_INT) {
            return GTKScanner.TOKEN_INT;
        }
        
        top = (int)scanner.currValue.longVal;
        
        if (scanner.getToken() != GTKScanner.TOKEN_COMMA) {
            return GTKScanner.TOKEN_COMMA;
        }
        
        if (scanner.getToken() != GTKScanner.TOKEN_INT) {
            return GTKScanner.TOKEN_INT;
        }
        
        bottom = (int)scanner.currValue.longVal;
        
        if (scanner.getToken() != GTKScanner.TOKEN_RIGHT_CURLY) {
            return GTKScanner.TOKEN_RIGHT_CURLY;
        }

        retVal[0] = new Insets(top, left, bottom, right);

        return GTKScanner.TOKEN_NONE;
private intparseDetail(PixmapStyle.Info info)

        int token;
        
        token = scanner.getToken();
        if (token != SYM_DETAIL) {
            return SYM_DETAIL;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_STRING) {
            return GTKScanner.TOKEN_STRING;
        }

        info.setDetail(scanner.currValue.stringVal);

        return GTKScanner.TOKEN_NONE;
private intparseFile(java.lang.String[] retVal)

        int token;

        token = scanner.getToken();
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_STRING) {
            return GTKScanner.TOKEN_STRING;
        }

        retVal[0] = parser.resolvePixmapPath(scanner.currValue.stringVal);

        return GTKScanner.TOKEN_NONE;
private intparseFunction(PixmapStyle.Info info)

        int token;

        token = scanner.getToken();
        if (token != SYM_FUNCTION) {
            return SYM_FUNCTION;
        }

        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }

        token = scanner.getToken();
        if (token >= SYM_D_HLINE && token <= SYM_D_STEPPER) {
            info.setFunction(symbolNames[token - SYM_IMAGE]);
        }
        
        // PENDING(shannonh) - should we complain if not a valid function?

        return GTKScanner.TOKEN_NONE;
private intparseGapSide(PixmapStyle.Info info)

        int token;
        
        token = scanner.getToken();
        if (token != SYM_GAP_SIDE) {
            return SYM_GAP_SIDE;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        switch(token) {
            case SYM_TOP:
                info.gapSide = GTKConstants.TOP;
                break;
            case SYM_BOTTOM:
                info.gapSide = GTKConstants.BOTTOM;
                break;
            case SYM_LEFT:
                info.gapSide = GTKConstants.LEFT;
                break;
            case SYM_RIGHT:
                info.gapSide = GTKConstants.RIGHT;
                break;
            default:
                return SYM_TOP;
        }

        return GTKScanner.TOKEN_NONE;
private intparseImage(PixmapStyle.Info[] retVal)

        int token;

        token = scanner.getToken();
        if (token != SYM_IMAGE) {
            return SYM_IMAGE;
        }

        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_LEFT_CURLY) {
            return GTKScanner.TOKEN_LEFT_CURLY;
        }

        PixmapStyle.Info info = new PixmapStyle.Info();

        // to hold the return value from parseFile
        String[] fileName = new String[1];
        
        // to hold the return value from parseStretch
        boolean[] stretch = new boolean[1];
        
        // to hold the return value from parseBorder
        Insets[] insets = new Insets[1];

        token = scanner.peekNextToken();
        while (token != GTKScanner.TOKEN_RIGHT_CURLY) {
            switch(token) {
                case SYM_FUNCTION:
                    token = parseFunction(info);
                    break;
                case SYM_RECOLORABLE:
                    token = parseRecolorable(info);
                    break;
                case SYM_DETAIL:
                    token = parseDetail(info);
                    break;
                case SYM_STATE:
                    token = parseState(info);
                    break;
                case SYM_SHADOW:
                    token = parseShadow(info);
                    break;
                case SYM_GAP_SIDE:
                    token = parseGapSide(info);
                    break;
                case SYM_ARROW_DIRECTION:
                    token = parseArrowDirection(info);
                    break;
                case SYM_ORIENTATION:
                    token = parseOrientation(info);
                    break;
                case SYM_FILE:
                    token = parseFile(fileName);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.image = fileName[0];
                    }
                    break;
                case SYM_BORDER:
                    token = parseBorder(insets);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.fileInsets = insets[0];
                    }
                    break;
                case SYM_STRETCH:
                    token = parseStretch(stretch);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.stretch = stretch[0];
                    }
                    break;
                case SYM_GAP_FILE:
                    token = parseFile(fileName);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.gapImage = fileName[0];
                    }
                    break;
                case SYM_GAP_BORDER:
                    token = parseBorder(insets);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.gapInsets = insets[0];
                    }
                    break;
                case SYM_GAP_START_FILE:
                    token = parseFile(fileName);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.gapStartImage = fileName[0];
                    }
                    break;
                case SYM_GAP_START_BORDER:
                    token = parseBorder(insets);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.gapStartInsets = insets[0];
                    }
                    break;
                case SYM_GAP_END_FILE:
                    token = parseFile(fileName);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.gapEndImage = fileName[0];
                    }
                    break;
                case SYM_GAP_END_BORDER:
                    token = parseBorder(insets);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.gapEndInsets = insets[0];
                    }
                    break;
                case SYM_OVERLAY_FILE:
                    token = parseFile(fileName);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.overlayImage = fileName[0];
                    }
                    break;
                case SYM_OVERLAY_BORDER:
                    token = parseBorder(insets);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.overlayInsets = insets[0];
                    }
                    break;
                case SYM_OVERLAY_STRETCH:
                    token = parseStretch(stretch);
                    if (token == GTKScanner.TOKEN_NONE) {
                        info.overlayStretch = stretch[0];
                    }
                    break;
                default:
                    scanner.getToken();
                    token = GTKScanner.TOKEN_RIGHT_CURLY;
                    break;
            }

            if (token != GTKScanner.TOKEN_NONE) {
                return token;
            }

            token = scanner.peekNextToken();
        }

        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_RIGHT_CURLY) {
            return GTKScanner.TOKEN_RIGHT_CURLY;
        }

        // PENDING(shannonh) - may want to do some validation of the
        //                     info before we return it

        retVal[0] = info;
        return GTKScanner.TOKEN_NONE;
private intparseOrientation(PixmapStyle.Info info)

        int token;
        
        token = scanner.getToken();
        if (token != SYM_ORIENTATION) {
            return SYM_ORIENTATION;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        switch(token) {
            case SYM_HORIZONTAL:
                info.orientation = GTKConstants.HORIZONTAL;
                break;
            case SYM_VERTICAL:
                info.orientation = GTKConstants.VERTICAL;
                break;
            default:
                return SYM_HORIZONTAL;
        }
        
        return GTKScanner.TOKEN_NONE;
private intparseRecolorable(PixmapStyle.Info info)

        int token;
        
        token = scanner.getToken();
        if (token != SYM_RECOLORABLE) {
            return SYM_RECOLORABLE;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        if (token == SYM_TRUE) {
            info.recolorable = true;
        } else if (token == SYM_FALSE) {
            info.recolorable = false;
        } else {
            return SYM_TRUE;
        }
        
        return GTKScanner.TOKEN_NONE;
private intparseShadow(PixmapStyle.Info info)

        int token;
        
        token = scanner.getToken();
        if (token != SYM_SHADOW) {
            return SYM_SHADOW;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        switch(token) {
            case SYM_NONE:
                info.shadow = GTKConstants.SHADOW_NONE;
                break;
            case SYM_IN:
                info.shadow = GTKConstants.SHADOW_IN;
                break;
            case SYM_OUT:
                info.shadow = GTKConstants.SHADOW_OUT;
                break;
            case SYM_ETCHED_IN:
                info.shadow = GTKConstants.SHADOW_ETCHED_IN;
                break;
            case SYM_ETCHED_OUT:
                info.shadow = GTKConstants.SHADOW_ETCHED_OUT;
                break;
            default:
                return SYM_NONE;
        }

        return GTKScanner.TOKEN_NONE;
private intparseState(PixmapStyle.Info info)

        int token;
        
        token = scanner.getToken();
        if (token != SYM_STATE) {
            return SYM_STATE;
        }
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        switch(token) {
            case SYM_NORMAL:
                info.componentState = SynthConstants.ENABLED;
                break;
            case SYM_ACTIVE:
                info.componentState = SynthConstants.PRESSED;
                break;
            case SYM_PRELIGHT:
                info.componentState = SynthConstants.MOUSE_OVER;
                break;
            case SYM_SELECTED:
                info.componentState = SynthConstants.SELECTED;
                break;
            case SYM_INSENSITIVE:
                info.componentState = SynthConstants.DISABLED;
                break;
            default:
                return SYM_NORMAL;
        }

        return GTKScanner.TOKEN_NONE;
private intparseStretch(boolean[] retVal)

        int token;
        
        token = scanner.getToken();
        
        token = scanner.getToken();
        if (token != GTKScanner.TOKEN_EQUAL_SIGN) {
            return GTKScanner.TOKEN_EQUAL_SIGN;
        }
        
        token = scanner.getToken();
        switch(token) {
            case SYM_TRUE:
                retVal[0] = true;
                break;
            case SYM_FALSE:
                retVal[0] = false;
                break;
            default:
                return SYM_TRUE;
        }
        
        return GTKScanner.TOKEN_NONE;
private voidregisterSymbolsIfNecessary()

        if (scanner.containsSymbol(symbolNames[0])) {
            return;
        }

        for (int i = 0; i < symbolNames.length; i++) {
            scanner.addSymbol(symbolNames[i], symbolVals[i]);
        }