示例#1
0
 def add_point(self, point, doc_point):
     subpoint = bezier_base_point(point)
     if self.path[0]:
         w = h = config.curve_point_sensitivity_size
         start = self.canvas.point_doc_to_win(self.path[0])
         if self.points:
             p = self.canvas.point_doc_to_win(self.points[-1])
             last = bezier_base_point(p)
             if is_point_in_rect2(subpoint, start, w,
                                  h) and len(self.points) > 1:
                 self.path[2] = sk2const.CURVE_CLOSED
                 if len(point) == 2:
                     self.points.append([] + self.path[0])
                 else:
                     p = doc_point
                     self.points.append(
                         [p[0], p[1], [] + self.path[0], p[3]])
                 if not self.ctrl_mask:
                     self.release_curve()
                 else:
                     self.draw = False
                 self.on_timer()
             elif not is_point_in_rect2(subpoint, last, w, h):
                 self.points.append(doc_point)
                 self.path[1] = self.points
         else:
             if not is_point_in_rect2(subpoint, start, w, h):
                 self.points.append(doc_point)
                 self.path[1] = self.points
     else:
         self.path[0] = doc_point
         self.paths.append(self.path)
示例#2
0
	def add_point(self, point, doc_point):
		subpoint = bezier_base_point(point)
		if self.path[0]:
			w = h = config.curve_point_sensitivity_size
			start = self.canvas.point_doc_to_win(self.path[0])
			if self.points:
				p = self.canvas.point_doc_to_win(self.points[-1])
				last = bezier_base_point(p)
				if is_point_in_rect2(subpoint, start, w, h) and len(self.points) > 1:
					self.path[2] = const.CURVE_CLOSED
					if len(point) == 2:
						self.points.append([] + self.path[0])
					else:
						p = doc_point
						self.points.append([p[0], p[1], [] + self.path[0], p[3]])
					if not self.ctrl_mask:
						self.release_curve()
					else:
						self.draw = False
					self.repaint()
				elif not is_point_in_rect2(subpoint, last, w, h):
					self.points.append(doc_point)
					self.path[1] = self.points
			else:
				if not is_point_in_rect2(subpoint, start, w, h):
					self.points.append(doc_point)
					self.path[1] = self.points
		else:
			self.path[0] = doc_point
			self.paths.append(self.path)
示例#3
0
    def mouse_up(self, event):
        if not self.draw:
            return
        self.create = False
        self.set_key_mask(event)
        self.control_point2, self.control_point2_doc = self._calc_points(event)
        self.cursor = [] + self.control_point2
        if self.path[0]:
            if self.alt_mask:
                self.point, self.point_doc = self._calc_points(event)
                self.add_point([] + self.point, [] + self.point_doc)
                self.control_point0 = [] + self.point
                self.cursor = event.get_point()
                self.curve_point = [] + self.point
            elif self.control_point2:
                self.point = [] + self.curve_point
                self.point_doc = [] + self.curve_point_doc
                self.control_point1 = contra_point(self.control_point2,
                                                   self.curve_point)
                self.control_point1_doc = contra_point(self.control_point2_doc,
                                                       self.curve_point_doc)

                node_type = sk2const.NODE_SYMMETRICAL
                if len(self.points):
                    bp_doc = bezier_base_point(self.points[-1])
                else:
                    bp_doc = self.path[0]
                if self.control_point0_doc == bp_doc and \
                        self.control_point1_doc == self.curve_point_doc:
                    node_type = sk2const.NODE_CUSP
                    p0d = midpoint(bp_doc, self.curve_point_doc, 1.0 / 3.0)
                    self.control_point0_doc = p0d
                    p1d = midpoint(bp_doc, self.curve_point_doc, 2.0 / 3.0)
                    self.control_point1_doc = p1d
                    self.control_point0 = self.canvas.doc_to_win(p0d)
                    self.control_point1 = self.canvas.doc_to_win(p1d)

                self.add_point([
                    self.control_point0, self.control_point1, self.curve_point,
                    node_type
                ], [
                    self.control_point0_doc, self.control_point1_doc,
                    self.curve_point_doc, node_type
                ])

                self.control_point0 = [] + self.control_point2
                self.control_point0_doc = [] + self.control_point2_doc
                snapped = self._calc_points(event)
                self.cursor = [] + snapped[0]
                self.curve_point, self.curve_point_doc = snapped
        else:
            self.point, self.point_doc = self._calc_points(event)
            self.add_point(self.point, self.point_doc)
            self.control_point0 = [] + self.point
            self.control_point0_doc = [] + self.point_doc
        self.on_timer()
