Exemple #1
0
 def RemoveObjects(self, infolist):
     if not infolist:
         return NullUndo
     sliced = selinfo.list_to_tree_sliced(infolist)
     sliced.reverse()
     undo = [self.begin_change_children()]
     try:
         for start, end in sliced:
             if type(end) == IntType:
                 # > 1 adjacent children of self. XXX implement this
                 raise SketchInternalError('Deletion of multiple objects'
                                           ' of BlendGroups not yet'
                                           ' implemented')
             elif type(end) == ListType:
                 # remove grandchildren (children of child of self)
                 if start % 2 == 0:
                     # control object changes. This should result in
                     # a recompute() automatically.
                     undo.append(self.objects[start].RemoveObjects(end))
                 else:
                     pass
             else:
                 # a single child. If it's one of our control
                 # objects, remove self
                 undo.append(self.do_remove_child(start))
         undo.append(self.end_change_children())
         return CreateListUndo(undo)
     except:
         Undo(CreateListUndo(undo))
         raise
Exemple #2
0
    def RemoveObjects(self, infolist):
	if not infolist:
	    return NullUndo
	sliced = selinfo.list_to_tree_sliced(infolist)
	sliced.reverse()
	undo = [self.begin_change_children()]
	try:
	    for start, end in sliced:
		if type(end) == IntType:
		    # > 1 adjacent children of self. XXX implement this
		    raise SketchInternalError('Deletion of multiple objects'
					      ' of BlendGroups not yet'
					      ' implemented')
		elif type(end) == ListType:
		    # remove grandchildren (children of child of self)
		    if start % 2 == 0:
			# control object changes. This should result in
			# a recompute() automatically.
			undo.append(self.objects[start].RemoveObjects(end))
		    else:
			pass
		else:
		    # a single child. If it's one of our control
		    # objects, remove self
		    undo.append(self.do_remove_child(start))
	    undo.append(self.end_change_children())
	    return CreateListUndo(undo)
	except:
	    Undo(CreateListUndo(undo))
	    raise
    def MoveObjectsUp(self, infolist):
        sliced = list_to_tree_sliced(infolist)
        sliced.reverse()
        undo = [self.begin_change_children()]
        selection = []
        permutation = range(len(self.objects))
        objects = self.objects
        max = len(objects)
        try:
            for start, end in sliced:
                if type(end) == IntType:
                    if end < max:
                        temp = permutation[start:end]
                        del permutation[start:end]
                        permutation[start + 1:start + 1] = temp
                        selection = selection + select_range(
                            start + 1, objects[start:end])
                    else:
                        selection = selection + select_range(
                            start, objects[start:end])

                elif type(end) == ListType:
                    sel, undo_info = objects[start].MoveObjectsUp(end)
                    if undo_info is not NullUndo:
                        undo.append(undo_info)
                    selection = selection + prepend_idx(start, sel)
                else:
                    if start < max - 1:
                        del permutation[start]
                        permutation.insert(start + 1, start)
                        selection.append(build_info(start + 1, objects[start]))
                    else:
                        selection.append(build_info(start, objects[start]))

            undo_info = self.permute_objects(permutation)
            if undo_info is not NullUndo:
                undo.append(undo_info)
            undo.append(self.end_change_children())
            if len(undo) <= 2:
                undo = NullUndo
                selection = infolist
            else:
                undo = CreateListUndo(undo)
            return (selection, undo)
        except:
            Undo(CreateListUndo(undo))
            raise
Exemple #4
0
    def MoveObjectsUp(self, infolist):
	sliced = list_to_tree_sliced(infolist)
	sliced.reverse()
	undo = [self.begin_change_children()]
	selection = []
	permutation = range(len(self.objects))
	objects = self.objects
	max = len(objects)
	try:
	    for start, end in sliced:
		if type(end) == IntType:
		    if end < max:
			temp = permutation[start:end]
			del permutation[start:end]
			permutation[start + 1:start + 1] = temp
			selection = selection + select_range(start + 1,
							   objects[start:end])
		    else:
			selection = selection + select_range(start,
							   objects[start:end])

		elif type(end) == ListType:
		    sel, undo_info = objects[start].MoveObjectsUp(end)
		    if undo_info is not NullUndo:
			undo.append(undo_info)
		    selection = selection + prepend_idx(start, sel)
		else:
		    if start < max - 1:
			del permutation[start]
			permutation.insert(start + 1, start)
			selection.append(build_info(start + 1, objects[start]))
		    else:
			selection.append(build_info(start, objects[start]))

	    undo_info = self.permute_objects(permutation)
	    if undo_info is not NullUndo:
		undo.append(undo_info)
	    undo.append(self.end_change_children())
	    if len(undo) <= 2:
		undo = NullUndo
		selection = infolist
	    else:
		undo = CreateListUndo(undo)
	    return (selection, undo)
	except:
	    Undo(CreateListUndo(undo))
	    raise
 def RemoveObjects(self, infolist):
     if not infolist:
         return NullUndo
     sliced = list_to_tree_sliced(infolist)
     sliced.reverse()  # important!
     undo = [self.begin_change_children()]
     try:
         for start, end in sliced:
             if type(end) == IntType:
                 undo.append(self.RemoveSlice(start, end))
             elif type(end) == ListType:
                 undo.append(self.objects[start].RemoveObjects(end))
             else:
                 undo.append(self.Remove(end, start))
         undo.append(self.end_change_children())
         return CreateListUndo(undo)
     except:
         Undo(CreateListUndo(undo))
         raise
