_ Git - cubeextranet.git/blob

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 package org.apache.pdfbox.pdmodel.documentinterchange.logicalstructure;
  18
  19 import java.util.ArrayList;
  20 import java.util.Iterator;
  21 import java.util.List;
  22
  23 import org.apache.pdfbox.cos.COSArray;
  24 import org.apache.pdfbox.cos.COSBase;
  25 import org.apache.pdfbox.cos.COSDictionary;
  26 import org.apache.pdfbox.cos.COSInteger;
  27 import org.apache.pdfbox.cos.COSName;
  28 import org.apache.pdfbox.cos.COSObject;
  29 import org.apache.pdfbox.pdmodel.common.COSArrayList;
  30 import org.apache.pdfbox.pdmodel.common.COSObjectable;
  31 import org.apache.pdfbox.pdmodel.graphics.xobject.PDXObject;
  32 import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotation;
  33
  34 /**
  35  * A node in the structure tree.
  36  *
  37  * @author Koch
  38  * @version $Revision: $
  39  */
  40 public abstract class PDStructureNode implements COSObjectable
  41 {
  42
  43     /**
  44      * Creates a node in the structure tree. Can be either a structure tree root,
  45      *  or a structure element.
  46      *
  47      * @param node the node dictionary
  48      * @return the structure node
  49      */
  50     public static PDStructureNode create(COSDictionary node)
  51     {
  52         String type = node.getNameAsString(COSName.TYPE);
  53         if ("StructTreeRoot".equals(type))
  54         {
  55             return new PDStructureTreeRoot(node);
  56         }
  57         if ((type == null) || "StructElem".equals(type))
  58         {
  59             return new PDStructureElement(node);
  60         }
  61         throw new IllegalArgumentException("Dictionary must not include a Type entry with a value that is neither StructTreeRoot nor StructElem.");
  62     }
  63
  64
  65     private COSDictionary dictionary;
  66
  67     protected COSDictionary getCOSDictionary()
  68     {
  69         return dictionary;
  70     }
  71
  72     /**
  73      * Constructor.
  74      *
  75      * @param type the type
  76      */
  77     protected PDStructureNode(String type)
  78     {
  79         this.dictionary = new COSDictionary();
  80         this.dictionary.setName(COSName.TYPE, type);
  81     }
  82
  83     /**
  84      * Constructor for an existing structure node.
  85      *
  86      * @param dictionary The existing dictionary.
  87      */
  88     protected PDStructureNode(COSDictionary dictionary)
  89     {
  90         this.dictionary = dictionary;
  91     }
  92
  93     /**
  94      * {@inheritDoc}
  95      */
  96     public COSBase getCOSObject()
  97     {
  98         return this.dictionary;
  99     }
 100
 101     /**
 102      * Returns the type.
 103      *
 104      * @return the type
 105      */
 106     public String getType()
 107     {
 108         return this.getCOSDictionary().getNameAsString(COSName.TYPE);
 109     }
 110
 111     /**
 112      * Returns a list of objects for the kids (K).
 113      *
 114      * @return a list of objects for the kids
 115      */
 116     public List<Object> getKids()
 117     {
 118         List<Object> kidObjects = new ArrayList<Object>();
 119         COSBase k = this.getCOSDictionary().getDictionaryObject(COSName.K);
 120         if (k instanceof COSArray)
 121         {
 122             Iterator<COSBase> kids = ((COSArray) k).iterator();
 123             while (kids.hasNext())
 124             {
 125                 COSBase kid = kids.next();
 126                 Object kidObject = this.createObject(kid);
 127                 if (kidObject != null)
 128                 {
 129                     kidObjects.add(kidObject);
 130                 }
 131             }
 132         }
 133         else
 134         {
 135             Object kidObject = this.createObject(k);
 136             if (kidObject != null)
 137             {
 138                 kidObjects.add(kidObject);
 139             }
 140         }
 141         return kidObjects;
 142     }
 143
 144     /**
 145      * Sets the kids (K).
 146      *
 147      * @param kids the kids
 148      */
 149     public void setKids(List<Object> kids)
 150     {
 151         this.getCOSDictionary().setItem(COSName.K,
 152             COSArrayList.converterToCOSArray(kids));
 153     }
 154
 155     /**
 156      * Appends a structure element kid.
 157      *
 158      * @param structureElement the structure element
 159      */
 160     public void appendKid(PDStructureElement structureElement)
 161     {
 162         this.appendObjectableKid(structureElement);
 163         structureElement.setParent(this);
 164     }
 165
 166     /**
 167      * Appends an objectable kid.
 168      *
 169      * @param objectable the objectable
 170      */
 171     protected void appendObjectableKid(COSObjectable objectable)
 172     {
 173         if (objectable == null)
 174         {
 175             return;
 176         }
 177         this.appendKid(objectable.getCOSObject());
 178     }
 179
 180     /**
 181      * Appends a COS base kid.
 182      *
 183      * @param object the COS base
 184      */
 185     protected void appendKid(COSBase object)
 186     {
 187         if (object == null)
 188         {
 189             return;
 190         }
 191         COSBase k = this.getCOSDictionary().getDictionaryObject(COSName.K);
 192         if (k == null)
 193         {
 194             // currently no kid: set new kid as kids
 195             this.getCOSDictionary().setItem(COSName.K, object);
 196         }
 197         else if (k instanceof COSArray)
 198         {
 199             // currently more than one kid: add new kid to existing array
 200             COSArray array = (COSArray) k;
 201             array.add(object);
 202         }
 203         else
 204         {
 205             // currently one kid: put current and new kid into array and set array as kids
 206             COSArray array = new COSArray();
 207             array.add(k);
 208             array.add(object);
 209             this.getCOSDictionary().setItem(COSName.K, array);
 210         }
 211     }
 212
 213     /**
 214      * Inserts a structure element kid before a reference kid.
 215      *
 216      * @param newKid the structure element
 217      * @param refKid the reference kid
 218      */
 219     public void insertBefore(PDStructureElement newKid, Object refKid)
 220     {
 221         this.insertObjectableBefore(newKid, refKid);
 222     }
 223
 224     /**
 225      * Inserts an objectable kid before a reference kid.
 226      *
 227      * @param newKid the objectable
 228      * @param refKid the reference kid
 229      */
 230     protected void insertObjectableBefore(COSObjectable newKid, Object refKid)
 231     {
 232         if (newKid == null)
 233         {
 234             return;
 235         }
 236         this.insertBefore(newKid.getCOSObject(), refKid);
 237     }
 238
 239     /**
 240      * Inserts an COS base kid before a reference kid.
 241      *
 242      * @param newKid the COS base
 243      * @param refKid the reference kid
 244      */
 245     protected void insertBefore(COSBase newKid, Object refKid)
 246     {
 247         if ((newKid == null) || (refKid == null))
 248         {
 249             return;
 250         }
 251         COSBase k = this.getCOSDictionary().getDictionaryObject(COSName.K);
 252         if (k == null)
 253         {
 254             return;
 255         }
 256         COSBase refKidBase = null;
 257         if (refKid instanceof COSObjectable)
 258         {
 259             refKidBase = ((COSObjectable) refKid).getCOSObject();
 260         }
 261         else if (refKid instanceof COSInteger)
 262         {
 263             refKidBase = (COSInteger) refKid;
 264         }
 265         if (k instanceof COSArray)
 266         {
 267             COSArray array = (COSArray) k;
 268             int refIndex = array.indexOfObject(refKidBase);
 269             array.add(refIndex, newKid.getCOSObject());
 270         }
 271         else
 272         {
 273             boolean onlyKid = k.equals(refKidBase);
 274             if (!onlyKid && (k instanceof COSObject))
 275             {
 276                 COSBase kObj = ((COSObject) k).getObject();
 277                 onlyKid = kObj.equals(refKidBase);
 278             }
 279             if (onlyKid)
 280             {
 281                 COSArray array = new COSArray();
 282                 array.add(newKid);
 283                 array.add(refKidBase);
 284                 this.getCOSDictionary().setItem(COSName.K, array);
 285             }
 286         }
 287     }
 288
 289     /**
 290      * Removes a structure element kid.
 291      *
 292      * @param structureElement the structure element
 293      * @return <code>true</code> if the kid was removed, <code>false</code> otherwise
 294      */
 295     public boolean removeKid(PDStructureElement structureElement)
 296     {
 297         boolean removed = this.removeObjectableKid(structureElement);
 298         if (removed)
 299         {
 300             structureElement.setParent(null);
 301         }
 302         return removed;
 303     }
 304
 305     /**
 306      * Removes an objectable kid.
 307      *
 308      * @param objectable the objectable
 309      * @return <code>true</code> if the kid was removed, <code>false</code> otherwise
 310      */
 311     protected boolean removeObjectableKid(COSObjectable objectable)
 312     {
 313         if (objectable == null)
 314         {
 315             return false;
 316         }
 317         return this.removeKid(objectable.getCOSObject());
 318     }
 319
 320     /**
 321      * Removes a COS base kid.
 322      *
 323      * @param object the COS base
 324      * @return <code>true</code> if the kid was removed, <code>false</code> otherwise
 325      */
 326     protected boolean removeKid(COSBase object)
 327     {
 328         if (object == null)
 329         {
 330             return false;
 331         }
 332         COSBase k = this.getCOSDictionary().getDictionaryObject(COSName.K);
 333         if (k == null)
 334         {
 335             // no kids: objectable is not a kid
 336             return false;
 337         }
 338         else if (k instanceof COSArray)
 339         {
 340             // currently more than one kid: remove kid from existing array
 341             COSArray array = (COSArray) k;
 342             boolean removed = array.removeObject(object);
 343             // if now only one kid: set remaining kid as kids
 344             if (array.size() == 1)
 345             {
 346                 this.getCOSDictionary().setItem(COSName.K, array.getObject(0));
 347             }
 348             return removed;
 349         }
 350         else
 351         {
 352             // currently one kid: if current kid equals given object, remove kids entry
 353             boolean onlyKid = k.equals(object);
 354             if (!onlyKid && (k instanceof COSObject))
 355             {
 356                 COSBase kObj = ((COSObject) k).getObject();
 357                 onlyKid = kObj.equals(object);
 358             }
 359             if (onlyKid)
 360             {
 361                 this.getCOSDictionary().setItem(COSName.K, null);
 362                 return true;
 363             }
 364             return false;
 365         }
 366     }
 367
 368     /**
 369      * Creates an object for a kid of this structure node.
 370      * The type of object depends on the type of the kid. It can be
 371      * <ul>
 372      * <li>a {@link PDStructureElement},</li>
 373      * <li>a {@link PDAnnotation},</li>
 374      * <li>a {@link PDXObject},</li>
 375      * <li>a {@link PDMarkedContentReference}</li>
 376      * <li>a {@link Integer}</li>
 377      * </ul>
 378      *
 379      * @param kid the kid
 380      * @return the object
 381      */
 382     protected Object createObject(COSBase kid)
 383     {
 384         COSDictionary kidDic = null;
 385         if (kid instanceof COSDictionary)
 386         {
 387             kidDic = (COSDictionary) kid;
 388         }
 389         else if (kid instanceof COSObject)
 390         {
 391             COSBase base = ((COSObject) kid).getObject();
 392             if (base instanceof COSDictionary)
 393             {
 394                 kidDic = (COSDictionary) base;
 395             }
 396         }
 397         if (kidDic != null)
 398         {
 399             String type = kidDic.getNameAsString(COSName.TYPE);
 400             if ((type == null) || PDStructureElement.TYPE.equals(type))
 401             {
 402                 // A structure element dictionary denoting another structure
 403                 // element
 404                 return new PDStructureElement(kidDic);
 405             }
 406             else if (PDObjectReference.TYPE.equals(type))
 407             {
 408                 // An object reference dictionary denoting a PDF object
 409                 return new PDObjectReference(kidDic);
 410             }
 411             else if (PDMarkedContentReference.TYPE.equals(type))
 412             {
 413                 // A marked-content reference dictionary denoting a
 414                 // marked-content sequence
 415                 return new PDMarkedContentReference(kidDic);
 416             }
 417         }
 418         else if (kid instanceof COSInteger)
 419         {
 420             // An integer marked-content identifier denoting a
 421             // marked-content sequence
 422             COSInteger mcid = (COSInteger) kid;
 423             return mcid.intValue();
 424         }
 425         return null;
 426     }
 427
 428 }