| /******************************************************************************* |
| * Copyright (c) 2003, 2020 IBM Corporation and Others |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Junji MAEDA - initial API and implementation |
| * Kentarou FUKUDA - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.actf.visualization.internal.engines.lowvision; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.StringTokenizer; |
| import java.util.Vector; |
| |
| import org.eclipse.actf.model.ui.editor.browser.ICurrentStyles; |
| import org.eclipse.actf.util.logging.DebugPrintUtil; |
| import org.eclipse.actf.visualization.engines.lowvision.LowVisionException; |
| import org.eclipse.actf.visualization.engines.lowvision.LowVisionType; |
| import org.eclipse.actf.visualization.engines.lowvision.image.ImageException; |
| import org.eclipse.actf.visualization.eval.problem.ILowvisionProblemSubtype; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.checker.W3CColorChecker; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.color.ColorCSS; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.color.ColorException; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.color.ColorIRGB; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.ColorProblem; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.ColorWarning; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.FixedSizeFontProblem; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.ILowVisionProblem; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.LowVisionProblem; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.LowVisionProblemException; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.ProhibitedBackgroundColorProblem; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.ProhibitedBothColorsProblem; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.ProhibitedForegroundColorProblem; |
| import org.eclipse.actf.visualization.internal.engines.lowvision.problem.SmallFontProblem; |
| import org.eclipse.swt.graphics.Rectangle; |
| |
| /* |
| * informations from HTML DOM |
| */ |
| public class PageElement { |
| |
| // IE fontsize |
| static final String IE_LARGEST_FONT = "16pt"; //$NON-NLS-1$ |
| static final double IE_EM_SCALING = 1.33; // "1em" in largest |
| // (experimental) |
| static final double IE_LARGER_SCALING = 1.67; // "larger" in largest |
| // (experimental) |
| static final double IE_SMALLER_SCALING = 1.00; // "smaller" in largest |
| // (experimental) |
| |
| // severity for color problems |
| public static final double SEVERITY_PROHIBITED_FOREGROUND_COLOR = 0.5; |
| public static final double SEVERITY_PROHIBITED_BACKGROUND_COLOR = 0.5; |
| public static final double SEVERITY_PROHIBITED_BOTH_COLORS = SEVERITY_PROHIBITED_FOREGROUND_COLOR |
| + SEVERITY_PROHIBITED_BACKGROUND_COLOR; |
| |
| private static final String DELIM = "/"; //$NON-NLS-1$ |
| |
| // text check |
| @SuppressWarnings("nls") |
| private static final String[] nonTextTagNames = { "area", "base", "basefont", "br", "col", "colgroup", "frame", |
| "frameset", "head", "html", "hr", "img", "isindex", "link", "meta", "optgroup", "param", "script", "select", |
| "style", "title" }; |
| |
| // tags that change font size when that succeeded pt from <body> |
| @SuppressWarnings("nls") |
| private static final String[] fontSizeChangeTags = { "big", "code", "h1", "h2", "h3", "h5", "h6", "kbd", "pre", |
| "samp", "small", "sub", "sup", "tt" }; |
| |
| /* |
| * tags that usually uses same font size (can change by using %,em,ex) -> |
| * now we can change font size of these elements |
| */ |
| // @SuppressWarnings("nls") |
| // private static final String[] alwaysFixedFontSizeTags = { "button", |
| // "option", "textarea" }; |
| |
| public static final int UNSET_POSITION = -1; |
| |
| public static final int UNSET_COLOR = -1; |
| |
| private String id = null; // eclipse-actf-id |
| |
| private ICurrentStyles style = null; |
| |
| private String tagName = null; |
| |
| // position in the image |
| private int x = UNSET_POSITION; |
| private int y = UNSET_POSITION; |
| private int width = UNSET_POSITION; |
| private int height = UNSET_POSITION; |
| |
| private int foregroundColor = UNSET_COLOR; |
| private int backgroundColor = UNSET_COLOR; |
| |
| private boolean bForegroundAlpha = false; |
| private boolean bBackgroundAlpha = false; |
| private boolean bOpacity = false; |
| |
| public PageElement(String _key, ICurrentStyles _cs) throws ImageException { |
| id = _key; |
| style = _cs; |
| |
| tagName = style.getTagName().toLowerCase(); |
| setDimension(); |
| setColors(); |
| } |
| |
| private void setDimension() { |
| // TODO confirm |
| Rectangle rect = style.getRectangle(); |
| x = rect.x; |
| y = rect.y; |
| width = rect.width; |
| height = rect.height; |
| } |
| |
| private void setColors() throws ImageException { |
| if (!isTextTag()) { |
| return; |
| } |
| |
| String fgStr = style.getComputedColor(); |
| String bgStr = style.getComputedBackgroundColor(); |
| String opacityStr = style.getOpacity(); |
| |
| try { |
| if (opacityStr != null) { |
| double opacity = Double.parseDouble(opacityStr); |
| if (opacity < 1) { |
| bOpacity = true; |
| } |
| } |
| } catch (Exception e1) { |
| DebugPrintUtil.devOrDebugPrintStackTrace(e1); |
| } |
| |
| // System.out.println(style.getXPath() + ":\t" + fgStr + " / " + bgStr + |
| // " / " + opacityStr); |
| |
| try { |
| foregroundColor = (new ColorCSS(fgStr)).toInt(); |
| } catch (ColorException e) { |
| if (ColorException.ALPHA_EXISTS.equals(e.getMessage())) { |
| bForegroundAlpha = true; |
| } else { |
| throw new ImageException("Could not interpret colors."); //$NON-NLS-1$ |
| } |
| } |
| try { |
| backgroundColor = (new ColorCSS(bgStr)).toInt(); |
| } catch (ColorException e) { |
| if (ColorException.ALPHA_EXISTS.equals(e.getMessage())) { |
| bBackgroundAlpha = true; |
| } else { |
| throw new ImageException("Could not interpret colors."); //$NON-NLS-1$ |
| } |
| } |
| } |
| |
| public int getX() { |
| return (x); |
| } |
| |
| public int getY() { |
| return (y); |
| } |
| |
| public int getWidth() { |
| return (width); |
| } |
| |
| public int getHeight() { |
| return (height); |
| } |
| |
| public String getTagName() { |
| return (tagName); |
| } |
| |
| public int getForegroundColor() { |
| return (foregroundColor); |
| } |
| |
| public int getBackgroundColor() { |
| return (backgroundColor); |
| } |
| |
| // _lvType: for LowVision error check |
| public ILowVisionProblem[] check(LowVisionType _lvType, String[] allowedFgColors, String[] allowedBgColors) { |
| Vector<ILowVisionProblem> problemVec = new Vector<ILowVisionProblem>(); |
| |
| // ignore elements not in the rendered area |
| if (x < 0 || y < 0) { |
| return (new LowVisionProblem[0]); |
| } |
| |
| try { |
| problemVec.addAll(checkColors(_lvType)); |
| } catch (LowVisionException e) { |
| DebugUtil.errMsg(this, "Error occurred in checking colors: id = " //$NON-NLS-1$ |
| + this.id); |
| e.printStackTrace(); |
| } |
| |
| FixedSizeFontProblem fsfp = null; |
| try { |
| fsfp = checkFixedSizeFont(_lvType); |
| } catch (LowVisionException e) { |
| DebugUtil.errMsg(this, "Error occurred in checking fixed-size font: id = " //$NON-NLS-1$ |
| + this.id); |
| e.printStackTrace(); |
| } |
| |
| SmallFontProblem sfp = null; |
| try { |
| sfp = checkSmallFont(_lvType); |
| } catch (LowVisionException e) { |
| DebugUtil.errMsg(this, "Error occurred in checking small font: id = " + this.id); //$NON-NLS-1$ |
| e.printStackTrace(); |
| } |
| |
| if (fsfp != null && sfp != null) { |
| // // calc severity |
| // double proba = Math.max( fsfp.getProbability(), |
| // sfp.getProbability() ); |
| |
| int type = fsfp.getLowVisionProblemType(); |
| String attrName = null; |
| switch (type) { |
| case ILowvisionProblemSubtype.LOWVISION_FIXED_SIZE_FONT_PROBLEM: |
| attrName = fsfp.getAttrName(); |
| try { |
| fsfp.changeType(ILowvisionProblemSubtype.LOWVISION_FIXED_SMALL_FONT_PROBLEM); |
| if (attrName != null && !attrName.isEmpty()) { |
| fsfp.setAttrName(attrName); |
| } |
| problemVec.addElement(fsfp); |
| } catch (LowVisionProblemException e) { |
| e.printStackTrace(); |
| } |
| break; |
| case ILowvisionProblemSubtype.LOWVISION_FIXED_SIZE_FONT_WARNING: |
| attrName = fsfp.getAttrName(); |
| try { |
| fsfp.changeType(ILowvisionProblemSubtype.LOWVISION_FIXED_SMALL_FONT_WARNIG); |
| if (attrName != null && !attrName.isEmpty()) { |
| fsfp.setAttrName(attrName); |
| } |
| problemVec.addElement(fsfp); |
| } catch (LowVisionProblemException e) { |
| e.printStackTrace(); |
| } |
| break; |
| default: |
| DebugUtil.errMsg(this, "not fixed size font error/warning: type = " + type); //$NON-NLS-1$ |
| } |
| // use fixed severity |
| } else if (fsfp != null) { |
| problemVec.addElement(fsfp); |
| } else if (sfp != null) { |
| problemVec.addElement(sfp); |
| } |
| |
| ProhibitedForegroundColorProblem pfcp = null; |
| ProhibitedBackgroundColorProblem pbcp = null; |
| |
| if (allowedFgColors != null && allowedFgColors.length > 0 && !bForegroundAlpha) { |
| try { |
| pfcp = checkAllowedForegroundColors(_lvType, allowedFgColors); |
| } catch (LowVisionException lve) { |
| lve.printStackTrace(); |
| } |
| } |
| if (allowedBgColors != null && allowedBgColors.length > 0 && !bBackgroundAlpha) { |
| try { |
| pbcp = checkAllowedBackgroundColors(_lvType, allowedBgColors); |
| } catch (LowVisionException lve) { |
| lve.printStackTrace(); |
| } |
| } |
| if ((pfcp != null) && (pbcp != null)) {// fg/bg |
| try { |
| problemVec.addElement( |
| new ProhibitedBothColorsProblem(this, _lvType, PageElement.SEVERITY_PROHIBITED_BOTH_COLORS)); |
| } catch (LowVisionProblemException lvpe) { |
| lvpe.printStackTrace(); |
| } |
| pfcp = null; |
| pbcp = null; |
| } else if (pfcp != null) { // fg |
| problemVec.addElement(pfcp); |
| } else if (pbcp != null) { // bg |
| problemVec.addElement(pbcp); |
| } |
| |
| int size = problemVec.size(); |
| ILowVisionProblem[] problemArray = new ILowVisionProblem[size]; |
| for (int i = 0; i < size; i++) { |
| problemArray[i] = problemVec.elementAt(i); |
| } |
| return (problemArray); |
| } |
| |
| private List<ILowVisionProblem> checkColors(LowVisionType _lvType) throws LowVisionException { |
| |
| List<ILowVisionProblem> result = new ArrayList<ILowVisionProblem>(); |
| |
| if (!isTextTag()) { |
| return (result); |
| } |
| try { |
| if (style.hasDescendantTextWithBGImage()) { |
| ColorProblem cp = new ColorProblem(this, _lvType, 0); |
| cp.setElement(style.getElement()); |
| cp.setHasBackgroundImage(true); |
| cp.setTargetStrings(style.getDescendantTextsWithBGImage()); |
| cp.setIsWarning(true); |
| result.add(cp); |
| } |
| |
| if (!style.hasChildText()) { |
| return (result); |
| } |
| |
| boolean hasBgImage = (style.getComputedBackgroundImage() != null |
| && !style.getComputedBackgroundImage().equalsIgnoreCase("none")); |
| |
| ColorWarning cw; |
| if (bOpacity) { |
| cw = new ColorWarning(ColorWarning.OPACITY, this, _lvType); |
| result.add(cw); |
| return (result); |
| } else if (bForegroundAlpha) { |
| if (bBackgroundAlpha) { |
| cw = new ColorWarning(ColorWarning.BOTH, this, _lvType); |
| } else { |
| cw = new ColorWarning(ColorWarning.FONT, this, _lvType); |
| } |
| cw.setElement(style.getElement()); |
| result.add(cw); |
| return (result); |
| } else if (bBackgroundAlpha) { |
| cw = new ColorWarning(ColorWarning.BACKGROUND, this, _lvType); |
| cw.setElement(style.getElement()); |
| result.add(cw); |
| return (result); |
| } |
| |
| ColorIRGB fgOrg = new ColorIRGB(foregroundColor); |
| ColorIRGB bgOrg = new ColorIRGB(backgroundColor); |
| |
| W3CColorChecker w3c = new W3CColorChecker(fgOrg, bgOrg); |
| double contrast = w3c.calcContrast(); |
| if (contrast < 7) { |
| ColorProblem cp = new ColorProblem(this, _lvType, w3c.calcSeverity()); |
| cp.setElement(style.getElement()); |
| cp.setContrast(contrast); |
| cp.setTargetStrings(style.getChildTexts()); |
| cp.setHasBackgroundImage(hasBgImage); |
| result.add(cp); |
| } |
| } catch (LowVisionProblemException e) { |
| } |
| return (result); |
| |
| /* |
| * if (!(_lvType.doChangeColors())) { //TODO ColorIRGB fgSim = null; |
| * ColorIRGB bgSim = null; try { fgSim = new |
| * ColorIRGB(_lvType.convertColor(foregroundColor)); bgSim = new |
| * ColorIRGB(_lvType.convertColor(backgroundColor)); } catch |
| * (LowVisionException e) { e.printStackTrace(); throw new |
| * LowVisionException("Could not convert colors."); //$NON-NLS-1$ } |
| * |
| * W3CColorChecker w3c = new W3CColorChecker(fgSim, bgSim); double |
| * severity = w3c.calcSeverity(); try { if (severity <= 0.0) { if |
| * (style.getBackgroundImage() != null && |
| * !style.getBackgroundImage().equalsIgnoreCase( "none")) { ColorProblem |
| * result = new ColorProblem(this, _lvType, 0); |
| * result.setHasBackgroundImage(true); return (result); } return (null); |
| * } else { ColorProblem result = new ColorProblem(this, _lvType, |
| * severity); if (style.getBackgroundImage() != null && |
| * !style.getBackgroundImage().equalsIgnoreCase( "none")) |
| * result.setHasBackgroundImage(true); return (result); } } catch |
| * (LowVisionProblemException e) { return (null); } } return(null); |
| */ |
| } |
| |
| /* |
| * fixed size font check experimental result (in IE6) (1)mm,cm,in,pt,pc,px |
| * -> fixed (2)larger,smaller, xx-small to xx-large -> variable (3)em,ex,% |
| * -> same with parent (if not specified in ancestor -> variable) |
| * |
| * if <BODY> uses "pt" -> consider IE added this configuration |
| * |
| * private static final Pattern regexFontSequence = |
| * Pattern.compile("^(([^\\/]+\\/)*([^\\/]+))$" ); |
| */ |
| private static final short FONT_SIZE_UNKNOWN = 0; |
| |
| private static final short FONT_SIZE_FIXED = 1; // in, cm, mm, pc, px |
| |
| private static final short FONT_SIZE_PT = 2; // pt |
| |
| private static final short FONT_SIZE_RELATIVE = 3; // smaller, larger |
| |
| // xx-small,..., xx-large |
| private static final short FONT_SIZE_ABSOLUTE = 4; |
| |
| private static final short FONT_SIZE_PERCENT = 5; // % |
| |
| private static final short FONT_SIZE_EM = 6; // em, ex |
| |
| private static final short FONT_SIZE_REM = 7; // rem |
| |
| private static final short FONT_SIZE_V = 8; // vw, vh,vmin,vmax |
| |
| private static final String[] FIXED_FONT_STRINGS = { "in", "cm", "mm", "pc", "px" }; |
| |
| private FixedSizeFontProblem checkFixedSizeFont(LowVisionType _lvType) throws LowVisionException { |
| // if (!(_lvType.doBlur())) { |
| // return (null); |
| // } |
| |
| if (!isTextTag()) { |
| return (null); |
| } |
| |
| if (!style.hasChildText()) { |
| return (null); |
| } |
| |
| // difficult to change font size |
| // if (isAlwaysFixedSizeFontTag(tagName)) { |
| // return (null); |
| // } |
| |
| String fontStr = style.getFontSize().toLowerCase(); |
| |
| // System.out.println(fontStr); |
| |
| // directly under the <BODY> |
| if (fontStr.indexOf(DELIM) == -1) { |
| fontStr = digitToFontSetting(fontStr); |
| short type = fontSizeType(fontStr); |
| |
| if (type == FONT_SIZE_FIXED) { |
| // not include "pt" because IE usually returns "pt" |
| String typeS = null; |
| |
| for (String tmpS : FIXED_FONT_STRINGS) { |
| if (fontStr.endsWith(tmpS)) { |
| typeS = tmpS; |
| } |
| } |
| |
| try { |
| FixedSizeFontProblem problem; |
| problem = new FixedSizeFontProblem(ILowvisionProblemSubtype.LOWVISION_FIXED_SIZE_FONT_PROBLEM, this, |
| _lvType); |
| if (typeS != null) { |
| problem.setAttrName(typeS); |
| } |
| problem.setElement(style.getElement()); |
| return (problem); |
| } catch (LowVisionProblemException e) { |
| e.printStackTrace(); |
| return (null); |
| } |
| } else if (type == FONT_SIZE_PT) { |
| FixedSizeFontProblem problem; |
| try { |
| problem = new FixedSizeFontProblem(ILowvisionProblemSubtype.LOWVISION_FIXED_SIZE_FONT_WARNING, this, |
| _lvType); |
| problem.setAttrName("pt"); |
| problem.setElement(style.getElement()); |
| return (problem); |
| } catch (LowVisionProblemException e) { |
| e.printStackTrace(); |
| return (null); |
| } |
| } else { |
| return (null); |
| } |
| } |
| |
| boolean fixedFlag = false; |
| StringTokenizer st = new StringTokenizer(fontStr, DELIM); |
| int tokenCount = st.countTokens(); |
| String myFont = digitToFontSetting(st.nextToken()); |
| short myType = fontSizeType(myFont); |
| if (myType == FONT_SIZE_FIXED) { |
| fixedFlag = true; |
| } else if (myType == FONT_SIZE_RELATIVE || myType == FONT_SIZE_ABSOLUTE) { |
| // fixedFlag = false; |
| } else { // "pt", "em", "ex", "%" |
| String[] fontSequence = new String[tokenCount]; |
| fontSequence[tokenCount - 1] = myFont; |
| for (int i = tokenCount - 2; i >= 0; i--) { |
| fontSequence[i] = digitToFontSetting(st.nextToken()); |
| } |
| StringTokenizer stTag = new StringTokenizer(tagName, DELIM); |
| if (stTag.countTokens() != tokenCount) { |
| throw new LowVisionException("# of tagNames and fontSizes did not match."); //$NON-NLS-1$ |
| } |
| String[] tagNameSequence = new String[tokenCount]; |
| for (int i = tokenCount - 1; i >= 0; i--) { |
| tagNameSequence[i] = stTag.nextToken(); |
| } |
| |
| // fixedFlag = false; |
| String curFont = fontSequence[0]; // <BODY> |
| short curType = fontSizeType(curFont); |
| boolean firstPtFlag = true; |
| |
| // if( curType == FONT_SIZE_PARENT ){ |
| // firstPtFlag = false; |
| // }else if( curType == FONT_SIZE_FIXED ){ |
| // fixedFlag = true; |
| // } |
| if (curType != FONT_SIZE_PT) { |
| firstPtFlag = false; |
| } |
| if (curType == FONT_SIZE_FIXED) { |
| fixedFlag = true; |
| } |
| |
| for (int i = 1; i < tokenCount; i++) { |
| String tmpFont = fontSequence[i]; |
| String tmpTag = tagNameSequence[i]; |
| // <TD>,<TH> -> same initialization at <BODY> |
| if (tmpTag.equals("td") || tmpTag.equals("th")) { //$NON-NLS-1$ //$NON-NLS-2$ |
| firstPtFlag = true; |
| if (curType != FONT_SIZE_PT) { |
| firstPtFlag = false; |
| } |
| if (curType == FONT_SIZE_FIXED) { |
| fixedFlag = true; |
| } |
| } else { |
| if (curFont.equals(tmpFont)) { // not defined by user |
| continue; |
| } else { |
| short tmpType = fontSizeType(tmpFont); |
| if (tmpType == FONT_SIZE_FIXED) { |
| fixedFlag = true; |
| firstPtFlag = true; |
| } else if (tmpType == FONT_SIZE_RELATIVE || tmpType == FONT_SIZE_ABSOLUTE) { |
| fixedFlag = false; |
| firstPtFlag = true; |
| } else if (tmpType == FONT_SIZE_PT) { |
| if (!firstPtFlag) { |
| firstPtFlag = true; |
| fixedFlag = false; // need check |
| } else if (curType != FONT_SIZE_PT || fixedFlag == true || !isFontSizeChangeTag(tmpTag)) { |
| fixedFlag = true; |
| } |
| // else{ |
| // // "pt" & parent "pt" & variable & <PRE> etc. -> |
| // variable |
| // } |
| } |
| // else{ |
| // // "em", "ex", "%"-> same as parent |
| // } |
| curFont = tmpFont; |
| curType = tmpType; |
| } |
| } |
| } |
| } |
| |
| if (fixedFlag) { |
| try { |
| FixedSizeFontProblem problem = new FixedSizeFontProblem( |
| ILowvisionProblemSubtype.LOWVISION_FIXED_SIZE_FONT_PROBLEM, this, _lvType); |
| problem.setElement(style.getElement()); |
| return (problem); |
| } catch (LowVisionProblemException e) { |
| e.printStackTrace(); |
| return (null); |
| } |
| } else { |
| return (null); |
| } |
| } |
| |
| @SuppressWarnings("nls") |
| private short fontSizeType(String _fontSize) { |
| String s = _fontSize.toLowerCase(); |
| |
| if (s.endsWith("vw") || s.endsWith("vh") || s.endsWith("vmin") || s.endsWith("vmax")) { |
| return (FONT_SIZE_V); |
| } else if (s.endsWith("mm") || s.endsWith("cm") || s.endsWith("in") || s.endsWith("pc") || s.endsWith("px")) { |
| return (FONT_SIZE_FIXED); |
| } else if (s.endsWith("pt")) { |
| return (FONT_SIZE_PT); |
| } else if (s.endsWith("%")) { |
| return (FONT_SIZE_PERCENT); |
| } else if (s.endsWith("rem")) { |
| return (FONT_SIZE_REM); |
| } else if (s.endsWith("em") || s.endsWith("ex")) { |
| return (FONT_SIZE_EM); |
| } else if (s.equals("smaller") || s.equals("larger")) { |
| return (FONT_SIZE_RELATIVE); |
| } else { |
| return (FONT_SIZE_ABSOLUTE); |
| } |
| } |
| |
| @SuppressWarnings("nls") |
| private String digitToFontSetting(String _fontStr) throws LowVisionException { |
| |
| if (_fontStr.length() == 1) { |
| if (_fontStr.equals("1")) { |
| return ("xx-small"); |
| } else if (_fontStr.equals("2")) { |
| return ("x-small"); |
| } else if (_fontStr.equals("3")) { |
| return ("small"); |
| } else if (_fontStr.equals("4")) { |
| return ("medium"); |
| } else if (_fontStr.equals("5")) { |
| return ("large"); |
| } else if (_fontStr.equals("6")) { |
| return ("x-large"); |
| } else if (_fontStr.equals("7")) { |
| return ("xx-large"); |
| } else { |
| throw new LowVisionException("Invalid font size setting: " + _fontStr); |
| } |
| } else if (_fontStr.startsWith("+")) { |
| if (_fontStr.equals("+1")) { |
| return ("120%"); |
| } else if (_fontStr.equals("+2")) { |
| return ("144%"); |
| } else if (_fontStr.equals("+3")) { |
| return ("173%"); |
| } else if (_fontStr.equals("+4")) { |
| return ("207%"); |
| } else if (_fontStr.equals("+5")) { |
| return ("249%"); |
| } else if (_fontStr.equals("+6")) { |
| return ("299%"); |
| } else if (_fontStr.equals("+0")) { |
| // used in some pages |
| return ("100%"); |
| } else { |
| throw new LowVisionException("Invalid font size setting: " + _fontStr); |
| } |
| } else if (_fontStr.startsWith("-")) { |
| if (_fontStr.equals("-1")) { |
| return ("83%"); |
| } else if (_fontStr.equals("-2")) { |
| return ("69%"); |
| } else if (_fontStr.equals("-3")) { |
| return ("58%"); |
| } else if (_fontStr.equals("-4")) { |
| return ("48%"); |
| } else if (_fontStr.equals("-5")) { |
| return ("40%"); |
| } else if (_fontStr.equals("-6")) { |
| return ("33%"); |
| } else if (_fontStr.equals("-0")) { |
| return ("100%"); |
| } else { |
| throw new LowVisionException("Invalid font size setting: " + _fontStr); |
| } |
| } else { |
| return (_fontStr); |
| } |
| } |
| |
| private boolean isFontSizeChangeTag(String _st) { |
| int len = fontSizeChangeTags.length; |
| String s = _st.toLowerCase(); |
| for (int i = 0; i < len; i++) { |
| if (s.equals(fontSizeChangeTags[i])) { |
| return (true); |
| } |
| } |
| return (false); |
| } |
| |
| // private boolean isAlwaysFixedSizeFontTag(String _st) { |
| // String s = _st.toLowerCase(); |
| // int index = s.indexOf(DELIM); |
| // if (index > -1) { |
| // s = s.substring(0, index); |
| // } |
| // int len = alwaysFixedFontSizeTags.length; |
| // for (int i = 0; i < len; i++) { |
| // if (s.equals(alwaysFixedFontSizeTags[i])) { |
| // return (true); |
| // } |
| // } |
| // return (false); |
| // } |
| |
| /* |
| * note: reset at td/th is experimental behaviour in IE6 |
| */ |
| @SuppressWarnings("nls") |
| private SmallFontProblem checkSmallFont(LowVisionType _lvType) throws LowVisionException { |
| if (!(_lvType.doBlur())) { |
| return (null); |
| } |
| |
| double eyesightLength = _lvType.getEyesightLength(); |
| |
| if (!isTextTag()) { |
| return (null); |
| } |
| |
| if (!style.hasChildText()) { |
| return (null); |
| } |
| |
| /* |
| * TODO <OPTION>: offsetWidth, offsetHeight = 0 -> can't highlight |
| * target |
| * |
| * need to select parent <SELECT> |
| */ |
| if (tagName.startsWith("option")) { |
| return (null); |
| } |
| |
| String fontStr = style.getFontSize().toLowerCase(); |
| |
| // reset at TD/TH |
| StringTokenizer fontSt = new StringTokenizer(fontStr, DELIM); |
| Vector<String> fontSequence = new Vector<String>(); |
| StringTokenizer tagSt = new StringTokenizer(tagName, DELIM); |
| String curFont = fontSt.nextToken(); |
| String curTag = tagSt.nextToken(); |
| fontSequence.addElement(curFont); |
| while (fontSt.hasMoreTokens()) { |
| String tmpFont = fontSt.nextToken(); |
| curTag = tagSt.nextToken(); |
| if (curTag.equals("td") || curTag.equals("th")) { |
| if (!(tmpFont.equals(curFont))) { |
| fontSequence.addElement(tmpFont); |
| } |
| break; |
| } else { |
| if (!(tmpFont.equals(curFont))) { |
| fontSequence.addElement(tmpFont); |
| } |
| } |
| curFont = tmpFont; |
| } |
| |
| int numFontSizeSettings = fontSequence.size(); |
| String[] fontSizeSettings = new String[numFontSizeSettings]; |
| for (int i = 0; i < numFontSizeSettings; i++) { |
| String tmpSetting = fontSequence.elementAt(i); |
| fontSizeSettings[i] = digitToFontSetting(tmpSetting); |
| } |
| fontSequence = null; |
| |
| /* |
| * if last value is "pt"-> consider the automatic setting by IE |
| * |
| * define LARGEST as default to check the small size font in the LARGEST |
| * setting |
| * |
| */ |
| String curFontSize = fontSizeSettings[numFontSizeSettings - 1]; |
| /* |
| * -> Do not replace "pt" values and evaluate it based on the value that |
| * used in IE. If the size is small, create warning. |
| */ |
| /* |
| * if (fontSizeType(curFontSize) == FONT_SIZE_PT) { |
| * fontSizeSettings[numFontSizeSettings - 1] = IE_LARGEST_FONT; for (int |
| * i = numFontSizeSettings - 2; i >= 0; i--) { if |
| * (fontSizeSettings[i].equals(curFontSize)) { fontSizeSettings[i] = |
| * IE_LARGEST_FONT; } else { break; } } } |
| */ |
| |
| float scaling = 1.0f; // smaller, larger, em, ex, % |
| short curType = FONT_SIZE_UNKNOWN; |
| for (int i = 0; i < numFontSizeSettings; i++) { |
| curFontSize = fontSizeSettings[i]; |
| curType = fontSizeType(curFontSize); |
| if (curType == FONT_SIZE_FIXED || curType == FONT_SIZE_PT) { |
| break; |
| } else if (curType == FONT_SIZE_ABSOLUTE) { |
| if (curFontSize.equals("xx-large")) { |
| curFontSize = "48pt"; |
| } else if (curFontSize.equals("x-large")) { |
| curFontSize = "32pt"; |
| } else if (curFontSize.equals("large")) { |
| curFontSize = "24pt"; |
| } else if (curFontSize.equals("medium")) { |
| curFontSize = "18pt"; |
| } else if (curFontSize.equals("small")) { |
| curFontSize = "16pt"; |
| } else if (curFontSize.equals("x-small")) { |
| curFontSize = "14pt"; |
| } else if (curFontSize.equals("xx-small")) { |
| curFontSize = "12pt"; |
| } |
| break; |
| } else if (curType == FONT_SIZE_PERCENT) { |
| double value = Double.parseDouble(curFontSize.substring(0, curFontSize.length() - 1)); |
| scaling *= (value / 100.0); |
| } else if (curType == FONT_SIZE_REM) { |
| // TODO get Root(html element) font size and evaluate size |
| // (font size check for relative spec is currently not used ) |
| } else if (curType == FONT_SIZE_EM) { |
| double value = 0.0; |
| value = Double.parseDouble(curFontSize.substring(0, curFontSize.length() - 2)); |
| if (curFontSize.endsWith("ex")) { |
| value /= 2.0; |
| } |
| scaling *= (value * IE_EM_SCALING); |
| } else if (curType == FONT_SIZE_V) { |
| // TODO get viewport and evaluate size |
| // (font size check for relative spec is currently not used ) |
| } else if (curFontSize.equals("larger")) { |
| scaling *= IE_LARGER_SCALING; |
| } else if (curFontSize.equals("smaller")) { |
| scaling *= IE_SMALLER_SCALING; |
| } else { |
| throw new LowVisionException("unknown font size setting: " + curFontSize); |
| } |
| } |
| |
| if (curType == FONT_SIZE_V || curType == FONT_SIZE_REM || curType == FONT_SIZE_UNKNOWN) { |
| return (null); |
| } |
| |
| if (curType != FONT_SIZE_FIXED && curType != FONT_SIZE_PT && curType != FONT_SIZE_ABSOLUTE) { |
| curFontSize = IE_LARGEST_FONT; |
| } |
| |
| float value; |
| try { |
| // value = Float.parseFloat(curFontSize.substring(0, |
| // curFontSize.length() - 2)); |
| String numPart = curFontSize.replaceAll("[^0-9\\.]", ""); |
| value = Float.parseFloat(numPart); |
| } catch (Exception e) { |
| throw new LowVisionException("unknown font size unit: " + curFontSize); |
| } |
| |
| float sizeInMm = 0.0f; |
| if (curFontSize.endsWith("in")) { |
| sizeInMm = LengthUtil.in2mm(value); |
| } else if (curFontSize.endsWith("cm")) { |
| sizeInMm = LengthUtil.cm2mm(value); |
| } else if (curFontSize.endsWith("mm")) { |
| sizeInMm = value; |
| } else if (curFontSize.endsWith("pt")) { |
| sizeInMm = LengthUtil.pt2mm(value); |
| } else if (curFontSize.endsWith("pc")) { |
| sizeInMm = LengthUtil.pc2mm(value); |
| } else if (curFontSize.endsWith("px")) { |
| sizeInMm = LengthUtil.px2mm(value); |
| } else { |
| throw new LowVisionException("unknown font size unit: " + curFontSize); |
| } |
| sizeInMm *= scaling; |
| |
| // can distinguish "c" and "o"? |
| // size of "c" is about half of char size |
| // disconnected part of "c" is about 1/5 of "c" |
| double severity = 2.0 - sizeInMm / (10.0 * eyesightLength); |
| if (severity > 1.0) |
| severity = 1.0; |
| else if (severity < 0.0) |
| severity = 0.0; |
| |
| if (severity > 0.0) { |
| try { |
| // fixed severity |
| SmallFontProblem problem = new SmallFontProblem(this, _lvType); |
| problem.setElement(style.getElement()); |
| return (problem); |
| } catch (LowVisionProblemException e) { |
| e.printStackTrace(); |
| return (null); |
| } |
| } else { |
| return (null); |
| } |
| } |
| |
| private ProhibitedForegroundColorProblem checkAllowedForegroundColors(LowVisionType _lvType, |
| String[] _allowedColors) throws LowVisionException { |
| if (_allowedColors == null) { |
| return (null); |
| } |
| int len = _allowedColors.length; |
| if (len == 0) { |
| return (null); |
| } |
| |
| if (!isTextTag()) { |
| return (null); |
| } |
| |
| // TODO check link color? |
| if (tagName.startsWith("a/")) { //$NON-NLS-1$ |
| return (null); |
| } |
| |
| // use "black" as default |
| // TODO use system color |
| if (foregroundColor == ColorCSS.DEFAULT_COLOR_INT) { |
| return (null); |
| } |
| |
| for (int i = 0; i < len; i++) { |
| String curColorString = _allowedColors[i]; |
| ColorIRGB templateColor = null; |
| try { |
| templateColor = new ColorIRGB(curColorString); |
| } catch (ColorException ce) { |
| ce.printStackTrace(); |
| throw new LowVisionException("ColorException occurs while converting String \"" //$NON-NLS-1$ |
| + curColorString + "\" to a color."); //$NON-NLS-1$ |
| } |
| if (templateColor.equals(foregroundColor)) { |
| return (null); |
| } |
| } |
| |
| try { |
| return (new ProhibitedForegroundColorProblem(this, _lvType, |
| PageElement.SEVERITY_PROHIBITED_FOREGROUND_COLOR)); |
| } catch (LowVisionProblemException lvpe) { |
| lvpe.printStackTrace(); |
| return (null); |
| } |
| } |
| |
| private ProhibitedBackgroundColorProblem checkAllowedBackgroundColors(LowVisionType _lvType, |
| String[] _allowedColors) throws LowVisionException { |
| if (_allowedColors == null) { |
| return (null); |
| } |
| int len = _allowedColors.length; |
| if (len == 0) { |
| return (null); |
| } |
| |
| if (!isTextTag()) { |
| return (null); |
| } |
| |
| // use transparent as defaul background-color |
| if (backgroundColor == ColorCSS.DEFAULT_BACKGROUND_COLOR_INT) { |
| return (null); |
| } |
| |
| for (int i = 0; i < len; i++) { |
| String curColorString = _allowedColors[i]; |
| ColorIRGB templateColor = null; |
| try { |
| templateColor = new ColorIRGB(curColorString); |
| } catch (ColorException ce) { |
| ce.printStackTrace(); |
| throw new LowVisionException("ColorException occurs while converting String \"" //$NON-NLS-1$ |
| + curColorString + "\" to a color."); //$NON-NLS-1$ |
| } |
| if (templateColor.equals(backgroundColor)) { |
| return (null); |
| } |
| } |
| try { |
| return (new ProhibitedBackgroundColorProblem(this, _lvType, |
| PageElement.SEVERITY_PROHIBITED_BACKGROUND_COLOR)); |
| } catch (LowVisionProblemException lvpe) { |
| lvpe.printStackTrace(); |
| return (null); |
| } |
| } |
| |
| private boolean isTextTag() { |
| String tagName = style.getTagName().toLowerCase(); |
| int len = nonTextTagNames.length; |
| for (int i = 0; i < len; i++) { |
| if (tagName.startsWith(nonTextTagNames[i] /* +"/" */)) { |
| return (false); |
| } |
| // if( tagName.equals( nonTextTagNames[i] ) ){ |
| // return( false ); |
| // } |
| } |
| return (true); |
| } |
| |
| } |
