/* GODOT ENGINE */

/* http://www.godotengine.org */

/*************************************************************************/

/* */

/* Permission is hereby granted, free of charge, to any person obtaining */

/* a copy of this software and associated documentation files (the */

#include "register_exporters.h"

#include "bind/core_bind.h"

#include "io/zip_io.h"

// plugins

#include "plugins/sprite_frames_editor_plugin.h"

#include "plugins/canvas_item_editor_plugin.h"

#include "plugins/spatial_editor_plugin.h"

#include "plugins/sample_editor_plugin.h"

#include "plugins/tile_map_editor_plugin.h"

#include "plugins/cube_grid_theme_editor_plugin.h"

#include "plugins/shader_editor_plugin.h"

#include "plugins/path_editor_plugin.h"

#include "plugins/rich_text_editor_plugin.h"

#include "plugins/collision_polygon_editor_plugin.h"

#include "plugins/animation_player_editor_plugin.h"

#include "plugins/baked_light_editor_plugin.h"

#include "plugins/polygon_2d_editor_plugin.h"

// end

#include "tools/editor/io_plugins/editor_texture_import_plugin.h"

#include "tools/editor/io_plugins/editor_scene_import_plugin.h"

#include "tools/editor/io_plugins/editor_translation_import_plugin.h"

#include "tools/editor/io_plugins/editor_mesh_import_plugin.h"

EditorNode *EditorNode::singleton=NULL;

void EditorNode::_update_title() {

String appname = Globals::get_singleton()->get("application/name");

String title = appname.empty()?String(VERSION_FULL_NAME):String(_MKSTR(VERSION_NAME) + String(" - ") + appname);

if (!edited.empty())

title+=" - " + String(edited.get_file());

if (unsaved_cache)

switch(p_event.key.scancode) {

if (!p_event.key.mod.shift && !p_event.key.mod.command)

_editor_select(3);

case KEY_F5: _menu_option_confirm((p_event.key.mod.control&&p_event.key.mod.shift)?RUN_PLAY_CUSTOM_SCENE:RUN_PLAY,true); break;

case KEY_F6: _menu_option_confirm(RUN_PLAY_SCENE,true); break;

case KEY_F7: _menu_option_confirm(RUN_PAUSE,true); break;

void EditorNode::_notification(int p_what) {

if (p_what==NOTIFICATION_EXIT_TREE) {

editor_data.save_editor_external_data();

log->deinit(); // do not get messages anymore

_update_title();

}

//get_root_node()->set_rect(viewport->get_global_rect());

//update the circle

circle_step=0;

circle_step_msec=tick;

update_menu->set_icon(gui_base->get_icon("Progress"+itos(circle_step+1),"EditorIcons"));

}

if (p_what==NOTIFICATION_ENTER_TREE) {

//MessageQueue::get_singleton()->push_call(this,"_get_scene_metadata");

get_tree()->set_editor_hint(true);

get_tree()->get_root()->set_as_audio_listener(false);

//import_monitor->scan_changes();

}

if (p_what==NOTIFICATION_READY) {

VisualServer::get_singleton()->viewport_set_hide_scenario(get_scene_root()->get_viewport(),true);

VisualServer::get_singleton()->viewport_set_hide_canvas(get_scene_root()->get_viewport(),true);

_editor_select(1);

if (defer_load_scene!="") {

E->get()->invalidate();

}

}

void EditorNode::_sources_changed(bool p_exist) {

}

void EditorNode::_node_renamed() {

if (property_editor)

void EditorNode::open_resource(const String& p_type) {

List<String> extensions;

ResourceLoader::get_recognized_extensions_for_type(p_type,&extensions);

current_option=RESOURCE_LOAD;

}

}

void EditorNode::save_resource_as(const Ref<Resource>& p_resource) {

}

}break;

}

}

}

