← Back to branch summary

~ubuntu-branches/ubuntu/quantal/openerp6.1/quantal-proposed

« back to all changes in this revision

Viewing changes to openerp/addons/auction/barcode/common.py

  • Committer: Package Import Robot
  • Author(s): Yolanda Robla
  • Date: 2012-09-20 15:29:00 UTC
  • Revision ID: package-import@ubuntu.com-20120920152900-woyy3yww8z6acmsk
Tags: upstream-6.1-1+dfsg
Import upstream version 6.1-1+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
openerp/addons/auction/barcode/common.py
 
1
# -*- coding: utf-8 -*-
 
2
#
 
3
# Copyright (c) 1996-2000 Tyler C. Sarna <tsarna@sarna.org>
 
4
# All rights reserved.
 
5
#
 
6
# Redistribution and use in source and binary forms, with or without
 
7
# modification, are permitted provided that the following conditions
 
8
# are met:
 
9
# 1. Redistributions of source code must retain the above copyright
 
10
#    notice, this list of conditions and the following disclaimer.
 
11
# 2. Redistributions in binary form must reproduce the above copyright
 
12
#    notice, this list of conditions and the following disclaimer in the
 
13
#    documentation and/or other materials provided with the distribution.
 
14
# 3. All advertising materials mentioning features or use of this software
 
15
#    must display the following acknowledgement:
 
16
#      This product includes software developed by Tyler C. Sarna.
 
17
# 4. Neither the name of the author nor the names of contributors
 
18
#    may be used to endorse or promote products derived from this software
 
19
#    without specific prior written permission.
 
20
#
 
21
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 
22
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
23
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 
24
# PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 
25
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 
26
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 
27
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 
28
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 
29
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 
30
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 
31
# POSSIBILITY OF SUCH DAMAGE.
 
32
#
 
33
 
 
34
from reportlab.platypus.flowables import Flowable
 
35
from reportlab.lib.units import inch
 
36
import string
 
37
 
 
38
class Barcode(Flowable):
 
39
    """Abstract Base for barcodes. Includes implementations of
 
40
    some methods suitable for the more primitive barcode types"""
 
41
    
 
42
    def __init__(self, value = ''):
 
43
        self.value = value
 
44
        
 
45
        if not hasattr(self, 'gap'):
 
46
            self.gap = None
 
47
            
 
48
        self.validate()
 
49
        self.encode()
 
50
        #print self.encoded
 
51
        self.decompose()
 
52
        #print self.decomposed
 
53
        self.computeSize()
 
54
 
 
55
    def validate(self):
 
56
        self.valid = 1
 
57
        self.validated = self.value
 
58
 
 
59
    def encode(self):
 
60
        self.encoded = self.validated
 
61
 
 
62
    def decompose(self):
 
63
        self.decomposed = self.encoded
 
64
 
 
65
    def computeSize(self, *args):
 
66
        xdim = self.xdim
 
67
        wx = xdim * self.ratio
 
68
 
 
69
        if self.gap == None:
 
70
            self.gap = xdim
 
71
            
 
72
        w = 0.0
 
73
        
 
74
        for c in self.decomposed:
 
75
            if c in 'sb':
 
76
                w = w + xdim
 
77
            elif c in 'SB':
 
78
                w = w + wx
 
79
            else: # 'i'
 
80
                w = w + self.gap
 
81
    
 
82
        if self.height is None:
 
83
            self.height = w * 0.15
 
84
            self.height = max(0.25 * inch, self.height)
 
85
            if self.bearers:
 
86
                self.height = self.height + self.bearers * 2.0 * xdim
 
87
 
 
88
        if self.quiet:
 
89
            w = w + self.lquiet + self.rquiet
 
90
            self.xo = self.lquiet
 
91
        else:
 
92
            self.xo = 0.0
 
93
            
 
94
        self.width = w
 
95
 
 
96
    def draw(self):
 
97
        xdim = self.xdim
 
98
        wx = xdim * self.ratio
 
99
    
 
100
        left = self.xo
 
101
        b = self.bearers * xdim
 
102
        bb = b * 0.5
 
103
        tb = self.height - (b * 1.5)
 
