Esempio n. 1
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()
Esempio n. 2
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()
Esempio n. 3
0
 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)
Esempio n. 4
0
 def repaint_draw(self):
     if self.path[0] or self.paths:
         paths = self.canvas.paths_doc_to_win(self.paths)
         cursor = self.cursor
         if not self.path[0]:
             cursor = []
         elif cursor and not self.create:
             snapped = self.snap.snap_point(cursor)[1:]
             self.curve_point, self.curve_point_doc = snapped
         path = []
         if self.control_point0:
             if not self.control_point2_doc:
                 return True
             self.control_point1_doc = contra_point(self.control_point2_doc,
                                                    self.curve_point_doc)
             path = [
                 self.point_doc,
                 [
                     self.control_point0_doc, self.control_point1_doc,
                     self.curve_point_doc
                 ], 0
             ]
             path = self.canvas.paths_doc_to_win([
                 path,
             ])[0]
         cpoint = []
         if self.create:
             cpoint = self.canvas.doc_to_win(self.control_point2_doc)
         self.canvas.renderer.paint_curve(paths, cursor, path, cpoint)
     return True
Esempio n. 5
0
 def mouse_up(self, event):
     if event.button == LEFT_BUTTON and self.draw:
         self.create = False
         self.ctrl_mask = False
         self.alt_mask = False
         p = [event.x, event.y]
         flag, self.control_point2, self.control_point2_doc = self.snap.snap_point(
             p)
         if event.state & gtk.gdk.CONTROL_MASK: self.ctrl_mask = True
         if event.state & gtk.gdk.MOD1_MASK: self.alt_mask = True
         if self.path[0]:
             if self.alt_mask:
                 p = [event.x, event.y]
                 flag, self.point, self.point_doc = self.snap.snap_point(p)
                 self.add_point([] + self.point, [] + self.point_doc)
                 self.control_point0 = [] + self.point
                 self.cursor = [event.x, event.y]
                 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)
                 self.add_point([
                     self.control_point0, self.control_point1,
                     self.curve_point, const.NODE_SYMMETRICAL
                 ], [
                     self.control_point0_doc, self.control_point1_doc,
                     self.curve_point_doc, const.NODE_SYMMETRICAL
                 ])
                 self.control_point0 = [] + self.control_point2
                 self.control_point0_doc = [] + self.control_point2_doc
                 p = [event.x, event.y]
                 self.cursor = [] + p
                 flag, self.curve_point, self.curve_point_doc = self.snap.snap_point(
                     p)
         else:
             p = [event.x, event.y]
             flag, self.point, self.point_doc = self.snap.snap_point(p)
             self.add_point(self.point, self.point_doc)
             self.control_point0 = [] + self.point
             self.control_point0_doc = [] + self.point_doc
         self.repaint()
Esempio n. 6
0
	def mouse_up(self, event):
		if event.button == LEFT_BUTTON and self.draw:
			self.create = False
			self.ctrl_mask = False
			self.alt_mask = False
			p = [event.x, event.y]
			flag, self.control_point2, self.control_point2_doc = self.snap.snap_point(p)
			if event.state & gtk.gdk.CONTROL_MASK: self.ctrl_mask = True
			if event.state & gtk.gdk.MOD1_MASK : self.alt_mask = True
			if self.path[0]:
				if self.alt_mask:
					p = [event.x, event.y]
					flag, self.point, self.point_doc = self.snap.snap_point(p)
					self.add_point([] + self.point, [] + self.point_doc)
					self.control_point0 = [] + self.point
					self.cursor = [event.x, event.y]
					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)
					self.add_point([self.control_point0, self.control_point1,
								self.curve_point, const.NODE_SYMMETRICAL],
								[self.control_point0_doc, self.control_point1_doc,
								self.curve_point_doc, const.NODE_SYMMETRICAL])
					self.control_point0 = [] + self.control_point2
					self.control_point0_doc = [] + self.control_point2_doc
					p = [event.x, event.y]
					self.cursor = [] + p
					flag, self.curve_point, self.curve_point_doc = self.snap.snap_point(p)
			else:
				p = [event.x, event.y]
				flag, self.point, self.point_doc = self.snap.snap_point(p)
				self.add_point(self.point, self.point_doc)
				self.control_point0 = [] + self.point
				self.control_point0_doc = [] + self.point_doc
			self.repaint()
Esempio n. 7
0
	def repaint(self):
		if self.path[0] or self.paths:
			paths = self.canvas.paths_doc_to_win(self.paths)
			cursor = self.cursor
			if not self.path[0]: cursor = []
			path = []
			if self.control_point0:
				self.control_point1 = contra_point(self.control_point2,
												self.curve_point)
				path = [self.point, [self.control_point0,
									self.control_point1,
									self.curve_point]]
			cpoint = []
			if self.create: cpoint = self.control_point2
			self.canvas.renderer.paint_curve(paths, cursor, path, cpoint)
		return True
Esempio n. 8
0
	def repaint_draw(self):
		if self.path[0] or self.paths:
			paths = self.canvas.paths_doc_to_win(self.paths)
			cursor = self.cursor
			if not self.path[0]: cursor = []
			path = []
			if self.control_point0:
				self.control_point1 = contra_point(self.control_point2,
												self.curve_point)
				path = [self.point, [self.control_point0,
									self.control_point1,
									self.curve_point]]
			cpoint = []
			if self.create: cpoint = self.control_point2
			self.canvas.renderer.paint_curve(paths, cursor, path, cpoint)
		return True