Exemple #6
0
    def RemoveObjects(self, infolist):
	if not infolist:
	    return NullUndo
	sliced = list_to_tree_sliced(infolist)
	sliced.reverse() # important!
	undo = [self.begin_change_children()]
	try:
	    for start, end in sliced:
		if type(end) == IntType:
		    undo.append(self.RemoveSlice(start, end))
		elif type(end) == ListType:
		    undo.append(self.objects[start].RemoveObjects(end))
		else:
		    undo.append(self.Remove(end, start))
	    undo.append(self.end_change_children())
	    return CreateListUndo(undo)
	except:
	    Undo(CreateListUndo(undo))
	    raise
    def move_objects_to_top(self, infolist, to_bottom=0):
        # Implement the public methods MoveToTop (if to_bottom is false)
        # and MoveToBottom (if to_bottom is true).
        sliced = list_to_tree_sliced(infolist)
        sliced.reverse()

        undo = [self.begin_change_children()]
        selection = []
        idxs = []
        permutation = range(len(self.objects))
        try:
            for start, end in sliced:
                if type(end) == IntType:
                    # a contiguous range of self's children (start:end)
                    idxs[:0] = permutation[start:end]
                    del permutation[start:end]
                elif type(end) == ListType:
                    # children of self.objects[start]
                    child = self.objects[start]
                    sel, undo_info = child.move_objects_to_top(end, to_bottom)
                    if undo_info is not NullUndo:
                        undo.append(undo_info)
                    selection = selection + prepend_idx(start, sel)
                else:
                    # a single object (self.object[start])
                    idxs.insert(0, start)
                    del permutation[start]

            if idxs:
                # direct children of self are involved: apply the
                # permutation
                if to_bottom:
                    permutation = idxs + permutation
                else:
                    permutation = permutation + idxs
                undo_info = self.permute_objects(permutation)
                if undo_info is not NullUndo:
                    undo.append(undo_info)
            # finished:
            undo.append(self.end_change_children())
            if len(undo) <= 2:
                # We haven't really done anything (undo has length 2),
                # so we just pass the selection info back unchanged
                selection = infolist
                undo = NullUndo
            else:
                # We have done something, so figure out the new
                # selection info
                undo = CreateListUndo(undo)

                if to_bottom:
                    selection = selection \
                       + select_range(0, self.objects[:len(idxs)])
                else:
                    min = len(self.objects) - len(idxs)
                    selection = selection \
                       + select_range(min, self.objects[min:])
            return (selection, undo)
        except:
            # Ooops, something's gone wrong. Undo everything we've done
            # so far... (hmm, this currently fails to undo everything if
            # undo.append(undo_info) fails... (the undo_info involved
            # would be lost))
            Undo(CreateListUndo(undo))
            raise
Exemple #8
0
    def move_objects_to_top(self, infolist, to_bottom = 0):
	# Implement the public methods MoveToTop (if to_bottom is false)
	# and MoveToBottom (if to_bottom is true).
	sliced = list_to_tree_sliced(infolist)
	sliced.reverse()

	undo = [self.begin_change_children()]
	selection = []
	idxs = []
	permutation = range(len(self.objects))
	try:
	    for start, end in sliced:
		if type(end) == IntType:
		    # a contiguous range of self's children (start:end)
		    idxs[:0] = permutation[start:end]
		    del permutation[start:end]
		elif type(end) == ListType:
		    # children of self.objects[start]
		    child = self.objects[start]
		    sel, undo_info = child.move_objects_to_top(end, to_bottom)
		    if undo_info is not NullUndo:
			undo.append(undo_info)
		    selection = selection + prepend_idx(start, sel)
		else:
		    # a single object (self.object[start])
		    idxs.insert(0, start)
		    del permutation[start]

	    if idxs:
		# direct children of self are involved: apply the
		# permutation
		if to_bottom:
		    permutation = idxs + permutation
		else:
		    permutation = permutation + idxs
		undo_info = self.permute_objects(permutation)
		if undo_info is not NullUndo:
		    undo.append(undo_info)
	    # finished:
	    undo.append(self.end_change_children())
	    if len(undo) <= 2:
		# We haven't really done anything (undo has length 2),
		# so we just pass the selection info back unchanged
		selection = infolist
		undo = NullUndo
	    else:
		# We have done something, so figure out the new
		# selection info
		undo = CreateListUndo(undo)

		if to_bottom:
		    selection = selection \
				+ select_range(0, self.objects[:len(idxs)])
		else:
		    min = len(self.objects) - len(idxs)
		    selection = selection \
				+ select_range(min, self.objects[min:])
	    return (selection, undo)
	except:
	    # Ooops, something's gone wrong. Undo everything we've done
	    # so far... (hmm, this currently fails to undo everything if
	    # undo.append(undo_info) fails... (the undo_info involved
	    # would be lost))
	    Undo(CreateListUndo(undo))
	    raise