104
 
 
105
        for c in self.decomposed:
 
106
            if c == 'i':
 
107
                left = left + self.gap
 
108
            elif c == 's':
 
109
                left = left + xdim
 
110
            elif c == 'S':
 
111
                left = left + wx
 
112
            elif c == 'b':
 
113
                self.rect(left, bb, xdim, tb)
 
114
                left = left + xdim
 
115
            elif c == 'B':
 
116
                self.rect(left, bb, wx, tb)
 
117
                left = left + wx
 
118
                
 
119
        if self.bearers:
 
120
            self.rect(self.lquiet, 0.0, \
 
121
                self.width - (self.lquiet + self.rquiet), b)
 
122
            self.rect(self.lquiet, self.height - b, \
 
123
                self.width - (self.lquiet + self.rquiet), b)
 
124
 
 
125
    def rect(self, x, y, w, h):
 
126
        self.canv.rect(x, y, w, h, stroke=0, fill=1)
 
127
 
 
128
 
 
129
class MultiWidthBarcode(Barcode):
 
130
    """Base for variable-bar-width codes like Code93 and Code128"""
 
131
    
 
132
    def computeSize(self, *args):
 
133
        xdim = self.xdim
 
134
        oa, oA = ord('a') - 1, ord('A') - 1
 
135
 
 
136
        w = 0.0
 
137
        
 
138
        for c in self.decomposed:
 
139
            oc = ord(c)
 
140
            if c in string.lowercase:
 
141
                w = w + xdim * (oc - oa)
 
142
            elif c in string.uppercase:
 
143
                w = w + xdim * (oc - oA)
 
144
    
 
145
        if self.height is None:
 
146
            self.height = w * 0.15
 
147
            self.height = max(0.25 * inch, self.height)
 
148
 
 
149
        if self.quiet:
 
150
            w = w + self.lquiet + self.rquiet
 
151
            self.xo = self.lquiet
 
152
        else:
 
153
            self.xo = 0.0
 
154
            
 
155
        self.width = w
 
156
 
 
157
    def draw(self):
 
158
        oa, oA = ord('a') - 1, ord('A') - 1
 
159
        xdim = self.xdim
 
160
        left = self.xo
 
161
 
 
162
        for c in self.decomposed:
 
163
            oc = ord(c)
 
164
            if c in string.lowercase:
 
165
                left = left + (oc - oa) * xdim
 
166
            elif c in string.uppercase:
 
167
                w = (oc - oA) * xdim
 
168
                self.rect(left, 0.0, w, self.height)
 
169
                left = left + w
 
170
 
 
171
 
 
172
class I2of5(Barcode):
 
173
    """
 
174
    Interleaved 2 of 5 is a numeric-only barcode.  It encodes an even
 
175
    number of digits; if an odd number is given, a 0 is prepended.
 
176
 
 
177
    Options that may be passed to constructor:
 
178
 
 
179
        value (int, or numeric string. required.):
 
180
            The value to encode.
 
181
   
 
182
        xdim (float, default .0075):
 
183
            X-Dimension, or width of the smallest element
 
184
            Minumum is .0075 inch (7.5 mils).
 
185
            
 
186
        ratio (float, default 2.2):
 
187
            The ratio of wide elements to narrow elements.
 
188
            Must be between 2.0 and 3.0 (or 2.2 and 3.0 if the
 
189
            xdim is greater than 20 mils (.02 inch))
 
190
            
 
191
        gap (float or None, default None):
 
192
            width of intercharacter gap. None means "use xdim".
 
193
        
 
194
        height (float, see default below):
 
195
            Height of the symbol.  Default is the height of the two
 
196
            bearer bars (if they exist) plus the greater of .25 inch
 
197
            or .15 times the symbol's length.
 
198
 
 
199
        checksum (bool, default 1):
 
200
            Wether to compute and include the check digit
 
201
            
 
202
        bearers (float, in units of xdim. default 3.0):
 
203
            Height of bearer bars (horizontal bars along the top and
 
204
            bottom of the barcode). Default is 3 x-dimensions.
 
205
            Set to zero for no bearer bars. (Bearer bars help detect
 
206
            misscans, so it is suggested to leave them on).
 
207
            
 
208
        quiet (bool, default 1):
 
209
            Wether to include quiet zones in the symbol.
 
210
            
 
211
        lquiet (float, see default below):
 
212
            Quiet zone size to left of code, if quiet is true.
 
213
            Default is the greater of .25 inch, or .15 times the symbol's
 
214
            length.
 
215
            
 
216
        rquiet (float, defaults as above):
 
217
            Quiet zone size to right left of code, if quiet is true.
 
218
            
 
219
    Sources of Information on Interleaved 2 of 5:
 
220
 
 
221
    http://www.semiconductor.agilent.com/barcode/sg/Misc/i_25.html
 
222
    http://www.adams1.com/pub/russadam/i25code.html
 
223
 
 
224
    Official Spec, "ANSI/AIM BC2-1995, USS" is available for US$45 from
 
225
    http://www.aimglobal.org/aimstore/
 
226
    """
 
