318 lines
13 KiB
Python
Executable File
318 lines
13 KiB
Python
Executable File
#! /usr/bin/python
|
|
'''
|
|
Copyright (C) 2017 Artem Synytsyn a.synytsyn@gmail.com
|
|
|
|
#TODO: Code cleaning and refactoring
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
'''
|
|
|
|
import inkex
|
|
import sys
|
|
from lxml import etree
|
|
from math import *
|
|
|
|
|
|
import re
|
|
from typing import Any
|
|
import wikipedia
|
|
import openpyxl
|
|
|
|
|
|
import math, decimal, datetime
|
|
dec = decimal.Decimal
|
|
|
|
|
|
|
|
|
|
|
|
# ['NAMESPACE', 'PARSER', 'TAG', 'WRAPPED_ATTRS', '__abstractmethods__', '__bool__',
|
|
# '__class__', '__contains__', '__copy__', '__deepcopy__', '__delattr__', '__delitem__',
|
|
# '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattr__',
|
|
# '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__',
|
|
# '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__ne__',
|
|
# '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__',
|
|
# '__setitem__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', '__weakref__',
|
|
# '_abc_impl', '_ancestors', '_init', '_is_visible', 'add', 'add_unit', 'addnext',
|
|
# 'addprevious', 'ancestors', 'append', 'attrib', 'backlinks', 'bake_transforms_recursively',
|
|
# 'base', 'bounding_box', 'cascaded_style', 'clear', 'clip', 'composed_style',
|
|
# 'composed_transform', 'copy', 'cssselect', 'delete', 'desc', 'descendants',
|
|
# 'description', 'duplicate', 'effective_style', 'eid', 'extend', 'find', 'findall',
|
|
# 'findone', 'findtext', 'get', 'get_id', 'get_line_height_uu', 'get_or_create',
|
|
# 'get_path', 'getchildren', 'getiterator', 'getnext', 'getparent', 'getprevious',
|
|
# 'getroottree', 'groupmode', 'href', 'index', 'insert', 'is_class_element',
|
|
# 'is_sensitive', 'is_visible', 'items', 'iter', 'iterancestors', 'iterchildren',
|
|
# 'iterdescendants', 'iterfind', 'itersiblings', 'itertext', 'keys', 'label',
|
|
# 'makeelement', 'new', 'nsmap', 'path', 'pop', 'prefix', 'presentation_style',
|
|
# 'remove', 'remove_all', 'replace', 'replace_with', 'root', 'set', 'set_id',
|
|
# 'set_path', 'set_random_id', 'set_random_ids', 'set_sensitive', 'shape_box',
|
|
# 'sourceline', 'specified_style', 'tag', 'tag_name', 'tail', 'text', 'title',
|
|
# 'to_dimensional', 'to_dimensionless', 'to_path_element', 'tostring', 'typename',
|
|
# 'unit', 'unit_to_viewport', 'unittouu', 'update', 'uutounit', 'values',
|
|
# 'viewport_to_unit', 'wrapped_attrs', 'wrapped_props', 'xml_path', 'xpath']
|
|
|
|
|
|
# ___ _ _ _ _ _
|
|
# |_ _|_ __ | | _____ ___ __ _ _ __ ___| | | |_ __ _ __(_)_ __ | |_
|
|
# | || '_ \| |/ / __|/ __/ _` | '_ \ / _ \ | | | '_ \| '__| | '_ \| __|
|
|
# | || | | | <\__ \ (_| (_| | |_) | __/ |_| | |_) | | | | | | | |_
|
|
# |___|_| |_|_|\_\___/\___\__,_| .__/ \___|\___/| .__/|_| |_|_| |_|\__|
|
|
# |_| |_|
|
|
|
|
|
|
# class _Spacing():
|
|
# size = 0.
|
|
# padding = 0.
|
|
# margin_top = 0.
|
|
# margin_bottom = 0.
|
|
# margin_left = 0.
|
|
# margin_right = 0.
|
|
|
|
|
|
|
|
|
|
class InkscapeUprint(inkex.Effect):
|
|
def __init__(self):
|
|
inkex.Effect.__init__(self)
|
|
|
|
# General settings
|
|
self.arg_parser.add_argument("--x",
|
|
type=float,
|
|
dest="x", default=0.0,
|
|
help="Center X")
|
|
self.arg_parser.add_argument("--y",
|
|
type=float,
|
|
dest="y", default=0.0,
|
|
help="Center Y")
|
|
self.arg_parser.add_argument("-u", "--units",
|
|
type=str,
|
|
dest="units", default="mm",
|
|
help="units to measure size of knob")
|
|
|
|
# Dummy
|
|
self.arg_parser.add_argument("--tab")
|
|
|
|
# # Label settings
|
|
self.arg_parser.add_argument("--subst_file",
|
|
type=str,
|
|
dest="subst_file", default='',
|
|
help="xlsx file to load substitutions")
|
|
|
|
|
|
self.__element_spacing = {
|
|
'size' : 0,
|
|
'padding' : 0,
|
|
'margin-top' : 0,
|
|
'margin-bottom' : 0,
|
|
'margin-left' : 0,
|
|
'margin-right' : 0
|
|
}
|
|
|
|
self.__page_spacing = {
|
|
'size' : 0,
|
|
'padding' : 0,
|
|
'margin-top' : 0,
|
|
'margin-bottom' : 0,
|
|
'margin-left' : 0,
|
|
'margin-right' : 0
|
|
}
|
|
|
|
for sk in self.__element_spacing.keys():
|
|
sk = sk.replace('-','_')
|
|
self.arg_parser.add_argument("--element_" + sk,
|
|
type=float,
|
|
dest="element_" + sk,
|
|
help="Spacing element" + " " + sk)
|
|
for sk in self.__page_spacing.keys():
|
|
sk = sk.replace('-','_')
|
|
self.arg_parser.add_argument("--page_" + sk,
|
|
type=float,
|
|
dest="page_" + sk,
|
|
help="Spacing page" + " " + sk)
|
|
|
|
|
|
def svg_traverse_node(self, node, tag=None, exclude=None):
|
|
def _tag(t):
|
|
return re.sub(r'\{.*?\}', r'', t)
|
|
l = []
|
|
if isinstance(node, etree._Element):
|
|
if (tag is None or _tag(node.tag) == tag) and (exclude is None or _tag(node.tag) != exclude):
|
|
l.append(node)
|
|
for child in node.getchildren():
|
|
l.extend(self.svg_traverse_node(child, tag=tag, exclude=exclude))
|
|
elif isinstance(node, etree._Comment):
|
|
pass
|
|
elif isinstance(node, list):
|
|
for child in node:
|
|
l.extend(self.svg_traverse_node(child, tag=tag, exclude=exclude))
|
|
return l
|
|
|
|
def replace_text(self, selected, substs):
|
|
import re
|
|
for node in selected:
|
|
tspans = [ n for n in self.svg_traverse_node(node, tag='tspan')]
|
|
for k,v in substs.items():
|
|
patt = re.compile(r'\{\{' + re.escape(k) + r'\}\}')
|
|
for t in tspans:
|
|
if t.text is None: continue
|
|
t.text = patt.sub(v, t.text)
|
|
# multilines = t.text.split('\n')
|
|
# if len(multilines) > 1:
|
|
# t.text = multilines[0]
|
|
# for i in range(1, len(multilines)):
|
|
# new_t = etree.Element('tspan', nsmap=t.nsmap)
|
|
# new_t.text = multilines[i]
|
|
# new_t.tail = t.tail
|
|
# new_t.attrib.update(t.attrib) # copy style
|
|
# p = t.getparent()
|
|
# p.insert(p.index(t) + 1, new_t)
|
|
|
|
def duplicate_object(self, parent, selected):
|
|
duplicated = []
|
|
import copy
|
|
for node in selected:
|
|
new_node = node.duplicate()
|
|
duplicated.append(new_node)
|
|
# duplicated.append(etree.Element(node.tag, node.attrib, nsmap=node.nsmap))
|
|
# # # inkex.utils.debug(' node.text = ' + str(type(node.text)))
|
|
# duplicated[-1].tail = node.tail
|
|
# duplicated[-1].text = node.text
|
|
# self.duplicate_object(duplicated[-1], node.getchildren())
|
|
parent.append(duplicated[-1])
|
|
|
|
return duplicated
|
|
|
|
def translate_object(self, obj, x, y):
|
|
trans = 'translate(' + str(float(x)) + ',' + str(float(y)) + ')'
|
|
for d in obj:
|
|
if 'transform' in d.attrib: d.set('transform', d.get('transform') + ' ' + trans)
|
|
else: d.set('transform', trans)
|
|
|
|
def place_in_pages(self, elements = None):
|
|
if elements is None:
|
|
return
|
|
first_page = self.svg.getElement("//inkscape:page")
|
|
if first_page is not None:
|
|
page_width = float(first_page.get('width'))
|
|
page_height = float(first_page.get('height'))
|
|
view = first_page.getparent()
|
|
else:
|
|
view = self.svg.getElement("//sodipodi:namedview")
|
|
if view is None:
|
|
inkex.utils.errormsg('No view found')
|
|
return
|
|
page_width = self.svg.get_page_bbox().width
|
|
page_height = self.svg.get_page_bbox().height
|
|
|
|
pages = [ node for node in self.svg_traverse_node(view, tag='inkscape:page')]
|
|
|
|
# the reference page is always the first one
|
|
pgbbox = {"width": page_width, "height": page_height}
|
|
elbbox = self.bbox
|
|
nx = int (( float(pgbbox['width']) - self.__page_spacing['margin-left'] - self.__page_spacing['margin-right'] - self.__element_spacing['padding']) / \
|
|
( elbbox.width + self.__element_spacing['padding'] ))
|
|
ny = int (( float(pgbbox['height']) - self.__page_spacing['margin-top'] - self.__page_spacing['margin-bottom'] - self.__element_spacing['padding'] ) / \
|
|
( elbbox.height + self.__element_spacing['padding'] ))
|
|
|
|
# remove model position
|
|
correct_x = self.bbox.left
|
|
correct_y = self.bbox.top
|
|
|
|
# compute page position zero
|
|
if len(pages) > 0:
|
|
rightmost_page = max(pages, key=lambda p: p.get('x'))
|
|
px = float(rightmost_page.get('x'))
|
|
py = float(rightmost_page.get('y'))
|
|
else:
|
|
px = 0.
|
|
py = 0.
|
|
|
|
# place elements
|
|
for i, el in enumerate(elements):
|
|
# create new page if needed
|
|
# inkex.utils.debug('nx: '+str(nx) + ' ny: '+str(ny))
|
|
if i % int(nx * ny) == 0:
|
|
new_page = etree.Element('{http://www.inkscape.org/namespaces/inkscape}page', nsmap=view.nsmap)
|
|
new_page.set('x', str(px + ( page_width + self.__page_spacing['padding'] )))
|
|
new_page.set('y', str(py) )
|
|
new_page.set('width', str(page_width))
|
|
new_page.set('height', str(page_height))
|
|
view.append(new_page)
|
|
rightmost_page = new_page
|
|
px = float(rightmost_page.get('x'))
|
|
py = float(rightmost_page.get('y'))
|
|
|
|
x = px + (i % nx) * ( elbbox.width + self.__element_spacing['padding'] ) \
|
|
+ self.__page_spacing['margin-left'] + self.__element_spacing['padding']
|
|
|
|
y = py + (i % (nx*ny) // nx) * ( elbbox.height + self.__element_spacing['padding'] ) \
|
|
+ self.__page_spacing['margin-top'] + self.__element_spacing['padding']
|
|
|
|
self.translate_object(el, x - correct_x, y - correct_y)
|
|
|
|
|
|
|
|
def compute_bounding_box(self, selected):
|
|
_tag = lambda t: re.sub(r'\{.*?\}', r'', t)
|
|
objs = [ n for n in self.svg_traverse_node(selected[0]) if _tag(n.tag) not in ['text', 'tspan','g'] ]
|
|
l = inkex.elements._selected.ElementList(self.svg, objs)
|
|
return l.bounding_box()
|
|
|
|
|
|
|
|
def effect(self):
|
|
# inkex.utils.debug('inkex: ' + inkex.__file__)
|
|
parent = self.svg.get_current_layer()
|
|
selected = self.svg.selected
|
|
|
|
for k in self.__page_spacing.keys():
|
|
self.__page_spacing[k] = self.svg.unittouu( str(self.options.__dict__['page_'+k.replace('-','_')]) + self.options.units )
|
|
for k in self.__element_spacing.keys():
|
|
self.__element_spacing[k] = self.svg.unittouu(str(self.options.__dict__['element_'+k.replace('-','_')]) + self.options.units)
|
|
|
|
if selected:
|
|
self.bbox = self.compute_bounding_box(selected)
|
|
if self.bbox is None:
|
|
inkex.utils.errormsg('bbox is None')
|
|
# self.x_offset = self.svg.unittouu(str(self.options.x) + self.options.units)
|
|
# self.y_offset = self.svg.unittouu(str(self.options.y) + self.options.units)
|
|
else:
|
|
inkex.utils.errormsg("Error - No object selected")
|
|
return
|
|
|
|
wb = openpyxl.load_workbook(self.options.subst_file)
|
|
ws = wb.active
|
|
headings = [cell.value for cell in ws[1]]
|
|
substs = []
|
|
for row in ws.iter_rows(min_row=2, values_only=True):
|
|
substs.append(dict(zip(headings, row)))
|
|
|
|
new_objects = []
|
|
|
|
for i, subst in enumerate(substs):
|
|
dup = self.duplicate_object(parent, selected)
|
|
# self.translate_object(dup, (i+1) * (self.x_offset + self.bbox.width), self.y_offset)
|
|
self.replace_text(dup, subst)
|
|
new_objects.append(dup)
|
|
|
|
# populating spacing with options
|
|
self.place_in_pages(new_objects)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
e = InkscapeUprint()
|
|
e.run()
|
|
|