Pages


1   /*
2     Copyright � 2006 Stefano Chizzolini. http://clown.stefanochizzolini.it
3   
4     Contributors:
5       * Stefano Chizzolini (original code developer, info@stefanochizzolini.it):
6         contributed code is Copyright � 2006 by Stefano Chizzolini.
7   
8     This file should be part of the source code distribution of "PDF Clown library"
9     (the Program): see the accompanying README files for more info.
10  
11    This Program is free software; you can redistribute it and/or modify it under
12    the terms of the GNU General Public License as published by the Free Software
13    Foundation; either version 2 of the License, or (at your option) any later version.
14  
15    This Program is distributed in the hope that it will be useful, but WITHOUT ANY
16    WARRANTY, either expressed or implied; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.
18  
19    You should have received a copy of the GNU General Public License along with this
20    Program (see README files); if not, go to the GNU website (http://www.gnu.org/).
21  
22    Redistribution and use, with or without modification, are permitted provided that such
23    redistributions retain the above copyright notice, license and disclaimer, along with
24    this list of conditions.
25  */
26  
27  package it.stefanochizzolini.clown.documents;
28  
29  import it.stefanochizzolini.clown.files.File;
30  import it.stefanochizzolini.clown.objects.IPdfNumber;
31  import it.stefanochizzolini.clown.objects.PdfArray;
32  import it.stefanochizzolini.clown.objects.PdfDictionary;
33  import it.stefanochizzolini.clown.objects.PdfDirectObject;
34  import it.stefanochizzolini.clown.objects.PdfInteger;
35  import it.stefanochizzolini.clown.objects.PdfName;
36  import it.stefanochizzolini.clown.objects.PdfObjectWrapper;
37  import it.stefanochizzolini.clown.objects.PdfReference;
38  import it.stefanochizzolini.clown.util.NotImplementedException;
39  
40  import java.util.ArrayList  ;
41  import java.util.Arrays  ;
42  import java.util.Collection  ;
43  import java.util.Iterator  ;
44  import java.util.List  ;
45  import java.util.ListIterator  ;
46  import java.util.NoSuchElementException  ;
47  import java.util.Stack  ;
48  
49  /**
50    Document pages collection.
51  */
52  public class Pages
53    extends PdfObjectWrapper<PdfDictionary>
54    implements List  <Page>
55  {
56    /*
57      TODO:IMPL A B-tree algorithm should be implemented to optimize the inner layout
58      of the page tree (better insertion/deletion performance). In this case, it would
59      be necessary to keep track of the modified tree nodes for incremental update.
60    */
61    // <class>
62    // <dynamic>
63    // <constructors>
64    Pages(
65      Document context
66      )
67    {
68      super(
69        context.getFile(),
70        new PdfDictionary(
71          new PdfName[]
72          {
73            PdfName.Type,
74            PdfName.Kids,
75            PdfName.Count
76          },
77          new PdfDirectObject[]
78          {
79            PdfName.Pages,
80            new PdfArray(),
81            new PdfInteger(0)
82          }
83          )
84        );
85    }
86  
87    Pages(
88      PdfDirectObject baseObject
89      )
90    {
91      super(
92        baseObject,
93        null // NO container (page tree root node MUST be an indirect object [PDF:1.6:3.6.1]).
94        );
95    }
96    // </constructors>
97  
98    // <interface>
99    // <public>
100   public Object   clone(
101     Document context
102     )
103   {throw new NotImplementedException();}
104 
105   // <List>
106   public void add(
107     int index,
108     Page page
109     )
110   {commonAddAll(index,Arrays.asList(page));}
111 
112   public boolean addAll(
113     int index,
114     Collection  <? extends Page> pages
115     )
116   {return commonAddAll(index,pages);}
117 
118   public Page get(
119     int index
120     )
121   {
122     /*
123       NOTE: As stated in [PDF:1.6:3.6.2], to retrieve pages is a matter of diving
124       inside a B-tree. To keep it as efficient as possible, this implementation
125       does NOT adopt recursion to deepen its search, opting for an iterative strategy
126       instead.
127     */
128     int pageOffset = 0;
129     PdfDictionary parent = getBaseDataObject();
130     PdfArray kids = (PdfArray)File.resolve(parent.get(PdfName.Kids));
131     for(
132       int i = 0;
133       i < kids.size();
134       i++
135       )
136     {
137       PdfReference kidReference = (PdfReference)kids.get(i);
138       PdfDictionary kid = (PdfDictionary)File.resolve(kidReference);
139       // Is current kid a page object?
140       if(kid.get(PdfName.Type).equals(PdfName.Page)) // Page object.
141       {
142         // Did we reach the searched position?
143         if(pageOffset == index) // Vertical scan (we finished).
144         {
145           // We got it!
146           return new Page(kidReference);
147         }
148         else // Horizontal scan (go past).
149         {
150           // Cumulate current page object count!
151           pageOffset++;
152         }
153       }
154       else // Page tree node.
155       {
156         // Does the current subtree contain the searched page?
157         if(((PdfInteger)kid.get(PdfName.Count)).getValue() + pageOffset > index) // Vertical scan (deepen the search).
158         {
159           // Go down one level!
160           parent = kid;
161           kids = (PdfArray)File.resolve(parent.get(PdfName.Kids));
162           i = -1;
163         }
164         else // Horizontal scan (go past).
165         {
166           // Cumulate current subtree count!
167           pageOffset += ((PdfInteger)kid.get(PdfName.Count)).getValue();
168         }
169       }
170     }
171 
172     return null;
173   }
174 
175   public int indexOf(
176     Object   page
177     )
178   {return ((Page)page).getIndex();}
179 
180   public int lastIndexOf(
181     Object   page
182     )
183   {
184     /*
185       NOTE: Each page object should NOT appear more than once inside the same document.
186     */
187     return indexOf(page);
188   }
189 
190   public ListIterator  <Page> listIterator(
191     )
192   {throw new NotImplementedException();}
193 
194   public ListIterator  <Page> listIterator(
195     int index
196     )
197   {throw new NotImplementedException();}
198 
199   public Page remove(
200     int index
201     )
202   {
203     Page page = get(index);
204     remove(page);
205 
206     return page;
207   }
208 
209   public Page set(
210     int index,
211     Page page
212     )
213   {
214     Page old = remove(index);
215     add(index,page);
216 
217     return old;
218   }
219 
220   public List  <Page> subList(
221     int fromIndex,
222     int toIndex
223     )
224   {
225   /*
226   TODO:IMPL this implementation is incoherent with the subList contract --> move to another location!
227   */
228     ArrayList  <Page> pages = new ArrayList  <Page>(toIndex - fromIndex);
229     int i = fromIndex;
230     Page page = get(i);
231     while(i++ < toIndex)
232     {
233       pages.add(page);
234       page = page.getNext();
235     }
236 
237     return pages;
238   }
239 
240   // <Collection>
241   public boolean add(
242     Page page
243     )
244   {return commonAddAll(-1,Arrays.asList(page));}
245 
246   public boolean addAll(
247     Collection  <? extends Page> pages
248     )
249   {return commonAddAll(-1,pages);}
250 
251   public void clear(
252     )
253   {throw new NotImplementedException();}
254 
255   public boolean contains(
256     Object   page
257     )
258   {throw new NotImplementedException();}
259 
260   public boolean containsAll(
261     Collection  <?> pages
262     )
263   {throw new NotImplementedException();}
264 
265   public boolean equals(
266     Object   object
267     )
268   {throw new NotImplementedException();}
269 
270   public int hashCode(
271     )
272   {throw new NotImplementedException();}
273 
274   public boolean isEmpty(
275     )
276   {throw new NotImplementedException();}
277 
278   public boolean remove(
279     Object   page
280     )
281   {
282     Page pageObj = (Page)page;
283     PdfDictionary pageData = pageObj.getBaseDataObject();
284     // Get the parent tree node!
285     PdfDirectObject parent = pageData.get(PdfName.Parent);
286     PdfDictionary parentData = (PdfDictionary)File.resolve(parent);
287     // Get the parent's page collection!
288     PdfDirectObject kids = parentData.get(PdfName.Kids);
289     PdfArray kidsData = (PdfArray)File.resolve(kids);
290     // Remove the page!
291     kidsData.remove(pageObj.getBaseObject());
292     boolean updateParent = !File.update(kids); // Try to update the page collection.
293     // Unbind the page from its parent!
294     pageData.put(PdfName.Parent,null);
295     pageObj.update();
296     // Decrementing the pages counters...
297     do
298     {
299       // Get the page collection counter!
300       PdfDirectObject count = parentData.get(PdfName.Count);
301       IPdfNumber countData = (IPdfNumber)File.resolve(count);
302       // Decrement the counter at the current level!
303       countData.translateNumberValue(-1);
304       updateParent |= !File.update(count); // Try to update the counter.
305       // Is the parent tree node to be updated?
306       /*
307         NOTE: It avoids to update the parent tree node if its modified fields are all
308         indirect objects which perform independent updates.
309       */
310       if(updateParent)
311       {
312         File.update(parent);
313         updateParent = false; // Reset.
314       }
315 
316       // Iterate upward!
317       parent = parentData.get(PdfName.Parent);
318       parentData = (PdfDictionary)File.resolve(parent);
319     } while(parent != null);
320 
321     return true;
322   }
323 
324   public boolean removeAll(
325     Collection  <?> pages
326     )
327   {
328     /*
329       NOTE: The interface contract doesn't prescribe any relation among the removing-collection's
330       items, so we cannot adopt the optimized approach of the add*(...) methods family,
331       where adding-collection's items are explicitly ordered.
332     */
333     boolean changed = false;
334     for(Object   page : pages)
335     {changed |= remove(page);}
336 
337     return changed;
338   }
339 
340   public boolean retainAll(
341     Collection  <?> pages
342     )
343   {throw new NotImplementedException();}
344 
345   public int size(
346     )
347   {return ((PdfInteger)getBaseDataObject().get(PdfName.Count)).getValue();}
348 
349   public Page[] toArray(
350     )
351   {throw new NotImplementedException();}
352 
353   public <Page> Page[] toArray(
354     Page[] pages
355     )
356   {throw new NotImplementedException();}
357 
358   // <Iterable>
359   public Iterator  <Page> iterator(
360     )
361   {
362     return new Iterator  <Page>()
363     {
364       // <class>
365       // <dynamic>
366       // <fields>
367       /**
368         Index of the next item.
369       */
370       private int index = 0;
371       /**
372         Collection size.
373       */
374       private int size = size();
375 
376       /**
377         Current level index.
378       */
379       private int levelIndex = 0;
380       /**
381         Stacked level indexes.
382       */
383       private Stack  <Integer  > levelIndexes = new Stack  <Integer  >();
384       /**
385         Current parent tree node.
386       */
387       private PdfDictionary parent = getBaseDataObject();
388       /**
389         Current child tree nodes.
390       */
391       private PdfArray kids = (PdfArray)File.resolve(parent.get(PdfName.Kids));
392       // </fields>
393 
394       // <interface>
395       // <public>
396       // <Iterator>
397       public boolean hasNext(
398         )
399       {return (index < size);}
400 
401       public Page next(
402         )
403       {
404         if(!hasNext())
405           throw new NoSuchElementException  ();
406 
407         return getNext();
408       }
409 
410       public void remove(
411         )
412       {throw new UnsupportedOperationException  ();}
413       // </Iterator>
414       // </public>
415 
416       // <private>
417       private Page getNext(
418         )
419       {
420         /*
421           NOTE: As stated in [PDF:1.6:3.6.2], to retrieve pages is a matter of diving
422           inside a B-tree.
423           This is a special adaptation of the get() algorithm necessary to keep
424           a low overhead throughout the page tree scan (using the get() method
425           would have implied a nonlinear computational cost).
426         */
427         /*
428           NOTE: Algorithm:
429           1. [Vertical, down] We have to go downward the page tree till we reach
430           a page (leaf node).
431           2. [Horizontal] Then we iterate across the page collection it belongs to,
432           repeating step 1 whenever we find a subtree.
433           3. [Vertical, up] When leaf-nodes scan is complete, we go upward solving
434           parent nodes, repeating step 2.
435         */
436         while(true)
437         {
438           // Did we complete current page-tree-branch level?
439           if(kids.size() == levelIndex) // Page subtree complete.
440           {
441             // 3. Go upward one level.
442             // Restore node index at the current level!
443             levelIndex = levelIndexes.pop() + 1; // Next node (partially scanned level).
444             // Move upward!
445             parent = (PdfDictionary)File.resolve(parent.get(PdfName.Parent));
446             kids = (PdfArray)File.resolve(parent.get(PdfName.Kids));
447           }
448           else // Page subtree incomplete.
449           {
450             PdfReference kidReference = (PdfReference)kids.get(levelIndex);
451             PdfDictionary kid = (PdfDictionary)File.resolve(kidReference);
452             // Is current kid a page object?
453             if(kid.get(PdfName.Type).equals(PdfName.Page)) // Page object.
454             {
455               // 2. Page found.
456               index++; // Absolute page index.
457               levelIndex++; // Current level node index.
458 
459               return new Page(kidReference);
460             }
461             else // Page tree node.
462             {
463               // 1. Go downward one level.
464               // Save node index at the current level!
465               levelIndexes.push(levelIndex);
466               // Move downward!
467               parent = kid;
468               kids = (PdfArray)File.resolve(parent.get(PdfName.Kids));
469               levelIndex = 0; // First node (new level).
470             }
471           }
472         }
473       }
474       // </private>
475       // </interface>
476       // </dynamic>
477       // </class>
478     };
479   }
480   // </Iterable>
481   // </Collection>
482   // </List>
483   // </public>
484 
485   // <private>
486   /**
487     Add a collection of pages at the specified position.
488     @param index Addition position. To append, use value -1.
489     @param pages Collection of pages to add.
490   */
491   private boolean commonAddAll(
492     int index,
493     Collection  <? extends Page> pages
494     )
495   {
496     PdfDirectObject parent;
497     PdfDictionary parentData;
498     PdfDirectObject kids;
499     PdfArray kidsData;
500     int offset;
501     // Append operation?
502     if(index == -1) // Append operation.
503     {
504       // Get the parent tree node!
505       parent = getBaseObject();
506       parentData = getBaseDataObject();
507       // Get the parent's page collection!
508       kids = parentData.get(PdfName.Kids);
509       kidsData = (PdfArray)File.resolve(kids);
510       offset = 0; // Not used.
511     }
512     else // Insert operation.
513     {
514       // Get the page currently at the specified position!
515       Page pivotPage = get(index);
516       // Get the parent tree node!
517       parent = pivotPage.getBaseDataObject().get(PdfName.Parent);
518       parentData = (PdfDictionary)File.resolve(parent);
519       // Get the parent's page collection!
520       kids = parentData.get(PdfName.Kids);
521       kidsData = (PdfArray)File.resolve(kids);
522       // Get the insertion's relative position within the parent's page collection!
523       offset = kidsData.indexOf(pivotPage.getBaseObject());
524     }
525 
526     // Adding the pages...
527     for(Page page : pages)
528     {
529       // Append?
530       if(index == -1) // Append.
531       {
532         // Append the page to the collection!
533         kidsData.add(page.getBaseObject());
534       }
535       else // Insert.
536       {
537         // Insert the page into the collection!
538         kidsData.add(
539           offset++,
540           page.getBaseObject()
541           );
542       }
543       // Bind the page to the collection!
544       page.getBaseDataObject().put(PdfName.Parent,parent);
545       page.update();
546     }
547     boolean updateParent = !File.update(kids); // Try to update the page collection.
548 
549     // Incrementing the pages counters...
550     do
551     {
552       // Get the page collection counter!
553       PdfDirectObject count = parentData.get(PdfName.Count);
554       IPdfNumber countData = (IPdfNumber)File.resolve(count);
555       // Increment the counter at the current level!
556       countData.translateNumberValue(pages.size());
557       updateParent |= !File.update(count); // Try to update the page counter.
558       // Is the parent tree node to be updated?
559       /*
560         NOTE: It avoids to update the parent tree node if its modified fields are all
561         indirect objects which perform independent updates.
562       */
563       if(updateParent)
564       {
565         File.update(parent);
566         updateParent = false; // Reset.
567       }
568 
569       // Iterate upward!
570       parent = parentData.get(PdfName.Parent);
571       parentData = (PdfDictionary)File.resolve(parent);
572     } while(parent != null);
573 
574     return true;
575   }
576   // </private>
577   // </interface>
578   // </dynamic>
579   // </class>
580 }
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags