editor_log.cpp 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519
  1. /**************************************************************************/
  2. /* editor_log.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /**************************************************************************/
  30. #include "editor_log.h"
  31. #include "core/object/undo_redo.h"
  32. #include "core/os/keyboard.h"
  33. #include "core/version.h"
  34. #include "editor/editor_node.h"
  35. #include "editor/editor_paths.h"
  36. #include "editor/editor_scale.h"
  37. #include "editor/editor_settings.h"
  38. #include "scene/gui/center_container.h"
  39. #include "scene/gui/separator.h"
  40. #include "scene/resources/font.h"
  41. void EditorLog::_error_handler(void *p_self, const char *p_func, const char *p_file, int p_line, const char *p_error, const char *p_errorexp, bool p_editor_notify, ErrorHandlerType p_type) {
  42. EditorLog *self = static_cast<EditorLog *>(p_self);
  43. String err_str;
  44. if (p_errorexp && p_errorexp[0]) {
  45. err_str = String::utf8(p_errorexp);
  46. } else {
  47. err_str = String::utf8(p_file) + ":" + itos(p_line) + " - " + String::utf8(p_error);
  48. }
  49. if (p_editor_notify) {
  50. err_str += " (User)";
  51. }
  52. MessageType message_type = p_type == ERR_HANDLER_WARNING ? MSG_TYPE_WARNING : MSG_TYPE_ERROR;
  53. if (self->current != Thread::get_caller_id()) {
  54. callable_mp(self, &EditorLog::add_message).bind(err_str, message_type).call_deferred();
  55. } else {
  56. self->add_message(err_str, message_type);
  57. }
  58. }
  59. void EditorLog::_update_theme() {
  60. const Ref<Font> normal_font = get_theme_font(SNAME("output_source"), SNAME("EditorFonts"));
  61. if (normal_font.is_valid()) {
  62. log->add_theme_font_override("normal_font", normal_font);
  63. }
  64. const Ref<Font> bold_font = get_theme_font(SNAME("output_source_bold"), SNAME("EditorFonts"));
  65. if (bold_font.is_valid()) {
  66. log->add_theme_font_override("bold_font", bold_font);
  67. }
  68. const Ref<Font> italics_font = get_theme_font(SNAME("output_source_italic"), SNAME("EditorFonts"));
  69. if (italics_font.is_valid()) {
  70. log->add_theme_font_override("italics_font", italics_font);
  71. }
  72. const Ref<Font> bold_italics_font = get_theme_font(SNAME("output_source_bold_italic"), SNAME("EditorFonts"));
  73. if (bold_italics_font.is_valid()) {
  74. log->add_theme_font_override("bold_italics_font", bold_italics_font);
  75. }
  76. const Ref<Font> mono_font = get_theme_font(SNAME("output_source_mono"), SNAME("EditorFonts"));
  77. if (mono_font.is_valid()) {
  78. log->add_theme_font_override("mono_font", mono_font);
  79. }
  80. // Disable padding for highlighted background/foreground to prevent highlights from overlapping on close lines.
  81. // This also better matches terminal output, which does not use any form of padding.
  82. log->add_theme_constant_override("text_highlight_h_padding", 0);
  83. log->add_theme_constant_override("text_highlight_v_padding", 0);
  84. const int font_size = get_theme_font_size(SNAME("output_source_size"), SNAME("EditorFonts"));
  85. log->add_theme_font_size_override("normal_font_size", font_size);
  86. log->add_theme_font_size_override("bold_font_size", font_size);
  87. log->add_theme_font_size_override("italics_font_size", font_size);
  88. log->add_theme_font_size_override("mono_font_size", font_size);
  89. type_filter_map[MSG_TYPE_STD]->toggle_button->set_icon(get_theme_icon(SNAME("Popup"), SNAME("EditorIcons")));
  90. type_filter_map[MSG_TYPE_ERROR]->toggle_button->set_icon(get_theme_icon(SNAME("StatusError"), SNAME("EditorIcons")));
  91. type_filter_map[MSG_TYPE_WARNING]->toggle_button->set_icon(get_theme_icon(SNAME("StatusWarning"), SNAME("EditorIcons")));
  92. type_filter_map[MSG_TYPE_EDITOR]->toggle_button->set_icon(get_theme_icon(SNAME("Edit"), SNAME("EditorIcons")));
  93. type_filter_map[MSG_TYPE_STD]->toggle_button->set_theme_type_variation("EditorLogFilterButton");
  94. type_filter_map[MSG_TYPE_ERROR]->toggle_button->set_theme_type_variation("EditorLogFilterButton");
  95. type_filter_map[MSG_TYPE_WARNING]->toggle_button->set_theme_type_variation("EditorLogFilterButton");
  96. type_filter_map[MSG_TYPE_EDITOR]->toggle_button->set_theme_type_variation("EditorLogFilterButton");
  97. clear_button->set_icon(get_theme_icon(SNAME("Clear"), SNAME("EditorIcons")));
  98. copy_button->set_icon(get_theme_icon(SNAME("ActionCopy"), SNAME("EditorIcons")));
  99. collapse_button->set_icon(get_theme_icon(SNAME("CombineLines"), SNAME("EditorIcons")));
  100. show_search_button->set_icon(get_theme_icon(SNAME("Search"), SNAME("EditorIcons")));
  101. search_box->set_right_icon(get_theme_icon(SNAME("Search"), SNAME("EditorIcons")));
  102. theme_cache.error_color = get_theme_color(SNAME("error_color"), SNAME("Editor"));
  103. theme_cache.error_icon = get_theme_icon(SNAME("Error"), SNAME("EditorIcons"));
  104. theme_cache.warning_color = get_theme_color(SNAME("warning_color"), SNAME("Editor"));
  105. theme_cache.warning_icon = get_theme_icon(SNAME("Warning"), SNAME("EditorIcons"));
  106. theme_cache.message_color = get_theme_color(SNAME("font_color"), SNAME("Editor")) * Color(1, 1, 1, 0.6);
  107. }
  108. void EditorLog::_notification(int p_what) {
  109. switch (p_what) {
  110. case NOTIFICATION_ENTER_TREE: {
  111. _update_theme();
  112. _load_state();
  113. } break;
  114. case NOTIFICATION_THEME_CHANGED: {
  115. _update_theme();
  116. _rebuild_log();
  117. } break;
  118. }
  119. }
  120. void EditorLog::_set_collapse(bool p_collapse) {
  121. collapse = p_collapse;
  122. _start_state_save_timer();
  123. _rebuild_log();
  124. }
  125. void EditorLog::_start_state_save_timer() {
  126. if (!is_loading_state) {
  127. save_state_timer->start();
  128. }
  129. }
  130. void EditorLog::_save_state() {
  131. Ref<ConfigFile> config;
  132. config.instantiate();
  133. // Load and amend existing config if it exists.
  134. config->load(EditorPaths::get_singleton()->get_project_settings_dir().path_join("editor_layout.cfg"));
  135. const String section = "editor_log";
  136. for (const KeyValue<MessageType, LogFilter *> &E : type_filter_map) {
  137. config->set_value(section, "log_filter_" + itos(E.key), E.value->is_active());
  138. }
  139. config->set_value(section, "collapse", collapse);
  140. config->set_value(section, "show_search", search_box->is_visible());
  141. config->save(EditorPaths::get_singleton()->get_project_settings_dir().path_join("editor_layout.cfg"));
  142. }
  143. void EditorLog::_load_state() {
  144. is_loading_state = true;
  145. Ref<ConfigFile> config;
  146. config.instantiate();
  147. config->load(EditorPaths::get_singleton()->get_project_settings_dir().path_join("editor_layout.cfg"));
  148. // Run the below code even if config->load returns an error, since we want the defaults to be set even if the file does not exist yet.
  149. const String section = "editor_log";
  150. for (const KeyValue<MessageType, LogFilter *> &E : type_filter_map) {
  151. E.value->set_active(config->get_value(section, "log_filter_" + itos(E.key), true));
  152. }
  153. collapse = config->get_value(section, "collapse", false);
  154. collapse_button->set_pressed(collapse);
  155. bool show_search = config->get_value(section, "show_search", true);
  156. search_box->set_visible(show_search);
  157. show_search_button->set_pressed(show_search);
  158. is_loading_state = false;
  159. }
  160. void EditorLog::_clear_request() {
  161. log->clear();
  162. messages.clear();
  163. _reset_message_counts();
  164. tool_button->set_icon(Ref<Texture2D>());
  165. }
  166. void EditorLog::_copy_request() {
  167. String text = log->get_selected_text();
  168. if (text.is_empty()) {
  169. text = log->get_parsed_text();
  170. }
  171. if (!text.is_empty()) {
  172. DisplayServer::get_singleton()->clipboard_set(text);
  173. }
  174. }
  175. void EditorLog::clear() {
  176. _clear_request();
  177. }
  178. void EditorLog::_process_message(const String &p_msg, MessageType p_type) {
  179. if (messages.size() > 0 && messages[messages.size() - 1].text == p_msg && messages[messages.size() - 1].type == p_type) {
  180. // If previous message is the same as the new one, increase previous count rather than adding another
  181. // instance to the messages list.
  182. LogMessage &previous = messages.write[messages.size() - 1];
  183. previous.count++;
  184. _add_log_line(previous, collapse);
  185. } else {
  186. // Different message to the previous one received.
  187. LogMessage message(p_msg, p_type);
  188. _add_log_line(message);
  189. messages.push_back(message);
  190. }
  191. type_filter_map[p_type]->set_message_count(type_filter_map[p_type]->get_message_count() + 1);
  192. }
  193. void EditorLog::add_message(const String &p_msg, MessageType p_type) {
  194. // Make text split by new lines their own message.
  195. // See #41321 for reasoning. At time of writing, multiple print()'s in running projects
  196. // get grouped together and sent to the editor log as one message. This can mess with the
  197. // search functionality (see the comments on the PR above for more details). This behavior
  198. // also matches that of other IDE's.
  199. Vector<String> lines = p_msg.split("\n", true);
  200. for (int i = 0; i < lines.size(); i++) {
  201. _process_message(lines[i], p_type);
  202. }
  203. }
  204. void EditorLog::set_tool_button(Button *p_tool_button) {
  205. tool_button = p_tool_button;
  206. }
  207. void EditorLog::register_undo_redo(UndoRedo *p_undo_redo) {
  208. p_undo_redo->set_commit_notify_callback(_undo_redo_cbk, this);
  209. }
  210. void EditorLog::_undo_redo_cbk(void *p_self, const String &p_name) {
  211. EditorLog *self = static_cast<EditorLog *>(p_self);
  212. self->add_message(p_name, EditorLog::MSG_TYPE_EDITOR);
  213. }
  214. void EditorLog::_rebuild_log() {
  215. log->clear();
  216. for (int msg_idx = 0; msg_idx < messages.size(); msg_idx++) {
  217. LogMessage msg = messages[msg_idx];
  218. if (collapse) {
  219. // If collapsing, only log one instance of the message.
  220. _add_log_line(msg);
  221. } else {
  222. // If not collapsing, log each instance on a line.
  223. for (int i = 0; i < msg.count; i++) {
  224. _add_log_line(msg);
  225. }
  226. }
  227. }
  228. }
  229. void EditorLog::_add_log_line(LogMessage &p_message, bool p_replace_previous) {
  230. if (!is_inside_tree()) {
  231. // The log will be built all at once when it enters the tree and has its theme items.
  232. return;
  233. }
  234. if (unlikely(log->is_updating())) {
  235. // The new message arrived during log RTL text processing/redraw (invalid BiDi control characters / font error), ignore it to avoid RTL data corruption.
  236. return;
  237. }
  238. // Only add the message to the log if it passes the filters.
  239. bool filter_active = type_filter_map[p_message.type]->is_active();
  240. String search_text = search_box->get_text();
  241. bool search_match = search_text.is_empty() || p_message.text.findn(search_text) > -1;
  242. if (!filter_active || !search_match) {
  243. return;
  244. }
  245. if (p_replace_previous) {
  246. // Remove last line if replacing, as it will be replace by the next added line.
  247. // Why "- 2"? RichTextLabel is weird. When you add a line with add_newline(), it also adds an element to the list of lines which is null/blank,
  248. // but it still counts as a line. So if you remove the last line (count - 1) you are actually removing nothing...
  249. log->remove_paragraph(log->get_paragraph_count() - 2);
  250. }
  251. switch (p_message.type) {
  252. case MSG_TYPE_STD: {
  253. } break;
  254. case MSG_TYPE_STD_RICH: {
  255. } break;
  256. case MSG_TYPE_ERROR: {
  257. log->push_color(theme_cache.error_color);
  258. Ref<Texture2D> icon = theme_cache.error_icon;
  259. log->add_image(icon);
  260. log->add_text(" ");
  261. tool_button->set_icon(icon);
  262. } break;
  263. case MSG_TYPE_WARNING: {
  264. log->push_color(theme_cache.warning_color);
  265. Ref<Texture2D> icon = theme_cache.warning_icon;
  266. log->add_image(icon);
  267. log->add_text(" ");
  268. tool_button->set_icon(icon);
  269. } break;
  270. case MSG_TYPE_EDITOR: {
  271. // Distinguish editor messages from messages printed by the project
  272. log->push_color(theme_cache.message_color);
  273. } break;
  274. }
  275. // If collapsing, add the count of this message in bold at the start of the line.
  276. if (collapse && p_message.count > 1) {
  277. log->push_bold();
  278. log->add_text(vformat("(%s) ", itos(p_message.count)));
  279. log->pop();
  280. }
  281. if (p_message.type == MSG_TYPE_STD_RICH) {
  282. log->append_text(p_message.text);
  283. } else {
  284. log->add_text(p_message.text);
  285. }
  286. // Need to use pop() to exit out of the RichTextLabels current "push" stack.
  287. // We only "push" in the above switch when message type != STD and RICH, so only pop when that is the case.
  288. if (p_message.type != MSG_TYPE_STD && p_message.type != MSG_TYPE_STD_RICH) {
  289. log->pop();
  290. }
  291. log->add_newline();
  292. if (p_replace_previous) {
  293. // Force sync last line update (skip if number of unprocessed log messages is too large to avoid editor lag).
  294. if (log->get_pending_paragraphs() < 100) {
  295. while (!log->is_ready()) {
  296. ::OS::get_singleton()->delay_usec(1);
  297. }
  298. }
  299. }
  300. }
  301. void EditorLog::_set_filter_active(bool p_active, MessageType p_message_type) {
  302. type_filter_map[p_message_type]->set_active(p_active);
  303. _start_state_save_timer();
  304. _rebuild_log();
  305. }
  306. void EditorLog::_set_search_visible(bool p_visible) {
  307. search_box->set_visible(p_visible);
  308. if (p_visible) {
  309. search_box->grab_focus();
  310. }
  311. _start_state_save_timer();
  312. }
  313. void EditorLog::_search_changed(const String &p_text) {
  314. _rebuild_log();
  315. }
  316. void EditorLog::_reset_message_counts() {
  317. for (const KeyValue<MessageType, LogFilter *> &E : type_filter_map) {
  318. E.value->set_message_count(0);
  319. }
  320. }
  321. EditorLog::EditorLog() {
  322. save_state_timer = memnew(Timer);
  323. save_state_timer->set_wait_time(2);
  324. save_state_timer->set_one_shot(true);
  325. save_state_timer->connect("timeout", callable_mp(this, &EditorLog::_save_state));
  326. add_child(save_state_timer);
  327. HBoxContainer *hb = this;
  328. VBoxContainer *vb_left = memnew(VBoxContainer);
  329. vb_left->set_custom_minimum_size(Size2(0, 180) * EDSCALE);
  330. vb_left->set_v_size_flags(SIZE_EXPAND_FILL);
  331. vb_left->set_h_size_flags(SIZE_EXPAND_FILL);
  332. hb->add_child(vb_left);
  333. // Log - Rich Text Label.
  334. log = memnew(RichTextLabel);
  335. log->set_threaded(true);
  336. log->set_use_bbcode(true);
  337. log->set_scroll_follow(true);
  338. log->set_selection_enabled(true);
  339. log->set_context_menu_enabled(true);
  340. log->set_focus_mode(FOCUS_CLICK);
  341. log->set_v_size_flags(SIZE_EXPAND_FILL);
  342. log->set_h_size_flags(SIZE_EXPAND_FILL);
  343. log->set_deselect_on_focus_loss_enabled(false);
  344. vb_left->add_child(log);
  345. // Search box
  346. search_box = memnew(LineEdit);
  347. search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL);
  348. search_box->set_placeholder(TTR("Filter Messages"));
  349. search_box->set_clear_button_enabled(true);
  350. search_box->set_visible(true);
  351. search_box->connect("text_changed", callable_mp(this, &EditorLog::_search_changed));
  352. vb_left->add_child(search_box);
  353. VBoxContainer *vb_right = memnew(VBoxContainer);
  354. hb->add_child(vb_right);
  355. // Tools grid
  356. HBoxContainer *hb_tools = memnew(HBoxContainer);
  357. hb_tools->set_h_size_flags(SIZE_SHRINK_CENTER);
  358. vb_right->add_child(hb_tools);
  359. // Clear.
  360. clear_button = memnew(Button);
  361. clear_button->set_flat(true);
  362. clear_button->set_focus_mode(FOCUS_NONE);
  363. clear_button->set_shortcut(ED_SHORTCUT("editor/clear_output", TTR("Clear Output"), KeyModifierMask::CMD_OR_CTRL | KeyModifierMask::SHIFT | Key::K));
  364. clear_button->set_shortcut_context(this);
  365. clear_button->connect("pressed", callable_mp(this, &EditorLog::_clear_request));
  366. hb_tools->add_child(clear_button);
  367. // Copy.
  368. copy_button = memnew(Button);
  369. copy_button->set_flat(true);
  370. copy_button->set_focus_mode(FOCUS_NONE);
  371. copy_button->set_shortcut(ED_SHORTCUT("editor/copy_output", TTR("Copy Selection"), KeyModifierMask::CMD_OR_CTRL | Key::C));
  372. copy_button->set_shortcut_context(this);
  373. copy_button->connect("pressed", callable_mp(this, &EditorLog::_copy_request));
  374. hb_tools->add_child(copy_button);
  375. // A second hbox to make a 2x2 grid of buttons.
  376. HBoxContainer *hb_tools2 = memnew(HBoxContainer);
  377. hb_tools2->set_h_size_flags(SIZE_SHRINK_CENTER);
  378. vb_right->add_child(hb_tools2);
  379. // Collapse.
  380. collapse_button = memnew(Button);
  381. collapse_button->set_flat(true);
  382. collapse_button->set_focus_mode(FOCUS_NONE);
  383. collapse_button->set_tooltip_text(TTR("Collapse duplicate messages into one log entry. Shows number of occurrences."));
  384. collapse_button->set_toggle_mode(true);
  385. collapse_button->set_pressed(false);
  386. collapse_button->connect("toggled", callable_mp(this, &EditorLog::_set_collapse));
  387. hb_tools2->add_child(collapse_button);
  388. // Show Search.
  389. show_search_button = memnew(Button);
  390. show_search_button->set_flat(true);
  391. show_search_button->set_focus_mode(FOCUS_NONE);
  392. show_search_button->set_toggle_mode(true);
  393. show_search_button->set_pressed(true);
  394. show_search_button->set_shortcut(ED_SHORTCUT("editor/open_search", TTR("Focus Search/Filter Bar"), KeyModifierMask::CMD_OR_CTRL | Key::F));
  395. show_search_button->set_shortcut_context(this);
  396. show_search_button->connect("toggled", callable_mp(this, &EditorLog::_set_search_visible));
  397. hb_tools2->add_child(show_search_button);
  398. // Message Type Filters.
  399. vb_right->add_child(memnew(HSeparator));
  400. LogFilter *std_filter = memnew(LogFilter(MSG_TYPE_STD));
  401. std_filter->initialize_button(TTR("Toggle visibility of standard output messages."), callable_mp(this, &EditorLog::_set_filter_active));
  402. vb_right->add_child(std_filter->toggle_button);
  403. type_filter_map.insert(MSG_TYPE_STD, std_filter);
  404. type_filter_map.insert(MSG_TYPE_STD_RICH, std_filter);
  405. LogFilter *error_filter = memnew(LogFilter(MSG_TYPE_ERROR));
  406. error_filter->initialize_button(TTR("Toggle visibility of errors."), callable_mp(this, &EditorLog::_set_filter_active));
  407. vb_right->add_child(error_filter->toggle_button);
  408. type_filter_map.insert(MSG_TYPE_ERROR, error_filter);
  409. LogFilter *warning_filter = memnew(LogFilter(MSG_TYPE_WARNING));
  410. warning_filter->initialize_button(TTR("Toggle visibility of warnings."), callable_mp(this, &EditorLog::_set_filter_active));
  411. vb_right->add_child(warning_filter->toggle_button);
  412. type_filter_map.insert(MSG_TYPE_WARNING, warning_filter);
  413. LogFilter *editor_filter = memnew(LogFilter(MSG_TYPE_EDITOR));
  414. editor_filter->initialize_button(TTR("Toggle visibility of editor messages."), callable_mp(this, &EditorLog::_set_filter_active));
  415. vb_right->add_child(editor_filter->toggle_button);
  416. type_filter_map.insert(MSG_TYPE_EDITOR, editor_filter);
  417. add_message(VERSION_FULL_NAME " (c) 2007-present Juan Linietsky, Ariel Manzur & Godot Contributors.");
  418. eh.errfunc = _error_handler;
  419. eh.userdata = this;
  420. add_error_handler(&eh);
  421. current = Thread::get_caller_id();
  422. }
  423. void EditorLog::deinit() {
  424. remove_error_handler(&eh);
  425. }
  426. EditorLog::~EditorLog() {
  427. for (const KeyValue<MessageType, LogFilter *> &E : type_filter_map) {
  428. // MSG_TYPE_STD_RICH is connected to the std_filter button, so we do this
  429. // to avoid it from being deleted twice, causing a crash on closing.
  430. if (E.key != MSG_TYPE_STD_RICH) {
  431. memdelete(E.value);
  432. }
  433. }
  434. }