void EditorNode::_get_scene_metadata() {

if (!scene)

return;

void EditorNode::_set_scene_metadata() {

if (!scene)

return;

};

bool ret_changed=false;

List<PropertyInfo> pi;

if (!(E->get().usage&PROPERTY_USAGE_STORAGE))

continue;

switch(E->get().type) {

case Variant::OBJECT: {

RES res = obj->get(E->get().name);

ret_changed=true;

} break;

case Variant::ARRAY: {

int len=varray.size();

for(int i=0;i<len;i++) {

Variant v=varray.get(i);

} break;

case Variant::DICTIONARY: {

List<Variant> keys;

d.get_key_list(&keys);

for(List<Variant>::Element *E=keys.front();E;E=E->next()) {

Variant v = d[E->get()];

} break;

default: {}

}

}

_find_and_save_edited_subresources(scene,processed,flags);

for(int i=0;i<scene->get_child_count();i++) {

Node *n = scene->get_child(i);

continue;

_save_edited_subresources(n,processed,flags);

}

}

void EditorNode::_save_scene(String p_file) {

if (!scene) {

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation can't be done without a tree root.");

return;

}

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Couldn't save scene. Likely dependencies (instances) couldn't be satisfied.");

return;

}

int flg=0;

if (EditorSettings::get_singleton()->get("on_save/compress_binary_resources"))

flg|=ResourceSaver::FLAG_COMPRESS;

err = ResourceSaver::save(p_file,sdata,flg);

_save_edited_subresources(scene,processed,flg);

editor_data.save_editor_external_data();

if (err==OK) {

scene->set_filename( Globals::get_singleton()->localize_path(p_file) );

//EditorFileSystem::get_singleton()->update_file(p_file,sdata->get_type());

_update_title();

} else {

_dialog_display_file_error(p_file,err);

push_item(res.operator->() );

} break;

case FILE_OPEN_SCENE: {

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation requieres a single selected node.");

break;

}

Node *base = selection.front()->get();

Map<Node*,Node*> reown;

Node *copy = base->duplicate_and_reown(reown);

if (copy) {

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Couldn't save subscene. Likely dependencies (instances) couldn't be satisfied.");

return;

}

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Error saving scene.");

break;

}

//EditorFileSystem::get_singleton()->update_file(p_file,sdata->get_type());

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Error duplicating scene to save it.");

break;

}

if (file->get_mode()==FileDialog::MODE_SAVE_FILE) {

}

} break;

case FILE_EXPORT_MESH_LIBRARY: {

Ref<MeshLibrary> ml;

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Can't load MeshLibrary for merging!.");

return;

}

ml = Ref<MeshLibrary>( memnew( MeshLibrary ));

}

Error err = ResourceSaver::save(p_file,ml);

if (err) {

accept->get_ok()->set_text("I see..");

accept->set_text("Error saving MeshLibrary!.");

return;

}

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Can't load TileSet for merging!.");

return;

}

ml = Ref<TileSet>( memnew( TileSet ));

}

Error err = ResourceSaver::save(p_file,ml);

if (err) {

accept->get_ok()->set_text("I see..");

accept->set_text("Error saving TileSet!.");

return;

}

} break;

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Can't open export templates zip.");

return;

}

unzClose(pkg);

} break;

default: { //save scene?

if (file->get_mode()==FileDialog::MODE_SAVE_FILE) {

}

} break;

}

void EditorNode::_property_editor_forward() {

if (editor_history.next())

void EditorNode::_imported(Node *p_node) {

if (scene) {

String path = scene->get_filename();

p_node->set_filename(path);

memdelete(scene);

}

}

uint32_t current = editor_history.get_current();

Object *current_obj = current>0 ? ObjectDB::get_instance(current) : NULL;

this->current=current_obj;

editor_path->update_path();

object_menu->set_disabled(true);

Resource *current_res = current_obj->cast_to<Resource>();

property_editor->edit( current_res );

object_menu->set_disabled(false);

Node * current_node = current_obj->cast_to<Node>();

ERR_FAIL_COND(!current_node);

scene_tree_dock->set_selected(current_node);

object_menu->get_popup()->clear();

}

if (main_plugin!=editor_plugin_screen) {

// update screen main_plugin

}

}

p->add_item("Copy Params",OBJECT_COPY_PARAMS);

p->add_item("Set Params",OBJECT_PASTE_PARAMS);

p->add_separator();

p->add_separator();

p->add_icon_item(gui_base->get_icon("Help","EditorIcons"),"Class Reference",OBJECT_REQUEST_HELP);

List<MethodInfo> methods;

_update_keying();

}

void EditorNode::_resource_selected(const RES& p_res,const String& p_property) {

}

play_button->set_pressed(false);

play_scene_button->set_pressed(false);

String current_filename;

String run_filename;

if (!scene) {

current_option=-1;

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("No scene to run exists.");

return;

}

if (scene->get_filename()=="") {

current_option=-1;

//accept->get_cancel()->hide();

return;

}

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("No main scene has ever been defined.\nSelect one from \"Project Settings\" under the 'application' category.");

return;

}

if (unsaved_cache) {

if (scene) { //only autosave if there is a scene obviously

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Current scene was never saved, please save scene before running.");

return;

}

}

}

editor_data.save_editor_external_data();

}

List<String> breakpoints;

editor_data.get_editor_breakpoints(&breakpoints);

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Could not start subprocess!");

return;

}

emit_signal("play_pressed");

if (p_current) {

play_scene_button->set_pressed(true);

} else {

play_button->set_pressed(true);

}

_playing_edited=p_current;

void EditorNode::_cleanup_scene() {

editor_selection->clear();

editor_data.clear_editor_states();

editor_history.clear();

property_editor->edit(NULL);

resources_dock->cleanup();

scene_import_metadata.unref();

if (scene) {

if (scene->get_filename()!="") {

previous_scenes.push_back(scene->get_filename());

}

_update_title();

}

void EditorNode::_menu_option_confirm(int p_option,bool p_confirmed) {

switch( p_option ) {

case FILE_NEW_SCENE: {

if (!p_confirmed) {

confirmation->get_ok()->set_text("Yes");

//confirmation->get_cancel()->show();

confirmation->set_text("Start a New Scene? (Current will be lost)");

break;

} break;

case FILE_OPEN_SCENE: {

//print_tree();

//not for now?

List<String> extensions;

ResourceLoader::get_recognized_extensions_for_type("PackedScene",&extensions);

//file->set_current_path(current_path);

if (scene) {

file->set_current_path(scene->get_filename());

};

file->popup_centered_ratio();

} break;

quick_open->set_title("Quick Open Script..");

} break;

case FILE_RUN_SCRIPT: {

file_script->popup_centered_ratio();

open_request(previous_scenes.back()->get());

} break;

case FILE_SAVE_SCENE: {

if (scene && scene->get_filename()!="") {

return;

};

// fallthrough to save_as

case FILE_SAVE_AS_SCENE: {

if (!scene) {

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation can't be done without a tree root.");

break;

}

bool relpaths = (scene->has_meta("__editor_relpaths__") && scene->get_meta("__editor_relpaths__").operator bool());

} break;

case FILE_DUMP_STRINGS: {

if (!scene) {

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation can't be done without a tree root.");

break;

}

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("Please save the scene first.");

break;

}

bool relpaths = (scene->has_meta("__editor_relpaths__") && scene->get_meta("__editor_relpaths__").operator bool());

file->set_current_path(cpath);

file->set_title("Save Translatable Strings");

case FILE_SAVE_SUBSCENE: {

if (!scene) {

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation can't be done without a scene.");

break;

}

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation requieres a single selected node.");

break;

}

Node *tocopy = selection.front()->get();

current_option=-1;

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation can't be done on instanced scenes.");

break;

}

List<String> extensions;

Ref<PackedScene> sd = memnew( PackedScene );

file->set_title("Save Sub-Scene As..");

} break;

case FILE_SAVE_OPTIMIZED: {

#if 0

if (!scene) {

case FILE_EXPORT_MESH_LIBRARY: {

current_option=-1;

//confirmation->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation can't be done without a scene.");

break;

}

//import_subscene->popup_centered_ratio();

current_option=-1;

//accept->get_cancel()->hide();

accept->get_ok()->set_text("I see..");

accept->set_text("This operation can't be done without a selected node.");

break;

}

case FILE_QUIT: {

if (!p_confirmed) {

confirmation->get_ok()->set_text("Quit");

//confirmation->get_cancel()->show();

confirmation->set_text("Exit the Editor?");

break;

}

_menu_option_confirm(RUN_STOP,true);

get_tree()->quit();

confirmation->get_ok()->set_text("Open");

//confirmation->get_cancel()->show();

confirmation->set_text("Current scene not saved. Open anyway?");

break;

}

log->add_message("REDO: "+action);

} break;

#if 0

case NODE_EXTERNAL_INSTANCE: {

} break;

#endif

case OBJECT_REQUEST_HELP: {

if (current) {

}

editor_data.get_undo_redo().clear_history();

editor_plugin_over->edit(NULL);

editor_plugin_over->edit(current);

}

call_dialog->popup_centered_ratio();

} break;

case RUN_PLAY: {

_run(false);

} break;

case RUN_PLAY_CUSTOM_SCENE: {

quick_run->popup("PackedScene",true);

quick_run->set_title("Quick Run Scene..");

editor_run.stop();

play_button->set_pressed(false);

play_scene_button->set_pressed(false);

emit_signal("stop_pressed");

} break;

case RUN_PLAY_SCENE: {

_run(true);

} break;

case RUN_SCENE_SETTINGS: {

run_settings_dialog->popup_run_settings();

if (!p_confirmed) {

confirmation->get_ok()->set_text("Yes");

confirmation->set_text("Open Project Manager? \n(Unsaved changes will be lost)");

break;

}

case RUN_FILE_SERVER: {

//file_server

if (ischecked) {

file_server->stop();

} else {

file_server->start();

}

} break;

case RUN_DEPLOY_DUMB_CLIENTS: {

run_native->set_deploy_dumb(!ischecked);

} break;

case SETTINGS_UPDATE_ALWAYS: {

update_menu->get_popup()->set_item_checked(0,true);

void EditorNode::_editor_select(int p_which) {

static bool selecting=false;

return;

selecting=true;

ERR_FAIL_INDEX(p_which,editor_table.size());

selecting=false;

editor_plugin_screen=new_editor;

editor_plugin_screen->make_visible(true);

editor_plugin_screen->selected_notify();

}

void EditorNode::add_editor_plugin(EditorPlugin *p_editor) {

if (p_editor->has_main_screen()) {

singleton->editor_table.push_back(p_editor);

}

singleton->editor_data.add_editor_plugin( p_editor );

if (p_editor->has_main_screen()) {

break;

}

}

singleton->editor_table.erase(p_editor);

}

singleton->remove_child(p_editor);

}

void EditorNode::set_edited_scene(Node *p_scene) {

animation_editor->set_root(NULL);

}

if (get_tree())

if (p_scene->get_parent()!=scene_root)

scene_root->add_child(p_scene);

animation_editor->set_root(p_scene);

}

}

