Godot version:
3.1 stable
Issue description:
If as a user you think you should be able to cut, copy and paste one thing* to another place, the editor should allow it.
Ctrl+C, Ctrl+X, Crtl V should copy/cut/paste the entirety of the selected thing(s). Right mouse click on the selected thing should offer only sub-categories or sub-properties of the selected thing to be copied or the whole thing. Pasting should be infinitely possible, without the need to have the selection focus on the thing I want to copy (this would be duplicate)
Pasting allows the user to choose the paste location freely at the current selection focus. Unlike duplicate, there may any number of operational steps in between respective copy and paste, because the copied thing is stored in the clipboard.
The pasted thing should unique by default. (Copy reference/paste reference an option in the right mouse click context menu)
We should implement it not only in already existing features, but should make it a quality requirement when new features are added.
*Thing(s) like:
Examples where such functionality is requested:
https://github.com/godotengine/godot/issues/24950
https://github.com/godotengine/godot/issues/3720
https://github.com/godotengine/godot/issues/23024
https://github.com/godotengine/godot/issues/13380
https://github.com/godotengine/godot/issues/7605
https://github.com/godotengine/godot/issues/15029
https://github.com/godotengine/godot/issues/30197
https://github.com/godotengine/godot/issues/11359
https://github.com/godotengine/godot/issues/30137
https://github.com/godotengine/godot/issues/27279
https://github.com/godotengine/godot/issues/27813
Here is why I think we need this issue (from my reddit post):
I think we need this overarching issue because yes, there already have been implementations of copy and paste throughout the editor, but a) unlike other software it's not a common feature, b) they are all implemented differently. I would not want us to continue down this road.
Sometimes you will find copy and paste only in a context menu, sometimes it's hidden in a drop down, sometimes it is called duplicate and not actually a true copy and paste, sometimes it copies as just reference, even though it says copy. It's not coherent. Having all these different operational paths for the same basic thing is unintuitve, confusing, requires more learning effort for no reason, and worst of all it misses the simple, globally well known "select thing -> copy (Crtl+C) -> go to paste location -> paste (Ctrl+V)" behavior.
As a novice Godot user, I should learn about nodes, signals and groups, not how to copy and paste.
The goal of this issue is to make Ctrl+C, Crtl+V as common place and straight forward as it is in other editing software and with it make Godot more user friendly and intuitive.
So I have many nodes in a scene. I want to pick just one of these nodes and put it to another scene (because I realize that this node should be in one scene and not another).
Currently, I have to:
1) Right-click on the source node
2) Save Branch as a Scene
3) Go to the target node
4) Right-click on the parent node
5) Merge from Scene
6) Delete the previously saved scene
So I think it could be easier with just a copy/paste.
Where is this feature? Over 2 years later and this is still not a thing.
@ryanhuellen It has barely been two months, let alone two years. Please be patient.
Features are added when random users decide to add them. Until someone decides they want to take this issue up, the rest of us will just have to wait.
Should this be implemented separately for each part of the Godot GUI?
Why not create a ClipboardManager class that manages all these stuff? Every time something is CTRL+Ced we could send that data to ClipboardManager which will process it as needed depending it's type(text, node, scene, button, resource, etc.).
It could even save the clipboard state on close as an extra feature if needed.
Plus one to this. One of my gripes especially with nodes. If nodes can duplicate, why not have a copy paste as well?
Hello, I am the OP of #30197. I should note that I don't mind that Copy and Paste currently use a reference, as it is consistent with the usage of other Resources you can copy/paste in the inspector, but because the UI for Animations is different and Animations aren't shown by the inspector in the same way by default, the use case becomes somewhat unclear and it's easy for a user to make a mistake and get mixed up over pasting duplicate references into an AnimationPlayer, which stores and displays these references with their own key names. I proposed my own possible solutions for this in the corresponding issue.
Having a copy/paste operation might be useful for nodes (especially across scenes) but it would be pretty difficult to achieve consistency for the functionality throughout the editor given that the current usage for copied objects is to copy their reference, and it sounds like you want to copy their value instead. This is a very broad topic for discussion and I would argue that despite the confusion I made issue about in #30197, I personally believe that the current behavior is correct, or at least consistent. In my issue, it simply needs to be clarified further. Yours is a different issue which I want to make distinct from my own.
For this thread, I would say that if there were to be a copy-paste operation for nodes, it's not clear whether the current shallow duplicate would be the right way to go if pasted across scenes. Perhaps some kind of dialog asking whether to make a shallow copy, deep copy (would be the same as duplicating and then selecting "Make Sub-resources unique" in inspector), or an inherited instance (if the copied object is a scene) would be appropriate, so that the user knows what the paste operation is actually doing.
I'm hearing "shallow copy" and "deep copy" right now for the first time. Please, let's not bring even more rare concepts into this!
The purpose of this issue is to do the exact opposite: Make sure incredible well known interaction with software (cut/copy/paste, (Crtl+X)(Crtl+C)(Crtl+V)) is existent and consistent in the Godot editor.
These commands cut the original or create duplicates(through aid of the clipboard) of files or piece of data in every operation system and editing software of pretty much any kind. It's "make unique" per default. It's intuitive behavior. Everyone knows how it works. It's something we don't have to teach.
Using those commands to establish connections to references files is not even remotely known behavior. There is no reason why we should not have our own set of commands with different names (like: "copy link to reference" (Ctrl+Shift+R), "paste link to reference"(Ctrl+R)) to connect to references. But but the love of Linus, let's pleeeeeease not use the most well known editing commands for something else than they have been used since the dawn of the digital age.
Well, I disagree. What may seem like obviously intuitive behavior to you won't be obviously intuitive to everyone else, and it's not even reasonable to replace all occurrences of reference-pasting which already exist with a deeper copy paradigm. You're asking to make copy-paste more intuitive by following a paradigm of consistency that only makes sense as long as it's not well-defined. Once the nitty-gritty details are brought into the discussion, the "intuitiveness" of it falls away.
Reference pasting is important to have and has already been made the default paradigm for current paste operations outside the text editor (ie: anything which copies an object). Duplicating is the current paradigm for copies which aren't direct instances. Yes, they can be confused sometimes, and clarifying that is definitely worth discussing. However, it's not currently anything that falls under "simple and intuitive" outside of any specific developer's use case, and that's the point I was trying to establish.
P.S. In code, when you shuttle objects around, objects are typically passed by reference. So I'm not surprised that this is also the default behavior for them in current copy-paste operations around the editor, because currently the only type of copy paste operations you can do are with Resources. When you paste, you're assigning a property a previously stored reference the way you'd paste a variable name to it in code. This seems more intuitive to me because I'm assigning a property value, and am not thinking about it like it were creating new objects for direct editing. For nodes and anything that doesn't read as a 1:1 logical mapping of the underlying code, I can see it being more intuitive to perform a value copy. But this behavior wouldn't remotely be consistent across the editor as-is, which is why this issue isn't as straightforward as it seems, and probably also why this issue got triaged into the discussion category. That's my two cents...
@golddotasksquestions Shallow copy and deep copy are not rare concepts. You might have heard them about it as some different terms.
You might be right about the copy-paste behavior so won't comment anything about it. I already gave a suggestion earlier.
Why not just rename 'Merge from Scene' to 'Copy from Scene'? We wouldn't have to introduce a new feature, though it would still be easier for beginners. And everyone else would know what it does.
Feature and improvement proposals for the Godot Engine are now being discussed and reviewed in a dedicated Godot Improvement Proposals (GIP) (godotengine/godot-proposals) issue tracker. The GIP tracker has a detailed issue template designed so that proposals include all the relevant information to start a productive discussion and help the community assess the validity of the proposal for the engine.
The main (godotengine/godot) tracker is now solely dedicated to bug reports and Pull Requests, enabling contributors to have a better focus on bug fixing work. Therefore, we are now closing all older feature proposals on the main issue tracker.
If you are interested in this feature proposal, please open a new proposal on the GIP tracker following the given issue template (after checking that it doesn't exist already). Be sure to reference this closed issue if it includes any relevant discussion (which you are also encouraged to summarize in the new proposal). Thanks in advance!
Discussion on this issue moved over to https://github.com/godotengine/godot-proposals/issues/955
Most helpful comment
Should this be implemented separately for each part of the Godot GUI?
Why not create a ClipboardManager class that manages all these stuff? Every time something is CTRL+Ced we could send that data to ClipboardManager which will process it as needed depending it's type(text, node, scene, button, resource, etc.).
It could even save the clipboard state on close as an extra feature if needed.