示例#4
0
	def mouse_up(self, event):
		if self.draw:
			self.create = False
			self.ctrl_mask = False
			self.alt_mask = False
			p = event.get_point()
			self.control_point2, self.control_point2_doc = self.snap.snap_point(p)[1:]
			self.ctrl_mask = event.is_ctrl()
			self.alt_mask = event.is_alt()
			if self.path[0]:
				if self.alt_mask:
					p = event.get_point()
					self.point, self.point_doc = self.snap.snap_point(p)[1:]
					self.add_point([] + self.point, [] + self.point_doc)
					self.control_point0 = [] + self.point
					self.cursor = event.get_point()
					self.curve_point = [] + self.point
				elif self.control_point2:
					self.point = [] + self.curve_point
					self.point_doc = [] + self.curve_point_doc
					self.control_point1 = contra_point(self.control_point2,
															 self.curve_point)
					self.control_point1_doc = contra_point(self.control_point2_doc,
															 self.curve_point_doc)

					node_type = const.NODE_SYMMETRICAL
					if len(self.points):
						bp_doc = bezier_base_point(self.points[-1])
					else:
						bp_doc = self.path[0]
					if self.control_point0_doc == bp_doc and \
					self.control_point1_doc == self.curve_point_doc:
						node_type = const.NODE_CUSP
						self.control_point0_doc = midpoint(bp_doc, self.curve_point_doc, 1.0 / 3.0)
						self.control_point1_doc = midpoint(bp_doc, self.curve_point_doc, 2.0 / 3.0)
						self.control_point0 = self.canvas.doc_to_win(self.control_point0_doc)
						self.control_point1 = self.canvas.doc_to_win(self.control_point1_doc)
					self.add_point([self.control_point0, self.control_point1,
								self.curve_point, node_type],
								[self.control_point0_doc, self.control_point1_doc,
								self.curve_point_doc, node_type])

					self.control_point0 = [] + self.control_point2
					self.control_point0_doc = [] + self.control_point2_doc
					p = event.get_point()
					self.cursor = [] + p
					self.curve_point, self.curve_point_doc = self.snap.snap_point(p)[1:]
			else:
				p = event.get_point()
				self.point, self.point_doc = self.snap.snap_point(p)[1:]
				self.add_point(self.point, self.point_doc)
				self.control_point0 = [] + self.point
				self.control_point0_doc = [] + self.point_doc
			self.on_timer()
示例#5
0
 def update_arrows(self):
     self.cache_arrows = []
     if self.is_curve and self.style[1]:
         stroke = self.style[1]
         arrs = stroke[9]
         if not arrs:
             return
         for path in self.paths:
             if path[-1] == sk2const.CURVE_CLOSED:
                 self.cache_arrows.append([])
                 continue
             tr = libgeom.multiply_trafo
             coef = self.cache_line_width
             end = start = None
             # end arrow
             if isinstance(arrs[0], int):
                 end_trafo = [coef, 0.0, 0.0, coef, 0.0, 0.0]
                 p1 = libgeom.apply_trafo_to_point(path[0], self.trafo)
                 p0 = libgeom.apply_trafo_to_point(path[1][0], self.trafo)
                 if libgeom.is_curve_point(p0):
                     p0 = p0[0]
                 angle = libgeom.get_point_angle(p1, p0)
                 end_trafo = tr(end_trafo, libgeom.trafo_rotate(angle))
                 trafo = [1.0, 0.0, 0.0, 1.0, p1[0], p1[1]]
                 end_trafo = tr(end_trafo, trafo)
                 end = arrows.get_arrow_cpath(arrs[0], end_trafo)
             #start arrow
             if isinstance(arrs[1], int):
                 start_trafo = [coef, 0.0, 0.0, coef, 0.0, 0.0]
                 p1 = libgeom.apply_trafo_to_point(path[1][-1], self.trafo)
                 if len(path[1]) == 1:
                     p0 = libgeom.apply_trafo_to_point(path[0], self.trafo)
                 else:
                     if libgeom.is_curve_point(p1):
                         p0 = p1[1]
                         p1 = p1[2]
                     else:
                         p0 = libgeom.bezier_base_point(path[1][-2])
                         p0 = libgeom.apply_trafo_to_point(p0, self.trafo)
                 angle = libgeom.get_point_angle(p1, p0)
                 start_trafo = tr(start_trafo, libgeom.trafo_rotate(angle))
                 trafo = [1.0, 0.0, 0.0, 1.0, p1[0], p1[1]]
                 start_trafo = tr(start_trafo, trafo)
                 start = arrows.get_arrow_cpath(arrs[1], start_trafo)
             self.cache_arrows.append([end, start])
示例#6
0
 def update_from_obj(self):
     self.paths = apply_trafo_to_paths(self.obj.paths, self.obj.trafo)
     path = self.paths[-1]
     if path[-1] == sk2const.CURVE_OPENED:
         self.path = path
         self.points = self.path[1]
         paths = self.canvas.paths_doc_to_win(self.paths)
         self.canvas.renderer.paint_curve(paths)
         last = bezier_base_point(self.points[-1])
         self.control_point0 = self.canvas.point_doc_to_win(last)
         self.control_point0_doc = [] + last
         self.point = [] + self.control_point0
         self.point_doc = [] + last
         self.control_point2 = [] + self.control_point0
         self.control_point2_doc = [] + last
         self.curve_point = [] + self.control_point0
         self.curve_point_doc = [] + last
     else:
         paths = self.canvas.paths_doc_to_win(self.paths)
         self.canvas.renderer.paint_curve(paths)
     self.draw = True
示例#7
0
	def update_from_obj(self):
		self.paths = apply_trafo_to_paths(self.obj.paths, self.obj.trafo)
		path = self.paths[-1]
		if path[-1] == const.CURVE_OPENED:
			self.path = path
			self.points = self.path[1]
			paths = self.canvas.paths_doc_to_win(self.paths)
			self.canvas.renderer.paint_curve(paths)
			last = bezier_base_point(self.points[-1])
			self.control_point0 = self.canvas.point_doc_to_win(last)
			self.control_point0_doc = [] + last
			self.point = [] + self.control_point0
			self.point_doc = [] + last
			self.control_point2 = [] + self.control_point0
			self.control_point2_doc = [] + last
			self.curve_point = [] + self.control_point0
			self.curve_point_doc = [] + last
		else:
			paths = self.canvas.paths_doc_to_win(self.paths)
			self.canvas.renderer.paint_curve(paths)
		self.draw = True