Show
Ignore:
Timestamp:
10/06/08 00:22:07 (16 years ago)
Author:
jerome
Message:

Removed spaces at EOL.

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • pkpgcounter/trunk/pkpgpdls/pclxl.py

    r3409 r3436  
    88# the Free Software Foundation, either version 3 of the License, or 
    99# (at your option) any later version. 
    10 #  
     10# 
    1111# This program is distributed in the hope that it will be useful, 
    1212# but WITHOUT ANY WARRANTY; without even the implied warranty of 
    1313# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1414# GNU General Public License for more details. 
    15 #  
     15# 
    1616# You should have received a copy of the GNU General Public License 
    1717# along with this program.  If not, see <http://www.gnu.org/licenses/>. 
    … …  
    3232class Parser(pdlparser.PDLParser) : 
    3333    """A parser for PCLXL (aka PCL6) documents.""" 
    34     totiffcommands = [ 'pcl6 -sDEVICE=pdfwrite -r"%(dpi)i" -dPARANOIDSAFER -dNOPAUSE -dBATCH -dQUIET -sOutputFile=- "%(infname)s" | gs -sDEVICE=tiff24nc -dPARANOIDSAFER -dNOPAUSE -dBATCH -dQUIET -r"%(dpi)i" -sOutputFile="%(outfname)s" -',  
     34    totiffcommands = [ 'pcl6 -sDEVICE=pdfwrite -r"%(dpi)i" -dPARANOIDSAFER -dNOPAUSE -dBATCH -dQUIET -sOutputFile=- "%(infname)s" | gs -sDEVICE=tiff24nc -dPARANOIDSAFER -dNOPAUSE -dBATCH -dQUIET -r"%(dpi)i" -sOutputFile="%(outfname)s" -', 
    3535                       'pcl6 -sDEVICE=pswrite -r"%(dpi)i" -dPARANOIDSAFER -dNOPAUSE -dBATCH -dQUIET -sOutputFile=- "%(infname)s" | gs -sDEVICE=tiff24nc -dPARANOIDSAFER -dNOPAUSE -dBATCH -dQUIET -r"%(dpi)i" -sOutputFile="%(outfname)s" -', 
    3636                     ] 
    3737    required = [ "pcl6", "gs" ] 
    3838    format = "PCLXL (aka PCL6)" 
    39     mediasizes = {  
     39    mediasizes = { 
    4040                    0 : "Letter", 
    4141                    1 : "Legal", 
    … …  
    6161                    21 : "JISExec", 
    6262                    96 : "Default", 
    63                  }    
    64                   
    65     mediasources = {              
     63                 } 
     64 
     65    mediasources = { 
    6666                     0 : "Default", 
    6767                     1 : "Auto", 
    … …  
    7373                     7 : "ThirdCassette", 
    7474                   } 
    75                     
    76     orientations = {                
     75 
     76    orientations = { 
    7777                     0 : "Portrait", 
    7878                     1 : "Landscape", 
    … …  
    8181                     4 : "Default", 
    8282                   } 
    83              
    84     def isValid(self) :     
     83 
     84    def isValid(self) : 
    8585        """Returns True if data is HP PCLXL aka PCL6, or Brother's' XL2HB, else False.""" 
    8686        if (((self.firstblock[:128].find("\033%-12345X") != -1) and \ 
    … …  
    9494            self.format = "XL2HB" 
    9595            return True 
    96         else :     
     96        else : 
    9797            return False 
    98              
     98 
    9999    def beginPage(self, nextpos) : 
    100100        """Indicates the beginning of a new page, and extracts media information.""" 
    101101        # self.logdebug("BeginPage at %x" % nextpos) 
    102102        self.pagecount += 1 
    103          
     103 
    104104        # Default values 
    105105        mediatypelabel = "Plain" 
    … …  
    108108        orientationlabel = "Portrait" 
    109109        duplexmode = None 
    110          
     110 
    111111        # Now go upstream to decode media type, size, source, and orientation 
    112112        # this saves time because we don't need a complete parser ! 
    … …  
    117117            if val in (0x44, 0x48, 0x41) : # if previous endPage or openDataSource or beginSession (first page) 
    118118                break 
    119             if val == 0x26 :     
     119            if val == 0x26 : 
    120120                mediasource = ord(minfile[pos - 2]) 
    121121                mediasourcelabel = self.mediasources.get(mediasource, str(mediasource)) 
    … …  
    132132                        mediasizelabel = minfile[pos+2:pos+2+arraylength].title() 
    133133                        pos -= 1 
    134                     else :     
     134                    else : 
    135135                        # if we just found an ubyte, then the media 
    136136                        # size is known by its index 
    137137                        mediasize = ord(minfile[pos+1]) 
    138138                        mediasizelabel = self.mediasizes.get(mediasize, str(mediasize)) 
    139                     pos -= 1  
     139                    pos -= 1 
    140140                    # self.logdebug("Media size : %s" % mediasizelabel) 
    141             elif val == 0x28 :     
     141            elif val == 0x28 : 
    142142                orientation = ord(minfile[pos - 2]) 
    143143                orientationlabel = self.orientations.get(orientation, str(orientation)) 
    144144                pos -= 4 
    145             elif val == 0x27 :     
     145            elif val == 0x27 : 
    146146                savepos = pos 
    147147                pos -= 1 
    148                 startpos = size = None  
     148                startpos = size = None 
    149149                while pos > 0 : # safety check : don't go back to far ! 
    150150                    val = ord(minfile[pos]) 
    151                     pos -= 1     
     151                    pos -= 1 
    152152                    if val == 0xc8 : 
    153153                        length = self.tags[ord(minfile[pos+2])] # will probably always be a byte or uint16 
    154                         if length == 1 :     
     154                        if length == 1 : 
    155155                            startpos = pos + 4 
    156156                            size = unpack("B", self.minfile[pos+3:startpos])[0] 
    157                         elif length == 2 :     
     157                        elif length == 2 : 
    158158                            startpos = pos + 5 
    159159                            size = unpack(self.unpackShort, self.minfile[pos+3:startpos])[0] 
    160                         elif length == 4 :     
     160                        elif length == 4 : 
    161161                            startpos = pos + 7 
    162162                            size = unpack(self.unpackLong, self.minfile[pos+3:startpos])[0] 
    163                         else :     
     163                        else : 
    164164                            raise pdlparser.PDLParserError, "Error on size at %s : %s" % (pos+2, length) 
    165165                        break 
    166166                mediatypelabel = minfile[startpos:startpos+size] 
    167167                # self.logdebug("Media type : %s" % mediatypelabel) 
    168             elif val == 0x34 :     
     168            elif val == 0x34 : 
    169169                duplexmode = "Simplex" 
    170170                pos -= 2 
    171             elif val in (0x35, 0x36) :     
     171            elif val in (0x35, 0x36) : 
    172172                duplexmode = "Duplex" 
    173173                pos -= 2 
    174             # else : TODO : CUSTOM MEDIA SIZE AND UNIT !  
    175             else :     
     174            # else : TODO : CUSTOM MEDIA SIZE AND UNIT ! 
     175            else : 
    176176                pos -= 1  # ignored 
    177         self.pages[self.pagecount] = { "copies" : 1,  
    178                                        "orientation" : orientationlabel,  
    179                                        "mediatype" : mediatypelabel,  
     177        self.pages[self.pagecount] = { "copies" : 1, 
     178                                       "orientation" : orientationlabel, 
     179                                       "mediatype" : mediatypelabel, 
    180180                                       "mediasize" : mediasizelabel, 
    181181                                       "mediasource" : mediasourcelabel, 
    182182                                       "duplex" : duplexmode, 
    183                                      }  
     183                                     } 
    184184        return 0 
    185          
    186     def endPage(self, nextpos) :     
     185 
     186    def endPage(self, nextpos) : 
    187187        """Indicates the end of a page.""" 
    188188        # self.logdebug("EndPage at %x" % nextpos) 
    … …  
    198198                # self.logdebug("Number of copies : %i" % nbcopies) 
    199199                self.pages[self.pagecount]["copies"] = nbcopies 
    200             except KeyError :     
     200            except KeyError : 
    201201                self.logdebug("It looks like this PCLXL file is corrupted.") 
    202202        return 0 
    203          
    204     def setColorSpace(self, nextpos) :     
     203 
     204    def setColorSpace(self, nextpos) : 
    205205        """Changes the color space.""" 
    206206        if self.minfile[nextpos-4:nextpos-1] == self.RGBColorSpace : # TODO : doesn't seem to handle all cases ! 
    207207            self.iscolor = True 
    208208        return 0 
    209              
     209 
    210210    def array_Generic(self, nextpos, size) : 
    211211        """Handles all arrays.""" 
    … …  
    220220        except KeyError : 
    221221            raise pdlparser.PDLParserError, "Error on array size at %x" % nextpos 
    222              
    223     def array_8(self, nextpos) :     
     222 
     223    def array_8(self, nextpos) : 
    224224        """Handles byte arrays.""" 
    225225        return self.array_Generic(nextpos, 1) 
    226          
     226 
    227227    def array_16(self, nextpos) : 
    228228        """Handles 16 bits arrays.""" 
    229229        return self.array_Generic(nextpos, 2) 
    230          
     230 
    231231    def array_32(self, nextpos) : 
    232232        """Handles 32 bits arrays and Canon ImageRunner tags.""" 
    … …  
    243243                toskip += length 
    244244            # self.logdebug("Canon ImageRunner skip until %x" % (nextpos+toskip)) 
    245             return toskip     
     245            return toskip 
    246246        else : 
    247247            # This is a normal PCLXL array 
    248248            return self.array_Generic(nextpos, 4) 
    249          
     249 
    250250    def embeddedDataSmall(self, nextpos) : 
    251251        """Handle small amounts of data.""" 
    252252        return 1 + ord(self.minfile[nextpos]) 
    253          
     253 
    254254    def embeddedData(self, nextpos) : 
    255255        """Handle normal amounts of data.""" 
    256256        return 4 + unpack(self.unpackLong, self.minfile[nextpos:nextpos+4])[0] 
    257          
    258     def skipHPPCLXL(self, nextpos) :     
     257 
     258    def skipHPPCLXL(self, nextpos) : 
    259259        """Skip the 'HP-PCL XL' statement if needed.""" 
    260260        minfile = self.minfile 
    … …  
    265265            while minfile[pos] != '\n' : 
    266266                pos += 1 
    267             length = (pos - nextpos + 1)     
    268             # self.logdebug("Skip HP PCLXL statement until %x" % (nextpos + length))   
     267            length = (pos - nextpos + 1) 
     268            # self.logdebug("Skip HP PCLXL statement until %x" % (nextpos + length)) 
    269269            return length 
    270         else :     
     270        else : 
    271271            return 0 
    272          
     272 
    273273    def littleEndian(self, nextpos) : 
    274274        """Toggles to little endianness.""" 
    … …  
    278278        # self.logdebug("LittleEndian at %x" % (nextpos - 1)) 
    279279        return self.skipHPPCLXL(nextpos) 
    280          
     280 
    281281    def bigEndian(self, nextpos) : 
    282282        """Toggles to big endianness.""" 
    … …  
    286286        # self.logdebug("BigEndian at %x" % (nextpos - 1)) 
    287287        return self.skipHPPCLXL(nextpos) 
    288      
     288 
    289289    def reservedForFutureUse(self, nextpos) : 
    290290        """Outputs something when a reserved byte is encountered.""" 
    291291        self.logdebug("Byte at %x is out of the PCLXL Protocol Class 2.0 Specification" % nextpos) 
    292         return 0     
    293          
     292        return 0 
     293 
    294294    def x46_class3(self, nextpos) : 
    295295        """Undocumented tag 0x46 in class 3.0 streams.""" 
    … …  
    301301            try : 
    302302                offset = self.x46_functions[funcid] 
    303             except KeyError :     
     303            except KeyError : 
    304304                self.logdebug("Unexpected subfunction 0x%02x for undocumented tag 0x46 at %x" % (funcid, nextpos)) 
    305305                break 
    306             else :     
     306            else : 
    307307                pos -= offset 
    308308                length = self.tags[ord(self.minfile[pos])] 
    … …  
    315315                        raise pdlparser.PDLParserError, "Error on size '%s' at %x" % (length, pos+1) 
    316316            val = ord(minfile[pos]) 
    317         return 0     
    318          
    319     def escape(self, nextpos) :     
     317        return 0 
     318 
     319    def escape(self, nextpos) : 
    320320        """Handles the ESC code.""" 
    321321        pos = endpos = nextpos 
    … …  
    331331                    quotes += 1 
    332332                endpos += 1 
    333                  
    334             # Store this in a per page mapping.     
     333 
     334            # Store this in a per page mapping. 
    335335            # NB : First time will be at page 0 (i.e. **before** page 1) ! 
    336336            stuff = self.escapedStuff.setdefault(self.pagecount, []) 
    … …  
    338338            self.logdebug("Escaped datas : [%s]" % repr(minfile[pos : endpos])) 
    339339        return endpos - pos 
    340          
     340 
    341341    def skipKyoceraPrescribe(self, nextpos) : 
    342342        """Skips Kyocera Prescribe commands.""" 
    … …  
    351351                    self.logdebug("Prescribe commands : [%s]" % repr(minfile[nextpos-1:pos])) 
    352352                    break 
    353                 pos += 1     
     353                pos += 1 
    354354            return (pos - nextpos) 
    355355        else : 
    356356            return 0 
    357              
     357 
    358358    def getJobSize(self) : 
    359359        """Counts pages in a PCLXL (PCL6) document. 
    360          
     360 
    361361           Algorithm by Jerome Alet. 
    362             
     362 
    363363           The documentation used for this was : 
    364           
     364 
    365365           HP PCL XL Feature Reference 
    366366           Protocol Class 2.0 
    367            http://www.hpdevelopersolutions.com/downloads/64/358/xl_ref20r22.pdf  
    368             
     367           http://www.hpdevelopersolutions.com/downloads/64/358/xl_ref20r22.pdf 
     368 
    369369           Protocol Class 2.1 Supplement 
    370370           xl_ref21.pdf 
    371             
     371 
    372372           Protocol Class 3.0 Supplement 
    373373           xl_refsup30r089.pdf 
    374374        """ 
    375          
     375 
    376376        infileno = self.infile.fileno() 
    377377        self.minfile = minfile = mmap.mmap(infileno, os.fstat(infileno)[6], prot=mmap.PROT_READ, flags=mmap.MAP_SHARED) 
    378          
     378 
    379379        self.iscolor = False 
    380          
     380 
    381381        found = False 
    382382        while not found : 
    … …  
    392392                if endian == 0x29 : 
    393393                    self.littleEndian(0) 
    394                 elif endian == 0x28 :     
     394                elif endian == 0x28 : 
    395395                    self.bigEndian(0) 
    396396                # elif endian == 0x27 : # TODO : This is the ASCII binding code : what does it do exactly ? 
    397                 #  
    398                 else :     
     397                # 
     398                else : 
    399399                    raise pdlparser.PDLParserError, "Unknown endianness marker 0x%02x at start !" % endian 
    400400        if not found : 
    401401            raise pdlparser.PDLParserError, "This file doesn't seem to be PCLXL (aka PCL6)" 
    402              
     402 
    403403        # Initialize Media Sources 
    404404        for i in range(8, 256) : 
    405405            self.mediasources[i] = "ExternalTray%03i" % (i - 7) 
    406              
     406 
    407407        # Initialize table of tags 
    408         self.tags = [ 0 ] * 256     
    409          
     408        self.tags = [ 0 ] * 256 
     409 
    410410        self.tags[0x1b] = self.escape # The escape code 
    411          
     411 
    412412        self.tags[0x21] = self.skipKyoceraPrescribe # 0x21 is not normally used 
    413          
     413 
    414414        # GhostScript's sources tell us that HP printers 
    415415        # only accept little endianness, but we can handle both. 
    416416        self.tags[0x28] = self.bigEndian    # BigEndian 
    417417        self.tags[0x29] = self.littleEndian # LittleEndian 
    418          
     418 
    419419        self.tags[0x43] = self.beginPage    # BeginPage 
    420420        self.tags[0x44] = self.endPage      # EndPage 
    421421        self.tags[0x45] = self.reservedForFutureUse # reserved 
    422          
    423         self.tags[0x46] = self.x46_class3  
    424          
     422 
     423        self.tags[0x46] = self.x46_class3 
     424 
    425425        self.tags[0x4a] = self.reservedForFutureUse # reserved 
    426426        self.tags[0x4b] = self.reservedForFutureUse # reserved 
    … …  
    428428        self.tags[0x4d] = self.reservedForFutureUse # reserved 
    429429        self.tags[0x4e] = self.reservedForFutureUse # reserved 
    430          
     430 
    431431        self.tags[0x56] = self.reservedForFutureUse # TODO : documentation not clear about reserved status 
    432          
     432 
    433433        self.tags[0x57] = self.reservedForFutureUse # reserved 
    434          
     434 
    435435        self.tags[0x59] = self.reservedForFutureUse # reserved 
    436436        self.tags[0x5a] = self.reservedForFutureUse # reserved 
    437          
     437 
    438438        self.tags[0x6a] = self.setColorSpace    # to detect color/b&w mode 
    439          
     439 
    440440        self.tags[0x87] = self.reservedForFutureUse # reserved 
    441441        self.tags[0x88] = self.reservedForFutureUse # reserved 
    442442        self.tags[0x89] = self.reservedForFutureUse # reserved 
    443443        self.tags[0x8a] = self.reservedForFutureUse # reserved 
    444          
     444 
    445445        self.tags[0x8b] = self.reservedForFutureUse # reserved 
    446          
     446 
    447447        self.tags[0x8c] = self.reservedForFutureUse # reserved 
    448448        self.tags[0x8d] = self.reservedForFutureUse # reserved 
    … …  
    450450        self.tags[0x8f] = self.reservedForFutureUse # reserved 
    451451        self.tags[0x90] = self.reservedForFutureUse # reserved 
    452          
     452 
    453453        self.tags[0x9a] = self.reservedForFutureUse # reserved 
    454454        self.tags[0x9c] = self.reservedForFutureUse # reserved 
    455          
     455 
    456456        self.tags[0xa4] = self.reservedForFutureUse # reserved 
    457457        self.tags[0xa5] = self.reservedForFutureUse # reserved 
    458458        self.tags[0xa6] = self.reservedForFutureUse # reserved 
    459459        self.tags[0xa7] = self.reservedForFutureUse # reserved 
    460          
     460 
    461461        self.tags[0xaa] = self.reservedForFutureUse # reserved 
    462462        self.tags[0xab] = self.reservedForFutureUse # reserved 
    … …  
    465465        self.tags[0xae] = self.reservedForFutureUse # reserved 
    466466        self.tags[0xaf] = self.reservedForFutureUse # reserved 
    467          
     467 
    468468        self.tags[0xb7] = self.reservedForFutureUse # reserved 
    469          
     469 
    470470        self.tags[0xba] = self.reservedForFutureUse # reserved 
    471471        self.tags[0xbb] = self.reservedForFutureUse # reserved 
    … …  
    473473        self.tags[0xbd] = self.reservedForFutureUse # reserved 
    474474        self.tags[0xbe] = self.reservedForFutureUse # reserved 
    475          
     475 
    476476        # self.tags[0xbf] = self.passThrough # PassThrough mode should already be taken care of automatically 
    477          
     477 
    478478        self.tags[0xc0] = 1 # ubyte 
    479479        self.tags[0xc1] = 2 # uint16 
    … …  
    482482        self.tags[0xc4] = 4 # sint32 
    483483        self.tags[0xc5] = 4 # real32 
    484          
     484 
    485485        self.tags[0xc6] = self.reservedForFutureUse # reserved 
    486486        self.tags[0xc7] = self.reservedForFutureUse # reserved 
    487          
     487 
    488488        self.tags[0xc8] = self.array_8  # ubyte_array 
    489489        self.tags[0xc9] = self.array_16 # uint16_array 
    … …  
    492492        self.tags[0xcc] = self.array_32 # sint32_array 
    493493        self.tags[0xcd] = self.array_32 # real32_array and unfortunately Canon ImageRunner 
    494          
     494 
    495495        self.tags[0xce] = self.reservedForFutureUse # reserved 
    496496        self.tags[0xcf] = self.reservedForFutureUse # reserved 
    497          
     497 
    498498        self.tags[0xd0] = 2 # ubyte_xy 
    499499        self.tags[0xd1] = 4 # uint16_xy 
    … …  
    512512        self.tags[0xde] = self.reservedForFutureUse # reserved 
    513513        self.tags[0xdf] = self.reservedForFutureUse # reserved 
    514          
     514 
    515515        self.tags[0xe0] = 4  # ubyte_box 
    516516        self.tags[0xe1] = 8  # uint16_box 
    … …  
    529529        self.tags[0xee] = self.reservedForFutureUse # reserved 
    530530        self.tags[0xef] = self.reservedForFutureUse # reserved 
    531          
     531 
    532532        self.tags[0xf0] = self.reservedForFutureUse # reserved 
    533533        self.tags[0xf1] = self.reservedForFutureUse # reserved 
    … …  
    538538        self.tags[0xf6] = self.reservedForFutureUse # reserved 
    539539        self.tags[0xf7] = self.reservedForFutureUse # reserved 
    540          
     540 
    541541        self.tags[0xf8] = 1 # attr_ubyte 
    542542        self.tags[0xf9] = 2 # attr_uint16 
    543          
     543 
    544544        self.tags[0xfa] = self.embeddedData      # dataLength 
    545545        self.tags[0xfb] = self.embeddedDataSmall # dataLengthByte 
    546          
     546 
    547547        self.tags[0xfc] = self.reservedForFutureUse # reserved 
    548548        self.tags[0xfd] = self.reservedForFutureUse # reserved 
    549549        self.tags[0xfe] = self.reservedForFutureUse # reserved 
    550550        self.tags[0xff] = self.reservedForFutureUse # reserved 
    551              
    552         # color spaces     
     551 
     552        # color spaces 
    553553        self.BWColorSpace = "".join([chr(0x00), chr(0xf8), chr(0x03)]) 
    554554        self.GrayColorSpace = "".join([chr(0x01), chr(0xf8), chr(0x03)]) 
    555555        self.RGBColorSpace = "".join([chr(0x02), chr(0xf8), chr(0x03)]) 
    556          
     556 
    557557        # set number of copies 
    558         self.setNumberOfCopies = "".join([chr(0xf8), chr(0x31)])  
    559          
     558        self.setNumberOfCopies = "".join([chr(0xf8), chr(0x31)]) 
     559 
    560560        # subcodes for undocumented tag 0x46 and the negative 
    561561        # offset to grab the value from. 
    … …  
    569569                               0x98 : 2, 
    570570                             } 
    571                               
     571 
    572572        # Markers for Canon ImageRunner printers 
    573573        self.imagerunnermarker1 = chr(0xcd) + chr(0xca) + chr(0x10) + chr(0x00) 
    574574        self.imagerunnermarker2 = chr(0xcd) + chr(0xca) + chr(0x10) + chr(0x02) 
    575                               
    576         self.pages = { 0 : { "copies" : 1,  
    577                              "orientation" : "Default",  
    578                              "mediatype" : "Plain",  
    579                              "mediasize" : "Default",  
    580                              "mediasource" : "Default",  
     575 
     576        self.pages = { 0 : { "copies" : 1, 
     577                             "orientation" : "Default", 
     578                             "mediatype" : "Plain", 
     579                             "mediasize" : "Default", 
     580                             "mediasource" : "Default", 
    581581                             "duplex" : None, 
    582                            }  
    583                      }       
     582                           } 
     583                     } 
    584584        tags = self.tags 
    585585        self.pagecount = 0 
    … …  
    592592                    try : 
    593593                        tag = ord(minfile[pos]) 
    594                     except OverflowError :     
     594                    except OverflowError : 
    595595                        pos = oldpos + 1 
    596596                    pos += 1 
    597597                    length = tags[tag] 
    598598                    if length : 
    599                         if callable(length) :     
     599                        if callable(length) : 
    600600                            length = length(pos) 
    601                         oldpos = pos     
    602                         pos += length     
    603             except IndexError : # EOF ?             
     601                        oldpos = pos 
     602                        pos += length 
     603            except IndexError : # EOF ? 
    604604                pass 
    605605        finally : 
    606606            self.minfile.close() 
    607              
     607 
    608608        # now handle number of copies for each page (may differ). 
    609609        if self.iscolor : 
    610610            colormode = "Color" 
    611         else :     
     611        else : 
    612612            colormode = "BW" 
    613              
     613 
    614614        defaultduplexmode = "Simplex" 
    615615        defaultpapersize = "" 
    616         defaultpjlcopies = 1     
     616        defaultpjlcopies = 1 
    617617        oldpjlcopies = -1 
    618618        oldduplexmode = "" 
    … …  
    622622            # in PCLXL documentation. 
    623623            # NB : is number of copies is 0, the page won't be output 
    624             # but the formula below is still correct : we want  
     624            # but the formula below is still correct : we want 
    625625            # to decrease the total number of pages in this case. 
    626626            page = self.pages.get(pnum, self.pages.get(1, { "copies" : 1, "mediasize" : "Default", "duplex" : None })) 
    … …  
    641641                    pjlcopies = nbqty 
    642642                else : 
    643                     if oldpjlcopies == -1 :     
     643                    if oldpjlcopies == -1 : 
    644644                        pjlcopies = defaultpjlcopies 
    645                     else :     
    646                         pjlcopies = oldpjlcopies     
    647                 if page["duplex"] :         
     645                    else : 
     646                        pjlcopies = oldpjlcopies 
     647                if page["duplex"] : 
    648648                    duplexmode = page["duplex"] 
    649                 else :     
     649                else : 
    650650                    defaultdm = pjlparser.default_variables.get("DUPLEX", "") 
    651651                    if defaultdm : 
    652652                        if defaultdm.upper() == "ON" : 
    653653                            defaultduplexmode = "Duplex" 
    654                         else :     
     654                        else : 
    655655                            defaultduplexmode = "Simplex" 
    656656                    envdm = pjlparser.environment_variables.get("DUPLEX", "") 
    … …  
    658658                        if envdm.upper() == "ON" : 
    659659                            duplexmode = "Duplex" 
    660                         else :     
     660                        else : 
    661661                            duplexmode = "Simplex" 
    662                     else :         
     662                    else : 
    663663                        if not oldduplexmode : 
    664664                            duplexmode = defaultduplexmode 
    665                         else :     
     665                        else : 
    666666                            duplexmode = oldduplexmode 
    667667                defaultps = pjlparser.default_variables.get("PAPER", "") 
    … …  
    671671                if envps : 
    672672                    papersize = envps 
    673                 else :     
     673                else : 
    674674                    if not oldpapersize : 
    675675                        papersize = defaultpapersize 
    676                     else :     
     676                    else : 
    677677                        papersize = oldpapersize 
    678             else :         
     678            else : 
    679679                if oldpjlcopies == -1 : 
    680680                    pjlcopies = defaultpjlcopies 
    681                 else :     
     681                else : 
    682682                    pjlcopies = oldpjlcopies 
    683683                if not oldduplexmode : 
    684684                    duplexmode = defaultduplexmode 
    685                 else :     
     685                else : 
    686686                    duplexmode = oldduplexmode 
    687                 if not oldpapersize :     
     687                if not oldpapersize : 
    688688                    papersize = defaultpapersize 
    689                 else :     
     689                else : 
    690690                    papersize = oldpapersize 
    691691                duplexmode = oldduplexmode 
    … …  
    693693            if page["mediasize"] != "Default" : 
    694694                papersize = page["mediasize"] 
    695             if not duplexmode :     
     695            if not duplexmode : 
    696696                duplexmode = oldduplexmode or defaultduplexmode 
    697             oldpjlcopies = pjlcopies     
     697            oldpjlcopies = pjlcopies 
    698698            oldduplexmode = duplexmode 
    699699            oldpapersize = papersize 
    700700            copies = max(pjlcopies, page["copies"]) # Was : pjlcopies * page["copies"] 
    701701            self.pagecount += (copies - 1) 
    702             self.logdebug("%s*%s*%s*%s*%s*%s*%s" % (copies,  
    703                                                  page["mediatype"],  
    704                                                  papersize,  
    705                                                  page["orientation"],  
    706                                                  page["mediasource"],  
    707                                                  duplexmode,  
     702            self.logdebug("%s*%s*%s*%s*%s*%s*%s" % (copies, 
     703                                                 page["mediatype"], 
     704                                                 papersize, 
     705                                                 page["orientation"], 
     706                                                 page["mediasource"], 
     707                                                 duplexmode, 
    708708                                                 colormode)) 
    709709        return self.pagecount