227
 
 
228
    patterns = {
 
229
        'start' : 'bsbs',
 
230
        'stop' : 'Bsb',
 
231
 
 
232
        'B0' : 'bbBBb',     'S0' : 'ssSSs',
 
233
        'B1' : 'BbbbB',     'S1' : 'SsssS',
 
234
        'B2' : 'bBbbB',     'S2' : 'sSssS',
 
235
        'B3' : 'BBbbb',     'S3' : 'SSsss',
 
236
        'B4' : 'bbBbB',     'S4' : 'ssSsS',
 
237
        'B5' : 'BbBbb',     'S5' : 'SsSss',
 
238
        'B6' : 'bBBbb',     'S6' : 'sSSss',
 
239
        'B7' : 'bbbBB',     'S7' : 'sssSS',
 
240
        'B8' : 'BbbBb',     'S8' : 'SssSs',
 
241
        'B9' : 'bBbBb',     'S9' : 'sSsSs'
 
242
    }
 
243
 
 
244
    def __init__(self, value='', **args):
 
245
        self.height = None
 
246
        self.xdim = inch * 0.0075
 
247
        self.ratio = 2.2
 
248
        self.checksum = 1
 
249
        self.bearers = 3.0
 
250
        self.quiet = 1
 
251
        self.lquiet = self.rquiet = None
 
252
 
 
253
        if type(value) == type(1):
 
254
            value = str(value)
 
255
 
 
256
        for (k, v) in args.items():
 
257
            setattr(self, k, v)
 
258
 
 
259
        if self.quiet:
 
260
            if self.lquiet is None:
 
261
                self.lquiet = min(inch * 0.25, self.xdim * 10.0)
 
262
                self.rquiet = min(inch * 0.25, self.xdim * 10.0)
 
263
        else:
 
264
            self.lquiet = self.rquiet = 0.0
 
265
 
 
266
        Barcode.__init__(self, value)
 
267
 
 
268
    def validate(self):
 
269
        vval = ""
 
270
        self.valid = 1
 
271
        for c in string.strip(self.value):
 
272
            if c not in string.digits:
 
273
                self.valid = 0
 
274
                continue
 
275
            vval = vval + c
 
276
        self.validated = vval
 
277
        return vval
 
278
 
 
279
    def encode(self):
 
280
        s = self.validated
 
281
 
 
282
        # make sure result will be a multiple of 2 digits long,
 
283
        # checksum included
 
284
        if ((len(self.validated) % 2 == 0) and self.checksum) \
 
285
        or ((len(self.validated) % 2 == 1) and not self.checksum):
 
286
            s = '0' + s
 
287
 
 
288
        if self.checksum:
 
289
            c = 0
 
290
            cm = 3
 
291
 
 
292
            for d in s:
 
293
                c = c + cm * int(d)
 
294
                if cm == 3:
 
295
                    cm = 1
 
296
                else:
 
297
                    cm = 3
 
298
 
 
299
            d = 10 - (int(d) % 10)
 
300
            s = s + `d`
 
301
 
 
302
        self.encoded = s
 
303
 
 
304
    def decompose(self):
 
305
        dval = self.patterns['start']
 