void EditorNode::_fetch_translatable_strings(const Object *p_object,Set<StringName>& strings) {

OS::Time time = OS::get_singleton()->get_time();

f->store_line("# Translation Strings Dump.");

f->store_line("# Created By.");

f->store_line("# From Scene: ");

f->store_line("# \t"+get_edited_scene()->get_filename());

f->store_line("");

}

}

ERR_FAIL_COND_V(saver.is_null(),ERR_INVALID_DATA);

List<Variant> keys;

return OK;

}

if (!is_inside_tree()) {

defer_load_scene = p_scene;

}

load_errors->clear();

String lpath = Globals::get_singleton()->localize_path(p_scene);

//accept->get_cancel()->hide();

accept->get_ok()->set_text("Ugh");

accept->set_text("Error loading scene, it must be inside the project path. Use 'Import' to open the scene, then save it inside the project path.");

opening_prev=false;

return ERR_FILE_NOT_FOUND;

}

if (!sdata.is_valid()) {

current_option=-1;

//accept->get_cancel()->hide();

accept->get_ok()->set_text("Ugh");

accept->set_text("Error loading scene.");

opening_prev=false;

return ERR_FILE_NOT_FOUND;

}

Node*new_scene=sdata->instance(true);

if (!new_scene) {

current_option=-1;

//accept->get_cancel()->hide();

accept->get_ok()->set_text("Ugh");

accept->set_text("Error loading scene.");

opening_prev=false;

return ERR_FILE_NOT_FOUND;

}

/*

Node *old_scene = edited_scene;

_hide_top_editors();

memdelete(old_scene);

}

*/

set_edited_scene(new_scene);

_get_scene_metadata();

scene_tree_dock->set_selected(new_scene, true);

property_editor->edit(new_scene);

saved_version=editor_data.get_undo_redo().get_version();

