EditorLog::EditorLog() { VBoxContainer *vb = this; add_constant_override("separation", get_constant("separation", "VBoxContainer")); HBoxContainer *hb = memnew(HBoxContainer); vb->add_child(hb); title = memnew(Label); title->set_text(TTR(" Output:")); title->set_h_size_flags(SIZE_EXPAND_FILL); hb->add_child(title); //pd = memnew( PaneDrag ); //hb->add_child(pd); //pd->connect("dragged",this,"_dragged"); //pd->set_default_cursor_shape(Control::CURSOR_MOVE); clearbutton = memnew(Button); hb->add_child(clearbutton); clearbutton->set_text(TTR("Clear")); clearbutton->connect("pressed", this, "_clear_request"); ec = memnew(Control); vb->add_child(ec); ec->set_custom_minimum_size(Size2(0, 180)); ec->set_v_size_flags(SIZE_EXPAND_FILL); pc = memnew(PanelContainer); ec->add_child(pc); pc->set_area_as_parent_rect(); pc->connect("tree_entered", this, "_override_logger_styles"); log = memnew(RichTextLabel); log->set_scroll_follow(true); log->set_selection_enabled(true); log->set_focus_mode(FOCUS_CLICK); pc->add_child(log); add_message(VERSION_FULL_NAME " (c) 2008-2017 Juan Linietsky, Ariel Manzur."); //log->add_text("Initialization Complete.\n"); //because it looks cool. eh.errfunc = _error_handler; eh.userdata = this; add_error_handler(&eh); current = Thread::get_caller_ID(); EditorNode::get_undo_redo()->set_commit_notify_callback(_undo_redo_cbk, this); }
ItemListEditor::ItemListEditor() { selected_idx=-1; options = memnew( MenuButton ); add_child(options); options->set_area_as_parent_rect(); options->set_text("Items"); options->get_popup()->add_item("Edit Items",MENU_EDIT_ITEMS); //options->get_popup()->add_item("Clear",MENU_CLEAR); options->get_popup()->connect("item_pressed", this,"_menu_option"); dialog = memnew( AcceptDialog ); add_child( dialog ); HBoxContainer *hbc = memnew( HBoxContainer ); dialog->add_child(hbc); dialog->set_child_rect(hbc); prop_editor = memnew( PropertyEditor ); hbc->add_child(prop_editor); prop_editor->set_h_size_flags(SIZE_EXPAND_FILL); VBoxContainer *vbc = memnew( VBoxContainer ); hbc->add_child(vbc); add_button = memnew( Button ); //add_button->set_text("Add"); add_button->connect("pressed",this,"_add_button"); vbc->add_child(add_button); del_button = memnew( Button ); //del_button->set_text("Del"); del_button->connect("pressed",this,"_delete_button"); vbc->add_child(del_button); dialog->set_title("Item List"); prop_editor->hide_top_label(); }
ConnectionsDock::ConnectionsDock(EditorNode *p_editor) { editor = p_editor; set_name(TTR("Signals")); VBoxContainer *vbc = this; tree = memnew(Tree); tree->set_columns(1); tree->set_select_mode(Tree::SELECT_ROW); tree->set_hide_root(true); vbc->add_child(tree); tree->set_v_size_flags(SIZE_EXPAND_FILL); connect_button = memnew(Button); connect_button->set_text(TTR("Connect")); HBoxContainer *hb = memnew(HBoxContainer); vbc->add_child(hb); hb->add_spacer(); hb->add_child(connect_button); connect_button->connect("pressed", this, "_connect_pressed"); //add_child(tree); connect_dialog = memnew(ConnectDialog); connect_dialog->set_as_toplevel(true); add_child(connect_dialog); remove_confirm = memnew(ConfirmationDialog); remove_confirm->set_as_toplevel(true); add_child(remove_confirm); /* node_only->set_anchor( MARGIN_TOP, ANCHOR_END ); node_only->set_anchor( MARGIN_BOTTOM, ANCHOR_END ); node_only->set_anchor( MARGIN_RIGHT, ANCHOR_END ); node_only->set_begin( Point2( 20,51) ); node_only->set_end( Point2( 10,44) ); */ remove_confirm->connect("confirmed", this, "_remove_confirm"); connect_dialog->connect("connected", this, "_connect"); tree->connect("item_selected", this, "_something_selected"); tree->connect("item_activated", this, "_something_activated"); add_constant_override("separation", 3 * EDSCALE); }
EditorAssetLibraryItemDescription::EditorAssetLibraryItemDescription() { VBoxContainer *vbox = memnew(VBoxContainer); add_child(vbox); HBoxContainer *hbox = memnew(HBoxContainer); vbox->add_child(hbox); vbox->add_constant_override("separation", 15); VBoxContainer *desc_vbox = memnew(VBoxContainer); hbox->add_child(desc_vbox); hbox->add_constant_override("separation", 15); item = memnew(EditorAssetLibraryItem); desc_vbox->add_child(item); desc_vbox->set_custom_minimum_size(Size2(300, 0)); PanelContainer *desc_bg = memnew(PanelContainer); desc_vbox->add_child(desc_bg); desc_bg->set_v_size_flags(SIZE_EXPAND_FILL); description = memnew(RichTextLabel); description->connect("meta_clicked", this, "_link_click"); //desc_vbox->add_child(description); desc_bg->add_child(description); desc_bg->add_style_override("panel", get_stylebox("normal", "TextEdit")); preview = memnew(TextureRect); preview->set_custom_minimum_size(Size2(640, 345)); hbox->add_child(preview); PanelContainer *previews_bg = memnew(PanelContainer); vbox->add_child(previews_bg); previews_bg->set_custom_minimum_size(Size2(0, 85)); previews_bg->add_style_override("panel", get_stylebox("normal", "TextEdit")); previews = memnew(ScrollContainer); previews_bg->add_child(previews); previews->set_enable_v_scroll(false); previews->set_enable_h_scroll(true); preview_hb = memnew(HBoxContainer); preview_hb->set_v_size_flags(SIZE_EXPAND_FILL); previews->add_child(preview_hb); get_ok()->set_text("Install"); get_cancel()->set_text("Close"); }
SpriteEditor::SpriteEditor() { options = memnew(MenuButton); CanvasItemEditor::get_singleton()->add_control_to_menu_panel(options); options->set_text(TTR("Sprite")); options->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("Sprite", "EditorIcons")); options->get_popup()->add_item(TTR("Convert to 2D Mesh"), MENU_OPTION_CREATE_MESH_2D); options->get_popup()->connect("id_pressed", this, "_menu_option"); err_dialog = memnew(AcceptDialog); add_child(err_dialog); debug_uv_dialog = memnew(ConfirmationDialog); debug_uv_dialog->get_ok()->set_text(TTR("Create 2D Mesh")); debug_uv_dialog->set_title("Mesh 2D Preview"); VBoxContainer *vb = memnew(VBoxContainer); debug_uv_dialog->add_child(vb); ScrollContainer *scroll = memnew(ScrollContainer); scroll->set_custom_minimum_size(Size2(800, 500) * EDSCALE); scroll->set_enable_h_scroll(true); scroll->set_enable_v_scroll(true); vb->add_margin_child(TTR("Preview:"), scroll, true); debug_uv = memnew(Control); debug_uv->connect("draw", this, "_debug_uv_draw"); scroll->add_child(debug_uv); debug_uv_dialog->connect("confirmed", this, "_create_mesh_node"); HBoxContainer *hb = memnew(HBoxContainer); hb->add_child(memnew(Label(TTR("Simplification: ")))); simplification = memnew(SpinBox); simplification->set_min(0.01); simplification->set_max(10.00); simplification->set_step(0.01); simplification->set_value(2); hb->add_child(simplification); hb->add_spacer(); hb->add_child(memnew(Label(TTR("Grow (Pixels): ")))); island_merging = memnew(SpinBox); island_merging->set_min(0); island_merging->set_max(10); island_merging->set_step(1); island_merging->set_value(2); hb->add_child(island_merging); hb->add_spacer(); update_preview = memnew(Button); update_preview->set_text(TTR("Update Preview")); update_preview->connect("pressed", this, "_update_mesh_data"); hb->add_child(update_preview); vb->add_margin_child(TTR("Settings:"), hb); add_child(debug_uv_dialog); }
EditorSubScene::EditorSubScene() { scene = NULL; is_root = false; set_title(TTR("Select Node(s) to Import")); set_hide_on_ok(false); VBoxContainer *vb = memnew(VBoxContainer); add_child(vb); //set_child_rect(vb); HBoxContainer *hb = memnew(HBoxContainer); path = memnew(LineEdit); path->connect("text_entered", this, "_path_changed"); hb->add_child(path); path->set_h_size_flags(SIZE_EXPAND_FILL); Button *b = memnew(Button); b->set_text(" .. "); hb->add_child(b); b->connect("pressed", this, "_path_browse"); vb->add_margin_child(TTR("Scene Path:"), hb); tree = memnew(Tree); tree->set_v_size_flags(SIZE_EXPAND_FILL); vb->add_margin_child(TTR("Import From Node:"), tree, true); tree->set_select_mode(Tree::SELECT_MULTI); tree->connect("multi_selected", this, "_item_multi_selected"); //tree->connect("nothing_selected", this, "_deselect_items"); tree->connect("cell_selected", this, "_selected_changed"); tree->connect("item_activated", this, "_ok", make_binds(), CONNECT_DEFERRED); file_dialog = memnew(EditorFileDialog); List<String> extensions; ResourceLoader::get_recognized_extensions_for_type("PackedScene", &extensions); for (List<String>::Element *E = extensions.front(); E; E = E->next()) { file_dialog->add_filter("*." + E->get()); } file_dialog->set_mode(EditorFileDialog::MODE_OPEN_FILE); add_child(file_dialog); file_dialog->connect("file_selected", this, "_path_selected"); }
void ProjectManager::_panel_draw(Node *p_hb) { HBoxContainer *hb = p_hb->cast_to<HBoxContainer>(); hb->draw_line(Point2(0,hb->get_size().y+1),Point2(hb->get_size().x-10,hb->get_size().y+1),get_color("guide_color","Tree")); if (selected_list.has(hb->get_meta("name"))) { hb->draw_style_box(get_stylebox("selected","Tree"),Rect2(Point2(),hb->get_size()-Size2(10,0))); } }
Variant ProjectExportDialog::get_drag_data_fw(const Point2 &p_point, Control *p_from) { if (p_from == presets) { int pos = presets->get_item_at_position(p_point, true); if (pos >= 0) { Dictionary d; d["type"] = "export_preset"; d["preset"] = pos; HBoxContainer *drag = memnew(HBoxContainer); TextureRect *tr = memnew(TextureRect); tr->set_texture(presets->get_item_icon(pos)); drag->add_child(tr); Label *label = memnew(Label); label->set_text(presets->get_item_text(pos)); drag->add_child(label); set_drag_preview(drag); return d; } } else if (p_from == patches) { TreeItem *item = patches->get_item_at_position(p_point); if (item && item->get_cell_mode(0) == TreeItem::CELL_MODE_CHECK) { int metadata = item->get_metadata(0); Dictionary d; d["type"] = "export_patch"; d["patch"] = metadata; Label *label = memnew(Label); label->set_text(item->get_text(0)); set_drag_preview(label); return d; } } return Variant(); }
ItemListEditor::ItemListEditor() { selected_idx=-1; add_child( memnew( VSeparator ) ); toolbar_button = memnew( ToolButton ); toolbar_button->set_text(TTR("Items")); add_child(toolbar_button); toolbar_button->connect("pressed",this,"_edit_items"); dialog = memnew( AcceptDialog ); dialog->set_title(TTR("Item List Editor")); add_child( dialog ); VBoxContainer *vbc = memnew( VBoxContainer ); dialog->add_child(vbc); dialog->set_child_rect(vbc); HBoxContainer *hbc = memnew( HBoxContainer ); hbc->set_h_size_flags(SIZE_EXPAND_FILL); vbc->add_child(hbc); add_button = memnew( Button ); add_button->set_text(TTR("Add")); hbc->add_child(add_button); add_button->connect("pressed",this,"_add_button"); hbc->add_spacer(); del_button = memnew( Button ); del_button->set_text(TTR("Delete")); hbc->add_child(del_button); del_button->connect("pressed",this,"_delete_button"); property_editor = memnew( PropertyEditor ); property_editor->hide_top_label(); property_editor->set_subsection_selectable(true); vbc->add_child(property_editor); property_editor->set_v_size_flags(SIZE_EXPAND_FILL); tree = property_editor->get_scene_tree(); }
ResourcePreloaderEditor::ResourcePreloaderEditor() { //add_style_override("panel", EditorNode::get_singleton()->get_gui_base()->get_stylebox("panel","Panel")); VBoxContainer *vbc = memnew(VBoxContainer); add_child(vbc); HBoxContainer *hbc = memnew(HBoxContainer); vbc->add_child(hbc); load = memnew(Button); load->set_tooltip(TTR("Load Resource")); hbc->add_child(load); paste = memnew(Button); paste->set_text(TTR("Paste")); hbc->add_child(paste); file = memnew(EditorFileDialog); add_child(file); tree = memnew(Tree); tree->connect("button_pressed", this, "_cell_button_pressed"); tree->set_columns(2); tree->set_column_min_width(0, 2); tree->set_column_min_width(1, 3); tree->set_column_expand(0, true); tree->set_column_expand(1, true); tree->set_v_size_flags(SIZE_EXPAND_FILL); tree->set_drag_forwarding(this); vbc->add_child(tree); dialog = memnew(AcceptDialog); add_child(dialog); load->connect("pressed", this, "_load_pressed"); paste->connect("pressed", this, "_paste_pressed"); file->connect("files_selected", this, "_files_load_request"); tree->connect("item_edited", this, "_item_edited"); loading_scene = false; }
ImportDock::ImportDock() { imported = memnew(LineEdit); imported->set_editable(false); add_child(imported); HBoxContainer *hb = memnew(HBoxContainer); add_margin_child(TTR("Import As:"), hb); import_as = memnew(OptionButton); hb->add_child(import_as); import_as->set_h_size_flags(SIZE_EXPAND_FILL); preset = memnew(MenuButton); preset->set_text(TTR("Preset..")); preset->get_popup()->connect("index_pressed", this, "_preset_selected"); hb->add_child(preset); import_opts = memnew(PropertyEditor); add_child(import_opts); import_opts->set_v_size_flags(SIZE_EXPAND_FILL); import_opts->hide_top_label(); import_opts->set_hide_script(true); hb = memnew(HBoxContainer); add_child(hb); import = memnew(Button); import->set_text(TTR("Reimport")); import->connect("pressed", this, "_reimport"); hb->add_spacer(); hb->add_child(import); hb->add_spacer(); params = memnew(ImportDockParameters); import_opts->edit(params); }
DependencyEditor::DependencyEditor() { VBoxContainer *vb = memnew( VBoxContainer ); vb->set_name(TTR("Dependencies")); add_child(vb); set_child_rect(vb); tree = memnew( Tree ); tree->set_columns(2); tree->set_column_titles_visible(true); tree->set_column_title(0,"Resource"); tree->set_column_title(1,"Path"); tree->set_hide_root(true); tree->connect("button_pressed",this,"_load_pressed"); HBoxContainer *hbc = memnew( HBoxContainer ); Label *label = memnew( Label(TTR("Dependencies:"))); hbc->add_child(label); hbc->add_spacer(); fixdeps = memnew( Button(TTR("Fix Broken"))); hbc->add_child(fixdeps); fixdeps->connect("pressed",this,"_fix_all"); vb->add_child(hbc); MarginContainer *mc = memnew( MarginContainer ); mc->set_v_size_flags(SIZE_EXPAND_FILL); mc->add_child(tree); vb->add_child(mc); set_title(TTR("Dependency Editor")); search = memnew( EditorFileDialog ); search->connect("file_selected",this,"_searched"); search->set_mode(EditorFileDialog::MODE_OPEN_FILE); search->set_title(TTR("Search Replacement Resource:")); add_child(search); }
EditorSubScene::EditorSubScene() { set_title("Select Sub-Scene.."); VBoxContainer *vb = memnew( VBoxContainer ); add_child(vb); set_child_rect(vb); HBoxContainer *hb = memnew( HBoxContainer ); path = memnew( LineEdit ); path->connect("text_entered",this,"_path_changed"); hb->add_child(path); path->set_h_size_flags(SIZE_EXPAND_FILL); Button *b = memnew( Button ); b->set_text(" .. "); hb->add_child(b); b->connect("pressed",this,"_path_browse"); vb->add_margin_child("Scene Path:",hb); tree = memnew( Tree ); tree->set_v_size_flags(SIZE_EXPAND_FILL); vb->add_margin_child("Import From Node:",tree)->set_v_size_flags(SIZE_EXPAND_FILL); file_dialog = memnew( FileDialog ); List<String> extensions; ResourceLoader::get_recognized_extensions_for_type("PackedScene",&extensions); for(List<String>::Element *E = extensions.front();E;E=E->next() ) { file_dialog->add_filter("*."+E->get()); } file_dialog->set_mode(FileDialog::MODE_OPEN_FILE); add_child(file_dialog); file_dialog->connect("file_selected",this,"_path_selected"); scene=NULL; set_hide_on_ok(false); }
GroupsEditor::GroupsEditor() { node = NULL; VBoxContainer *vbc = this; group_dialog = memnew(GroupDialog); group_dialog->set_as_toplevel(true); add_child(group_dialog); group_dialog->connect("popup_hide", this, "_group_dialog_closed"); Button *group_dialog_button = memnew(Button); group_dialog_button->set_text(TTR("Manage Groups")); vbc->add_child(group_dialog_button); group_dialog_button->connect("pressed", this, "_show_group_dialog"); HBoxContainer *hbc = memnew(HBoxContainer); vbc->add_child(hbc); group_name = memnew(LineEdit); group_name->set_h_size_flags(SIZE_EXPAND_FILL); hbc->add_child(group_name); group_name->connect("text_entered", this, "_add_group"); add = memnew(Button); add->set_text(TTR("Add")); hbc->add_child(add); add->connect("pressed", this, "_add_group", varray(String())); tree = memnew(Tree); tree->set_hide_root(true); tree->set_v_size_flags(SIZE_EXPAND_FILL); vbc->add_child(tree); tree->connect("button_pressed", this, "_remove_group"); add_constant_override("separation", 3 * EDSCALE); }
void ProjectManager::_panel_input(const InputEvent& p_ev,Node *p_hb) { if (p_ev.type==InputEvent::MOUSE_BUTTON && p_ev.mouse_button.pressed && p_ev.mouse_button.button_index==BUTTON_LEFT) { String clicked = p_hb->get_meta("name"); String clicked_main_scene = p_hb->get_meta("main_scene"); if (p_ev.key.mod.shift && selected_list.size()>0 && last_clicked!="" && clicked != last_clicked) { int clicked_id = -1; int last_clicked_id = -1; for(int i=0;i<scroll_childs->get_child_count();i++) { HBoxContainer *hb = scroll_childs->get_child(i)->cast_to<HBoxContainer>(); if (!hb) continue; if (hb->get_meta("name") == clicked) clicked_id = i; if (hb->get_meta("name") == last_clicked) last_clicked_id = i; } if (last_clicked_id!=-1 && clicked_id!=-1) { int min = clicked_id < last_clicked_id? clicked_id : last_clicked_id; int max = clicked_id > last_clicked_id? clicked_id : last_clicked_id; for(int i=0; i<scroll_childs->get_child_count(); ++i) { HBoxContainer *hb = scroll_childs->get_child(i)->cast_to<HBoxContainer>(); if (!hb) continue; if (i!=clicked_id && (i<min || i>max) && !p_ev.key.mod.control) { selected_list.erase(hb->get_meta("name")); } else if (i>=min && i<=max) { selected_list.insert(hb->get_meta("name"), hb->get_meta("main_scene")); } } } } else if (selected_list.has(clicked) && p_ev.key.mod.control) { selected_list.erase(clicked); } else { last_clicked = clicked; if (p_ev.key.mod.control || selected_list.size()==0) { selected_list.insert(clicked, clicked_main_scene); } else { selected_list.clear(); selected_list.insert(clicked, clicked_main_scene); } } _update_project_buttons(); if (p_ev.mouse_button.doubleclick) _open_project(); //open if doubleclicked } }
PathsDialog::PathsDialog(Window *p_parent,DefaultPaths *p_paths,ConfigApi *p_config) : Window(p_parent,MODE_POPUP,SIZE_TOPLEVEL_CENTER) { paths=p_paths; config=p_config; WindowBox *vb = new WindowBox("Default Paths"); set_root_frame( vb ); MarginGroup *mg = vb->add( new MarginGroup("Song Path:")); HBoxContainer *hbc = mg->add(new HBoxContainer); song_path=hbc->add(new LineEdit,1); song_path->text_changed_signal.connect(this,&PathsDialog::paths_text_changed); hbc->add(new Button("Browse"))->pressed_signal.connect(this,&PathsDialog::browse_song_path); mg = vb->add( new MarginGroup("Sample Path:")); hbc = mg->add(new HBoxContainer); sample_path=hbc->add(new LineEdit,1); sample_path->text_changed_signal.connect(this,&PathsDialog::paths_text_changed); hbc->add(new Button("Browse"))->pressed_signal.connect(this,&PathsDialog::browse_sample_path); mg = vb->add( new MarginGroup("Instrument Path:")); hbc = mg->add(new HBoxContainer); instrument_path=hbc->add(new LineEdit,1); instrument_path->text_changed_signal.connect(this,&PathsDialog::paths_text_changed); hbc->add(new Button("Browse"))->pressed_signal.connect(this,&PathsDialog::browse_instrument_path); browser = new FileDialog(get_root()); browser->dir_selected_signal.connect(this,&PathsDialog::dir_selected ); config->write_entry_signal.connect( this, &PathsDialog::save_slot ); config->read_entry_signal.connect( this, &PathsDialog::read_slot ); config->read_finished_signal.connect( this, &PathsDialog::read_finished ); updating=false; update_paths(); }
PatternTranspose::PatternTranspose(Window *p_parent,Editor *p_editor) : Window(p_parent,Window::MODE_POPUP,Window::SIZE_CENTER) { editor=p_editor; VBoxContainer *vb = new VBoxContainer; set_root_frame( vb ); MarginGroup *mg=vb->add(new MarginGroup("Note Relationship")); for (int i=0;i<12;i++) { static const char* notes[12]={"C","C#","D","D#","E","F","F#","G","G#","A","A#","B"}; HBoxContainer *hb=mg->add(new HBoxContainer); LineEdit *le=hb->add(new LineEdit,1); le->set_text(notes[i]); le->set_editable( false ); hb->add(new HSeparator,2); trans[i]=hb->add(new ComboBox,2); for (int j=0;j<12;j++) { trans[i]->add_string(notes[j]); } trans[i]->select(i); } mg=vb->add(new MarginGroup("Actions")); HBoxContainer *hb = mg->add(new CenterContainer)->set(new HBoxContainer); hb->add(new Button("Clear"))->pressed_signal.connect(this,&PatternTranspose::reset); hb->add(new VSeparator); hb->add(new Button("Lower"))->pressed_signal.connect(this,&PatternTranspose::lower); hb->add(new Button("Raise"))->pressed_signal.connect(this,&PatternTranspose::raise); hb->add(new VSeparator); apply_b=hb->add(new Button("Apply")); apply_b->pressed_signal.connect(this,&PatternTranspose::apply); }
ColorPicker::ColorPicker() : BoxContainer(true) { updating = true; edit_alpha = true; text_is_constructor = false; raw_mode_enabled = false; deferred_mode_enabled = false; changing_color = false; screen = NULL; HBoxContainer *hb_smpl = memnew(HBoxContainer); btn_pick = memnew(ToolButton); btn_pick->connect("pressed", this, "_screen_pick_pressed"); sample = memnew(TextureRect); sample->set_h_size_flags(SIZE_EXPAND_FILL); sample->connect("draw", this, "_sample_draw"); hb_smpl->add_child(sample); hb_smpl->add_child(btn_pick); add_child(hb_smpl); HBoxContainer *hb_edit = memnew(HBoxContainer); hb_edit->set_v_size_flags(SIZE_EXPAND_FILL); uv_edit = memnew(Control); uv_edit->connect("gui_input", this, "_uv_input"); uv_edit->set_mouse_filter(MOUSE_FILTER_PASS); uv_edit->set_h_size_flags(SIZE_EXPAND_FILL); uv_edit->set_v_size_flags(SIZE_EXPAND_FILL); uv_edit->set_custom_minimum_size(Size2(get_constant("sv_width"), get_constant("sv_height"))); uv_edit->connect("draw", this, "_hsv_draw", make_binds(0, uv_edit)); add_child(hb_edit); w_edit = memnew(Control); w_edit->set_custom_minimum_size(Size2(get_constant("h_width"), 0)); w_edit->set_h_size_flags(SIZE_FILL); w_edit->set_v_size_flags(SIZE_EXPAND_FILL); w_edit->connect("gui_input", this, "_w_input"); w_edit->connect("draw", this, "_hsv_draw", make_binds(1, w_edit)); hb_edit->add_child(uv_edit); hb_edit->add_child(memnew(VSeparator)); hb_edit->add_child(w_edit); VBoxContainer *vbl = memnew(VBoxContainer); add_child(vbl); add_child(memnew(HSeparator)); VBoxContainer *vbr = memnew(VBoxContainer); add_child(vbr); vbr->set_h_size_flags(SIZE_EXPAND_FILL); const char *lt[4] = { "R", "G", "B", "A" }; for (int i = 0; i < 4; i++) { HBoxContainer *hbc = memnew(HBoxContainer); labels[i] = memnew(Label(lt[i])); labels[i]->set_custom_minimum_size(Size2(get_constant("label_width"), 0)); labels[i]->set_v_size_flags(SIZE_SHRINK_CENTER); hbc->add_child(labels[i]); scroll[i] = memnew(HSlider); scroll[i]->set_v_size_flags(SIZE_SHRINK_CENTER); scroll[i]->set_focus_mode(FOCUS_NONE); hbc->add_child(scroll[i]); values[i] = memnew(SpinBox); scroll[i]->share(values[i]); hbc->add_child(values[i]); values[i]->get_line_edit()->connect("focus_entered", this, "_focus_enter"); values[i]->get_line_edit()->connect("focus_exited", this, "_focus_exit"); scroll[i]->set_min(0); scroll[i]->set_page(0); scroll[i]->set_h_size_flags(SIZE_EXPAND_FILL); scroll[i]->connect("value_changed", this, "_value_changed"); vbr->add_child(hbc); } HBoxContainer *hhb = memnew(HBoxContainer); btn_mode = memnew(CheckButton); btn_mode->set_text(TTR("Raw Mode")); btn_mode->connect("toggled", this, "set_raw_mode"); hhb->add_child(btn_mode); vbr->add_child(hhb); text_type = memnew(Button); text_type->set_flat(true); text_type->connect("pressed", this, "_text_type_toggled"); hhb->add_child(text_type); c_text = memnew(LineEdit); hhb->add_child(c_text); c_text->connect("text_entered", this, "_html_entered"); c_text->connect("focus_entered", this, "_focus_enter"); c_text->connect("focus_exited", this, "_html_focus_exit"); text_type->set_text("#"); c_text->set_h_size_flags(SIZE_EXPAND_FILL); _update_controls(); updating = false; set_pick_color(Color(1, 1, 1)); HBoxContainer *bbc = memnew(HBoxContainer); add_child(bbc); preset = memnew(TextureRect); bbc->add_child(preset); preset->connect("gui_input", this, "_preset_input"); preset->connect("draw", this, "_update_presets"); bt_add_preset = memnew(Button); bt_add_preset->set_tooltip(TTR("Add current color as a preset")); bt_add_preset->connect("pressed", this, "_add_preset_pressed"); bbc->add_child(bt_add_preset); }
void ExportTemplateManager::_update_template_list() { while (current_hb->get_child_count()) { memdelete(current_hb->get_child(0)); } while (installed_vb->get_child_count()) { memdelete(installed_vb->get_child(0)); } DirAccess *d = DirAccess::create(DirAccess::ACCESS_FILESYSTEM); Error err = d->change_dir(EditorSettings::get_singleton()->get_templates_dir()); d->list_dir_begin(); Set<String> templates; if (err == OK) { bool isdir; String c = d->get_next(&isdir); while (c != String()) { if (isdir && !c.begins_with(".")) { templates.insert(c); } c = d->get_next(&isdir); } } d->list_dir_end(); memdelete(d); String current_version = VERSION_FULL_CONFIG; Label *current = memnew(Label); current->set_h_size_flags(SIZE_EXPAND_FILL); current_hb->add_child(current); if (templates.has(current_version)) { current->add_color_override("font_color", get_color("success_color", "Editor")); Button *redownload = memnew(Button); redownload->set_text(TTR("Re-Download")); current_hb->add_child(redownload); redownload->connect("pressed", this, "_download_template", varray(current_version)); Button *uninstall = memnew(Button); uninstall->set_text(TTR("Uninstall")); current_hb->add_child(uninstall); current->set_text(current_version + " " + TTR("(Installed)")); uninstall->connect("pressed", this, "_uninstall_template", varray(current_version)); } else { current->add_color_override("font_color", get_color("error_color", "Editor")); Button *redownload = memnew(Button); redownload->set_text(TTR("Download")); redownload->connect("pressed", this, "_download_template", varray(current_version)); current_hb->add_child(redownload); current->set_text(current_version + " " + TTR("(Missing)")); } for (Set<String>::Element *E = templates.back(); E; E = E->prev()) { HBoxContainer *hbc = memnew(HBoxContainer); Label *version = memnew(Label); version->set_modulate(get_color("disabled_font_color", "Editor")); String text = E->get(); if (text == current_version) { text += " " + TTR("(Current)"); } version->set_text(text); version->set_h_size_flags(SIZE_EXPAND_FILL); hbc->add_child(version); Button *uninstall = memnew(Button); uninstall->set_text(TTR("Uninstall")); hbc->add_child(uninstall); uninstall->connect("pressed", this, "_uninstall_template", varray(E->get())); installed_vb->add_child(hbc); } }
SpriteFramesEditor::SpriteFramesEditor() { //add_style_override("panel", get_stylebox("panel","Panel")); split = memnew(HSplitContainer); add_child(split); VBoxContainer *vbc_animlist = memnew(VBoxContainer); split->add_child(vbc_animlist); vbc_animlist->set_custom_minimum_size(Size2(150, 0)); //vbc_animlist->set_v_size_flags(SIZE_EXPAND_FILL); VBoxContainer *sub_vb = memnew(VBoxContainer); vbc_animlist->add_margin_child(TTR("Animations"), sub_vb, true); sub_vb->set_v_size_flags(SIZE_EXPAND_FILL); HBoxContainer *hbc_animlist = memnew(HBoxContainer); sub_vb->add_child(hbc_animlist); new_anim = memnew(Button); hbc_animlist->add_child(new_anim); new_anim->connect("pressed", this, "_animation_add"); hbc_animlist->add_spacer(); remove_anim = memnew(Button); hbc_animlist->add_child(remove_anim); remove_anim->connect("pressed", this, "_animation_remove"); animations = memnew(Tree); sub_vb->add_child(animations); animations->set_v_size_flags(SIZE_EXPAND_FILL); animations->set_hide_root(true); animations->connect("cell_selected", this, "_animation_select"); animations->connect("item_edited", this, "_animation_name_edited"); animations->set_single_select_cell_editing_only_when_already_selected(true); anim_speed = memnew(SpinBox); vbc_animlist->add_margin_child(TTR("Speed (FPS):"), anim_speed); anim_speed->set_min(0); anim_speed->set_max(100); anim_speed->set_step(0.01); anim_speed->connect("value_changed", this, "_animation_fps_changed"); anim_loop = memnew(CheckButton); anim_loop->set_text(TTR("Loop")); vbc_animlist->add_child(anim_loop); anim_loop->connect("pressed", this, "_animation_loop_changed"); VBoxContainer *vbc = memnew(VBoxContainer); split->add_child(vbc); vbc->set_h_size_flags(SIZE_EXPAND_FILL); sub_vb = memnew(VBoxContainer); vbc->add_margin_child(TTR("Animation Frames"), sub_vb, true); HBoxContainer *hbc = memnew(HBoxContainer); sub_vb->add_child(hbc); //animations = memnew( ItemList ); load = memnew(Button); load->set_tooltip(TTR("Load Resource")); hbc->add_child(load); copy = memnew(Button); copy->set_text(TTR("Copy")); hbc->add_child(copy); paste = memnew(Button); paste->set_text(TTR("Paste")); hbc->add_child(paste); empty = memnew(Button); empty->set_text(TTR("Insert Empty (Before)")); hbc->add_child(empty); empty2 = memnew(Button); empty2->set_text(TTR("Insert Empty (After)")); hbc->add_child(empty2); move_up = memnew(Button); move_up->set_text(TTR("Up")); hbc->add_child(move_up); move_down = memnew(Button); move_down->set_text(TTR("Down")); hbc->add_child(move_down); _delete = memnew(Button); hbc->add_child(_delete); file = memnew(EditorFileDialog); add_child(file); tree = memnew(ItemList); tree->set_v_size_flags(SIZE_EXPAND_FILL); tree->set_icon_mode(ItemList::ICON_MODE_TOP); int thumbnail_size = 96; tree->set_max_columns(0); tree->set_icon_mode(ItemList::ICON_MODE_TOP); tree->set_fixed_column_width(thumbnail_size * 3 / 2); tree->set_max_text_lines(2); tree->set_fixed_icon_size(Size2(thumbnail_size, thumbnail_size)); //tree->set_min_icon_size(Size2(thumbnail_size,thumbnail_size)); tree->set_drag_forwarding(this); sub_vb->add_child(tree); dialog = memnew(AcceptDialog); add_child(dialog); load->connect("pressed", this, "_load_pressed"); _delete->connect("pressed", this, "_delete_pressed"); copy->connect("pressed", this, "_copy_pressed"); paste->connect("pressed", this, "_paste_pressed"); empty->connect("pressed", this, "_empty_pressed"); empty2->connect("pressed", this, "_empty2_pressed"); move_up->connect("pressed", this, "_up_pressed"); move_down->connect("pressed", this, "_down_pressed"); file->connect("files_selected", this, "_file_load_request"); //dialog->connect("confirmed", this,"_delete_confirm_pressed"); //tree->connect("item_selected", this,"_item_edited"); loading_scene = false; sel = -1; updating = false; edited_anim = "default"; }
EditorTranslationImportDialog(EditorTranslationImportPlugin *p_plugin) { plugin=p_plugin; set_title(TTR("Import Translation")); VBoxContainer *vbc = memnew( VBoxContainer ); add_child(vbc); set_child_rect(vbc); VBoxContainer *csvb = memnew( VBoxContainer ); HBoxContainer *hbc = memnew( HBoxContainer ); csvb->add_child(hbc); vbc->add_margin_child(TTR("Source CSV:"),csvb); import_path = memnew( LineEdit ); import_path->set_h_size_flags(SIZE_EXPAND_FILL); hbc->add_child(import_path); ignore_first = memnew( CheckButton ); ignore_first->set_text(TTR("Ignore First Row")); csvb->add_child(ignore_first); Button * import_choose = memnew( Button ); import_choose->set_text(" .. "); hbc->add_child(import_choose); import_choose->connect("pressed", this,"_browse"); VBoxContainer *tcomp = memnew( VBoxContainer); hbc = memnew( HBoxContainer ); tcomp->add_child(hbc); vbc->add_margin_child(TTR("Target Path:"),tcomp); save_path = memnew( LineEdit ); save_path->set_h_size_flags(SIZE_EXPAND_FILL); hbc->add_child(save_path); Button * save_choose = memnew( Button ); save_choose->set_text(" .. "); hbc->add_child(save_choose); save_choose->connect("pressed", this,"_browse_target"); compress = memnew( CheckButton); compress->set_pressed(true); compress->set_text(TTR("Compress")); tcomp->add_child(compress); add_to_project = memnew( CheckButton); add_to_project->set_pressed(true); add_to_project->set_text(TTR("Add to Project (engine.cfg)")); tcomp->add_child(add_to_project); file_select = memnew(EditorFileDialog); file_select->set_access(EditorFileDialog::ACCESS_FILESYSTEM); add_child(file_select); file_select->set_mode(EditorFileDialog::MODE_OPEN_FILE); file_select->connect("file_selected", this,"_choose_file"); file_select->add_filter("*.csv ; Translation CSV"); save_select = memnew( EditorDirDialog ); add_child(save_select); // save_select->set_mode(EditorFileDialog::MODE_OPEN_DIR); save_select->connect("dir_selected", this,"_choose_save_dir"); get_ok()->connect("pressed", this,"_import"); get_ok()->set_text(TTR("Import")); error_dialog = memnew ( ConfirmationDialog ); add_child(error_dialog); error_dialog->get_ok()->set_text(TTR("Accept")); // error_dialog->get_cancel()->hide(); set_hide_on_ok(false); columns = memnew( Tree ); vbc->add_margin_child(TTR("Import Languages:"),columns,true); }
void VisualShaderEditor::_update_graph() { if (updating) return; if (visual_shader.is_null()) return; graph->set_scroll_ofs(visual_shader->get_graph_offset() * EDSCALE); VisualShader::Type type = VisualShader::Type(edit_type->get_selected()); graph->clear_connections(); //erase all nodes for (int i = 0; i < graph->get_child_count(); i++) { if (Object::cast_to<GraphNode>(graph->get_child(i))) { memdelete(graph->get_child(i)); i--; } } static const Color type_color[3] = { Color::html("#61daf4"), Color::html("#d67dee"), Color::html("#f6a86e") }; List<VisualShader::Connection> connections; visual_shader->get_node_connections(type, &connections); Ref<StyleBoxEmpty> label_style = make_empty_stylebox(2, 1, 2, 1); Vector<int> nodes = visual_shader->get_node_list(type); for (int n_i = 0; n_i < nodes.size(); n_i++) { Vector2 position = visual_shader->get_node_position(type, nodes[n_i]); Ref<VisualShaderNode> vsnode = visual_shader->get_node(type, nodes[n_i]); GraphNode *node = memnew(GraphNode); graph->add_child(node); /*if (!vsnode->is_connected("changed", this, "_node_changed")) { vsnode->connect("changed", this, "_node_changed", varray(vsnode->get_instance_id()), CONNECT_DEFERRED); }*/ node->set_offset(position); node->set_title(vsnode->get_caption()); node->set_name(itos(nodes[n_i])); if (nodes[n_i] >= 2) { node->set_show_close_button(true); node->connect("close_request", this, "_delete_request", varray(nodes[n_i]), CONNECT_DEFERRED); } node->connect("dragged", this, "_node_dragged", varray(nodes[n_i])); Control *custom_editor = NULL; int port_offset = 0; Ref<VisualShaderNodeUniform> uniform = vsnode; if (uniform.is_valid()) { LineEdit *uniform_name = memnew(LineEdit); uniform_name->set_text(uniform->get_uniform_name()); node->add_child(uniform_name); uniform_name->connect("text_entered", this, "_line_edit_changed", varray(uniform_name, nodes[n_i])); uniform_name->connect("focus_exited", this, "_line_edit_focus_out", varray(uniform_name, nodes[n_i])); if (vsnode->get_input_port_count() == 0 && vsnode->get_output_port_count() == 1 && vsnode->get_output_port_name(0) == "") { //shortcut VisualShaderNode::PortType port_right = vsnode->get_output_port_type(0); node->set_slot(0, false, VisualShaderNode::PORT_TYPE_SCALAR, Color(), true, port_right, type_color[port_right]); continue; } port_offset++; } for (int i = 0; i < plugins.size(); i++) { custom_editor = plugins.write[i]->create_editor(vsnode); if (custom_editor) { break; } } if (custom_editor && vsnode->get_output_port_count() > 0 && vsnode->get_output_port_name(0) == "" && (vsnode->get_input_port_count() == 0 || vsnode->get_input_port_name(0) == "")) { //will be embedded in first port } else if (custom_editor) { port_offset++; node->add_child(custom_editor); custom_editor = NULL; } for (int i = 0; i < MAX(vsnode->get_input_port_count(), vsnode->get_output_port_count()); i++) { if (vsnode->is_port_separator(i)) { node->add_child(memnew(HSeparator)); port_offset++; } bool valid_left = i < vsnode->get_input_port_count(); VisualShaderNode::PortType port_left = VisualShaderNode::PORT_TYPE_SCALAR; bool port_left_used = false; String name_left; if (valid_left) { name_left = vsnode->get_input_port_name(i); port_left = vsnode->get_input_port_type(i); for (List<VisualShader::Connection>::Element *E = connections.front(); E; E = E->next()) { if (E->get().to_node == nodes[n_i] && E->get().to_port == i) { port_left_used = true; } } } bool valid_right = i < vsnode->get_output_port_count(); VisualShaderNode::PortType port_right = VisualShaderNode::PORT_TYPE_SCALAR; String name_right; if (valid_right) { name_right = vsnode->get_output_port_name(i); port_right = vsnode->get_output_port_type(i); } HBoxContainer *hb = memnew(HBoxContainer); Variant default_value; if (valid_left && !port_left_used) { default_value = vsnode->get_input_port_default_value(i); } if (default_value.get_type() != Variant::NIL) { // only a label Button *button = memnew(Button); hb->add_child(button); button->connect("pressed", this, "_edit_port_default_input", varray(button, nodes[n_i], i)); switch (default_value.get_type()) { case Variant::COLOR: { button->set_custom_minimum_size(Size2(30, 0) * EDSCALE); button->connect("draw", this, "_draw_color_over_button", varray(button, default_value)); } break; case Variant::INT: case Variant::REAL: { button->set_text(String::num(default_value, 4)); } break; case Variant::VECTOR3: { Vector3 v = default_value; button->set_text(String::num(v.x, 3) + "," + String::num(v.y, 3) + "," + String::num(v.z, 3)); } break; default: {} } } if (i == 0 && custom_editor) { hb->add_child(custom_editor); custom_editor->set_h_size_flags(SIZE_EXPAND_FILL); } else { if (valid_left) { Label *label = memnew(Label); label->set_text(name_left); label->add_style_override("normal", label_style); //more compact hb->add_child(label); } hb->add_spacer(); if (valid_right) { Label *label = memnew(Label); label->set_text(name_right); label->set_align(Label::ALIGN_RIGHT); label->add_style_override("normal", label_style); //more compact hb->add_child(label); } } if (valid_right && edit_type->get_selected() == VisualShader::TYPE_FRAGMENT) { TextureButton *preview = memnew(TextureButton); preview->set_toggle_mode(true); preview->set_normal_texture(get_icon("GuiVisibilityHidden", "EditorIcons")); preview->set_pressed_texture(get_icon("GuiVisibilityVisible", "EditorIcons")); preview->set_v_size_flags(SIZE_SHRINK_CENTER); if (vsnode->get_output_port_for_preview() == i) { preview->set_pressed(true); } preview->connect("pressed", this, "_preview_select_port", varray(nodes[n_i], i), CONNECT_DEFERRED); hb->add_child(preview); } node->add_child(hb); node->set_slot(i + port_offset, valid_left, port_left, type_color[port_left], valid_right, port_right, type_color[port_right]); if (EditorSettings::get_singleton()->get("interface/theme/use_graph_node_headers")) { Ref<StyleBoxFlat> sb = node->get_stylebox("frame", "GraphNode"); Color c = sb->get_border_color(MARGIN_TOP); Color mono_color = ((c.r + c.g + c.b) / 3) < 0.7 ? Color(1.0, 1.0, 1.0) : Color(0.0, 0.0, 0.0); mono_color.a = 0.85; c = mono_color; node->add_color_override("title_color", c); c.a = 0.7; node->add_color_override("close_color", c); } } if (vsnode->get_output_port_for_preview() >= 0) { VisualShaderNodePortPreview *port_preview = memnew(VisualShaderNodePortPreview); port_preview->setup(visual_shader, type, nodes[n_i], vsnode->get_output_port_for_preview()); port_preview->set_h_size_flags(SIZE_SHRINK_CENTER); node->add_child(port_preview); } String error = vsnode->get_warning(visual_shader->get_mode(), type); if (error != String()) { Label *error_label = memnew(Label); error_label->add_color_override("font_color", get_color("error_color", "Editor")); error_label->set_text(error); node->add_child(error_label); } } for (List<VisualShader::Connection>::Element *E = connections.front(); E; E = E->next()) { int from = E->get().from_node; int from_idx = E->get().from_port; int to = E->get().to_node; int to_idx = E->get().to_port; graph->connect_node(itos(from), from_idx, itos(to), to_idx); } }
ResourcesDock::ResourcesDock(EditorNode *p_editor) { editor=p_editor; VBoxContainer *vbc = this; HBoxContainer *hbc = memnew( HBoxContainer ); vbc->add_child(hbc); Button *b; b = memnew( ToolButton ); b->set_tooltip(TTR("Create New Resource")); b->connect("pressed",this,"_tool_selected",make_binds(TOOL_NEW)); hbc->add_child( b ); button_new=b; b = memnew( ToolButton ); b->set_tooltip(TTR("Open Resource")); b->connect("pressed",this,"_tool_selected",make_binds(TOOL_OPEN)); hbc->add_child( b ); button_open=b; MenuButton *mb = memnew( MenuButton ); mb->set_tooltip(TTR("Save Resource")); mb->get_popup()->add_item(TTR("Save Resource"),TOOL_SAVE); mb->get_popup()->add_item(TTR("Save Resource As.."),TOOL_SAVE_AS); mb->get_popup()->connect("item_pressed",this,"_tool_selected" ); hbc->add_child( mb ); button_save=mb; hbc->add_spacer(); mb = memnew( MenuButton ); mb->set_tooltip(TTR("Resource Tools")); mb->get_popup()->add_item(TTR("Make Local"),TOOL_MAKE_LOCAL); mb->get_popup()->add_item(TTR("Copy"),TOOL_COPY); mb->get_popup()->add_item(TTR("Paste"),TOOL_PASTE); mb->get_popup()->connect("item_pressed",this,"_tool_selected" ); hbc->add_child( mb ); button_tools=mb; resources = memnew( Tree ); vbc->add_child(resources); resources->set_v_size_flags(SIZE_EXPAND_FILL); resources->create_item(); //root resources->set_hide_root(true); resources->connect("cell_selected",this,"_resource_selected"); resources->connect("button_pressed",this,"_delete"); create_dialog = memnew( CreateDialog ); add_child(create_dialog); create_dialog->set_base_type("Resource"); create_dialog->connect("create",this,"_create"); accept = memnew (AcceptDialog); add_child(accept); file = memnew( EditorFileDialog ); add_child(file); file->connect("file_selected",this,"_file_action"); block_add=false; }
AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor) { editor=p_editor; singleton=this; updating=false; set_focus_mode(FOCUS_ALL); player=NULL; add_style_override("panel", get_stylebox("panel","Panel")); Label * l; /*l= memnew( Label ); l->set_text("Animation Player:"); add_child(l);*/ HBoxContainer *hb = memnew( HBoxContainer ); add_child(hb); add_anim = memnew( ToolButton ); add_anim->set_tooltip("Create new animation in player."); hb->add_child(add_anim); load_anim = memnew( ToolButton ); load_anim->set_tooltip("Load an animation from disk."); hb->add_child(load_anim); save_anim = memnew(MenuButton); save_anim->set_tooltip("Save the current animation"); save_anim->get_popup()->add_item("Save", ANIM_SAVE); save_anim->get_popup()->add_item("Save As..", ANIM_SAVE_AS); save_anim->set_focus_mode(Control::FOCUS_NONE); hb->add_child(save_anim); accept = memnew(AcceptDialog); add_child(accept); accept->connect("confirmed", this, "_menu_confirm_current"); duplicate_anim = memnew( ToolButton ); hb->add_child(duplicate_anim); duplicate_anim->set_tooltip("Duplicate Animation"); rename_anim = memnew( ToolButton ); hb->add_child(rename_anim); rename_anim->set_tooltip("Rename Animation"); remove_anim = memnew( ToolButton ); hb->add_child(remove_anim); remove_anim->set_tooltip("Remove Animation"); animation = memnew( OptionButton ); hb->add_child(animation); animation->set_h_size_flags(SIZE_EXPAND_FILL); animation->set_tooltip("Display list of animations in player."); autoplay = memnew( ToolButton ); hb->add_child(autoplay); autoplay->set_tooltip("Autoplay On Load"); blend_anim = memnew( ToolButton ); hb->add_child(blend_anim); blend_anim->set_tooltip("Edit Target Blend Times"); tool_anim = memnew( MenuButton); //tool_anim->set_flat(false); tool_anim->set_tooltip("Animation Tools"); tool_anim->get_popup()->add_item("Copy Animation",TOOL_COPY_ANIM); tool_anim->get_popup()->add_item("Paste Animation",TOOL_PASTE_ANIM); //tool_anim->get_popup()->add_separator(); //tool_anim->get_popup()->add_item("Edit Anim Resource",TOOL_PASTE_ANIM); hb->add_child(tool_anim); edit_anim = memnew( ToolButton ); edit_anim->set_toggle_mode(true); hb->add_child(edit_anim); edit_anim->set_tooltip("Open animation editor.\nProperty editor will displays all editable keys too."); hb = memnew (HBoxContainer); add_child(hb); play_bw_from = memnew( ToolButton ); play_bw_from->set_tooltip("Play backwards selected animation from current pos. (A)"); hb->add_child(play_bw_from); play_bw = memnew( ToolButton ); play_bw->set_tooltip("Play backwards selected animation from end. (Shift+A)"); hb->add_child(play_bw); stop = memnew( ToolButton ); stop->set_toggle_mode(true); hb->add_child(stop); stop->set_tooltip("Stop animation playback. (S)"); play = memnew( ToolButton ); play->set_tooltip("Play selected animation from start. (Shift+D)"); hb->add_child(play); play_from = memnew( ToolButton ); play_from->set_tooltip("Play selected animation from current pos. (D)"); hb->add_child(play_from); //pause = memnew( Button ); //pause->set_toggle_mode(true); //hb->add_child(pause); seek = memnew( HSlider ); seek->set_val(0); seek->set_step(0.01); hb->add_child(seek); seek->set_h_size_flags(SIZE_EXPAND_FILL); seek->set_stretch_ratio(8); seek->set_tooltip("Seek animation (when stopped)."); frame = memnew( SpinBox ); hb->add_child(frame); frame->set_h_size_flags(SIZE_EXPAND_FILL); frame->set_stretch_ratio(2); frame->set_tooltip("Animation position (in seconds)."); seek->share(frame); scale = memnew( LineEdit ); hb->add_child(scale); scale->set_h_size_flags(SIZE_EXPAND_FILL); scale->set_stretch_ratio(1); scale->set_tooltip("Scale animation playback globally for the node."); scale->hide(); resource_edit_anim= memnew( Button ); hb->add_child(resource_edit_anim); resource_edit_anim->hide(); file = memnew(EditorFileDialog); add_child(file); name_dialog = memnew( ConfirmationDialog ); name_dialog->set_title("Create New Animation"); name_dialog->set_hide_on_ok(false); add_child(name_dialog); name = memnew( LineEdit ); name_dialog->add_child(name); name->set_pos(Point2(18,30)); name->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,10); name_dialog->register_text_enter(name); l = memnew( Label ); l->set_text("Animation Name:"); l->set_pos( Point2(10,10) ); name_dialog->add_child(l); name_title=l; error_dialog = memnew( ConfirmationDialog ); error_dialog->get_ok()->set_text("Close"); //error_dialog->get_cancel()->set_text("Close"); error_dialog->set_text("Error!"); add_child(error_dialog); name_dialog->connect("confirmed", this,"_animation_name_edited"); blend_editor.dialog = memnew( AcceptDialog ); add_child(blend_editor.dialog); blend_editor.dialog->get_ok()->set_text("Close"); blend_editor.dialog->set_hide_on_ok(true); VBoxContainer *blend_vb = memnew( VBoxContainer); blend_editor.dialog->add_child(blend_vb); blend_editor.dialog->set_child_rect(blend_vb); blend_editor.tree = memnew( Tree ); blend_editor.tree->set_columns(2); blend_vb->add_margin_child("Blend Times: ",blend_editor.tree,true); blend_editor.next = memnew( LineEdit ); blend_vb->add_margin_child("Next (Auto Queue):",blend_editor.next); blend_editor.dialog->set_title("Cross-Animation Blend Times"); updating_blends=false; blend_editor.tree->connect("item_edited",this,"_blend_edited"); autoplay->connect("pressed", this,"_autoplay_pressed"); autoplay->set_toggle_mode(true); play->connect("pressed", this,"_play_pressed"); play_from->connect("pressed", this,"_play_from_pressed"); play_bw->connect("pressed", this,"_play_bw_pressed"); play_bw_from->connect("pressed", this,"_play_bw_from_pressed"); stop->connect("pressed", this,"_stop_pressed"); //pause->connect("pressed", this,"_pause_pressed"); add_anim->connect("pressed", this,"_animation_new"); rename_anim->connect("pressed", this,"_animation_rename"); load_anim->connect("pressed", this,"_animation_load"); duplicate_anim->connect("pressed", this,"_animation_duplicate"); //frame->connect("text_entered", this,"_seek_frame_changed"); edit_anim->connect("pressed", this,"_animation_edit"); blend_anim->connect("pressed", this,"_animation_blend"); remove_anim->connect("pressed", this,"_animation_remove"); animation->connect("item_selected", this,"_animation_selected",Vector<Variant>(),true); resource_edit_anim->connect("pressed", this,"_animation_resource_edit"); file->connect("file_selected", this,"_dialog_action"); seek->connect("value_changed", this, "_seek_value_changed",Vector<Variant>(),true); scale->connect("text_entered", this, "_scale_changed",Vector<Variant>(),true); editor->get_animation_editor()->connect("timeline_changed",this,"_animation_key_editor_seek"); editor->get_animation_editor()->connect("animation_len_changed",this,"_animation_key_editor_anim_len_changed"); HBoxContainer *ahb = editor->get_animation_panel_hb(); nodename = memnew( Label ); ahb->add_child(nodename); nodename->set_h_size_flags(SIZE_EXPAND_FILL); nodename->set_opacity(0.5); pin = memnew( TextureButton ); pin->set_toggle_mode(true); ahb->add_child(pin); renaming=false; last_active=false; set_process_unhandled_key_input(true); }
HBoxContainer* EditorAddonLibrary::_make_pages(int p_page,int p_max_page,int p_page_len,int p_total_items,int p_current_items) { HBoxContainer * hbc = memnew( HBoxContainer ); //do the mario int from = p_page-5; if (from<0) from=0; int to = from+10; if (to>p_max_page) to=p_max_page; Color gray = Color(0.65,0.65,0.65); hbc->add_spacer(); hbc->add_constant_override("separation",10); LinkButton *first = memnew( LinkButton ); first->set_text("first"); first->add_color_override("font_color", gray ); first->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); first->connect("pressed",this,"_search",varray(0)); hbc->add_child(first); if (p_page>0) { LinkButton *prev = memnew( LinkButton ); prev->set_text("prev"); prev->add_color_override("font_color", gray ); prev->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); prev->connect("pressed",this,"_search",varray(p_page-1)); hbc->add_child(prev); } for(int i=from;i<=to;i++) { if (i==p_page) { Label *current = memnew(Label); current->set_text(itos(i)); hbc->add_child(current); } else { LinkButton *current = memnew( LinkButton ); current->add_color_override("font_color", gray ); current->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); current->set_text(itos(i)); current->connect("pressed",this,"_search",varray(i)); hbc->add_child(current); } } if (p_page<p_max_page) { LinkButton *next = memnew( LinkButton ); next->set_text("next"); next->add_color_override("font_color", gray ); next->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); next->connect("pressed",this,"_search",varray(p_page+1)); hbc->add_child(next); } LinkButton *last = memnew( LinkButton ); last->set_text("last"); last->add_color_override("font_color", gray ); last->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER); hbc->add_child(last); last->connect("pressed",this,"_search",varray(p_max_page)); Label *totals = memnew( Label ); totals->set_text("( "+itos(from*p_page_len)+" - "+itos(from*p_page_len+p_current_items-1)+" / "+itos(p_total_items)+" )"); hbc->add_child(totals); hbc->add_spacer(); return hbc; }
EditorSceneImportDialog::EditorSceneImportDialog(EditorNode *p_editor, EditorSceneImportPlugin *p_plugin) { editor=p_editor; plugin=p_plugin; set_title("Import 3D Scene"); HBoxContainer *import_hb = memnew( HBoxContainer ); add_child(import_hb); set_child_rect(import_hb); VBoxContainer *vbc = memnew( VBoxContainer ); import_hb->add_child(vbc); vbc->set_h_size_flags(SIZE_EXPAND_FILL); HBoxContainer *hbc = memnew( HBoxContainer ); vbc->add_margin_child("Source Scene:",hbc); import_path = memnew( LineEdit ); import_path->set_h_size_flags(SIZE_EXPAND_FILL); hbc->add_child(import_path); Button * import_choose = memnew( Button ); import_choose->set_text(" .. "); hbc->add_child(import_choose); import_choose->connect("pressed", this,"_browse"); hbc = memnew( HBoxContainer ); vbc->add_margin_child("Target Scene:",hbc); save_path = memnew( LineEdit ); save_path->set_h_size_flags(SIZE_EXPAND_FILL); hbc->add_child(save_path); Button * save_choose = memnew( Button ); save_choose->set_text(" .. "); hbc->add_child(save_choose); save_choose->connect("pressed", this,"_browse_target"); texture_action = memnew( OptionButton ); texture_action->add_item("Same as Target Scene"); texture_action->add_item("Shared"); texture_action->select(0); vbc->add_margin_child("Target Texture Folder:",texture_action); import_options = memnew( Tree ); vbc->set_v_size_flags(SIZE_EXPAND_FILL); vbc->add_margin_child("Options:",import_options,true); file_select = memnew(FileDialog); file_select->set_access(FileDialog::ACCESS_FILESYSTEM); add_child(file_select); file_select->set_mode(FileDialog::MODE_OPEN_FILE); file_select->connect("file_selected", this,"_choose_file"); save_select = memnew(EditorDirDialog); add_child(save_select); //save_select->set_mode(FileDialog::MODE_SAVE_FILE); save_select->connect("dir_selected", this,"_choose_save_file"); get_ok()->connect("pressed", this,"_import"); get_ok()->set_text("Import"); TreeItem *root = import_options->create_item(NULL); import_options->set_hide_root(true); TreeItem *importopts = import_options->create_item(root); importopts->set_text(0,"Import:"); const FlagInfo* fn=scene_flag_names; while(fn->text) { TreeItem *opt = import_options->create_item(importopts); opt->set_cell_mode(0,TreeItem::CELL_MODE_CHECK); opt->set_checked(0,true); opt->set_editable(0,true); opt->set_text(0,fn->text); opt->set_metadata(0,fn->value); scene_flags.push_back(opt); fn++; } hbc = memnew( HBoxContainer ); vbc->add_margin_child("Post-Process Script:",hbc); script_path = memnew( LineEdit ); script_path->set_h_size_flags(SIZE_EXPAND_FILL); hbc->add_child(script_path); Button * script_choose = memnew( Button ); script_choose->set_text(" .. "); hbc->add_child(script_choose); script_choose->connect("pressed", this,"_browse_script"); script_select = memnew(FileDialog); add_child(script_select); for(int i=0;i<ScriptServer::get_language_count();i++) { ScriptLanguage *sl=ScriptServer::get_language(i); String ext = sl->get_extension(); if (ext=="") continue; script_select->add_filter("*."+ext+" ; "+sl->get_name()); } script_select->set_mode(FileDialog::MODE_OPEN_FILE); script_select->connect("file_selected", this,"_choose_script"); error_dialog = memnew ( ConfirmationDialog ); add_child(error_dialog); error_dialog->get_ok()->set_text("Accept"); // error_dialog->get_cancel()->hide(); set_hide_on_ok(false); GLOBAL_DEF("import/shared_textures","res://"); Globals::get_singleton()->set_custom_property_info("import/shared_textures",PropertyInfo(Variant::STRING,"import/shared_textures",PROPERTY_HINT_DIR)); import_hb->add_constant_override("separation",30); VBoxContainer *ovb = memnew( VBoxContainer); ovb->set_h_size_flags(SIZE_EXPAND_FILL); import_hb->add_child(ovb); texture_options = memnew( EditorImportTextureOptions ); ovb->add_child(texture_options); texture_options->set_v_size_flags(SIZE_EXPAND_FILL); //animation_options->set_flags(EditorImport:: texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_RAM); texture_options->set_flags( EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA | EditorTextureImportPlugin::IMAGE_FLAG_REPEAT | EditorTextureImportPlugin::IMAGE_FLAG_FILTER ); animation_options = memnew( EditorImportAnimationOptions ); ovb->add_child(animation_options); animation_options->set_v_size_flags(SIZE_EXPAND_FILL); animation_options->set_flags(EditorSceneAnimationImportPlugin::ANIMATION_DETECT_LOOP|EditorSceneAnimationImportPlugin::ANIMATION_KEEP_VALUE_TRACKS|EditorSceneAnimationImportPlugin::ANIMATION_OPTIMIZE); confirm_import = memnew( ConfirmationDialog ); add_child(confirm_import); VBoxContainer *cvb = memnew( VBoxContainer ); confirm_import->add_child(cvb); confirm_import->set_child_rect(cvb); PanelContainer *pc = memnew( PanelContainer ); pc->add_style_override("panel",get_stylebox("normal","TextEdit")); //ec->add_child(pc); missing_files = memnew( RichTextLabel ); cvb->add_margin_child("The Following Files are Missing:",pc,true); pc->add_child(missing_files); confirm_import->get_ok()->set_text("Import Anyway"); confirm_import->get_cancel()->set_text("Cancel"); confirm_import->connect("popup_hide",this,"_dialog_hid"); confirm_import->connect("confirmed",this,"_import_confirm"); confirm_import->set_hide_on_ok(false); add_button("Import & Open",!OS::get_singleton()->get_swap_ok_cancel())->connect("pressed",this,"_open_and_import"); confirm_open = memnew( ConfirmationDialog ); add_child(confirm_open); confirm_open->set_text("Edited scene has not been saved, open imported scene anyway?"); confirm_open->connect("confirmed",this,"_import",varray(true)); wip_import=NULL; wip_blocked=false; wip_open=false; //texture_options->set_format(EditorImport::IMAGE_FORMAT_C); }
void ProjectManager::_load_recent_projects() { while(scroll_childs->get_child_count()>0) { memdelete( scroll_childs->get_child(0)); } List<PropertyInfo> properties; EditorSettings::get_singleton()->get_property_list(&properties); Color font_color = get_color("font_color","Tree"); for(List<PropertyInfo>::Element *E=properties.front();E;E=E->next()) { String _name = E->get().name; if (!_name.begins_with("projects/")) continue; String project = _name.get_slice("/",1); String path = EditorSettings::get_singleton()->get(_name); String conf=path.plus_file("engine.cfg"); Ref<ConfigFile> cf = memnew( ConfigFile ); Error err = cf->load(conf); ERR_CONTINUE(err!=OK); Ref<Texture> icon; String project_name="Unnamed Project"; if (cf->has_section_key("application","icon")) { String appicon = cf->get_value("application","icon"); if (appicon!="") { Image img; Error err = img.load(appicon.replace_first("res://",path+"/")); if (err==OK) { img.resize(64,64); Ref<ImageTexture> it = memnew( ImageTexture ); it->create_from_image(img); icon=it; } } } if (cf->has_section_key("application","name")) { project_name = cf->get_value("application","name"); } if (icon.is_null()) { icon=get_icon("DefaultProjectIcon","EditorIcons"); } String main_scene; if (cf->has_section_key("application","main_scene")) { main_scene = cf->get_value("application","main_scene"); } HBoxContainer *hb = memnew( HBoxContainer ); hb->set_meta("name",project); hb->set_meta("main_scene",main_scene); hb->connect("draw",this,"_panel_draw",varray(hb)); hb->connect("input_event",this,"_panel_input",varray(hb)); TextureFrame *tf = memnew( TextureFrame ); tf->set_texture(icon); hb->add_child(tf); VBoxContainer *vb = memnew(VBoxContainer); hb->add_child(vb); EmptyControl *ec = memnew( EmptyControl ); ec->set_minsize(Size2(0,1)); vb->add_child(ec); Label *title = memnew( Label(project_name) ); title->add_font_override("font",get_font("large","Fonts")); title->add_color_override("font_color",font_color); vb->add_child(title); Label *fpath = memnew( Label(path) ); vb->add_child(fpath); fpath->set_opacity(0.5); fpath->add_color_override("font_color",font_color); scroll_childs->add_child(hb); } erase_btn->set_disabled(selected==""); open_btn->set_disabled(selected==""); if (selected=="") run_btn->set_disabled(true); }
MaterialEditor::MaterialEditor() { viewport = memnew( Viewport ); Ref<World> world; world.instance(); viewport->set_world(world); //use own world add_child(viewport); viewport->set_disable_input(true); camera = memnew( Camera ); camera->set_transform(Transform(Matrix3(),Vector3(0,0,3))); camera->set_perspective(45,0.1,10); viewport->add_child(camera); light1 = memnew( DirectionalLight ); light1->set_transform(Transform().looking_at(Vector3(-1,-1,-1),Vector3(0,1,0))); viewport->add_child(light1); light2 = memnew( DirectionalLight ); light2->set_transform(Transform().looking_at(Vector3(0,1,0),Vector3(0,0,1))); light2->set_color(Light::COLOR_DIFFUSE,Color(0.7,0.7,0.7)); light2->set_color(Light::COLOR_SPECULAR,Color(0.7,0.7,0.7)); viewport->add_child(light2); sphere_instance = memnew( MeshInstance ); viewport->add_child(sphere_instance); box_instance = memnew( MeshInstance ); viewport->add_child(box_instance); Transform box_xform; box_xform.basis.rotate(Vector3(1,0,0),Math::deg2rad(25)); box_xform.basis = box_xform.basis * Matrix3().rotated(Vector3(0,1,0),Math::deg2rad(25)); box_xform.basis.scale(Vector3(0.8,0.8,0.8)); box_instance->set_transform(box_xform); { sphere_mesh.instance(); int lats=32; int lons=32; float radius=1.0; PoolVector<Vector3> vertices; PoolVector<Vector3> normals; PoolVector<Vector2> uvs; PoolVector<float> tangents; Matrix3 tt = Matrix3(Vector3(0,1,0),Math_PI*0.5); for(int i = 1; i <= lats; i++) { double lat0 = Math_PI * (-0.5 + (double) (i - 1) / lats); double z0 = Math::sin(lat0); double zr0 = Math::cos(lat0); double lat1 = Math_PI * (-0.5 + (double) i / lats); double z1 = Math::sin(lat1); double zr1 = Math::cos(lat1); for(int j = lons; j >= 1; j--) { double lng0 = 2 * Math_PI * (double) (j - 1) / lons; double x0 = Math::cos(lng0); double y0 = Math::sin(lng0); double lng1 = 2 * Math_PI * (double) (j) / lons; double x1 = Math::cos(lng1); double y1 = Math::sin(lng1); Vector3 v[4]={ Vector3(x1 * zr0, z0, y1 *zr0), Vector3(x1 * zr1, z1, y1 *zr1), Vector3(x0 * zr1, z1, y0 *zr1), Vector3(x0 * zr0, z0, y0 *zr0) }; #define ADD_POINT(m_idx) \ normals.push_back(v[m_idx]);\ vertices.push_back(v[m_idx]*radius);\ { Vector2 uv(Math::atan2(v[m_idx].x,v[m_idx].z),Math::atan2(-v[m_idx].y,v[m_idx].z));\ uv/=Math_PI;\ uv*=4.0;\ uv=uv*0.5+Vector2(0.5,0.5);\ uvs.push_back(uv);\ }\ { Vector3 t = tt.xform(v[m_idx]);\ tangents.push_back(t.x);\ tangents.push_back(t.y);\ tangents.push_back(t.z);\ tangents.push_back(1.0);\ } ADD_POINT(0); ADD_POINT(1); ADD_POINT(2); ADD_POINT(2); ADD_POINT(3); ADD_POINT(0); } } Array arr; arr.resize(VS::ARRAY_MAX); arr[VS::ARRAY_VERTEX]=vertices; arr[VS::ARRAY_NORMAL]=normals; arr[VS::ARRAY_TANGENT]=tangents; arr[VS::ARRAY_TEX_UV]=uvs; sphere_mesh->add_surface(Mesh::PRIMITIVE_TRIANGLES,arr); sphere_instance->set_mesh(sphere_mesh); } { box_mesh.instance(); PoolVector<Vector3> vertices; PoolVector<Vector3> normals; PoolVector<float> tangents; PoolVector<Vector3> uvs; int vtx_idx=0; #define ADD_VTX(m_idx);\ vertices.push_back( face_points[m_idx] );\ normals.push_back( normal_points[m_idx] );\ tangents.push_back( normal_points[m_idx][1] );\ tangents.push_back( normal_points[m_idx][2] );\ tangents.push_back( normal_points[m_idx][0] );\ tangents.push_back( 1.0 );\ uvs.push_back( Vector3(uv_points[m_idx*2+0],uv_points[m_idx*2+1],0) );\ vtx_idx++;\ for (int i=0;i<6;i++) { Vector3 face_points[4]; Vector3 normal_points[4]; float uv_points[8]={0,0,0,1,1,1,1,0}; for (int j=0;j<4;j++) { float v[3]; v[0]=1.0; v[1]=1-2*((j>>1)&1); v[2]=v[1]*(1-2*(j&1)); for (int k=0;k<3;k++) { if (i<3) face_points[j][(i+k)%3]=v[k]*(i>=3?-1:1); else face_points[3-j][(i+k)%3]=v[k]*(i>=3?-1:1); } normal_points[j]=Vector3(); normal_points[j][i%3]=(i>=3?-1:1); } //tri 1 ADD_VTX(0); ADD_VTX(1); ADD_VTX(2); //tri 2 ADD_VTX(2); ADD_VTX(3); ADD_VTX(0); } Array d; d.resize(VS::ARRAY_MAX); d[VisualServer::ARRAY_NORMAL]= normals ; d[VisualServer::ARRAY_TANGENT]= tangents ; d[VisualServer::ARRAY_TEX_UV]= uvs ; d[VisualServer::ARRAY_VERTEX]= vertices ; PoolVector<int> indices; indices.resize(vertices.size()); for(int i=0;i<vertices.size();i++) indices.set(i,i); d[VisualServer::ARRAY_INDEX]=indices; box_mesh->add_surface(Mesh::PRIMITIVE_TRIANGLES,d); box_instance->set_mesh(box_mesh); box_instance->hide(); } set_custom_minimum_size(Size2(1,150)*EDSCALE); HBoxContainer *hb = memnew( HBoxContainer ); add_child(hb); hb->set_area_as_parent_rect(2); VBoxContainer *vb_shape = memnew( VBoxContainer ); hb->add_child(vb_shape); sphere_switch = memnew( TextureButton ); sphere_switch->set_toggle_mode(true); sphere_switch->set_pressed(true); vb_shape->add_child(sphere_switch); sphere_switch->connect("pressed",this,"_button_pressed",varray(sphere_switch)); box_switch = memnew( TextureButton ); box_switch->set_toggle_mode(true); box_switch->set_pressed(false); vb_shape->add_child(box_switch); box_switch->connect("pressed",this,"_button_pressed",varray(box_switch)); hb->add_spacer(); VBoxContainer *vb_light = memnew( VBoxContainer ); hb->add_child(vb_light); light_1_switch = memnew( TextureButton ); light_1_switch->set_toggle_mode(true); vb_light->add_child(light_1_switch); light_1_switch->connect("pressed",this,"_button_pressed",varray(light_1_switch)); light_2_switch = memnew( TextureButton ); light_2_switch->set_toggle_mode(true); vb_light->add_child(light_2_switch); light_2_switch->connect("pressed",this,"_button_pressed",varray(light_2_switch)); first_enter=true; }
SoundDriverDialog::SoundDriverDialog(Window *p_parent,ConfigApi *p_config) : Window(p_parent,MODE_POPUP,SIZE_CENTER) { config=p_config; WindowBox *vb = new WindowBox("Sound Driver"); set_root_frame( vb ); MarginGroup *mg = vb->add( new MarginGroup("Selected Driver:")); sound_driver=mg->add(new ComboBox); sound_driver->selected_signal.connect( this, &SoundDriverDialog::sound_driver_changed ); HBoxContainer *hbc = mg->add( new HBoxContainer ); hbc->add( new Button("Disable"),1)->pressed_signal.connect(this,&SoundDriverDialog::disable); hbc->add( new Button("Reset"),1)->pressed_signal.connect(this,&SoundDriverDialog::restart); vb->add(new HSeparator); mg = vb->add( new MarginGroup("Mixing Frequency:")); mix_freq=mg->add(new ComboBox); mix_freq->add_string("4096"); mix_freq->add_string("8192"); mix_freq->add_string("11025"); mix_freq->add_string("22050"); mix_freq->add_string("44100"); mix_freq->add_string("48000"); mix_freq->add_string("96000"); mix_freq->add_string("192000"); mix_freq->selected_signal.connect( this, &SoundDriverDialog::parameter_changed_i ); mg = vb->add( new MarginGroup("Format:")); bits=mg->add(new ComboBox); bits->add_string( "8 Bits" ); bits->add_string( "16 Bits" ); bits->add_string( "24/32 Bits" ); bits->selected_signal.connect( this, &SoundDriverDialog::parameter_changed_i ); stereo=mg->add(new CheckButton("Stereo")); stereo->pressed_signal.connect(this, &SoundDriverDialog::parameter_changed ); mg = vb->add( new MarginGroup("Buffer Size (frames):")); buffsize=mg->add(new ComboBox); buffsize->add_string("128"); buffsize->add_string("256"); buffsize->add_string("512"); buffsize->add_string("1024"); buffsize->add_string("2048"); buffsize->add_string("4096"); buffsize->add_string("8192"); buffsize->add_string("16384"); buffsize->add_string("32768"); buffsize->selected_signal.connect( this, &SoundDriverDialog::parameter_changed_i ); mg = vb->add( new MarginGroup("Status:")); status=mg->add(new LineEdit("Active")); status->set_editable( false ); updating=false; updating_parameters=false; config->write_entry_signal.connect( this, &SoundDriverDialog::save_slot ); config->read_entry_signal.connect( this, &SoundDriverDialog::read_slot ); config->read_finished_signal.connect( this, &SoundDriverDialog::read_finished ); config_must_enable_driver=false; config_driver=-1; }
ColorPicker::ColorPicker() { //edit_alpha=false; updating=true; edit_alpha=true; VBoxContainer *vbl = memnew( VBoxContainer ); add_child(vbl); mode_box = memnew( OptionButton ); mode_box->add_item("RGB"); mode_box->add_item("HSV"); mode_box->add_item("RAW"); mode_box->connect("item_selected",this,"set_mode"); color_box=memnew( Control ); color_box->set_v_size_flags(SIZE_EXPAND_FILL); vbl->add_child(color_box); color_box->connect("draw",this,"_color_box_draw"); vbl->add_child(mode_box); VBoxContainer *vbr = memnew( VBoxContainer ); add_child(vbr); vbr->set_h_size_flags(SIZE_EXPAND_FILL); for(int i=0;i<4;i++) { HBoxContainer *hbc = memnew( HBoxContainer ); labels[i]=memnew( Label ); hbc->add_child(labels[i]); scroll[i]=memnew( HSlider ); hbc->add_child(scroll[i]); values[i]=memnew( SpinBox ); scroll[i]->share(values[i]); hbc->add_child(values[i]); scroll[i]->set_min(0); scroll[i]->set_page(0); scroll[i]->set_h_size_flags(SIZE_EXPAND_FILL); scroll[i]->connect("value_changed",this,"_value_changed"); vbr->add_child(hbc); } HBoxContainer *hhb = memnew( HBoxContainer ); vbr->add_child(hhb); html_num = memnew( Label ); hhb->add_child(html_num); html = memnew( LineEdit ); hhb->add_child(html); html->connect("text_entered",this,"_html_entered"); html_num->set_text("#"); html->set_h_size_flags(SIZE_EXPAND_FILL); mode=MODE_RGB; _update_controls(); _update_color(); updating=false; }