306
 
 
307
        for i in range(0, len(self.encoded), 2):
 
308
            b = self.patterns['B' + self.encoded[i]]
 
309
            s = self.patterns['S' + self.encoded[i+1]]
 
310
 
 
311
            for i in range(0, len(b)):
 
312
                dval = dval + b[i] + s[i]
 
313
 
 
314
        self.decomposed = dval + self.patterns['stop']
 
315
        return self.decomposed
 
316
 
 
317
 
 
318
 
 
319
class MSI(Barcode):
 
320
    """
 
321
    MSI is a numeric-only barcode.
 
322
 
 
323
    Options that may be passed to constructor:
 
324
 
 
325
        value (int, or numeric string. required.):
 
326
            The value to encode.
 
327
   
 
328
        xdim (float, default .0075):
 
329
            X-Dimension, or width of the smallest element
 
330
            
 
331
        ratio (float, default 2.2):
 
332
            The ratio of wide elements to narrow elements.
 
333
            
 
334
        gap (float or None, default None):
 
335
            width of intercharacter gap. None means "use xdim".
 
336
        
 
337
        height (float, see default below):
 
338
            Height of the symbol.  Default is the height of the two
 
339
            bearer bars (if they exist) plus the greater of .25 inch
 
340
            or .15 times the symbol's length.
 
341
 
 
342
        checksum (bool, default 1):
 
343
            Wether to compute and include the check digit
 
344
            
 
345
        bearers (float, in units of xdim. default 0):
 
346
            Height of bearer bars (horizontal bars along the top and
 
347
            bottom of the barcode). Default is 0 (no bearers).
 
348
            
 
349
        lquiet (float, see default below):
 
350
            Quiet zone size to left of code, if quiet is true.
 
351
            Default is the greater of .25 inch, or 10 xdims.
 
352
            
 
353
        rquiet (float, defaults as above):
 
354
            Quiet zone size to right left of code, if quiet is true.
 
355
            
 
356
    Sources of Information on MSI Bar Code:
 
357
 
 
358
    http://www.semiconductor.agilent.com/barcode/sg/Misc/msi_code.html
 
359
    http://www.adams1.com/pub/russadam/plessy.html
 
360
    """
 
361
 
 
362
    patterns = {
 
363
        'start' : 'Bs',          'stop' : 'bSb',
 
364
 
 
365
        '0' : 'bSbSbSbS',        '1' : 'bSbSbSBs',
 
366
        '2' : 'bSbSBsbS',        '3' : 'bSbSBsBs',
 
367
        '4' : 'bSBsbSbS',        '5' : 'bSBsbSBs',
 
368
        '6' : 'bSBsBsbS',        '7' : 'bSBsBsBs',
 
369
        '8' : 'BsbSbSbS',        '9' : 'BsbSbSBs'
 
370
    }
 
371
 
 
372
    def __init__(self, value="", **args):
 
373
        self.height = None
 
374
        self.xdim = inch * 0.0075
 
375
        self.ratio = 2.2
 
376
        self.checksum = 1
 
377
        self.bearers = 0.0
 
378
        self.quiet = 1
 
379
        self.lquiet = self.rquiet = None
 
380
 
 
381
        if type(value) == type(1):
 
382
            value = str(value)
 
383
 
 
384
        for (k, v) in args.items():
 
385
            setattr(self, k, v)
 
386
 
 
387
        if self.quiet:
 
388
            if self.lquiet is None:
 
389
                self.lquiet = max(inch * 0.25, self.xdim * 10.0)
 
390
                self.rquiet = max(inch * 0.25, self.xdim * 10.0)
 
391
        else:
 
392
            self.lquiet = self.rquiet = 0.0
 
393
 
 
394
        Barcode.__init__(self, value)
 
395
 
 
396
    def validate(self):
 
397
        vval = ""
 
398
        self.valid = 1
 
399
        for c in string.strip(self.value):
 
400
            if c not in string.digits:
 
401
                self.valid = 0
 
402
                continue
 
403
            vval = vval + c
 
404
        self.validated = vval
 
405
        return vval
 
406
 
 
407
    def encode(self):
 