_update_title();

_add_to_recent_scenes(lpath);

if (new_scene->has_meta("__editor_plugin_screen__")) {

prev_scene->set_disabled(previous_scenes.size()==0);

opening_prev=false;

push_item(new_scene);

void EditorNode::open_request(const String& p_path) {

}

request_instance_scene(p_path);

}

}

void EditorNode::_transform_keyed(Object *sp,const String& p_sub,const Transform& p_key) {

void EditorNode::_close_messages() {

// left_split->set_dragger_visible(false);

// scene_root_parent->set_anchor_and_margin(MARGIN_BOTTOM,Control::ANCHOR_END,0);

}

void EditorNode::_show_messages() {

// left_split->set_dragger_visible(true);

// scene_root_parent->set_anchor_and_margin(MARGIN_BOTTOM,Control::ANCHOR_END,log->get_margin(MARGIN_TOP));

}

String path = "res://"+rc[p_idx];

_recent_scene=rc[p_idx];

open_recent_confirmation->set_text("Discard current scene and open:\n'"+rc[p_idx]+"'");

open_recent_confirmation->get_label()->set_align(Label::ALIGN_CENTER);

open_recent_confirmation->popup_centered(Size2(400,100));

return;

}

#endif

}

void EditorNode::_update_recent_scenes() {

String base="_"+Globals::get_singleton()->get_resource_path().replace("\\","::").replace("/","::");

void EditorNode::_quick_opened(const String& p_resource) {

open_request(p_resource);

} else {

load_resource(p_resource);

void EditorNode::notify_child_process_exited() {

stop_button->set_pressed(false);

editor_run.stop();

ObjectTypeDB::register_type<EditorImportPlugin>();

ObjectTypeDB::register_type<EditorScenePostImport>();

ObjectTypeDB::register_type<EditorScript>();

//ObjectTypeDB::register_type<EditorImporter>();

ObjectTypeDB::bind_method("_quick_opened",&EditorNode::_quick_opened);

ObjectTypeDB::bind_method("_quick_run",&EditorNode::_quick_run);

ObjectTypeDB::bind_method("_import_action",&EditorNode::_import_action);

//ObjectTypeDB::bind_method("_import",&EditorNode::_import);

// ObjectTypeDB::bind_method("_import_conflicts_solved",&EditorNode::_import_conflicts_solved);

ObjectTypeDB::bind_method("_open_recent_scene",&EditorNode::_open_recent_scene);

ObjectTypeDB::bind_method("_save_optimized",&EditorNode::_save_optimized);

ObjectTypeDB::bind_method(_MD("animation_panel_make_visible","enable"),&EditorNode::animation_panel_make_visible);

ObjectTypeDB::bind_method("_sources_changed",&EditorNode::_sources_changed);

ObjectTypeDB::bind_method("_fs_changed",&EditorNode::_fs_changed);

ADD_SIGNAL( MethodInfo("play_pressed") );

ADD_SIGNAL( MethodInfo("pause_pressed") );

singleton->file_dialogs.erase(p_dialog);

}

Vector<EditorNodeInitCallback> EditorNode::_init_callbacks;

Error EditorNode::export_platform(const String& p_platform, const String& p_path, bool p_debug,const String& p_password,bool p_quit_after) {

return OK;

}

EditorNode::EditorNode() {

EditorHelp::generate_doc(); //before any editor classes are crated

singleton=this;

FileAccess::set_backup_save(true);

EditorSettings::create();

ResourceLoader::set_abort_on_missing_resources(false);

ResourceLoader::set_error_notify_func(this,_load_error_notify);

ResourceLoader::set_timestamp_on_load(true);

ResourceSaver::set_timestamp_on_save(true);

FileDialog::register_func=_file_dialog_register;

FileDialog::unregister_func=_file_dialog_unregister;

editor_import_export = memnew( EditorImportExport );

register_exporters();

gui_base->set_area_as_parent_rect();

gui_base->set_theme( theme );

editor_register_icons(theme);

editor_register_fonts(theme);

String global_font = EditorSettings::get_singleton()->get("global/font");

if (global_font!="") {

Ref<Font> fnt = ResourceLoader::load(global_font);

theme->set_stylebox("EditorFocus","EditorStyles",focus_sbt);

progress_dialog = memnew( ProgressDialog );

gui_base->add_child(progress_dialog);

gui_base->set_anchor( MARGIN_RIGHT, Control::ANCHOR_END );

gui_base->set_anchor( MARGIN_BOTTOM, Control::ANCHOR_END );

gui_base->set_end( Point2(0,0) );

main_vbox = memnew( VBoxContainer );

gui_base->add_child(main_vbox);

main_vbox->set_area_as_parent_rect(8);

menu_hb = memnew( HBoxContainer );

main_vbox->add_child(menu_hb);

top_split = memnew( VSplitContainer );

top_split->set_v_size_flags(Control::SIZE_EXPAND_FILL);

top_split->set_collapsed(true);

srt->add_constant_override("separation",0);

main_editor_tabs->connect("tab_changed",this,"_editor_select");

scene_root_parent = memnew( Panel );

scene_root = memnew( Viewport );

//scene_root_base->add_child(scene_root);

scene_root->set_meta("_editor_disable_input",true);

VisualServer::get_singleton()->viewport_set_hide_scenario(scene_root->get_viewport(),true);

animation_panel=pc;

animation_panel->hide();

HBoxContainer *animation_hb = memnew( HBoxContainer);

animation_vb->add_child(animation_hb);

anim_close->set_pressed_texture( anim_close->get_icon("Close","EditorIcons"));

PanelContainer *top_region = memnew( PanelContainer );

top_region->add_style_override("panel",gui_base->get_stylebox("hover","Button"));

HBoxContainer *left_menu_hb = memnew( HBoxContainer );

prev_scene->set_disabled(true);

//left_menu_hb->add_child( prev_scene );

prev_scene->connect("pressed",this,"_menu_option",make_binds(FILE_OPEN_PREV));

prev_scene->set_pos(Point2(3,24));

Separator *vs=NULL;

file_menu->set_tooltip("Operations with scene files.");

p=file_menu->get_popup();

p->add_item("New Scene",FILE_NEW_SCENE);

p->add_item("Open Scene..",FILE_OPEN_SCENE,KEY_MASK_CMD+KEY_O);

p->add_item("Save Scene",FILE_SAVE_SCENE,KEY_MASK_CMD+KEY_S);

p->add_item("Save Scene As..",FILE_SAVE_AS_SCENE,KEY_MASK_SHIFT+KEY_MASK_CMD+KEY_S);

p->add_separator();

p->add_submenu_item("Open Recent","RecentScenes",FILE_OPEN_RECENT);

p->add_separator();

p->add_item("Quick Open Scene..",FILE_QUICK_OPEN_SCENE,KEY_MASK_SHIFT+KEY_MASK_CMD+KEY_O);

p->add_item("Quick Open Script..",FILE_QUICK_OPEN_SCRIPT,KEY_MASK_ALT+KEY_MASK_CMD+KEY_O);

p->add_separator();

PopupMenu *pm_export = memnew(PopupMenu );

p->add_separator();

p->add_item("Project Settings",RUN_SETTINGS);

p->add_separator();

p->add_item("Quit to Project List",RUN_PROJECT_MANAGER,KEY_MASK_SHIFT+KEY_MASK_CMD+KEY_Q);

p->add_item("Quit",FILE_QUIT,KEY_MASK_CMD+KEY_Q);

p->add_child(recent_scenes);

recent_scenes->connect("item_pressed",this,"_open_recent_scene");

//menu_hb->add_spacer();

#if 0

node_menu = memnew( MenuButton );

left_menu_hb->add_child( import_menu );

p=import_menu->get_popup();

p->connect("item_pressed",this,"_menu_option");

export_button = memnew( ToolButton );

play_button->set_icon(gui_base->get_icon("MainPlay","EditorIcons"));

play_button->set_focus_mode(Control::FOCUS_NONE);

play_button->connect("pressed", this,"_menu_option",make_binds(RUN_PLAY));

//menu_panel->add_child(pause_button); - not needed for now?

pause_button->set_toggle_mode(true);

pause_button->set_icon(gui_base->get_icon("Pause","EditorIcons"));

pause_button->set_focus_mode(Control::FOCUS_NONE);

pause_button->connect("pressed", this,"_menu_option",make_binds(RUN_PAUSE));

pause_button->set_tooltip("Pause the scene (F7).");

stop_button = memnew( ToolButton );

play_hb->add_child(stop_button);

//stop_button->set_toggle_mode(true);

menu_hb->add_child(native_play_button);

native_play_button->hide();

native_play_button->get_popup()->connect("item_pressed",this,"_run_in_device");

// play_hb->add_child(s1);

play_scene_button = memnew( ToolButton );

play_custom_scene_button->connect("pressed", this,"_menu_option",make_binds(RUN_PLAY_CUSTOM_SCENE));

play_custom_scene_button->set_tooltip("Play custom scene ("+keycode_get_string(KEY_MASK_CMD|KEY_MASK_SHIFT|KEY_F5)+").");

p->add_separator();

p->connect("item_pressed",this,"_menu_option");

run_settings_button = memnew( ToolButton );

//menu_hb->add_child(run_settings_button);

//run_settings_button->set_toggle_mode(true);

run_settings_button->set_focus_mode(Control::FOCUS_NONE);

run_settings_button->set_icon(gui_base->get_icon("Run","EditorIcons"));

run_settings_button->connect("pressed", this,"_menu_option",make_binds(RUN_SCENE_SETTINGS));

/*

run_settings_button = memnew( ToolButton );

*/

top_region = memnew( PanelContainer );

top_region->add_style_override("panel",gui_base->get_stylebox("hover","Button"));

HBoxContainer *right_menu_hb = memnew( HBoxContainer );

sources_button->connect("pressed",this,"_menu_option",varray(SOURCES_REIMPORT));

sources_button->set_tooltip("Alerts when an external resource has changed.");

//sources_button->connect();

/*

scene_tree_dock = memnew( SceneTreeDock(this,scene_root,editor_selection,editor_data) );

scene_tree_dock->set_name("Scene");

resources_dock = memnew( ResourcesDock(this) );

resources_dock->set_name("Resources");

editor_spacer->set_v_size_flags(Control::SIZE_EXPAND_FILL);

editor_vsplit->add_child( editor_spacer );

editor_spacer->add_child( top_pallete );

editor_spacer->set_v_size_flags(Control::SIZE_EXPAND_FILL);

editor_vsplit->add_child( editor_spacer );

editor_spacer->add_child( prop_pallete );

VBoxContainer *prop_editor_base = memnew( VBoxContainer );

prop_editor_base->set_name("Inspector"); // Properties?

HBoxContainer *prop_editor_hb = memnew( HBoxContainer );

property_back = memnew( ToolButton );

property_back->set_icon( gui_base->get_icon("Back","EditorIcons") );

property_back->set_flat(true);

property_back->set_tooltip("Go to the previous edited object in history.");

prop_editor_hb->add_child( property_back );

property_forward->set_icon( gui_base->get_icon("Forward","EditorIcons") );

property_forward->set_flat(true);

property_forward->set_tooltip("Go to the next edited object in history.");

prop_editor_hb->add_child( property_forward );

object_menu = memnew( MenuButton );

object_menu->set_icon(gui_base->get_icon("Tools","EditorIcons"));

prop_editor_hb->add_child( object_menu );

object_menu->set_tooltip("Object properties.");

scenes_dock = memnew( ScenesDock(this) );

scenes_dock->set_name("FileSystem");

scenes_dock->connect("open",this,"open_request");

scenes_dock->connect("instance",this,"_instance_request");

log = memnew( EditorLog );

log->connect("close_request",this,"_close_messages");

log->connect("show_request",this,"_show_messages");

//left_split->set_dragger_visible(false);

old_split_ofs=0;

animation_vb->add_child(animation_editor);

animation_editor->hide();

bottom_hb = memnew( HBoxContainer );

log->get_button()->set_h_size_flags(Control::SIZE_EXPAND_FILL);

//progress_hb->set_h_size_flags(Control::SIZE_EXPAND_FILL);

/*

animation_menu = memnew( ToolButton );

settings_config_dialog = memnew( EditorSettingsDialog );

gui_base->add_child(settings_config_dialog);

about->get_ok()->set_text("Thanks!");

about->set_hide_on_ok(true);

Label *about_text = memnew( Label );

about_text->set_pos(Point2(gui_base->get_icon("Logo","EditorIcons")->get_size().width+30,20));

gui_base->add_child(about);

about->add_child(about_text);

logo->set_pos(Point2(20,20));

logo->set_texture(gui_base->get_icon("Logo","EditorIcons") );

file_templates->add_filter("*.tpz ; Template Package");

gui_base->add_child(file);

file->set_current_dir("res://");

editor_import_export->add_import_plugin( Ref<EditorTextureImportPlugin>( memnew(EditorTextureImportPlugin(this,EditorTextureImportPlugin::MODE_TEXTURE_2D) )));

editor_import_export->add_import_plugin( Ref<EditorTextureImportPlugin>( memnew(EditorTextureImportPlugin(this,EditorTextureImportPlugin::MODE_ATLAS) )));

Ref<EditorSceneImportPlugin> _scene_import = memnew(EditorSceneImportPlugin(this) );

Ref<EditorSceneImporterCollada> _collada_import = memnew( EditorSceneImporterCollada);

_scene_import->add_importer(_collada_import);

editor_import_export->add_import_plugin( Ref<EditorSampleImportPlugin>( memnew(EditorSampleImportPlugin(this))));

editor_import_export->add_import_plugin( Ref<EditorTranslationImportPlugin>( memnew(EditorTranslationImportPlugin(this))));

editor_import_export->add_export_plugin( Ref<EditorTextureExportPlugin>( memnew(EditorTextureExportPlugin)));

add_editor_plugin( memnew( CanvasItemEditorPlugin(this) ) );

add_editor_plugin( memnew( SpatialEditorPlugin(this) ) );

add_editor_plugin( memnew( ScriptEditorPlugin(this) ) );

add_editor_plugin( memnew( AnimationPlayerEditorPlugin(this) ) );

add_editor_plugin( memnew( CameraEditorPlugin(this) ) );

add_editor_plugin( memnew( SampleEditorPlugin(this) ) );

add_editor_plugin( memnew( SampleLibraryEditorPlugin(this) ) );

add_editor_plugin( memnew( ParticlesEditorPlugin(this) ) );

add_editor_plugin( memnew( ResourcePreloaderEditorPlugin(this) ) );

add_editor_plugin( memnew( ItemListEditorPlugin(this) ) );

add_editor_plugin( memnew( CollisionPolygonEditorPlugin(this) ) );

add_editor_plugin( memnew( CollisionPolygon2DEditorPlugin(this) ) );

add_editor_plugin( memnew( TileSetEditorPlugin(this) ) );

add_editor_plugin( memnew( TileMapEditorPlugin(this) ) );

add_editor_plugin( memnew( SpriteFramesEditorPlugin(this) ) );

add_editor_plugin( memnew( Particles2DEditorPlugin(this) ) );

add_editor_plugin( memnew( Path2DEditorPlugin(this) ) );

add_editor_plugin( memnew( PathEditorPlugin(this) ) );

add_editor_plugin( memnew( BakedLightEditorPlugin(this) ) );

add_editor_plugin( memnew( Polygon2DEditorPlugin(this) ) );

for(int i=0;i<EditorPlugins::get_plugin_count();i++)

add_editor_plugin( EditorPlugins::create(i,this) );

circle_step_msec=OS::get_singleton()->get_ticks_msec();

circle_step_frame=OS::get_singleton()->get_frames_drawn();;

circle_step=0;

editor_plugin_screen=NULL;

editor_plugin_over=NULL;

Globals::get_singleton()->set("debug/indicators_enabled",true);

Globals::get_singleton()->set("render/room_cull_enabled",false);

theme->set_color("fg_selected","Editor",Color::html("ffbd8e8e"));

theme->set_color("fg_error","Editor",Color::html("ffbd8e8e"));

}

unsaved_cache=true;

_last_instanced_scene=NULL;

Node::set_human_readable_collision_renaming(true);

// Ref<ImageTexture> it = gui_base->get_icon("logo","Icons");

// OS::get_singleton()->set_icon( it->get_data() );

for(int i=0;i<_init_callbacks.size();i++)

_init_callbacks[i]();

}

EditorNode::~EditorNode() {

memdelete(editor_selection);

memdelete(file_server);

EditorSettings::destroy();