Esempio n. 9
0
 def update_connection(self):
     after = self.get_point_after()
     before = self.get_point_before()
     if self.path.is_closed():
         if self.path.points[0] == self:
             before = self.path.points[-1]
         if not after and self.is_end():
             after = self.path.points[0]
     if after and after.is_curve():
         if self.is_symmetrical():
             after.point[0] = libgeom.contra_point(self.point[1],
                                                   self.point[2])
         if self.is_smooth() and self.is_curve():
             after.point[0] = libgeom.contra_point(self.point[1],
                                                   self.point[2],
                                                   after.point[0])
     elif after and not after.is_curve():
         if self.is_smooth() and self.is_curve():
             lenght = libgeom.distance(self.point[2], after.point)
             if lenght:
                 self.point[1] = libgeom.contra_point(after.point,
                                                      self.point[2],
                                                      self.point[1])
     if before and before.is_curve():
         if before.is_symmetrical():
             before.point[1] = libgeom.contra_point(self.point[0],
                                                    before.point[2])
         if before.is_smooth() and self.is_curve():
             before.point[1] = libgeom.contra_point(self.point[0],
                                                    before.point[2],
                                                    before.point[1])
     elif before and not before.is_curve():
         if self.is_opp_smooth():
             p = before.get_point_before()
             if p:
                 p = p.get_base_point()
                 lenght = libgeom.distance(p, before.point)
                 if lenght:
                     self.point[0] = libgeom.contra_point(p,
                                                          before.point,
                                                          self.point[0])
Esempio n. 10
0
	def update_connection(self):
		after = self.get_point_after()
		before = self.get_point_before()
		if self.path.is_closed():
			if self.path.points[0] == self:
				before = self.path.points[-1]
			if not after and self.is_end():
				after = self.path.points[0]
		if after and after.is_curve():
			if self.is_symmetrical():
				after.point[0] = libgeom.contra_point(self.point[1],
													self.point[2])
			if self.is_smooth() and self.is_curve():
				after.point[0] = libgeom.contra_point(self.point[1],
												self.point[2], after.point[0])
		elif after and not after.is_curve():
			if self.is_smooth() and self.is_curve():
				l = libgeom.distance(self.point[2], after.point)
				if l:
					self.point[1] = libgeom.contra_point(after.point,
												self.point[2], self.point[1])
		if before and before.is_curve():
			if before.is_symmetrical():
				before.point[1] = libgeom.contra_point(self.point[0],
													before.point[2])
			if before.is_smooth() and self.is_curve():
				before.point[1] = libgeom.contra_point(self.point[0],
											before.point[2], before.point[1])
		elif before and not before.is_curve():
			if self.is_opp_smooth():
				p = before.get_point_before()
				if p:
					p = p.get_base_point()
					l = libgeom.distance(p, before.point)
					if l:
						self.point[0] = libgeom.contra_point(p,
												before.point, self.point[0])
Esempio n. 11
0
    def xspline2path(self, pts, cpts, closed=False):
        marker = sk2const.NODE_SMOOTH
        points = []
        pts = pts[:]
        cpts = cpts[:]
        if closed:
            last = pts[-1]
            pts.append(pts[0])
            cpts.append(cpts[0])
        else:
            last = libgeom.contra_point(pts[1], pts[0])
            ipt = libgeom.contra_point(pts[-2], pts[-1])
            pts.append(ipt)
            cpts.append(0.0)

        for idx, cpt in enumerate(cpts[0:-1], 0):
            cur = pts[idx][:]
            foll = pts[idx + 1]

            if cpt == 0.0:
                # 'angular point'
                if not points:
                    points.append(cur)
                else:
                    points.append([c1, cur[:], cur[:], marker])
                c1 = cur[:]
            elif cpt < 0.0:
                # 'interpolation point'
                coef = 0.5 * abs(cpt)
                c2, c1n = figlib.ctrl_points(last, cur, foll, coef)
                if not points:
                    points.append(cur)
                else:
                    points.append([c1, c2, cur, marker])
                c1 = c1n
            else:
                # 'approximated point'
                coef = 1.0 - F13 + F13 * (1.0 - cpt)
                mp = libgeom.midpoint(last, foll)
                node = libgeom.midpoint(mp, cur, coef)
                if not points:
                    points.append(node)
                else:
                    c2 = libgeom.midpoint(last, cur, coef)
                    points.append([c1, c2, node, marker])
                c1 = libgeom.midpoint(foll, cur, coef)
            last = cur

        if closed:
            cpt = cpts[-1]
            cur = pts[-1]
            foll = pts[1]
            if cpt == 0.0:
                points.append([c1, cur[:], cur[:], marker])
            elif cpt < 0.0:
                coef = 0.5 * abs(cpt)
                c2, c1n = figlib.ctrl_points(last, cur, foll, coef)
                points.append([c1, c2, cur, marker])
            else:
                coef = 1.0 - F13 + F13 * (1.0 - cpt)
                mp = libgeom.midpoint(last, foll)
                node = libgeom.midpoint(mp, cur, coef)
                c2 = libgeom.midpoint(last, cur, coef)
                points.append([c1, c2, node, marker])
        return points