def _create_new_canvas(self): pagesize = PAGE_SIZE_MAP[self.pagesize] units = UNITS_MAP[self.dest_box_units] gc = Canvas(filename=self.filename, pagesize=pagesize) width = pagesize[0] * units * inch / 72.0 height = pagesize[1] * units * inch / 72.0 x = self.dest_box[0] * units y = self.dest_box[1] * units w = self.dest_box[2] * units h = self.dest_box[3] * units if w < 0: w += width if h < 0: h += height if w < 0 or h < 0: warnings.warn("Margins exceed page dimensions.") self.gc = None return gc.translate(x, y) path = gc.beginPath() path.rect(0, 0, w, h) gc.clipPath(path, stroke=0, fill=0) return gc
def _create_new_canvas(self): pagesize = PAGE_SIZE_MAP[self.pagesize] units = UNITS_MAP[self.dest_box_units] gc = Canvas(filename=self.filename, pagesize=pagesize) width = pagesize[0] * units * inch / 72.0 height = pagesize[1] * units * inch / 72.0 x = self.dest_box[0] * units y = self.dest_box[1] * units w = self.dest_box[2] * units h = self.dest_box[3] * units if w < 0: w += width if h < 0: h += height if w < 0 or h < 0: warnings.warn("Margins exceed page dimensions.") self.gc = None return gc.translate(x,y) path = gc.beginPath() path.rect(0, 0, w, h) gc.clipPath(path, stroke=0, fill=0) return gc
def __init__(self, IDmodele=None, taillePage=(210, 297), listeValeurs=[], margeHaut=10, margeGauche=10, margeBas = 10, margeDroite=10, espaceVertical=5, espaceHorizontal=5, nbre_copies=1, AfficherContourEtiquette=True, AfficherReperesDecoupe=True, ): # ---------------------------------------------------------------------------------------------------------------------------------------- def AfficheReperesDecoupe(): if AfficherReperesDecoupe == True : canvas.setStrokeColor( (0.9, 0.9, 0.9) ) canvas.setLineWidth(0.25) # Repères de colonnes for y1, y2 in [(hauteurPage*mm-4*mm, hauteurPage*mm-margeHaut*mm+2*mm), (4*mm, margeBas-2*mm)] : x = margeGauche*mm for numColonne in range(0, nbreColonnes): canvas.line(x, y1, x, y2) x += largeurEtiquette*mm canvas.line(x, y1, x, y2) x += espaceHorizontal*mm # Repères de lignes for x1, x2 in [(4*mm, margeGauche*mm-2*mm), (largeurPage*mm-4*mm, largeurPage*mm-margeDroite*mm+2*mm)] : y = hauteurPage*mm - margeHaut*mm for numLigne in range(0, nbreLignes): canvas.line(x1, y, x2, y) y -= hauteurEtiquette*mm canvas.line(x1, y, x2, y) y -= espaceVertical*mm # ----------------------------------------------------------------------------------------------------------------------------------------- largeurPage = taillePage[0] hauteurPage = taillePage[1] # Initialisation du modèle de document modeleDoc = DLG_Noedoc.ModeleDoc(IDmodele=IDmodele) largeurEtiquette = modeleDoc.dictInfosModele["largeur"] hauteurEtiquette = modeleDoc.dictInfosModele["hauteur"] # Calcul du nbre de colonnes et de lignes nbreColonnes = (largeurPage - margeGauche - margeDroite + espaceHorizontal) / (largeurEtiquette + espaceHorizontal) nbreLignes = (hauteurPage - margeHaut - margeBas + espaceVertical) / (hauteurEtiquette + espaceVertical) # Initialisation du PDF nomDoc = FonctionsPerso.GenerationNomDoc("ETIQUETTES", "pdf") canvas = Canvas(nomDoc, pagesize=(largeurPage*mm, hauteurPage*mm)) # Création des étiquettes numColonne = 0 numLigne = 0 for dictValeurs in listeValeurs : for num_copie in range(0, nbre_copies) : x = margeGauche + ((largeurEtiquette + espaceHorizontal) * numColonne) y = hauteurPage - margeHaut - hauteurEtiquette - ((hauteurEtiquette + espaceVertical) * numLigne) # Positionnement sur la feuille canvas.saveState() canvas.translate(x*mm, y*mm) # Création du clipping p = canvas.beginPath() canvas.setStrokeColor( (1, 1, 1) ) canvas.setLineWidth(0.25) p.rect(0, 0, largeurEtiquette*mm, hauteurEtiquette*mm) canvas.clipPath(p) # Dessin de l'étiquette modeleDoc.DessineFond(canvas, dictChamps=dictValeurs) etat = modeleDoc.DessineTousObjets(canvas, dictChamps=dictValeurs) if etat == False : return # Dessin du contour de l'étiquette if AfficherContourEtiquette == True : canvas.setStrokeColor( (0, 0, 0) ) canvas.setLineWidth(0.25) canvas.rect(0, 0, largeurEtiquette*mm, hauteurEtiquette*mm) canvas.restoreState() # Saut de colonne numColonne += 1 # Saut de ligne if numColonne > nbreColonnes - 1 : numLigne += 1 numColonne = 0 # Saut de page if numLigne > nbreLignes - 1 : AfficheReperesDecoupe() canvas.showPage() numLigne = 0 # Affichage des repères de découpe AfficheReperesDecoupe() # Finalisation du PDF canvas.save() try : FonctionsPerso.LanceFichierExterne(nomDoc) except : print "Probleme dans l'edition des etiquettes"
class PDFGenerator(object): canvas = None colorspace = None use_spot = True num_pages = 0 page_count = 0 prgs_msg = _('Saving in process...') def __init__(self, fileptr, cms, version=PDF_VERSION_DEFAULT): self.cms = cms self.canvas = Canvas(fileptr, pdfVersion=version[0]) self.info = UC_PDFInfo(self.canvas._doc) self.info.pdfxversion = version[1] self.info.subject = '---' self.canvas.setPageCompression(1) # ---PDF doc data def set_creator(self, name): self.info.creator = name def set_producer(self, name): self.info.producer = name def set_title(self, title): self.info.title = title def set_author(self, author): self.info.author = author def set_subject(self, subj): self.info.subject = subj def set_keywords(self, keywords): self.info.keywords = keywords # ---Rendering options def set_compression(self, val=True): self.canvas.setPageCompression(int(val)) def set_colorspace(self, cs=None): self.colorspace = cs def set_spot_usage(self, val=True): self.use_spot = val # ---Page processing def set_num_pages(self, num=1): self.num_pages = num def set_progress_message(self, msg): self.prgs_msg = msg def start_page(self, w, h, left_margin=0.0, top_margin=0.0): self.canvas.translate(w / 2.0 - left_margin, h / 2.0 - top_margin) self.canvas.setPageSize((w, h)) position = 0.0 if self.num_pages: position = float(self.page_count) / float(self.num_pages) events.emit(events.FILTER_INFO, self.prgs_msg, position) def end_page(self): self.canvas.showPage() self.page_count += 1 position = 1.0 if self.num_pages: position = float(self.page_count) / float(self.num_pages) events.emit(events.FILTER_INFO, self.prgs_msg, position) def save(self): self.canvas.save() # --- Rendering def render(self, objs, toplevel=False): obj_count = 0 for obj in objs: if obj.is_pixmap(): self.draw_pixmap(obj) elif obj.is_primitive(): curve_obj = obj.to_curve() if curve_obj.is_primitive(): self.draw_curve(curve_obj) else: self.render(curve_obj.childs) elif obj.is_container(): self.draw_container(obj) else: self.render(obj.childs) # ---Progress obj_count += 1 shift = 0.0 page_size = 1.0 if self.num_pages: shift = float(self.page_count) / float(self.num_pages) page_size = 1.0 / float(self.num_pages) position = shift + obj_count / len(objs) * page_size events.emit(events.FILTER_INFO, self.prgs_msg, position) def draw_curve(self, curve_obj): paths = libgeom.apply_trafo_to_paths(curve_obj.paths, curve_obj.trafo) pdfpath, closed = self.make_pdfpath(paths) fill_style = curve_obj.style[0] stroke_style = curve_obj.style[1] if stroke_style and stroke_style[7]: self.stroke_pdfpath(pdfpath, stroke_style, curve_obj.stroke_trafo) if fill_style and fill_style[0] & sk2const.FILL_CLOSED_ONLY and closed: self.fill_pdfpath(curve_obj, pdfpath, fill_style, curve_obj.fill_trafo) elif fill_style and not fill_style[0] & sk2const.FILL_CLOSED_ONLY: self.fill_pdfpath(curve_obj, pdfpath, fill_style, curve_obj.fill_trafo) if stroke_style and not stroke_style[7]: self.stroke_pdfpath(pdfpath, stroke_style, curve_obj.stroke_trafo) def draw_container(self, obj): container = obj.childs[0].to_curve() paths = libgeom.apply_trafo_to_paths(container.paths, container.trafo) pdfpath, closed = self.make_pdfpath(paths) fill_style = container.style[0] stroke_style = container.style[1] if stroke_style and stroke_style[7]: self.stroke_pdfpath(pdfpath, stroke_style, container.stroke_trafo) self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) if fill_style and fill_style[0] & sk2const.FILL_CLOSED_ONLY and closed: self.fill_pdfpath(container, pdfpath, fill_style, container.fill_trafo) elif fill_style and not fill_style[0] & sk2const.FILL_CLOSED_ONLY: self.fill_pdfpath(container, pdfpath, fill_style, container.fill_trafo) self.render(obj.childs[1:]) self.canvas.restoreState() if stroke_style and not stroke_style[7]: self.stroke_pdfpath(pdfpath, stroke_style, container.stroke_trafo) def make_pdfpath(self, paths): closed = False pdfpath = self.canvas.beginPath() for path in paths: pdfpath.moveTo(*path[0]) for point in path[1]: if len(point) > 2: pdfpath.curveTo(point[0][0], point[0][1], point[1][0], point[1][1], point[2][0], point[2][1]) else: pdfpath.lineTo(*point) if path[2]: pdfpath.close() closed = True return pdfpath, closed def set_fill_rule(self, fillrule): if fillrule in (sk2const.FILL_EVENODD, sk2const.FILL_EVENODD_CLOSED_ONLY): fillrule = FILL_EVEN_ODD else: fillrule = FILL_NON_ZERO self.canvas._fillMode = fillrule def set_rgb_values(self, color, pdfcolor): r, g, b = self.cms.get_rgb_color(color)[1] density = pdfcolor.density if density < 1: r = density * (r - 1) + 1 g = density * (g - 1) + 1 b = density * (b - 1) + 1 pdfcolor.red, pdfcolor.green, pdfcolor.blue = (r, g, b) def get_pdfcolor(self, color): pdfcolor = None alpha = color[2] if self.use_spot and color[0] == uc2const.COLOR_SPOT: c, m, y, k = self.cms.get_cmyk_color(color)[1] spotname = color[3] if spotname == uc2const.COLOR_REG: spotname = 'All' pdfcolor = CMYKColorSep(c, m, y, k, spotName=spotname, alpha=alpha) elif self.colorspace == uc2const.COLOR_CMYK: c, m, y, k = self.cms.get_cmyk_color(color)[1] pdfcolor = CMYKColor(c, m, y, k, alpha=alpha) elif self.colorspace == uc2const.COLOR_RGB: r, g, b = self.cms.get_rgb_color(color)[1] return Color(r, g, b, alpha) elif self.colorspace == uc2const.COLOR_GRAY: gray = self.cms.get_grayscale_color(color) k = 1.0 - gray[1][0] c = m = y = 0.0 pdfcolor = CMYKColor(c, m, y, k, alpha=alpha) else: if color[0] == uc2const.COLOR_RGB: r, g, b = color[1] return Color(r, g, b, alpha) elif color[0] == uc2const.COLOR_GRAY: k = 1.0 - color[1][0] c = m = y = 0.0 pdfcolor = CMYKColor(c, m, y, k, alpha=alpha) else: c, m, y, k = self.cms.get_cmyk_color(color)[1] pdfcolor = CMYKColor(c, m, y, k, alpha=alpha) self.set_rgb_values(color, pdfcolor) return pdfcolor def stroke_pdfpath(self, pdfpath, stroke_style, stroke_trafo=[]): width = stroke_style[1] if not stroke_style[8]: width = stroke_style[1] else: if not stroke_trafo: stroke_trafo = [] + sk2const.NORMAL_TRAFO points = [[0.0, 0.0], [1.0, 0.0]] points = libgeom.apply_trafo_to_points(points, stroke_trafo) coef = libgeom.distance(*points) width = stroke_style[1] * coef self.canvas.setStrokeColor(self.get_pdfcolor(stroke_style[2])) dash = stroke_style[3] caps = stroke_style[4] joint = stroke_style[5] miter = stroke_style[6] self.canvas.setLineWidth(width) self.canvas.setLineCap(caps - 1) self.canvas.setLineJoin(joint) dashes = [] if dash: dashes = list(dash) w = width if w < 1.0: w = 1.0 for i in range(len(dashes)): dashes[i] = w * dashes[i] self.canvas.setDash(dashes) self.canvas.setMiterLimit(miter) self.canvas.drawPath(pdfpath, 1, 0) self.canvas.setStrokeAlpha(1.0) def fill_pdfpath(self, obj, pdfpath, fill_style, fill_trafo=None): self.set_fill_rule(fill_style[0]) if fill_style[1] == sk2const.FILL_SOLID: self.canvas.setFillColor(self.get_pdfcolor(fill_style[2])) self.canvas.drawPath(pdfpath, 0, 1) elif fill_style[1] == sk2const.FILL_GRADIENT: gradient = fill_style[2] stops = gradient[2] transparency = False for stop in stops: if stop[1][2] < 1.0: transparency = True break if transparency: self.fill_tr_gradient(obj, pdfpath, fill_trafo, gradient) else: self.fill_gradient(pdfpath, fill_trafo, gradient) elif fill_style[1] == sk2const.FILL_PATTERN: pattern = fill_style[2] self.fill_pattern(obj, pdfpath, fill_trafo, pattern) def fill_gradient(self, pdfpath, fill_trafo, gradient): self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) if fill_trafo: self.canvas.transform(*fill_trafo) grad_type = gradient[0] sp, ep = gradient[1] stops = gradient[2] colors = [] positions = [] for offset, color in stops: positions.append(offset) colors.append(self.get_pdfcolor(color)) if grad_type == sk2const.GRADIENT_RADIAL: radius = libgeom.distance(sp, ep) self.canvas.radialGradient(sp[0], sp[1], radius, colors, positions, True) else: x0, y0 = sp x1, y1 = ep self.canvas.linearGradient(x0, y0, x1, y1, colors, positions, True) self.canvas.restoreState() def fill_tr_gradient(self, obj, pdfpath, fill_trafo, gradient): grad_type = gradient[0] if grad_type == sk2const.GRADIENT_RADIAL: self.fill_radial_tr_gradient(obj, pdfpath, fill_trafo, gradient) else: self.fill_linear_tr_gradient(obj, pdfpath, fill_trafo, gradient) def get_grcolor_at_point(self, stops, point=0.0): if not point: return self.get_pdfcolor(stops[0][1]) if point == 1.0: return self.get_pdfcolor(stops[-1][1]) stop0 = stops[0] stop1 = None for item in stops: if item[0] < point: stop0 = item if item[0] >= point: stop1 = item break size = stop1[0] - stop0[0] if not size: color = stop1[1] else: coef = (point - stop0[0]) / size color = self.cms.mix_colors(stop0[1], stop1[1], coef) return self.get_pdfcolor(color) def fill_linear_tr_gradient(self, obj, pdfpath, fill_trafo, gradient): if not fill_trafo: fill_trafo = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] stops = gradient[2] sp, ep = gradient[1] dx, dy = sp l = libgeom.distance(sp, ep) angle = libgeom.get_point_angle(ep, sp) m21 = math.sin(angle) m11 = m22 = math.cos(angle) m12 = -m21 trafo = [m11, m21, m12, m22, dx, dy] inv_trafo = libgeom.multiply_trafo(libgeom.invert_trafo(fill_trafo), libgeom.invert_trafo(trafo)) cv_trafo = libgeom.multiply_trafo(trafo, fill_trafo) paths = libgeom.apply_trafo_to_paths(obj.paths, obj.trafo) paths = libgeom.apply_trafo_to_paths(paths, inv_trafo) bbox = libgeom.sum_bbox(libgeom.get_paths_bbox(paths), [0.0, 0.0, l, 0.0]) bbox = libgeom.normalize_bbox(bbox) y = bbox[1] d = libgeom.distance(*libgeom.apply_trafo_to_points( [[0.0, 0.0], [0.0, 1.0]], inv_trafo)) height = bbox[3] - bbox[1] self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) self.canvas.transform(*cv_trafo) self.canvas.setFillColor(self.get_grcolor_at_point(stops, 0.0)) self.canvas.rect(bbox[0], y, 0.0 - bbox[0], height, stroke=0, fill=1) x = 0.0 while x < l: point = x / l self.canvas.setFillColor(self.get_grcolor_at_point(stops, point)) if x + d < l: width = d else: width = l - x self.canvas.rect(x, y, width, height, stroke=0, fill=1) x += d self.canvas.setFillColor(self.get_grcolor_at_point(stops, 1.0)) self.canvas.rect(l, y, bbox[2] - l, height, stroke=0, fill=1) self.canvas.restoreState() def fill_radial_tr_gradient(self, obj, pdfpath, fill_trafo, gradient): if not fill_trafo: fill_trafo = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] stops = gradient[2] sp, ep = gradient[1] dx, dy = sp l = libgeom.distance(sp, ep) trafo = [1.0, 0.0, 0.0, 1.0, dx, dy] inv_trafo = libgeom.multiply_trafo(libgeom.invert_trafo(fill_trafo), libgeom.invert_trafo(trafo)) cv_trafo = libgeom.multiply_trafo(trafo, fill_trafo) paths = libgeom.apply_trafo_to_paths(obj.paths, obj.trafo) paths = libgeom.apply_trafo_to_paths(paths, inv_trafo) bbox = libgeom.sum_bbox(libgeom.get_paths_bbox(paths), [0.0, 0.0, l, 0.0]) bbox = libgeom.normalize_bbox(bbox) d = libgeom.distance(*libgeom.apply_trafo_to_points( [[0.0, 0.0], [0.0, 1.0]], inv_trafo)) circle_paths = libgeom.get_circle_paths(0.0, 0.0, sk2const.ARC_CHORD) trafo = [2.0, 0.0, 0.0, 2.0, -1.0, -1.0] circle_paths = libgeom.apply_trafo_to_paths(circle_paths, trafo) inner_paths = [] r = 0.0 self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) self.canvas.transform(*cv_trafo) while r < l: point = r / l self.canvas.setFillColor(self.get_grcolor_at_point(stops, point)) if r + d < l: coef = (r + d) else: coef = l trafo = [coef, 0.0, 0.0, coef, 0.0, 0.0] paths = libgeom.apply_trafo_to_paths(circle_paths, trafo) ring = self.make_pdfpath(inner_paths + paths)[0] inner_paths = paths self.canvas.drawPath(ring, stroke=0, fill=1) r += d self.canvas.setFillColor(self.get_grcolor_at_point(stops, 1.0)) r = max(bbox[2] - bbox[0], bbox[3] - bbox[1]) trafo = [2.0 * r, 0.0, 0.0, 2.0 * r, 0.0, 0.0] paths = libgeom.apply_trafo_to_paths(circle_paths, trafo) ring = self.make_pdfpath(inner_paths + paths)[0] self.canvas.drawPath(ring, stroke=0, fill=1) self.canvas.restoreState() def draw_image(self, image, alpha_channel=None): if not image: return if self.colorspace == uc2const.COLOR_CMYK: image = self.cms.convert_image(image, uc2const.IMAGE_CMYK) elif self.colorspace == uc2const.COLOR_RGB: image = self.cms.convert_image(image, uc2const.IMAGE_RGB) elif self.colorspace == uc2const.COLOR_GRAY: image = self.cms.convert_image(image, uc2const.IMAGE_GRAY) img = ImageReader(image) img.getRGBData() if alpha_channel: img._dataA = ImageReader(alpha_channel) self.canvas.drawImage(img, 0, 0, mask='auto') def draw_pixmap_obj(self, obj): if obj.colorspace in uc2const.DUOTONES: fg, bg = libimg.convert_duotone_to_image(self.cms, obj) self.draw_image(*bg) self.draw_image(*fg) else: raw_image = Image.open(StringIO(b64decode(obj.bitmap))) raw_image.load() alpha_chnl = None if obj.alpha_channel: alpha_chnl = Image.open(StringIO(b64decode(obj.alpha_channel))) alpha_chnl.load() self.draw_image(raw_image, alpha_chnl) def draw_pixmap(self, obj): self.canvas.saveState() self.canvas.transform(*obj.trafo) self.canvas.setFillColorCMYK(0, 0, 0, 1, 1) self.canvas.setStrokeColorCMYK(0, 0, 0, 1, 1) self.draw_pixmap_obj(obj) self.canvas.restoreState() def fill_pattern(self, obj, pdfpath, fill_trafo, pattern): if not fill_trafo: fill_trafo = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] inv_ptrn_trafo = libgeom.invert_trafo(pattern[3]) inv_trafo = libgeom.multiply_trafo( libgeom.invert_trafo(fill_trafo), libgeom.invert_trafo(inv_ptrn_trafo)) paths = libgeom.apply_trafo_to_paths(obj.paths, obj.trafo) paths = libgeom.apply_trafo_to_paths(paths, inv_trafo) bbox = libgeom.get_paths_bbox(paths) cv_trafo = libgeom.multiply_trafo(pattern[3], fill_trafo) bmpstr = b64decode(pattern[1]) image_obj = sk2_model.Pixmap(obj.config) libimg.set_image_data(self.cms, image_obj, bmpstr) if pattern[0] == sk2const.PATTERN_IMG and \ len(pattern) > 2: image_obj.style[3] = deepcopy(pattern[2]) libimg.update_image(self.cms, image_obj) self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) self.canvas.transform(*cv_trafo) w, h = image_obj.get_size() x = bbox[0] y = bbox[3] while y > bbox[1] - h: while x < bbox[2]: self.canvas.saveState() self.canvas.transform(1.0, 0.0, 0.0, 1.0, x, y) self.draw_pixmap_obj(image_obj) self.canvas.restoreState() x += w y -= h x = bbox[0] self.canvas.restoreState()
def __init__( self, IDmodele=None, taillePage=(210, 297), listeValeurs=[], margeHaut=10, margeGauche=10, margeBas=10, margeDroite=10, espaceVertical=5, espaceHorizontal=5, nbre_copies=1, AfficherContourEtiquette=True, AfficherReperesDecoupe=True, ): # ---------------------------------------------------------------------------------------------------------------------------------------- def AfficheReperesDecoupe(): if AfficherReperesDecoupe == True: canvas.setStrokeColor((0.9, 0.9, 0.9)) canvas.setLineWidth(0.25) # Repères de colonnes for y1, y2 in [(hauteurPage * mm - 4 * mm, hauteurPage * mm - margeHaut * mm + 2 * mm), (4 * mm, margeBas - 2 * mm)]: x = margeGauche * mm for numColonne in range(0, nbreColonnes): canvas.line(x, y1, x, y2) x += largeurEtiquette * mm canvas.line(x, y1, x, y2) x += espaceHorizontal * mm # Repères de lignes for x1, x2 in [(4 * mm, margeGauche * mm - 2 * mm), (largeurPage * mm - 4 * mm, largeurPage * mm - margeDroite * mm + 2 * mm)]: y = hauteurPage * mm - margeHaut * mm for numLigne in range(0, nbreLignes): canvas.line(x1, y, x2, y) y -= hauteurEtiquette * mm canvas.line(x1, y, x2, y) y -= espaceVertical * mm # ----------------------------------------------------------------------------------------------------------------------------------------- largeurPage = taillePage[0] hauteurPage = taillePage[1] # Initialisation du modèle de document modeleDoc = DLG_Noedoc.ModeleDoc(IDmodele=IDmodele) largeurEtiquette = modeleDoc.dictInfosModele["largeur"] hauteurEtiquette = modeleDoc.dictInfosModele["hauteur"] # Calcul du nbre de colonnes et de lignes nbreColonnes = (largeurPage - margeGauche - margeDroite + espaceHorizontal) / (largeurEtiquette + espaceHorizontal) nbreLignes = (hauteurPage - margeHaut - margeBas + espaceVertical) / (hauteurEtiquette + espaceVertical) # Initialisation du PDF nomDoc = FonctionsPerso.GenerationNomDoc("ETIQUETTES", "pdf") canvas = Canvas(nomDoc, pagesize=(largeurPage * mm, hauteurPage * mm)) # Création des étiquettes numColonne = 0 numLigne = 0 for dictValeurs in listeValeurs: for num_copie in range(0, nbre_copies): x = margeGauche + ( (largeurEtiquette + espaceHorizontal) * numColonne) y = hauteurPage - margeHaut - hauteurEtiquette - ( (hauteurEtiquette + espaceVertical) * numLigne) # Positionnement sur la feuille canvas.saveState() canvas.translate(x * mm, y * mm) # Création du clipping p = canvas.beginPath() canvas.setStrokeColor((1, 1, 1)) canvas.setLineWidth(0.25) p.rect(0, 0, largeurEtiquette * mm, hauteurEtiquette * mm) canvas.clipPath(p) # Dessin de l'étiquette modeleDoc.DessineFond(canvas, dictChamps=dictValeurs) etat = modeleDoc.DessineTousObjets(canvas, dictChamps=dictValeurs) if etat == False: return # Dessin du contour de l'étiquette if AfficherContourEtiquette == True: canvas.setStrokeColor((0, 0, 0)) canvas.setLineWidth(0.25) canvas.rect(0, 0, largeurEtiquette * mm, hauteurEtiquette * mm) canvas.restoreState() # Saut de colonne numColonne += 1 # Saut de ligne if numColonne > nbreColonnes - 1: numLigne += 1 numColonne = 0 # Saut de page if numLigne > nbreLignes - 1: AfficheReperesDecoupe() canvas.showPage() numLigne = 0 # Affichage des repères de découpe AfficheReperesDecoupe() # Finalisation du PDF canvas.save() try: FonctionsPerso.LanceFichierExterne(nomDoc) except: print "Probleme dans l'edition des etiquettes"
class PDFGenerator(object): canvas = None colorspace = None use_spot = True num_pages = 0 page_count = 0 prgs_msg = _('Saving in process...') def __init__(self, fileptr, cms, version=PDF_VERSION_DEFAULT): self.cms = cms self.canvas = Canvas(fileptr, pdfVersion=version[0]) self.info = UC_PDFInfo(self.canvas._doc) self.info.pdfxversion = version[1] self.info.subject = '---' self.canvas.setPageCompression(1) #---PDF doc data def set_creator(self, name): self.info.creator = name def set_producer(self, name): self.info.producer = name def set_title(self, title): self.info.title = title def set_author(self, author): self.info.author = author def set_subject(self, subj): self.info.subject = subj def set_keywords(self, keywords): self.info.keywords = keywords #---Rendering options def set_compression(self, val=True): self.canvas.setPageCompression(int(val)) def set_colorspace(self, cs=None): self.colorspace = cs def set_spot_usage(self, val=True): self.use_spot = val #---Page processing def set_num_pages(self, num=1): self.num_pages = num def set_progress_message(self, msg): self.prgs_msg = msg def start_page(self, w, h, left_margin=0.0, top_margin=0.0): self.canvas.translate(w / 2.0 - left_margin, h / 2.0 - top_margin) self.canvas.setPageSize((w, h)) position = 0.0 if self.num_pages: position = float(self.page_count) / float(self.num_pages) events.emit(events.FILTER_INFO, self.prgs_msg, position) def end_page(self): self.canvas.showPage() self.page_count += 1 position = 1.0 if self.num_pages: position = float(self.page_count) / float(self.num_pages) events.emit(events.FILTER_INFO, self.prgs_msg, position) def save(self): self.canvas.save() #--- Rendering def render(self, objs, toplevel=False): obj_count = 0 for obj in objs: if obj.is_pixmap(): self.draw_pixmap(obj) elif obj.is_primitive(): curve_obj = obj.to_curve() if curve_obj.is_primitive(): self.draw_curve(curve_obj) else: self.render(curve_obj.childs) elif obj.is_container(): self.draw_container(obj) else: self.render(obj.childs) #---Progress obj_count += 1 shift = 0.0 page_size = 1.0 if self.num_pages: shift = float(self.page_count) / float(self.num_pages) page_size = 1.0 / float(self.num_pages) position = shift + obj_count / len(objs) * page_size events.emit(events.FILTER_INFO, self.prgs_msg, position) def draw_curve(self, curve_obj): paths = libgeom.apply_trafo_to_paths(curve_obj.paths, curve_obj.trafo) pdfpath, closed = self.make_pdfpath(paths) fill_style = curve_obj.style[0] stroke_style = curve_obj.style[1] if stroke_style and stroke_style[7]: self.stroke_pdfpath(pdfpath, stroke_style, curve_obj.stroke_trafo) if fill_style and fill_style[0] & sk2_const.FILL_CLOSED_ONLY and closed: self.fill_pdfpath(curve_obj, pdfpath, fill_style, curve_obj.fill_trafo) elif fill_style and not fill_style[0] & sk2_const.FILL_CLOSED_ONLY: self.fill_pdfpath(curve_obj, pdfpath, fill_style, curve_obj.fill_trafo) if stroke_style and not stroke_style[7]: self.stroke_pdfpath(pdfpath, stroke_style, curve_obj.stroke_trafo) def draw_container(self, obj): container = obj.childs[0].to_curve() paths = libgeom.apply_trafo_to_paths(container.paths, container.trafo) pdfpath, closed = self.make_pdfpath(paths) fill_style = container.style[0] stroke_style = container.style[1] if stroke_style and stroke_style[7]: self.stroke_pdfpath(pdfpath, stroke_style, container.stroke_trafo) self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) if fill_style and fill_style[0] & sk2_const.FILL_CLOSED_ONLY and closed: self.fill_pdfpath(container, pdfpath, fill_style, container.fill_trafo) elif fill_style and not fill_style[0] & sk2_const.FILL_CLOSED_ONLY: self.fill_pdfpath(container, pdfpath, fill_style, container.fill_trafo) self.render(obj.childs[1:]) self.canvas.restoreState() if stroke_style and not stroke_style[7]: self.stroke_pdfpath(pdfpath, stroke_style, container.stroke_trafo) def make_pdfpath(self, paths): closed = False pdfpath = self.canvas.beginPath() for path in paths: pdfpath.moveTo(*path[0]) for point in path[1]: if len(point) > 2: pdfpath.curveTo(point[0][0], point[0][1], point[1][0], point[1][1], point[2][0], point[2][1]) else: pdfpath.lineTo(*point) if path[2]: pdfpath.close() closed = True return pdfpath, closed def set_fill_rule(self, fillrule): if fillrule in (sk2_const.FILL_EVENODD, sk2_const.FILL_EVENODD_CLOSED_ONLY): fillrule = FILL_EVEN_ODD else:fillrule = FILL_NON_ZERO self.canvas._fillMode = fillrule def set_rgb_values(self, color, pdfcolor): r, g, b = self.cms.get_rgb_color(color)[1] density = pdfcolor.density if density < 1: r = density * (r - 1) + 1 g = density * (g - 1) + 1 b = density * (b - 1) + 1 pdfcolor.red, pdfcolor.green, pdfcolor.blue = (r, g, b) def get_pdfcolor(self, color): pdfcolor = None alpha = color[2] if self.use_spot and color[0] == uc2const.COLOR_SPOT: c, m, y, k = self.cms.get_cmyk_color(color)[1] spotname = color[3] if spotname == uc2const.COLOR_REG: spotname = 'All' pdfcolor = CMYKColorSep(c, m, y, k, spotName=spotname, alpha=alpha) elif self.colorspace == uc2const.COLOR_CMYK: c, m, y, k = self.cms.get_cmyk_color(color)[1] pdfcolor = CMYKColor(c, m, y, k, alpha=alpha) elif self.colorspace == uc2const.COLOR_RGB: r, g, b = self.cms.get_rgb_color(color)[1] return Color(r, g, b, alpha) elif self.colorspace == uc2const.COLOR_GRAY: gray = self.cms.get_grayscale_color(color) k = 1.0 - gray[1][0] c = m = y = 0.0 pdfcolor = CMYKColor(c, m, y, k, alpha=alpha) else: if color[0] == uc2const.COLOR_RGB: r, g, b = color[1] return Color(r, g, b, alpha) elif color[0] == uc2const.COLOR_GRAY: k = 1.0 - color[1][0] c = m = y = 0.0 pdfcolor = CMYKColor(c, m, y, k, alpha=alpha) else: c, m, y, k = self.cms.get_cmyk_color(color)[1] pdfcolor = CMYKColor(c, m, y, k, alpha=alpha) self.set_rgb_values(color, pdfcolor) return pdfcolor def stroke_pdfpath(self, pdfpath, stroke_style, stroke_trafo=[]): width = stroke_style[1] if not stroke_style[8]: width = stroke_style[1] else: if not stroke_trafo: stroke_trafo = [] + sk2_const.NORMAL_TRAFO points = [[0.0, 0.0], [1.0, 0.0]] points = libgeom.apply_trafo_to_points(points, stroke_trafo) coef = libgeom.distance(*points) width = stroke_style[1] * coef self.canvas.setStrokeColor(self.get_pdfcolor(stroke_style[2])) dash = stroke_style[3] caps = stroke_style[4] joint = stroke_style[5] miter = stroke_style[6] self.canvas.setLineWidth(width) self.canvas.setLineCap(caps - 1) self.canvas.setLineJoin(joint) dashes = [] if dash: dashes = list(dash) w = width if w < 1.0: w = 1.0 for i in range(len(dashes)): dashes[i] = w * dashes[i] self.canvas.setDash(dashes) self.canvas.setMiterLimit(miter) self.canvas.drawPath(pdfpath, 1, 0) self.canvas.setStrokeAlpha(1.0) def fill_pdfpath(self, obj, pdfpath, fill_style, fill_trafo=None): self.set_fill_rule(fill_style[0]) if fill_style[1] == sk2_const.FILL_SOLID: self.canvas.setFillColor(self.get_pdfcolor(fill_style[2])) self.canvas.drawPath(pdfpath, 0, 1) elif fill_style[1] == sk2_const.FILL_GRADIENT: gradient = fill_style[2] stops = gradient[2] transparency = False for stop in stops: if stop[1][2] < 1.0: transparency = True break if transparency: self.fill_tr_gradient(obj, pdfpath, fill_trafo, gradient) else: self.fill_gradient(pdfpath, fill_trafo, gradient) elif fill_style[1] == sk2_const.FILL_PATTERN: pattern = fill_style[2] self.fill_pattern(obj, pdfpath, fill_trafo, pattern) def fill_gradient(self, pdfpath, fill_trafo, gradient): self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) if fill_trafo: self.canvas.transform(*fill_trafo) grad_type = gradient[0] sp, ep = gradient[1] stops = gradient[2] colors = [] positions = [] for offset, color in stops: positions.append(offset) colors.append(self.get_pdfcolor(color)) if grad_type == sk2_const.GRADIENT_RADIAL: radius = libgeom.distance(sp, ep) self.canvas.radialGradient(sp[0], sp[1], radius, colors, positions, True) else: x0, y0 = sp x1, y1 = ep self.canvas.linearGradient(x0, y0, x1, y1, colors, positions, True) self.canvas.restoreState() def fill_tr_gradient(self, obj, pdfpath, fill_trafo, gradient): grad_type = gradient[0] if grad_type == sk2_const.GRADIENT_RADIAL: self.fill_radial_tr_gradient(obj, pdfpath, fill_trafo, gradient) else: self.fill_linear_tr_gradient(obj, pdfpath, fill_trafo, gradient) def get_grcolor_at_point(self, stops, point=0.0): if not point:return self.get_pdfcolor(stops[0][1]) if point == 1.0:return self.get_pdfcolor(stops[-1][1]) stop0 = stops[0] stop1 = None for item in stops: if item[0] < point:stop0 = item if item[0] >= point: stop1 = item break size = stop1[0] - stop0[0] if not size: color = stop1[1] else: coef = (point - stop0[0]) / size color = self.cms.mix_colors(stop0[1], stop1[1], coef) return self.get_pdfcolor(color) def fill_linear_tr_gradient(self, obj, pdfpath, fill_trafo, gradient): if not fill_trafo: fill_trafo = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] stops = gradient[2] sp, ep = gradient[1] dx, dy = sp l = libgeom.distance(sp, ep) angle = libgeom.get_point_angle(ep, sp) m21 = math.sin(angle) m11 = m22 = math.cos(angle) m12 = -m21 trafo = [m11, m21, m12, m22, dx, dy] inv_trafo = libgeom.multiply_trafo(libgeom.invert_trafo(fill_trafo), libgeom.invert_trafo(trafo)) cv_trafo = libgeom.multiply_trafo(trafo, fill_trafo) paths = libgeom.apply_trafo_to_paths(obj.paths, obj.trafo) paths = libgeom.apply_trafo_to_paths(paths, inv_trafo) bbox = libgeom.sum_bbox(libgeom.get_paths_bbox(paths), [0.0, 0.0, l, 0.0]) bbox = libgeom.normalize_bbox(bbox) y = bbox[1] d = libgeom.distance(*libgeom.apply_trafo_to_points([[0.0, 0.0], [0.0, 1.0]], inv_trafo)) height = bbox[3] - bbox[1] self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) self.canvas.transform(*cv_trafo) self.canvas.setFillColor(self.get_grcolor_at_point(stops, 0.0)) self.canvas.rect(bbox[0], y, 0.0 - bbox[0], height, stroke=0, fill=1) x = 0.0 while x < l: point = x / l self.canvas.setFillColor(self.get_grcolor_at_point(stops, point)) if x + d < l: width = d else: width = l - x self.canvas.rect(x, y, width, height, stroke=0, fill=1) x += d self.canvas.setFillColor(self.get_grcolor_at_point(stops, 1.0)) self.canvas.rect(l, y, bbox[2] - l, height, stroke=0, fill=1) self.canvas.restoreState() def fill_radial_tr_gradient(self, obj, pdfpath, fill_trafo, gradient): if not fill_trafo: fill_trafo = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] stops = gradient[2] sp, ep = gradient[1] dx, dy = sp l = libgeom.distance(sp, ep) trafo = [1.0, 0.0, 0.0, 1.0, dx, dy] inv_trafo = libgeom.multiply_trafo(libgeom.invert_trafo(fill_trafo), libgeom.invert_trafo(trafo)) cv_trafo = libgeom.multiply_trafo(trafo, fill_trafo) paths = libgeom.apply_trafo_to_paths(obj.paths, obj.trafo) paths = libgeom.apply_trafo_to_paths(paths, inv_trafo) bbox = libgeom.sum_bbox(libgeom.get_paths_bbox(paths), [0.0, 0.0, l, 0.0]) bbox = libgeom.normalize_bbox(bbox) d = libgeom.distance(*libgeom.apply_trafo_to_points([[0.0, 0.0], [0.0, 1.0]], inv_trafo)) circle_paths = libgeom.get_circle_paths(0.0, 0.0, sk2_const.ARC_CHORD) trafo = [2.0, 0.0, 0.0, 2.0, -1.0, -1.0] circle_paths = libgeom.apply_trafo_to_paths(circle_paths, trafo) inner_paths = [] r = 0.0 self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) self.canvas.transform(*cv_trafo) while r < l: point = r / l self.canvas.setFillColor(self.get_grcolor_at_point(stops, point)) if r + d < l: coef = (r + d) else: coef = l trafo = [coef, 0.0, 0.0, coef, 0.0, 0.0] paths = libgeom.apply_trafo_to_paths(circle_paths, trafo) ring = self.make_pdfpath(inner_paths + paths)[0] inner_paths = paths self.canvas.drawPath(ring, stroke=0, fill=1) r += d self.canvas.setFillColor(self.get_grcolor_at_point(stops, 1.0)) r = max(bbox[2] - bbox[0], bbox[3] - bbox[1]) trafo = [2.0 * r, 0.0, 0.0, 2.0 * r, 0.0, 0.0] paths = libgeom.apply_trafo_to_paths(circle_paths, trafo) ring = self.make_pdfpath(inner_paths + paths)[0] self.canvas.drawPath(ring, stroke=0, fill=1) self.canvas.restoreState() def draw_image(self, image, alpha_channel=None): if not image: return if self.colorspace == uc2const.COLOR_CMYK: image = self.cms.convert_image(image, uc2const.IMAGE_CMYK) elif self.colorspace == uc2const.COLOR_RGB: image = self.cms.convert_image(image, uc2const.IMAGE_RGB) elif self.colorspace == uc2const.COLOR_GRAY: image = self.cms.convert_image(image, uc2const.IMAGE_GRAY) img = ImageReader(image) img.getRGBData() if alpha_channel: img._dataA = ImageReader(alpha_channel) self.canvas.drawImage(img, 0, 0, mask='auto') def draw_pixmap_obj(self, obj): if obj.colorspace in uc2const.DUOTONES: fg, bg = libimg.convert_duotone_to_image(self.cms, obj) self.draw_image(*bg) self.draw_image(*fg) else: raw_image = Image.open(StringIO(b64decode(obj.bitmap))) raw_image.load() alpha_chnl = None if obj.alpha_channel: alpha_chnl = Image.open(StringIO(b64decode(obj.alpha_channel))) alpha_chnl.load() self.draw_image(raw_image, alpha_chnl) def draw_pixmap(self, obj): self.canvas.saveState() self.canvas.transform(*obj.trafo) self.canvas.setFillColorCMYK(0, 0, 0, 1, 1) self.canvas.setStrokeColorCMYK(0, 0, 0, 1, 1) self.draw_pixmap_obj(obj) self.canvas.restoreState() def fill_pattern(self, obj, pdfpath, fill_trafo, pattern): if not fill_trafo: fill_trafo = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] inv_ptrn_trafo = libgeom.invert_trafo(pattern[3]) inv_trafo = libgeom.multiply_trafo(libgeom.invert_trafo(fill_trafo), libgeom.invert_trafo(inv_ptrn_trafo)) paths = libgeom.apply_trafo_to_paths(obj.paths, obj.trafo) paths = libgeom.apply_trafo_to_paths(paths, inv_trafo) bbox = libgeom.get_paths_bbox(paths) cv_trafo = libgeom.multiply_trafo(pattern[3], fill_trafo) bmpstr = b64decode(pattern[1]) image_obj = sk2_model.Pixmap(obj.config) libimg.set_image_data(self.cms, image_obj, bmpstr) if pattern[0] == sk2_const.PATTERN_IMG and \ len(pattern) > 2: image_obj.style[3] = deepcopy(pattern[2]) libimg.update_image(self.cms, image_obj) self.canvas.saveState() self.canvas.clipPath(pdfpath, 0, 0) self.canvas.transform(*cv_trafo) w, h = image_obj.get_size() x = bbox[0] y = bbox[3] while y > bbox[1] - h: while x < bbox[2]: self.canvas.saveState() self.canvas.transform(1.0, 0.0, 0.0, 1.0, x, y) self.draw_pixmap_obj(image_obj) self.canvas.restoreState() x += w y -= h x = bbox[0] self.canvas.restoreState()