Changeset 703

Show
Ignore:
Timestamp:
01/25/06 10:28:22 (3 years ago)
Author:
laotzu
Message:

Add ability to manipulate page boxes.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • pypdf/trunk/pyPdf/generic.py

    r701 r703  
    3737import re 
    3838from utils import readNonWhitespace 
    39  
    40 class BooleanObject(object): 
    41     def __init__(self, value): 
    42         self.value = value 
    43  
    44     def writeToStream(self, stream): 
    45         if self.value: 
    46             stream.write("true") 
    47         else: 
    48             stream.write("false") 
    49  
    50     def readFromStream(stream): 
    51         word = stream.read(4) 
    52         if word == "true": 
    53             return BooleanObject(True) 
    54         elif word == "fals": 
    55             stream.read(1) 
    56             return BooleanObject(False) 
    57         assert False 
    58     readFromStream = staticmethod(readFromStream) 
    59  
    60  
    61 class ArrayObject(list): 
    62     def writeToStream(self, stream): 
    63         stream.write("[") 
    64         for data in self: 
    65             stream.write(" ") 
    66             data.writeToStream(stream) 
    67         stream.write(" ]") 
    68  
    69     def readFromStream(stream, pdf): 
    70         arr = ArrayObject() 
    71         assert stream.read(1) == "[" 
    72         while True: 
    73             # skip leading whitespace 
    74             tok = stream.read(1) 
    75             while tok.isspace(): 
    76                 tok = stream.read(1) 
    77             stream.seek(-1, 1) 
    78             # check for array ending 
    79             peekahead = stream.read(1) 
    80             if peekahead == "]": 
    81                 break 
    82             stream.seek(-1, 1) 
    83             # read and append obj 
    84             arr.append(readObject(stream, pdf)) 
    85         return arr 
    86     readFromStream = staticmethod(readFromStream) 
    87  
    88  
    89 class IndirectObject(object): 
    90     def __init__(self, idnum, generation, pdf): 
    91         self.idnum = idnum 
    92         self.generation = generation 
    93         self.pdf = pdf 
    94  
    95     def __repr__(self): 
    96         return "IndirectObject(%r, %r)" % (self.idnum, self.generation) 
    97  
    98     def writeToStream(self, stream): 
    99         stream.write("%s %s R" % (self.idnum, self.generation)) 
    100  
    101     def readFromStream(stream, pdf): 
    102         idnum = "" 
    103         while True: 
    104             tok = stream.read(1) 
    105             if tok.isspace(): 
    106                 break 
    107             idnum += tok 
    108         generation = "" 
    109         while True: 
    110             tok = stream.read(1) 
    111             if tok.isspace(): 
    112                 break 
    113             generation += tok 
    114         r = stream.read(1) 
    115         #if r != "R": 
    116         #    stream.seek(-20, 1) 
    117         #    print idnum, generation 
    118         #    print repr(stream.read(40)) 
    119         assert r == "R" 
    120         return IndirectObject(int(idnum), int(generation), pdf) 
    121     readFromStream = staticmethod(readFromStream) 
    122  
    123  
    124 class FloatObject(float): 
    125     def writeToStream(self, stream): 
    126         stream.write(repr(self)) 
    127  
    128  
    129 class NumberObject(int): 
    130     def __init__(self, value): 
    131         int.__init__(self, value) 
    132  
    133     def writeToStream(self, stream): 
    134         stream.write(repr(self)) 
    135  
    136     def readFromStream(stream): 
    137         name = "" 
    138         while True: 
    139             tok = stream.read(1) 
    140             if tok != '+' and tok != '-' and tok != '.' and not tok.isdigit(): 
    141                 stream.seek(-1, 1) 
    142                 break 
    143             name += tok 
    144         if name.find(".") != -1: 
    145             return FloatObject(name) 
    146         else: 
    147             return NumberObject(name) 
    148     readFromStream = staticmethod(readFromStream) 
    149  
    150  
    151 class StringObject(str): 
    152     def writeToStream(self, stream): 
    153         stream.write("(") 
    154         for c in self: 
    155             if not c.isalnum() and not c.isspace(): 
    156                 stream.write("\\%03o" % ord(c)) 
    157             else: 
    158                 stream.write(c) 
    159         stream.write(")") 
    160  
    161     def readHexStringFromStream(stream): 
    162         stream.read(1) 
    163         txt = "" 
    164         x = "" 
    165         while True: 
    166             tok = readNonWhitespace(stream) 
    167             if tok == ">": 
    168                 break 
    169             x += tok 
    170             if len(x) == 2: 
    171                 txt += chr(int(x, base=16)) 
    172                 x = "" 
    173         if len(x) == 1: 
    174             x += "0" 
    175         if len(x) == 2: 
    176             txt += chr(int(x, base=16)) 
    177         return StringObject(txt) 
    178     readHexStringFromStream = staticmethod(readHexStringFromStream) 
    179  
    180     def readFromStream(stream): 
    181         tok = stream.read(1) 
    182         parens = 1 
    183         txt = "" 
    184         while True: 
    185             tok = stream.read(1) 
    186             if tok == "(": 
    187                 parens += 1 
    188             elif tok == ")": 
    189                 parens -= 1 
    190                 if parens == 0: 
    191                     break 
    192             elif tok == "\\": 
    193                 tok = stream.read(1) 
    194                 if tok == "n": 
    195                     tok = "\n" 
    196                 elif tok == "r": 
    197                     tok = "\r" 
    198                 elif tok == "t": 
    199                     tok = "\t" 
    200                 elif tok == "b": 
    201                     tok == "\b" 
    202                 elif tok == "f": 
    203                     tok = "\f" 
    204                 elif tok == "(": 
    205                     tok = "(" 
    206                 elif tok == ")": 
    207                     tok = ")" 
    208                 elif tok == "\\": 
    209                     tok = "\\" 
    210                 elif tok.isdigit(): 
    211                     tok += stream.read(2) 
    212                     tok = chr(int(tok, base=8)) 
    213             txt += tok 
    214         return StringObject(txt) 
    215     readFromStream = staticmethod(readFromStream) 
    216  
    217  
    218 class NameObject(str): 
    219     delimiterCharacters = "(", ")", "<", ">", "[", "]", "{", "}", "/", "%" 
    220  
    221     def __init__(self, data): 
    222         str.__init__(self, data) 
    223  
    224     def writeToStream(self, stream): 
    225         stream.write(self) 
    226  
    227     def readFromStream(stream): 
    228         name = stream.read(1) 
    229         assert name == "/" 
    230         while True: 
    231             tok = stream.read(1) 
    232             if tok.isspace() or tok in NameObject.delimiterCharacters: 
    233                 stream.seek(-1, 1) 
    234                 break 
    235             name += tok 
    236         return NameObject(name) 
    237     readFromStream = staticmethod(readFromStream) 
    238  
    239  
    240 class DictionaryObject(dict): 
    241     def __init__(self): 
    242         pass 
    243  
    244     def writeToStream(self, stream): 
    245         stream.write("<<\n") 
    246         for key, value in self.items(): 
    247             if key != "__streamdata__": 
    248                 key.writeToStream(stream) 
    249                 stream.write(" ") 
    250                 value.writeToStream(stream) 
    251                 stream.write("\n") 
    252         stream.write(">>") 
    253         if self.has_key("__streamdata__"): 
    254             stream.write("\nstream\n") 
    255             stream.write(self["__streamdata__"]) 
    256             stream.write("\nendstream") 
    257  
    258     def readFromStream(stream, pdf): 
    259         assert stream.read(2) == "<<" 
    260         retval = DictionaryObject() 
    261         while True: 
    262             tok = readNonWhitespace(stream) 
    263             if tok == ">": 
    264                 stream.read(1) 
    265                 break 
    266             stream.seek(-1, 1) 
    267             key = readObject(stream, pdf) 
    268             tok = readNonWhitespace(stream) 
    269             stream.seek(-1, 1) 
    270             value = readObject(stream, pdf) 
    271             if retval.has_key(key): 
    272                 # multiple definitions of key not handled yet 
    273                 assert False 
    274             retval[key] = value 
    275         pos = stream.tell() 
    276         s = readNonWhitespace(stream) 
    277         if s == 's' and stream.read(5) == 'tream': 
    278             eol = stream.read(1) 
    279             assert eol in ("\n", "\r") 
    280             if eol == "\r": 
    281                 # read \n after 
    282                 stream.read(1) 
    283             # this is a stream object, not a dictionary 
    284             assert retval.has_key("/Length") 
    285             length = retval["/Length"] 
    286             if isinstance(length, IndirectObject): 
    287                 t = stream.tell() 
    288                 length = pdf.getObject(length) 
    289                 stream.seek(t, 0) 
    290             retval["__streamdata__"] = stream.read(length) 
    291             e = readNonWhitespace(stream) 
    292             ndstream = stream.read(8) 
    293             assert e == "e" and ndstream == "ndstream" 
    294         else: 
    295             stream.seek(pos, 0) 
    296         return retval 
    297     readFromStream = staticmethod(readFromStream) 
    29839 
    29940def readObject(stream, pdf): 
    …… 
    33475        else: 
    33576            return NumberObject.readFromStream(stream) 
     77 
     78 
     79class BooleanObject(object): 
     80    def __init__(self, value): 
     81        self.value = value 
     82 
     83    def writeToStream(self, stream): 
     84        if self.value: 
     85            stream.write("true") 
     86        else: 
     87            stream.write("false") 
     88 
     89    def readFromStream(stream): 
     90        word = stream.read(4) 
     91        if word == "true": 
     92            return BooleanObject(True) 
     93        elif word == "fals": 
     94            stream.read(1) 
     95            return BooleanObject(False) 
     96        assert False 
     97    readFromStream = staticmethod(readFromStream) 
     98 
     99 
     100class ArrayObject(list): 
     101    def writeToStream(self, stream): 
     102        stream.write("[") 
     103        for data in self: 
     104            stream.write(" ") 
     105            data.writeToStream(stream) 
     106        stream.write(" ]") 
     107 
     108    def readFromStream(stream, pdf): 
     109        arr = ArrayObject() 
     110        assert stream.read(1) == "[" 
     111        while True: 
     112            # skip leading whitespace 
     113            tok = stream.read(1) 
     114            while tok.isspace(): 
     115                tok = stream.read(1) 
     116            stream.seek(-1, 1) 
     117            # check for array ending 
     118            peekahead = stream.read(1) 
     119            if peekahead == "]": 
     120                break 
     121            stream.seek(-1, 1) 
     122            # read and append obj 
     123            arr.append(readObject(stream, pdf)) 
     124        return arr 
     125    readFromStream = staticmethod(readFromStream) 
     126 
     127 
     128class IndirectObject(object): 
     129    def __init__(self, idnum, generation, pdf): 
     130        self.idnum = idnum 
     131        self.generation = generation 
     132        self.pdf = pdf 
     133 
     134    def __repr__(self): 
     135        return "IndirectObject(%r, %r)" % (self.idnum, self.generation) 
     136 
     137    def writeToStream(self, stream): 
     138        stream.write("%s %s R" % (self.idnum, self.generation)) 
     139 
     140    def readFromStream(stream, pdf): 
     141        idnum = "" 
     142        while True: 
     143            tok = stream.read(1) 
     144            if tok.isspace(): 
     145                break 
     146            idnum += tok 
     147        generation = "" 
     148        while True: 
     149            tok = stream.read(1) 
     150            if tok.isspace(): 
     151                break 
     152            generation += tok 
     153        r = stream.read(1) 
     154        #if r != "R": 
     155        #    stream.seek(-20, 1) 
     156        #    print idnum, generation 
     157        #    print repr(stream.read(40)) 
     158        assert r == "R" 
     159        return IndirectObject(int(idnum), int(generation), pdf) 
     160    readFromStream = staticmethod(readFromStream) 
     161 
     162 
     163class FloatObject(float): 
     164    def writeToStream(self, stream): 
     165        stream.write(repr(self)) 
     166 
     167 
     168class NumberObject(int): 
     169    def __init__(self, value): 
     170        int.__init__(self, value) 
     171 
     172    def writeToStream(self, stream): 
     173        stream.write(repr(self)) 
     174 
     175    def readFromStream(stream): 
     176        name = "" 
     177        while True: 
     178            tok = stream.read(1) 
     179            if tok != '+' and tok != '-' and tok != '.' and not tok.isdigit(): 
     180                stream.seek(-1, 1) 
     181                break 
     182            name += tok 
     183        if name.find(".") != -1: 
     184            return FloatObject(name) 
     185        else: 
     186            return NumberObject(name) 
     187    readFromStream = staticmethod(readFromStream) 
     188 
     189 
     190class StringObject(str): 
     191    def writeToStream(self, stream): 
     192        stream.write("(") 
     193        for c in self: 
     194            if not c.isalnum() and not c.isspace(): 
     195                stream.write("\\%03o" % ord(c)) 
     196            else: 
     197                stream.write(c) 
     198        stream.write(")") 
     199 
     200    def readHexStringFromStream(stream): 
     201        stream.read(1) 
     202        txt = "" 
     203        x = "" 
     204        while True: 
     205            tok = readNonWhitespace(stream) 
     206            if tok == ">": 
     207                break 
     208            x += tok 
     209            if len(x) == 2: 
     210                txt += chr(int(x, base=16)) 
     211                x = "" 
     212        if len(x) == 1: 
     213            x += "0" 
     214        if len(x) == 2: 
     215            txt += chr(int(x, base=16)) 
     216        return StringObject(txt) 
     217    readHexStringFromStream = staticmethod(readHexStringFromStream) 
     218 
     219    def readFromStream(stream): 
     220        tok = stream.read(1) 
     221        parens = 1 
     222        txt = "" 
     223        while True: 
     224            tok = stream.read(1) 
     225            if tok == "(": 
     226                parens += 1 
     227            elif tok == ")": 
     228                parens -= 1 
     229                if parens == 0: 
     230                    break 
     231            elif tok == "\\": 
     232                tok = stream.read(1) 
     233                if tok == "n": 
     234                    tok = "\n" 
     235                elif tok == "r": 
     236                    tok = "\r" 
     237                elif tok == "t": 
     238                    tok = "\t" 
     239                elif tok == "b": 
     240                    tok == "\b" 
     241                elif tok == "f": 
     242                    tok = "\f" 
     243                elif tok == "(": 
     244                    tok = "(" 
     245                elif tok == ")": 
     246                    tok = ")" 
     247                elif tok == "\\": 
     248                    tok = "\\" 
     249                elif tok.isdigit(): 
     250                    tok += stream.read(2) 
     251                    tok = chr(int(tok, base=8)) 
     252            txt += tok 
     253        return StringObject(txt) 
     254    readFromStream = staticmethod(readFromStream) 
     255 
     256 
     257class NameObject(str): 
     258    delimiterCharacters = "(", ")", "<", ">", "[", "]", "{", "}", "/", "%" 
     259 
     260    def __init__(self, data): 
     261        str.__init__(self, data) 
     262 
     263    def writeToStream(self, stream): 
     264        stream.write(self) 
     265 
     266    def readFromStream(stream): 
     267        name = stream.read(1) 
     268        assert name == "/" 
     269        while True: 
     270            tok = stream.read(1) 
     271            if tok.isspace() or tok in NameObject.delimiterCharacters: 
     272                stream.seek(-1, 1) 
     273                break 
     274            name += tok 
     275        return NameObject(name) 
     276    readFromStream = staticmethod(readFromStream) 
     277 
     278 
     279class DictionaryObject(dict): 
     280    def __init__(self): 
     281        pass 
     282 
     283    def writeToStream(self, stream): 
     284        stream.write("<<\n") 
     285        for key, value in self.items(): 
     286            if key != "__streamdata__": 
     287                key.writeToStream(stream) 
     288                stream.write(" ") 
     289                value.writeToStream(stream) 
     290                stream.write("\n") 
     291        stream.write(">>") 
     292        if self.has_key("__streamdata__"): 
     293            stream.write("\nstream\n") 
     294            stream.write(self["__streamdata__"]) 
     295            stream.write("\nendstream") 
     296 
     297    def readFromStream(stream, pdf): 
     298        assert stream.read(2) == "<<" 
     299        retval = DictionaryObject() 
     300        while True: 
     301            tok = readNonWhitespace(stream) 
     302            if tok == ">": 
     303                stream.read(1) 
     304                break 
     305            stream.seek(-1, 1) 
     306            key = readObject(stream, pdf) 
     307            tok = readNonWhitespace(stream) 
     308            stream.seek(-1, 1) 
     309            value = readObject(stream, pdf) 
     310            if retval.has_key(key): 
     311                # multiple definitions of key not handled yet 
     312                assert False 
     313            retval[key] = value 
     314        pos = stream.tell() 
     315        s = readNonWhitespace(stream) 
     316        if s == 's' and stream.read(5) == 'tream': 
     317            eol = stream.read(1) 
     318            assert eol in ("\n", "\r") 
     319            if eol == "\r": 
     320                # read \n after 
     321                stream.read(1) 
     322            # this is a stream object, not a dictionary 
     323            assert retval.has_key("/Length") 
     324            length = retval["/Length"] 
     325            if isinstance(length, IndirectObject): 
     326                t = stream.tell() 
     327                length = pdf.getObject(length) 
     328                stream.seek(t, 0) 
     329            retval["__streamdata__"] = stream.read(length) 
     330            e = readNonWhitespace(stream) 
     331            ndstream = stream.read(8) 
     332            assert e == "e" and ndstream == "ndstream" 
     333        else: 
     334            stream.seek(pos, 0) 
     335        return retval 
     336    readFromStream = staticmethod(readFromStream) 
     337 
     338 
     339class RectangleObject(ArrayObject): 
     340    def __init__(self, arr): 
     341        # must have four points 
     342        assert len(arr) == 4 
     343        # automatically convert arr[x] into NumberObject(arr[x]) if necessary 
     344        ArrayObject.__init__(self, [self.ensureIsNumber(x) for x in arr]) 
     345 
     346    def ensureIsNumber(self, value): 
     347        if not isinstance(value, NumberObject): 
     348            value = NumberObject(value) 
     349        return value 
     350 
     351    def __repr__(self): 
     352        return "RectangleObject(%s)" % repr(list(self)) 
     353 
     354    def getLowerLeft_x(self): 
     355        return self[0] 
     356 
     357    def getLowerLeft_y(self): 
     358        return self[1] 
     359 
     360    def getUpperRight_x(self): 
     361        return self[2] 
     362 
     363    def getUpperRight_y(self): 
     364        return self[3] 
     365 
     366    def getUpperLeft_x(self): 
     367        return self.getLowerLeft_x() 
     368     
     369    def getUpperLeft_y(self): 
     370        return self.getUpperRight_y() 
     371 
     372    def getLowerRight_x(self): 
     373        return self.getUpperRight_x() 
     374 
     375    def getLowerRight_y(self): 
     376        return self.getLowerLeft_y() 
     377 
     378    def getLowerLeft(self): 
     379        return self.getLowerLeft_x(), self.getLowerLeft_y() 
     380 
     381    def getLowerRight(self): 
     382        return self.getLowerRight_x(), self.getLowerRight_y() 
     383 
     384    def getUpperLeft(self): 
     385        return self.getUpperLeft_x(), self.getUpperLeft_y() 
     386 
     387    def getUpperRight(self): 
     388        return self.getUpperRight_x(), self.getUpperRight_y() 
     389 
     390    def setLowerLeft(self, value): 
     391        self[0], self[1] = [self.ensureIsNumber(x) for x in value] 
     392 
     393    def setLowerRight(self, value): 
     394        self[2], self[1] = [self.ensureIsNumber(x) for x in value] 
     395 
     396    def setUpperLeft(self, value): 
     397        self[0], self[3] = [self.ensureIsNumber(x) for x in value] 
     398 
     399    def setUpperRight(self, value): 
     400        self[2], self[3] = [self.ensureIsNumber(x) for x in value] 
     401 
     402    lowerLeft = property(getLowerLeft, setLowerLeft, None, None) 
     403    lowerRight = property(getLowerRight, setLowerRight, None, None) 
     404    upperLeft = property(getUpperLeft, setUpperLeft, None, None) 
     405    upperRight = property(getUpperRight, setUpperRight, None, None) 
     406 

  • pypdf/trunk/pyPdf/pdf.py

    r701 r703  
    4444 
    4545import filters 
    46 from generic import NameObject, DictionaryObject, IndirectObject, readObject 
    47 from generic import NumberObject, ArrayObject, StringObject 
     46from generic import * 
    4847from utils import readNonWhitespace, readUntilWhitespace 
    4948 
    …… 
    244243                if not pages.has_key(attr): 
    245244                    pages[attr] = value 
    246             pageObj = PageObject() 
     245            pageObj = PageObject(self) 
    247246            pageObj.update(pages) 
    248247            self.flattenedPages.append(pageObj) 
    …… 
    419418 
    420419 
     420def getRectangle(self, name, defaults): 
     421    retval = self.get(name) 
     422    if isinstance(retval, RectangleObject): 
     423        return retval 
     424    if retval == None: 
     425        for d in defaults: 
     426            retval = self.get(d) 
     427            if retval != None: 
     428                break 
     429    if isinstance(retval, IndirectObject): 
     430        retval = self.pdf.getObject(retval) 
     431    retval = RectangleObject(retval) 
     432    setRectangle(self, name, retval) 
     433    return retval 
     434 
     435def setRectangle(self, name, value): 
     436    if not isinstance(name, NameObject): 
     437        name = NameObject(name) 
     438    self[name] = value 
     439 
     440def deleteRectangle(self, name): 
     441    del self[name] 
     442 
     443def addRectangleAccessor(klass, propname, name, fallback, docs): 
     444    setattr(klass, propname, 
     445        property( 
     446            lambda self: getRectangle(self, name, fallback), 
     447            lambda self, value: setRectangle(self, name, value), 
     448            lambda self: deleteRectangle(self, name), 
     449            docs 
     450            ) 
     451        ) 
     452 
    421453class PageObject(DictionaryObject): 
     454    def __init__(self, pdf): 
     455        self.pdf = pdf 
     456 
    422457    def rotateClockwise(self, angle): 
    423458        """ 
    …… 
    445480        self[NameObject("/Rotate")] = NumberObject(currentAngle + angle) 
    446481 
     482addRectangleAccessor(PageObject, "mediaBox", "/MediaBox", (), 
     483        """A rectangle, expressed in default user space units, defining the 
     484        boundaries of the physical medium on which the page is intended to be 
     485        displayed or printed. 
     486 
     487        Stability: Added in v1.4, will exist for all v1.x releases 
     488        thereafter.""") 
     489addRectangleAccessor(PageObject, "cropBox", "/CropBox", ("/MediaBox",), 
     490        """A rectangle, expressed in default user space units, defining the 
     491        visible region of default user space.  When the page is displayed or 
     492        printed, its contents are to be clipped (cropped) to this rectangle and 
     493        then imposed on the output medium in some implementation-defined 
     494        manner.  Default value: same as MediaBox. 
     495 
     496        Stability: Added in v1.4, will exist for all v1.x releases 
     497        thereafter.""") 
     498addRectangleAccessor(PageObject, "bleedBox", "/BleedBox", ("/CropBox", 
     499        "/MediaBox"), """A rectangle, expressed in default user space units, 
     500        defining the region to which the contents of the page should be clipped 
     501        when output in a production environment. 
     502         
     503        Stability: Added in v1.4, will exist for all v1.x releases 
     504        thereafter.""") 
     505addRectangleAccessor(PageObject, "trimBox", "/TrimBox", ("/CropBox", 
     506        "/MediaBox"), """A rectangle, expressed in default user space units, 
     507        defining the intended dimensions of the finished page after trimming. 
     508         
     509        Stability: Added in v1.4, will exist for all v1.x releases 
     510        thereafter.""") 
     511addRectangleAccessor(PageObject, "artBox", "/ArtBox", ("/CropBox", 
     512        "/MediaBox"), """A rectangle, expressed in default user space units, 
     513        defining the extent of the page's meaningful content as intended by the 
     514        page's creator. 
     515         
     516        Stability: Added in v1.4, will exist for all v1.x releases 
     517        thereafter.""") 
     518 
     519 
     520class ContentStream(DictionaryObject): 
     521    def __init__(self, stream): 
     522        self.operations = [] 
     523        self.__parseContentStream(stream) 
     524 
     525    def __parseContentStream(self, stream): 
     526        stream = StringIO(filters.decodeStreamData(stream)) 
     527        operands = [] 
     528        while True: 
     529            peek = readNonWhitespace(stream) 
     530            if peek == '': 
     531                break 
     532            stream.seek(-1, 1) 
     533            if peek.isalpha(): 
     534                operator = readUntilWhitespace(stream) 
     535                self.operations.append((operands, operator)) 
     536                operands = [] 
     537                print self.operations[-1] 
     538            else: 
     539                operands.append(readObject(stream, None)) 
    447540 
    448541 
    …… 
    467560    #output.addPage(input1.getPage(0)) 
    468561 
    469     input2 = PdfFileReader(file("plik2.pdf", "rb")) 
    470     for i in range(input2.getNumPages()): 
    471         output.addPage(input2.getPage(i).testOperation(input2)) 
    472      
     562    input2 = PdfFileReader(file("..\\test\\5000-s1-05e.pdf", "rb")) 
     563    page = input2.getPage(1) 
     564    page.cropBox.upperRight = (200, 200) 
     565    print repr(page.cropBox) 
     566    page.cropBox = RectangleObject((20, 20, 40, 40)) 
     567    print repr(page.cropBox) 
     568    del page.cropBox 
     569    print repr(page.cropBox) 
     570    #contents = input2.getObject(page["/Contents"]) 
     571    #contentStream = ContentStream(contents) 
     572    #for operands,operator in contentStream.operations: 
     573    #    for operand in operands: 
     574    #        if isinstance(operand, NameObject): 
     575    #            print "name object" 
     576 
     577    output.addPage(page) 
    473578    output.write(file("test.pdf", "wb")) 
    474579 
     580