| /* ==================================================================== |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to You under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| ==================================================================== */ |
| |
| package org.apache.poi.hwpf.sprm; |
| |
| import org.apache.logging.log4j.LogManager; |
| import org.apache.logging.log4j.Logger; |
| import org.apache.poi.hwpf.usermodel.ShadingDescriptor80; |
| |
| import org.apache.poi.hwpf.model.Colorref; |
| import org.apache.poi.hwpf.model.Hyphenation; |
| import org.apache.poi.hwpf.model.StyleSheet; |
| import org.apache.poi.hwpf.usermodel.BorderCode; |
| import org.apache.poi.hwpf.usermodel.CharacterProperties; |
| import org.apache.poi.hwpf.usermodel.DateAndTime; |
| import org.apache.poi.hwpf.usermodel.ShadingDescriptor; |
| import org.apache.poi.util.Internal; |
| import org.apache.poi.util.LittleEndian; |
| |
| @Internal |
| public final class CharacterSprmUncompressor extends SprmUncompressor |
| { |
| private static final Logger LOG = LogManager.getLogger(CharacterSprmUncompressor.class); |
| |
| public CharacterSprmUncompressor() |
| { |
| } |
| |
| @Deprecated |
| public static CharacterProperties uncompressCHP( |
| CharacterProperties parent, byte[] grpprl, int offset ) |
| { |
| CharacterProperties newProperties = parent.copy(); |
| applySprms( parent, grpprl, offset, true, newProperties ); |
| return newProperties; |
| } |
| |
| public static CharacterProperties uncompressCHP( StyleSheet styleSheet, |
| CharacterProperties parStyle, byte[] grpprl, int offset ) |
| { |
| CharacterProperties newProperties; |
| if ( parStyle == null ) |
| { |
| parStyle = new CharacterProperties(); |
| newProperties = new CharacterProperties(); |
| } |
| else |
| { |
| newProperties = parStyle.copy(); |
| } |
| |
| /* |
| * not fully conform to specification, but the fastest way to make it |
| * work. Shall be rewritten if any errors would be found -- vlsergey |
| */ |
| Integer style = getIstd( grpprl, offset ); |
| if ( style != null ) |
| { |
| try |
| { |
| applySprms( parStyle, styleSheet.getCHPX( style ), 0, false, |
| newProperties ); |
| } |
| catch ( Exception exc ) |
| { |
| LOG.atError().withThrowable(exc).log("Unable to apply all style {} CHP SPRMs to CHP", style); |
| } |
| } |
| |
| CharacterProperties styleProperties = newProperties; |
| newProperties = styleProperties.copy(); |
| |
| try |
| { |
| applySprms( styleProperties, grpprl, offset, true, newProperties ); |
| } |
| catch ( Exception exc ) |
| { |
| LOG.atError().withThrowable(exc).log("Unable to process all direct CHP SPRMs"); |
| } |
| return newProperties; |
| } |
| |
| private static void applySprms( CharacterProperties parentProperties, |
| byte[] grpprl, int offset, boolean warnAboutNonChpSprms, |
| CharacterProperties targetProperties ) |
| { |
| SprmIterator sprmIt = new SprmIterator( grpprl, offset ); |
| |
| while ( sprmIt.hasNext() ) |
| { |
| SprmOperation sprm = sprmIt.next(); |
| |
| if ( sprm.getType() != 2 ) |
| { |
| if ( warnAboutNonChpSprms ) |
| { |
| LOG.atWarn().log("Non-CHP SPRM returned by SprmIterator: {}", sprm); |
| } |
| continue; |
| } |
| |
| unCompressCHPOperation( parentProperties, targetProperties, sprm ); |
| } |
| } |
| |
| private static Integer getIstd( byte[] grpprl, int offset ) |
| { |
| Integer style = null; |
| try |
| { |
| SprmIterator sprmIt = new SprmIterator( grpprl, offset ); |
| while ( sprmIt.hasNext() ) |
| { |
| SprmOperation sprm = sprmIt.next(); |
| |
| if ( sprm.getType() == 2 && sprm.getOperation() == 0x30 ) |
| { |
| // sprmCIstd (0x4A30) |
| style = Integer.valueOf( sprm.getOperand() ); |
| } |
| } |
| } |
| catch ( Exception exc ) |
| { |
| LOG.atError().withThrowable(exc).log("Unable to extract istd from direct CHP SPRM"); |
| } |
| return style; |
| } |
| |
| /** |
| * Used in decompression of a chpx. This performs an operation defined by |
| * a single sprm. |
| * |
| * @param oldCHP The base CharacterProperties. |
| * @param newCHP The current CharacterProperties. |
| * @param sprm an SPRM opearation |
| */ |
| static void unCompressCHPOperation (CharacterProperties oldCHP, |
| CharacterProperties newCHP, |
| SprmOperation sprm) |
| { |
| |
| switch (sprm.getOperation()) |
| { |
| case 0: |
| newCHP.setFRMarkDel (getFlag (sprm.getOperand())); |
| break; |
| case 0x1: |
| newCHP.setFRMark (getFlag (sprm.getOperand())); |
| break; |
| case 0x2: |
| newCHP.setFFldVanish (getFlag (sprm.getOperand())); |
| break; |
| case 0x3: |
| // sprmCPicLocation -- 0x6A03 |
| /* |
| * [MS-DOC] |
| * |
| * Page 104 of 622 |
| * |
| * A signed 32-bit integer that specifies either the position in the |
| * Data Stream of a picture or binary data or the name of an OLE |
| * object storage. |
| */ |
| newCHP.setFcPic( sprm.getOperand() ); |
| newCHP.setFSpec( true ); |
| break; |
| case 0x4: |
| newCHP.setIbstRMark ((short) sprm.getOperand()); |
| break; |
| case 0x5: |
| newCHP.setDttmRMark (new DateAndTime(sprm.getGrpprl(), sprm.getGrpprlOffset())); |
| break; |
| case 0x6: |
| newCHP.setFData (getFlag (sprm.getOperand())); |
| break; |
| case 0x7: |
| //don't care about this |
| break; |
| case 0x8: |
| //short chsDiff = (short)((param & 0xff0000) >>> 16); |
| int operand =sprm.getOperand(); |
| short chsDiff = (short) (operand & 0x0000ff); |
| newCHP.setFChsDiff (getFlag (chsDiff)); |
| newCHP.setChse ((short) (operand & 0xffff00)); |
| break; |
| case 0x9: |
| newCHP.setFSpec (true); |
| newCHP.setFtcSym (LittleEndian.getShort (sprm.getGrpprl(), sprm.getGrpprlOffset())); |
| newCHP.setXchSym (LittleEndian.getShort (sprm.getGrpprl(), sprm.getGrpprlOffset() + 2)); |
| break; |
| case 0xa: |
| newCHP.setFOle2 (getFlag (sprm.getOperand())); |
| break; |
| case 0xb: |
| |
| // Obsolete |
| break; |
| case 0xc: |
| newCHP.setIcoHighlight ((byte) sprm.getOperand()); |
| newCHP.setFHighlight (getFlag (sprm.getOperand())); |
| break; |
| case 0xd: |
| |
| // undocumented |
| break; |
| case 0xe: |
| newCHP.setFcObj (sprm.getOperand()); |
| break; |
| case 0xf: |
| |
| // undocumented |
| break; |
| case 0x10: |
| |
| // undocumented |
| break; |
| |
| // undocumented till 0x30 |
| |
| case 0x11: |
| // sprmCFWebHidden |
| break; |
| case 0x12: |
| break; |
| case 0x13: |
| break; |
| case 0x14: |
| break; |
| case 0x15: |
| // sprmCRsidProp |
| break; |
| case 0x16: |
| // sprmCRsidText |
| break; |
| case 0x17: |
| // sprmCRsidRMDel |
| break; |
| case 0x18: |
| // sprmCFSpecVanish |
| break; |
| case 0x19: |
| break; |
| case 0x1a: |
| // sprmCFMathPr |
| break; |
| case 0x1b: |
| break; |
| case 0x1c: |
| break; |
| case 0x1d: |
| break; |
| case 0x1e: |
| break; |
| case 0x1f: |
| break; |
| case 0x20: |
| break; |
| case 0x21: |
| break; |
| case 0x22: |
| break; |
| case 0x23: |
| break; |
| case 0x24: |
| break; |
| case 0x25: |
| break; |
| case 0x26: |
| break; |
| case 0x27: |
| break; |
| case 0x28: |
| break; |
| case 0x29: |
| break; |
| case 0x2a: |
| break; |
| case 0x2b: |
| break; |
| case 0x2c: |
| break; |
| case 0x2d: |
| break; |
| case 0x2e: |
| break; |
| case 0x2f: |
| break; |
| case 0x30: |
| newCHP.setIstd( sprm.getOperand() ); |
| // 0x30 is supported by uncompressCHP(...) |
| break; |
| case 0x31: |
| |
| //permutation vector for fast saves, who cares! |
| break; |
| case 0x32: |
| newCHP.setFBold (false); |
| newCHP.setFItalic (false); |
| newCHP.setFOutline (false); |
| newCHP.setFStrike (false); |
| newCHP.setFShadow (false); |
| newCHP.setFSmallCaps (false); |
| newCHP.setFCaps (false); |
| newCHP.setFVanish (false); |
| newCHP.setKul ((byte) 0); |
| newCHP.setIco ((byte) 0); |
| break; |
| case 0x33: |
| // preserve the fSpec setting from the original CHP |
| boolean fSpec = newCHP.isFSpec(); |
| newCHP = oldCHP.copy(); |
| newCHP.setFSpec( fSpec ); |
| return; |
| case 0x34: |
| // sprmCKcd |
| break; |
| case 0x35: |
| newCHP.setFBold (getCHPFlag ((byte) sprm.getOperand(), oldCHP.isFBold ())); |
| break; |
| case 0x36: |
| newCHP.setFItalic (getCHPFlag ((byte) sprm.getOperand(), oldCHP.isFItalic ())); |
| break; |
| case 0x37: |
| newCHP.setFStrike (getCHPFlag ((byte) sprm.getOperand(), oldCHP.isFStrike ())); |
| break; |
| case 0x38: |
| newCHP.setFOutline (getCHPFlag ((byte) sprm.getOperand(), oldCHP.isFOutline ())); |
| break; |
| case 0x39: |
| newCHP.setFShadow (getCHPFlag ((byte) sprm.getOperand(), oldCHP.isFShadow ())); |
| break; |
| case 0x3a: |
| newCHP.setFSmallCaps (getCHPFlag ((byte) sprm.getOperand(), oldCHP.isFSmallCaps ())); |
| break; |
| case 0x3b: |
| newCHP.setFCaps (getCHPFlag ((byte) sprm.getOperand(), oldCHP.isFCaps ())); |
| break; |
| case 0x3c: |
| newCHP.setFVanish (getCHPFlag ((byte) sprm.getOperand(), oldCHP.isFVanish ())); |
| break; |
| case 0x3d: |
| newCHP.setFtcAscii ((short) sprm.getOperand()); |
| break; |
| case 0x3e: |
| newCHP.setKul ((byte) sprm.getOperand()); |
| break; |
| case 0x3f: |
| operand = sprm.getOperand(); |
| int hps = operand & 0xff; |
| if (hps != 0) |
| { |
| newCHP.setHps (hps); |
| } |
| |
| //byte cInc = (byte)(((byte)(param & 0xfe00) >>> 4) >> 1); |
| byte cInc = (byte) ((operand & 0xff00) >>> 8); |
| cInc >>>= 1; |
| if (cInc != 0) |
| { |
| newCHP.setHps (Math.max (newCHP.getHps () + (cInc * 2), 2)); |
| } |
| |
| //byte hpsPos = (byte)((param & 0xff0000) >>> 8); |
| byte hpsPos = (byte) ((operand & 0xff0000) >>> 16); |
| if (hpsPos != (byte)0x80) |
| { |
| newCHP.setHpsPos (hpsPos); |
| } |
| boolean fAdjust = (operand & 0x0100) > 0; |
| if (fAdjust && (hpsPos & 0xFF) != 128 && hpsPos != 0 && oldCHP.getHpsPos () == 0) |
| { |
| newCHP.setHps (Math.max (newCHP.getHps () + ( -2), 2)); |
| } |
| if (fAdjust && hpsPos == 0 && oldCHP.getHpsPos () != 0) |
| { |
| newCHP.setHps (Math.max (newCHP.getHps () + 2, 2)); |
| } |
| break; |
| case 0x40: |
| newCHP.setDxaSpace (sprm.getOperand()); |
| break; |
| case 0x41: |
| newCHP.setLidDefault ((short) sprm.getOperand()); |
| break; |
| case 0x42: |
| newCHP.setIco ((byte) sprm.getOperand()); |
| break; |
| case 0x43: |
| newCHP.setHps (sprm.getOperand()); |
| break; |
| case 0x44: |
| byte hpsLvl = (byte) sprm.getOperand(); |
| newCHP.setHps (Math.max (newCHP.getHps () + (hpsLvl * 2), 2)); |
| break; |
| case 0x45: |
| newCHP.setHpsPos ((short) sprm.getOperand()); |
| break; |
| case 0x46: |
| if (sprm.getOperand() != 0) |
| { |
| if (oldCHP.getHpsPos () == 0) |
| { |
| newCHP.setHps (Math.max (newCHP.getHps () + ( -2), 2)); |
| } |
| } |
| else |
| { |
| if (oldCHP.getHpsPos () != 0) |
| { |
| newCHP.setHps (Math.max (newCHP.getHps () + 2, 2)); |
| } |
| } |
| break; |
| case 0x47: |
| /*CharacterProperties genCHP = new CharacterProperties (); |
| genCHP.setFtcAscii (4); |
| genCHP = (CharacterProperties) unCompressProperty (varParam, genCHP, |
| styleSheet); |
| CharacterProperties styleCHP = styleSheet.getStyleDescription (oldCHP. |
| getBaseIstd ()).getCHP (); |
| if (genCHP.isFBold () == newCHP.isFBold ()) |
| { |
| newCHP.setFBold (styleCHP.isFBold ()); |
| } |
| if (genCHP.isFItalic () == newCHP.isFItalic ()) |
| { |
| newCHP.setFItalic (styleCHP.isFItalic ()); |
| } |
| if (genCHP.isFSmallCaps () == newCHP.isFSmallCaps ()) |
| { |
| newCHP.setFSmallCaps (styleCHP.isFSmallCaps ()); |
| } |
| if (genCHP.isFVanish () == newCHP.isFVanish ()) |
| { |
| newCHP.setFVanish (styleCHP.isFVanish ()); |
| } |
| if (genCHP.isFStrike () == newCHP.isFStrike ()) |
| { |
| newCHP.setFStrike (styleCHP.isFStrike ()); |
| } |
| if (genCHP.isFCaps () == newCHP.isFCaps ()) |
| { |
| newCHP.setFCaps (styleCHP.isFCaps ()); |
| } |
| if (genCHP.getFtcAscii () == newCHP.getFtcAscii ()) |
| { |
| newCHP.setFtcAscii (styleCHP.getFtcAscii ()); |
| } |
| if (genCHP.getFtcFE () == newCHP.getFtcFE ()) |
| { |
| newCHP.setFtcFE (styleCHP.getFtcFE ()); |
| } |
| if (genCHP.getFtcOther () == newCHP.getFtcOther ()) |
| { |
| newCHP.setFtcOther (styleCHP.getFtcOther ()); |
| } |
| if (genCHP.getHps () == newCHP.getHps ()) |
| { |
| newCHP.setHps (styleCHP.getHps ()); |
| } |
| if (genCHP.getHpsPos () == newCHP.getHpsPos ()) |
| { |
| newCHP.setHpsPos (styleCHP.getHpsPos ()); |
| } |
| if (genCHP.getKul () == newCHP.getKul ()) |
| { |
| newCHP.setKul (styleCHP.getKul ()); |
| } |
| if (genCHP.getDxaSpace () == newCHP.getDxaSpace ()) |
| { |
| newCHP.setDxaSpace (styleCHP.getDxaSpace ()); |
| } |
| if (genCHP.getIco () == newCHP.getIco ()) |
| { |
| newCHP.setIco (styleCHP.getIco ()); |
| } |
| if (genCHP.getLidDefault () == newCHP.getLidDefault ()) |
| { |
| newCHP.setLidDefault (styleCHP.getLidDefault ()); |
| } |
| if (genCHP.getLidFE () == newCHP.getLidFE ()) |
| { |
| newCHP.setLidFE (styleCHP.getLidFE ()); |
| }*/ |
| break; |
| case 0x48: |
| newCHP.setIss ((byte) sprm.getOperand()); |
| break; |
| case 0x49: |
| newCHP.setHps (LittleEndian.getShort (sprm.getGrpprl(), sprm.getGrpprlOffset())); |
| break; |
| case 0x4a: |
| int increment = LittleEndian.getShort (sprm.getGrpprl(), sprm.getGrpprlOffset()); |
| newCHP.setHps (Math.max (newCHP.getHps () + increment, 8)); |
| break; |
| case 0x4b: |
| newCHP.setHpsKern (sprm.getOperand()); |
| break; |
| // Microsoft Office Word 97-2007 Binary File Format (.doc) Specification |
| // Page 59 of 210 |
| case 0x4c: |
| // sprmCMajority50 -- 0xCA4C |
| // unCompressCHPOperation (oldCHP, newCHP, 0x47, param, varParam, |
| // styleSheet, opSize); |
| break; |
| case 0x4d: |
| // sprmCHpsMul -- 0x4A4D |
| float percentage = sprm.getOperand() / 100.0f; |
| int add = (int) ( percentage * newCHP.getHps() ); |
| newCHP.setHps( newCHP.getHps() + add ); |
| break; |
| case 0x4e: |
| // sprmCHresi -- 0x484e |
| Hyphenation hyphenation = new Hyphenation( |
| (short) sprm.getOperand() ); |
| newCHP.setHresi( hyphenation ); |
| break; |
| case 0x4f: |
| newCHP.setFtcAscii ((short) sprm.getOperand()); |
| break; |
| case 0x50: |
| newCHP.setFtcFE ((short) sprm.getOperand()); |
| break; |
| case 0x51: |
| newCHP.setFtcOther ((short) sprm.getOperand()); |
| break; |
| case 0x52: |
| // sprmCCharScale |
| break; |
| case 0x53: |
| newCHP.setFDStrike (getFlag (sprm.getOperand())); |
| break; |
| case 0x54: |
| newCHP.setFImprint (getFlag (sprm.getOperand())); |
| break; |
| case 0x55: |
| // sprmCFSpec -- 0x0855 |
| newCHP.setFSpec( getFlag( sprm.getOperand() ) ); |
| break; |
| case 0x56: |
| newCHP.setFObj (getFlag (sprm.getOperand())); |
| break; |
| case 0x57: |
| // sprmCPropRMark -- 0xCA57 |
| /* |
| * Microsoft Office Word 97-2007 Binary File Format (.doc) |
| * Specification |
| * |
| * Page 78 of 210 |
| * |
| * sprmCPropRMark (opcode 0xCA57) is interpreted by moving the first |
| * parameter byte to chp.fPropRMark, the next two bytes to |
| * chp.ibstPropRMark, and the remaining four bytes to |
| * chp.dttmPropRMark. |
| */ |
| byte[] buf = sprm.getGrpprl(); |
| int offset = sprm.getGrpprlOffset(); |
| newCHP.setFPropRMark( buf[offset] != 0 ); |
| newCHP.setIbstPropRMark( LittleEndian.getShort( buf, offset + 1 ) ); |
| newCHP.setDttmPropRMark( new DateAndTime( buf, offset + 3 ) ); |
| break; |
| case 0x58: |
| newCHP.setFEmboss (getFlag (sprm.getOperand())); |
| break; |
| case 0x59: |
| newCHP.setSfxtText ((byte) sprm.getOperand()); |
| break; |
| case 0x5a: |
| // sprmCFBiDi |
| break; |
| case 0x5b: |
| break; |
| case 0x5c: |
| // sprmCFBoldBi |
| break; |
| case 0x5d: |
| // sprmCFItalicBi |
| break; |
| case 0x5e: |
| // sprmCFtcBi |
| break; |
| case 0x5f: |
| // sprmCLidBi |
| break; |
| case 0x60: |
| // sprmCIcoBi |
| break; |
| case 0x61: |
| // sprmCHpsBi |
| break; |
| case 0x62: |
| // sprmCDispFldRMark -- 0xCA62 |
| /* |
| * Microsoft Office Word 97-2007 Binary File Format (.doc) |
| * Specification |
| * |
| * Page 78 of 210 |
| * |
| * sprmCDispFldRMark (opcode 0xCA62) is interpreted by moving the |
| * first parameter byte to chp.fDispFldRMark, the next two bytes to |
| * chp.ibstDispFldRMark, the next four bytes to |
| * chp.dttmDispFldRMark, and the remaining 32 bytes to |
| * chp.xstDispFldRMark. |
| */ |
| byte[] xstDispFldRMark = new byte[32]; |
| buf = sprm.getGrpprl(); |
| offset = sprm.getGrpprlOffset(); |
| newCHP.setFDispFldRMark( 0 != buf[offset] ); |
| newCHP.setIbstDispFldRMark( LittleEndian.getShort( buf, offset + 1 ) ); |
| newCHP.setDttmDispFldRMark( new DateAndTime( buf, offset + 3 ) ); |
| System.arraycopy( buf, offset + 7, xstDispFldRMark, 0, 32 ); |
| newCHP.setXstDispFldRMark( xstDispFldRMark ); |
| break; |
| case 0x63: |
| newCHP.setIbstRMarkDel ((short) sprm.getOperand()); |
| break; |
| case 0x64: |
| newCHP.setDttmRMarkDel (new DateAndTime(sprm.getGrpprl(), sprm.getGrpprlOffset())); |
| break; |
| case 0x65: |
| newCHP.setBrc (new BorderCode(sprm.getGrpprl(), sprm.getGrpprlOffset())); |
| break; |
| case 0x66: |
| // sprmCShd80 |
| /* |
| * "A Shd80 structure that specifies the background shading for the text. By default, text is not shaded." |
| * |
| * Word (.doc) Binary File Format. Copyright (c) 2011 Microsoft |
| * Corporation. Release: Tuesday, March 15, 2011 |
| */ |
| ShadingDescriptor80 oldDescriptor = new ShadingDescriptor80( |
| sprm.getGrpprl(), sprm.getGrpprlOffset() ); |
| ShadingDescriptor newDescriptor = oldDescriptor |
| .toShadingDescriptor(); |
| newCHP.setShd( newDescriptor ); |
| break; |
| case 0x67: |
| // Obsolete |
| break; |
| case 0x68: |
| // sprmCFUsePgsuSettings |
| break; |
| case 0x69: |
| break; |
| case 0x6a: |
| break; |
| case 0x6b: |
| break; |
| case 0x6c: |
| break; |
| case 0x6d: |
| newCHP.setLidDefault ((short) sprm.getOperand()); |
| break; |
| case 0x6e: |
| newCHP.setLidFE ((short) sprm.getOperand()); |
| break; |
| case 0x6f: |
| newCHP.setIdctHint ((byte) sprm.getOperand()); |
| break; |
| case 0x70: |
| // sprmCCv -- 0x6870 |
| newCHP.setCv( new Colorref( sprm.getOperand() ) ); |
| break; |
| case 0x71: |
| // sprmCShd |
| break; |
| case 0x72: |
| // sprmCBrc |
| break; |
| case 0x73: |
| // sprmCRgLid0 |
| break; |
| case 0x74: |
| // sprmCRgLid1 |
| break; |
| case 0x75: |
| // sprmCFNoProof -- 0x875 |
| /* |
| * "A ToggleOperand value that specifies whether the text is excluded from the proofing analysis. By default, text is not excluded from the proofing analysis." |
| * |
| * Word (.doc) Binary File Format. Copyright (c) 2012 Microsoft |
| * Corporation. Released: October 8, 2012 |
| */ |
| newCHP.setFNoProof(getCHPFlag((byte) sprm.getOperand(), |
| oldCHP.isFNoProof())); |
| break; |
| default: |
| LOG.atDebug().log("Unknown CHP sprm ignored: {}", sprm); |
| break; |
| } |
| } |
| |
| private static boolean getCHPFlag (byte x, boolean oldVal) |
| { |
| /* |
| switch(x) |
| { |
| case 0: |
| return false; |
| case 1: |
| return true; |
| case (byte)0x80: |
| return oldVal; |
| case (byte)0x81: |
| return !oldVal; |
| default: |
| return false; |
| } |
| */ |
| if (x == 0) |
| { |
| return false; |
| } |
| else if (x == 1) |
| { |
| return true; |
| } |
| else if ((x & 0x81) == 0x80) |
| { |
| return oldVal; |
| } |
| else if ((x & 0x81) == 0x81) |
| { |
| return!oldVal; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| } |