Community
@dglenn9000 wrote:I came across a great script that asks you to select a block and then replaces it with another block you select. Is there a way to modify this script so you dont have to manually choose the blocks. Instead have it find all block names starting with "Supply Diffuser 24x24" and replace them with a block in the drawing named V01.
....
That's so much easier a task that it's not worth modifying -- here's a from-scratch way to do it [minimally tested]:
(defun C:TEST ()
(vl-load-com)
(foreach
x
(mapcar 'cadr (ssnamex (ssget "_X" '((2 . "Supply Diffuser 24x24*")))))
(vla-put-name (vlax-ename->vla-object x) "V01")
); foreach
); defun
EDIT:
You can make a generic one as a function that takes the two Block names as arguments, rather than as a Command, so you don't need a dedicated routine for every possible replacement:
(defun BlockReplace (old new)
(vl-load-com)
(foreach
x
(mapcar 'cadr (ssnamex (ssget "_X" (list (cons 2 old)))))
(vla-put-name (vlax-ename->vla-object x) new)
); foreach
); defun
Usage for your example: (blockreplace "Supply Diffuser 24x24*" "V01")
[Further EDIT: I hadn't really noticed the "starting with" part until lgabriel's post brought it to my attention -- I've added the asterisk to the Block name.]
Kent Cooper, AIA 
@dglenn9000 wrote:....
Thanks Kent1Cooper, your script is able to accomplish the task in 1/10th the code I had before. However, I do not understand how I would use the generic version exactly. How would I redefine old & new if I had multiple blocks to replace?
....
The 'old' and 'new' entries are "arguments" to the function, which is what the list in parentheses after the function name at the top is. For a function defined without a C: prefix before the name, if arguments are listed there [before a slash if there is one, but there's no need for one here], then you must supply values for those arguments when you use the function, just as with any standard AutoLISP function. You do that by entering, in parentheses [also just as with any AutoLISP function], the function name followed by values for all the arguments. Everywhere the argument name appears in the code, the argument value supplied will be used for it. See the Usage sample following that code, for the situation in your original example.
If by "multiple blocks to replace" you mean multiple Block names, for each one of which you want to replace all insertions of it with some other Block name, you would need to run the function once per combination. So if you want to replace all Blocks named "Bob" with "Carol," and all Blocks named "Ted" with "Alice," you would do:
(BlockReplace "Bob" "Carol")
(BlockReplace "Ted" "Alice")
If having multiple replacements to do like that is something you need regularly, it wouldn't be difficult to make a variation in which you could supply two lists, one of the old names and another of the new, for instance one that would be used this way to do the above and a few more:
(BlockReplaceL '("Bob" "Ted" "Mickey" "Fred") '("Carol" "Alice" "Minnie" "Ginger"))
The same could be done in a way that might make it easier to keep track, using one argument that would be a list of two-item lists, each containing an old name with its corresponding new name:
(BlockReplaceL '(("Bob" "Carol") ("Ted" "Alice") ("Mickey" "Minnie") ("Fred" "Ginger")))
Either way would be able to handle any number of Block replacements you want, with only one function definition. [The L at the end of the presumed function name would be for "List," to distinguish it from the one-name-at-a-time routine.] Is that something you would have a use for?
[If by "multiple blocks to replace" you mean there are multiple insertions of a single Block name and you want to replace all of them with the same different Block name, it already does that.]
[And by the way, it's not a Script, nor is the code in you first post. The word "Script" has a specific meaning in AutoCAD, and these don't qualify. Call them "routines" or "functions" or (with the C: prefix to the name) "command definitions" or something.]
Kent Cooper, AIA
@dglenn9000 wrote:....
I will read up on error handling and try and incorporate it with this
scriptroutine. ....
This may not be something that requires error handling in the usual sense. That's generally intended to do things like set back System Variable settings that have been changed, etc., in case the routine itself doesn't get around to doing so because of some error that interrupts it. But this routine doesn't change anything that would need to be reset.
There are two errors I can picture you could get: if there are no insertions of Blocks with the old name, in which case the (ssnamex) function will have a problem, and if the new name is not a defined Block in the drawing, in which case the substitution won't work. If you don't mind seeing an error message in either case, you can just leave it alone, because the errors won't mean there's anything that needs to be "handled."
You could use an error handler simply to suppress display of error messages, but there's perhaps a better way to avoid those. The routine can test whether there are any Blocks of the old name, and whether the new name is a defined Block, and only proceed to replace them if both are true.
(defun BlockReplace (old new / ss)
(vl-load-com)
(if
(and
(setq ss (ssget "_X" (list (cons 2 old)))); there are some
(tblsearch "block" new); the Block is defined
); and
(foreach ; then
x
(mapcar 'cadr (ssnamex ss))
(vla-put-name (vlax-ename->vla-object x) new)
); foreach
); if
(princ)
); defun
Come to think of it, I guess having such a Block on a locked Layer would be a third error possibility. Is that something you would need to account for? If so, it would be better to have the routine check for each Block it finds, because that way, it can skip the locked ones but still replace all those that are not on locked Layers, whereas if you don't check for each one, it will stop when it reaches the first one on a locked Layer, and later ones it has found won't be replaced even if they're not on locked Layers.
Kent Cooper, AIA
@m_rogoff wrote:
....
Where does the (BlockReplace "NEW" "OLD") go in relation to the code? Are you saying if the (new or old) block definition does not exist in the drawing it will crap out?
....
After you have loaded the routine, then this [arguments the other way around, in the order they're listed in the parentheses after the function name]:
(BlockReplace "OLD" "NEW")
is what you would type at the Command: line [or include in other code] to use it. See the beginning of Post 5.
If either there are no insertions of the "OLD" Block [even if it is defined in the drawing], or there is no Block definition with the "NEW" name in the drawing, or both, it won't "crap out," but will simply not do anything, because there will be nothing to do. The (ssget) function is looking for those insertions, and the (tblsearch) function is looking for that definition. The (and) function ensures that only if both of those find something will it proceed to replace the old one(s) with the new one.
If you like, it could be made to notify you if it doesn't have anything to do, and why if you want to know that.
Kent Cooper, AIA
@m_rogoff wrote:
Bear with me please, Kent. If I understand you correctly...(see my changes below)
....
(defun BlockReplaceL '(("Bob" "Carol") ("Ted" "Alice") ("Mickey" "Minnie") ("Fred" "Ginger"))) / ss)
....
It would require that we "make a variation" [Post 5] of the routine, but unfortunately that needs to be more varied than simply replacing the Block names with lists. It would need to step through the list-of-lists and do the operation on each thing in it. It could be done a few different ways, maybe most simply by having the same BlockReplace function in Post 7, and applying that to each sub-list, something like this [untested]:
[include the BlockReplace routine definition in the same file, then:]
(defun BlockReplaceL (blklist)
(foreach sublist blklist (BlockReplace (car sublist) (cadr sublist)))
)
Usage would then be as described in Post 5:
(BlockReplaceL '(("Bob" "Carol") ("Ted" "Alice") ("Mickey" "Minnie") ("Fred" "Ginger")))
Kent Cooper, AIA
@MRogoff wrote:
Like this? ....
(defun BlockReplaceL '(("new" "old") ("Bob" "Carol") ("Ted" "Alice") ("Mickey" "Minnie") ("Fred" "Ginger"))) / ss)
....
No, you don't want to build specific Block names into the definition of the routine like that. You want to define it with placeholders, and then supply the specific Block names as arguments to be fed in for the placeholders when you use the routine.
Using the way I suggested in Post 11 [it's not the only way to do this], put into one .lsp file or separately, as you prefer, as long as both get loaded, these two function definitions:
(defun BlockReplace (old new / ss) ; from Post 7
(vl-load-com)
(if
(and
(setq ss (ssget "_X" (list (cons 2 old)))); there are some old ones
(tblsearch "block" new); the new Block is defined
); and
(foreach ; then
x
(mapcar 'cadr (ssnamex ss)); extracts the Block references
(vla-put-name (vlax-ename->vla-object x) new); changes their Block names
); foreach
); if
(princ)
); defun
(defun BlockReplaceL (blklist) ; from Post 11
(foreach sublist blklist (BlockReplace (car sublist) (cadr sublist))); calling the other routine
)
Then to use it, see the end of Post 11, with your list of two-name sublists as the argument that blklist is a placeholder for in the lower routine Within that, the first and second item in each sublist are the arguments that old and new are placeholders for in the upper routine.
This way of doing it means you can still do a single such replacement by using the upper routine as a stand-alone, not called from within the lower routine, with just the two names, and without the need to put them into a sublist:
(BlockReplace "Laurel" "Hardy")
That would be equivalent [but simpler] to using the lower routine with a single two-name sublist in its blklist argument:
(BlockReplaceL '(("Laurel" "Hardy")))
Kent Cooper, AIA
@m_rogoff wrote:
....
1. If the block does not already exist in the dwg, this will not work. Is there a way to specify a block from a folder location (ie: M:\SYM\blockname.dwg)? Or possibly insert the new block version and immediately delete it?
2. If a dynamic block has been modified, ie: visibilty state changed from default or parameters have been stretched, the block will not be replaced.
3. If I need to REDEFINE a block from a newer version from the folder location, is this possible?
....
1. The (tblsearch) function that looks for it can't look for an external file, nor can the (vla-put-name) function use one, so in that case you would need to bring it in. Precede the rest of the code with something like:
(if (not (tblsearch "block" "blockname")) (command "_.insert" "M:\\SYM\\blockname" nil))
That should bring in the definition, and when it's asking for an insertion point, cancel the command, so it's not necessary to finishing Inserting and then Erase it. [Note the double backslashes, which could be replaced by single forward-slashes, but single backslashes can't be used because they are control characters and trigger other stuff depending on what follows them.]
2. Unfortunately, (ssget) searching for code-2 entries can't find Blocks by their effective name. So I think it would be necessary to find all Block insertions, and in stepping through them, get their effective names, and for those that match, do the replacement. Search this Forum for code using the effectivename VLA property.
3. If the folder location is in the Support File Search Path list [OPTIONS, Files tab], and the Block name is the same as the drawing name, then you can replace a Block's definition with the Insert command using the blockname= form, again cancelling the command after the new definition has been brought in, something like:
(command "_.insert" "blockname=" "_yes" nil)
[You don't need to include the .dwg filetype ending -- that's the only filetype it will look for.] Or if that location isn't one that it will know to look in, you can spell it out, with things on both sides of the = sign:
(command "_.insert" "blockname=M:\\SYM\\blockname" "_yes" nil)
That "_yes" answer assumes that the Block exists in the drawing already -- it's answering the question of whether to replace it. To make the whole thing cover more possibilities, you might include a check for whether it does, before running that part.
Kent Cooper, AIA
@m_rogoff wrote:
Why couldn't I just _rename / block and then redefine using your suggestion with blockname=? Wouldn't that just be a simple 2 line code?
(command "_rename" "oldblockname" "newblockname")
(command "_.insert" "newblockname=" "_yes" nil)
That ought to work, but only if "oldblockname" is already in the drawing [Post 14 item 1 suggests it won't always be]. But if it is, and newblockname is not a Block currently in the drawing but is a drawing in a Support File Search Path location, and if you don't particularly need to have the different name, but only want the definition changed, you should be able to just do:
(command "_.insert" "oldblockname=newblockname" "_yes" nil)
Kent Cooper, AIA
![Autodesk Design & Make Report](https://forums.autodesk.com/t5/image/serverpage/image-id/1350519iCB55845EBFC43016/image-size/large?v=v2&px=999" "Autodesk Design & Make Report")
