Almost. The way I would see it working is that, when creating a new Action within an Action Group, there would be a new option in the "Select Action Type" drop down list, which would be something like "Run Action Group". It would take the name of the action group to run, as a parameter. This would allow Action Groups to be treated like subroutines. The "groups" that you refer to would be a new Action Groups, each composed of calls to other Action Groups, mixed in with other Actions if required.
The obvious(?) implementation involves a recursive call to the "Run Action Group", hence my comment about re-entrant code. I implemented something similar in another program, Long, Long Ago in a Computer Lab Far Far Away - the actual implementation is a lot simpler than it sounds.
Just to illustrate (and I'm not trying to tell Florian how to code! - this is just for other "interested parties" and to clarify what I mean) - the implementation goes something like this. Assuming that there's a routine somewhere in MP3Tag that processes an Action Group specified as a parameter, we insert an extra "ActionGroupAsAction" line to make it look something like this:
Function ProcessActionGroup(ActionGroupName, Parameter1, Parameter2, Parameter3);
Select On ActionGroupName
Format: <format Parameter1>;
Replace: <replace Parameter1 with Parameter2>;
ReplaceWithRegEx: <replace regex Parameter1 with Parameter2>;
ActionGroupAsAction: ProcessActionGroup(Parameter1, Parameter2, Parameter3, Null);
(written in ObviousCode ).
Note that the ActionGroupAsAction line passes the incoming Parameter1 to ProcessActionGroup as the new ActionGroupName parameter, so it "calls" the named Action Group.
In Real Life it's not quite so trivial, there are issues with typing, etc., and the code has to all be re-entrant (suitable for recursion - no global variables), but I hope this illustrates the idea - it's also a good classroom example of how to use recursion effectively.
Yes - that's the objective.
Kind of - by doing it recursively, you can add an infinite number of levels of hierarchy - Each Action Group can contain calls to other Action Groups, which in turn call more Action Groups, etc. There would need to be a depth limit specified, though, in order to prevent accidental infinite recursion which would hang the program.
Almost, but not quite - '"Run Action Group" as an Action' would allow you to write one Action Group that can then be inserted into others (potentially nested) - this is far more powerful than just being able to (manually) load and save sequences.