408
        s = self.validated
 
409
 
 
410
        if self.checksum:
 
411
            c = ''
 
412
            for i in range(1, len(s), 2):
 
413
                c = c + s[i]
 
414
            d = str(int(c) * 2)
 
415
            t = 0
 
416
            for c in d:
 
417
                t = t + int(c)
 
418
            for i in range(0, len(s), 2):
 
419
                t = t + int(s[i])
 
420
            c = 10 - (t % 10)
 
421
 
 
422
            s = s + str(c)
 
423
 
 
424
        self.encoded = s
 
425
 
 
426
    def decompose(self):
 
427
        dval = self.patterns['start']
 
428
 
 
429
        for c in self.encoded:
 
430
            dval = dval + self.patterns[c]
 
431
 
 
432
        self.decomposed = dval + self.patterns['stop']
 
433
        return self.decomposed
 
434
 
 
435
 
 
436
 
 
437
class Codabar(Barcode):
 
438
    """
 
439
    Codabar is a numeric plus some puntuation ("-$:/.+") barcode
 
440
    with four start/stop characters (A, B, C, and D).
 
441
 
 
442
    Options that may be passed to constructor:
 
443
 
 
444
        value (string. required.):
 
445
            The value to encode.
 
446
   
 
447
        xdim (float, default .0065):
 
448
            X-Dimension, or width of the smallest element
 
449
            minimum is 6.5 mils (.0065 inch)
 
450
            
 
451
        ratio (float, default 2.0):
 
452
            The ratio of wide elements to narrow elements.
 
453
            
 
454
        gap (float or None, default None):
 
455
            width of intercharacter gap. None means "use xdim".
 
456
        
 
457
        height (float, see default below):
 
458
            Height of the symbol.  Default is the height of the two
 
459
            bearer bars (if they exist) plus the greater of .25 inch
 
460
            or .15 times the symbol's length.
 
461
 
 
462
        checksum (bool, default 0):
 
463
            Wether to compute and include the check digit
 
464
            
 
465
        bearers (float, in units of xdim. default 0):
 
466
            Height of bearer bars (horizontal bars along the top and
 
467
            bottom of the barcode). Default is 0 (no bearers).
 
468
            
 
469
        quiet (bool, default 1):
 
470
            Wether to include quiet zones in the symbol.
 
471
            
 
472
        lquiet (float, see default below):
 
473
            Quiet zone size to left of code, if quiet is true.
 
474
            Default is the greater of .25 inch, or 10 xdim
 
475
            
 
476
        rquiet (float, defaults as above):
 
477
            Quiet zone size to right left of code, if quiet is true.
 
478
            
 
479
    Sources of Information on Codabar
 
480
 
 
481
    http://www.semiconductor.agilent.com/barcode/sg/Misc/codabar.html
 
482
    http://www.barcodeman.com/codabar.html
 
483
 
 
484
    Official Spec, "ANSI/AIM BC3-1995, USS" is available for US$45 from
 
485
    http://www.aimglobal.org/aimstore/
 
486
    """
 
487
 
 
488
    patterns = {
 
489
        '0':    'bsbsbSB',        '1':    'bsbsBSb',        '2':    'bsbSbsB',
 
490
        '3':    'BSbsbsb',        '4':    'bsBsbSb',        '5':    'BsbsbSb',
 
491
        '6':    'bSbsbsB',        '7':    'bSbsBsb',        '8':    'bSBsbsb',
 
492
        '9':    'BsbSbsb',        '-':    'bsbSBsb',        '$':    'bsBSbsb',
 
493
        ':':    'BsbsBsB',        '/':    'BsBsbsB',        '.':    'BsBsBsb',
 
494
        '+':    'bsBsBsB',        'A':    'bsBSbSb',        'B':    'bSbSbsB',
 
495
        'C':    'bsbSbSB',        'D':    'bsbSBSb'
 
496
    }
 
497
 
 
498
    values = {
 
499
        '0' : 0,    '1' : 1,    '2' : 2,    '3' : 3,    '4' : 4,
 
500
        '5' : 5,    '6' : 6,    '7' : 7,    '8' : 8,    '9' : 9,
 
501
        '-' : 10,   '$' : 11,   ':' : 12,   '/' : 13,   '.' : 14,
 
502
        '+' : 15,   'A' : 16,   'B' : 17,   'C' : 18,   'D' : 19
 
503
    }
 
