def count_bbox(self, objs):
bbox = []
for obj in objs:
if obj.is_selectable():
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
elif obj.childs:
bbox = libgeom.sum_bbox(bbox, self.count_bbox(obj.childs))
return bbox
def count_bbox(self, objs):
bbox = []
for obj in objs:
if obj.is_selectable:
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
elif obj.childs:
bbox = libgeom.sum_bbox(bbox, self.count_bbox(obj.childs))
return bbox
def create_jobs(self):
if self.obj_stack:
m11, m21, m12, m22, dx, dy = SK2_to_PLT_TRAFO
if self.plt_doc.config.force_zero:
bbox = []
bbox += self.obj_stack[0].cache_bbox
for obj in self.obj_stack:
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
dx = -bbox[0] * m11
dy = -bbox[1] * m22
trafo = [m11, m21, m12, m22, dx, dy]
obj_num = len(self.obj_stack)
for obj in self.obj_stack:
self.counter += 1
position = float(self.counter) / obj_num
if position - self.position > 0.05:
msg = _('Saving in process...')
events.emit(events.FILTER_INFO, msg, position)
self.position = position
paths = libgeom.get_flattened_path(obj, trafo,
self.plt_doc.config.tolerance)
if paths is None: continue
for path in paths:
if path and path[1]:
self.jobs.append(plt_model.PltJob('', path))
def update_bbox(self):
self.bbox = []
if self.objs:
self.bbox += self.objs[0].cache_bbox
for obj in self.objs:
self.bbox = sum_bbox(self.bbox, obj.cache_bbox)
self.update_markers()
def cdc_draw_move_frame(self, trafo):
bbox = self.presenter.selection.bbox
if bbox:
cpath = libcairo.convert_bbox_to_cpath(bbox)
libcairo.apply_trafo(cpath, trafo)
libcairo.apply_trafo(cpath, self.canvas.trafo)
bbox = self.cdc_to_int(*libcairo.get_cpath_bbox(cpath))
frame = self.cdc_bbox_to_frame(bbox)
if self.frame and frame == self.frame:
return
if not self.frame:
self.frame = frame
bbox2 = self.cdc_frame_to_bbox(self.frame)
frame_sum = self.cdc_bbox_to_frame(libgeom.sum_bbox(bbox, bbox2))
x, y, w, h = self.cdc_normalize_rect(*frame_sum)
self.frame = frame
surface = cairo.ImageSurface(cairo.FORMAT_RGB24, w + 2, h + 2)
ctx = cairo.Context(surface)
ctx.set_source_surface(self.surface, -x + 1, -y + 1)
ctx.paint()
ctx.set_matrix(cairo.Matrix(1.0, 0.0, 0.0, 1.0, -x + 1, -y + 1))
self._cdc_draw_cpath(ctx, cpath)
dc = wx.ClientDC(self.canvas)
dc.DrawBitmap(copy_surface_to_bitmap(surface), x - 1, y - 1)
self.cdc_reflect_snapping()
def cdc_draw_frame(self, start, end, temp_surfase=False):
if start and end:
if self.frame:
if start == self.frame[0] and end == self.frame[1]:
return
cpath = libcairo.convert_bbox_to_cpath(start + end)
bbox = self.cdc_to_int(*libcairo.get_cpath_bbox(cpath))
frame = self.cdc_bbox_to_frame(bbox)
if not self.frame:
self.frame = frame
bbox2 = self.cdc_frame_to_bbox(self.frame)
frame_sum = self.cdc_bbox_to_frame(libgeom.sum_bbox(bbox, bbox2))
x, y, w, h = self.cdc_normalize_rect(*frame_sum)
self.frame = frame
surface = cairo.ImageSurface(cairo.FORMAT_RGB24, w + 2, h + 2)
ctx = cairo.Context(surface)
if temp_surfase:
ctx.set_source_surface(self.temp_surface, -x + 1, -y + 1)
else:
ctx.set_source_surface(self.surface, -x + 1, -y + 1)
ctx.paint()
ctx.set_matrix(cairo.Matrix(1.0, 0.0, 0.0, 1.0, -x + 1, -y + 1))
self._cdc_draw_cpath(ctx, cpath)
self.canvas.dc.put_surface(surface, x - 1, y - 1)
self.cdc_reflect_snapping()
def update_bbox(self): self.bbox = [] if self.objs: self.bbox += self.objs[0].cache_bbox for obj in self.objs: self.bbox = libgeom.sum_bbox(self.bbox, obj.cache_bbox) self.update_markers()
def create_jobs(self):
if self.obj_stack:
m11, m21, m12, m22, dx, dy = SK2_to_PLT_TRAFO
if self.plt_doc.config.force_zero:
bbox = []
bbox += self.obj_stack[0].cache_bbox
for obj in self.obj_stack:
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
dx = -bbox[0] * m11
dy = -bbox[1] * m22
trafo = [m11, m21, m12, m22, dx, dy]
obj_num = len(self.obj_stack)
for obj in self.obj_stack:
self.counter += 1
position = float(self.counter) / obj_num
if position - self.position > 0.05:
msg = _('Saving in process...')
events.emit(events.FILTER_INFO, msg, position)
self.position = position
paths = libgeom.get_flattened_path(
obj, trafo, self.plt_doc.config.tolerance)
if paths is None: continue
for path in paths:
if path and path[1]:
self.jobs.append(plt_model.PltJob('', path))
def do_cutting(self):
cut_bbox = None
ret = get_cut_dialog(self.app)
if ret == gtk.RESPONSE_ACCEPT:
#Collect all objects
page = self.doc_presenter.methods.get_pages()[-1]
objs = []
for layer in page.childs:
for obj in layer.childs:
objs.append(obj)
if not objs:
first = _('Cannot cutting in file')
sec = _('There are no objects in document.')
msg = ("%s '%s'.") % (first, config.output_file)
msg_dialog(self.app.mw, self.app.appdata.app_name, msg, sec)
return
try:
saver = get_saver('file.plt')
if config.cut_bbox:
bbox = []
bbox += objs[0].cache_bbox
for obj in objs:
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
layer = page.childs[-1]
cut_bbox = model.Rectangle(layer.config, layer, bbox)
layer.childs.append(cut_bbox)
cut_bbox.update()
pd = ProgressDialog(_('Cutting...'), self.app.mw)
ret = pd.run(saver, [
self.doc_presenter, config.output_file, True, {
'tolerance': config.tolerance
}
])
if ret == gtk.RESPONSE_OK:
if not pd.error_info is None:
pd.destroy()
raise IOError(*pd.error_info)
pd.destroy()
else:
pd.destroy()
raise IOError(_('Error while saving'), config.output_file)
except IOError:
details = sys.exc_info()[1].__str__() + sys.exc_info(
)[2].__str__()
first = _('Cannot cutting!')
sec = _('Please check file name and write permissions')
msg = ("%s '%s'.") % (first, config.output_file)
msg_dialog(self.app.mw, self.app.appdata.app_name, msg, sec,
details)
if not cut_bbox is None:
self.doc_presenter.methods.delete_object(cut_bbox)
def _sum_bbox(bbox0, bbox1):
if bbox0 is None and bbox1 is None:
return None
if bbox0 is None:
return [] + bbox1
if bbox1 is None:
return [] + bbox0
return libgeom.sum_bbox(bbox0, bbox1)
def do_cutting(self):
cut_bbox = None
ret = get_cut_dialog(self.app)
if ret == gtk.RESPONSE_ACCEPT:
#Collect all objects
page = self.doc_presenter.methods.get_pages()[-1]
objs = []
for layer in page.childs:
for obj in layer.childs:
objs.append(obj)
if not objs:
first = _('Cannot cutting in file')
sec = _('There are no objects in document.')
msg = ("%s '%s'.") % (first, config.output_file)
msg_dialog(self.app.mw, self.app.appdata.app_name, msg, sec)
return
try:
saver = get_saver('file.plt')
if config.cut_bbox:
bbox = []
bbox += objs[0].cache_bbox
for obj in objs:
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
layer = page.childs[-1]
cut_bbox = model.Rectangle(layer.config, layer, bbox)
layer.childs.append(cut_bbox)
cut_bbox.update()
pd = ProgressDialog(_('Cutting...'), self.app.mw)
ret = pd.run(saver, [self.doc_presenter,
config.output_file,
True,
{'tolerance':config.tolerance}])
if ret == gtk.RESPONSE_OK:
if not pd.error_info is None:
pd.destroy()
raise IOError(*pd.error_info)
pd.destroy()
else:
pd.destroy()
raise IOError(_('Error while saving'), config.output_file)
except IOError:
details = sys.exc_info()[1].__str__() + sys.exc_info()[2].__str__()
first = _('Cannot cutting!')
sec = _('Please check file name and write permissions')
msg = ("%s '%s'.") % (first, config.output_file)
msg_dialog(self.app.mw, self.app.appdata.app_name, msg, sec, details)
if not cut_bbox is None:
self.doc_presenter.methods.delete_object(cut_bbox)
def create_jobs(self):
if self.obj_stack:
m11, m21, m12, m22, dx, dy = SK2_to_PLT_TRAFO
if self.plt_doc.config.plt_force_zero:
bbox = []
bbox += self.obj_stack[0].cache_bbox
for obj in self.obj_stack:
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
dx = -bbox[0] * m11
dy = -bbox[1] * m22
trafo = [
m11 * self.plt_doc.config.plt_scale, m21, m12,
m22 * self.plt_doc.config.plt_scale, dx, dy
]
obj_num = len(self.obj_stack)
for obj in self.obj_stack:
self.counter += 1
position = float(self.counter) / obj_num
if position - self.position > 0.05:
msg = _('Saving in progress...')
events.emit(events.FILTER_INFO, msg, position)
self.position = position
paths = libgeom.get_flattened_paths(
obj, trafo, self.plt_doc.config.plt_tolerance)
if paths is None:
continue
for path in paths:
if self.plt_doc.config.plt_optimize:
rl = self.plt_doc.config.plt_rounding_level
path[0] = [round(x / rl) * rl for x in path[0]]
start0, start1 = [], path[0]
points = []
for point in path[1]:
point = [round(x / rl) * rl for x in point]
if not point == start1:
if point == start0:
points = points[:-1]
if len(points) > 1:
start0, start1 = points[-1], start0
elif points:
start0, start1 = [], start0
continue
start0, start1 = start1, point
points.append(point)
path[1] = points
if path and path[1]:
self.jobs.append(plt_model.PltJob('', path))
def _ellipse(self, element):
center, chunk = self.read_point(element.params)
cdp1, chunk = self.read_point(chunk)
cdp2, chunk = self.read_point(chunk)
cdp3 = libgeom.contra_point(cdp1, center)
cdp4 = libgeom.contra_point(cdp2, center)
bbox = libgeom.sum_bbox(cdp1 + cdp2, cdp3 + cdp4)
bbox = libgeom.apply_trafo_to_bbox(bbox, self.get_trafo())
rect = libgeom.bbox_to_rect(bbox)
circle = sk2_model.Circle(self.layer.config, self.layer, rect,
style=self.get_style(fill=True))
self.layer.childs.append(circle)
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 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 update_bbox(self):
bp = libgeom.apply_trafo_to_point([0.0, 0.0], self.trafo)
self.cache_bbox = 2 * bp
index = 0
for item in self.cache_cpath:
if not item:
data = self.cache_layout_data[index]
bp = [data[0], data[4]]
bbox = 2 * libgeom.apply_trafo_to_point(bp, self.trafo)
else:
bbox = libgeom.get_cpath_bbox(item)
if not self.cache_bbox:
self.cache_bbox = bbox
else:
self.cache_bbox = libgeom.sum_bbox(self.cache_bbox, bbox)
index += 1
def update_bbox(self): bp = libgeom.apply_trafo_to_point([0.0, 0.0], self.trafo) self.cache_bbox = 2 * bp index = 0 for item in self.cache_cpath: if not item: data = self.cache_layout_data[index] bp = [data[0], data[4]] bbox = 2 * libgeom.apply_trafo_to_point(bp, self.trafo) else: bbox = libgeom.get_cpath_bbox(item) if not self.cache_bbox: self.cache_bbox = bbox else: self.cache_bbox = libgeom.sum_bbox(self.cache_bbox, bbox) index += 1
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 render(objs, cms):
bbox = reduce(lambda a, b: libgeom.sum_bbox(a, b.cache_bbox), objs, [])
w, h = libgeom.bbox_size(bbox)
x, y = libgeom.bbox_center(bbox)
trafo = (1.0, 0, 0, -1.0, w / 2.0 - x, h / 2.0 + y)
canvas_matrix = cairo.Matrix(*trafo)
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(w), int(h))
ctx = cairo.Context(surface)
ctx.set_matrix(canvas_matrix)
rend = crenderer.CairoRenderer(cms)
rend.antialias_flag = True
rend.render(ctx, objs)
image_stream = StringIO()
surface.write_to_png(image_stream)
return image_stream
def _get_fixed_bbox(self, obj):
bbox = obj.cache_bbox
if obj.is_curve and obj.cache_arrows:
for pair in obj.cache_arrows:
for item in pair:
if item:
arrow_bbox = libgeom.get_cpath_bbox(item)
bbox = libgeom.sum_bbox(bbox, arrow_bbox)
bbox = self.presenter.canvas.bbox_doc_to_win(bbox)
bbox = libgeom.normalize_bbox(bbox)
if not bbox[2] - bbox[0]:
bbox[2] += 4
bbox[0] -= 4
if not bbox[3] - bbox[1]:
bbox[3] += 4
bbox[1] -= 4
return bbox
def simplify_doc(doc):
#Other pages deleting
page = doc.methods.get_page()
page.parent.childs = [
page,
]
#Master layers merging
master_layers = doc.methods.get_master_layers()
if master_layers:
page.childs += master_layers
master_layers[0].parent.childs = []
#Model update
doc.update()
#Unsupported and empty objects removing
for layer in [] + page.childs:
for obj in [] + layer.childs:
_check_object(doc, obj)
if not layer.childs and len(page.childs) > 1:
doc.methods.delete_object(layer)
#Collect all objects
objs = []
for layer in page.childs:
for obj in layer.childs:
objs.append(obj)
if not objs: return False
#Move to origin
bbox = []
bbox += objs[0].cache_bbox
for obj in objs:
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
dx = -bbox[0]
dy = -bbox[1]
trafo = [1.0, 0.0, 0.0, 1.0, dx, dy]
for obj in objs:
obj.apply_trafo(trafo)
return True
def make_template(self):
self.rifx = self.cmx_cfg.rifx
cont_obj = self.make_el(cmx_const.CONT_ID)
self.cmx_model.add(cont_obj)
self.cmx_model.add(self.make_el(cmx_const.CCMM_ID))
if self.cmx_cfg.save_preview:
self.cmx_model.add(
self.make_el(cmx_const.DISP_ID, bmp=self._make_preview()))
if self.cmx_cfg.pack:
self.root = self.make_el(cmx_const.PACK_ID)
self.cmx_model.add(self.root)
objs = []
for page in self.sk2_mtds.get_pages():
self.root.add(self.make_el(cmx_const.PAGE_ID))
self.root.add(self.make_el(cmx_const.RLST_ID))
if not self.cmx_cfg.v1:
self.root.add(self.make_el(cmx_const.RLST_ID))
for layer in page.childs:
objs.extend(layer.childs)
cmx_ids = [
cmx_const.ROTL_ID, cmx_const.ROTT_ID, cmx_const.RPEN_ID,
cmx_const.RDOT_ID, cmx_const.ROTA_ID, cmx_const.RCLR_ID,
cmx_const.RSCR_ID, cmx_const.INDX_ID
]
for cmx_id in cmx_ids:
self.root.add(self.make_el(cmx_id))
self.cmx_model.update_map()
self.coef = uc2const.pt_to_in * 1000.0
factor = 0.001
if objs:
bbox = [] + objs[0].cache_bbox
for obj in objs[1:]:
bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)
max_value = max([abs(item) for item in bbox])
frame = 255 * 255 / 2.0
self.coef = uc2const.pt_to_in * frame / max_value
factor = max_value / frame
cont_obj.set('factor', utils.py_float2double(factor, self.rifx))
cont_obj.set('unit', cmx_const.CONT_UNIT_IN)
def simplify_doc(doc): #Other pages deleting page = doc.methods.get_page() page.parent.childs = [page, ] #Master layers merging master_layers = doc.methods.get_master_layers() if master_layers: page.childs += master_layers master_layers[0].parent.childs = [] #Model update doc.update() #Unsupported and empty objects removing for layer in [] + page.childs: for obj in [] + layer.childs: _check_object(doc, obj) if not layer.childs and len(page.childs) > 1: doc.methods.delete_object(layer) #Collect all objects objs = [] for layer in page.childs: for obj in layer.childs: objs.append(obj) if not objs: return False #Move to origin bbox = [] bbox += objs[0].cache_bbox for obj in objs: bbox = libgeom.sum_bbox(bbox, obj.cache_bbox) dx = -bbox[0] dy = -bbox[1] trafo = [1.0, 0.0, 0.0, 1.0, dx, dy] for obj in objs: obj.apply_trafo(trafo) return True
def cdc_draw_move_frame(self, trafo): bbox = self.presenter.selection.bbox if bbox: cpath = libcairo.convert_bbox_to_cpath(bbox) libcairo.apply_trafo(cpath, trafo) libcairo.apply_trafo(cpath, self.canvas.trafo) bbox = self.cdc_to_int(*libcairo.get_cpath_bbox(cpath)) frame = self.cdc_bbox_to_frame(bbox) if self.frame and frame == self.frame:return if not self.frame:self.frame = frame bbox2 = self.cdc_frame_to_bbox(self.frame) frame_sum = self.cdc_bbox_to_frame(libgeom.sum_bbox(bbox, bbox2)) x, y, w, h = self.cdc_normalize_rect(*frame_sum) self.frame = frame surface = cairo.ImageSurface(cairo.FORMAT_RGB24, w + 2, h + 2) ctx = cairo.Context(surface) ctx.set_source_surface(self.surface, -x + 1, -y + 1) ctx.paint() ctx.set_matrix(cairo.Matrix(1.0, 0.0, 0.0, 1.0, -x + 1, -y + 1)) self._cdc_draw_cpath(ctx, cpath) dc = wx.ClientDC(self.canvas) dc.DrawBitmap(copy_surface_to_bitmap(surface), x - 1, y - 1) self.cdc_reflect_snapping()
def cdc_draw_frame(self, start, end, temp_surfase=False): if start and end: if self.frame: if start == self.frame[0] and end == self.frame[1]:return cpath = libcairo.convert_bbox_to_cpath(start + end) bbox = self.cdc_to_int(*libcairo.get_cpath_bbox(cpath)) frame = self.cdc_bbox_to_frame(bbox) if not self.frame:self.frame = frame bbox2 = self.cdc_frame_to_bbox(self.frame) frame_sum = self.cdc_bbox_to_frame(libgeom.sum_bbox(bbox, bbox2)) x, y, w, h = self.cdc_normalize_rect(*frame_sum) self.frame = frame surface = cairo.ImageSurface(cairo.FORMAT_RGB24, w + 2, h + 2) ctx = cairo.Context(surface) if temp_surfase: ctx.set_source_surface(self.temp_surface, -x + 1, -y + 1) else: ctx.set_source_surface(self.surface, -x + 1, -y + 1) ctx.paint() ctx.set_matrix(cairo.Matrix(1.0, 0.0, 0.0, 1.0, -x + 1, -y + 1)) self._cdc_draw_cpath(ctx, cpath) dc = wx.ClientDC(self.canvas) dc.DrawBitmap(copy_surface_to_bitmap(surface), x - 1, y - 1) self.cdc_reflect_snapping()
def update_bbox(self): if self.childs: self.cache_bbox = deepcopy(self.childs[0].cache_bbox) for child in self.childs[1:]: self.cache_bbox = libgeom.sum_bbox(self.cache_bbox, child.cache_bbox)
