public static WidthType WidthType(this HtmlNode htmlNode, WidthType defaultValue)
{
if (!htmlNode.ContainsAttributes("width"))
{
return(defaultValue);
}
var attribute = htmlNode.Attributes["width"];
if (string.IsNullOrEmpty(attribute.Value))
{
return(defaultValue);
}
if (attribute.Value.Equals("auto", StringComparison.CurrentCultureIgnoreCase))
{
return(Enums.WidthType.Auto);
}
if (attribute.Value.IsDigitsOnly())
{
return(Enums.WidthType.Fixed);
}
if (attribute.Value.Contains('*'))
{
return(Enums.WidthType.Star);
}
return(defaultValue);
}
internal PreferredWidth method_44()
{
int num = 6;
short num2 = 0;
WidthType auto = WidthType.Auto;
bool flag = false;
while (base.method_19())
{
string str = base.method_1();
if (str != null)
{
if (!(str == BookmarkStart.b("嬫", num)))
{
if (str == BookmarkStart.b("堫圭䀯圱", num))
{
auto = Class417.smethod_32(base.method_3());
}
}
else
{
flag = smethod_0(base.method_3());
num2 = (short)this.method_50(base.method_3());
}
}
}
if ((auto == WidthType.Percentage) && !flag)
{
num2 = (short)(num2 / 50);
}
return(new PreferredWidth(auto, num2));
}
public PreferredWidth(WidthType type, short value)
{
int num = 2;
this.widthType_0 = WidthType.Auto;
switch (type)
{
case WidthType.None:
case WidthType.Auto:
if (value != 0)
{
throw new ArgumentException(string.Format(BookmarkStart.b("缧䈩䤫䀭ု䘱尳匵ᠷ丹䔻丽┿扁ⵃ㕅桇ㅉ籋㍍籏牑⁓㹕㵗穙⩛㽝ᝡţ乥፧孩ᅫ䝭偯άųյ౷婹ṻ᭽ꁿ늁", num), type, value), BookmarkStart.b("帧䬩䀫嬭唯", num));
}
break;
case WidthType.Percentage:
if ((value < 0) || (value > 600))
{
throw new ArgumentException(string.Format(BookmarkStart.b("缧䈩䤫䀭ု䘱尳匵ᠷ丹䔻丽┿扁ⵃ㕅桇ㅉ籋㍍籏牑⁓㹕㵗穙⩛㽝ᝡţ乥፧孩ᅫ䝭偯άųյ౷婹ṻ᭽ꁿꖇﶓﶗ몙ﶛ쒟芡좣쎥\udba7\ud9a9貫\udaad\ud8af펱\udab3\u96b5ힷ좹鲻\udbbd\ub1bf럁ꗃ뻉ꏋ", num), type, value), BookmarkStart.b("帧䬩䀫嬭唯", num));
}
break;
case WidthType.Twip:
if ((value < 0) || (value > 0x7bc0))
{
throw new ArgumentException(string.Format(BookmarkStart.b("缧䈩䤫䀭ု䘱尳匵ᠷ丹䔻丽┿扁ⵃ㕅桇ㅉ籋㍍籏牑⁓㹕㵗穙⩛㽝ᝡţ乥፧孩ᅫ䝭偯άųյ౷婹ṻ᭽ꁿꖇﶓﶗ몙ﶛ쒟芡얣좥첧誩삫쮭쎯솱钳습킷\udbb9\ud2bb麽꾿냁ꏅ맇뿉귋ꋍꛑ믓\ud8df\ud2e1", num), type, value), BookmarkStart.b("帧䬩䀫嬭唯", num));
}
break;
}
this.widthType_0 = type;
this.short_0 = value;
}
private DataTemplate _GetTemplateForWidth(WidthType type)
{
switch (type)
{
case WidthType.XS:
return(_TakeFirstNonNull(ContentTemplateXS, ContentTemplateSM, ContentTemplateMD, ContentTemplateLG, ContentTemplateXL));
case WidthType.SM:
return(_TakeFirstNonNull(ContentTemplateSM, ContentTemplateXS, ContentTemplateMD, ContentTemplateLG, ContentTemplateXL));
case WidthType.MD:
return(_TakeFirstNonNull(ContentTemplateMD, ContentTemplateSM, ContentTemplateXS, ContentTemplateLG, ContentTemplateXL));
case WidthType.LG:
return(_TakeFirstNonNull(ContentTemplateLG, ContentTemplateMD, ContentTemplateSM, ContentTemplateXS, ContentTemplateXL));
case WidthType.XL:
return(_TakeFirstNonNull(ContentTemplateXL, ContentTemplateLG, ContentTemplateMD, ContentTemplateSM, ContentTemplateXS));
}
return(null);
}
/************************
* public methods
*/
public bool Validate(Validator v, OTFontVal fontOwner)
{
bool bRet = true;
if (v.PerformTest(T.PCLT_TableLength))
{
if (GetLength() == 54)
{
v.Pass(T.PCLT_TableLength, P.PCLT_P_TableLength, m_tag);
}
else
{
v.Error(T.PCLT_TableLength, E.PCLT_E_TableLength, m_tag, GetLength().ToString());
bRet = false;
}
}
if (v.PerformTest(T.PCLT_Version))
{
if (Version.GetUint() == 0x00010000)
{
v.Pass(T.PCLT_Version, P.PCLT_P_Version, m_tag);
}
else
{
v.Error(T.PCLT_Version, E.PCLT_E_Version, m_tag, "0x" + Version.GetUint().ToString("x8"));
bRet = false;
}
}
if (v.PerformTest(T.PCLT_Pitch))
{
Table_hmtx hmtxTable = (Table_hmtx)fontOwner.GetTable("hmtx");
Table_maxp maxpTable = (Table_maxp)fontOwner.GetTable("maxp");
if (hmtxTable == null)
{
v.Error(T.PCLT_Pitch, E._TEST_E_TableMissing, m_tag, "hmtx");
bRet = false;
}
else if (maxpTable == null)
{
v.Error(T.PCLT_Pitch, E._TEST_E_TableMissing, m_tag, "maxp");
bRet = false;
}
else
{
uint iSpaceGlyph = fontOwner.FastMapUnicodeToGlyphID(' ');
if (iSpaceGlyph < fontOwner.GetMaxpNumGlyphs())
{
Table_hmtx.longHorMetric hmSpace = hmtxTable.GetOrMakeHMetric(iSpaceGlyph, fontOwner);
if (hmSpace != null)
{
if (Pitch == hmSpace.advanceWidth)
{
v.Pass(T.PCLT_Pitch, P.PCLT_P_Pitch, m_tag);
}
else
{
string s = "actual = " + Pitch + ", expected = " + hmSpace.advanceWidth;
v.Error(T.PCLT_Pitch, E.PCLT_E_Pitch, m_tag, s);
bRet = false;
}
}
}
else
{
// JJF Figure out what to do
v.Warning(T.PCLT_Pitch, W._TEST_W_ErrorInAnotherTable, m_tag, "can't validate Pitch field, error getting the space glyph");
bRet = false;
}
}
}
if (v.PerformTest(T.PCLT_Style))
{
ushort Posture = (ushort)(Style & 0x0003);
ushort Width = (ushort)((Style >> 2) & 0x0007);
ushort Structure = (ushort)((Style >> 5) & 0x001f);
ushort Reserved = (ushort)(Style >> 10);
bool bBitsOk = true;
if (Posture == 3)
{
v.Error(T.PCLT_Style, E.PCLT_E_Style_Posture, m_tag, "0x" + Style.ToString("x4"));
bBitsOk = false;
bRet = false;
}
if (Width == 5)
{
v.Error(T.PCLT_Style, E.PCLT_E_Style_Width, m_tag, "0x" + Style.ToString("x4"));
bBitsOk = false;
bRet = false;
}
if (Structure > 17)
{
v.Error(T.PCLT_Style, E.PCLT_E_Style_Structure, m_tag, "0x" + Style.ToString("x4"));
bBitsOk = false;
bRet = false;
}
if (Reserved != 0)
{
v.Error(T.PCLT_Style, E.PCLT_E_Style_Reserved, m_tag, "0x" + Style.ToString("x4"));
bBitsOk = false;
bRet = false;
}
if (bBitsOk)
{
v.Pass(T.PCLT_Style, P.PCLT_P_Style, m_tag);
}
}
if (v.PerformTest(T.PCLT_StrokeWeight))
{
if (StrokeWeight >= -7 && StrokeWeight <= 7)
{
v.Pass(T.PCLT_StrokeWeight, P.PCLT_P_StrokeWeight, m_tag, StrokeWeight.ToString());
}
else
{
v.Error(T.PCLT_StrokeWeight, E.PCLT_E_StrokeWeight, m_tag, StrokeWeight.ToString());
bRet = false;
}
}
if (v.PerformTest(T.PCLT_WidthType))
{
if (WidthType >= -5 && WidthType <= 5)
{
v.Pass(T.PCLT_WidthType, P.PCLT_P_WidthType, m_tag, WidthType.ToString());
}
else
{
v.Error(T.PCLT_WidthType, E.PCLT_E_WidthType, m_tag, WidthType.ToString());
bRet = false;
}
}
if (v.PerformTest(T.PCLT_SerifStyle))
{
uint bot6 = (uint)SerifStyle & 0x3f;
uint top2 = (uint)SerifStyle >> 6;
bool bBitsOk = true;
if (bot6 > 12)
{
v.Error(T.PCLT_SerifStyle, E.PCLT_E_Bottom6, m_tag, "0x" + SerifStyle.ToString("x2"));
bBitsOk = false;
bRet = false;
}
if (top2 == 0 || top2 == 3)
{
v.Error(T.PCLT_SerifStyle, E.PCLT_E_Top2, m_tag);
bBitsOk = false;
bRet = false;
}
if (bBitsOk)
{
v.Pass(T.PCLT_SerifStyle, P.PCLT_P_SerifStyle, m_tag);
}
}
if (v.PerformTest(T.PCLT_Reserved))
{
if (Reserved == 0)
{
v.Pass(T.PCLT_Reserved, P.PCLT_P_Reserved, m_tag);
}
else
{
v.Error(T.PCLT_Reserved, E.PCLT_E_Reserved, m_tag, Reserved.ToString());
bRet = false;
}
}
return(bRet);
}
public void Apply(TablePropertyExceptions tapx)
{
XmlElement tblBorders = _nodeFactory.CreateElement("w", "tblBorders", OpenXmlNamespaces.WordprocessingML);
XmlElement tblCellMar = _nodeFactory.CreateElement("w", "tblCellMar", OpenXmlNamespaces.WordprocessingML);
XmlElement tblLayout = _nodeFactory.CreateElement("w", "tblLayout", OpenXmlNamespaces.WordprocessingML);
XmlElement tblpPr = _nodeFactory.CreateElement("w", "tblpPr", OpenXmlNamespaces.WordprocessingML);
XmlAttribute layoutType = _nodeFactory.CreateAttribute("w", "type", OpenXmlNamespaces.WordprocessingML);
layoutType.Value = "fixed";
Int16 tblIndent = 0;
Int16 gabHalf = 0;
Int16 marginLeft = 0;
Int16 marginRight = 0;
foreach (SinglePropertyModifier sprm in tapx.grpprl)
{
switch (sprm.OpCode)
{
case SinglePropertyModifier.OperationCode.sprmTDxaGapHalf:
gabHalf = System.BitConverter.ToInt16(sprm.Arguments, 0);
break;
//table definition
case SinglePropertyModifier.OperationCode.sprmTDefTable:
SprmTDefTable tDef = new SprmTDefTable(sprm.Arguments);
//Workaround for retrieving the indent of the table:
//In some files there is a indent but no sprmTWidthIndent is set.
//For this cases we can calculate the indent of the table by getting the
//first boundary of the TDef and adding the padding of the cells
tblIndent = System.BitConverter.ToInt16(sprm.Arguments, 1);
//add the gabHalf
tblIndent += gabHalf;
//If there follows a real sprmTWidthIndent, this value will be overwritten
break;
//preferred table width
case SinglePropertyModifier.OperationCode.sprmTTableWidth:
WidthType fts = (WidthType)sprm.Arguments[0];
Int16 width = System.BitConverter.ToInt16(sprm.Arguments, 1);
XmlElement tblW = _nodeFactory.CreateElement("w", "tblW", OpenXmlNamespaces.WordprocessingML);
XmlAttribute w = _nodeFactory.CreateAttribute("w", "w", OpenXmlNamespaces.WordprocessingML);
w.Value = width.ToString();
XmlAttribute type = _nodeFactory.CreateAttribute("w", "type", OpenXmlNamespaces.WordprocessingML);
type.Value = fts.ToString();
tblW.Attributes.Append(type);
tblW.Attributes.Append(w);
_tblPr.AppendChild(tblW);
break;
//justification
case SinglePropertyModifier.OperationCode.sprmTJc:
case SinglePropertyModifier.OperationCode.sprmTJcRow:
appendValueElement(_tblPr, "jc", ((Global.JustificationCode)sprm.Arguments[0]).ToString(), true);
break;
//indent
case SinglePropertyModifier.OperationCode.sprmTWidthIndent:
tblIndent = System.BitConverter.ToInt16(sprm.Arguments, 1);
break;
//style
case SinglePropertyModifier.OperationCode.sprmTIstd:
case SinglePropertyModifier.OperationCode.sprmTIstdPermute:
Int16 styleIndex = System.BitConverter.ToInt16(sprm.Arguments, 0);
if (_styles.Styles.Count > styleIndex)
{
string id = StyleSheetMapping.MakeStyleId(_styles.Styles[styleIndex]);
if (id != "TableNormal")
{
appendValueElement(_tblPr, "tblStyle", id, true);
}
}
break;
//bidi
case SinglePropertyModifier.OperationCode.sprmTFBiDi:
case SinglePropertyModifier.OperationCode.sprmTFBiDi90:
appendValueElement(_tblPr, "bidiVisual", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString(), true);
break;
//table look
case SinglePropertyModifier.OperationCode.sprmTTlp:
appendValueElement(_tblPr, "tblLook", String.Format("{0:x4}", System.BitConverter.ToInt16(sprm.Arguments, 2)), true);
break;
//autofit
case SinglePropertyModifier.OperationCode.sprmTFAutofit:
if (sprm.Arguments[0] == 1)
{
layoutType.Value = "auto";
}
break;
//default cell padding (margin)
case SinglePropertyModifier.OperationCode.sprmTCellPadding:
case SinglePropertyModifier.OperationCode.sprmTCellPaddingDefault:
case SinglePropertyModifier.OperationCode.sprmTCellPaddingOuter:
byte grfbrc = sprm.Arguments[2];
Int16 wMar = System.BitConverter.ToInt16(sprm.Arguments, 4);
if (Utils.BitmaskToBool((int)grfbrc, 0x01))
{
appendDxaElement(tblCellMar, "top", wMar.ToString(), true);
}
if (Utils.BitmaskToBool((int)grfbrc, 0x02))
{
marginLeft = wMar;
}
if (Utils.BitmaskToBool((int)grfbrc, 0x04))
{
appendDxaElement(tblCellMar, "bottom", wMar.ToString(), true);
}
if (Utils.BitmaskToBool((int)grfbrc, 0x08))
{
marginRight = wMar;
}
break;
//row count
case SinglePropertyModifier.OperationCode.sprmTCHorzBands:
appendValueElement(_tblPr, "tblStyleRowBandSize", sprm.Arguments[0].ToString(), true);
break;
//col count
case SinglePropertyModifier.OperationCode.sprmTCVertBands:
appendValueElement(_tblPr, "tblStyleColBandSize", sprm.Arguments[0].ToString(), true);
break;
//overlap
case SinglePropertyModifier.OperationCode.sprmTFNoAllowOverlap:
bool noOverlap = Utils.ByteToBool(sprm.Arguments[0]);
string tblOverlapVal = "overlap";
if (noOverlap)
{
tblOverlapVal = "never";
}
appendValueElement(_tblPr, "tblOverlap", tblOverlapVal, true);
break;
//shading
case SinglePropertyModifier.OperationCode.sprmTSetShdTable:
ShadingDescriptor desc = new ShadingDescriptor(sprm.Arguments);
appendShading(_tblPr, desc);
break;
//borders 80 exceptions
case SinglePropertyModifier.OperationCode.sprmTTableBorders80:
byte[] brc80 = new byte[4];
//top border
Array.Copy(sprm.Arguments, 0, brc80, 0, 4);
brcTop = new BorderCode(brc80);
//left
Array.Copy(sprm.Arguments, 4, brc80, 0, 4);
brcLeft = new BorderCode(brc80);
//bottom
Array.Copy(sprm.Arguments, 8, brc80, 0, 4);
brcBottom = new BorderCode(brc80);
//right
Array.Copy(sprm.Arguments, 12, brc80, 0, 4);
brcRight = new BorderCode(brc80);
//inside H
Array.Copy(sprm.Arguments, 16, brc80, 0, 4);
brcHorz = new BorderCode(brc80);
//inside V
Array.Copy(sprm.Arguments, 20, brc80, 0, 4);
brcVert = new BorderCode(brc80);
break;
//border exceptions
case SinglePropertyModifier.OperationCode.sprmTTableBorders:
byte[] brc = new byte[8];
//top border
Array.Copy(sprm.Arguments, 0, brc, 0, 8);
brcTop = new BorderCode(brc);
//left
Array.Copy(sprm.Arguments, 8, brc, 0, 8);
brcLeft = new BorderCode(brc);
//bottom
Array.Copy(sprm.Arguments, 16, brc, 0, 8);
brcBottom = new BorderCode(brc);
//right
Array.Copy(sprm.Arguments, 24, brc, 0, 8);
brcRight = new BorderCode(brc);
//inside H
Array.Copy(sprm.Arguments, 32, brc, 0, 8);
brcHorz = new BorderCode(brc);
//inside V
Array.Copy(sprm.Arguments, 40, brc, 0, 8);
brcVert = new BorderCode(brc);
break;
//floating table properties
case SinglePropertyModifier.OperationCode.sprmTPc:
byte flag = sprm.Arguments[0];
Global.VerticalPositionCode pcVert = (Global.VerticalPositionCode)((flag & 0x30) >> 4);
Global.HorizontalPositionCode pcHorz = (Global.HorizontalPositionCode)((flag & 0xC0) >> 6);
appendValueAttribute(tblpPr, "horzAnchor", pcHorz.ToString());
appendValueAttribute(tblpPr, "vertAnchor", pcVert.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmTDxaFromText:
appendValueAttribute(tblpPr, "leftFromText", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmTDxaFromTextRight:
appendValueAttribute(tblpPr, "rightFromText", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmTDyaFromText:
appendValueAttribute(tblpPr, "topFromText", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmTDyaFromTextBottom:
appendValueAttribute(tblpPr, "bottomFromText", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmTDxaAbs:
appendValueAttribute(tblpPr, "tblpX", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmTDyaAbs:
appendValueAttribute(tblpPr, "tblpY", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
}
}
//indent
if (tblIndent != 0)
{
XmlElement tblInd = _nodeFactory.CreateElement("w", "tblInd", OpenXmlNamespaces.WordprocessingML);
XmlAttribute tblIndW = _nodeFactory.CreateAttribute("w", "w", OpenXmlNamespaces.WordprocessingML);
tblIndW.Value = tblIndent.ToString();
tblInd.Attributes.Append(tblIndW);
XmlAttribute tblIndType = _nodeFactory.CreateAttribute("w", "type", OpenXmlNamespaces.WordprocessingML);
tblIndType.Value = "dxa";
tblInd.Attributes.Append(tblIndType);
_tblPr.AppendChild(tblInd);
}
//append floating props
if (tblpPr.Attributes.Count > 0)
{
_tblPr.AppendChild(tblpPr);
}
//set borders
if (brcTop != null)
{
XmlNode topBorder = _nodeFactory.CreateNode(XmlNodeType.Element, "w", "top", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(brcTop, topBorder);
addOrSetBorder(_tblBorders, topBorder);
}
if (brcLeft != null)
{
XmlNode leftBorder = _nodeFactory.CreateNode(XmlNodeType.Element, "w", "left", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(brcLeft, leftBorder);
addOrSetBorder(_tblBorders, leftBorder);
}
if (brcBottom != null)
{
XmlNode bottomBorder = _nodeFactory.CreateNode(XmlNodeType.Element, "w", "bottom", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(brcBottom, bottomBorder);
addOrSetBorder(_tblBorders, bottomBorder);
}
if (brcRight != null)
{
XmlNode rightBorder = _nodeFactory.CreateNode(XmlNodeType.Element, "w", "right", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(brcRight, rightBorder);
addOrSetBorder(_tblBorders, rightBorder);
}
if (brcHorz != null)
{
XmlNode insideHBorder = _nodeFactory.CreateNode(XmlNodeType.Element, "w", "insideH", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(brcHorz, insideHBorder);
addOrSetBorder(_tblBorders, insideHBorder);
}
if (brcVert != null)
{
XmlNode insideVBorder = _nodeFactory.CreateNode(XmlNodeType.Element, "w", "insideV", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(brcVert, insideVBorder);
addOrSetBorder(_tblBorders, insideVBorder);
}
if (_tblBorders.ChildNodes.Count > 0)
{
_tblPr.AppendChild(_tblBorders);
}
//append layout type
tblLayout.Attributes.Append(layoutType);
_tblPr.AppendChild(tblLayout);
//append margins
if (marginLeft == 0 && gabHalf != 0)
{
appendDxaElement(tblCellMar, "left", gabHalf.ToString(), true);
}
else
{
appendDxaElement(tblCellMar, "left", marginLeft.ToString(), true);
}
if (marginRight == 0 && gabHalf != 0)
{
appendDxaElement(tblCellMar, "right", gabHalf.ToString(), true);
}
else
{
appendDxaElement(tblCellMar, "right", marginRight.ToString(), true);
}
_tblPr.AppendChild(tblCellMar);
//write Properties
if (_tblPr.ChildNodes.Count > 0 || _tblPr.Attributes.Count > 0)
{
_tblPr.WriteTo(_writer);
}
//append the grid
_tblGrid = _nodeFactory.CreateElement("w", "tblGrid", OpenXmlNamespaces.WordprocessingML);
foreach (Int16 colW in _grid)
{
XmlElement gridCol = _nodeFactory.CreateElement("w", "gridCol", OpenXmlNamespaces.WordprocessingML);
XmlAttribute gridColW = _nodeFactory.CreateAttribute("w", "w", OpenXmlNamespaces.WordprocessingML);
gridColW.Value = colW.ToString();
gridCol.Attributes.Append(gridColW);
_tblGrid.AppendChild(gridCol);
}
_tblGrid.WriteTo(_writer);
}
public static Rect GetRect(float x, float y, float width, float height, Rect offset, WidthType type)
{
Vector2 finalPos = new Vector2(offset.x + (x * (maxWidth * width)), offset.y + (y * (maxHeight * height)));
x *= maxWidth;
y *= maxHeight;
return(new Rect(finalPos, new Vector2(width, height)));
}