504
 
 
505
    chars = string.digits + "-$:/.+"
 
506
 
 
507
    def __init__(self, value='', **args):
 
508
        self.height = None
 
509
        self.xdim = inch * 0.0065
 
510
        self.ratio = 2.0 # XXX ?
 
511
        self.checksum = 0
 
512
        self.bearers = 0.0
 
513
        self.quiet = 1
 
514
        self.lquiet = self.rquiet = None
 
515
 
 
516
        if type(value) == type(1):
 
517
            value = str(value)
 
518
 
 
519
        for (k, v) in args.items():
 
520
            setattr(self, k, v)
 
521
 
 
522
        if self.quiet:
 
523
            if self.lquiet is None:
 
524
                self.lquiet = min(inch * 0.25, self.xdim * 10.0)
 
525
                self.rquiet = min(inch * 0.25, self.xdim * 10.0)
 
526
        else:
 
527
            self.lquiet = self.rquiet = 0.0
 
528
 
 
529
        Barcode.__init__(self, value)
 
530
 
 
531
    def validate(self):
 
532
        vval = ""
 
533
        self.valid = 1
 
534
        s = string.strip(self.value)
 
535
        for i in range(0, len(s)):
 
536
            c = s[i]
 
537
            if c not in self.chars:
 
538
                if ((i != 0) and (i != len(s) - 1)) or (c not in 'ABCD'):
 
539
                    self.Valid = 0
 
540
                    continue
 
541
            vval = vval + c
 
542
 
 
543
        if vval[0] not in 'ABCD':
 
544
            vval = 'A' + vval
 
545
        if vval[-1] not in 'ABCD':
 
546
            vval = vval + vval[0]
 
547
 
 
548
        self.validated = vval
 
549
        return vval
 
550
 
 
551
    def encode(self):
 
552
        s = self.validated
 
553
 
 
554
        if self.checksum:
 
555
            v = 0
 
556
            for c in s:
 
557
                v = v + self.values[v]
 
558
            v = 16 - (v % 16)
 
559
            s = s + self.chars[v]
 
560
 
 
561
        self.encoded = s
 
562
 
 
563
    def decompose(self):
 
564
        dval = ""
 
565
        for c in self.encoded:
 
566
            dval = dval + self.patterns[c] + 'i'
 
567
        self.decomposed = dval[:-1]            
 
568
        return self.decomposed
 
569
 
 
570
 
 
571
 
 
572
class Code11(Barcode):
 
573
    """
 
574
    Code 11 is an almost-numeric barcode. It encodes the digits 0-9 plus
 
575
    dash ("-"). 11 characters total, hence the name.
 
576
    
 
577
        value (int or string. required.):
 
578
            The value to encode.
 
579
   
 
580
        xdim (float, default .0075):
 
581
            X-Dimension, or width of the smallest element
 
582
            
 
583
        ratio (float, default 2.2):
 
584
            The ratio of wide elements to narrow elements.
 
585
            
 
586
        gap (float or None, default None):
 
587
            width of intercharacter gap. None means "use xdim".
 
588
        
 
589
        height (float, see default below):
 
590
            Height of the symbol.  Default is the height of the two
 
591
            bearer bars (if they exist) plus the greater of .25 inch
 
592
            or .15 times the symbol's length.
 
593
 
 
594
        checksum (0 none, 1 1-digit, 2 2-digit, -1 auto, default -1):
 
595
            How many checksum digits to include. -1 ("auto") means
 
596
            1 if the number of digits is 10 or less, else 2.
 
597
            
 
598
        bearers (float, in units of xdim. default 0):
 
599
            Height of bearer bars (horizontal bars along the top and
 
600
            bottom of the barcode). Default is 0 (no bearers).
 
601
            
 
602
        quiet (bool, default 1):
 
603
            Wether to include quiet zones in the symbol.
 
604
            
 
605
        lquiet (float, see default below):
 
606
            Quiet zone size to left of code, if quiet is true.
 
607
            Default is the greater of .25 inch, or 10 xdim
 
608
            
 
609
        rquiet (float, defaults as above):
 
610
            Quiet zone size to right left of code, if quiet is true.
 
611
            
 
612
    Sources of Information on Code 11:
 
613
 
 
614
    http://www.cwi.nl/people/dik/english/codes/barcodes.html
 
615
    """
 
