Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
      Licensed to Plutext Pty Ltd under one or more contributor license agreements.  
      
    *  This file is part of docx4j.
   
       docx4j is licensed 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.docx4j.model.styles;
  
  import java.util.List;
  
  
  import org.docx4j.wml.Jc;
 
 /*
  *  @author Alberto Zerolo
  *  @since 3.0.0
  *  
 */
 public class StyleUtil {
 	
 	public static final String CHARACTER_STYLE = "character";
 	public static final String PARAGRAPH_STYLE = "paragraph";
 	public static final String TABLE_STYLE = "table";
 	public static final String NUMBERING_STYLE = "numbering";
 
 /////////////////////////////////////////////
 // areEqual-Methods
 /////////////////////////////////////////////
 	public static boolean areEqual(Style style1Style style2boolean compareIDs) {
 		if (style1 == style2
 			return true;
 		if (((style1 != null) && (style2 == null)) || ((style1 == null) && (style2 != null)))
 			return false;
 		
 		if ((compareIDs && (!areEqual(style1.getStyleId(), style2.getStyleId()))) ||
 			(!areEqual(style1.getType(), style2.getType()))) {
 			return false;
 		}
 		if (.equals(style1.getType())) {
 			return areEqual(style1.getBasedOn(), style2.getBasedOn()) && 
 			       areEqual(style1.getRPr(), style2.getRPr());
 		}
 		else if (.equals(style1.getType()) || 
 				 .equals(style1.getType())) {
 			return areEqual(style1.getBasedOn(), style2.getBasedOn()) &&
 				   areEqual(style1.getRPr(), style2.getRPr()) &&
 			       areEqual(style1.getPPr(), style2.getPPr());
 		}
 		else if (.equals(style1.getType())) {
 			return areEqual(style1.getBasedOn(), style2.getBasedOn()) &&
 			       areEqual(style1.getTblPr(), style2.getTblPr()) &&
 				   areEqual(style1.getTcPr(), style2.getTcPr()) &&
 				   areEqual(style1.getTblStylePr(), style2.getTblStylePr());
 			
 		}
 		throw new IllegalArgumentException("Invalid style type: " + style1.getType());
 	}
 
 	public static boolean areEqual(PPr pPr1PPr pPr2) {
 		return (pPr1 == pPr2) ||
 			((pPr1 != null) && (pPr2 != null) &&
 			  areEqual((PPrBase)pPr1, (PPrBase)pPr2) &&
 			  areEqual(pPr1.getRPr(), pPr2.getRPr())
 			);
 	}
 
 	public static boolean areEqual(PPrBase pPrBase1PPrBase pPrBase2) {
 		return (pPrBase1 == pPrBase2) ||
 			(   (pPrBase1 != null) && (pPrBase2 != null) &&
 				areEqual(pPrBase1.getPStyle(), pPrBase2.getPStyle()) &&	
 				areEqual(pPrBase1.getKeepNext(), pPrBase2.getKeepNext()) &&	
 				areEqual(pPrBase1.getKeepLines(), pPrBase2.getKeepLines()) &&	
 				areEqual(pPrBase1.getPageBreakBefore(), pPrBase2.getPageBreakBefore()) &&	
 				areEqual(pPrBase1.getFramePr(), pPrBase2.getFramePr()) &&	
 				areEqual(pPrBase1.getWidowControl(), pPrBase2.getWidowControl()) &&	
 				areEqual(pPrBase1.getNumPr(), pPrBase2.getNumPr()) &&	
 				areEqual(pPrBase1.getPBdr(), pPrBase2.getPBdr()) &&	
 				areEqual(pPrBase1.getShd(), pPrBase2.getShd()) &&	
 				areEqual(pPrBase1.getTabs(), pPrBase2.getTabs()) &&	
 				areEqual(pPrBase1.getKinsoku(), pPrBase2.getKinsoku()) &&	
 				areEqual(pPrBase1.getWordWrap(), pPrBase2.getWordWrap()) &&	
 				areEqual(pPrBase1.getOverflowPunct(), pPrBase2.getOverflowPunct()) &&	
 				areEqual(pPrBase1.getTopLinePunct(), pPrBase2.getTopLinePunct()) &&	
 				areEqual(pPrBase1.getAutoSpaceDE(), pPrBase2.getAutoSpaceDE()) &&	
 				areEqual(pPrBase1.getAutoSpaceDN(), pPrBase2.getAutoSpaceDN()) &&	
 				areEqual(pPrBase1.getBidi(), pPrBase2.getBidi()) &&	
 				areEqual(pPrBase1.getAdjustRightInd(), pPrBase2.getAdjustRightInd()) &&	
 				areEqual(pPrBase1.getSnapToGrid(), pPrBase2.getSnapToGrid()) &&	
 				areEqual(pPrBase1.getSpacing(), pPrBase2.getSpacing()) &&	
 				areEqual(pPrBase1.getInd(), pPrBase2.getInd()) &&	
 				areEqual(pPrBase1.getContextualSpacing(), pPrBase2.getContextualSpacing()) &&	
 				areEqual(pPrBase1.getMirrorIndents(), pPrBase2.getMirrorIndents()) &&	
 				areEqual(pPrBase1.getSuppressOverlap(), pPrBase2.getSuppressOverlap()) &&	
 				areEqual(pPrBase1.getJc(), pPrBase2.getJc()) &&	
 				areEqual(pPrBase1.getTextDirection(), pPrBase2.getTextDirection()) &&	
 				areEqual(pPrBase1.getTextAlignment(), pPrBase2.getTextAlignment()) &&	
 				areEqual(pPrBase1.getTextboxTightWrap(), pPrBase2.getTextboxTightWrap()) &&	
 				areEqual(pPrBase1.getOutlineLvl(), pPrBase2.getOutlineLvl()) &&
 				areEqual(pPrBase1.getCnfStyle(), pPrBase2.getCnfStyle())	
 			);
 	}
 
 	public static boolean areEqual(RPr rPr1RPr rPr2) {
 		return ((rPr1 == rPr2) ||
 				((rPr1 != null) && (rPr2 != null) &&
 				 areEqual(rPr1.getRStyle(), rPr2.getRStyle()) &&
 				 areEqual(rPr1.getRFonts(), rPr2.getRFonts()) &&
 				 areEqual(rPr1.getB(), rPr2.getB()) &&
 				 areEqual(rPr1.getBCs(), rPr2.getBCs()) &&
 				 areEqual(rPr1.getI(), rPr2.getI()) &&
 				 areEqual(rPr1.getICs(), rPr2.getICs()) &&
 				 areEqual(rPr1.getCaps(), rPr2.getCaps()) &&
 				 areEqual(rPr1.getSmallCaps(), rPr2.getSmallCaps()) &&
 				 areEqual(rPr1.getStrike(), rPr2.getStrike()) &&
 				 areEqual(rPr1.getDstrike(), rPr2.getDstrike()) &&
 				 areEqual(rPr1.getOutline(), rPr2.getOutline()) &&
 				 areEqual(rPr1.getShadow(), rPr2.getShadow()) &&
 				 areEqual(rPr1.getEmboss(), rPr2.getEmboss()) &&
 				 areEqual(rPr1.getImprint(), rPr2.getImprint()) &&
 				 areEqual(rPr1.getSnapToGrid(), rPr2.getSnapToGrid()) &&
 				 areEqual(rPr1.getVanish(), rPr2.getVanish()) &&
 				 areEqual(rPr1.getColor(), rPr2.getColor()) &&
 			 	 areEqual(rPr1.getSpacing(), rPr2.getSpacing()) &&
 				 areEqual(rPr1.getW(), rPr2.getW()) &&
 				 areEqual(rPr1.getKern(), rPr2.getKern()) &&
 				 areEqual(rPr1.getPosition(), rPr2.getPosition()) &&
 				 areEqual(rPr1.getSz(), rPr2.getSz()) &&
 				 areEqual(rPr1.getSzCs(), rPr2.getSzCs()) &&
 				 areEqual(rPr1.getHighlight(), rPr2.getHighlight()) &&
 				 areEqual(rPr1.getU(), rPr2.getU()) &&
 				 areEqual(rPr1.getEffect(), rPr2.getEffect()) &&
 				 areEqual(rPr1.getBdr(), rPr2.getBdr()) &&
 				 areEqual(rPr1.getShd(), rPr2.getShd()) &&
 				 areEqual(rPr1.getVertAlign(), rPr2.getVertAlign()) &&
 				 areEqual(rPr1.getRtl(), rPr2.getRtl()) &&
 				 areEqual(rPr1.getCs(), rPr2.getCs()) &&
 				 areEqual(rPr1.getEm(), rPr2.getEm()) &&
 				 areEqual(rPr1.getSpecVanish(), rPr2.getSpecVanish()) &&
 				 areEqual(rPr1.getOMath(), rPr2.getOMath())
 				 
 				 // rPr1.getLang()  ??
 				 )
 			    );
 	}
 
 	public static boolean areEqual(ParaRPr rPr1ParaRPr rPr2) {
 		return ((rPr1 == rPr2) ||
 				((rPr1 != null) && (rPr2 != null) &&
 				 areEqual(rPr1.getRStyle(), rPr2.getRStyle()) &&
 				 areEqual(rPr1.getRFonts(), rPr2.getRFonts()) &&
 				 areEqual(rPr1.getB(), rPr2.getB()) &&
 				 areEqual(rPr1.getBCs(), rPr2.getBCs()) &&
 				 areEqual(rPr1.getI(), rPr2.getI()) &&
 				 areEqual(rPr1.getICs(), rPr2.getICs()) &&
 				 areEqual(rPr1.getCaps(), rPr2.getCaps()) &&
 				 areEqual(rPr1.getSmallCaps(), rPr2.getSmallCaps()) &&
 				 areEqual(rPr1.getStrike(), rPr2.getStrike()) &&
 				 areEqual(rPr1.getDstrike(), rPr2.getDstrike()) &&
 				 areEqual(rPr1.getOutline(), rPr2.getOutline()) &&
 				 areEqual(rPr1.getShadow(), rPr2.getShadow()) &&
 				 areEqual(rPr1.getEmboss(), rPr2.getEmboss()) &&
 				 areEqual(rPr1.getImprint(), rPr2.getImprint()) &&
 				 areEqual(rPr1.getSnapToGrid(), rPr2.getSnapToGrid()) &&
 				 areEqual(rPr1.getVanish(), rPr2.getVanish()) &&
 				 areEqual(rPr1.getColor(), rPr2.getColor()) &&
 			 	 areEqual(rPr1.getSpacing(), rPr2.getSpacing()) &&
 				 areEqual(rPr1.getW(), rPr2.getW()) &&
 				 areEqual(rPr1.getKern(), rPr2.getKern()) &&
 				 areEqual(rPr1.getPosition(), rPr2.getPosition()) &&
 				 areEqual(rPr1.getSz(), rPr2.getSz()) &&
 				 areEqual(rPr1.getSzCs(), rPr2.getSzCs()) &&
 				 areEqual(rPr1.getHighlight(), rPr2.getHighlight()) &&
 				 areEqual(rPr1.getU(), rPr2.getU()) &&
 				 areEqual(rPr1.getEffect(), rPr2.getEffect()) &&
 				 areEqual(rPr1.getBdr(), rPr2.getBdr()) &&
 				 areEqual(rPr1.getShd(), rPr2.getShd()) &&
 				 areEqual(rPr1.getVertAlign(), rPr2.getVertAlign()) &&
 				 areEqual(rPr1.getRtl(), rPr2.getRtl()) &&
 				 areEqual(rPr1.getCs(), rPr2.getCs()) &&
 				 areEqual(rPr1.getEm(), rPr2.getEm()) &&
 				 areEqual(rPr1.getSpecVanish(), rPr2.getSpecVanish()) &&
 				 areEqual(rPr1.getOMath(), rPr2.getOMath())
 				 )
 			    );
 	}
 
 	public static boolean areEqual(CTTblPrBase tblPr1CTTblPrBase tblPr2) {
 		return ((tblPr1 == tblPr2) ||
 				((tblPr1 != null) && (tblPr2 != null) &&
 				 areEqual(tblPr1.getTblStyle(), tblPr2.getTblStyle()) &&
 				 areEqual(tblPr1.getTblpPr(), tblPr2.getTblpPr()) &&
 				 areEqual(tblPr1.getTblOverlap(), tblPr2.getTblOverlap()) &&
 				 areEqual(tblPr1.getTblW(), tblPr2.getTblW()) &&
 				 areEqual(tblPr1.getJc(), tblPr2.getJc()) &&
 				 areEqual(tblPr1.getTblCellSpacing(), tblPr2.getTblCellSpacing()) &&
 				 areEqual(tblPr1.getTblInd(), tblPr2.getTblInd()) &&
 				 areEqual(tblPr1.getTblBorders(), tblPr2.getTblBorders()) &&
 				 areEqual(tblPr1.getShd(), tblPr2.getShd()) &&
 				 areEqual(tblPr1.getTblLayout(), tblPr2.getTblLayout()) &&
 				 areEqual(tblPr1.getTblCellMar(), tblPr2.getTblCellMar()) &&
 				 areEqual(tblPr1.getTblLook(), tblPr2.getTblLook())
 				)
 			   );
 	}
 
 	public static boolean areEqual(CTTblLook tblLook1CTTblLook tblLook2) {
 		return ((tblLook1 == tblLook2) || 
 				((tblLook1 !=null) && (tblLook2 !=null) &&
 						areEqual(tblLook1.getVal(), tblLook2.getVal()) &&
 						areEqual(tblLook1.getFirstColumn(), tblLook2.getFirstColumn()) &&
 						areEqual(tblLook1.getFirstRow(), tblLook2.getFirstRow()) &&
 						areEqual(tblLook1.getLastColumn(), tblLook2.getLastColumn()) &&
 						areEqual(tblLook1.getLastRow(), tblLook2.getLastRow()) &&
 						areEqual(tblLook1.getNoHBand(), tblLook2.getNoHBand()) &&
 						areEqual(tblLook1.getNoVBand(), tblLook2.getNoVBand())
 						)
 						);
 	}
 						
 	
 	private static boolean areEqual(STOnOff oo1STOnOff oo2) {
 		return (oo1 == oo2);
 	}
 
 	public static boolean areEqual(TcPr tcPr1TcPr tcPr2) {
 		return ((tcPr1 == tcPr2) ||
 				((tcPr1 != null) && (tcPr2 != null) &&
 				 areEqual(tcPr1.getCnfStyle(), tcPr2.getCnfStyle()) &&
 				 areEqual(tcPr1.getTcW(), tcPr2.getTcW()) &&
 				 areEqual(tcPr1.getGridSpan(), tcPr2.getGridSpan()) &&
 				 areEqual(tcPr1.getHMerge(), tcPr2.getHMerge()) &&
 				 areEqual(tcPr1.getVMerge(), tcPr2.getVMerge()) &&
 				 areEqual(tcPr1.getTcBorders(), tcPr2.getTcBorders()) &&
 				 areEqual(tcPr1.getShd(), tcPr2.getShd()) &&
 				 areEqual(tcPr1.getNoWrap(), tcPr2.getNoWrap()) &&
 				 areEqual(tcPr1.getTcMar(), tcPr2.getTcMar()) &&
 				 areEqual(tcPr1.getTextDirection(), tcPr2.getTextDirection()) &&
 				 areEqual(tcPr1.getTcFitText(), tcPr2.getTcFitText()) &&
 				 areEqual(tcPr1.getVAlign(), tcPr2.getVAlign()) &&
 				 areEqual(tcPr1.getHideMark(), tcPr2.getHideMark())
 				)
 			   );
 	}
 
 	public static boolean areEqual(List<CTTblStylePrtblStylePrList1List<CTTblStylePrtblStylePrList2) {
 		if (tblStylePrList1 == tblStylePrList2)
 			return true;
 		if (((tblStylePrList1 == null) && (tblStylePrList2 != null)) || ((tblStylePrList1 != null) && (tblStylePrList2 == null)))
 			return false;
 		if (tblStylePrList1.size() != tblStylePrList2.size())
 			return false;
 		
 		for (int i=0; i<tblStylePrList1.size(); i++)
 			if (!areEqual(tblStylePrList1.get(i), tblStylePrList2.get(i)))
 				return false;
 		return true;
 	}
 
 	public static boolean areEqual(CTTblStylePr ctTblStylePr1CTTblStylePr ctTblStylePr2) {
 		return ((ctTblStylePr1 == ctTblStylePr2) ||
 				((ctTblStylePr1 != null) && (ctTblStylePr2 != null) &&
 				 areEqual(ctTblStylePr1.getPPr(), ctTblStylePr2.getPPr()) &&
 				 areEqual(ctTblStylePr1.getRPr(), ctTblStylePr2.getRPr()) &&
 				 areEqual(ctTblStylePr1.getTblPr(), ctTblStylePr2.getTblPr()) &&
 				 areEqual(ctTblStylePr1.getTrPr(), ctTblStylePr2.getTrPr()) &&
 				 areEqual(ctTblStylePr1.getType(), ctTblStylePr2.getType())
 			)
 		   );
 	}
 
 	public static boolean areEqual(OutlineLvl outlineLvl1OutlineLvl outlineLvl2) {
 		return (outlineLvl1 == outlineLvl2) ||
 		       ((outlineLvl1 != null) && (outlineLvl2 != null) &&
 		        areEqual(outlineLvl1.getVal(), outlineLvl2.getVal()));
 	}
 
 	public static boolean areEqual(CTTextboxTightWrap textboxTightWrap1CTTextboxTightWrap textboxTightWrap2) {
 		return (textboxTightWrap1 == textboxTightWrap2) ||
 	       ((textboxTightWrap1 != null) && (textboxTightWrap2 != null) &&
 	    	((textboxTightWrap1.getVal() == textboxTightWrap2.getVal()) ||
 	    	 ((textboxTightWrap1.getVal() != null) &&
 	    	   (textboxTightWrap1.getVal().equals(textboxTightWrap2.getVal()))
 	    	 ) 		
 	    	)
 	       );
 	}
 
 	public static boolean areEqual(TextAlignment textAlignment1TextAlignment textAlignment2) {
 		return (textAlignment1 == textAlignment2) ||
 	       ((textAlignment1 != null) && (textAlignment2 != null) &&
 	    	((textAlignment1.getVal() == textAlignment2.getVal()) ||
 	    	 ((textAlignment1.getVal() != null) &&
 	    	   (textAlignment1.getVal().equals(textAlignment2.getVal()))
 	    	 ) 		
 	    	)
 	       );
 	}
 
 	public static boolean areEqual(TextDirection textDirection1TextDirection textDirection2) {
 		return (textDirection1 == textDirection2) ||
 	       ((textDirection1 != null) && (textDirection2 != null) &&
 	        areEqual(textDirection1.getVal(), textDirection2.getVal()));
 	}
 
 	public static boolean areEqual(Jc jc1Jc jc2) {
 		return (jc1 == jc2) ||
 	       ((jc1 != null) && (jc2 != null) &&
 	    	((jc1.getVal() == jc2.getVal()) ||
 	    	 ((jc1.getVal() != null) &&
 	    	   (jc1.getVal().equals(jc2.getVal()))
 	    	 ) 		
 	    	)
 	       );
 	}
 
 	public static boolean areEqual(Ind ind1Ind ind2) {
 		return ((ind1 == ind2) ||
 			((ind1 != null) && (ind2 != null) &&
 			 areEqual(ind1.getFirstLine(), ind2.getFirstLine()) &&
 			 areEqual(ind1.getHanging(), ind2.getHanging()) &&
 			 areEqual(ind1.getHangingChars(), ind2.getHangingChars()) &&
 			 areEqual(ind1.getLeft(), ind2.getLeft()) &&
 			 areEqual(ind1.getLeftChars(), ind2.getLeftChars()) &&
 			 areEqual(ind1.getRight(), ind2.getRight()) &&
 			)
 		);
 	}
 
 	public static boolean areEqual(Spacing spacing1Spacing spacing2) {
 		return ((spacing1 == spacing2) ||
 				((spacing1 != null) && (spacing2 != null) &&
 				 areEqual(spacing1.getAfter(), spacing2.getAfter()) &&
 				 areEqual(spacing1.getAfterLines(), spacing2.getAfterLines()) &&
 				 areEqual(spacing1.getBefore(), spacing2.getBefore()) &&
 				 areEqual(spacing1.getBeforeLines(), spacing2.getBeforeLines()) &&
 				 areEqual(spacing1.getLine(), spacing2.getLine()) &&
 				 ((spacing1.getLineRule() == spacing2.getLineRule()) ||
 				  ((spacing1.getLineRule() != null) && 
 				   (spacing1.getLineRule().equals(spacing2.getLineRule()))))
 				 )
 				);
 	}
 
 	public static boolean areEqual(Tabs tabs1Tabs tabs2) {
 		if (tabs1 == tabs2)
 			return true;
 		if (((tabs1 != null) && (tabs2 == null)) || ((tabs1 == null) && (tabs2 != null)))
 			return false;
 		if (tabs1.getTab() == tabs2.getTab())
 			return true;
 		if (tabs1.getTab().size() != tabs2.getTab().size())
 			return false;
 		for (int i=0; i<tabs1.getTab().size(); i++)
 			if (!areEqual(tabs1.getTab().get(i), tabs2.getTab().get(i)))
 				return false;
 		return true;
 	}
 
 	public static boolean areEqual(CTTabStop ctTabStop1CTTabStop ctTabStop2) {
 		return ((ctTabStop1 == ctTabStop2) ||
 				((ctTabStop1 != null) && (ctTabStop2 != null) &&
 				  areEqual(ctTabStop1.getPos(), ctTabStop2.getPos()) &&
 						
 				 ((ctTabStop1.getVal() == ctTabStop2.getVal()) ||
 				  ((ctTabStop1.getVal() != null) && 
 				   (ctTabStop1.getVal().equals(ctTabStop2.getVal())))) &&
 				   
 				 ((ctTabStop1.getLeader() == ctTabStop2.getLeader()) ||
 				  ((ctTabStop1.getLeader() != null) && 
 				   (ctTabStop1.getLeader().equals(ctTabStop2.getLeader()))))
 				 )
 			   );
 	}
 
 	public static boolean areEqual(CTShd shd1CTShd shd2) {
 		return ((shd1 == shd2) ||
 				((shd1 != null) && (shd2 != null) &&
 				 areEqual(shd1.getColor(), shd2.getColor()) &&
 				 areEqual(shd1.getThemeTint(), shd2.getThemeTint()) &&
 				 areEqual(shd1.getThemeShade(), shd2.getThemeShade()) &&
 				 areEqual(shd1.getFill(), shd2.getFill()) &&
 				 areEqual(shd1.getThemeColor(), shd2.getThemeColor()) &&
 				 areEqual(shd1.getThemeFill(), shd2.getThemeFill()) &&
 						
 				 ((shd1.getVal() == shd2.getVal()) ||
 				  ((shd1.getVal() != null) && 
 				   (shd1.getVal().equals(shd2.getVal()))))
 				 )
 			   );
 	}
 
 	public static boolean areEqual(PBdr pBdr1PBdr pBdr2) {
 		return ((pBdr1 == pBdr2) ||
 				((pBdr1 != null) && (pBdr2 != null) &&
 				 areEqual(pBdr1.getTop(), pBdr2.getTop()) && 
 				 areEqual(pBdr1.getLeft(), pBdr2.getLeft()) &&
 				 areEqual(pBdr1.getBottom(), pBdr2.getBottom()) &&
 				 areEqual(pBdr1.getRight(), pBdr2.getRight()) &&
 				 areEqual(pBdr1.getBetween(), pBdr2.getBetween()) &&
 				 areEqual(pBdr1.getBar(), pBdr2.getBar())
 				)
 			   );
 	}
 
 	public static boolean areEqual(CTBorder border1CTBorder border2) {
 		return ((border1 == border2) ||
 				((border1 != null) && (border2 != null) &&
 				 areEqual(border1.getColor(), border2.getColor()) &&
 				 areEqual(border1.getSpace(), border2.getSpace()) && 
 				 areEqual(border1.getSz(), border2.getSz()) && 
 				 areEqual(border1.getThemeColor(), border2.getThemeColor()) && 
 				 areEqual(border1.getThemeShade(), border2.getThemeShade()) && 
 				 areEqual(border1.getThemeTint(), border2.getThemeTint()) &&
 				 
 				 ((border1.getVal() == border2.getVal()) ||
 						  ((border1.getVal() != null) && 
 						   (border1.getVal().equals(border2.getVal()))))
 				 
 				)
 			   );
 	}
 
 	public static boolean areEqual(NumPr numPr1NumPr numPr2) {
 		// Comparing the numbering format would require looking into the 
 		// numbering definitions part, for this reason only the id is 
 		// checked
 		return ((numPr1 == numPr2) ||
 				((numPr1 != null) && (numPr2 != null) &&
 				 ((numPr1.getNumId() == numPr2.getNumId()) ||
 				  ((numPr1.getNumId() != null) && (numPr2.getNumId() != null) &&
 				  areEqual(numPr1.getNumId().getVal(), numPr2.getNumId().getVal()))
 				 )
 				)
 			   );
 	}
 
 	public static boolean areEqual(CTFramePr framePr1CTFramePr framePr2) {
 		return ((framePr1 == framePr2) ||
 				((framePr1 != null) && (framePr2 != null) &&
 				 areEqual(framePr1.getDropCap(), framePr2.getDropCap()) &&
 				 areEqual(framePr1.getLines(), framePr2.getLines()) &&
 				 areEqual(framePr1.getW(), framePr2.getW()) &&
 				 areEqual(framePr1.getH(), framePr2.getH()) &&
 				 areEqual(framePr1.getVSpace(), framePr2.getVSpace()) && 
 				 areEqual(framePr1.getHSpace(), framePr2.getHSpace()) &&
 				 areEqual(framePr1.getWrap(), framePr2.getWrap()) &&
 				 areEqual(framePr1.getHAnchor(), framePr2.getHAnchor()) &&
 				 areEqual(framePr1.getVAnchor(), framePr2.getVAnchor()) &&
 				 areEqual(framePr1.getX(), framePr2.getX()) &&
 				 areEqual(framePr1.getXAlign(), framePr2.getXAlign()) && 
 				 areEqual(framePr1.getY(), framePr2.getY()) &&
 				 areEqual(framePr1.getYAlign(), framePr2.getYAlign()) &&
 				 areEqual(framePr1.getHRule(), framePr2.getHRule()) &&
 				 (framePr1.isAnchorLock() == framePr2.isAnchorLock())
 				 )
 			    );
 	}
 
 	public static boolean areEqual(CTCnf cnfStyle1CTCnf cnfStyle2) {
 		return (cnfStyle1 == cnfStyle2) ||
 			   ((cnfStyle1 != null) && (cnfStyle2 != null) &&
 		       areEqual(cnfStyle1.getVal(), cnfStyle2.getVal())
 		       );
 	}
 
 	public static boolean areEqual(STHeightRule hRule1STHeightRule hRule2) {
 		return (hRule1 == hRule2) ||
 		   ((hRule1 != null) && 
 		    (hRule1.equals(hRule2)));
 	}
 
 	public static boolean areEqual(STYAlign yAlign1STYAlign yAlign2) {
 		return (yAlign1 == yAlign2) ||
 		   ((yAlign1 != null) && 
 		    (yAlign1.equals(yAlign2)));
 	}
 
 	public static boolean areEqual(STXAlign xAlign1STXAlign xAlign2) {
 		return (xAlign1 == xAlign2) ||
 		   ((xAlign1 != null) && 
 		    (xAlign1.equals(xAlign2)));
 	}
 
 	public static boolean areEqual(STVAnchor vAnchor1STVAnchor vAnchor2) {
 		return (vAnchor1 == vAnchor2) ||
 		   ((vAnchor1 != null) && 
 		    (vAnchor1.equals(vAnchor2)));
 	}
 
 	public static boolean areEqual(STHAnchor hAnchor1STHAnchor hAnchor2) {
 		return (hAnchor1 == hAnchor2) ||
 		   ((hAnchor1 != null) && 
 		    (hAnchor1.equals(hAnchor2)));
 	}
 
 	public static boolean areEqual(STWrap wrap1STWrap wrap2) {
 		return (wrap1 == wrap2) ||
 		   ((wrap1 != null) && 
 		    (wrap1.equals(wrap2)));
 	}
 
 	public static boolean areEqual(STDropCap dropCap1STDropCap dropCap2) {
 		return (dropCap1 == dropCap2) ||
 		   ((dropCap1 != null) && 
 		    (dropCap1.equals(dropCap2)));
 	}
 
 	public static boolean areEqual(PStyle pStyle1PStyle pStyle2) {
 		return (pStyle1 == pStyle2) ||
 	       ((pStyle1 != null) && (pStyle2 != null) &&
 	        areEqual(pStyle1.getVal(), pStyle2.getVal()));
 	}
 
 	public static boolean areEqual(BasedOn basedOn1BasedOn basedOn2) {
 		return (basedOn1 == basedOn2) ||
 	       ((basedOn1 != null) && (basedOn2 != null) &&
 	        areEqual(basedOn1.getVal(), basedOn2.getVal()));
 	}
 
 	public static boolean areEqual(RFonts rFonts1RFonts rFonts2) {
 		//Comparing the ascii version should be enough in most cases 
 		return (rFonts1 == rFonts2) ||
 		       ((rFonts1 != null) && (rFonts2 != null) &&
 			   (areEqual(rFonts1.getAscii(), rFonts2.getAscii()))
 			    );
 	}
 
 	public static boolean areEqual(RStyle rStyle1RStyle rStyle2) {
 		return (rStyle1 == rStyle2) ||
 	       ((rStyle1 != null) && (rStyle2 != null) &&
 		   (areEqual(rStyle1.getVal(), rStyle2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(CTEm em1CTEm em2) {
 		return (em1 == em2) ||
 	       ((em1 != null) && (em2 != null) &&
 		   (areEqual(em1.getVal(), em2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(CTVerticalAlignRun vertAlign1CTVerticalAlignRun vertAlign2) {
 		return (vertAlign1 == vertAlign2) ||
 	       ((vertAlign1 != null) && (vertAlign2 != null) &&
 		   (areEqual(vertAlign1.getVal(), vertAlign2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(CTTextEffect effect1CTTextEffect effect2) {
 		return (effect1 == effect2) ||
 	       ((effect1 != null) && (effect2 != null) &&
 		   (areEqual(effect1.getVal(), effect2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(U u1U u2) {
 		return (u1 == u2) ||
 	       ((u1 != null) && (u2 != null) &&
 		    areEqual(u1.getVal(), u2.getVal()) &&
 		    areEqual(u1.getColor(), u2.getColor())
 		    );
 	}
 
 	public static boolean areEqual(Highlight highlight1Highlight highlight2) {
 		return (highlight1 == highlight2) ||
 	       ((highlight1 != null) && (highlight2 != null) &&
 		   (areEqual(highlight1.getVal(), highlight2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(CTSignedHpsMeasure measure1CTSignedHpsMeasure measure2) {
 		return (measure1 == measure2) ||
 	       ((measure1 != null) && (measure2 != null) &&
 		   (areEqual(measure1.getVal(), measure2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(HpsMeasure measure1HpsMeasure measure2) {
 		return (measure1 == measure2) ||
 	       ((measure1 != null) && (measure2 != null) &&
 		   (areEqual(measure1.getVal(), measure2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(CTTextScale scale1CTTextScale scale2) {
 		return (scale1 == scale2) ||
 	       ((scale1 != null) && (scale2 != null) &&
 		   (areEqual(scale1.getVal(), scale2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(CTSignedTwipsMeasure measure1CTSignedTwipsMeasure measure2) {
 		return (measure1 == measure2) ||
 	       ((measure1 != null) && (measure2 != null) &&
 		   (areEqual(measure1.getVal(), measure2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(Color color1Color color2) {
 		return (color1 == color2) ||
 	       ((color1 != null) && (color2 != null) &&
 		   (areEqual(color1.getVal(), color2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(CTTblLayoutType tblLayout1CTTblLayoutType tblLayout2) {
 		return (tblLayout1 == tblLayout2) ||
 	       ((tblLayout1 != null) && (tblLayout2 != null) &&
 		   (areEqual(tblLayout1.getType(), tblLayout2.getType()))
 		    );
 	}
 
 	public static boolean areEqual(CTTblCellMar margin1CTTblCellMar margin2) {
 		return (margin1 == margin2) ||
 	       ((margin1 != null) && (margin2 != null) &&
 		    areEqual(margin1.getBottom(), margin2.getBottom()) &&
 		    areEqual(margin1.getLeft(), margin2.getLeft()) &&
 		    areEqual(margin1.getRight(), margin2.getRight()) &&
 		    areEqual(margin1.getTop(), margin2.getTop())
 		    );
 	}
 
 	public static boolean areEqual(TblBorders borders1TblBorders borders2) {
 		return (borders1 == borders2) ||
 	       ((borders1 != null) && (borders2 != null) &&
 		    areEqual(borders1.getBottom(), borders2.getBottom()) &&
 		    areEqual(borders1.getLeft(), borders2.getLeft()) &&
 		    areEqual(borders1.getRight(), borders2.getRight()) &&
 		    areEqual(borders1.getTop(), borders2.getTop()) &&
 		    areEqual(borders1.getInsideH(), borders2.getInsideH()) &&
 		    areEqual(borders1.getInsideV(), borders2.getInsideV())
 		    );
 	}
 
 	public static boolean areEqual(TblStyleColBandSize bandSize1TblStyleColBandSize bandSize2) {
 		return (bandSize1 == bandSize2) ||
 	       ((bandSize1 != null) && (bandSize2 != null) &&
 		    areEqual(bandSize1.getVal(), bandSize2.getVal())
 		    );
 	}
 
 	public static boolean areEqual(TblStyleRowBandSize bandSize1TblStyleRowBandSize bandSize2) {
 		return (bandSize1 == bandSize2) ||
 	       ((bandSize1 != null) && (bandSize2 != null) &&
 		    areEqual(bandSize1.getVal(), bandSize2.getVal())
 		    );
 	}
 
 	public static boolean areEqual(CTTblOverlap overlap1CTTblOverlap overlap2) {
 		return (overlap1 == overlap2) ||
 	       ((overlap1 != null) && (overlap2 != null) &&
 		    areEqual(overlap1.getVal(), overlap2.getVal())
 		    );
 	}
 
 	public static boolean areEqual(CTTblPPr tblpPr1CTTblPPr tblpPr2) {
 		return (tblpPr1 == tblpPr2) ||
 	       ((tblpPr1 != null) && (tblpPr2 != null) &&
 			areEqual(tblpPr1.getLeftFromText(), tblpPr2.getLeftFromText()) &&
 			areEqual(tblpPr1.getRightFromText(), tblpPr2.getRightFromText()) &&
 			areEqual(tblpPr1.getTopFromText(), tblpPr2.getTopFromText()) &&
 			areEqual(tblpPr1.getBottomFromText(), tblpPr2.getBottomFromText()) &&
 			areEqual(tblpPr1.getVertAnchor(), tblpPr2.getVertAnchor()) &&
 			areEqual(tblpPr1.getHorzAnchor(), tblpPr2.getHorzAnchor()) &&
 			areEqual(tblpPr1.getTblpXSpec(), tblpPr2.getTblpXSpec()) &&
 			areEqual(tblpPr1.getTblpX(), tblpPr2.getTblpX()) &&
 			areEqual(tblpPr1.getTblpYSpec(), tblpPr2.getTblpYSpec()) &&
 			areEqual(tblpPr1.getTblpY(), tblpPr2.getTblpY())		
 		    );
 	}
 
 	public static boolean areEqual(TblStyle style1TblStyle style2) {
 		return (style1 == style2) ||
 	       ((style1 != null) && (style2 != null) &&
 		    areEqual(style1.getVal(), style2.getVal())
 		    );
 	}
 
 	public static boolean areEqual(CTVerticalJc vAlign1CTVerticalJc vAlign2) {
 		return (vAlign1 == vAlign2) ||
 	       ((vAlign1 != null) && (vAlign2 != null) &&
 		    areEqual(vAlign1.getVal(), vAlign2.getVal())
 		    );
 	}
 
 	public static boolean areEqual(TcMar margin1TcMar margin2) {
 		return (margin1 == margin2) ||
 	       ((margin1 != null) && (margin2 != null) &&
 		    areEqual(margin1.getBottom(), margin2.getBottom()) &&
 		    areEqual(margin1.getLeft(), margin2.getLeft()) &&
 		    areEqual(margin1.getRight(), margin2.getRight()) &&
 		    areEqual(margin1.getTop(), margin2.getTop())
 		    );
 	}
 
 	public static boolean areEqual(TcBorders borders1TcBorders borders2) {
 		return (borders1 == borders2) ||
 	       ((borders1 != null) && (borders2 != null) &&
 		    areEqual(borders1.getBottom(), borders2.getBottom()) &&
 		    areEqual(borders1.getLeft(), borders2.getLeft()) &&
 		    areEqual(borders1.getRight(), borders2.getRight()) &&
 		    areEqual(borders1.getTop(), borders2.getTop()) &&
 		    areEqual(borders1.getInsideH(), borders2.getInsideH()) &&
 		    areEqual(borders1.getInsideV(), borders2.getInsideV()) &&
 		    areEqual(borders1.getTl2Br(), borders2.getTl2Br()) &&
 		    areEqual(borders1.getTr2Bl(), borders2.getTr2Bl())
 		    );
 	}
 
 	public static boolean areEqual(VMerge merge1VMerge merge2) {
 		return (merge1 == merge2) ||
 	       ((merge1 != null) && (merge2 != null) &&
 		    areEqual(merge1.getVal(), merge2.getVal())
 		    );
 	}
 
 	public static boolean areEqual(HMerge merge1HMerge merge2) {
 		return (merge1 == merge2) ||
 	       ((merge1 != null) && (merge2 != null) &&
 		    areEqual(merge1.getVal(), merge2.getVal())
 		    );
 	}
 
 	public static boolean areEqual(GridSpan gridSpan1GridSpan gridSpan2) {
 		return (gridSpan1 == gridSpan2) ||
 	       ((gridSpan1 != null) && (gridSpan2 != null) &&
 		    areEqual(gridSpan1.getVal(), gridSpan2.getVal())
 		    );
 	}
 
 	public static boolean areEqual(TrPr trPr1TrPr trPr2) {
 	List<JAXBElement<?>> defs1 = null;
 	List<JAXBElement<?>> defs2 = null;
 	JAXBElement<?> defs1element = null;
 	Object defs2value = null;
 	QName qName = null;
 	String qNameLocal = null;
 		if (trPr1 == trPr2)
 			return true;
 		if (((trPr1 != null) && (trPr2 == null)) || ((trPr1 == null) && (trPr2 != null)))
 			return false;
 		defs1 = trPr1.getCnfStyleOrDivIdOrGridBefore();
 		defs2 = trPr2.getCnfStyleOrDivIdOrGridBefore();
 		if (defs1 == defs2
 			return true;
 		//getCnfStyleOrDivIdOrGridBefore() is allways != null
 		if (defs1.size() != defs2.size())
 			return false;
 		if (defs1.isEmpty())
 			return true;
 
 		for (int i=0; i<defs1.size(); i++) {
 			defs1element = defs1.get(i);
 			qName = defs1element.getName();
 			defs2value = findTrValue(defs2qName);
 			if (defs2value == null)
 				return false;
 			qNameLocal = qName.getLocalPart();
 			if ("gridAfter".equals(qNameLocal)) {
 				if (!areEqual((GridAfter)defs1element.getValue(), (GridAfter)defs2value))
 					return false;
 			}
 			else if ("cantSplit".equals(qNameLocal)) {
 				if (!areEqual((BooleanDefaultTrue)defs1element.getValue(), (BooleanDefaultTrue)defs2value))
 					return false;
 			}
 			else if ("wBefore".equals(qNameLocal)) {
 				if (!areEqual((TblWidth)defs1element.getValue(), (TblWidth)defs2value))
 					return false;
 			}
 			else if ("jc".equals(qNameLocal)) {
 				if (!areEqual((Jc)defs1element.getValue(), (Jc)defs2value))
 					return false;
 			}
 			else if ("cnfStyle".equals(qNameLocal)) {
 				if (!areEqual((CTCnf)defs1element.getValue(), (CTCnf)defs2value))
 					return false;
 			}
 			else if ("gridBefore".equals(qNameLocal)) {
 				if (!areEqual((GridBefore)defs1element.getValue(), (GridBefore)defs2value))
 					return false;
 			}
 			else if ("hidden".equals(qNameLocal)) {
 				if (!areEqual((BooleanDefaultTrue)defs1element.getValue(), (BooleanDefaultTrue)defs2value))
 					return false;
 			}
 			else if ("trHeight".equals(qNameLocal)) {
 				if (!areEqual((CTHeight)defs1element.getValue(), (CTHeight)defs2value))
 					return false;
 			}
 			else if ("wAfter".equals(qNameLocal)) {
 				if (!areEqual((TblWidth)defs1element.getValue(), (TblWidth)defs2value))
 					return false;
 			}
 			else if ("tblHeader".equals(qNameLocal)) {
 				if (!areEqual((BooleanDefaultTrue)defs1element.getValue(), (BooleanDefaultTrue)defs2value))
 					return false;
 			}
 			else if ("tblCellSpacing".equals(qNameLocal)) {
 				if (!areEqual((TblWidth)defs1element.getValue(), (TblWidth)defs2value))
 					return false;
 			}
 		}
 		return true;
 	}
 
 	private static Object findTrValue(List<JAXBElement<?>> defsQName qName) {
 		for (int i=0; i<defs.size(); i++)
 			if (qName.equals(defs.get(i).getName())) 
 				return defs.get(i).getValue();
 		return null;
 	}
 
 	public static boolean areEqual(GridBefore value1GridBefore value2) {
 		return (value1 == value2) ||
 	       ((value1 != null) && (value2 != null) &&
 		   (areEqual(value1.getVal(), value2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(GridAfter value1GridAfter value2) {
 		return (value1 == value2) ||
 	       ((value1 != null) && (value2 != null) &&
 		   (areEqual(value1.getVal(), value2.getVal()))
 		    );
 	}
 
 	public static boolean areEqual(CTHeight height1CTHeight height2) {
 		return (height1 == height2) ||
 	       ((height1 != null) && (height2 != null) &&
 		    areEqual(height1.getVal(), height2.getVal()) &&
 		    areEqual(height1.getHRule(), height2.getHRule())
 		    );
 	}
 
 	public static boolean