maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Remove ToolButton in favor of Button

Browse source 
ToolButton has no redeeming differences with Button;
it's just a Button with the Flat property enabled by default.
Removing it avoids some confusion when creating GUIs.

Existing ToolButtons will be converted to Buttons, but the Flat
property won't be enabled automatically.

This closes https://github.com/godotengine/godot-proposals/issues/1081.
This commit is contained in:
Hugo Locurcio 2020-06-19 20:49:04 +02:00
parent cb9d02a8d1
commit 31b7f02a29
No known key found for this signature in database
GPG key ID: 39E8F8BE30B0A49C
103 changed files with 616 additions and 590 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
doc/classes/EditorPlugin.xml
View file

@ -22,7 +22,7 @@
</description>
</method>
<method name="add_control_to_bottom_panel">
<return type="ToolButton">
<return type="Button">
</return>
<argument index="0" name="control" type="Control">
</argument>

57
doc/classes/ToolButton.xml
View file

@ -1,57 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="ToolButton" inherits="Button" version="4.0">
<brief_description>
Flat button helper class.
</brief_description>
<description>
This is a helper class to generate a flat [Button] (see [member Button.flat]), creating a [ToolButton] is equivalent to:
[codeblock]
var btn = Button.new()
btn.flat = true
[/codeblock]
</description>
<tutorials>
</tutorials>
<methods>
</methods>
<members>
<member name="flat" type="bool" setter="set_flat" getter="is_flat" override="true" default="true" />
</members>
<constants>
</constants>
<theme_items>
<theme_item name="disabled" type="StyleBox">
[StyleBox] used when the [ToolButton] is disabled.
</theme_item>
<theme_item name="focus" type="StyleBox">
[StyleBox] used when the [ToolButton] is focused. It is displayed over the current [StyleBox], so using [StyleBoxEmpty] will just disable the focus visual effect.
</theme_item>
<theme_item name="font" type="Font">
[Font] of the [ToolButton]'s text.
</theme_item>
<theme_item name="font_color" type="Color" default="Color( 0.88, 0.88, 0.88, 1 )">
Default text [Color] of the [ToolButton].
</theme_item>
<theme_item name="font_color_disabled" type="Color" default="Color( 0.9, 0.95, 1, 0.3 )">
Text [Color] used when the [ToolButton] is disabled.
</theme_item>
<theme_item name="font_color_hover" type="Color" default="Color( 0.94, 0.94, 0.94, 1 )">
Text [Color] used when the [ToolButton] is being hovered.
</theme_item>
<theme_item name="font_color_pressed" type="Color" default="Color( 1, 1, 1, 1 )">
Text [Color] used when the [ToolButton] is being pressed.
</theme_item>
<theme_item name="hover" type="StyleBox">
[StyleBox] used when the [ToolButton] is being hovered.
</theme_item>
<theme_item name="hseparation" type="int" default="3">
The horizontal space between [ToolButton]'s icon and text.
</theme_item>
<theme_item name="normal" type="StyleBox">
Default [StyleBox] for the [ToolButton].
</theme_item>
<theme_item name="pressed" type="StyleBox">
[StyleBox] used when the [ToolButton] is being pressed.
</theme_item>
</theme_items>
</class>

15
editor/animation_track_editor.cpp
View file