616
    
 
617
    chars = string.digits + '-'
 
618
    
 
619
    patterns = {
 
620
        '0' : 'bsbsB',        '1' : 'BsbsB',        '2' : 'bSbsB',
 
621
        '3' : 'BSbsb',        '4' : 'bsBsB',        '5' : 'BsBsb',
 
622
        '6' : 'bSBsb',        '7' : 'bsbSB',        '8' : 'BsbSb',
 
623
        '9' : 'Bsbsb',        '-' : 'bsBsb',        'S' : 'bsBSb' # Start/Stop
 
624
    }
 
625
 
 
626
    values = {
 
627
        '0' : 0,    '1' : 1,    '2' : 2,    '3' : 3,    '4' : 4,
 
628
        '5' : 5,    '6' : 6,    '7' : 7,    '8' : 8,    '9' : 9,
 
629
        '-' : 10,
 
630
    }
 
631
 
 
632
    def __init__(self, value='', **args):
 
633
        self.height = None
 
634
        self.xdim = inch * 0.0075
 
635
        self.ratio = 2.2 # XXX ?
 
636
        self.checksum = -1 # Auto 
 
637
        self.bearers = 0.0
 
638
        self.quiet = 1
 
639
        self.lquiet = self.rquiet = None
 
640
 
 
641
        if type(value) == type(1):
 
642
            value = str(value)
 
643
 
 
644
        for (k, v) in args.items():
 
645
            setattr(self, k, v)
 
646
 
 
647
        if self.quiet:
 
648
            if self.lquiet is None:
 
649
                self.lquiet = min(inch * 0.25, self.xdim * 10.0)
 
650
                self.rquiet = min(inch * 0.25, self.xdim * 10.0)
 
651
        else:
 
652
            self.lquiet = self.rquiet = 0.0
 
653
 
 
654
        Barcode.__init__(self, value)
 
655
 
 
656
    def validate(self):
 
657
        vval = ""
 
658
        self.valid = 1
 
659
        s = string.strip(self.value)
 
660
        for i in range(0, len(s)):
 
661
            c = s[i]
 
662
            if c not in self.chars:
 
663
                self.Valid = 0
 
664
                continue
 
665
            vval = vval + c
 
666
 
 
667
        self.validated = vval
 
668
        return vval
 
669
 
 
670
    def encode(self):
 
671
        s = self.validated
 
672
 
 
673
        if self.checksum == -1:
 
674
            if len(s) <= 10:
 
675
                self.checksum = 1
 
676
            else:
 
677
                self.checksum = 2
 
678
 
 
679
        if self.checksum > 0:
 
680
            # compute first checksum
 
681
            i = 0; v = 1; c = 0
 
682
            while i < len(s):
 
683
                c = c + v * string.index(self.chars, s[-(i+1)])
 
684
                i = i + 1; v = v + 1
 
685
                if v > 10:
 
686
                    v = 1
 
687
            s = s + self.chars[c % 11]
 
688
 
 
689
        if self.checksum > 1:
 
690
            # compute second checksum
 
691
            i = 0; v = 1; c = 0
 
692
            while i < len(s):
 
693
                c = c + v * string.index(self.chars, s[-(i+1)])
 
694
                i = i + 1; v = v + 1
 
695
                if v > 9:
 
696
                    v = 1
 
697
            s = s + self.chars[c % 10]
 
698
 
 
699
        self.encoded = 'S' + s + 'S'
 
700
 
 
701
    def decompose(self):
 
702
        dval = ""
 
703
        for c in self.encoded:
 
704
            dval = dval + self.patterns[c] + 'i'
 
705
        self.decomposed = dval[:-1]            
 
706
        return self.decomposed
 
707
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: