private void apppendCellShading(byte[] sprmArg, int cellIndex)
{
//shading descriptor can have 10 bytes (Word 2000) or 2 bytes (Word 97)
int shdLength = 2;
if (sprmArg.Length % 10 == 0)
{
shdLength = 10;
}
byte[] shdBytes = new byte[shdLength];
//multiple cell can be formatted with the same SHD.
//in this case there is only 1 SHD for all cells in the row.
if ((cellIndex * shdLength) >= sprmArg.Length)
{
//use the first SHD
cellIndex = 0;
}
Array.Copy(sprmArg, cellIndex * shdBytes.Length, shdBytes, 0, shdBytes.Length);
ShadingDescriptor shd = new ShadingDescriptor(shdBytes);
appendShading(_tcPr, shd);
}
protected PAPAbstractType()
{
this.field_11_lspd = new LineSpacingDescriptor();
this.field_11_lspd = new LineSpacingDescriptor();
this.field_28_dcs = new DropCapSpecifier();
this.field_32_fWidowControl = true;
this.field_41_lvl = 9;
this.field_61_brcTop = new BorderCode();
this.field_62_brcLeft = new BorderCode();
this.field_63_brcBottom = new BorderCode();
this.field_64_brcRight = new BorderCode();
this.field_65_brcBetween = new BorderCode();
this.field_66_brcBar = new BorderCode();
this.field_67_shd = new ShadingDescriptor();
this.field_68_anld = new byte[0];
this.field_69_phe = new byte[0];
this.field_72_dttmPropRMark = new DateAndTime();
this.field_74_rgdxaTab = new int[0];
this.field_75_rgtbd = new byte[0];
this.field_76_numrm = new byte[0];
this.field_77_ptap = new byte[0];
}
protected void appendShading(XmlElement parent, ShadingDescriptor desc)
{
XmlElement shd = _nodeFactory.CreateElement("w", "shd", OpenXmlNamespaces.WordprocessingML);
//fill color
XmlAttribute fill = _nodeFactory.CreateAttribute("w", "fill", OpenXmlNamespaces.WordprocessingML);
if (desc.cvBack != 0)
{
fill.Value = new RGBColor((int)desc.cvBack, RGBColor.ByteOrder.RedLast).SixDigitHexCode;
}
else
{
fill.Value = desc.icoBack.ToString();
}
shd.Attributes.Append(fill);
//foreground color
XmlAttribute color = _nodeFactory.CreateAttribute("w", "color", OpenXmlNamespaces.WordprocessingML);
if (desc.cvFore != 0)
{
color.Value = new RGBColor((int)desc.cvFore, RGBColor.ByteOrder.RedFirst).SixDigitHexCode;
}
else
{
color.Value = desc.icoFore.ToString();
}
shd.Attributes.Append(color);
//pattern
XmlAttribute val = _nodeFactory.CreateAttribute("w", "val", OpenXmlNamespaces.WordprocessingML);
val.Value = getShadingPattern(desc);
shd.Attributes.Append(val);
parent.AppendChild(shd);
}
private string getShadingPattern(ShadingDescriptor shd)
{
string pattern = "";
switch (shd.ipat)
{
case ShadingDescriptor.ShadingPattern.Automatic:
pattern = "auto";
break;
case ShadingDescriptor.ShadingPattern.Solid:
pattern = "solid";
break;
case ShadingDescriptor.ShadingPattern.Percent_5:
pattern = "pct5";
break;
case ShadingDescriptor.ShadingPattern.Percent_10:
pattern = "pct10";
break;
case ShadingDescriptor.ShadingPattern.Percent_20:
pattern = "pct20";
break;
case ShadingDescriptor.ShadingPattern.Percent_25:
pattern = "pct25";
break;
case ShadingDescriptor.ShadingPattern.Percent_30:
pattern = "pct30";
break;
case ShadingDescriptor.ShadingPattern.Percent_40:
pattern = "pct40";
break;
case ShadingDescriptor.ShadingPattern.Percent_50:
pattern = "pct50";
break;
case ShadingDescriptor.ShadingPattern.Percent_60:
pattern = "pct60";
break;
case ShadingDescriptor.ShadingPattern.Percent_70:
pattern = "pct70";
break;
case ShadingDescriptor.ShadingPattern.Percent_75:
pattern = "pct75";
break;
case ShadingDescriptor.ShadingPattern.Percent_80:
pattern = "pct80";
break;
case ShadingDescriptor.ShadingPattern.Percent_90:
pattern = "pct90";
break;
case ShadingDescriptor.ShadingPattern.DarkHorizontal:
pattern = "thinHorzStripe";
break;
case ShadingDescriptor.ShadingPattern.DarkVertical:
pattern = "thinVertStripe";
break;
case ShadingDescriptor.ShadingPattern.DarkForwardDiagonal:
break;
case ShadingDescriptor.ShadingPattern.DarkBackwardDiagonal:
break;
case ShadingDescriptor.ShadingPattern.DarkCross:
break;
case ShadingDescriptor.ShadingPattern.DarkDiagonalCross:
pattern = "thinDiagCross";
break;
case ShadingDescriptor.ShadingPattern.Horizontal:
pattern = "horzStripe";
break;
case ShadingDescriptor.ShadingPattern.Vertical:
pattern = "vertStripe";
break;
case ShadingDescriptor.ShadingPattern.ForwardDiagonal:
break;
case ShadingDescriptor.ShadingPattern.BackwardDiagonal:
break;
case ShadingDescriptor.ShadingPattern.Cross:
break;
case ShadingDescriptor.ShadingPattern.DiagonalCross:
pattern = "diagCross";
break;
case ShadingDescriptor.ShadingPattern.Percent_2_5:
pattern = "pct5";
break;
case ShadingDescriptor.ShadingPattern.Percent_7_5:
pattern = "pct10";
break;
case ShadingDescriptor.ShadingPattern.Percent_12_5:
pattern = "pct12";
break;
case ShadingDescriptor.ShadingPattern.Percent_15:
pattern = "pct15";
break;
case ShadingDescriptor.ShadingPattern.Percent_17_5:
pattern = "pct15";
break;
case ShadingDescriptor.ShadingPattern.Percent_22_5:
pattern = "pct20";
break;
case ShadingDescriptor.ShadingPattern.Percent_27_5:
pattern = "pct30";
break;
case ShadingDescriptor.ShadingPattern.Percent_32_5:
pattern = "pct35";
break;
case ShadingDescriptor.ShadingPattern.Percent_35:
pattern = "pct35";
break;
case ShadingDescriptor.ShadingPattern.Percent_37_5:
pattern = "pct37";
break;
case ShadingDescriptor.ShadingPattern.Percent_42_5:
pattern = "pct40";
break;
case ShadingDescriptor.ShadingPattern.Percent_45:
pattern = "pct45";
break;
case ShadingDescriptor.ShadingPattern.Percent_47_5:
pattern = "pct45";
break;
case ShadingDescriptor.ShadingPattern.Percent_52_5:
pattern = "pct50";
break;
case ShadingDescriptor.ShadingPattern.Percent_55:
pattern = "pct55";
break;
case ShadingDescriptor.ShadingPattern.Percent_57_5:
pattern = "pct55";
break;
case ShadingDescriptor.ShadingPattern.Percent_62_5:
pattern = "pct62";
break;
case ShadingDescriptor.ShadingPattern.Percent_65:
pattern = "pct65";
break;
case ShadingDescriptor.ShadingPattern.Percent_67_5:
pattern = "pct65";
break;
case ShadingDescriptor.ShadingPattern.Percent_72_5:
pattern = "pct70";
break;
case ShadingDescriptor.ShadingPattern.Percent_77_5:
pattern = "pct75";
break;
case ShadingDescriptor.ShadingPattern.Percent_82_5:
pattern = "pct80";
break;
case ShadingDescriptor.ShadingPattern.Percent_85:
pattern = "pct85";
break;
case ShadingDescriptor.ShadingPattern.Percent_87_5:
pattern = "pct87";
break;
case ShadingDescriptor.ShadingPattern.Percent_92_5:
pattern = "pct90";
break;
case ShadingDescriptor.ShadingPattern.Percent_95:
pattern = "pct95";
break;
case ShadingDescriptor.ShadingPattern.Percent_97_5:
pattern = "pct95";
break;
case ShadingDescriptor.ShadingPattern.Percent_97:
pattern = "pct95";
break;
default:
pattern = "nil";
break;
}
return(pattern);
}
/**
* Set the shd field for the CHP record.
*/
public void SetShd(ShadingDescriptor field_42_shd)
{
this.field_42_shd = field_42_shd;
}
private void convertSprms(List <SinglePropertyModifier> sprms, XmlElement parent)
{
XmlElement shd = _nodeFactory.CreateElement("w", "shd", OpenXmlNamespaces.WordprocessingML);
XmlElement rFonts = _nodeFactory.CreateElement("w", "rFonts", OpenXmlNamespaces.WordprocessingML);
XmlElement color = _nodeFactory.CreateElement("w", "color", OpenXmlNamespaces.WordprocessingML);
XmlAttribute colorVal = _nodeFactory.CreateAttribute("w", "val", OpenXmlNamespaces.WordprocessingML);
XmlElement lang = _nodeFactory.CreateElement("w", "lang", OpenXmlNamespaces.WordprocessingML);
foreach (SinglePropertyModifier sprm in sprms)
{
switch ((int)sprm.OpCode)
{
//style id
case 0x4A30:
_currentIstd = System.BitConverter.ToUInt16(sprm.Arguments, 0);
appendValueElement(parent, "rStyle", StyleSheetMapping.MakeStyleId(_doc.Styles.Styles[_currentIstd]), true);
break;
//Element flags
case 0x085A:
appendFlagElement(parent, sprm, "rtl", true);
break;
case 0x0835:
appendFlagElement(parent, sprm, "b", true);
break;
case 0x085C:
appendFlagElement(parent, sprm, "bCs", true);
break;
case 0x083B:
appendFlagElement(parent, sprm, "caps", true);;
break;
case 0x0882:
appendFlagElement(parent, sprm, "cs", true);
break;
case 0x2A53:
appendFlagElement(parent, sprm, "dstrike", true);
break;
case 0x0858:
appendFlagElement(parent, sprm, "emboss", true);
break;
case 0x0854:
appendFlagElement(parent, sprm, "imprint", true);
break;
case 0x0836:
appendFlagElement(parent, sprm, "i", true);
break;
case 0x085D:
appendFlagElement(parent, sprm, "iCs", true);
break;
case 0x0875:
appendFlagElement(parent, sprm, "noProof", true);
break;
case 0x0838:
appendFlagElement(parent, sprm, "outline", true);
break;
case 0x0839:
appendFlagElement(parent, sprm, "shadow", true);
break;
case 0x083A:
appendFlagElement(parent, sprm, "smallCaps", true);
break;
case 0x0818:
appendFlagElement(parent, sprm, "specVanish", true);
break;
case 0x0837:
appendFlagElement(parent, sprm, "strike", true);
break;
case 0x083C:
appendFlagElement(parent, sprm, "vanish", true);
break;
case 0x0811:
appendFlagElement(parent, sprm, "webHidden", true);
break;
case 0x2A48:
SuperscriptIndex iss = (SuperscriptIndex)sprm.Arguments[0];
appendValueElement(parent, "vertAlign", iss.ToString(), true);
break;
//language
case 0x486D:
case 0x4873:
//latin
LanguageId langid = new LanguageId(System.BitConverter.ToInt16(sprm.Arguments, 0));
langid.Convert(new LanguageIdMapping(lang, LanguageIdMapping.LanguageType.Default));
break;
case 0x486E:
case 0x4874:
//east asia
langid = new LanguageId(System.BitConverter.ToInt16(sprm.Arguments, 0));
langid.Convert(new LanguageIdMapping(lang, LanguageIdMapping.LanguageType.EastAsian));
break;
case 0x485F:
//bidi
langid = new LanguageId(System.BitConverter.ToInt16(sprm.Arguments, 0));
langid.Convert(new LanguageIdMapping(lang, LanguageIdMapping.LanguageType.Complex));
break;
//borders
case 0x6865:
case 0xCA72:
XmlNode bdr = _nodeFactory.CreateElement("w", "bdr", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(new BorderCode(sprm.Arguments), bdr);
parent.AppendChild(bdr);
break;
//shading
case 0x4866:
case 0xCA71:
ShadingDescriptor desc = new ShadingDescriptor(sprm.Arguments);
appendShading(parent, desc);
break;
//color
case 0x2A42:
case 0x4A60:
colorVal.Value = ((Global.ColorIdentifier)(sprm.Arguments[0])).ToString();
break;
case 0x6870:
//R
colorVal.Value = String.Format("{0:x2}", sprm.Arguments[0]);
//G
colorVal.Value += String.Format("{0:x2}", sprm.Arguments[1]);
//B
colorVal.Value += String.Format("{0:x2}", sprm.Arguments[2]);
break;
//highlightning
case 0x2A0C:
appendValueElement(parent, "highlight", ((Global.ColorIdentifier)sprm.Arguments[0]).ToString(), true);
break;
//spacing
case 0x8840:
appendValueElement(parent, "spacing", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString(), true);
break;
//font size
case 0x4A43:
appendValueElement(parent, "sz", sprm.Arguments[0].ToString(), true);
break;
case 0x484B:
appendValueElement(parent, "kern", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString(), true);
break;
case 0x4A61:
appendValueElement(parent, "szCs", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString(), true);
break;
//font family
case 0x4A4F:
XmlAttribute ascii = _nodeFactory.CreateAttribute("w", "ascii", OpenXmlNamespaces.WordprocessingML);
FontFamilyName ffn = (FontFamilyName)_doc.FontTable.Data[System.BitConverter.ToUInt16(sprm.Arguments, 0)];
ascii.Value = ffn.xszFtn;
rFonts.Attributes.Append(ascii);
break;
case 0x4A50:
XmlAttribute eastAsia = _nodeFactory.CreateAttribute("w", "eastAsia", OpenXmlNamespaces.WordprocessingML);
FontFamilyName ffnAsia = (FontFamilyName)_doc.FontTable.Data[System.BitConverter.ToUInt16(sprm.Arguments, 0)];
eastAsia.Value = ffnAsia.xszFtn;
rFonts.Attributes.Append(eastAsia);
break;
case 0x4A51:
XmlAttribute ansi = _nodeFactory.CreateAttribute("w", "hAnsi", OpenXmlNamespaces.WordprocessingML);
FontFamilyName ffnAnsi = (FontFamilyName)_doc.FontTable.Data[System.BitConverter.ToUInt16(sprm.Arguments, 0)];
ansi.Value = ffnAnsi.xszFtn;
rFonts.Attributes.Append(ansi);
break;
//Underlining
case 0x2A3E:
appendValueElement(parent, "u", lowerFirstChar(((Global.UnderlineCode)sprm.Arguments[0]).ToString()), true);
break;
//char width
case 0x4852:
appendValueElement(parent, "w", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString(), true);
break;
//animation
case 0x2859:
appendValueElement(parent, "effect", ((Global.TextAnimation)sprm.Arguments[0]).ToString(), true);
break;
default:
break;
}
}
//apend lang
if (lang.Attributes.Count > 0)
{
parent.AppendChild(lang);
}
//append fonts
if (rFonts.Attributes.Count > 0)
{
parent.AppendChild(rFonts);
}
//append color
if (colorVal.Value != "")
{
color.Attributes.Append(colorVal);
parent.AppendChild(color);
}
}
public void Apply(ParagraphPropertyExceptions papx)
{
var ind = this._nodeFactory.CreateElement("w", "ind", OpenXmlNamespaces.WordprocessingML);
var numPr = this._nodeFactory.CreateElement("w", "numPr", OpenXmlNamespaces.WordprocessingML);
var pBdr = this._nodeFactory.CreateElement("w", "pBdr", OpenXmlNamespaces.WordprocessingML);
var spacing = this._nodeFactory.CreateElement("w", "spacing", OpenXmlNamespaces.WordprocessingML);
XmlElement jc = null;
//append style id , do not append "Normal" style (istd 0)
var pStyle = this._nodeFactory.CreateElement("w", "pStyle", OpenXmlNamespaces.WordprocessingML);
var styleId = this._nodeFactory.CreateAttribute("w", "val", OpenXmlNamespaces.WordprocessingML);
styleId.Value = StyleSheetMapping.MakeStyleId(this._parentDoc.Styles.Styles[papx.istd]);
pStyle.Attributes.Append(styleId);
this._pPr.AppendChild(pStyle);
//append formatting of paragraph end mark
if (this._paraEndChpx != null)
{
var rPr = this._nodeFactory.CreateElement("w", "rPr", OpenXmlNamespaces.WordprocessingML);
//append properties
this._paraEndChpx.Convert(new CharacterPropertiesMapping(rPr, this._ctx.Doc, new RevisionData(this._paraEndChpx), papx, false));
var rev = new RevisionData(this._paraEndChpx);
//append delete infos
if (rev.Type == RevisionData.RevisionType.Deleted)
{
var del = this._nodeFactory.CreateElement("w", "del", OpenXmlNamespaces.WordprocessingML);
rPr.AppendChild(del);
}
if (rPr.ChildNodes.Count > 0)
{
this._pPr.AppendChild(rPr);
}
}
bool isRightToLeft = false;
foreach (var sprm in papx.grpprl)
{
switch (sprm.OpCode)
{
//rsid for paragraph property enditing (write to parent element)
case SinglePropertyModifier.OperationCode.sprmPRsid:
string rsid = string.Format("{0:x8}", System.BitConverter.ToInt32(sprm.Arguments, 0));
this._ctx.AddRsid(rsid);
this._writer.WriteAttributeString("w", "rsidP", OpenXmlNamespaces.WordprocessingML, rsid);
break;
//attributes
case SinglePropertyModifier.OperationCode.sprmPIpgp:
var divId = this._nodeFactory.CreateAttribute("w", "divId", OpenXmlNamespaces.WordprocessingML);
divId.Value = System.BitConverter.ToUInt32(sprm.Arguments, 0).ToString();
this._pPr.Attributes.Append(divId);
break;
case SinglePropertyModifier.OperationCode.sprmPFAutoSpaceDE:
appendFlagAttribute(this._pPr, sprm, "autoSpaceDE");
break;
case SinglePropertyModifier.OperationCode.sprmPFAutoSpaceDN:
appendFlagAttribute(this._pPr, sprm, "autoSpaceDN");
break;
case SinglePropertyModifier.OperationCode.sprmPFContextualSpacing:
appendFlagAttribute(this._pPr, sprm, "contextualSpacing");
break;
//element flags
case SinglePropertyModifier.OperationCode.sprmPFBiDi:
isRightToLeft = true;
appendFlagElement(this._pPr, sprm, "bidi", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFKeep:
appendFlagElement(this._pPr, sprm, "keepLines", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFKeepFollow:
appendFlagElement(this._pPr, sprm, "keepNext", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFKinsoku:
appendFlagElement(this._pPr, sprm, "kinsoku", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFOverflowPunct:
appendFlagElement(this._pPr, sprm, "overflowPunct", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFPageBreakBefore:
appendFlagElement(this._pPr, sprm, "pageBreakBefore", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFNoAutoHyph:
appendFlagElement(this._pPr, sprm, "su_pPressAutoHyphens", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFNoLineNumb:
appendFlagElement(this._pPr, sprm, "su_pPressLineNumbers", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFNoAllowOverlap:
appendFlagElement(this._pPr, sprm, "su_pPressOverlap", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFTopLinePunct:
appendFlagElement(this._pPr, sprm, "topLinePunct", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFWidowControl:
appendFlagElement(this._pPr, sprm, "widowControl", true);
break;
case SinglePropertyModifier.OperationCode.sprmPFWordWrap:
appendFlagElement(this._pPr, sprm, "wordWrap", true);
break;
//indentation
case SinglePropertyModifier.OperationCode.sprmPDxaLeft:
case SinglePropertyModifier.OperationCode.sprmPDxaLeft80:
case SinglePropertyModifier.OperationCode.sprmPNest:
case SinglePropertyModifier.OperationCode.sprmPNest80:
appendValueAttribute(ind, "left", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDxcLeft:
appendValueAttribute(ind, "leftChars", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDxaLeft1:
case SinglePropertyModifier.OperationCode.sprmPDxaLeft180:
short flValue = System.BitConverter.ToInt16(sprm.Arguments, 0);
string flName;
if (flValue >= 0)
{
flName = "firstLine";
}
else
{
flName = "hanging";
flValue *= -1;
}
appendValueAttribute(ind, flName, flValue.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDxcLeft1:
appendValueAttribute(ind, "firstLineChars", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDxaRight:
case SinglePropertyModifier.OperationCode.sprmPDxaRight80:
appendValueAttribute(ind, "right", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDxcRight:
appendValueAttribute(ind, "rightChars", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString());
break;
//spacing
case SinglePropertyModifier.OperationCode.sprmPDyaBefore:
var before = this._nodeFactory.CreateAttribute("w", "before", OpenXmlNamespaces.WordprocessingML);
before.Value = System.BitConverter.ToUInt16(sprm.Arguments, 0).ToString();
spacing.Attributes.Append(before);
break;
case SinglePropertyModifier.OperationCode.sprmPDyaAfter:
var after = this._nodeFactory.CreateAttribute("w", "after", OpenXmlNamespaces.WordprocessingML);
after.Value = System.BitConverter.ToUInt16(sprm.Arguments, 0).ToString();
spacing.Attributes.Append(after);
break;
case SinglePropertyModifier.OperationCode.sprmPFDyaAfterAuto:
var afterAutospacing = this._nodeFactory.CreateAttribute("w", "afterAutospacing", OpenXmlNamespaces.WordprocessingML);
afterAutospacing.Value = sprm.Arguments[0].ToString();
spacing.Attributes.Append(afterAutospacing);
break;
case SinglePropertyModifier.OperationCode.sprmPFDyaBeforeAuto:
var beforeAutospacing = this._nodeFactory.CreateAttribute("w", "beforeAutospacing", OpenXmlNamespaces.WordprocessingML);
beforeAutospacing.Value = sprm.Arguments[0].ToString();
spacing.Attributes.Append(beforeAutospacing);
break;
case SinglePropertyModifier.OperationCode.sprmPDyaLine:
var lspd = new LineSpacingDescriptor(sprm.Arguments);
var line = this._nodeFactory.CreateAttribute("w", "line", OpenXmlNamespaces.WordprocessingML);
line.Value = Math.Abs(lspd.dyaLine).ToString();
spacing.Attributes.Append(line);
var lineRule = this._nodeFactory.CreateAttribute("w", "lineRule", OpenXmlNamespaces.WordprocessingML);
if (!lspd.fMultLinespace && lspd.dyaLine < 0)
{
lineRule.Value = "exact";
}
else if (!lspd.fMultLinespace && lspd.dyaLine > 0)
{
lineRule.Value = "atLeast";
}
//no line rule means auto
spacing.Attributes.Append(lineRule);
break;
//justification code
case SinglePropertyModifier.OperationCode.sprmPJc:
case SinglePropertyModifier.OperationCode.sprmPJc80:
jc = this._nodeFactory.CreateElement("w", "jc", OpenXmlNamespaces.WordprocessingML);
var jcVal = this._nodeFactory.CreateAttribute("w", "val", OpenXmlNamespaces.WordprocessingML);
jcVal.Value = ((Global.JustificationCode)sprm.Arguments[0]).ToString();
jc.Attributes.Append(jcVal);
break;
//borders
//case 0x461C:
case SinglePropertyModifier.OperationCode.sprmPBrcTop:
//case 0x4424:
case SinglePropertyModifier.OperationCode.sprmPBrcTop80:
var topBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "top", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(new BorderCode(sprm.Arguments), topBorder);
addOrSetBorder(pBdr, topBorder);
break;
//case 0x461D:
case SinglePropertyModifier.OperationCode.sprmPBrcLeft:
//case 0x4425:
case SinglePropertyModifier.OperationCode.sprmPBrcLeft80:
var leftBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "left", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(new BorderCode(sprm.Arguments), leftBorder);
addOrSetBorder(pBdr, leftBorder);
break;
//case 0x461E:
case SinglePropertyModifier.OperationCode.sprmPBrcBottom:
//case 0x4426:
case SinglePropertyModifier.OperationCode.sprmPBrcBottom80:
var bottomBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "bottom", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(new BorderCode(sprm.Arguments), bottomBorder);
addOrSetBorder(pBdr, bottomBorder);
break;
//case 0x461F:
case SinglePropertyModifier.OperationCode.sprmPBrcRight:
//case 0x4427:
case SinglePropertyModifier.OperationCode.sprmPBrcRight80:
var rightBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "right", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(new BorderCode(sprm.Arguments), rightBorder);
addOrSetBorder(pBdr, rightBorder);
break;
//case 0x4620:
case SinglePropertyModifier.OperationCode.sprmPBrcBetween:
//case 0x4428:
case SinglePropertyModifier.OperationCode.sprmPBrcBetween80:
var betweenBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "between", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(new BorderCode(sprm.Arguments), betweenBorder);
addOrSetBorder(pBdr, betweenBorder);
break;
//case 0x4621:
case SinglePropertyModifier.OperationCode.sprmPBrcBar:
//case 0x4629:
case SinglePropertyModifier.OperationCode.sprmPBrcBar80:
var barBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "bar", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(new BorderCode(sprm.Arguments), barBorder);
addOrSetBorder(pBdr, barBorder);
break;
//shading
case SinglePropertyModifier.OperationCode.sprmPShd80:
case SinglePropertyModifier.OperationCode.sprmPShd:
var desc = new ShadingDescriptor(sprm.Arguments);
appendShading(this._pPr, desc);
break;
//numbering
case SinglePropertyModifier.OperationCode.sprmPIlvl:
appendValueElement(numPr, "ilvl", sprm.Arguments[0].ToString(), true);
break;
case SinglePropertyModifier.OperationCode.sprmPIlfo:
ushort val = System.BitConverter.ToUInt16(sprm.Arguments, 0);
appendValueElement(numPr, "numId", val.ToString(), true);
////check if there is a ilvl reference, if not, check the count of LVLs.
////if only one LVL exists in the referenced list, create a hard reference to that LVL
//if (containsLvlReference(papx.grpprl) == false)
//{
// ListFormatOverride lfo = _ctx.Doc.ListFormatOverrideTable[val];
// int index = NumberingMapping.FindIndexbyId(_ctx.Doc.ListTable, lfo.lsid);
// ListData lst = _ctx.Doc.ListTable[index];
// if (lst.rglvl.Length == 1)
// {
// appendValueElement(numPr, "ilvl", "0", true);
// }
//}
break;
//tabs
case SinglePropertyModifier.OperationCode.sprmPChgTabsPapx:
case SinglePropertyModifier.OperationCode.sprmPChgTabs:
var tabs = this._nodeFactory.CreateElement("w", "tabs", OpenXmlNamespaces.WordprocessingML);
int pos = 0;
//read the removed tabs
byte itbdDelMax = sprm.Arguments[pos];
pos++;
for (int i = 0; i < itbdDelMax; i++)
{
var tab = this._nodeFactory.CreateElement("w", "tab", OpenXmlNamespaces.WordprocessingML);
//clear
var tabsVal = this._nodeFactory.CreateAttribute("w", "val", OpenXmlNamespaces.WordprocessingML);
tabsVal.Value = "clear";
tab.Attributes.Append(tabsVal);
//position
var tabsPos = this._nodeFactory.CreateAttribute("w", "pos", OpenXmlNamespaces.WordprocessingML);
tabsPos.Value = System.BitConverter.ToInt16(sprm.Arguments, pos).ToString();
tab.Attributes.Append(tabsPos);
tabs.AppendChild(tab);
//skip the tolerence array in sprm 0xC615
if (sprm.OpCode == SinglePropertyModifier.OperationCode.sprmPChgTabs)
{
pos += 4;
}
else
{
pos += 2;
}
}
//read the added tabs
byte itbdAddMax = sprm.Arguments[pos];
pos++;
for (int i = 0; i < itbdAddMax; i++)
{
var tbd = new TabDescriptor(sprm.Arguments[pos + (itbdAddMax * 2) + i]);
var tab = this._nodeFactory.CreateElement("w", "tab", OpenXmlNamespaces.WordprocessingML);
//justification
var tabsVal = this._nodeFactory.CreateAttribute("w", "val", OpenXmlNamespaces.WordprocessingML);
tabsVal.Value = ((Global.JustificationCode)tbd.jc).ToString();
tab.Attributes.Append(tabsVal);
//tab leader type
var leader = this._nodeFactory.CreateAttribute("w", "leader", OpenXmlNamespaces.WordprocessingML);
leader.Value = ((Global.TabLeader)tbd.tlc).ToString();
tab.Attributes.Append(leader);
//position
var tabsPos = this._nodeFactory.CreateAttribute("w", "pos", OpenXmlNamespaces.WordprocessingML);
tabsPos.Value = System.BitConverter.ToInt16(sprm.Arguments, pos + (i * 2)).ToString();
tab.Attributes.Append(tabsPos);
tabs.AppendChild(tab);
}
this._pPr.AppendChild(tabs);
break;
//frame properties
case SinglePropertyModifier.OperationCode.sprmPPc:
//position code
byte flag = sprm.Arguments[0];
var pcVert = (Global.VerticalPositionCode)((flag & 0x30) >> 4);
var pcHorz = (Global.HorizontalPositionCode)((flag & 0xC0) >> 6);
appendValueAttribute(this._framePr, "hAnchor", pcHorz.ToString());
appendValueAttribute(this._framePr, "vAnchor", pcVert.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPWr:
var wrapping = (Global.TextFrameWrapping)sprm.Arguments[0];
appendValueAttribute(this._framePr, "wrap", wrapping.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDxaAbs:
short frameX = System.BitConverter.ToInt16(sprm.Arguments, 0);
appendValueAttribute(this._framePr, "x", frameX.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDyaAbs:
short frameY = System.BitConverter.ToInt16(sprm.Arguments, 0);
appendValueAttribute(this._framePr, "y", frameY.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPWHeightAbs:
short frameHeight = System.BitConverter.ToInt16(sprm.Arguments, 0);
appendValueAttribute(this._framePr, "h", frameHeight.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDxaWidth:
short frameWidth = System.BitConverter.ToInt16(sprm.Arguments, 0);
appendValueAttribute(this._framePr, "w", frameWidth.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDxaFromText:
short frameSpaceH = System.BitConverter.ToInt16(sprm.Arguments, 0);
appendValueAttribute(this._framePr, "hSpace", frameSpaceH.ToString());
break;
case SinglePropertyModifier.OperationCode.sprmPDyaFromText:
short frameSpaceV = System.BitConverter.ToInt16(sprm.Arguments, 0);
appendValueAttribute(this._framePr, "vSpace", frameSpaceV.ToString());
break;
//outline level
case SinglePropertyModifier.OperationCode.sprmPOutLvl:
appendValueElement(this._pPr, "outlineLvl", sprm.Arguments[0].ToString(), false);
break;
default:
break;
}
}
//append frame properties
if (this._framePr.Attributes.Count > 0)
{
this._pPr.AppendChild(this._framePr);
}
//append section properties
if (this._sepx != null)
{
var sectPr = this._nodeFactory.CreateElement("w", "sectPr", OpenXmlNamespaces.WordprocessingML);
this._sepx.Convert(new SectionPropertiesMapping(sectPr, this._ctx, this._sectionNr));
this._pPr.AppendChild(sectPr);
}
//append indent
if (ind.Attributes.Count > 0)
{
this._pPr.AppendChild(ind);
}
//append spacing
if (spacing.Attributes.Count > 0)
{
this._pPr.AppendChild(spacing);
}
//append justification
if (jc != null)
{
var jcVal = jc.Attributes["val", OpenXmlNamespaces.WordprocessingML];
if ((isRightToLeft || isStyleRightToLeft(papx.istd)) && jcVal.Value == "right")
{
//ignore jc="right" for RTL documents
}
else
{
this._pPr.AppendChild(jc);
}
}
//append numPr
if (numPr.ChildNodes.Count > 0)
{
this._pPr.AppendChild(numPr);
}
//append borders
if (pBdr.ChildNodes.Count > 0)
{
this._pPr.AppendChild(pBdr);
}
//write Properties
if (this._pPr.ChildNodes.Count > 0 || this._pPr.Attributes.Count > 0)
{
this._pPr.WriteTo(this._writer);
}
}
public void Apply(TablePropertyExceptions tapx)
{
var tblBorders = this._nodeFactory.CreateElement("w", "tblBorders", OpenXmlNamespaces.WordprocessingML);
var tblCellMar = this._nodeFactory.CreateElement("w", "tblCellMar", OpenXmlNamespaces.WordprocessingML);
var tblLayout = this._nodeFactory.CreateElement("w", "tblLayout", OpenXmlNamespaces.WordprocessingML);
var tblpPr = this._nodeFactory.CreateElement("w", "tblpPr", OpenXmlNamespaces.WordprocessingML);
var layoutType = this._nodeFactory.CreateAttribute("w", "type", OpenXmlNamespaces.WordprocessingML);
layoutType.Value = "fixed";
short tblIndent = 0;
short gabHalf = 0;
short marginLeft = 0;
short marginRight = 0;
foreach (var 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:
var 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:
var fts = (WidthType)sprm.Arguments[0];
short width = System.BitConverter.ToInt16(sprm.Arguments, 1);
var tblW = this._nodeFactory.CreateElement("w", "tblW", OpenXmlNamespaces.WordprocessingML);
var w = this._nodeFactory.CreateAttribute("w", "w", OpenXmlNamespaces.WordprocessingML);
w.Value = width.ToString();
var type = this._nodeFactory.CreateAttribute("w", "type", OpenXmlNamespaces.WordprocessingML);
type.Value = fts.ToString();
tblW.Attributes.Append(type);
tblW.Attributes.Append(w);
this._tblPr.AppendChild(tblW);
break;
//justification
case SinglePropertyModifier.OperationCode.sprmTJc:
case SinglePropertyModifier.OperationCode.sprmTJcRow:
appendValueElement(this._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:
short styleIndex = System.BitConverter.ToInt16(sprm.Arguments, 0);
if (this._styles.Styles.Count > styleIndex)
{
string id = StyleSheetMapping.MakeStyleId(this._styles.Styles[styleIndex]);
if (id != "TableNormal")
{
appendValueElement(this._tblPr, "tblStyle", id, true);
}
}
break;
//bidi
case SinglePropertyModifier.OperationCode.sprmTFBiDi:
case SinglePropertyModifier.OperationCode.sprmTFBiDi90:
appendValueElement(this._tblPr, "bidiVisual", System.BitConverter.ToInt16(sprm.Arguments, 0).ToString(), true);
break;
//table look
case SinglePropertyModifier.OperationCode.sprmTTlp:
appendValueElement(this._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];
short 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(this._tblPr, "tblStyleRowBandSize", sprm.Arguments[0].ToString(), true);
break;
//col count
case SinglePropertyModifier.OperationCode.sprmTCVertBands:
appendValueElement(this._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(this._tblPr, "tblOverlap", tblOverlapVal, true);
break;
//shading
case SinglePropertyModifier.OperationCode.sprmTSetShdTable:
var desc = new ShadingDescriptor(sprm.Arguments);
appendShading(this._tblPr, desc);
break;
//borders 80 exceptions
case SinglePropertyModifier.OperationCode.sprmTTableBorders80:
var brc80 = new byte[4];
//top border
Array.Copy(sprm.Arguments, 0, brc80, 0, 4);
this.brcTop = new BorderCode(brc80);
//left
Array.Copy(sprm.Arguments, 4, brc80, 0, 4);
this.brcLeft = new BorderCode(brc80);
//bottom
Array.Copy(sprm.Arguments, 8, brc80, 0, 4);
this.brcBottom = new BorderCode(brc80);
//right
Array.Copy(sprm.Arguments, 12, brc80, 0, 4);
this.brcRight = new BorderCode(brc80);
//inside H
Array.Copy(sprm.Arguments, 16, brc80, 0, 4);
this.brcHorz = new BorderCode(brc80);
//inside V
Array.Copy(sprm.Arguments, 20, brc80, 0, 4);
this.brcVert = new BorderCode(brc80);
break;
//border exceptions
case SinglePropertyModifier.OperationCode.sprmTTableBorders:
var brc = new byte[8];
//top border
Array.Copy(sprm.Arguments, 0, brc, 0, 8);
this.brcTop = new BorderCode(brc);
//left
Array.Copy(sprm.Arguments, 8, brc, 0, 8);
this.brcLeft = new BorderCode(brc);
//bottom
Array.Copy(sprm.Arguments, 16, brc, 0, 8);
this.brcBottom = new BorderCode(brc);
//right
Array.Copy(sprm.Arguments, 24, brc, 0, 8);
this.brcRight = new BorderCode(brc);
//inside H
Array.Copy(sprm.Arguments, 32, brc, 0, 8);
this.brcHorz = new BorderCode(brc);
//inside V
Array.Copy(sprm.Arguments, 40, brc, 0, 8);
this.brcVert = new BorderCode(brc);
break;
//floating table properties
case SinglePropertyModifier.OperationCode.sprmTPc:
byte flag = sprm.Arguments[0];
var pcVert = (Global.VerticalPositionCode)((flag & 0x30) >> 4);
var 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)
{
var tblInd = this._nodeFactory.CreateElement("w", "tblInd", OpenXmlNamespaces.WordprocessingML);
var tblIndW = this._nodeFactory.CreateAttribute("w", "w", OpenXmlNamespaces.WordprocessingML);
tblIndW.Value = tblIndent.ToString();
tblInd.Attributes.Append(tblIndW);
var tblIndType = this._nodeFactory.CreateAttribute("w", "type", OpenXmlNamespaces.WordprocessingML);
tblIndType.Value = "dxa";
tblInd.Attributes.Append(tblIndType);
this._tblPr.AppendChild(tblInd);
}
//append floating props
if (tblpPr.Attributes.Count > 0)
{
this._tblPr.AppendChild(tblpPr);
}
//set borders
if (this.brcTop != null)
{
var topBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "top", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(this.brcTop, topBorder);
addOrSetBorder(this._tblBorders, topBorder);
}
if (this.brcLeft != null)
{
var leftBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "left", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(this.brcLeft, leftBorder);
addOrSetBorder(this._tblBorders, leftBorder);
}
if (this.brcBottom != null)
{
var bottomBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "bottom", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(this.brcBottom, bottomBorder);
addOrSetBorder(this._tblBorders, bottomBorder);
}
if (this.brcRight != null)
{
var rightBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "right", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(this.brcRight, rightBorder);
addOrSetBorder(this._tblBorders, rightBorder);
}
if (this.brcHorz != null)
{
var insideHBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "insideH", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(this.brcHorz, insideHBorder);
addOrSetBorder(this._tblBorders, insideHBorder);
}
if (this.brcVert != null)
{
var insideVBorder = this._nodeFactory.CreateNode(XmlNodeType.Element, "w", "insideV", OpenXmlNamespaces.WordprocessingML);
appendBorderAttributes(this.brcVert, insideVBorder);
addOrSetBorder(this._tblBorders, insideVBorder);
}
if (this._tblBorders.ChildNodes.Count > 0)
{
this._tblPr.AppendChild(this._tblBorders);
}
//append layout type
tblLayout.Attributes.Append(layoutType);
this._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);
}
this._tblPr.AppendChild(tblCellMar);
//write Properties
if (this._tblPr.ChildNodes.Count > 0 || this._tblPr.Attributes.Count > 0)
{
this._tblPr.WriteTo(this._writer);
}
//append the grid
this._tblGrid = this._nodeFactory.CreateElement("w", "tblGrid", OpenXmlNamespaces.WordprocessingML);
foreach (short colW in this._grid)
{
var gridCol = this._nodeFactory.CreateElement("w", "gridCol", OpenXmlNamespaces.WordprocessingML);
var gridColW = this._nodeFactory.CreateAttribute("w", "w", OpenXmlNamespaces.WordprocessingML);
gridColW.Value = colW.ToString();
gridCol.Attributes.Append(gridColW);
this._tblGrid.AppendChild(gridCol);
}
this._tblGrid.WriteTo(this._writer);
}