@ -1783,7 +1783,8 @@ AnimationTimelineEdit::AnimationTimelineEdit() {
length->set_tooltip(TTR("Animation length (seconds)"));
length->connect("value_changed", callable_mp(this, &AnimationTimelineEdit::_anim_length_changed));
len_hb->add_child(length);
loop = memnew(ToolButton);
loop = memnew(Button);
loop->set_flat(true);
loop->set_tooltip(TTR("Animation Looping"));
loop->connect("pressed", callable_mp(this, &AnimationTimelineEdit::_anim_loop_pressed));
loop->set_toggle_mode(true);
@ -2786,7 +2787,8 @@ Variant AnimationTrackEdit::get_drag_data(const Point2 &p_point) {
drag_data["group"] = base_path;
drag_data["index"] = track;
ToolButton *tb = memnew(ToolButton);
Button *tb = memnew(Button);
tb->set_flat(true);
tb->set_text(path_cache);
tb->set_icon(icon_cache);
set_drag_preview(tb);
@ -5640,14 +5642,16 @@ AnimationTrackEditor::AnimationTrackEditor() {
bottom_hb->add_spacer();
selected_filter = memnew(ToolButton);
selected_filter = memnew(Button);
selected_filter->set_flat(true);
selected_filter->connect("pressed", callable_mp(this, &AnimationTrackEditor::_view_group_toggle)); //same function works the same
selected_filter->set_toggle_mode(true);
selected_filter->set_tooltip(TTR("Only show tracks from nodes selected in tree."));
bottom_hb->add_child(selected_filter);
view_group = memnew(ToolButton);
view_group = memnew(Button);
view_group->set_flat(true);
view_group->connect("pressed", callable_mp(this, &AnimationTrackEditor::_view_group_toggle));
view_group->set_toggle_mode(true);
view_group->set_tooltip(TTR("Group tracks by node or display them as plain list."));
@ -5655,7 +5659,8 @@ AnimationTrackEditor::AnimationTrackEditor() {
bottom_hb->add_child(view_group);
bottom_hb->add_child(memnew(VSeparator));
snap = memnew(ToolButton);
snap = memnew(Button);
snap->set_flat(true);
snap->set_text(TTR("Snap:") + " ");
bottom_hb->add_child(snap);
snap->set_disabled(true);

9
editor/animation_track_editor.h
View file

@ -44,7 +44,6 @@
#include "scene/gui/spin_box.h"
#include "scene/gui/tab_container.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tool_button.h"
#include "scene/resources/animation.h"
#include "scene_tree_editor.h"
@ -59,7 +58,7 @@ class AnimationTimelineEdit : public Range {
HBoxContainer *len_hb;
EditorSpinSlider *length;
ToolButton *loop;
Button *loop;
TextureRect *time_icon;
MenuButton *add_track;
@ -310,7 +309,7 @@ class AnimationTrackEditor : public VBoxContainer {
HSlider *zoom;
EditorSpinSlider *step;
TextureRect *zoom_icon;
ToolButton *snap;
Button *snap;
OptionButton *snap_mode;
Button *imported_anim_warning;
@ -457,8 +456,8 @@ class AnimationTrackEditor : public VBoxContainer {
void _anim_duplicate_keys(bool transpose);
void _view_group_toggle();
ToolButton *view_group;
ToolButton *selected_filter;
Button *view_group;
Button *selected_filter;
void _selection_changed();

12
editor/code_editor.cpp
View file

@ -628,12 +628,14 @@ FindReplaceBar::FindReplaceBar() {
hbc_button_search->add_child(matches_label);
matches_label->hide();
find_prev = memnew(ToolButton);
find_prev = memnew(Button);
find_prev->set_flat(true);
hbc_button_search->add_child(find_prev);
find_prev->set_focus_mode(FOCUS_NONE);
find_prev->connect("pressed", callable_mp(this, &FindReplaceBar::search_prev));
find_next = memnew(ToolButton);
find_next = memnew(Button);
find_next->set_flat(true);
hbc_button_search->add_child(find_next);
find_next->set_focus_mode(FOCUS_NONE);
find_next->connect("pressed", callable_mp(this, &FindReplaceBar::search_next));
@ -1706,7 +1708,8 @@ CodeTextEditor::CodeTextEditor() {
error_line = 0;
error_column = 0;
toggle_scripts_button = memnew(ToolButton);
toggle_scripts_button = memnew(Button);
toggle_scripts_button->set_flat(true);
toggle_scripts_button->connect("pressed", callable_mp(this, &CodeTextEditor::_toggle_scripts_pressed));
status_bar->add_child(toggle_scripts_button);
toggle_scripts_button->hide();
@ -1726,7 +1729,8 @@ CodeTextEditor::CodeTextEditor() {
find_replace_bar->connect("error", callable_mp(error, &Label::set_text));
// Warnings
warning_button = memnew(ToolButton);
warning_button = memnew(Button);
warning_button->set_flat(true);
status_bar->add_child(warning_button);
warning_button->set_v_size_flags(SIZE_EXPAND | SIZE_SHRINK_CENTER);
warning_button->set_default_cursor_shape(CURSOR_POINTING_HAND);

9
editor/code_editor.h
View file

@ -37,7 +37,6 @@
#include "scene/gui/dialogs.h"
#include "scene/gui/line_edit.h"
#include "scene/gui/text_edit.h"
#include "scene/gui/tool_button.h"
#include "scene/main/timer.h"
class GotoLineDialog : public ConfirmationDialog {
@ -63,8 +62,8 @@ class FindReplaceBar : public HBoxContainer {
LineEdit *search_text;
Label *matches_label;
ToolButton *find_prev;
ToolButton *find_next;
Button *find_prev;
Button *find_next;
CheckBox *case_sensitive;
CheckBox *whole_words;
TextureButton *hide_button;
@ -142,8 +141,8 @@ class CodeTextEditor : public VBoxContainer {
FindReplaceBar *find_replace_bar;
HBoxContainer *status_bar;
ToolButton *toggle_scripts_button;
ToolButton *warning_button;
Button *toggle_scripts_button;
Button *warning_button;
Label *warning_count_label;
Label *line_and_col_txt;

3
editor/create_dialog.cpp
View file

@ -673,7 +673,8 @@ Variant CreateDialog::get_drag_data_fw(const Point2 &p_point, Control *p_from) {
d["type"] = "create_favorite_drag";
d["class"] = ti->get_text(0);
ToolButton *tb = memnew(ToolButton);
Button *tb = memnew(Button);
tb->set_flat(true);
tb->set_icon(ti->get_icon(0));
tb->set_text(ti->get_text(0));
favorites->set_drag_preview(tb);

24
editor/debugger/script_editor_debugger.cpp
View file

@ -1517,27 +1517,31 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) {
hbc->add_child(memnew(VSeparator));
skip_breakpoints = memnew(ToolButton);
skip_breakpoints = memnew(Button);
skip_breakpoints->set_flat(true);
hbc->add_child(skip_breakpoints);
skip_breakpoints->set_tooltip(TTR("Skip Breakpoints"));
skip_breakpoints->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_skip_breakpoints));
hbc->add_child(memnew(VSeparator));
copy = memnew(ToolButton);
copy = memnew(Button);
copy->set_flat(true);
hbc->add_child(copy);
copy->set_tooltip(TTR("Copy Error"));
copy->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_copy));
hbc->add_child(memnew(VSeparator));
step = memnew(ToolButton);
step = memnew(Button);
step->set_flat(true);
hbc->add_child(step);
step->set_tooltip(TTR("Step Into"));
step->set_shortcut(ED_GET_SHORTCUT("debugger/step_into"));
step->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_step));
next = memnew(ToolButton);
next = memnew(Button);
next->set_flat(true);
hbc->add_child(next);
next->set_tooltip(TTR("Step Over"));
next->set_shortcut(ED_GET_SHORTCUT("debugger/step_over"));
@ -1545,13 +1549,15 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) {
hbc->add_child(memnew(VSeparator));
dobreak = memnew(ToolButton);
dobreak = memnew(Button);
dobreak->set_flat(true);
hbc->add_child(dobreak);
dobreak->set_tooltip(TTR("Break"));
dobreak->set_shortcut(ED_GET_SHORTCUT("debugger/break"));
dobreak->connect("pressed", callable_mp(this, &ScriptEditorDebugger::debug_break));
docontinue = memnew(ToolButton);
docontinue = memnew(Button);
docontinue->set_flat(true);
hbc->add_child(docontinue);
docontinue->set_tooltip(TTR("Continue"));
docontinue->set_shortcut(ED_GET_SHORTCUT("debugger/continue"));
@ -1730,9 +1736,11 @@ ScriptEditorDebugger::ScriptEditorDebugger(EditorNode *p_editor) {
vmem_total->set_editable(false);
vmem_total->set_custom_minimum_size(Size2(100, 0) * EDSCALE);
vmem_hb->add_child(vmem_total);
vmem_refresh = memnew(ToolButton);
vmem_refresh = memnew(Button);
vmem_refresh->set_flat(true);
vmem_hb->add_child(vmem_refresh);
vmem_export = memnew(ToolButton);
vmem_export = memnew(Button);
vmem_export->set_flat(true);
vmem_export->set_tooltip(TTR("Export list to a CSV file"));
vmem_hb->add_child(vmem_export);
vmem_vb->add_child(vmem_hb);

9
editor/editor_audio_buses.cpp
View file

@ -782,19 +782,22 @@ EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) {
HBoxContainer *hbc = memnew(HBoxContainer);
vb->add_child(hbc);
solo = memnew(ToolButton);
solo = memnew(Button);
solo->set_flat(true);
solo->set_toggle_mode(true);
solo->set_tooltip(TTR("Solo"));
solo->set_focus_mode(FOCUS_NONE);
solo->connect("pressed", callable_mp(this, &EditorAudioBus::_solo_toggled));
hbc->add_child(solo);
mute = memnew(ToolButton);
mute = memnew(Button);
mute->set_flat(true);
mute->set_toggle_mode(true);
mute->set_tooltip(TTR("Mute"));
mute->set_focus_mode(FOCUS_NONE);
mute->connect("pressed", callable_mp(this, &EditorAudioBus::_mute_toggled));
hbc->add_child(mute);
bypass = memnew(ToolButton);
bypass = memnew(Button);
bypass->set_flat(true);
bypass->set_toggle_mode(true);
bypass->set_tooltip(TTR("Bypass"));
bypass->set_focus_mode(FOCUS_NONE);

1
editor/editor_audio_buses.h
View file

@ -45,7 +45,6 @@
#include "scene/gui/slider.h"
#include "scene/gui/texture_progress.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tool_button.h"
#include "scene/gui/tree.h"
class EditorAudioBuses;

30
editor/editor_file_dialog.cpp
View file

@ -1455,11 +1455,14 @@ EditorFileDialog::EditorFileDialog() {
HBoxContainer *pathhb = memnew(HBoxContainer);
dir_prev = memnew(ToolButton);
dir_prev = memnew(Button);
dir_prev->set_flat(true);
dir_prev->set_tooltip(TTR("Go to previous folder."));
dir_next = memnew(ToolButton);
dir_next = memnew(Button);
dir_next->set_flat(true);
dir_next->set_tooltip(TTR("Go to next folder."));
dir_up = memnew(ToolButton);
dir_up = memnew(Button);
dir_up->set_flat(true);
dir_up->set_tooltip(TTR("Go to parent folder."));
pathhb->add_child(dir_prev);
@ -1479,18 +1482,21 @@ EditorFileDialog::EditorFileDialog() {
pathhb->add_child(dir);
dir->set_h_size_flags(Control::SIZE_EXPAND_FILL);
refresh = memnew(ToolButton);
refresh = memnew(Button);
refresh->set_flat(true);
refresh->set_tooltip(TTR("Refresh files."));
refresh->connect("pressed", callable_mp(this, &EditorFileDialog::update_file_list));
pathhb->add_child(refresh);
favorite = memnew(ToolButton);
favorite = memnew(Button);
favorite->set_flat(true);
favorite->set_toggle_mode(true);
favorite->set_tooltip(TTR("(Un)favorite current folder."));
favorite->connect("pressed", callable_mp(this, &EditorFileDialog::_favorite_pressed));
pathhb->add_child(favorite);
show_hidden = memnew(ToolButton);
show_hidden = memnew(Button);
show_hidden->set_flat(true);
show_hidden->set_toggle_mode(true);
show_hidden->set_pressed(is_showing_hidden_files());
show_hidden->set_tooltip(TTR("Toggle the visibility of hidden files."));
@ -1502,7 +1508,8 @@ EditorFileDialog::EditorFileDialog() {
Ref<ButtonGroup> view_mode_group;
view_mode_group.instance();
mode_thumbnails = memnew(ToolButton);
mode_thumbnails = memnew(Button);
mode_thumbnails->set_flat(true);
mode_thumbnails->connect("pressed", callable_mp(this, &EditorFileDialog::set_display_mode), varray(DISPLAY_THUMBNAILS));
mode_thumbnails->set_toggle_mode(true);
mode_thumbnails->set_pressed(display_mode == DISPLAY_THUMBNAILS);
@ -1510,7 +1517,8 @@ EditorFileDialog::EditorFileDialog() {
mode_thumbnails->set_tooltip(TTR("View items as a grid of thumbnails."));
pathhb->add_child(mode_thumbnails);
mode_list = memnew(ToolButton);
mode_list = memnew(Button);
mode_list->set_flat(true);
mode_list->connect("pressed", callable_mp(this, &EditorFileDialog::set_display_mode), varray(DISPLAY_LIST));
mode_list->set_toggle_mode(true);
mode_list->set_pressed(display_mode == DISPLAY_LIST);
@ -1547,10 +1555,12 @@ EditorFileDialog::EditorFileDialog() {
fav_vb->add_child(fav_hb);
fav_hb->add_child(memnew(Label(TTR("Favorites:"))));
fav_hb->add_spacer();
fav_up = memnew(ToolButton);
fav_up = memnew(Button);
fav_up->set_flat(true);
fav_hb->add_child(fav_up);
fav_up->connect("pressed", callable_mp(this, &EditorFileDialog::_favorite_move_up));
fav_down = memnew(ToolButton);
fav_down = memnew(Button);
fav_down->set_flat(true);
fav_hb->add_child(fav_down);
fav_down->connect("pressed", callable_mp(this, &EditorFileDialog::_favorite_move_down));

21
editor/editor_file_dialog.h
View file

@ -40,7 +40,6 @@
#include "scene/gui/separator.h"
#include "scene/gui/split_container.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tool_button.h"
class DependencyRemoveDialog;
@ -95,9 +94,9 @@ private:
bool can_create_dir;
LineEdit *dir;
ToolButton *dir_prev;
ToolButton *dir_next;
ToolButton *dir_up;
Button *dir_prev;
Button *dir_next;
Button *dir_up;
HBoxContainer *drives_container;
HBoxContainer *shortcuts_container;
@ -116,15 +115,15 @@ private:
ConfirmationDialog *confirm_save;
DependencyRemoveDialog *remove_dialog;
ToolButton *mode_thumbnails;
ToolButton *mode_list;
Button *mode_thumbnails;
Button *mode_list;
ToolButton *refresh;
ToolButton *favorite;
ToolButton *show_hidden;
Button *refresh;
Button *favorite;
Button *show_hidden;
ToolButton *fav_up;
ToolButton *fav_down;
Button *fav_up;
Button *fav_down;
ItemList *favorites;
ItemList *recent;

6
editor/editor_help.cpp
View file

@ -1664,12 +1664,14 @@ FindBar::FindBar() {
add_child(matches_label);
matches_label->hide();
find_prev = memnew(ToolButton);
find_prev = memnew(Button);
find_prev->set_flat(true);
add_child(find_prev);
find_prev->set_focus_mode(FOCUS_NONE);
find_prev->connect("pressed", callable_mp(this, &FindBar::search_prev));
find_next = memnew(ToolButton);
find_next = memnew(Button);
find_next->set_flat(true);
add_child(find_next);
find_next->set_focus_mode(FOCUS_NONE);
find_next->connect("pressed", callable_mp(this, &FindBar::search_next));

4
editor/editor_help.h
View file

@ -47,8 +47,8 @@ class FindBar : public HBoxContainer {
GDCLASS(FindBar, HBoxContainer);
LineEdit *search_text;
ToolButton *find_prev;
ToolButton *find_next;
Button *find_prev;
Button *find_next;
Label *matches_label;
TextureButton *hide_button;
String prev_search;

6
editor/editor_help_search.cpp
View file

@ -201,14 +201,16 @@ EditorHelpSearch::EditorHelpSearch() {
register_text_enter(search_box);
hbox->add_child(search_box);
case_sensitive_button = memnew(ToolButton);
case_sensitive_button = memnew(Button);
case_sensitive_button->set_flat(true);
case_sensitive_button->set_tooltip(TTR("Case Sensitive"));
case_sensitive_button->connect("pressed", callable_mp(this, &EditorHelpSearch::_update_results));
case_sensitive_button->set_toggle_mode(true);
case_sensitive_button->set_focus_mode(Control::FOCUS_NONE);
hbox->add_child(case_sensitive_button);
hierarchy_button = memnew(ToolButton);
hierarchy_button = memnew(Button);
hierarchy_button->set_flat(true);
hierarchy_button->set_tooltip(TTR("Show Hierarchy"));
hierarchy_button->connect("pressed", callable_mp(this, &EditorHelpSearch::_update_results));
hierarchy_button->set_toggle_mode(true);

4
editor/editor_help_search.h
View file

@ -54,8 +54,8 @@ class EditorHelpSearch : public ConfirmationDialog {
};
LineEdit *search_box;
ToolButton *case_sensitive_button;
ToolButton *hierarchy_button;
Button *case_sensitive_button;
Button *hierarchy_button;
OptionButton *filter_combo;
Tree *results_tree;
bool old_search;

2
editor/editor_log.cpp
View file

@ -124,7 +124,7 @@ void EditorLog::add_message(const String &p_msg, MessageType p_type) {
}
}
void EditorLog::set_tool_button(ToolButton *p_tool_button) {
void EditorLog::set_tool_button(Button *p_tool_button) {
tool_button = p_tool_button;
}

15
editor/editor_log.h
View file

@ -31,17 +31,16 @@
#ifndef EDITOR_LOG_H
#define EDITOR_LOG_H
#include "scene/gui/control.h"
#include "scene/gui/label.h"
#include "scene/gui/rich_text_label.h"
#include "scene/gui/texture_button.h"
//#include "scene/gui/empty_control.h"
#include "core/os/thread.h"
#include "pane_drag.h"
#include "scene/gui/box_container.h"
#include "scene/gui/button.h"
#include "scene/gui/control.h"
#include "scene/gui/label.h"
#include "scene/gui/panel_container.h"
#include "scene/gui/rich_text_label.h"
#include "scene/gui/texture_button.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tool_button.h"
class EditorLog : public VBoxContainer {
GDCLASS(EditorLog, VBoxContainer);
@ -52,7 +51,7 @@ class EditorLog : public VBoxContainer {
RichTextLabel *log;
HBoxContainer *title_hb;
//PaneDrag *pd;
ToolButton *tool_button;
Button *tool_button;
static void _error_handler(void *p_self, const char *p_func, const char *p_file, int p_line, const char *p_error, const char *p_errorexp, ErrorHandlerType p_type);
@ -78,7 +77,7 @@ public:
};
void add_message(const String &p_msg, MessageType p_type = MSG_TYPE_STD);
void set_tool_button(ToolButton *p_tool_button);
void set_tool_button(Button *p_tool_button);
void deinit();
void clear();

46
editor/editor_node.cpp
View file

@ -58,7 +58,6 @@
#include "scene/gui/tab_container.h"
#include "scene/gui/tabs.h"
#include "scene/gui/texture_progress.h"
#include "scene/gui/tool_button.h"
#include "scene/resources/packed_scene.h"
#include "servers/navigation_server_2d.h"
#include "servers/navigation_server_3d.h"
@ -485,7 +484,7 @@ void EditorNode::_notification(int p_what) {
// update_icons
for (int i = 0; i < singleton->main_editor_buttons.size(); i++) {
ToolButton *tb = singleton->main_editor_buttons[i];
Button *tb = singleton->main_editor_buttons[i];
EditorPlugin *p_editor = singleton->editor_table[i];
Ref<Texture2D> icon = p_editor->get_icon();
@ -2776,7 +2775,8 @@ void EditorNode::select_editor_by_name(const String &p_name) {
void EditorNode::add_editor_plugin(EditorPlugin *p_editor, bool p_config_changed) {
if (p_editor->has_main_screen()) {
ToolButton *tb = memnew(ToolButton);
Button *tb = memnew(Button);
tb->set_flat(true);
tb->set_toggle_mode(true);
tb->connect("pressed", callable_mp(singleton, &EditorNode::_editor_select), varray(singleton->main_editor_buttons.size()));
tb->set_text(p_editor->get_name());
@ -4621,8 +4621,9 @@ void EditorNode::_scene_tab_changed(int p_tab) {
editor_data.get_undo_redo().commit_action();
}
ToolButton *EditorNode::add_bottom_panel_item(String p_text, Control *p_item) {
ToolButton *tb = memnew(ToolButton);
Button *EditorNode::add_bottom_panel_item(String p_text, Control *p_item) {
Button *tb = memnew(Button);
tb->set_flat(true);
tb->connect("toggled", callable_mp(this, &EditorNode::_bottom_panel_switch), varray(bottom_panel_items.size()));
tb->set_text(p_text);
tb->set_toggle_mode(true);
@ -5698,7 +5699,8 @@ EditorNode::EditorNode() {
dock_select_popup->add_child(dock_vb);
HBoxContainer *dock_hb = memnew(HBoxContainer);
dock_tab_move_left = memnew(ToolButton);
dock_tab_move_left = memnew(Button);
dock_tab_move_left->set_flat(true);
dock_tab_move_left->set_icon(theme->get_icon("Back", "EditorIcons"));
dock_tab_move_left->set_focus_mode(Control::FOCUS_NONE);
dock_tab_move_left->connect("pressed", callable_mp(this, &EditorNode::_dock_move_left));
@ -5710,7 +5712,8 @@ EditorNode::EditorNode() {
dock_label->set_align(Label::ALIGN_CENTER);
dock_hb->add_child(dock_label);
dock_tab_move_right = memnew(ToolButton);
dock_tab_move_right = memnew(Button);
dock_tab_move_right->set_flat(true);
dock_tab_move_right->set_icon(theme->get_icon("Forward", "EditorIcons"));
dock_tab_move_right->set_focus_mode(Control::FOCUS_NONE);
dock_tab_move_right->connect("pressed", callable_mp(this, &EditorNode::_dock_move_right));
@ -5804,7 +5807,8 @@ EditorNode::EditorNode() {
srt->add_child(tabbar_container);
tabbar_container->add_child(scene_tabs);
distraction_free = memnew(ToolButton);
distraction_free = memnew(Button);
distraction_free->set_flat(true);
#ifdef OSX_ENABLED
distraction_free->set_shortcut(ED_SHORTCUT("editor/distraction_free_mode", TTR("Distraction Free Mode"), KEY_MASK_CMD | KEY_MASK_CTRL | KEY_D));
#else
@ -5815,7 +5819,8 @@ EditorNode::EditorNode() {
distraction_free->set_icon(gui_base->get_theme_icon("DistractionFree", "EditorIcons"));
distraction_free->set_toggle_mode(true);
scene_tab_add = memnew(ToolButton);
scene_tab_add = memnew(Button);
scene_tab_add->set_flat(true);
tabbar_container->add_child(scene_tab_add);
tabbar_container->add_child(distraction_free);
scene_tab_add->set_tooltip(TTR("Add a new scene."));
@ -5852,7 +5857,8 @@ EditorNode::EditorNode() {
file_menu->add_theme_style_override("hover", gui_base->get_theme_stylebox("MenuHover", "EditorStyles"));
left_menu_hb->add_child(file_menu);
prev_scene = memnew(ToolButton);
prev_scene = memnew(Button);
prev_scene->set_flat(true);
prev_scene->set_icon(gui_base->get_theme_icon("PrevScene", "EditorIcons"));
prev_scene->set_tooltip(TTR("Go to previously opened scene."));
prev_scene->set_disabled(true);
@ -6081,7 +6087,8 @@ EditorNode::EditorNode() {
HBoxContainer *play_hb = memnew(HBoxContainer);
menu_hb->add_child(play_hb);
play_button = memnew(ToolButton);
play_button = memnew(Button);
play_button->set_flat(true);
play_hb->add_child(play_button);
play_button->set_toggle_mode(true);
play_button->set_icon(gui_base->get_theme_icon("MainPlay", "EditorIcons"));
@ -6094,7 +6101,8 @@ EditorNode::EditorNode() {
play_button->set_shortcut(ED_SHORTCUT("editor/play", TTR("Play"), KEY_F5));
#endif
pause_button = memnew(ToolButton);
pause_button = memnew(Button);
pause_button->set_flat(true);
pause_button->set_toggle_mode(true);
pause_button->set_icon(gui_base->get_theme_icon("Pause", "EditorIcons"));
pause_button->set_focus_mode(Control::FOCUS_NONE);
@ -6107,7 +6115,8 @@ EditorNode::EditorNode() {
pause_button->set_shortcut(ED_SHORTCUT("editor/pause_scene", TTR("Pause Scene"), KEY_F7));
#endif
stop_button = memnew(ToolButton);
stop_button = memnew(Button);
stop_button->set_flat(true);
play_hb->add_child(stop_button);
stop_button->set_focus_mode(Control::FOCUS_NONE);
stop_button->set_icon(gui_base->get_theme_icon("Stop", "EditorIcons"));
@ -6124,7 +6133,8 @@ EditorNode::EditorNode() {
play_hb->add_child(run_native);
run_native->connect("native_run", callable_mp(this, &EditorNode::_run_native));
play_scene_button = memnew(ToolButton);
play_scene_button = memnew(Button);
play_scene_button->set_flat(true);
play_hb->add_child(play_scene_button);
play_scene_button->set_toggle_mode(true);
play_scene_button->set_focus_mode(Control::FOCUS_NONE);
@ -6137,7 +6147,8 @@ EditorNode::EditorNode() {
play_scene_button->set_shortcut(ED_SHORTCUT("editor/play_scene", TTR("Play Scene"), KEY_F6));
#endif
play_custom_scene_button = memnew(ToolButton);
play_custom_scene_button = memnew(Button);
play_custom_scene_button->set_flat(true);
play_hb->add_child(play_custom_scene_button);
play_custom_scene_button->set_toggle_mode(true);
play_custom_scene_button->set_focus_mode(Control::FOCUS_NONE);
@ -6298,7 +6309,8 @@ EditorNode::EditorNode() {
version_label->set_self_modulate(Color(1, 1, 1, 0.6));
bottom_panel_hb->add_child(version_label);
bottom_panel_raise = memnew(ToolButton);
bottom_panel_raise = memnew(Button);
bottom_panel_raise->set_flat(true);
bottom_panel_raise->set_icon(gui_base->get_theme_icon("ExpandBottomDock", "EditorIcons"));
bottom_panel_raise->set_shortcut(ED_SHORTCUT("editor/bottom_panel_expand", TTR("Expand Bottom Panel"), KEY_MASK_SHIFT | KEY_F12));
@ -6309,7 +6321,7 @@ EditorNode::EditorNode() {
bottom_panel_raise->connect("toggled", callable_mp(this, &EditorNode::_bottom_panel_raise_toggled));
log = memnew(EditorLog);
ToolButton *output_button = add_bottom_panel_item(TTR("Output"), log);
Button *output_button = add_bottom_panel_item(TTR("Output"), log);
log->set_tool_button(output_button);
old_split_ofs = 0;

38
editor/editor_node.h
View file

@ -83,7 +83,7 @@ class ScriptCreateDialog;
class TabContainer;
class Tabs;
class TextureProgress;
class ToolButton;
class Button;
class VSplitContainer;
class Window;
class SubViewport;
@ -265,15 +265,15 @@ private:
MenuButton *settings_menu;
MenuButton *help_menu;
PopupMenu *tool_menu;
ToolButton *export_button;
ToolButton *prev_scene;
ToolButton *play_button;
ToolButton *pause_button;
ToolButton *stop_button;
ToolButton *run_settings_button;
ToolButton *play_scene_button;
ToolButton *play_custom_scene_button;
ToolButton *search_button;
Button *export_button;
Button *prev_scene;
Button *play_button;
Button *pause_button;
Button *stop_button;
Button *run_settings_button;
Button *play_scene_button;
Button *play_custom_scene_button;
Button *search_button;
TextureProgress *audio_vu;
Timer *screenshot_timer;
@ -336,7 +336,7 @@ private:
EditorQuickOpen *quick_run;
HBoxContainer *main_editor_button_vb;
Vector<ToolButton *> main_editor_buttons;
Vector<Button *> main_editor_buttons;
Vector<EditorPlugin *> editor_table;
AudioStreamPreviewGenerator *preview_gen;
@ -358,15 +358,15 @@ private:
PopupPanel *dock_select_popup;
Control *dock_select;
Button *dock_float;
ToolButton *dock_tab_move_left;
ToolButton *dock_tab_move_right;
Button *dock_tab_move_left;
Button *dock_tab_move_right;
int dock_popup_selected;
Timer *dock_drag_timer;
bool docks_visible;
HBoxContainer *tabbar_container;
ToolButton *distraction_free;
ToolButton *scene_tab_add;
Button *distraction_free;
Button *scene_tab_add;
bool scene_distraction;
bool script_distraction;
@ -412,7 +412,7 @@ private:
struct BottomPanelItem {
String name;
Control *control;
ToolButton *button;
Button *button;
};
Vector<BottomPanelItem> bottom_panel_items;
@ -422,7 +422,7 @@ private:
HBoxContainer *bottom_panel_hb_editors;
VBoxContainer *bottom_panel_vb;
Label *version_label;
ToolButton *bottom_panel_raise;
Button *bottom_panel_raise;
void _bottom_panel_raise_toggled(bool);
@ -821,9 +821,9 @@ public:
bool is_exiting() const { return exiting; }
ToolButton *get_pause_button() { return pause_button; }
Button *get_pause_button() { return pause_button; }
ToolButton *add_bottom_panel_item(String p_text, Control *p_item);
Button *add_bottom_panel_item(String p_text, Control *p_item);
bool are_bottom_panels_hidden() const;
void make_bottom_panel_item_visible(Control *p_item);
void raise_bottom_panel_item(Control *p_item);

2
editor/editor_plugin.cpp
View file

@ -332,7 +332,7 @@ void EditorPlugin::remove_autoload_singleton(const String &p_name) {
EditorNode::get_singleton()->get_project_settings()->get_autoload_settings()->autoload_remove(p_name);
}
ToolButton *EditorPlugin::add_control_to_bottom_panel(Control *p_control, const String &p_title) {
Button *EditorPlugin::add_control_to_bottom_panel(Control *p_control, const String &p_title) {
ERR_FAIL_NULL_V(p_control, nullptr);
return EditorNode::get_singleton()->add_bottom_panel_item(p_title, p_control);
}

3
editor/editor_plugin.h
View file

@ -37,7 +37,6 @@
#include "editor/import/editor_import_plugin.h"
#include "editor/import/resource_importer_scene.h"
#include "editor/script_create_dialog.h"
#include "scene/gui/tool_button.h"
#include "scene/main/node.h"
#include "scene/resources/texture.h"
@ -161,7 +160,7 @@ public:
void add_control_to_container(CustomControlContainer p_location, Control *p_control);
void remove_control_from_container(CustomControlContainer p_location, Control *p_control);
ToolButton *add_control_to_bottom_panel(Control *p_control, const String &p_title);
Button *add_control_to_bottom_panel(Control *p_control, const String &p_title);
void add_control_to_dock(DockSlot p_slot, Control *p_control);
void remove_control_from_docks(Control *p_control);
void remove_control_from_bottom_panel(Control *p_control);

3
editor/editor_properties.cpp
View file

@ -164,7 +164,8 @@ EditorPropertyMultilineText::EditorPropertyMultilineText() {
add_focusable(text);
hb->add_child(text);
text->set_h_size_flags(SIZE_EXPAND_FILL);
open_big_text = memnew(ToolButton);
open_big_text = memnew(Button);
open_big_text->set_flat(true);
open_big_text->connect("pressed", callable_mp(this, &EditorPropertyMultilineText::_open_big_text));
hb->add_child(open_big_text);
big_text_dialog = nullptr;

16
editor/editor_themes.cpp
View file

@ -570,17 +570,17 @@ Ref<Theme> create_editor_theme(const Ref<Theme> p_theme) {
theme->set_stylebox("focus", "PopupMenu", style_menu);
theme->set_stylebox("disabled", "PopupMenu", style_menu);
theme->set_stylebox("normal", "ToolButton", style_menu);
theme->set_stylebox("hover", "ToolButton", style_menu);
theme->set_stylebox("pressed", "ToolButton", style_menu);
theme->set_stylebox("focus", "ToolButton", style_menu);
theme->set_stylebox("disabled", "ToolButton", style_menu);
theme->set_stylebox("normal", "Button", style_menu);
theme->set_stylebox("hover", "Button", style_menu);
theme->set_stylebox("pressed", "Button", style_menu);
theme->set_stylebox("focus", "Button", style_menu);
theme->set_stylebox("disabled", "Button", style_menu);
theme->set_color("font_color", "MenuButton", font_color);
theme->set_color("font_color_hover", "MenuButton", font_color_hl);
theme->set_color("font_color", "ToolButton", font_color);
theme->set_color("font_color_hover", "ToolButton", font_color_hl);
theme->set_color("font_color_pressed", "ToolButton", accent_color);
theme->set_color("font_color", "Button", font_color);
theme->set_color("font_color_hover", "Button", font_color_hl);
theme->set_color("font_color_pressed", "Button", accent_color);
theme->set_stylebox("MenuHover", "EditorStyles", style_menu_hover_border);

9
editor/filesystem_dock.cpp
View file

@ -2543,13 +2543,15 @@ FileSystemDock::FileSystemDock(EditorNode *p_editor) {
toolbar_hbc->add_theme_constant_override("separation", 0);
top_vbc->add_child(toolbar_hbc);
button_hist_prev = memnew(ToolButton);
button_hist_prev = memnew(Button);
button_hist_prev->set_flat(true);
button_hist_prev->set_disabled(true);
button_hist_prev->set_focus_mode(FOCUS_NONE);
button_hist_prev->set_tooltip(TTR("Previous Folder/File"));
toolbar_hbc->add_child(button_hist_prev);
button_hist_next = memnew(ToolButton);
button_hist_next = memnew(Button);
button_hist_next->set_flat(true);
button_hist_next->set_disabled(true);
button_hist_next->set_focus_mode(FOCUS_NONE);
button_hist_next->set_tooltip(TTR("Next Folder/File"));
@ -2627,7 +2629,8 @@ FileSystemDock::FileSystemDock(EditorNode *p_editor) {
file_list_search_box->connect("text_changed", callable_mp(this, &FileSystemDock::_search_changed), varray(file_list_search_box));
path_hb->add_child(file_list_search_box);
button_file_list_display_mode = memnew(ToolButton);
button_file_list_display_mode = memnew(Button);
button_file_list_display_mode->set_flat(true);
path_hb->add_child(button_file_list_display_mode);
files = memnew(ItemList);

1
editor/filesystem_dock.h
View file

@ -40,7 +40,6 @@
#include "scene/gui/option_button.h"
#include "scene/gui/progress_bar.h"
#include "scene/gui/split_container.h"
#include "scene/gui/tool_button.h"
#include "scene/gui/tree.h"
#include "scene/main/timer.h"

6
editor/groups_editor.cpp
View file

@ -477,7 +477,8 @@ GroupDialog::GroupDialog() {
vbc_buttons->set_h_size_flags(Control::SIZE_SHRINK_CENTER);
vbc_buttons->set_v_size_flags(Control::SIZE_SHRINK_CENTER);
add_button = memnew(ToolButton);
add_button = memnew(Button);
add_button->set_flat(true);
add_button->set_text(TTR("Add"));
add_button->connect("pressed", callable_mp(this, &GroupDialog::_add_pressed));
@ -486,7 +487,8 @@ GroupDialog::GroupDialog() {
vbc_buttons->add_spacer();
vbc_buttons->add_spacer();
remove_button = memnew(ToolButton);
remove_button = memnew(Button);
remove_button->set_flat(true);
remove_button->set_text(TTR("Remove"));
remove_button->connect("pressed", callable_mp(this, &GroupDialog::_removed_pressed));

5
editor/groups_editor.h
View file

@ -38,7 +38,6 @@
#include "scene/gui/item_list.h"
#include "scene/gui/line_edit.h"
#include "scene/gui/popup.h"
#include "scene/gui/tool_button.h"
#include "scene/gui/tree.h"
class GroupDialog : public AcceptDialog {
@ -63,8 +62,8 @@ class GroupDialog : public AcceptDialog {
Label *group_empty;
ToolButton *add_button;
ToolButton *remove_button;
Button *add_button;
Button *remove_button;
String selected_group;

12
editor/inspector_dock.cpp
View file

@ -493,14 +493,16 @@ InspectorDock::InspectorDock(EditorNode *p_editor, EditorData &p_editor_data) {
HBoxContainer *general_options_hb = memnew(HBoxContainer);
add_child(general_options_hb);
resource_new_button = memnew(ToolButton);
resource_new_button = memnew(Button);
resource_new_button->set_flat(true);
resource_new_button->set_tooltip(TTR("Create a new resource in memory and edit it."));
resource_new_button->set_icon(get_theme_icon("New", "EditorIcons"));
general_options_hb->add_child(resource_new_button);
resource_new_button->connect("pressed", callable_mp(this, &InspectorDock::_new_resource));
resource_new_button->set_focus_mode(Control::FOCUS_NONE);
resource_load_button = memnew(ToolButton);
resource_load_button = memnew(Button);
resource_load_button->set_flat(true);
resource_load_button->set_tooltip(TTR("Load an existing resource from disk and edit it."));
resource_load_button->set_icon(get_theme_icon("Load", "EditorIcons"));
general_options_hb->add_child(resource_load_button);
@ -519,7 +521,8 @@ InspectorDock::InspectorDock(EditorNode *p_editor, EditorData &p_editor_data) {
general_options_hb->add_spacer();
backward_button = memnew(ToolButton);
backward_button = memnew(Button);
backward_button->set_flat(true);
general_options_hb->add_child(backward_button);
backward_button->set_icon(get_theme_icon("Back", "EditorIcons"));
backward_button->set_flat(true);
@ -527,7 +530,8 @@ InspectorDock::InspectorDock(EditorNode *p_editor, EditorData &p_editor_data) {
backward_button->set_disabled(true);
backward_button->connect("pressed", callable_mp(this, &InspectorDock::_edit_back));
forward_button = memnew(ToolButton);
forward_button = memnew(Button);
forward_button->set_flat(true);
general_options_hb->add_child(forward_button);
forward_button->set_icon(get_theme_icon("Forward", "EditorIcons"));
forward_button->set_flat(true);

9
editor/inspector_dock.h
View file

@ -42,7 +42,6 @@
#include "scene/gui/control.h"
#include "scene/gui/label.h"
#include "scene/gui/popup_menu.h"
#include "scene/gui/tool_button.h"
class EditorNode;
@ -74,13 +73,13 @@ class InspectorDock : public VBoxContainer {
Object *current;
ToolButton *backward_button;
ToolButton *forward_button;
Button *backward_button;
Button *forward_button;
EditorFileDialog *load_resource_dialog;
CreateDialog *new_resource_dialog;
ToolButton *resource_new_button;
ToolButton *resource_load_button;
Button *resource_new_button;
Button *resource_load_button;
MenuButton *resource_save_button;
MenuButton *history_menu;
LineEdit *search;

6
editor/node_dock.cpp
View file

@ -92,7 +92,8 @@ NodeDock::NodeDock() {
add_child(mode_hb);
mode_hb->hide();
connections_button = memnew(ToolButton);
connections_button = memnew(Button);
connections_button->set_flat(true);
connections_button->set_text(TTR("Signals"));
connections_button->set_toggle_mode(true);
connections_button->set_pressed(true);
@ -101,7 +102,8 @@ NodeDock::NodeDock() {
mode_hb->add_child(connections_button);
connections_button->connect("pressed", callable_mp(this, &NodeDock::show_connections));
groups_button = memnew(ToolButton);
groups_button = memnew(Button);
groups_button->set_flat(true);
groups_button->set_text(TTR("Groups"));
groups_button->set_toggle_mode(true);
groups_button->set_pressed(false);

4
editor/node_dock.h
View file

@ -37,8 +37,8 @@
class NodeDock : public VBoxContainer {
GDCLASS(NodeDock, VBoxContainer);
ToolButton *connections_button;
ToolButton *groups_button;
Button *connections_button;
Button *groups_button;
ConnectionsDock *connections;
GroupsEditor *groups;

9
editor/plugins/abstract_polygon_2d_editor.cpp
View file

@ -703,17 +703,20 @@ AbstractPolygon2DEditor::AbstractPolygon2DEditor(EditorNode *p_editor, bool p_wi
edge_point = PosVertex();
add_child(memnew(VSeparator));
button_create = memnew(ToolButton);
button_create = memnew(Button);
button_create->set_flat(true);
add_child(button_create);
button_create->connect("pressed", callable_mp(this, &AbstractPolygon2DEditor::_menu_option), varray(MODE_CREATE));
button_create->set_toggle_mode(true);
button_edit = memnew(ToolButton);
button_edit = memnew(Button);
button_edit->set_flat(true);
add_child(button_edit);
button_edit->connect("pressed", callable_mp(this, &AbstractPolygon2DEditor::_menu_option), varray(MODE_EDIT));
button_edit->set_toggle_mode(true);
button_delete = memnew(ToolButton);
button_delete = memnew(Button);
button_delete->set_flat(true);
add_child(button_delete);
button_delete->connect("pressed", callable_mp(this, &AbstractPolygon2DEditor::_menu_option), varray(MODE_DELETE));
button_delete->set_toggle_mode(true);

7
editor/plugins/abstract_polygon_2d_editor.h
View file

@ -34,16 +34,15 @@
#include "editor/editor_node.h"
#include "editor/editor_plugin.h"
#include "scene/2d/polygon_2d.h"
#include "scene/gui/tool_button.h"
class CanvasItemEditor;
class AbstractPolygon2DEditor : public HBoxContainer {
GDCLASS(AbstractPolygon2DEditor, HBoxContainer);
ToolButton *button_create;
ToolButton *button_edit;
ToolButton *button_delete;
Button *button_create;
Button *button_edit;
Button *button_delete;
struct Vertex {
Vertex() {}

15
editor/plugins/animation_blend_space_1d_editor.cpp
View file

@ -595,7 +595,8 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() {
Ref<ButtonGroup> bg;
bg.instance();
tool_blend = memnew(ToolButton);
tool_blend = memnew(Button);
tool_blend->set_flat(true);
tool_blend->set_toggle_mode(true);
tool_blend->set_button_group(bg);
top_hb->add_child(tool_blend);
@ -603,14 +604,16 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() {
tool_blend->set_tooltip(TTR("Set the blending position within the space"));
tool_blend->connect("pressed", callable_mp(this, &AnimationNodeBlendSpace1DEditor::_tool_switch), varray(3));
tool_select = memnew(ToolButton);
tool_select = memnew(Button);
tool_select->set_flat(true);
tool_select->set_toggle_mode(true);
tool_select->set_button_group(bg);
top_hb->add_child(tool_select);
tool_select->set_tooltip(TTR("Select and move points, create points with RMB."));
tool_select->connect("pressed", callable_mp(this, &AnimationNodeBlendSpace1DEditor::_tool_switch), varray(0));
tool_create = memnew(ToolButton);
tool_create = memnew(Button);
tool_create->set_flat(true);
tool_create->set_toggle_mode(true);
tool_create->set_button_group(bg);
top_hb->add_child(tool_create);
@ -619,14 +622,16 @@ AnimationNodeBlendSpace1DEditor::AnimationNodeBlendSpace1DEditor() {
tool_erase_sep = memnew(VSeparator);
top_hb->add_child(tool_erase_sep);
tool_erase = memnew(ToolButton);
tool_erase = memnew(Button);
tool_erase->set_flat(true);
top_hb->add_child(tool_erase);
tool_erase->set_tooltip(TTR("Erase points."));
tool_erase->connect("pressed", callable_mp(this, &AnimationNodeBlendSpace1DEditor::_erase_selected));
top_hb->add_child(memnew(VSeparator));
snap = memnew(ToolButton);
snap = memnew(Button);
snap->set_flat(true);
snap->set_toggle_mode(true);
top_hb->add_child(snap);
snap->set_pressed(true);

12
editor/plugins/animation_blend_space_1d_editor.h
View file

@ -47,15 +47,15 @@ class AnimationNodeBlendSpace1DEditor : public AnimationTreeNodeEditorPlugin {
Ref<AnimationNodeBlendSpace1D> blend_space;
HBoxContainer *goto_parent_hb;
ToolButton *goto_parent;
Button *goto_parent;
PanelContainer *panel;
ToolButton *tool_blend;
ToolButton *tool_select;
ToolButton *tool_create;
Button *tool_blend;
Button *tool_select;
Button *tool_create;
VSeparator *tool_erase_sep;
ToolButton *tool_erase;
ToolButton *snap;
Button *tool_erase;
Button *snap;
SpinBox *snap_value;
LineEdit *label_value;

21
editor/plugins/animation_blend_space_2d_editor.cpp
View file

@ -819,7 +819,8 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() {
Ref<ButtonGroup> bg;
bg.instance();
tool_blend = memnew(ToolButton);
tool_blend = memnew(Button);
tool_blend->set_flat(true);
tool_blend->set_toggle_mode(true);
tool_blend->set_button_group(bg);
top_hb->add_child(tool_blend);
@ -827,21 +828,24 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() {
tool_blend->set_tooltip(TTR("Set the blending position within the space"));
tool_blend->connect("pressed", callable_mp(this, &AnimationNodeBlendSpace2DEditor::_tool_switch), varray(3));
tool_select = memnew(ToolButton);
tool_select = memnew(Button);
tool_select->set_flat(true);
tool_select->set_toggle_mode(true);
tool_select->set_button_group(bg);
top_hb->add_child(tool_select);
tool_select->set_tooltip(TTR("Select and move points, create points with RMB."));
tool_select->connect("pressed", callable_mp(this, &AnimationNodeBlendSpace2DEditor::_tool_switch), varray(0));
tool_create = memnew(ToolButton);
tool_create = memnew(Button);
tool_create->set_flat(true);
tool_create->set_toggle_mode(true);
tool_create->set_button_group(bg);
top_hb->add_child(tool_create);
tool_create->set_tooltip(TTR("Create points."));
tool_create->connect("pressed", callable_mp(this, &AnimationNodeBlendSpace2DEditor::_tool_switch), varray(1));
tool_triangle = memnew(ToolButton);
tool_triangle = memnew(Button);
tool_triangle->set_flat(true);
tool_triangle->set_toggle_mode(true);
tool_triangle->set_button_group(bg);
top_hb->add_child(tool_triangle);
@ -850,7 +854,8 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() {
tool_erase_sep = memnew(VSeparator);
top_hb->add_child(tool_erase_sep);
tool_erase = memnew(ToolButton);
tool_erase = memnew(Button);
tool_erase->set_flat(true);
top_hb->add_child(tool_erase);
tool_erase->set_tooltip(TTR("Erase points and triangles."));
tool_erase->connect("pressed", callable_mp(this, &AnimationNodeBlendSpace2DEditor::_erase_selected));
@ -858,7 +863,8 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() {
top_hb->add_child(memnew(VSeparator));
auto_triangles = memnew(ToolButton);
auto_triangles = memnew(Button);
auto_triangles->set_flat(true);
top_hb->add_child(auto_triangles);
auto_triangles->connect("pressed", callable_mp(this, &AnimationNodeBlendSpace2DEditor::_auto_triangles_toggled));
auto_triangles->set_toggle_mode(true);
@ -866,7 +872,8 @@ AnimationNodeBlendSpace2DEditor::AnimationNodeBlendSpace2DEditor() {
top_hb->add_child(memnew(VSeparator));
snap = memnew(ToolButton);
snap = memnew(Button);
snap->set_flat(true);
snap->set_toggle_mode(true);
top_hb->add_child(snap);
snap->set_pressed(true);

14
editor/plugins/animation_blend_space_2d_editor.h
View file

@ -47,18 +47,18 @@ class AnimationNodeBlendSpace2DEditor : public AnimationTreeNodeEditorPlugin {
Ref<AnimationNodeBlendSpace2D> blend_space;
PanelContainer *panel;
ToolButton *tool_blend;
ToolButton *tool_select;
ToolButton *tool_create;
ToolButton *tool_triangle;
Button *tool_blend;
Button *tool_select;
Button *tool_create;
Button *tool_triangle;
VSeparator *tool_erase_sep;
ToolButton *tool_erase;
ToolButton *snap;
Button *tool_erase;
Button *snap;
SpinBox *snap_x;
SpinBox *snap_y;
OptionButton *interpolation;
ToolButton *auto_triangles;
Button *auto_triangles;
LineEdit *label_x;
LineEdit *label_y;

24
editor/plugins/animation_player_editor_plugin.cpp
View file

@ -1502,24 +1502,29 @@ AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor, AnimationPlay
HBoxContainer *hb = memnew(HBoxContainer);
add_child(hb);
play_bw_from = memnew(ToolButton);
play_bw_from = memnew(Button);
play_bw_from->set_flat(true);
play_bw_from->set_tooltip(TTR("Play selected animation backwards from current pos. (A)"));
hb->add_child(play_bw_from);
play_bw = memnew(ToolButton);
play_bw = memnew(Button);
play_bw->set_flat(true);
play_bw->set_tooltip(TTR("Play selected animation backwards from end. (Shift+A)"));
hb->add_child(play_bw);
stop = memnew(ToolButton);
stop = memnew(Button);
stop->set_flat(true);
stop->set_toggle_mode(true);
hb->add_child(stop);
stop->set_tooltip(TTR("Stop animation playback. (S)"));
play = memnew(ToolButton);
play = memnew(Button);
play->set_flat(true);
play->set_tooltip(TTR("Play selected animation from start. (Shift+D)"));
hb->add_child(play);
play_from = memnew(ToolButton);
play_from = memnew(Button);
play_from->set_flat(true);
play_from->set_tooltip(TTR("Play selected animation from current pos. (D)"));
hb->add_child(play_from);
@ -1571,7 +1576,8 @@ AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor, AnimationPlay
animation->set_tooltip(TTR("Display list of animations in player."));
animation->set_clip_text(true);
autoplay = memnew(ToolButton);
autoplay = memnew(Button);
autoplay->set_flat(true);
hb->add_child(autoplay);
autoplay->set_tooltip(TTR("Autoplay on Load"));
@ -1583,7 +1589,8 @@ AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor, AnimationPlay
hb->add_child(memnew(VSeparator));
onion_toggle = memnew(ToolButton);
onion_toggle = memnew(Button);
onion_toggle->set_flat(true);
onion_toggle->set_toggle_mode(true);
onion_toggle->set_tooltip(TTR("Enable Onion Skinning"));
onion_toggle->connect("pressed", callable_mp(this, &AnimationPlayerEditor::_onion_skinning_menu), varray(ONION_SKINNING_ENABLE));
@ -1608,7 +1615,8 @@ AnimationPlayerEditor::AnimationPlayerEditor(EditorNode *p_editor, AnimationPlay
hb->add_child(memnew(VSeparator));
pin = memnew(ToolButton);
pin = memnew(Button);
pin->set_flat(true);
pin->set_toggle_mode(true);
pin->set_tooltip(TTR("Pin AnimationPlayer"));
hb->add_child(pin);

4
editor/plugins/animation_player_editor_plugin.h
View file

@ -96,9 +96,9 @@ class AnimationPlayerEditor : public VBoxContainer {
Button *autoplay;
MenuButton *tool_anim;
ToolButton *onion_toggle;
Button *onion_toggle;
MenuButton *onion_skinning;
ToolButton *pin;
Button *pin;
SpinBox *frame;
LineEdit *scale;
LineEdit *name;

18
editor/plugins/animation_state_machine_editor.cpp
View file

@ -1208,7 +1208,8 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() {
Ref<ButtonGroup> bg;
bg.instance();
tool_select = memnew(ToolButton);
tool_select = memnew(Button);
tool_select->set_flat(true);
top_hb->add_child(tool_select);
tool_select->set_toggle_mode(true);
tool_select->set_button_group(bg);
@ -1216,14 +1217,16 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() {
tool_select->set_tooltip(TTR("Select and move nodes.\nRMB to add new nodes.\nShift+LMB to create connections."));
tool_select->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_update_mode), varray(), CONNECT_DEFERRED);
tool_create = memnew(ToolButton);
tool_create = memnew(Button);
tool_create->set_flat(true);
top_hb->add_child(tool_create);
tool_create->set_toggle_mode(true);
tool_create->set_button_group(bg);
tool_create->set_tooltip(TTR("Create new nodes."));
tool_create->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_update_mode), varray(), CONNECT_DEFERRED);
tool_connect = memnew(ToolButton);
tool_connect = memnew(Button);
tool_connect->set_flat(true);
top_hb->add_child(tool_connect);
tool_connect->set_toggle_mode(true);
tool_connect->set_button_group(bg);
@ -1233,7 +1236,8 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() {
tool_erase_hb = memnew(HBoxContainer);
top_hb->add_child(tool_erase_hb);
tool_erase_hb->add_child(memnew(VSeparator));
tool_erase = memnew(ToolButton);
tool_erase = memnew(Button);
tool_erase->set_flat(true);
tool_erase->set_tooltip(TTR("Remove selected node or transition."));
tool_erase_hb->add_child(tool_erase);
tool_erase->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_erase_selected));
@ -1241,13 +1245,15 @@ AnimationNodeStateMachineEditor::AnimationNodeStateMachineEditor() {
tool_erase_hb->add_child(memnew(VSeparator));
tool_autoplay = memnew(ToolButton);
tool_autoplay = memnew(Button);
tool_autoplay->set_flat(true);
tool_autoplay->set_tooltip(TTR("Toggle autoplay this animation on start, restart or seek to zero."));
tool_erase_hb->add_child(tool_autoplay);
tool_autoplay->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_autoplay_selected));
tool_autoplay->set_disabled(true);
tool_end = memnew(ToolButton);
tool_end = memnew(Button);
tool_end->set_flat(true);
tool_end->set_tooltip(TTR("Set the end animation. This is useful for sub-transitions."));
tool_erase_hb->add_child(tool_end);
tool_end->connect("pressed", callable_mp(this, &AnimationNodeStateMachineEditor::_end_selected));

12
editor/plugins/animation_state_machine_editor.h
View file

@ -46,16 +46,16 @@ class AnimationNodeStateMachineEditor : public AnimationTreeNodeEditorPlugin {
Ref<AnimationNodeStateMachine> state_machine;
ToolButton *tool_select;
ToolButton *tool_create;
ToolButton *tool_connect;
Button *tool_select;
Button *tool_create;
Button *tool_connect;
Popup *name_edit_popup;
LineEdit *name_edit;
HBoxContainer *tool_erase_hb;
ToolButton *tool_erase;
ToolButton *tool_autoplay;
ToolButton *tool_end;
Button *tool_erase;
Button *tool_autoplay;
Button *tool_end;
OptionButton *transition_mode;
OptionButton *play_mode;

6
editor/plugins/audio_stream_editor_plugin.cpp
View file

@ -220,12 +220,14 @@ AudioStreamEditor::AudioStreamEditor() {
hbox->add_theme_constant_override("separation", 0);
vbox->add_child(hbox);
_play_button = memnew(ToolButton);
_play_button = memnew(Button);
_play_button->set_flat(true);
hbox->add_child(_play_button);
_play_button->set_focus_mode(Control::FOCUS_NONE);
_play_button->connect("pressed", callable_mp(this, &AudioStreamEditor::_play));
_stop_button = memnew(ToolButton);
_stop_button = memnew(Button);
_stop_button->set_flat(true);
hbox->add_child(_stop_button);
_stop_button->set_focus_mode(Control::FOCUS_NONE);
_stop_button->connect("pressed", callable_mp(this, &AudioStreamEditor::_stop));

4
editor/plugins/audio_stream_editor_plugin.h
View file

@ -47,8 +47,8 @@ class AudioStreamEditor : public ColorRect {
Label *_current_label;
Label *_duration_label;
ToolButton *_play_button;
ToolButton *_stop_button;
Button *_play_button;
Button *_stop_button;
float _current;
bool _dragging;

3
editor/plugins/baked_lightmap_editor_plugin.cpp
View file

@ -117,7 +117,8 @@ void BakedLightmapEditorPlugin::_bind_methods() {
BakedLightmapEditorPlugin::BakedLightmapEditorPlugin(EditorNode *p_node) {
editor = p_node;
bake = memnew(ToolButton);
bake = memnew(Button);
bake->set_flat(true);
bake->set_icon(editor->get_gui_base()->get_theme_icon("Bake", "EditorIcons"));
bake->set_text(TTR("Bake Lightmaps"));
bake->hide();

2
editor/plugins/baked_lightmap_editor_plugin.h
View file

@ -41,7 +41,7 @@ class BakedLightmapEditorPlugin : public EditorPlugin {
BakedLightmap *lightmap;
ToolButton *bake;
Button *bake;
EditorNode *editor;
EditorFileDialog *file_dialog;

59
editor/plugins/canvas_item_editor_plugin.cpp
View file

@ -4447,7 +4447,7 @@ void CanvasItemEditor::_button_override_camera(bool p_pressed) {
}
void CanvasItemEditor::_button_tool_select(int p_index) {
ToolButton *tb[TOOL_MAX] = { select_button, list_select_button, move_button, scale_button, rotate_button, pivot_button, pan_button, ruler_button };
Button *tb[TOOL_MAX] = { select_button, list_select_button, move_button, scale_button, rotate_button, pivot_button, pan_button, ruler_button };
for (int i = 0; i < TOOL_MAX; i++) {
tb[i]->set_pressed(i == p_index);
}
@ -5577,13 +5577,15 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
viewport->add_child(controls_vb);
zoom_minus = memnew(ToolButton);
zoom_minus = memnew(Button);
zoom_minus->set_flat(true);
zoom_hb->add_child(zoom_minus);
zoom_minus->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_zoom_minus));
zoom_minus->set_shortcut(ED_SHORTCUT("canvas_item_editor/zoom_minus", TTR("Zoom Out"), KEY_MASK_CMD | KEY_MINUS));
zoom_minus->set_focus_mode(FOCUS_NONE);
zoom_reset = memnew(ToolButton);
zoom_reset = memnew(Button);
zoom_reset->set_flat(true);
zoom_hb->add_child(zoom_reset);
zoom_reset->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_zoom_reset));
zoom_reset->set_shortcut(ED_SHORTCUT("canvas_item_editor/zoom_reset", TTR("Zoom Reset"), KEY_MASK_CMD | KEY_0));
@ -5592,7 +5594,8 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
// Prevent the button's size from changing when the text size changes
zoom_reset->set_custom_minimum_size(Size2(75 * EDSCALE, 0));
zoom_plus = memnew(ToolButton);
zoom_plus = memnew(Button);
zoom_plus->set_flat(true);
zoom_hb->add_child(zoom_plus);
zoom_plus->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_zoom_plus));
zoom_plus->set_shortcut(ED_SHORTCUT("canvas_item_editor/zoom_plus", TTR("Zoom In"), KEY_MASK_CMD | KEY_EQUAL)); // Usually direct access key for PLUS
@ -5600,7 +5603,8 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
updating_scroll = false;
select_button = memnew(ToolButton);
select_button = memnew(Button);
select_button->set_flat(true);
hb->add_child(select_button);
select_button->set_toggle_mode(true);
select_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_tool_select), make_binds(TOOL_SELECT));
@ -5610,21 +5614,24 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
hb->add_child(memnew(VSeparator));
move_button = memnew(ToolButton);
move_button = memnew(Button);
move_button->set_flat(true);
hb->add_child(move_button);
move_button->set_toggle_mode(true);
move_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_tool_select), make_binds(TOOL_MOVE));
move_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/move_mode", TTR("Move Mode"), KEY_W));
move_button->set_tooltip(TTR("Move Mode"));
rotate_button = memnew(ToolButton);
rotate_button = memnew(Button);
rotate_button->set_flat(true);
hb->add_child(rotate_button);
rotate_button->set_toggle_mode(true);
rotate_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_tool_select), make_binds(TOOL_ROTATE));
rotate_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/rotate_mode", TTR("Rotate Mode"), KEY_E));
rotate_button->set_tooltip(TTR("Rotate Mode"));
scale_button = memnew(ToolButton);
scale_button = memnew(Button);
scale_button->set_flat(true);
hb->add_child(scale_button);
scale_button->set_toggle_mode(true);
scale_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_tool_select), make_binds(TOOL_SCALE));
@ -5633,26 +5640,30 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
hb->add_child(memnew(VSeparator));
list_select_button = memnew(ToolButton);
list_select_button = memnew(Button);
list_select_button->set_flat(true);
hb->add_child(list_select_button);
list_select_button->set_toggle_mode(true);
list_select_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_tool_select), make_binds(TOOL_LIST_SELECT));
list_select_button->set_tooltip(TTR("Show a list of all objects at the position clicked\n(same as Alt+RMB in select mode)."));
pivot_button = memnew(ToolButton);
pivot_button = memnew(Button);
pivot_button->set_flat(true);
hb->add_child(pivot_button);
pivot_button->set_toggle_mode(true);
pivot_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_tool_select), make_binds(TOOL_EDIT_PIVOT));
pivot_button->set_tooltip(TTR("Click to change object's rotation pivot."));
pan_button = memnew(ToolButton);
pan_button = memnew(Button);
pan_button->set_flat(true);
hb->add_child(pan_button);
pan_button->set_toggle_mode(true);
pan_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_tool_select), make_binds(TOOL_PAN));
pan_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/pan_mode", TTR("Pan Mode"), KEY_G));
pan_button->set_tooltip(TTR("Pan Mode"));
ruler_button = memnew(ToolButton);
ruler_button = memnew(Button);
ruler_button->set_flat(true);
hb->add_child(ruler_button);
ruler_button->set_toggle_mode(true);
ruler_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_button_tool_select), make_binds(TOOL_RULER));
@ -5661,14 +5672,16 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
hb->add_child(memnew(VSeparator));
smart_snap_button = memnew(ToolButton);
smart_snap_button = memnew(Button);
smart_snap_button->set_flat(true);
hb->add_child(smart_snap_button);
smart_snap_button->set_toggle_mode(true);
smart_snap_button->connect("toggled", callable_mp(this, &CanvasItemEditor::_button_toggle_smart_snap));
smart_snap_button->set_tooltip(TTR("Toggle smart snapping."));
smart_snap_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/use_smart_snap", TTR("Use Smart Snap"), KEY_MASK_SHIFT | KEY_S));
grid_snap_button = memnew(ToolButton);
grid_snap_button = memnew(Button);
grid_snap_button->set_flat(true);
hb->add_child(grid_snap_button);
grid_snap_button->set_toggle_mode(true);
grid_snap_button->connect("toggled", callable_mp(this, &CanvasItemEditor::_button_toggle_grid_snap));
@ -5707,23 +5720,27 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
hb->add_child(memnew(VSeparator));
lock_button = memnew(ToolButton);
lock_button = memnew(Button);
lock_button->set_flat(true);
hb->add_child(lock_button);
lock_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_popup_callback), varray(LOCK_SELECTED));
lock_button->set_tooltip(TTR("Lock the selected object in place (can't be moved)."));
unlock_button = memnew(ToolButton);
unlock_button = memnew(Button);
unlock_button->set_flat(true);
hb->add_child(unlock_button);
unlock_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_popup_callback), varray(UNLOCK_SELECTED));
unlock_button->set_tooltip(TTR("Unlock the selected object (can be moved)."));
group_button = memnew(ToolButton);
group_button = memnew(Button);
group_button->set_flat(true);
hb->add_child(group_button);
group_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_popup_callback), varray(GROUP_SELECTED));
group_button->set_tooltip(TTR("Makes sure the object's children are not selectable."));
ungroup_button = memnew(ToolButton);
ungroup_button = memnew(Button);
ungroup_button->set_flat(true);
hb->add_child(ungroup_button);
ungroup_button->connect("pressed", callable_mp(this, &CanvasItemEditor::_popup_callback), varray(UNGROUP_SELECTED));
ungroup_button->set_tooltip(TTR("Restores the object's children's ability to be selected."));
@ -5748,7 +5765,8 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
hb->add_child(memnew(VSeparator));
override_camera_button = memnew(ToolButton);
override_camera_button = memnew(Button);
override_camera_button->set_flat(true);
hb->add_child(override_camera_button);
override_camera_button->connect("toggled", callable_mp(this, &CanvasItemEditor::_button_override_camera));
override_camera_button->set_toggle_mode(true);
@ -5795,7 +5813,8 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
anchors_popup->set_name("Anchors");
anchors_popup->connect("id_pressed", callable_mp(this, &CanvasItemEditor::_popup_callback));
anchor_mode_button = memnew(ToolButton);
anchor_mode_button = memnew(Button);
anchor_mode_button->set_flat(true);
hb->add_child(anchor_mode_button);
anchor_mode_button->set_toggle_mode(true);
anchor_mode_button->hide();

38
editor/plugins/canvas_item_editor_plugin.h
View file

@ -228,9 +228,9 @@ private:
VScrollBar *v_scroll;
HBoxContainer *hb;
ToolButton *zoom_minus;
ToolButton *zoom_reset;
ToolButton *zoom_plus;
Button *zoom_minus;
Button *zoom_reset;
Button *zoom_plus;
Map<Control *, Timer *> popup_temporarily_timers;
@ -336,31 +336,31 @@ private:
};
List<PoseClipboard> pose_clipboard;
ToolButton *select_button;
Button *select_button;
ToolButton *move_button;
ToolButton *scale_button;
ToolButton *rotate_button;
Button *move_button;
Button *scale_button;
Button *rotate_button;
ToolButton *list_select_button;
ToolButton *pivot_button;
ToolButton *pan_button;
Button *list_select_button;
Button *pivot_button;
Button *pan_button;
ToolButton *ruler_button;
Button *ruler_button;
ToolButton *smart_snap_button;
ToolButton *grid_snap_button;
Button *smart_snap_button;
Button *grid_snap_button;
MenuButton *snap_config_menu;
PopupMenu *smartsnap_config_popup;
ToolButton *lock_button;
ToolButton *unlock_button;
Button *lock_button;
Button *unlock_button;
ToolButton *group_button;
ToolButton *ungroup_button;
Button *group_button;
Button *ungroup_button;
MenuButton *skeleton_menu;
ToolButton *override_camera_button;
Button *override_camera_button;
MenuButton *view_menu;
HBoxContainer *animation_hb;
MenuButton *animation_menu;
@ -369,7 +369,7 @@ private:
PopupMenu *anchors_and_margins_popup;
PopupMenu *anchors_popup;
ToolButton *anchor_mode_button;
Button *anchor_mode_button;
Button *key_loc_button;
Button *key_rot_button;

6
editor/plugins/collision_polygon_3d_editor_plugin.cpp
View file

@ -501,12 +501,14 @@ CollisionPolygon3DEditor::CollisionPolygon3DEditor(EditorNode *p_editor) {
undo_redo = EditorNode::get_undo_redo();
add_child(memnew(VSeparator));
button_create = memnew(ToolButton);
button_create = memnew(Button);
button_create->set_flat(true);
add_child(button_create);
button_create->connect("pressed", callable_mp(this, &CollisionPolygon3DEditor::_menu_option), varray(MODE_CREATE));
button_create->set_toggle_mode(true);
button_edit = memnew(ToolButton);
button_edit = memnew(Button);
button_edit->set_flat(true);
add_child(button_edit);
button_edit->connect("pressed", callable_mp(this, &CollisionPolygon3DEditor::_menu_option), varray(MODE_EDIT));
button_edit->set_toggle_mode(true);

5
editor/plugins/collision_polygon_3d_editor_plugin.h
View file

@ -36,7 +36,6 @@
#include "scene/3d/collision_polygon_3d.h"
#include "scene/3d/immediate_geometry_3d.h"
#include "scene/3d/mesh_instance_3d.h"
#include "scene/gui/tool_button.h"
class CanvasItemEditor;
@ -53,8 +52,8 @@ class CollisionPolygon3DEditor : public HBoxContainer {
Mode mode;
ToolButton *button_create;
ToolButton *button_edit;
Button *button_create;
Button *button_edit;
Ref<StandardMaterial3D> line_material;
Ref<StandardMaterial3D> handle_material;

3
editor/plugins/gi_probe_editor_plugin.cpp
View file

@ -144,7 +144,8 @@ GIProbeEditorPlugin::GIProbeEditorPlugin(EditorNode *p_node) {
bake_hb = memnew(HBoxContainer);
bake_hb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
bake_hb->hide();
bake = memnew(ToolButton);
bake = memnew(Button);
bake->set_flat(true);
bake->set_icon(editor->get_gui_base()->get_theme_icon("Bake", "EditorIcons"));
bake->set_text(TTR("Bake GI Probe"));
bake->connect("pressed", callable_mp(this, &GIProbeEditorPlugin::_bake));

2
editor/plugins/gi_probe_editor_plugin.h
View file

@ -43,7 +43,7 @@ class GIProbeEditorPlugin : public EditorPlugin {
HBoxContainer *bake_hb;
Label *bake_info;
ToolButton *bake;
Button *bake;
EditorNode *editor;
EditorFileDialog *probe_file;

3
editor/plugins/item_list_editor_plugin.cpp
View file

@ -325,7 +325,8 @@ ItemListEditor::ItemListEditor() {
selected_idx = -1;
item_list = nullptr;
toolbar_button = memnew(ToolButton);
toolbar_button = memnew(Button);
toolbar_button->set_flat(true);
toolbar_button->set_text(TTR("Items"));
add_child(toolbar_button);
toolbar_button->connect("pressed", callable_mp(this, &ItemListEditor::_edit_items));

2
editor/plugins/item_list_editor_plugin.h
View file

@ -198,7 +198,7 @@ class ItemListEditor : public HBoxContainer {
Node *item_list;
ToolButton *toolbar_button;
Button *toolbar_button;
AcceptDialog *dialog;
EditorInspector *property_editor;

24
editor/plugins/node_3d_editor_plugin.cpp
View file

@ -6048,7 +6048,7 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
button_binds.resize(1);
String sct;
tool_button[TOOL_MODE_SELECT] = memnew(ToolButton);
tool_button[TOOL_MODE_SELECT] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_MODE_SELECT]);
tool_button[TOOL_MODE_SELECT]->set_toggle_mode(true);
tool_button[TOOL_MODE_SELECT]->set_flat(true);
@ -6060,7 +6060,7 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
hbc_menu->add_child(memnew(VSeparator));
tool_button[TOOL_MODE_MOVE] = memnew(ToolButton);
tool_button[TOOL_MODE_MOVE] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_MODE_MOVE]);
tool_button[TOOL_MODE_MOVE]->set_toggle_mode(true);
tool_button[TOOL_MODE_MOVE]->set_flat(true);
@ -6068,7 +6068,7 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
tool_button[TOOL_MODE_MOVE]->connect("pressed", callable_mp(this, &Node3DEditor::_menu_item_pressed), button_binds);
tool_button[TOOL_MODE_MOVE]->set_shortcut(ED_SHORTCUT("spatial_editor/tool_move", TTR("Move Mode"), KEY_W));
tool_button[TOOL_MODE_ROTATE] = memnew(ToolButton);
tool_button[TOOL_MODE_ROTATE] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_MODE_ROTATE]);
tool_button[TOOL_MODE_ROTATE]->set_toggle_mode(true);
tool_button[TOOL_MODE_ROTATE]->set_flat(true);
@ -6076,7 +6076,7 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
tool_button[TOOL_MODE_ROTATE]->connect("pressed", callable_mp(this, &Node3DEditor::_menu_item_pressed), button_binds);
tool_button[TOOL_MODE_ROTATE]->set_shortcut(ED_SHORTCUT("spatial_editor/tool_rotate", TTR("Rotate Mode"), KEY_E));
tool_button[TOOL_MODE_SCALE] = memnew(ToolButton);
tool_button[TOOL_MODE_SCALE] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_MODE_SCALE]);
tool_button[TOOL_MODE_SCALE]->set_toggle_mode(true);
tool_button[TOOL_MODE_SCALE]->set_flat(true);
@ -6086,7 +6086,7 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
hbc_menu->add_child(memnew(VSeparator));
tool_button[TOOL_MODE_LIST_SELECT] = memnew(ToolButton);
tool_button[TOOL_MODE_LIST_SELECT] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_MODE_LIST_SELECT]);
tool_button[TOOL_MODE_LIST_SELECT]->set_toggle_mode(true);
tool_button[TOOL_MODE_LIST_SELECT]->set_flat(true);
@ -6094,25 +6094,25 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
tool_button[TOOL_MODE_LIST_SELECT]->connect("pressed", callable_mp(this, &Node3DEditor::_menu_item_pressed), button_binds);
tool_button[TOOL_MODE_LIST_SELECT]->set_tooltip(TTR("Show a list of all objects at the position clicked\n(same as Alt+RMB in select mode)."));
tool_button[TOOL_LOCK_SELECTED] = memnew(ToolButton);
tool_button[TOOL_LOCK_SELECTED] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_LOCK_SELECTED]);
button_binds.write[0] = MENU_LOCK_SELECTED;
tool_button[TOOL_LOCK_SELECTED]->connect("pressed", callable_mp(this, &Node3DEditor::_menu_item_pressed), button_binds);
tool_button[TOOL_LOCK_SELECTED]->set_tooltip(TTR("Lock the selected object in place (can't be moved)."));
tool_button[TOOL_UNLOCK_SELECTED] = memnew(ToolButton);
tool_button[TOOL_UNLOCK_SELECTED] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_UNLOCK_SELECTED]);
button_binds.write[0] = MENU_UNLOCK_SELECTED;
tool_button[TOOL_UNLOCK_SELECTED]->connect("pressed", callable_mp(this, &Node3DEditor::_menu_item_pressed), button_binds);
tool_button[TOOL_UNLOCK_SELECTED]->set_tooltip(TTR("Unlock the selected object (can be moved)."));
tool_button[TOOL_GROUP_SELECTED] = memnew(ToolButton);
tool_button[TOOL_GROUP_SELECTED] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_GROUP_SELECTED]);
button_binds.write[0] = MENU_GROUP_SELECTED;
tool_button[TOOL_GROUP_SELECTED]->connect("pressed", callable_mp(this, &Node3DEditor::_menu_item_pressed), button_binds);
tool_button[TOOL_GROUP_SELECTED]->set_tooltip(TTR("Makes sure the object's children are not selectable."));
tool_button[TOOL_UNGROUP_SELECTED] = memnew(ToolButton);
tool_button[TOOL_UNGROUP_SELECTED] = memnew(Button);
hbc_menu->add_child(tool_button[TOOL_UNGROUP_SELECTED]);
button_binds.write[0] = MENU_UNGROUP_SELECTED;
tool_button[TOOL_UNGROUP_SELECTED]->connect("pressed", callable_mp(this, &Node3DEditor::_menu_item_pressed), button_binds);
@ -6120,7 +6120,7 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
hbc_menu->add_child(memnew(VSeparator));
tool_option_button[TOOL_OPT_LOCAL_COORDS] = memnew(ToolButton);
tool_option_button[TOOL_OPT_LOCAL_COORDS] = memnew(Button);
hbc_menu->add_child(tool_option_button[TOOL_OPT_LOCAL_COORDS]);
tool_option_button[TOOL_OPT_LOCAL_COORDS]->set_toggle_mode(true);
tool_option_button[TOOL_OPT_LOCAL_COORDS]->set_flat(true);
@ -6128,7 +6128,7 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
tool_option_button[TOOL_OPT_LOCAL_COORDS]->connect("toggled", callable_mp(this, &Node3DEditor::_menu_item_toggled), button_binds);
tool_option_button[TOOL_OPT_LOCAL_COORDS]->set_shortcut(ED_SHORTCUT("spatial_editor/local_coords", TTR("Use Local Space"), KEY_T));
tool_option_button[TOOL_OPT_USE_SNAP] = memnew(ToolButton);
tool_option_button[TOOL_OPT_USE_SNAP] = memnew(Button);
hbc_menu->add_child(tool_option_button[TOOL_OPT_USE_SNAP]);
tool_option_button[TOOL_OPT_USE_SNAP]->set_toggle_mode(true);
tool_option_button[TOOL_OPT_USE_SNAP]->set_flat(true);
@ -6138,7 +6138,7 @@ Node3DEditor::Node3DEditor(EditorNode *p_editor) {
hbc_menu->add_child(memnew(VSeparator));
tool_option_button[TOOL_OPT_OVERRIDE_CAMERA] = memnew(ToolButton);
tool_option_button[TOOL_OPT_OVERRIDE_CAMERA] = memnew(Button);
hbc_menu->add_child(tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]);
tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->set_toggle_mode(true);
tool_option_button[TOOL_OPT_OVERRIDE_CAMERA]->set_flat(true);

15
editor/plugins/path_2d_editor_plugin.cpp
View file

@ -532,35 +532,40 @@ Path2DEditor::Path2DEditor(EditorNode *p_editor) {
sep = memnew(VSeparator);
base_hb->add_child(sep);
curve_edit = memnew(ToolButton);
curve_edit = memnew(Button);
curve_edit->set_flat(true);
curve_edit->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveEdit", "EditorIcons"));
curve_edit->set_toggle_mode(true);
curve_edit->set_focus_mode(Control::FOCUS_NONE);
curve_edit->set_tooltip(TTR("Select Points") + "\n" + TTR("Shift+Drag: Select Control Points") + "\n" + keycode_get_string(KEY_MASK_CMD) + TTR("Click: Add Point") + "\n" + TTR("Left Click: Split Segment (in curve)") + "\n" + TTR("Right Click: Delete Point"));
curve_edit->connect("pressed", callable_mp(this, &Path2DEditor::_mode_selected), varray(MODE_EDIT));
base_hb->add_child(curve_edit);
curve_edit_curve = memnew(ToolButton);
curve_edit_curve = memnew(Button);
curve_edit_curve->set_flat(true);
curve_edit_curve->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveCurve", "EditorIcons"));
curve_edit_curve->set_toggle_mode(true);
curve_edit_curve->set_focus_mode(Control::FOCUS_NONE);
curve_edit_curve->set_tooltip(TTR("Select Control Points (Shift+Drag)"));
curve_edit_curve->connect("pressed", callable_mp(this, &Path2DEditor::_mode_selected), varray(MODE_EDIT_CURVE));
base_hb->add_child(curve_edit_curve);
curve_create = memnew(ToolButton);
curve_create = memnew(Button);
curve_create->set_flat(true);
curve_create->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveCreate", "EditorIcons"));
curve_create->set_toggle_mode(true);
curve_create->set_focus_mode(Control::FOCUS_NONE);
curve_create->set_tooltip(TTR("Add Point (in empty space)"));
curve_create->connect("pressed", callable_mp(this, &Path2DEditor::_mode_selected), varray(MODE_CREATE));
base_hb->add_child(curve_create);
curve_del = memnew(ToolButton);
curve_del = memnew(Button);
curve_del->set_flat(true);
curve_del->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveDelete", "EditorIcons"));
curve_del->set_toggle_mode(true);
curve_del->set_focus_mode(Control::FOCUS_NONE);
curve_del->set_tooltip(TTR("Delete Point"));
curve_del->connect("pressed", callable_mp(this, &Path2DEditor::_mode_selected), varray(MODE_DELETE));
base_hb->add_child(curve_del);
curve_close = memnew(ToolButton);
curve_close = memnew(Button);
curve_close->set_flat(true);
curve_close->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveClose", "EditorIcons"));
curve_close->set_focus_mode(Control::FOCUS_NONE);
curve_close->set_tooltip(TTR("Close Curve"));

11
editor/plugins/path_2d_editor_plugin.h
View file

@ -34,7 +34,6 @@
#include "editor/editor_node.h"
#include "editor/editor_plugin.h"
#include "scene/2d/path_2d.h"
#include "scene/gui/tool_button.h"
class CanvasItemEditor;
@ -60,11 +59,11 @@ class Path2DEditor : public HBoxContainer {
};
Mode mode;
ToolButton *curve_create;
ToolButton *curve_edit;
ToolButton *curve_edit_curve;
ToolButton *curve_del;
ToolButton *curve_close;
Button *curve_create;
Button *curve_edit;
Button *curve_edit_curve;
Button *curve_del;
Button *curve_close;
MenuButton *handle_menu;
bool mirror_handle_angle;

12
editor/plugins/path_3d_editor_plugin.cpp
View file

@ -557,28 +557,32 @@ Path3DEditorPlugin::Path3DEditorPlugin(EditorNode *p_node) {
sep = memnew(VSeparator);
sep->hide();
Node3DEditor::get_singleton()->add_control_to_menu_panel(sep);
curve_edit = memnew(ToolButton);
curve_edit = memnew(Button);
curve_edit->set_flat(true);
curve_edit->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveEdit", "EditorIcons"));
curve_edit->set_toggle_mode(true);
curve_edit->hide();
curve_edit->set_focus_mode(Control::FOCUS_NONE);
curve_edit->set_tooltip(TTR("Select Points") + "\n" + TTR("Shift+Drag: Select Control Points") + "\n" + keycode_get_string(KEY_MASK_CMD) + TTR("Click: Add Point") + "\n" + TTR("Right Click: Delete Point"));
Node3DEditor::get_singleton()->add_control_to_menu_panel(curve_edit);
curve_create = memnew(ToolButton);
curve_create = memnew(Button);
curve_create->set_flat(true);
curve_create->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveCreate", "EditorIcons"));
curve_create->set_toggle_mode(true);
curve_create->hide();
curve_create->set_focus_mode(Control::FOCUS_NONE);
curve_create->set_tooltip(TTR("Add Point (in empty space)") + "\n" + TTR("Split Segment (in curve)"));
Node3DEditor::get_singleton()->add_control_to_menu_panel(curve_create);
curve_del = memnew(ToolButton);
curve_del = memnew(Button);
curve_del->set_flat(true);
curve_del->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveDelete", "EditorIcons"));
curve_del->set_toggle_mode(true);
curve_del->hide();
curve_del->set_focus_mode(Control::FOCUS_NONE);
curve_del->set_tooltip(TTR("Delete Point"));
Node3DEditor::get_singleton()->add_control_to_menu_panel(curve_del);
curve_close = memnew(ToolButton);
curve_close = memnew(Button);
curve_close->set_flat(true);
curve_close->set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("CurveClose", "EditorIcons"));
curve_close->hide();
curve_close->set_focus_mode(Control::FOCUS_NONE);

8
editor/plugins/path_3d_editor_plugin.h
View file

@ -68,10 +68,10 @@ class Path3DEditorPlugin : public EditorPlugin {
GDCLASS(Path3DEditorPlugin, EditorPlugin);
Separator *sep;
ToolButton *curve_create;
ToolButton *curve_edit;
ToolButton *curve_del;
ToolButton *curve_close;
Button *curve_create;
Button *curve_edit;
Button *curve_del;
Button *curve_close;
MenuButton *handle_menu;
EditorNode *editor;

3
editor/plugins/physical_bone_3d_editor_plugin.cpp
View file

@ -55,7 +55,8 @@ PhysicalBone3DEditor::PhysicalBone3DEditor(EditorNode *p_editor) :
spatial_editor_hb->add_child(memnew(VSeparator));
button_transform_joint = memnew(ToolButton);
button_transform_joint = memnew(Button);
button_transform_joint->set_flat(true);
spatial_editor_hb->add_child(button_transform_joint);
button_transform_joint->set_text(TTR("Move Joint"));

2
editor/plugins/physical_bone_3d_editor_plugin.h
View file

@ -38,7 +38,7 @@ class PhysicalBone3DEditor : public Object {
EditorNode *editor;
HBoxContainer *spatial_editor_hb;
ToolButton *button_transform_joint;
Button *button_transform_joint;
PhysicalBone3D *selected = nullptr;

19
editor/plugins/polygon_2d_editor_plugin.cpp
View file

@ -1214,7 +1214,8 @@ Polygon2DEditor::Polygon2DEditor(EditorNode *p_editor) :
use_snap = EditorSettings::get_singleton()->get_project_metadata("polygon_2d_uv_editor", "snap_enabled", false);
snap_show_grid = EditorSettings::get_singleton()->get_project_metadata("polygon_2d_uv_editor", "show_grid", false);
button_uv = memnew(ToolButton);
button_uv = memnew(Button);
button_uv->set_flat(true);
add_child(button_uv);
button_uv->set_tooltip(TTR("Open Polygon 2D UV editor."));
button_uv->connect("pressed", callable_mp(this, &Polygon2DEditor::_menu_option), varray(MODE_EDIT_UV));
@ -1231,16 +1232,16 @@ Polygon2DEditor::Polygon2DEditor(EditorNode *p_editor) :
uv_edit_group.instance();
uv_edit_mode[0] = memnew(ToolButton);
uv_edit_mode[0] = memnew(Button);
uv_mode_hb->add_child(uv_edit_mode[0]);
uv_edit_mode[0]->set_toggle_mode(true);
uv_edit_mode[1] = memnew(ToolButton);
uv_edit_mode[1] = memnew(Button);
uv_mode_hb->add_child(uv_edit_mode[1]);
uv_edit_mode[1]->set_toggle_mode(true);
uv_edit_mode[2] = memnew(ToolButton);
uv_edit_mode[2] = memnew(Button);
uv_mode_hb->add_child(uv_edit_mode[2]);
uv_edit_mode[2]->set_toggle_mode(true);
uv_edit_mode[3] = memnew(ToolButton);
uv_edit_mode[3] = memnew(Button);
uv_mode_hb->add_child(uv_edit_mode[3]);
uv_edit_mode[3]->set_toggle_mode(true);
@ -1264,7 +1265,7 @@ Polygon2DEditor::Polygon2DEditor(EditorNode *p_editor) :
uv_main_vb->add_child(uv_mode_hb);
for (int i = 0; i < UV_MODE_MAX; i++) {
uv_button[i] = memnew(ToolButton);
uv_button[i] = memnew(Button);
uv_button[i]->set_toggle_mode(true);
uv_mode_hb->add_child(uv_button[i]);
uv_button[i]->connect("pressed", callable_mp(this, &Polygon2DEditor::_uv_mode), varray(i));
@ -1334,7 +1335,8 @@ Polygon2DEditor::Polygon2DEditor(EditorNode *p_editor) :
uv_mode_hb->add_child(memnew(VSeparator));
b_snap_enable = memnew(ToolButton);
b_snap_enable = memnew(Button);
b_snap_enable->set_flat(true);
uv_mode_hb->add_child(b_snap_enable);
b_snap_enable->set_text(TTR("Snap"));
b_snap_enable->set_focus_mode(FOCUS_NONE);
@ -1343,7 +1345,8 @@ Polygon2DEditor::Polygon2DEditor(EditorNode *p_editor) :
b_snap_enable->set_tooltip(TTR("Enable Snap"));
b_snap_enable->connect("toggled", callable_mp(this, &Polygon2DEditor::_set_use_snap));
b_snap_grid = memnew(ToolButton);
b_snap_grid = memnew(Button);
b_snap_grid->set_flat(true);
uv_mode_hb->add_child(b_snap_grid);
b_snap_grid->set_text(TTR("Grid"));
b_snap_grid->set_focus_mode(FOCUS_NONE);

10
editor/plugins/polygon_2d_editor_plugin.h
View file

@ -60,16 +60,16 @@ class Polygon2DEditor : public AbstractPolygon2DEditor {
UV_MODE_MAX
};
ToolButton *uv_edit_mode[4];
Button *uv_edit_mode[4];
Ref<ButtonGroup> uv_edit_group;
Polygon2D *node;
UVMode uv_mode;
AcceptDialog *uv_edit;
ToolButton *uv_button[UV_MODE_MAX];
ToolButton *b_snap_enable;
ToolButton *b_snap_grid;
Button *uv_button[UV_MODE_MAX];
Button *b_snap_enable;
Button *b_snap_grid;
Panel *uv_edit_draw;
HSlider *uv_zoom;
SpinBox *uv_zoom_value;
@ -115,7 +115,7 @@ class Polygon2DEditor : public AbstractPolygon2DEditor {
AcceptDialog *error;
ToolButton *button_uv;
Button *button_uv;
bool use_snap;
bool snap_show_grid;

15
editor/plugins/script_editor_plugin.cpp
View file

@ -2988,7 +2988,8 @@ ScriptEditor::ScriptEditor(EditorNode *p_editor) {
filename->add_theme_style_override("normal", EditorNode::get_singleton()->get_gui_base()->get_theme_stylebox("normal", "LineEdit"));
buttons_hbox->add_child(filename);
members_overview_alphabeta_sort_button = memnew(ToolButton);
members_overview_alphabeta_sort_button = memnew(Button);
members_overview_alphabeta_sort_button->set_flat(true);
members_overview_alphabeta_sort_button->set_tooltip(TTR("Toggle alphabetical sorting of the method list."));
members_overview_alphabeta_sort_button->set_toggle_mode(true);
members_overview_alphabeta_sort_button->set_pressed(EditorSettings::get_singleton()->get("text_editor/tools/sort_members_outline_alphabetically"));
@ -3115,13 +3116,15 @@ ScriptEditor::ScriptEditor(EditorNode *p_editor) {
menu_hb->add_spacer();
site_search = memnew(ToolButton);
site_search = memnew(Button);
site_search->set_flat(true);
site_search->set_text(TTR("Online Docs"));
site_search->connect("pressed", callable_mp(this, &ScriptEditor::_menu_option), varray(SEARCH_WEBSITE));
menu_hb->add_child(site_search);
site_search->set_tooltip(TTR("Open Godot online documentation."));
help_search = memnew(ToolButton);
help_search = memnew(Button);
help_search->set_flat(true);
help_search->set_text(TTR("Search Help"));
help_search->connect("pressed", callable_mp(this, &ScriptEditor::_menu_option), varray(SEARCH_HELP));
menu_hb->add_child(help_search);
@ -3129,13 +3132,15 @@ ScriptEditor::ScriptEditor(EditorNode *p_editor) {
menu_hb->add_child(memnew(VSeparator));
script_back = memnew(ToolButton);
script_back = memnew(Button);
script_back->set_flat(true);
script_back->connect("pressed", callable_mp(this, &ScriptEditor::_history_back));
menu_hb->add_child(script_back);
script_back->set_disabled(true);
script_back->set_tooltip(TTR("Go to previous edited document."));
script_forward = memnew(ToolButton);
script_forward = memnew(Button);
script_forward->set_flat(true);
script_forward->connect("pressed", callable_mp(this, &ScriptEditor::_history_forward));
menu_hb->add_child(script_forward);
script_forward->set_disabled(true);

9
editor/plugins/script_editor_plugin.h
View file

@ -43,7 +43,6 @@
#include "scene/gui/split_container.h"
#include "scene/gui/tab_container.h"
#include "scene/gui/text_edit.h"
#include "scene/gui/tool_button.h"
#include "scene/gui/tree.h"
#include "scene/main/timer.h"
#include "scene/resources/text_file.h"
@ -211,7 +210,7 @@ class ScriptEditor : public PanelContainer {
VBoxContainer *overview_vbox;
HBoxContainer *buttons_hbox;
Label *filename;
ToolButton *members_overview_alphabeta_sort_button;
Button *members_overview_alphabeta_sort_button;
bool members_overview_enabled;
ItemList *help_overview;
bool help_overview_enabled;
@ -221,15 +220,15 @@ class ScriptEditor : public PanelContainer {
AcceptDialog *error_dialog;
ConfirmationDialog *erase_tab_confirm;
ScriptCreateDialog *script_create_dialog;
ToolButton *scripts_visible;
Button *scripts_visible;
String current_theme;
TextureRect *script_icon;
Label *script_name_label;
ToolButton *script_back;
ToolButton *script_forward;
Button *script_back;
Button *script_forward;
FindInFilesDialog *find_in_files_dialog;
FindInFilesPanel *find_in_files;

33
editor/plugins/sprite_frames_editor_plugin.cpp
View file

@ -873,12 +873,14 @@ SpriteFramesEditor::SpriteFramesEditor() {
HBoxContainer *hbc_animlist = memnew(HBoxContainer);
sub_vb->add_child(hbc_animlist);
new_anim = memnew(ToolButton);
new_anim = memnew(Button);
new_anim->set_flat(true);
new_anim->set_tooltip(TTR("New Animation"));
hbc_animlist->add_child(new_anim);
new_anim->connect("pressed", callable_mp(this, &SpriteFramesEditor::_animation_add));
remove_anim = memnew(ToolButton);
remove_anim = memnew(Button);
remove_anim->set_flat(true);
remove_anim->set_tooltip(TTR("Remove Animation"));
hbc_animlist->add_child(remove_anim);
remove_anim->connect("pressed", callable_mp(this, &SpriteFramesEditor::_animation_remove));
@ -913,45 +915,54 @@ SpriteFramesEditor::SpriteFramesEditor() {
HBoxContainer *hbc = memnew(HBoxContainer);
sub_vb->add_child(hbc);
load = memnew(ToolButton);
load = memnew(Button);
load->set_flat(true);
load->set_tooltip(TTR("Add a Texture from File"));
hbc->add_child(load);
load_sheet = memnew(ToolButton);
load_sheet = memnew(Button);
load_sheet->set_flat(true);
load_sheet->set_tooltip(TTR("Add Frames from a Sprite Sheet"));
hbc->add_child(load_sheet);
hbc->add_child(memnew(VSeparator));
copy = memnew(ToolButton);
copy = memnew(Button);
copy->set_flat(true);
copy->set_tooltip(TTR("Copy"));
hbc->add_child(copy);
paste = memnew(ToolButton);
paste = memnew(Button);
paste->set_flat(true);
paste->set_tooltip(TTR("Paste"));
hbc->add_child(paste);
hbc->add_child(memnew(VSeparator));
empty = memnew(ToolButton);
empty = memnew(Button);
empty->set_flat(true);
empty->set_tooltip(TTR("Insert Empty (Before)"));
hbc->add_child(empty);
empty2 = memnew(ToolButton);
empty2 = memnew(Button);
empty2->set_flat(true);
empty2->set_tooltip(TTR("Insert Empty (After)"));
hbc->add_child(empty2);
hbc->add_child(memnew(VSeparator));
move_up = memnew(ToolButton);
move_up = memnew(Button);
move_up->set_flat(true);
move_up->set_tooltip(TTR("Move (Before)"));
hbc->add_child(move_up);
move_down = memnew(ToolButton);
move_down = memnew(Button);
move_down->set_flat(true);
move_down->set_tooltip(TTR("Move (After)"));
hbc->add_child(move_down);
_delete = memnew(ToolButton);
_delete = memnew(Button);
_delete->set_flat(true);
_delete->set_tooltip(TTR("Delete"));
hbc->add_child(_delete);

22
editor/plugins/sprite_frames_editor_plugin.h
View file

@ -43,22 +43,22 @@
class SpriteFramesEditor : public HSplitContainer {
GDCLASS(SpriteFramesEditor, HSplitContainer);
ToolButton *load;
ToolButton *load_sheet;
ToolButton *_delete;
ToolButton *copy;
ToolButton *paste;
ToolButton *empty;
ToolButton *empty2;
ToolButton *move_up;
ToolButton *move_down;
Button *load;
Button *load_sheet;
Button *_delete;
Button *copy;
Button *paste;
Button *empty;
Button *empty2;
Button *move_up;
Button *move_down;
ItemList *tree;
bool loading_scene;
int sel;
HSplitContainer *split;
ToolButton *new_anim;
ToolButton *remove_anim;
Button *new_anim;
Button *remove_anim;
Tree *animations;
SpinBox *anim_speed;

9
editor/plugins/texture_region_editor_plugin.cpp
View file

@ -1037,17 +1037,20 @@ TextureRegionEditor::TextureRegionEditor(EditorNode *p_editor) {
edit_draw->add_child(zoom_hb);
zoom_hb->set_begin(Point2(5, 5));
zoom_out = memnew(ToolButton);
zoom_out = memnew(Button);
zoom_out->set_flat(true);
zoom_out->set_tooltip(TTR("Zoom Out"));
zoom_out->connect("pressed", callable_mp(this, &TextureRegionEditor::_zoom_out));
zoom_hb->add_child(zoom_out);
zoom_reset = memnew(ToolButton);
zoom_reset = memnew(Button);
zoom_reset->set_flat(true);
zoom_reset->set_tooltip(TTR("Zoom Reset"));
zoom_reset->connect("pressed", callable_mp(this, &TextureRegionEditor::_zoom_reset));
zoom_hb->add_child(zoom_reset);
zoom_in = memnew(ToolButton);
zoom_in = memnew(Button);
zoom_in->set_flat(true);
zoom_in->set_tooltip(TTR("Zoom In"));
zoom_in->connect("pressed", callable_mp(this, &TextureRegionEditor::_zoom_in));
zoom_hb->add_child(zoom_in);

6
editor/plugins/texture_region_editor_plugin.h
View file

@ -56,9 +56,9 @@ class TextureRegionEditor : public VBoxContainer {
friend class TextureRegionEditorPlugin;
OptionButton *snap_mode_button;
ToolButton *zoom_in;
ToolButton *zoom_reset;
ToolButton *zoom_out;
Button *zoom_in;
Button *zoom_reset;
Button *zoom_out;
HBoxContainer *hb_grid; //For showing/hiding the grid controls when changing the SnapMode
SpinBox *sb_step_y;
SpinBox *sb_step_x;

5
editor/plugins/theme_editor_plugin.cpp
View file

@ -672,8 +672,9 @@ ThemeEditor::ThemeEditor() {
bt->set_text(TTR("Disabled Button"));
bt->set_disabled(true);
first_vb->add_child(bt);
ToolButton *tb = memnew(ToolButton);
tb->set_text("ToolButton");
Button *tb = memnew(Button);
tb->set_flat(true);
tb->set_text("Button");
first_vb->add_child(tb);
CheckButton *cb = memnew(CheckButton);

29
editor/plugins/tile_map_editor_plugin.cpp
View file

@ -91,7 +91,7 @@ void TileMapEditor::_notification(int p_what) {
}
void TileMapEditor::_update_button_tool() {
ToolButton *tb[4] = { paint_button, bucket_fill_button, picker_button, select_button };
Button *tb[4] = { paint_button, bucket_fill_button, picker_button, select_button };
// Unpress all buttons
for (int i = 0; i < 4; i++) {
tb[i]->set_pressed(false);
@ -1959,26 +1959,30 @@ TileMapEditor::TileMapEditor(EditorNode *p_editor) {
toolbar->add_child(memnew(VSeparator));
// Tools.
paint_button = memnew(ToolButton);
paint_button = memnew(Button);
paint_button->set_flat(true);
paint_button->set_shortcut(ED_SHORTCUT("tile_map_editor/paint_tile", TTR("Paint Tile"), KEY_P));
paint_button->set_tooltip(TTR("Shift+LMB: Line Draw\nShift+Ctrl+LMB: Rectangle Paint"));
paint_button->connect("pressed", callable_mp(this, &TileMapEditor::_button_tool_select), make_binds(TOOL_NONE));
paint_button->set_toggle_mode(true);
toolbar->add_child(paint_button);
bucket_fill_button = memnew(ToolButton);
bucket_fill_button = memnew(Button);
bucket_fill_button->set_flat(true);
bucket_fill_button->set_shortcut(ED_SHORTCUT("tile_map_editor/bucket_fill", TTR("Bucket Fill"), KEY_B));
bucket_fill_button->connect("pressed", callable_mp(this, &TileMapEditor::_button_tool_select), make_binds(TOOL_BUCKET));
bucket_fill_button->set_toggle_mode(true);
toolbar->add_child(bucket_fill_button);
picker_button = memnew(ToolButton);
picker_button = memnew(Button);
picker_button->set_flat(true);
picker_button->set_shortcut(ED_SHORTCUT("tile_map_editor/pick_tile", TTR("Pick Tile"), KEY_I));
picker_button->connect("pressed", callable_mp(this, &TileMapEditor::_button_tool_select), make_binds(TOOL_PICKING));
picker_button->set_toggle_mode(true);
toolbar->add_child(picker_button);
select_button = memnew(ToolButton);
select_button = memnew(Button);
select_button->set_flat(true);
select_button->set_shortcut(ED_SHORTCUT("tile_map_editor/select", TTR("Select"), KEY_M));
select_button->connect("pressed", callable_mp(this, &TileMapEditor::_button_tool_select), make_binds(TOOL_SELECTING));
select_button->set_toggle_mode(true);
@ -2017,35 +2021,40 @@ TileMapEditor::TileMapEditor(EditorNode *p_editor) {
p->add_item(TTR("Fix Invalid Tiles"), OPTION_FIX_INVALID);
p->connect("id_pressed", callable_mp(this, &TileMapEditor::_menu_option));
rotate_left_button = memnew(ToolButton);
rotate_left_button = memnew(Button);
rotate_left_button->set_flat(true);
rotate_left_button->set_tooltip(TTR("Rotate Left"));
rotate_left_button->set_focus_mode(FOCUS_NONE);
rotate_left_button->connect("pressed", callable_mp(this, &TileMapEditor::_rotate), varray(-1));
rotate_left_button->set_shortcut(ED_SHORTCUT("tile_map_editor/rotate_left", TTR("Rotate Left"), KEY_A));
tool_hb->add_child(rotate_left_button);
rotate_right_button = memnew(ToolButton);
rotate_right_button = memnew(Button);
rotate_right_button->set_flat(true);
rotate_right_button->set_tooltip(TTR("Rotate Right"));
rotate_right_button->set_focus_mode(FOCUS_NONE);
rotate_right_button->connect("pressed", callable_mp(this, &TileMapEditor::_rotate), varray(1));
rotate_right_button->set_shortcut(ED_SHORTCUT("tile_map_editor/rotate_right", TTR("Rotate Right"), KEY_S));
tool_hb->add_child(rotate_right_button);
flip_horizontal_button = memnew(ToolButton);
flip_horizontal_button = memnew(Button);
flip_horizontal_button->set_flat(true);
flip_horizontal_button->set_tooltip(TTR("Flip Horizontally"));
flip_horizontal_button->set_focus_mode(FOCUS_NONE);
flip_horizontal_button->connect("pressed", callable_mp(this, &TileMapEditor::_flip_horizontal));
flip_horizontal_button->set_shortcut(ED_SHORTCUT("tile_map_editor/flip_horizontal", TTR("Flip Horizontally"), KEY_X));
tool_hb->add_child(flip_horizontal_button);
flip_vertical_button = memnew(ToolButton);
flip_vertical_button = memnew(Button);
flip_vertical_button->set_flat(true);
flip_vertical_button->set_tooltip(TTR("Flip Vertically"));
flip_vertical_button->set_focus_mode(FOCUS_NONE);
flip_vertical_button->connect("pressed", callable_mp(this, &TileMapEditor::_flip_vertical));
flip_vertical_button->set_shortcut(ED_SHORTCUT("tile_map_editor/flip_vertical", TTR("Flip Vertically"), KEY_Z));
tool_hb->add_child(flip_vertical_button);
clear_transform_button = memnew(ToolButton);
clear_transform_button = memnew(Button);
clear_transform_button->set_flat(true);
clear_transform_button->set_tooltip(TTR("Clear Transform"));
clear_transform_button->set_focus_mode(FOCUS_NONE);
clear_transform_button->connect("pressed", callable_mp(this, &TileMapEditor::_clear_transform));

19
editor/plugins/tile_map_editor_plugin.h
View file

@ -38,7 +38,6 @@
#include "scene/gui/label.h"
#include "scene/gui/line_edit.h"
#include "scene/gui/menu_button.h"
#include "scene/gui/tool_button.h"
class TileMapEditor : public VBoxContainer {
GDCLASS(TileMapEditor, VBoxContainer);
@ -88,16 +87,16 @@ class TileMapEditor : public VBoxContainer {
Label *tile_info;
MenuButton *options;
ToolButton *paint_button;
ToolButton *bucket_fill_button;
ToolButton *picker_button;
ToolButton *select_button;
Button *paint_button;
Button *bucket_fill_button;
Button *picker_button;
Button *select_button;
ToolButton *flip_horizontal_button;
ToolButton *flip_vertical_button;
ToolButton *rotate_left_button;
ToolButton *rotate_right_button;
ToolButton *clear_transform_button;
Button *flip_horizontal_button;
Button *flip_vertical_button;
Button *rotate_left_button;
Button *rotate_right_button;
Button *clear_transform_button;
CheckBox *manual_button;
CheckBox *priority_button;

36
editor/plugins/tile_set_editor_plugin.cpp
View file

@ -341,12 +341,12 @@ TileSetEditor::TileSetEditor(EditorNode *p_editor) {
HBoxContainer *tileset_toolbar_container = memnew(HBoxContainer);
left_container->add_child(tileset_toolbar_container);
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE] = memnew(ToolButton);
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE] = memnew(Button);
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tileset_toolbar_button_pressed), varray(TOOL_TILESET_ADD_TEXTURE));
tileset_toolbar_container->add_child(tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]);
tileset_toolbar_buttons[TOOL_TILESET_ADD_TEXTURE]->set_tooltip(TTR("Add Texture(s) to TileSet."));
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE] = memnew(ToolButton);
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE] = memnew(Button);
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tileset_toolbar_button_pressed), varray(TOOL_TILESET_REMOVE_TEXTURE));
tileset_toolbar_container->add_child(tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]);
tileset_toolbar_buttons[TOOL_TILESET_REMOVE_TEXTURE]->set_tooltip(TTR("Remove selected Texture from TileSet."));
@ -402,13 +402,13 @@ TileSetEditor::TileSetEditor(EditorNode *p_editor) {
tool_hb->add_child(spacer);
tool_hb->move_child(spacer, WORKSPACE_CREATE_SINGLE);
tools[SELECT_NEXT] = memnew(ToolButton);
tools[SELECT_NEXT] = memnew(Button);
tool_hb->add_child(tools[SELECT_NEXT]);
tool_hb->move_child(tools[SELECT_NEXT], WORKSPACE_CREATE_SINGLE);
tools[SELECT_NEXT]->set_shortcut(ED_SHORTCUT("tileset_editor/next_shape", TTR("Next Coordinate"), KEY_PAGEDOWN));
tools[SELECT_NEXT]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tool_clicked), varray(SELECT_NEXT));
tools[SELECT_NEXT]->set_tooltip(TTR("Select the next shape, subtile, or Tile."));
tools[SELECT_PREVIOUS] = memnew(ToolButton);
tools[SELECT_PREVIOUS] = memnew(Button);
tool_hb->add_child(tools[SELECT_PREVIOUS]);
tool_hb->move_child(tools[SELECT_PREVIOUS], WORKSPACE_CREATE_SINGLE);
tools[SELECT_PREVIOUS]->set_shortcut(ED_SHORTCUT("tileset_editor/previous_shape", TTR("Previous Coordinate"), KEY_PAGEUP));
@ -465,7 +465,7 @@ TileSetEditor::TileSetEditor(EditorNode *p_editor) {
toolbar = memnew(HBoxContainer);
Ref<ButtonGroup> tg(memnew(ButtonGroup));
tools[TOOL_SELECT] = memnew(ToolButton);
tools[TOOL_SELECT] = memnew(Button);
toolbar->add_child(tools[TOOL_SELECT]);
tools[TOOL_SELECT]->set_toggle_mode(true);
tools[TOOL_SELECT]->set_button_group(tg);
@ -474,27 +474,27 @@ TileSetEditor::TileSetEditor(EditorNode *p_editor) {
separator_bitmask = memnew(VSeparator);
toolbar->add_child(separator_bitmask);
tools[BITMASK_COPY] = memnew(ToolButton);
tools[BITMASK_COPY] = memnew(Button);
tools[BITMASK_COPY]->set_tooltip(TTR("Copy bitmask."));
tools[BITMASK_COPY]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tool_clicked), varray(BITMASK_COPY));
toolbar->add_child(tools[BITMASK_COPY]);
tools[BITMASK_PASTE] = memnew(ToolButton);
tools[BITMASK_PASTE] = memnew(Button);
tools[BITMASK_PASTE]->set_tooltip(TTR("Paste bitmask."));
tools[BITMASK_PASTE]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tool_clicked), varray(BITMASK_PASTE));
toolbar->add_child(tools[BITMASK_PASTE]);
tools[BITMASK_CLEAR] = memnew(ToolButton);
tools[BITMASK_CLEAR] = memnew(Button);
tools[BITMASK_CLEAR]->set_tooltip(TTR("Erase bitmask."));
tools[BITMASK_CLEAR]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tool_clicked), varray(BITMASK_CLEAR));
toolbar->add_child(tools[BITMASK_CLEAR]);
tools[SHAPE_NEW_RECTANGLE] = memnew(ToolButton);
tools[SHAPE_NEW_RECTANGLE] = memnew(Button);
toolbar->add_child(tools[SHAPE_NEW_RECTANGLE]);
tools[SHAPE_NEW_RECTANGLE]->set_toggle_mode(true);
tools[SHAPE_NEW_RECTANGLE]->set_button_group(tg);
tools[SHAPE_NEW_RECTANGLE]->set_tooltip(TTR("Create a new rectangle."));
tools[SHAPE_NEW_RECTANGLE]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tool_clicked), varray(SHAPE_NEW_RECTANGLE));
tools[SHAPE_NEW_POLYGON] = memnew(ToolButton);
tools[SHAPE_NEW_POLYGON] = memnew(Button);
toolbar->add_child(tools[SHAPE_NEW_POLYGON]);
tools[SHAPE_NEW_POLYGON]->set_toggle_mode(true);
tools[SHAPE_NEW_POLYGON]->set_button_group(tg);
@ -503,13 +503,13 @@ TileSetEditor::TileSetEditor(EditorNode *p_editor) {
separator_shape_toggle = memnew(VSeparator);
toolbar->add_child(separator_shape_toggle);
tools[SHAPE_TOGGLE_TYPE] = memnew(ToolButton);
tools[SHAPE_TOGGLE_TYPE] = memnew(Button);
tools[SHAPE_TOGGLE_TYPE]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tool_clicked), varray(SHAPE_TOGGLE_TYPE));
toolbar->add_child(tools[SHAPE_TOGGLE_TYPE]);
separator_delete = memnew(VSeparator);
toolbar->add_child(separator_delete);
tools[SHAPE_DELETE] = memnew(ToolButton);
tools[SHAPE_DELETE] = memnew(Button);
tools[SHAPE_DELETE]->connect("pressed", callable_mp(this, &TileSetEditor::_on_tool_clicked), varray(SHAPE_DELETE));
toolbar->add_child(tools[SHAPE_DELETE]);
@ -533,12 +533,12 @@ TileSetEditor::TileSetEditor(EditorNode *p_editor) {
separator_grid = memnew(VSeparator);
toolbar->add_child(separator_grid);
tools[SHAPE_KEEP_INSIDE_TILE] = memnew(ToolButton);
tools[SHAPE_KEEP_INSIDE_TILE] = memnew(Button);
tools[SHAPE_KEEP_INSIDE_TILE]->set_toggle_mode(true);
tools[SHAPE_KEEP_INSIDE_TILE]->set_pressed(true);
tools[SHAPE_KEEP_INSIDE_TILE]->set_tooltip(TTR("Keep polygon inside region Rect."));
toolbar->add_child(tools[SHAPE_KEEP_INSIDE_TILE]);
tools[TOOL_GRID_SNAP] = memnew(ToolButton);
tools[TOOL_GRID_SNAP] = memnew(Button);
tools[TOOL_GRID_SNAP]->set_toggle_mode(true);
tools[TOOL_GRID_SNAP]->set_tooltip(TTR("Enable snap and show grid (configurable via the Inspector)."));
tools[TOOL_GRID_SNAP]->connect("toggled", callable_mp(this, &TileSetEditor::_on_grid_snap_toggled));
@ -548,20 +548,20 @@ TileSetEditor::TileSetEditor(EditorNode *p_editor) {
separator->set_h_size_flags(SIZE_EXPAND_FILL);
toolbar->add_child(separator);
tools[ZOOM_OUT] = memnew(ToolButton);
tools[ZOOM_OUT] = memnew(Button);
tools[ZOOM_OUT]->connect("pressed", callable_mp(this, &TileSetEditor::_zoom_out));
toolbar->add_child(tools[ZOOM_OUT]);
tools[ZOOM_OUT]->set_tooltip(TTR("Zoom Out"));
tools[ZOOM_1] = memnew(ToolButton);
tools[ZOOM_1] = memnew(Button);
tools[ZOOM_1]->connect("pressed", callable_mp(this, &TileSetEditor::_zoom_reset));
toolbar->add_child(tools[ZOOM_1]);
tools[ZOOM_1]->set_tooltip(TTR("Zoom Reset"));
tools[ZOOM_IN] = memnew(ToolButton);
tools[ZOOM_IN] = memnew(Button);
tools[ZOOM_IN]->connect("pressed", callable_mp(this, &TileSetEditor::_zoom_in));
toolbar->add_child(tools[ZOOM_IN]);
tools[ZOOM_IN]->set_tooltip(TTR("Zoom In"));
tools[VISIBLE_INFO] = memnew(ToolButton);
tools[VISIBLE_INFO] = memnew(Button);
tools[VISIBLE_INFO]->set_toggle_mode(true);
tools[VISIBLE_INFO]->set_tooltip(TTR("Display Tile Names (Hold Alt Key)"));
toolbar->add_child(tools[VISIBLE_INFO]);

6
editor/plugins/tile_set_editor_plugin.h
View file

@ -46,7 +46,7 @@ class TileSetEditor : public HSplitContainer {
GDCLASS(TileSetEditor, HSplitContainer);
enum TextureToolButtons {
enum TextureButtons {
TOOL_TILESET_ADD_TEXTURE,
TOOL_TILESET_REMOVE_TEXTURE,
TOOL_TILESET_CREATE_SCENE,
@ -111,7 +111,7 @@ class TileSetEditor : public HSplitContainer {
ItemList *texture_list;
int option;
ToolButton *tileset_toolbar_buttons[TOOL_TILESET_MAX];
Button *tileset_toolbar_buttons[TOOL_TILESET_MAX];
MenuButton *tileset_toolbar_tools;
Map<RID, Ref<Texture2D>> texture_map;
@ -146,7 +146,7 @@ class TileSetEditor : public HSplitContainer {
Button *tool_editmode[EDITMODE_MAX];
HSeparator *separator_editmode;
HBoxContainer *toolbar;
ToolButton *tools[TOOL_MAX];
Button *tools[TOOL_MAX];
VSeparator *separator_shape_toggle;
VSeparator *separator_bitmask;
VSeparator *separator_delete;

2
editor/plugins/version_control_editor_plugin.cpp
View file

@ -300,7 +300,7 @@ void VersionControlEditorPlugin::register_editor() {
TabContainer *dock_vbc = (TabContainer *)version_commit_dock->get_parent_control();
dock_vbc->set_tab_title(version_commit_dock->get_index(), TTR("Commit"));
ToolButton *vc = EditorNode::get_singleton()->add_bottom_panel_item(TTR("Version Control"), version_control_dock);
Button *vc = EditorNode::get_singleton()->add_bottom_panel_item(TTR("Version Control"), version_control_dock);
set_version_control_tool_button(vc);
}
}

4
editor/plugins/version_control_editor_plugin.h
View file

@ -90,7 +90,7 @@ private:
Label *commit_status;
PanelContainer *version_control_dock;
ToolButton *version_control_dock_button;
Button *version_control_dock_button;
VBoxContainer *diff_vbc;
HBoxContainer *diff_hbc;
Button *diff_refresh_button;
@ -121,7 +121,7 @@ public:
static VersionControlEditorPlugin *get_singleton();
void popup_vcs_set_up_dialog(const Control *p_gui_base);
void set_version_control_tool_button(ToolButton *p_button) { version_control_dock_button = p_button; }
void set_version_control_tool_button(Button *p_button) { version_control_dock_button = p_button; }
PopupMenu *get_version_control_actions_panel() const { return version_control_actions; }
VBoxContainer *get_version_commit_dock() const { return version_commit_dock; }

6
editor/plugins/visual_shader_editor_plugin.cpp
View file

@ -2341,13 +2341,15 @@ VisualShaderEditor::VisualShaderEditor() {
graph->get_zoom_hbox()->add_child(edit_type);
graph->get_zoom_hbox()->move_child(edit_type, 0);
add_node = memnew(ToolButton);
add_node = memnew(Button);
add_node->set_flat(true);
graph->get_zoom_hbox()->add_child(add_node);
add_node->set_text(TTR("Add Node..."));
graph->get_zoom_hbox()->move_child(add_node, 0);
add_node->connect("pressed", callable_mp(this, &VisualShaderEditor::_show_members_dialog), varray(false));
preview_shader = memnew(ToolButton);
preview_shader = memnew(Button);
preview_shader->set_flat(true);
preview_shader->set_toggle_mode(true);
preview_shader->set_tooltip(TTR("Show resulted shader code."));
graph->get_zoom_hbox()->add_child(preview_shader);

4
editor/plugins/visual_shader_editor_plugin.h
View file

@ -60,8 +60,8 @@ class VisualShaderEditor : public VBoxContainer {
Ref<VisualShader> visual_shader;
HSplitContainer *main_box;
GraphEdit *graph;
ToolButton *add_node;
ToolButton *preview_shader;
Button *add_node;
Button *preview_shader;
OptionButton *edit_type;

6
editor/project_export.cpp
View file

@ -1064,10 +1064,12 @@ ProjectExportDialog::ProjectExportDialog() {
//presets->set_drag_forwarding(this);
mc->add_child(presets);
presets->connect("item_selected", callable_mp(this, &ProjectExportDialog::_edit_preset));
duplicate_preset = memnew(ToolButton);
duplicate_preset = memnew(Button);
duplicate_preset->set_flat(true);
preset_hb->add_child(duplicate_preset);
duplicate_preset->connect("pressed", callable_mp(this, &ProjectExportDialog::_duplicate_preset));
delete_preset = memnew(ToolButton);
delete_preset = memnew(Button);
delete_preset->set_flat(true);
preset_hb->add_child(delete_preset);
delete_preset->connect("pressed", callable_mp(this, &ProjectExportDialog::_delete_preset));

1
editor/project_manager.cpp
View file

@ -50,7 +50,6 @@
#include "scene/gui/panel_container.h"
#include "scene/gui/separator.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tool_button.h"
#include "scene/main/window.h"
#include "servers/display_server.h"

1
editor/project_manager.h
View file

@ -35,7 +35,6 @@
#include "scene/gui/dialogs.h"
#include "scene/gui/file_dialog.h"
#include "scene/gui/scroll_container.h"
#include "scene/gui/tool_button.h"
#include "scene/gui/tree.h"
class ProjectDialog;

3
editor/project_settings_editor.cpp
View file

@ -1872,7 +1872,8 @@ ProjectSettingsEditor::ProjectSettingsEditor(EditorData *p_data) {
restart_button->connect("pressed", callable_mp(this, &ProjectSettingsEditor::_editor_restart));
restart_hb->add_child(restart_button);
restart_button->set_text(TTR("Save & Restart"));
restart_close_button = memnew(ToolButton);
restart_close_button = memnew(Button);
restart_close_button->set_flat(true);
restart_close_button->connect("pressed", callable_mp(this, &ProjectSettingsEditor::_editor_restart_close));
restart_hb->add_child(restart_close_button);
restart_container->hide();

2
editor/project_settings_editor.h
View file

@ -174,7 +174,7 @@ class ProjectSettingsEditor : public AcceptDialog {
Label *restart_label;
TextureRect *restart_icon;
PanelContainer *restart_container;
ToolButton *restart_close_button;
Button *restart_close_button;
void _editor_restart_request();
void _editor_restart();

21
editor/scene_tree_dock.cpp
View file

@ -1076,7 +1076,8 @@ void SceneTreeDock::_notification(int p_what) {
top_row->add_child(memnew(Label(TTR("Create Root Node:"))));
top_row->add_spacer();
ToolButton *node_shortcuts_toggle = memnew(ToolButton);
Button *node_shortcuts_toggle = memnew(Button);
node_shortcuts_toggle->set_flat(true);
node_shortcuts_toggle->set_name("NodeShortcutsToggle");
node_shortcuts_toggle->set_icon(get_theme_icon("Favorites", "EditorIcons"));
node_shortcuts_toggle->set_toggle_mode(true);
@ -2801,13 +2802,15 @@ SceneTreeDock::SceneTreeDock(EditorNode *p_editor, Node *p_scene_root, EditorSel
ED_SHORTCUT("scene_tree/delete_no_confirm", TTR("Delete (No Confirm)"), KEY_MASK_SHIFT | KEY_DELETE);
ED_SHORTCUT("scene_tree/delete", TTR("Delete"), KEY_DELETE);
button_add = memnew(ToolButton);
button_add = memnew(Button);
button_add->set_flat(true);
button_add->connect("pressed", callable_mp(this, &SceneTreeDock::_tool_selected), make_binds(TOOL_NEW, false));
button_add->set_tooltip(TTR("Add/Create a New Node."));
button_add->set_shortcut(ED_GET_SHORTCUT("scene_tree/add_child_node"));
filter_hbc->add_child(button_add);
button_instance = memnew(ToolButton);
button_instance = memnew(Button);
button_instance->set_flat(true);
button_instance->connect("pressed", callable_mp(this, &SceneTreeDock::_tool_selected), make_binds(TOOL_INSTANCE, false));
button_instance->set_tooltip(TTR("Instance a scene file as a Node. Creates an inherited scene if no root node exists."));
button_instance->set_shortcut(ED_GET_SHORTCUT("scene_tree/instance_scene"));
@ -2821,14 +2824,16 @@ SceneTreeDock::SceneTreeDock(EditorNode *p_editor, Node *p_scene_root, EditorSel
filter->add_theme_constant_override("minimum_spaces", 0);
filter->connect("text_changed", callable_mp(this, &SceneTreeDock::_filter_changed));
button_create_script = memnew(ToolButton);
button_create_script = memnew(Button);
button_create_script->set_flat(true);
button_create_script->connect("pressed", callable_mp(this, &SceneTreeDock::_tool_selected), make_binds(TOOL_ATTACH_SCRIPT, false));
button_create_script->set_tooltip(TTR("Attach a new or existing script to the selected node."));
button_create_script->set_shortcut(ED_GET_SHORTCUT("scene_tree/attach_script"));
filter_hbc->add_child(button_create_script);
button_create_script->hide();
button_detach_script = memnew(ToolButton);
button_detach_script = memnew(Button);
button_detach_script->set_flat(true);
button_detach_script->connect("pressed", callable_mp(this, &SceneTreeDock::_tool_selected), make_binds(TOOL_DETACH_SCRIPT, false));
button_detach_script->set_tooltip(TTR("Detach the script from the selected node."));
button_detach_script->set_shortcut(ED_GET_SHORTCUT("scene_tree/detach_script"));
@ -2838,14 +2843,16 @@ SceneTreeDock::SceneTreeDock(EditorNode *p_editor, Node *p_scene_root, EditorSel
button_hb = memnew(HBoxContainer);
vbc->add_child(button_hb);
edit_remote = memnew(ToolButton);
edit_remote = memnew(Button);
edit_remote->set_flat(true);
button_hb->add_child(edit_remote);
edit_remote->set_h_size_flags(SIZE_EXPAND_FILL);
edit_remote->set_text(TTR("Remote"));
edit_remote->set_toggle_mode(true);
edit_remote->connect("pressed", callable_mp(this, &SceneTreeDock::_remote_tree_selected));
edit_local = memnew(ToolButton);
edit_local = memnew(Button);
edit_local->set_flat(true);
button_hb->add_child(edit_local);
edit_local->set_h_size_flags(SIZE_EXPAND_FILL);
edit_local->set_text(TTR("Local"));

11
editor/scene_tree_dock.h
View file

@ -46,7 +46,6 @@
#include "scene/gui/control.h"
#include "scene/gui/label.h"
#include "scene/gui/popup_menu.h"
#include "scene/gui/tool_button.h"
#include "scene/gui/tree.h"
#include "scene_tree_editor.h"
@ -106,15 +105,15 @@ class SceneTreeDock : public VBoxContainer {
CreateDialog *create_dialog;
RenameDialog *rename_dialog;
ToolButton *button_add;
ToolButton *button_instance;
ToolButton *button_create_script;
ToolButton *button_detach_script;
Button *button_add;
Button *button_instance;
Button *button_create_script;
Button *button_detach_script;
Button *button_3d;
HBoxContainer *button_hb;
ToolButton *edit_local, *edit_remote;
Button *edit_local, *edit_remote;
SceneTreeEditor *scene_tree;
Control *remote_tree;

3
editor/settings_config_dialog.cpp
View file

@ -432,7 +432,8 @@ EditorSettingsDialog::EditorSettingsDialog() {
restart_button->connect("pressed", callable_mp(this, &EditorSettingsDialog::_editor_restart));
restart_hb->add_child(restart_button);
restart_button->set_text(TTR("Save & Restart"));
restart_close_button = memnew(ToolButton);
restart_close_button = memnew(Button);
restart_close_button->set_flat(true);
restart_close_button->connect("pressed", callable_mp(this, &EditorSettingsDialog::_editor_restart_close));
restart_hb->add_child(restart_close_button);
restart_container->hide();

3
editor/settings_config_dialog.h
View file

@ -38,7 +38,6 @@
#include "scene/gui/rich_text_label.h"
#include "scene/gui/tab_container.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tool_button.h"
class EditorSettingsDialog : public AcceptDialog {
GDCLASS(EditorSettingsDialog, AcceptDialog);
@ -94,7 +93,7 @@ class EditorSettingsDialog : public AcceptDialog {
Label *restart_label;
TextureRect *restart_icon;
PanelContainer *restart_container;
ToolButton *restart_close_button;
Button *restart_close_button;
void _editor_restart_request();
void _editor_restart();

6
modules/gdnavigation/navigation_mesh_editor_plugin.cpp
View file

@ -95,13 +95,15 @@ void NavigationMeshEditor::_bind_methods() {
NavigationMeshEditor::NavigationMeshEditor() {
bake_hbox = memnew(HBoxContainer);
button_bake = memnew(ToolButton);
button_bake = memnew(Button);
button_bake->set_flat(true);
bake_hbox->add_child(button_bake);
button_bake->set_toggle_mode(true);
button_bake->set_text(TTR("Bake NavMesh"));
button_bake->connect("pressed", callable_mp(this, &NavigationMeshEditor::_bake_pressed));
button_reset = memnew(ToolButton);
button_reset = memnew(Button);
button_reset->set_flat(true);
bake_hbox->add_child(button_reset);
// No button text, we only use a revert icon which is set when entering the tree.
button_reset->set_tooltip(TTR("Clear the navigation mesh."));

4
modules/gdnavigation/navigation_mesh_editor_plugin.h
View file

@ -46,8 +46,8 @@ class NavigationMeshEditor : public Control {
AcceptDialog *err_dialog;
HBoxContainer *bake_hbox;
ToolButton *button_bake;
ToolButton *button_reset;
Button *button_bake;
Button *button_reset;
Label *bake_info;
NavigationRegion3D *node;

6
modules/gridmap/grid_map_editor_plugin.cpp
View file

@ -1241,14 +1241,16 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
search_box->connect("text_changed", callable_mp(this, &GridMapEditor::_text_changed));
search_box->connect("gui_input", callable_mp(this, &GridMapEditor::_sbox_input));
mode_thumbnail = memnew(ToolButton);
mode_thumbnail = memnew(Button);
mode_thumbnail->set_flat(true);
mode_thumbnail->set_toggle_mode(true);
mode_thumbnail->set_pressed(true);
mode_thumbnail->set_icon(p_editor->get_gui_base()->get_theme_icon("FileThumbnail", "EditorIcons"));
hb->add_child(mode_thumbnail);
mode_thumbnail->connect("pressed", callable_mp(this, &GridMapEditor::_set_display_mode), varray(DISPLAY_THUMBNAIL));
mode_list = memnew(ToolButton);
mode_list = memnew(Button);
mode_list->set_flat(true);
mode_list->set_toggle_mode(true);
mode_list->set_pressed(false);
mode_list->set_icon(p_editor->get_gui_base()->get_theme_icon("FileList", "EditorIcons"));

4
modules/gridmap/grid_map_editor_plugin.h
View file

@ -74,8 +74,8 @@ class GridMapEditor : public VBoxContainer {
MenuButton *options;
SpinBox *floor;
double accumulated_floor_delta;
ToolButton *mode_thumbnail;
ToolButton *mode_list;
Button *mode_thumbnail;
Button *mode_list;
LineEdit *search_box;
HSlider *size_slider;
HBoxContainer *spatial_editor_hb;

8
modules/mono/editor/GodotTools/GodotTools/BottomPanel.cs
View file

@ -20,8 +20,8 @@ namespace GodotTools
private ItemList buildTabsList;
private TabContainer buildTabs;
private ToolButton warningsBtn;
private ToolButton errorsBtn;
private Button warningsBtn;
private Button errorsBtn;
private Button viewLogBtn;
private void _UpdateBuildTabsList()
@ -285,7 +285,7 @@ namespace GodotTools
toolBarHBox.AddSpacer(begin: false);
warningsBtn = new ToolButton
warningsBtn = new Button
{
Text = "Warnings".TTR(),
ToggleMode = true,
@ -296,7 +296,7 @@ namespace GodotTools
warningsBtn.Toggled += _WarningsToggled;
toolBarHBox.AddChild(warningsBtn);
errorsBtn = new ToolButton
errorsBtn = new Button
{
Text = "Errors".TTR(),
ToggleMode = true,

4
modules/mono/editor/GodotTools/GodotTools/GodotSharpEditor.cs
View file

@ -30,7 +30,7 @@ namespace GodotTools
private AcceptDialog aboutDialog;
private CheckBox aboutDialogCheckBox;
private ToolButton bottomPanelBtn;
private Button bottomPanelBtn;
public GodotIdeManager GodotIdeManager { get; private set; }
@ -513,7 +513,7 @@ namespace GodotTools
menuPopup.IdPressed += _MenuOptionPressed;
var buildButton = new ToolButton
var buildButton = new Button
{
Text = "Build",
HintTooltip = "Build solution",

3
scene/gui/color_picker.cpp
View file

@ -758,7 +758,8 @@ ColorPicker::ColorPicker() :
sample->set_h_size_flags(SIZE_EXPAND_FILL);
sample->connect("draw", callable_mp(this, &ColorPicker::_sample_draw));
btn_pick = memnew(ToolButton);
btn_pick = memnew(Button);
btn_pick->set_flat(true);
hb_smpl->add_child(btn_pick);
btn_pick->set_toggle_mode(true);
btn_pick->set_tooltip(TTR("Pick a color from the editor window."));

3
scene/gui/color_picker.h
View file

@ -41,7 +41,6 @@
#include "scene/gui/slider.h"
#include "scene/gui/spin_box.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tool_button.h"
class ColorPicker : public BoxContainer {
GDCLASS(ColorPicker, BoxContainer);
@ -57,7 +56,7 @@ private:
HSeparator *preset_separator;
Button *bt_add_preset;
List<Color> presets;
ToolButton *btn_pick;
Button *btn_pick;
CheckButton *btn_hsv;
CheckButton *btn_raw;
HSlider *scroll[4];

15
scene/gui/file_dialog.cpp
View file

@ -45,9 +45,9 @@ VBoxContainer *FileDialog::get_vbox() {
}
void FileDialog::_theme_changed() {
Color font_color = vbox->get_theme_color("font_color", "ToolButton");
Color font_color_hover = vbox->get_theme_color("font_color_hover", "ToolButton");
Color font_color_pressed = vbox->get_theme_color("font_color_pressed", "ToolButton");
Color font_color = vbox->get_theme_color("font_color", "Button");
Color font_color_hover = vbox->get_theme_color("font_color_hover", "Button");
Color font_color_pressed = vbox->get_theme_color("font_color_pressed", "Button");
dir_up->add_theme_color_override("icon_color_normal", font_color);
dir_up->add_theme_color_override("icon_color_hover", font_color_hover);
@ -859,7 +859,8 @@ FileDialog::FileDialog() {
HBoxContainer *hbc = memnew(HBoxContainer);
dir_up = memnew(ToolButton);
dir_up = memnew(Button);
dir_up->set_flat(true);
dir_up->set_tooltip(RTR("Go to parent folder."));
hbc->add_child(dir_up);
dir_up->connect("pressed", callable_mp(this, &FileDialog::_go_up));
@ -877,12 +878,14 @@ FileDialog::FileDialog() {
hbc->add_child(dir);
dir->set_h_size_flags(Control::SIZE_EXPAND_FILL);
refresh = memnew(ToolButton);
refresh = memnew(Button);
refresh->set_flat(true);
refresh->set_tooltip(RTR("Refresh files."));
refresh->connect("pressed", callable_mp(this, &FileDialog::update_file_list));
hbc->add_child(refresh);
show_hidden = memnew(ToolButton);
show_hidden = memnew(Button);
show_hidden->set_flat(true);
show_hidden->set_toggle_mode(true);
show_hidden->set_pressed(is_showing_hidden_files());
show_hidden->set_tooltip(RTR("Toggle the visibility of hidden files."));

7
scene/gui/file_dialog.h
View file

@ -36,7 +36,6 @@
#include "scene/gui/dialogs.h"
#include "scene/gui/line_edit.h"
#include "scene/gui/option_button.h"
#include "scene/gui/tool_button.h"
#include "scene/gui/tree.h"
class FileDialog : public ConfirmationDialog {
@ -87,10 +86,10 @@ private:
DirAccess *dir_access;
ConfirmationDialog *confirm_save;
ToolButton *dir_up;
Button *dir_up;
ToolButton *refresh;
ToolButton *show_hidden;
Button *refresh;
Button *show_hidden;
Vector<String> filters;

13
scene/gui/graph_edit.cpp
View file

@ -33,6 +33,7 @@
#include "core/input/input.h"
#include "core/os/keyboard.h"
#include "scene/gui/box_container.h"
#include "scene/gui/button.h"
#ifdef TOOLS_ENABLED
#include "editor/editor_scale.h"
@ -1310,25 +1311,29 @@ GraphEdit::GraphEdit() {
top_layer->add_child(zoom_hb);
zoom_hb->set_position(Vector2(10, 10));
zoom_minus = memnew(ToolButton);
zoom_minus = memnew(Button);
zoom_minus->set_flat(true);
zoom_hb->add_child(zoom_minus);
zoom_minus->set_tooltip(RTR("Zoom Out"));
zoom_minus->connect("pressed", callable_mp(this, &GraphEdit::_zoom_minus));
zoom_minus->set_focus_mode(FOCUS_NONE);
zoom_reset = memnew(ToolButton);
zoom_reset = memnew(Button);
zoom_reset->set_flat(true);
zoom_hb->add_child(zoom_reset);
zoom_reset->set_tooltip(RTR("Zoom Reset"));
zoom_reset->connect("pressed", callable_mp(this, &GraphEdit::_zoom_reset));
zoom_reset->set_focus_mode(FOCUS_NONE);
zoom_plus = memnew(ToolButton);
zoom_plus = memnew(Button);
zoom_plus->set_flat(true);
zoom_hb->add_child(zoom_plus);
zoom_plus->set_tooltip(RTR("Zoom In"));
zoom_plus->connect("pressed", callable_mp(this, &GraphEdit::_zoom_plus));
zoom_plus->set_focus_mode(FOCUS_NONE);
snap_button = memnew(ToolButton);
snap_button = memnew(Button);
snap_button->set_flat(true);
snap_button->set_toggle_mode(true);
snap_button->set_tooltip(RTR("Enable snap and show grid."));
snap_button->connect("pressed", callable_mp(this, &GraphEdit::_snap_toggled));

10
scene/gui/graph_edit.h
View file

@ -32,12 +32,12 @@
#define GRAPH_EDIT_H
#include "scene/gui/box_container.h"
#include "scene/gui/button.h"
#include "scene/gui/graph_node.h"
#include "scene/gui/scroll_bar.h"
#include "scene/gui/slider.h"
#include "scene/gui/spin_box.h"
#include "scene/gui/texture_rect.h"
#include "scene/gui/tool_button.h"
class GraphEdit;
@ -65,11 +65,11 @@ public:
};
private:
ToolButton *zoom_minus;
ToolButton *zoom_reset;
ToolButton *zoom_plus;
Button *zoom_minus;
Button *zoom_reset;
Button *zoom_plus;
ToolButton *snap_button;
Button *snap_button;
SpinBox *snap_amount;
void _zoom_minus();

35
scene/gui/tool_button.cpp
View file

@ -1,35 +0,0 @@
/*************************************************************************/
/* tool_button.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "tool_button.h"
ToolButton::ToolButton() {
set_flat(true);
}

Some files were not shown because too many files have changed in this diff Show more