EditorPlugin

type Advanced = class

type AfterGUIInput int //gd:EditorPlugin.AfterGUIInput

type Any interface {
	gd.IsClass
	AsEditorPlugin() Instance
}

type CustomControlContainer int //gd:EditorPlugin.CustomControlContainer

type DockSlot int //gd:EditorPlugin.DockSlot

type Expanded [1]gdclass.EditorPlugin

type Extension[T gdclass.Interface] struct{ gdclass.Extension[T, Instance] }

type ID Object.ID

type Implementation = implementation

type Instance [1]gdclass.EditorPlugin

type Interface interface {
	// Called when there is a root node in the current edited scene, [Interface.Handles] is implemented, and an [graphics.gd/classdb/InputEvent] happens in the 2D viewport. If this method returns true, 'event' is intercepted by this [graphics.gd/classdb/EditorPlugin], otherwise 'event' is forwarded to other Editor classes.
	//
	//
	//
	// [gdscript]
	//
	// # Prevents the InputEvent from reaching other Editor classes.
	//
	// func _forward_canvas_gui_input(event):
	//
	//     return true
	//
	// [/gdscript]
	//
	// [csharp]
	//
	// // Prevents the InputEvent from reaching other Editor classes.
	//
	// public override bool ForwardCanvasGuiInput(InputEvent @event)
	//
	// {
	//
	//     return true;
	//
	// }
	//
	// [/csharp]
	//
	//
	//
	// This method must return false in order to forward the [graphics.gd/classdb/InputEvent] to other Editor classes.
	//
	//
	//
	// [gdscript]
	//
	// # Consumes InputEventMouseMotion and forwards other InputEvent types.
	//
	// func _forward_canvas_gui_input(event):
	//
	//     if (event is InputEventMouseMotion):
	//
	//         return true
	//
	//     return false
	//
	// [/gdscript]
	//
	// [csharp]
	//
	// // Consumes InputEventMouseMotion and forwards other InputEvent types.
	//
	// public override bool _ForwardCanvasGuiInput(InputEvent @event)
	//
	// {
	//
	//     if (@event is InputEventMouseMotion)
	//
	//     {
	//
	//         return true;
	//
	//     }
	//
	//     return false;
	//
	// }
	//
	// [/csharp]
	//
	//
	ForwardCanvasGuiInput(event InputEvent.Instance) bool
	// Called by the engine when the 2D editor's viewport is updated. Use the overlay [graphics.gd/classdb/Control] for drawing. You can update the viewport manually by calling [Instance.UpdateOverlays].
	//
	//
	//
	// [gdscript]
	//
	// func _forward_canvas_draw_over_viewport(overlay):
	//
	//     # Draw a circle at cursor position.
	//
	//     overlay.draw_circle(overlay.get_local_mouse_position(), 64, Color.WHITE)
	//
	//
	//
	// func _forward_canvas_gui_input(event):
	//
	//     if event is InputEventMouseMotion:
	//
	//         # Redraw viewport when cursor is moved.
	//
	//         update_overlays()
	//
	//         return true
	//
	//     return false
	//
	// [/gdscript]
	//
	// [csharp]
	//
	// public override void _ForwardCanvasDrawOverViewport(Control viewportControl)
	//
	// {
	//
	//     // Draw a circle at cursor position.
	//
	//     viewportControl.DrawCircle(viewportControl.GetLocalMousePosition(), 64, Colors.White);
	//
	// }
	//
	//
	//
	// public override bool _ForwardCanvasGuiInput(InputEvent @event)
	//
	// {
	//
	//     if (@event is InputEventMouseMotion)
	//
	//     {
	//
	//         // Redraw viewport when cursor is moved.
	//
	//         UpdateOverlays();
	//
	//         return true;
	//
	//     }
	//
	//     return false;
	//
	// }
	//
	// [/csharp]
	//
	//
	ForwardCanvasDrawOverViewport(viewport_control Control.Instance)
	// This method is the same as [Interface.ForwardCanvasDrawOverViewport], except it draws on top of everything. Useful when you need an extra layer that shows over anything else.
	//
	// You need to enable calling of this method by using [Instance.SetForceDrawOverForwardingEnabled].
	ForwardCanvasForceDrawOverViewport(viewport_control Control.Instance)
	// Called when there is a root node in the current edited scene, [Interface.Handles] is implemented, and an [graphics.gd/classdb/InputEvent] happens in the 3D viewport. The return value decides whether the [graphics.gd/classdb/InputEvent] is consumed or forwarded to other [graphics.gd/classdb/EditorPlugin]s. See [AfterGUIInput] for options.
	//
	//
	//
	// [gdscript]
	//
	// # Prevents the InputEvent from reaching other Editor classes.
	//
	// func _forward_3d_gui_input(camera, event):
	//
	//     return EditorPlugin.AFTER_GUI_INPUT_STOP
	//
	// [/gdscript]
	//
	// [csharp]
	//
	// // Prevents the InputEvent from reaching other Editor classes.
	//
	// public override EditorPlugin.AfterGuiInput _Forward3DGuiInput(Camera3D camera, InputEvent @event)
	//
	// {
	//
	//     return EditorPlugin.AfterGuiInput.Stop;
	//
	// }
	//
	// [/csharp]
	//
	//
	//
	// This method must return [AfterGuiInputPass] in order to forward the [graphics.gd/classdb/InputEvent] to other Editor classes.
	//
	//
	//
	// [gdscript]
	//
	// # Consumes InputEventMouseMotion and forwards other InputEvent types.
	//
	// func _forward_3d_gui_input(camera, event):
	//
	//     return EditorPlugin.AFTER_GUI_INPUT_STOP if event is InputEventMouseMotion else EditorPlugin.AFTER_GUI_INPUT_PASS
	//
	// [/gdscript]
	//
	// [csharp]
	//
	// // Consumes InputEventMouseMotion and forwards other InputEvent types.
	//
	// public override EditorPlugin.AfterGuiInput _Forward3DGuiInput(Camera3D camera, InputEvent @event)
	//
	// {
	//
	//     return @event is InputEventMouseMotion ? EditorPlugin.AfterGuiInput.Stop : EditorPlugin.AfterGuiInput.Pass;
	//
	// }
	//
	// [/csharp]
	//
	//
	Forward3dGuiInput(viewport_camera Camera3D.Instance, event InputEvent.Instance) AfterGUIInput
	// Called by the engine when the 3D editor's viewport is updated. Use the overlay [graphics.gd/classdb/Control] for drawing. You can update the viewport manually by calling [Instance.UpdateOverlays].
	//
	//
	//
	// [gdscript]
	//
	// func _forward_3d_draw_over_viewport(overlay):
	//
	//     # Draw a circle at cursor position.
	//
	//     overlay.draw_circle(overlay.get_local_mouse_position(), 64, Color.WHITE)
	//
	//
	//
	// func _forward_3d_gui_input(camera, event):
	//
	//     if event is InputEventMouseMotion:
	//
	//         # Redraw viewport when cursor is moved.
	//
	//         update_overlays()
	//
	//         return EditorPlugin.AFTER_GUI_INPUT_STOP
	//
	//     return EditorPlugin.AFTER_GUI_INPUT_PASS
	//
	// [/gdscript]
	//
	// [csharp]
	//
	// public override void _Forward3DDrawOverViewport(Control viewportControl)
	//
	// {
	//
	//     // Draw a circle at cursor position.
	//
	//     viewportControl.DrawCircle(viewportControl.GetLocalMousePosition(), 64, Colors.White);
	//
	// }
	//
	//
	//
	// public override EditorPlugin.AfterGuiInput _Forward3DGuiInput(Camera3D viewportCamera, InputEvent @event)
	//
	// {
	//
	//     if (@event is InputEventMouseMotion)
	//
	//     {
	//
	//         // Redraw viewport when cursor is moved.
	//
	//         UpdateOverlays();
	//
	//         return EditorPlugin.AfterGuiInput.Stop;
	//
	//     }
	//
	//     return EditorPlugin.AfterGuiInput.Pass;
	//
	// }
	//
	// [/csharp]
	//
	//
	Forward3dDrawOverViewport(viewport_control Control.Instance)
	// This method is the same as [Interface.Forward3dDrawOverViewport], except it draws on top of everything. Useful when you need an extra layer that shows over anything else.
	//
	// You need to enable calling of this method by using [Instance.SetForceDrawOverForwardingEnabled].
	Forward3dForceDrawOverViewport(viewport_control Control.Instance)
	// Override this method in your plugin to provide the name of the plugin when displayed in the Godot editor.
	//
	// For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons.
	GetPluginName() string
	// Override this method in your plugin to return a [graphics.gd/classdb/Texture2D] in order to give it an icon.
	//
	// For main screen plugins, this appears at the top of the screen, to the right of the "2D", "3D", "Script", and "AssetLib" buttons.
	//
	// Ideally, the plugin icon should be white with a transparent background and 16×16 pixels in size.
	//
	//
	//
	// [gdscript]
	//
	// func _get_plugin_icon():
	//
	//     # You can use a custom icon:
	//
	//     return preload("res://addons/my_plugin/my_plugin_icon.svg")
	//
	//     # Or use a built-in icon:
	//
	//     return EditorInterface.get_editor_theme().get_icon("Node", "EditorIcons")
	//
	// [/gdscript]
	//
	// [csharp]
	//
	// public override Texture2D _GetPluginIcon()
	//
	// {
	//
	//     // You can use a custom icon:
	//
	//     return ResourceLoader.Load<Texture2D>("res://addons/my_plugin/my_plugin_icon.svg");
	//
	//     // Or use a built-in icon:
	//
	//     return EditorInterface.Singleton.GetEditorTheme().GetIcon("Node", "EditorIcons");
	//
	// }
	//
	// [/csharp]
	//
	//
	GetPluginIcon() Texture2D.Instance
	// Returns true if this is a main screen editor plugin (it goes in the workspace selector together with 2D, 3D, Script and AssetLib).
	//
	// When the plugin's workspace is selected, other main screen plugins will be hidden, but your plugin will not appear automatically. It needs to be added as a child of [graphics.gd/classdb/EditorInterface.GetEditorMainScreen] and made visible inside [Interface.MakeVisible].
	//
	// Use [Interface.GetPluginName] and [Interface.GetPluginIcon] to customize the plugin button's appearance.
	//
	//
	//
	// var plugin_control
	//
	//
	//
	// func _enter_tree():
	//
	//     plugin_control = preload("my_plugin_control.tscn").instantiate()
	//
	//     EditorInterface.get_editor_main_screen().add_child(plugin_control)
	//
	//     plugin_control.hide()
	//
	//
	//
	// func _has_main_screen():
	//
	//     return true
	//
	//
	//
	// func _make_visible(visible):
	//
	//     plugin_control.visible = visible
	//
	//
	//
	// func _get_plugin_name():
	//
	//     return "My Super Cool Plugin 3000"
	//
	//
	//
	// func _get_plugin_icon():
	//
	//     return EditorInterface.get_editor_theme().get_icon("Node", "EditorIcons")
	//
	//
	HasMainScreen() bool
	// This function will be called when the editor is requested to become visible. It is used for plugins that edit a specific object type.
	//
	// Remember that you have to manage the visibility of all your editor controls manually.
	MakeVisible(visible bool)
	// This function is used for plugins that edit specific object types (nodes or resources). It requests the editor to edit the given object.
	//
	// 'object' can be null if the plugin was editing an object, but there is no longer any selected object handled by this plugin. It can be used to cleanup editing state.
	Edit(obj Object.Instance)
	// Implement this function if your plugin edits a specific type of object (Resource or Node). If you return true, then you will get the functions [Interface.Edit] and [Interface.MakeVisible] called when the editor requests them. If you have declared the methods [Interface.ForwardCanvasGuiInput] and [Interface.Forward3dGuiInput] these will be called too.
	//
	// Note: Each plugin should handle only one type of objects at a time. If a plugin handles more types of objects and they are edited at the same time, it will result in errors.
	Handles(obj Object.Instance) bool
	// Override this method to provide a state data you want to be saved, like view position, grid settings, folding, etc. This is used when saving the scene (so state is kept when opening it again) and for switching tabs (so state can be restored when the tab returns). This data is automatically saved for each scene in an editstate file in the editor metadata folder. If you want to store global (scene-independent) editor data for your plugin, you can use [Interface.GetWindowLayout] instead.
	//
	// Use [Interface.SetState] to restore your saved state.
	//
	// Note: This method should not be used to save important settings that should persist with the project.
	//
	// Note: You must implement [Interface.GetPluginName] for the state to be stored and restored correctly.
	//
	//
	//
	// func _get_state():
	//
	//     var state = {"zoom": zoom, "preferred_color": my_color}
	//
	//     return state
	//
	//
	GetState() map[interface{}]interface{}
	// Restore the state saved by [Interface.GetState]. This method is called when the current scene tab is changed in the editor.
	//
	// Note: Your plugin must implement [Interface.GetPluginName], otherwise it will not be recognized and this method will not be called.
	//
	//
	//
	// func _set_state(data):
	//
	//     zoom = data.get("zoom", 1.0)
	//
	//     preferred_color = data.get("my_color", Color.WHITE)
	//
	//
	SetState(state map[interface{}]interface{})
	// Clear all the state and reset the object being edited to zero. This ensures your plugin does not keep editing a currently existing node, or a node from the wrong scene.
	Clear()
	// Override this method to provide a custom message that lists unsaved changes. The editor will call this method when exiting or when closing a scene, and display the returned string in a confirmation dialog. Return empty string if the plugin has no unsaved changes.
	//
	// When closing a scene, 'for_scene' is the path to the scene being closed. You can use it to handle built-in resources in that scene.
	//
	// If the user confirms saving, [Interface.SaveExternalData] will be called, before closing the editor.
	//
	//
	//
	// func _get_unsaved_status(for_scene):
	//
	//     if not unsaved:
	//
	//         return ""
	//
	//
	//
	//     if for_scene.is_empty():
	//
	//         return "Save changes in MyCustomPlugin before closing?"
	//
	//     else:
	//
	//         return "Scene %s has changes from MyCustomPlugin. Save before closing?" % for_scene.get_file()
	//
	//
	//
	// func _save_external_data():
	//
	//     unsaved = false
	//
	//
	//
	// If the plugin has no scene-specific changes, you can ignore the calls when closing scenes:
	//
	//
	//
	// func _get_unsaved_status(for_scene):
	//
	//     if not for_scene.is_empty():
	//
	//         return ""
	//
	//
	GetUnsavedStatus(for_scene string) string
	// This method is called after the editor saves the project or when it's closed. It asks the plugin to save edited external scenes/resources.
	SaveExternalData()
	// This method is called when the editor is about to save the project, switch to another tab, etc. It asks the plugin to apply any pending state changes to ensure consistency.
	//
	// This is used, for example, in shader editors to let the plugin know that it must apply the shader code being written by the user to the object.
	ApplyChanges()
	// This is for editors that edit script-based objects. You can return a list of breakpoints in the format (script:line), for example: res://path_to_script.gd:25.
	GetBreakpoints() []string
	// Restore the plugin GUI layout and data saved by [Interface.GetWindowLayout]. This method is called for every plugin on editor startup. Use the provided 'configuration' file to read your saved data.
	//
	//
	//
	// func _set_window_layout(configuration):
	//
	//     $Window.position = configuration.get_value("MyPlugin", "window_position", Vector2())
	//
	//     $Icon.modulate = configuration.get_value("MyPlugin", "icon_color", Color.WHITE)
	//
	//
	SetWindowLayout(configuration ConfigFile.Instance)
	// Override this method to provide the GUI layout of the plugin or any other data you want to be stored. This is used to save the project's editor layout when [Instance.QueueSaveLayout] is called or the editor layout was changed (for example changing the position of a dock). The data is stored in the editor_layout.cfg file in the editor metadata directory.
	//
	// Use [Interface.SetWindowLayout] to restore your saved layout.
	//
	//
	//
	// func _get_window_layout(configuration):
	//
	//     configuration.set_value("MyPlugin", "window_position", $Window.position)
	//
	//     configuration.set_value("MyPlugin", "icon_color", $Icon.modulate)
	//
	//
	GetWindowLayout(configuration ConfigFile.Instance)
	// This method is called when the editor is about to run the project. The plugin can then perform required operations before the project runs.
	//
	// This method must return a boolean. If this method returns false, the project will not run. The run is aborted immediately, so this also prevents all other plugins' [Interface.Build] methods from running.
	Build() bool
	// Called by the engine when the user enables the [graphics.gd/classdb/EditorPlugin] in the Plugin tab of the project settings window.
	EnablePlugin()
	// Called by the engine when the user disables the [graphics.gd/classdb/EditorPlugin] in the Plugin tab of the project settings window.
	DisablePlugin()
}