project_export.cpp 66 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865
  1. /**************************************************************************/
  2. /* project_export.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 "project_export.h"
  31. #include "core/config/project_settings.h"
  32. #include "core/version.h"
  33. #include "editor/editor_node.h"
  34. #include "editor/editor_string_names.h"
  35. #include "editor/export/editor_export.h"
  36. #include "editor/file_system/editor_file_system.h"
  37. #include "editor/gui/editor_file_dialog.h"
  38. #include "editor/import/resource_importer_texture_settings.h"
  39. #include "editor/inspector/editor_properties.h"
  40. #include "editor/settings/editor_settings.h"
  41. #include "editor/settings/project_settings_editor.h"
  42. #include "editor/themes/editor_scale.h"
  43. #include "scene/gui/check_button.h"
  44. #include "scene/gui/item_list.h"
  45. #include "scene/gui/line_edit.h"
  46. #include "scene/gui/link_button.h"
  47. #include "scene/gui/margin_container.h"
  48. #include "scene/gui/menu_button.h"
  49. #include "scene/gui/option_button.h"
  50. #include "scene/gui/popup_menu.h"
  51. #include "scene/gui/split_container.h"
  52. #include "scene/gui/tab_container.h"
  53. #include "scene/gui/texture_rect.h"
  54. #include "scene/gui/tree.h"
  55. void ProjectExportTextureFormatError::_on_fix_texture_format_pressed() {
  56. export_dialog->hide();
  57. ProjectSettingsEditor *project_settings = EditorNode::get_singleton()->get_project_settings();
  58. project_settings->set_general_page("rendering/textures");
  59. project_settings->set_filter(setting_identifier);
  60. project_settings->popup_project_settings(false);
  61. }
  62. void ProjectExportTextureFormatError::_bind_methods() {
  63. }
  64. void ProjectExportTextureFormatError::_notification(int p_what) {
  65. switch (p_what) {
  66. case NOTIFICATION_THEME_CHANGED: {
  67. texture_format_error_label->add_theme_color_override(SceneStringName(font_color), get_theme_color(SNAME("error_color"), EditorStringName(Editor)));
  68. } break;
  69. }
  70. }
  71. void ProjectExportTextureFormatError::show_for_texture_format(const String &p_friendly_name, const String &p_setting_identifier) {
  72. texture_format_error_label->set_text(vformat(TTR("Target platform requires '%s' texture compression. Enable 'Import %s' to fix."), p_friendly_name, p_friendly_name.replace_char('/', ' ')));
  73. setting_identifier = p_setting_identifier;
  74. show();
  75. }
  76. ProjectExportTextureFormatError::ProjectExportTextureFormatError(ProjectExportDialog *p_export_dialog) {
  77. export_dialog = p_export_dialog;
  78. // Set up the label.
  79. texture_format_error_label = memnew(Label);
  80. texture_format_error_label->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  81. add_child(texture_format_error_label);
  82. // Set up the fix button.
  83. fix_texture_format_button = memnew(LinkButton);
  84. fix_texture_format_button->set_v_size_flags(Control::SIZE_SHRINK_CENTER);
  85. fix_texture_format_button->set_text(TTR("Show Project Setting"));
  86. add_child(fix_texture_format_button);
  87. fix_texture_format_button->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportTextureFormatError::_on_fix_texture_format_pressed));
  88. }
  89. void ProjectExportDialog::_notification(int p_what) {
  90. switch (p_what) {
  91. case NOTIFICATION_VISIBILITY_CHANGED: {
  92. if (!is_visible()) {
  93. EditorSettings::get_singleton()->set_project_metadata("dialog_bounds", "export", Rect2(get_position(), get_size()));
  94. }
  95. } break;
  96. case NOTIFICATION_THEME_CHANGED: {
  97. duplicate_preset->set_button_icon(presets->get_editor_theme_icon(SNAME("Duplicate")));
  98. delete_preset->set_button_icon(presets->get_editor_theme_icon(SNAME("Remove")));
  99. patch_add_btn->set_button_icon(get_editor_theme_icon(SNAME("Add")));
  100. } break;
  101. case NOTIFICATION_READY: {
  102. duplicate_preset->set_button_icon(presets->get_editor_theme_icon(SNAME("Duplicate")));
  103. delete_preset->set_button_icon(presets->get_editor_theme_icon(SNAME("Remove")));
  104. patch_add_btn->set_button_icon(get_editor_theme_icon(SNAME("Add")));
  105. connect(SceneStringName(confirmed), callable_mp(this, &ProjectExportDialog::_export_pck_zip));
  106. _update_export_all();
  107. } break;
  108. }
  109. }
  110. void ProjectExportDialog::popup_export() {
  111. add_preset->get_popup()->clear();
  112. for (int i = 0; i < EditorExport::get_singleton()->get_export_platform_count(); i++) {
  113. Ref<EditorExportPlatform> plat = EditorExport::get_singleton()->get_export_platform(i);
  114. add_preset->get_popup()->add_icon_item(plat->get_logo(), plat->get_name());
  115. }
  116. _update_presets();
  117. if (presets->get_current() >= 0) {
  118. _update_current_preset(); // triggers rescan for templates if newly installed
  119. }
  120. // Restore valid window bounds or pop up at default size.
  121. Rect2 saved_size = EditorSettings::get_singleton()->get_project_metadata("dialog_bounds", "export", Rect2());
  122. if (saved_size != Rect2()) {
  123. popup(saved_size);
  124. } else {
  125. popup_centered_clamped(Size2(900, 500) * EDSCALE, 0.7);
  126. }
  127. }
  128. void ProjectExportDialog::_add_preset(int p_platform) {
  129. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_platform(p_platform)->create_preset();
  130. ERR_FAIL_COND(preset.is_null());
  131. String preset_name = EditorExport::get_singleton()->get_export_platform(p_platform)->get_name();
  132. bool make_runnable = true;
  133. int attempt = 1;
  134. while (true) {
  135. bool valid = true;
  136. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  137. Ref<EditorExportPreset> p = EditorExport::get_singleton()->get_export_preset(i);
  138. if (p->get_platform() == preset->get_platform() && p->is_runnable()) {
  139. make_runnable = false;
  140. }
  141. if (p->get_name() == preset_name) {
  142. valid = false;
  143. break;
  144. }
  145. }
  146. if (valid) {
  147. break;
  148. }
  149. attempt++;
  150. preset_name = EditorExport::get_singleton()->get_export_platform(p_platform)->get_name() + " " + itos(attempt);
  151. }
  152. preset->set_name(preset_name);
  153. if (make_runnable) {
  154. preset->set_runnable(make_runnable);
  155. }
  156. EditorExport::get_singleton()->add_export_preset(preset);
  157. _update_presets();
  158. _edit_preset(EditorExport::get_singleton()->get_export_preset_count() - 1);
  159. }
  160. void ProjectExportDialog::_force_update_current_preset_parameters() {
  161. // Force the parameters section to refresh its UI.
  162. parameters->edit(nullptr);
  163. _update_current_preset();
  164. }
  165. void ProjectExportDialog::_update_current_preset() {
  166. _edit_preset(presets->get_current());
  167. }
  168. void ProjectExportDialog::_update_presets() {
  169. updating = true;
  170. Ref<EditorExportPreset> current;
  171. if (presets->get_current() >= 0 && presets->get_current() < presets->get_item_count()) {
  172. current = get_current_preset();
  173. }
  174. int current_idx = -1;
  175. presets->clear();
  176. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  177. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_preset(i);
  178. if (preset == current) {
  179. current_idx = i;
  180. }
  181. String preset_name = preset->get_name();
  182. if (preset->is_runnable()) {
  183. preset_name += " (" + TTR("Runnable") + ")";
  184. }
  185. preset->update_files();
  186. presets->add_item(preset_name, preset->get_platform()->get_logo());
  187. }
  188. if (current_idx != -1) {
  189. presets->select(current_idx);
  190. }
  191. updating = false;
  192. }
  193. void ProjectExportDialog::_update_export_all() {
  194. bool can_export = EditorExport::get_singleton()->get_export_preset_count() > 0;
  195. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  196. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_preset(i);
  197. bool needs_templates;
  198. String error;
  199. if (preset->get_export_path().is_empty() || !preset->get_platform()->can_export(preset, error, needs_templates)) {
  200. can_export = false;
  201. break;
  202. }
  203. }
  204. export_all_button->set_disabled(!can_export);
  205. if (can_export) {
  206. export_all_button->set_tooltip_text(TTR("Export the project for all the presets defined."));
  207. } else {
  208. export_all_button->set_tooltip_text(TTR("All presets must have an export path defined for Export All to work."));
  209. }
  210. }
  211. void ProjectExportDialog::_edit_preset(int p_index) {
  212. if (p_index < 0 || p_index >= presets->get_item_count()) {
  213. name->set_text("");
  214. name->set_editable(false);
  215. export_path->hide();
  216. advanced_options->set_disabled(true);
  217. runnable->set_disabled(true);
  218. parameters->edit(nullptr);
  219. presets->deselect_all();
  220. duplicate_preset->set_disabled(true);
  221. delete_preset->set_disabled(true);
  222. sections->hide();
  223. patches->clear();
  224. export_error->hide();
  225. export_templates_error->hide();
  226. return;
  227. }
  228. Ref<EditorExportPreset> current = EditorExport::get_singleton()->get_export_preset(p_index);
  229. ERR_FAIL_COND(current.is_null());
  230. updating = true;
  231. presets->select(p_index);
  232. sections->show();
  233. name->set_editable(true);
  234. export_path->show();
  235. duplicate_preset->set_disabled(false);
  236. delete_preset->set_disabled(false);
  237. get_ok_button()->set_disabled(false);
  238. name->set_text(current->get_name());
  239. List<String> extension_list = current->get_platform()->get_binary_extensions(current);
  240. Vector<String> extension_vector;
  241. for (const String &extension : extension_list) {
  242. extension_vector.push_back("*." + extension);
  243. }
  244. export_path->get_path_edit()->clear();
  245. export_path->setup(extension_vector, false, true, false);
  246. export_path->update_property();
  247. advanced_options->set_disabled(false);
  248. advanced_options->set_pressed(current->are_advanced_options_enabled());
  249. runnable->set_disabled(false);
  250. runnable->set_pressed(current->is_runnable());
  251. if (parameters->get_edited_object() != current.ptr()) {
  252. current->update_value_overrides();
  253. }
  254. parameters->set_object_class(current->get_platform()->get_class_name());
  255. parameters->edit(current.ptr());
  256. export_filter->select(current->get_export_filter());
  257. include_filters->set_text(current->get_include_filter());
  258. include_label->set_text(_get_resource_export_header(current->get_export_filter()));
  259. exclude_filters->set_text(current->get_exclude_filter());
  260. server_strip_message->set_visible(current->get_export_filter() == EditorExportPreset::EXPORT_CUSTOMIZED);
  261. patches->clear();
  262. TreeItem *patch_root = patches->create_item();
  263. Vector<String> patch_list = current->get_patches();
  264. for (int i = 0; i < patch_list.size(); i++) {
  265. TreeItem *patch = patches->create_item(patch_root);
  266. const String &patch_path = patch_list[i];
  267. patch->set_cell_mode(0, TreeItem::CELL_MODE_STRING);
  268. patch->set_editable(0, true);
  269. patch->set_text(0, patch_path.get_file());
  270. patch->set_tooltip_text(0, patch_path);
  271. patch->set_metadata(0, i);
  272. patch->add_button(0, get_editor_theme_icon(SNAME("Remove")), 0);
  273. patch->add_button(0, get_editor_theme_icon(SNAME("FileBrowse")), 1);
  274. }
  275. _fill_resource_tree();
  276. bool needs_templates;
  277. String error;
  278. if (!current->get_platform()->can_export(current, error, needs_templates)) {
  279. if (!error.is_empty()) {
  280. Vector<String> items = error.split("\n", false);
  281. error = "";
  282. for (int i = 0; i < items.size(); i++) {
  283. if (i > 0) {
  284. error += "\n";
  285. }
  286. error += " - " + items[i];
  287. }
  288. export_error->set_text(error);
  289. export_error->show();
  290. } else {
  291. export_error->hide();
  292. }
  293. if (needs_templates) {
  294. export_templates_error->show();
  295. } else {
  296. export_templates_error->hide();
  297. }
  298. export_warning->hide();
  299. export_button->set_disabled(true);
  300. } else {
  301. if (error != String()) {
  302. Vector<String> items = error.split("\n", false);
  303. error = "";
  304. for (int i = 0; i < items.size(); i++) {
  305. if (i > 0) {
  306. error += "\n";
  307. }
  308. error += " - " + items[i];
  309. }
  310. export_warning->set_text(error);
  311. export_warning->show();
  312. } else {
  313. export_warning->hide();
  314. }
  315. export_error->hide();
  316. export_templates_error->hide();
  317. export_button->set_disabled(false);
  318. }
  319. custom_features->set_text(current->get_custom_features());
  320. _update_feature_list();
  321. _update_export_all();
  322. child_controls_changed();
  323. if ((feature_set.has("s3tc") || feature_set.has("bptc")) && !ResourceImporterTextureSettings::should_import_s3tc_bptc()) {
  324. export_texture_format_error->show_for_texture_format("S3TC/BPTC", "rendering/textures/vram_compression/import_s3tc_bptc");
  325. } else if ((feature_set.has("etc2") || feature_set.has("astc")) && !ResourceImporterTextureSettings::should_import_etc2_astc()) {
  326. export_texture_format_error->show_for_texture_format("ETC2/ASTC", "rendering/textures/vram_compression/import_etc2_astc");
  327. } else {
  328. export_texture_format_error->hide();
  329. }
  330. String enc_in_filters_str = current->get_enc_in_filter();
  331. String enc_ex_filters_str = current->get_enc_ex_filter();
  332. if (!updating_enc_filters) {
  333. enc_in_filters->set_text(enc_in_filters_str);
  334. enc_ex_filters->set_text(enc_ex_filters_str);
  335. }
  336. bool enc_pck_mode = current->get_enc_pck();
  337. enc_pck->set_pressed(enc_pck_mode);
  338. uint64_t seed = current->get_seed();
  339. if (!updating_seed) {
  340. seed_input->set_text(itos(seed));
  341. }
  342. enc_directory->set_disabled(!enc_pck_mode);
  343. enc_in_filters->set_editable(enc_pck_mode);
  344. enc_ex_filters->set_editable(enc_pck_mode);
  345. script_key->set_editable(enc_pck_mode);
  346. seed_input->set_editable(enc_pck_mode);
  347. bool enc_directory_mode = current->get_enc_directory();
  348. enc_directory->set_pressed(enc_directory_mode);
  349. String key = current->get_script_encryption_key();
  350. if (!updating_script_key) {
  351. script_key->set_text(key);
  352. }
  353. if (enc_pck_mode) {
  354. script_key->set_editable(true);
  355. bool key_valid = _validate_script_encryption_key(key);
  356. if (key_valid) {
  357. script_key_error->hide();
  358. } else {
  359. script_key_error->show();
  360. }
  361. } else {
  362. script_key->set_editable(false);
  363. script_key_error->hide();
  364. }
  365. int script_export_mode = current->get_script_export_mode();
  366. script_mode->select(script_export_mode);
  367. updating = false;
  368. }
  369. void ProjectExportDialog::_update_feature_list() {
  370. Ref<EditorExportPreset> current = get_current_preset();
  371. ERR_FAIL_COND(current.is_null());
  372. List<String> features_list;
  373. current->get_platform()->get_platform_features(&features_list);
  374. current->get_platform()->get_preset_features(current, &features_list);
  375. String custom = current->get_custom_features();
  376. Vector<String> custom_list = custom.split(",");
  377. for (int i = 0; i < custom_list.size(); i++) {
  378. String f = custom_list[i].strip_edges();
  379. if (!f.is_empty()) {
  380. features_list.push_back(f);
  381. }
  382. }
  383. feature_set.clear();
  384. for (const String &E : features_list) {
  385. feature_set.insert(E);
  386. }
  387. #ifdef REAL_T_IS_DOUBLE
  388. feature_set.insert("double");
  389. #else
  390. feature_set.insert("single");
  391. #endif // REAL_T_IS_DOUBLE
  392. custom_feature_display->clear();
  393. String text;
  394. bool first = true;
  395. for (const String &E : feature_set) {
  396. if (!first) {
  397. text += ", ";
  398. } else {
  399. first = false;
  400. }
  401. text += E;
  402. }
  403. custom_feature_display->add_text(text);
  404. }
  405. void ProjectExportDialog::_custom_features_changed(const String &p_text) {
  406. if (updating) {
  407. return;
  408. }
  409. Ref<EditorExportPreset> current = get_current_preset();
  410. ERR_FAIL_COND(current.is_null());
  411. current->set_custom_features(p_text);
  412. _update_feature_list();
  413. }
  414. void ProjectExportDialog::_tab_changed(int) {
  415. _update_feature_list();
  416. }
  417. void ProjectExportDialog::_update_parameters(const String &p_edited_property) {
  418. _update_current_preset();
  419. }
  420. void ProjectExportDialog::_advanced_options_pressed() {
  421. if (updating) {
  422. return;
  423. }
  424. Ref<EditorExportPreset> current = get_current_preset();
  425. ERR_FAIL_COND(current.is_null());
  426. current->set_advanced_options_enabled(advanced_options->is_pressed());
  427. _update_presets();
  428. }
  429. void ProjectExportDialog::_runnable_pressed() {
  430. if (updating) {
  431. return;
  432. }
  433. Ref<EditorExportPreset> current = get_current_preset();
  434. ERR_FAIL_COND(current.is_null());
  435. if (runnable->is_pressed()) {
  436. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  437. Ref<EditorExportPreset> p = EditorExport::get_singleton()->get_export_preset(i);
  438. if (p->get_platform() == current->get_platform()) {
  439. p->set_runnable(current == p);
  440. }
  441. }
  442. } else {
  443. current->set_runnable(false);
  444. }
  445. _update_presets();
  446. }
  447. void ProjectExportDialog::_name_changed(const String &p_string) {
  448. if (updating) {
  449. return;
  450. }
  451. Ref<EditorExportPreset> current = get_current_preset();
  452. ERR_FAIL_COND(current.is_null());
  453. current->set_name(p_string);
  454. _update_presets();
  455. }
  456. void ProjectExportDialog::set_export_path(const String &p_value) {
  457. Ref<EditorExportPreset> current = get_current_preset();
  458. ERR_FAIL_COND(current.is_null());
  459. current->set_export_path(p_value);
  460. }
  461. String ProjectExportDialog::get_export_path() {
  462. Ref<EditorExportPreset> current = get_current_preset();
  463. ERR_FAIL_COND_V(current.is_null(), String(""));
  464. return current->get_export_path();
  465. }
  466. Ref<EditorExportPreset> ProjectExportDialog::get_current_preset() const {
  467. return EditorExport::get_singleton()->get_export_preset(presets->get_current());
  468. }
  469. void ProjectExportDialog::_export_path_changed(const StringName &p_property, const Variant &p_value, const String &p_field, bool p_changing) {
  470. if (updating) {
  471. return;
  472. }
  473. Ref<EditorExportPreset> current = get_current_preset();
  474. ERR_FAIL_COND(current.is_null());
  475. current->set_export_path(p_value);
  476. _update_presets();
  477. _update_export_all();
  478. }
  479. void ProjectExportDialog::_enc_filters_changed(const String &p_filters) {
  480. if (updating) {
  481. return;
  482. }
  483. Ref<EditorExportPreset> current = get_current_preset();
  484. ERR_FAIL_COND(current.is_null());
  485. current->set_enc_in_filter(enc_in_filters->get_text());
  486. current->set_enc_ex_filter(enc_ex_filters->get_text());
  487. updating_enc_filters = true;
  488. _update_current_preset();
  489. updating_enc_filters = false;
  490. }
  491. void ProjectExportDialog::_open_key_help_link() {
  492. OS::get_singleton()->shell_open(vformat("%s/contributing/development/compiling/compiling_with_script_encryption_key.html", GODOT_VERSION_DOCS_URL));
  493. }
  494. void ProjectExportDialog::_enc_pck_changed(bool p_pressed) {
  495. if (updating) {
  496. return;
  497. }
  498. Ref<EditorExportPreset> current = get_current_preset();
  499. ERR_FAIL_COND(current.is_null());
  500. current->set_enc_pck(p_pressed);
  501. enc_directory->set_disabled(!p_pressed);
  502. enc_in_filters->set_editable(p_pressed);
  503. enc_ex_filters->set_editable(p_pressed);
  504. script_key->set_editable(p_pressed);
  505. _update_current_preset();
  506. }
  507. void ProjectExportDialog::_seed_input_changed(const String &p_text) {
  508. if (updating) {
  509. return;
  510. }
  511. Ref<EditorExportPreset> current = get_current_preset();
  512. ERR_FAIL_COND(current.is_null());
  513. current->set_seed(seed_input->get_text().to_int());
  514. updating_seed = true;
  515. _update_current_preset();
  516. updating_seed = false;
  517. }
  518. void ProjectExportDialog::_enc_directory_changed(bool p_pressed) {
  519. if (updating) {
  520. return;
  521. }
  522. Ref<EditorExportPreset> current = get_current_preset();
  523. ERR_FAIL_COND(current.is_null());
  524. current->set_enc_directory(p_pressed);
  525. _update_current_preset();
  526. }
  527. void ProjectExportDialog::_script_encryption_key_changed(const String &p_key) {
  528. if (updating) {
  529. return;
  530. }
  531. Ref<EditorExportPreset> current = get_current_preset();
  532. ERR_FAIL_COND(current.is_null());
  533. current->set_script_encryption_key(p_key);
  534. updating_script_key = true;
  535. _update_current_preset();
  536. updating_script_key = false;
  537. }
  538. bool ProjectExportDialog::_validate_script_encryption_key(const String &p_key) {
  539. bool is_valid = false;
  540. if (!p_key.is_empty() && p_key.is_valid_hex_number(false) && p_key.length() == 64) {
  541. is_valid = true;
  542. }
  543. return is_valid;
  544. }
  545. void ProjectExportDialog::_script_export_mode_changed(int p_mode) {
  546. if (updating) {
  547. return;
  548. }
  549. Ref<EditorExportPreset> current = get_current_preset();
  550. ERR_FAIL_COND(current.is_null());
  551. current->set_script_export_mode(p_mode);
  552. _update_current_preset();
  553. }
  554. void ProjectExportDialog::_duplicate_preset() {
  555. Ref<EditorExportPreset> current = get_current_preset();
  556. if (current.is_null()) {
  557. return;
  558. }
  559. Ref<EditorExportPreset> preset = current->get_platform()->create_preset();
  560. ERR_FAIL_COND(preset.is_null());
  561. String preset_name = current->get_name() + " (copy)";
  562. bool make_runnable = true;
  563. while (true) {
  564. bool valid = true;
  565. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  566. Ref<EditorExportPreset> p = EditorExport::get_singleton()->get_export_preset(i);
  567. if (p->get_platform() == preset->get_platform() && p->is_runnable()) {
  568. make_runnable = false;
  569. }
  570. if (p->get_name() == preset_name) {
  571. valid = false;
  572. break;
  573. }
  574. }
  575. if (valid) {
  576. break;
  577. }
  578. preset_name += " (copy)";
  579. }
  580. preset->set_name(preset_name);
  581. if (make_runnable) {
  582. preset->set_runnable(make_runnable);
  583. }
  584. preset->set_advanced_options_enabled(current->are_advanced_options_enabled());
  585. preset->set_dedicated_server(current->is_dedicated_server());
  586. preset->set_export_filter(current->get_export_filter());
  587. preset->set_include_filter(current->get_include_filter());
  588. preset->set_exclude_filter(current->get_exclude_filter());
  589. preset->set_patches(current->get_patches());
  590. preset->set_custom_features(current->get_custom_features());
  591. preset->set_enc_in_filter(current->get_enc_in_filter());
  592. preset->set_enc_ex_filter(current->get_enc_ex_filter());
  593. preset->set_enc_pck(current->get_enc_pck());
  594. preset->set_enc_directory(current->get_enc_directory());
  595. preset->set_script_encryption_key(current->get_script_encryption_key());
  596. preset->set_script_export_mode(current->get_script_export_mode());
  597. for (const KeyValue<StringName, Variant> &E : current->get_values()) {
  598. preset->set(E.key, E.value);
  599. }
  600. EditorExport::get_singleton()->add_export_preset(preset);
  601. _update_presets();
  602. _edit_preset(EditorExport::get_singleton()->get_export_preset_count() - 1);
  603. }
  604. void ProjectExportDialog::_delete_preset() {
  605. Ref<EditorExportPreset> current = get_current_preset();
  606. if (current.is_null()) {
  607. return;
  608. }
  609. delete_confirm->set_text(vformat(TTR("Delete preset '%s'?"), current->get_name()));
  610. delete_confirm->popup_centered();
  611. }
  612. void ProjectExportDialog::_delete_preset_confirm() {
  613. int idx = presets->get_current();
  614. _edit_preset(-1);
  615. export_button->set_disabled(true);
  616. get_ok_button()->set_disabled(true);
  617. EditorExport::get_singleton()->remove_export_preset(idx);
  618. _update_presets();
  619. // The Export All button might become enabled (if all other presets have an export path defined),
  620. // or it could be disabled (if there are no presets anymore).
  621. _update_export_all();
  622. }
  623. Variant ProjectExportDialog::get_drag_data_fw(const Point2 &p_point, Control *p_from) {
  624. if (p_from == presets) {
  625. int pos = -1;
  626. if (p_point == Vector2(Math::INF, Math::INF)) {
  627. if (presets->is_anything_selected()) {
  628. pos = presets->get_selected_items()[0];
  629. }
  630. } else {
  631. pos = presets->get_item_at_position(p_point, true);
  632. }
  633. if (pos >= 0) {
  634. Dictionary d;
  635. d["type"] = "export_preset";
  636. d["preset"] = pos;
  637. HBoxContainer *drag = memnew(HBoxContainer);
  638. TextureRect *tr = memnew(TextureRect);
  639. tr->set_texture(presets->get_item_icon(pos));
  640. drag->add_child(tr);
  641. Label *label = memnew(Label);
  642. label->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  643. label->set_text(presets->get_item_text(pos));
  644. label->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED); // Don't translate user input.
  645. drag->add_child(label);
  646. presets->set_drag_preview(drag);
  647. return d;
  648. }
  649. } else if (p_from == patches) {
  650. TreeItem *item = (p_point == Vector2(Math::INF, Math::INF)) ? patches->get_selected() : patches->get_item_at_position(p_point);
  651. if (item) {
  652. int item_metadata = item->get_metadata(0);
  653. Dictionary d;
  654. d["type"] = "export_patch";
  655. d["patch"] = item_metadata;
  656. Label *label = memnew(Label);
  657. label->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  658. label->set_text(item->get_text(0));
  659. patches->set_drag_preview(label);
  660. return d;
  661. }
  662. }
  663. return Variant();
  664. }
  665. bool ProjectExportDialog::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const {
  666. if (p_from == presets) {
  667. Dictionary d = p_data;
  668. if (!d.has("type") || String(d["type"]) != "export_preset") {
  669. return false;
  670. }
  671. int pos = -1;
  672. bool end = true;
  673. if (p_point == Vector2(Math::INF, Math::INF)) {
  674. if (presets->is_anything_selected()) {
  675. pos = presets->get_selected_items()[0];
  676. }
  677. } else {
  678. pos = presets->get_item_at_position(p_point, true);
  679. end = presets->is_pos_at_end_of_items(p_point);
  680. }
  681. if (pos < 0 && !end) {
  682. return false;
  683. }
  684. } else if (p_from == patches) {
  685. Dictionary d = p_data;
  686. if (d.get("type", "") != "export_patch") {
  687. return false;
  688. }
  689. TreeItem *item = (p_point == Vector2(Math::INF, Math::INF)) ? patches->get_selected() : patches->get_item_at_position(p_point);
  690. if (!item) {
  691. return false;
  692. }
  693. patches->set_drop_mode_flags(Tree::DROP_MODE_INBETWEEN);
  694. }
  695. return true;
  696. }
  697. void ProjectExportDialog::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) {
  698. if (p_from == presets) {
  699. Dictionary d = p_data;
  700. int from_pos = d["preset"];
  701. int to_pos = -1;
  702. int pos = -1;
  703. bool end = true;
  704. if (p_point == Vector2(Math::INF, Math::INF)) {
  705. if (presets->is_anything_selected()) {
  706. pos = presets->get_selected_items()[0];
  707. }
  708. } else {
  709. pos = presets->get_item_at_position(p_point, true);
  710. end = presets->is_pos_at_end_of_items(p_point);
  711. }
  712. if (pos >= 0) {
  713. to_pos = pos;
  714. }
  715. if (to_pos == -1 && !end) {
  716. return;
  717. }
  718. if (to_pos == from_pos) {
  719. return;
  720. } else if (to_pos > from_pos) {
  721. to_pos--;
  722. }
  723. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_preset(from_pos);
  724. EditorExport::get_singleton()->remove_export_preset(from_pos);
  725. EditorExport::get_singleton()->add_export_preset(preset, to_pos);
  726. _update_presets();
  727. if (to_pos >= 0) {
  728. _edit_preset(to_pos);
  729. } else {
  730. _edit_preset(presets->get_item_count() - 1);
  731. }
  732. } else if (p_from == patches) {
  733. Dictionary d = p_data;
  734. int from_pos = d["patch"];
  735. TreeItem *item = (p_point == Vector2(Math::INF, Math::INF)) ? patches->get_selected() : patches->get_item_at_position(p_point);
  736. if (!item) {
  737. return;
  738. }
  739. int to_pos = item->get_metadata(0);
  740. int pos = -1;
  741. if (p_point == Vector2(Math::INF, Math::INF)) {
  742. pos = patches->get_drop_section_at_position(patches->get_item_rect(item).position);
  743. } else {
  744. pos = patches->get_drop_section_at_position(p_point);
  745. }
  746. if (pos > 0) {
  747. to_pos++;
  748. }
  749. if (to_pos > from_pos) {
  750. to_pos--;
  751. }
  752. Ref<EditorExportPreset> preset = get_current_preset();
  753. String patch = preset->get_patch(from_pos);
  754. preset->remove_patch(from_pos);
  755. preset->add_patch(patch, to_pos);
  756. _update_current_preset();
  757. }
  758. }
  759. void ProjectExportDialog::_export_type_changed(int p_which) {
  760. if (updating) {
  761. return;
  762. }
  763. Ref<EditorExportPreset> current = get_current_preset();
  764. if (current.is_null()) {
  765. return;
  766. }
  767. EditorExportPreset::ExportFilter filter_type = (EditorExportPreset::ExportFilter)p_which;
  768. current->set_export_filter(filter_type);
  769. current->set_dedicated_server(filter_type == EditorExportPreset::EXPORT_CUSTOMIZED);
  770. server_strip_message->set_visible(filter_type == EditorExportPreset::EXPORT_CUSTOMIZED);
  771. // Default to stripping everything when first switching to server build.
  772. if (filter_type == EditorExportPreset::EXPORT_CUSTOMIZED && current->get_customized_files_count() == 0) {
  773. current->set_file_export_mode("res://", EditorExportPreset::MODE_FILE_STRIP);
  774. }
  775. include_label->set_text(_get_resource_export_header(current->get_export_filter()));
  776. updating = true;
  777. _fill_resource_tree();
  778. updating = false;
  779. }
  780. String ProjectExportDialog::_get_resource_export_header(EditorExportPreset::ExportFilter p_filter) const {
  781. switch (p_filter) {
  782. case EditorExportPreset::EXCLUDE_SELECTED_RESOURCES:
  783. return TTR("Resources to exclude:");
  784. case EditorExportPreset::EXPORT_CUSTOMIZED:
  785. return TTR("Resources to override export behavior:");
  786. default:
  787. return TTR("Resources to export:");
  788. }
  789. }
  790. void ProjectExportDialog::_filter_changed(const String &p_filter) {
  791. if (updating) {
  792. return;
  793. }
  794. Ref<EditorExportPreset> current = get_current_preset();
  795. if (current.is_null()) {
  796. return;
  797. }
  798. current->set_include_filter(include_filters->get_text());
  799. current->set_exclude_filter(exclude_filters->get_text());
  800. }
  801. void ProjectExportDialog::_fill_resource_tree() {
  802. include_files->clear();
  803. include_label->hide();
  804. include_margin->hide();
  805. Ref<EditorExportPreset> current = get_current_preset();
  806. if (current.is_null()) {
  807. return;
  808. }
  809. EditorExportPreset::ExportFilter f = current->get_export_filter();
  810. if (f == EditorExportPreset::EXPORT_ALL_RESOURCES) {
  811. return;
  812. }
  813. TreeItem *root = include_files->create_item();
  814. if (f == EditorExportPreset::EXPORT_CUSTOMIZED) {
  815. include_files->set_columns(2);
  816. include_files->set_column_expand(1, false);
  817. include_files->set_column_custom_minimum_width(1, 250 * EDSCALE);
  818. } else {
  819. include_files->set_columns(1);
  820. }
  821. include_label->show();
  822. include_margin->show();
  823. _fill_tree(EditorFileSystem::get_singleton()->get_filesystem(), root, current, f);
  824. if (f == EditorExportPreset::EXPORT_CUSTOMIZED) {
  825. _propagate_file_export_mode(include_files->get_root(), EditorExportPreset::MODE_FILE_NOT_CUSTOMIZED);
  826. }
  827. }
  828. void ProjectExportDialog::_setup_item_for_file_mode(TreeItem *p_item, EditorExportPreset::FileExportMode p_mode) {
  829. if (p_mode == EditorExportPreset::MODE_FILE_NOT_CUSTOMIZED) {
  830. p_item->set_checked(0, false);
  831. p_item->set_cell_mode(1, TreeItem::CELL_MODE_STRING);
  832. p_item->set_editable(1, false);
  833. p_item->set_selectable(1, false);
  834. p_item->set_custom_color(1, get_theme_color(SNAME("font_disabled_color"), EditorStringName(Editor)));
  835. } else {
  836. p_item->set_checked(0, true);
  837. p_item->set_cell_mode(1, TreeItem::CELL_MODE_CUSTOM);
  838. p_item->set_editable(1, true);
  839. p_item->set_selectable(1, true);
  840. p_item->clear_custom_color(1);
  841. }
  842. p_item->set_metadata(1, p_mode);
  843. }
  844. bool ProjectExportDialog::_fill_tree(EditorFileSystemDirectory *p_dir, TreeItem *p_item, Ref<EditorExportPreset> &current, EditorExportPreset::ExportFilter p_export_filter) {
  845. p_item->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
  846. p_item->set_icon(0, presets->get_theme_icon(SNAME("folder"), SNAME("FileDialog")));
  847. p_item->set_text(0, p_dir->get_name() + "/");
  848. p_item->set_editable(0, true);
  849. p_item->set_metadata(0, p_dir->get_path());
  850. if (p_export_filter == EditorExportPreset::EXPORT_CUSTOMIZED) {
  851. _setup_item_for_file_mode(p_item, current->get_file_export_mode(p_dir->get_path()));
  852. }
  853. bool used = false;
  854. for (int i = 0; i < p_dir->get_subdir_count(); i++) {
  855. TreeItem *subdir = include_files->create_item(p_item);
  856. if (_fill_tree(p_dir->get_subdir(i), subdir, current, p_export_filter)) {
  857. used = true;
  858. } else {
  859. memdelete(subdir);
  860. }
  861. }
  862. for (int i = 0; i < p_dir->get_file_count(); i++) {
  863. String type = p_dir->get_file_type(i);
  864. if (p_export_filter == EditorExportPreset::EXPORT_SELECTED_SCENES && type != "PackedScene") {
  865. continue;
  866. }
  867. if (type == "TextFile" || type == "OtherFile") {
  868. continue;
  869. }
  870. TreeItem *file = include_files->create_item(p_item);
  871. file->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
  872. file->set_text(0, p_dir->get_file(i));
  873. String path = p_dir->get_file_path(i);
  874. file->set_icon(0, EditorNode::get_singleton()->get_class_icon(type));
  875. file->set_editable(0, true);
  876. file->set_metadata(0, path);
  877. if (p_export_filter == EditorExportPreset::EXPORT_CUSTOMIZED) {
  878. _setup_item_for_file_mode(file, current->get_file_export_mode(path));
  879. } else {
  880. file->set_checked(0, current->has_export_file(path));
  881. file->propagate_check(0);
  882. }
  883. used = true;
  884. }
  885. return used;
  886. }
  887. void ProjectExportDialog::_propagate_file_export_mode(TreeItem *p_item, EditorExportPreset::FileExportMode p_inherited_export_mode) {
  888. EditorExportPreset::FileExportMode file_export_mode = (EditorExportPreset::FileExportMode)(int)p_item->get_metadata(1);
  889. bool is_inherited = false;
  890. if (file_export_mode == EditorExportPreset::MODE_FILE_NOT_CUSTOMIZED) {
  891. file_export_mode = p_inherited_export_mode;
  892. is_inherited = true;
  893. }
  894. if (file_export_mode == EditorExportPreset::MODE_FILE_NOT_CUSTOMIZED) {
  895. p_item->set_text(1, "");
  896. } else {
  897. String text = file_mode_popup->get_item_text(file_mode_popup->get_item_index(file_export_mode));
  898. if (is_inherited) {
  899. text += " " + TTR("(Inherited)");
  900. }
  901. p_item->set_text(1, text);
  902. }
  903. for (int i = 0; i < p_item->get_child_count(); i++) {
  904. _propagate_file_export_mode(p_item->get_child(i), file_export_mode);
  905. }
  906. }
  907. void ProjectExportDialog::_tree_changed() {
  908. if (updating) {
  909. return;
  910. }
  911. Ref<EditorExportPreset> current = get_current_preset();
  912. if (current.is_null()) {
  913. return;
  914. }
  915. TreeItem *item = include_files->get_edited();
  916. if (!item) {
  917. return;
  918. }
  919. if (current->get_export_filter() == EditorExportPreset::EXPORT_CUSTOMIZED) {
  920. EditorExportPreset::FileExportMode file_mode = EditorExportPreset::MODE_FILE_NOT_CUSTOMIZED;
  921. String path = item->get_metadata(0);
  922. if (item->is_checked(0)) {
  923. file_mode = current->get_file_export_mode(path, EditorExportPreset::MODE_FILE_STRIP);
  924. }
  925. current->set_file_export_mode(path, file_mode);
  926. _setup_item_for_file_mode(item, file_mode);
  927. _propagate_file_export_mode(include_files->get_root(), EditorExportPreset::MODE_FILE_NOT_CUSTOMIZED);
  928. } else {
  929. item->propagate_check(0);
  930. }
  931. }
  932. void ProjectExportDialog::_check_propagated_to_item(Object *p_obj, int column) {
  933. Ref<EditorExportPreset> current = get_current_preset();
  934. if (current.is_null()) {
  935. return;
  936. }
  937. TreeItem *item = Object::cast_to<TreeItem>(p_obj);
  938. String path = item->get_metadata(0);
  939. if (item && !path.ends_with("/")) {
  940. bool added = item->is_checked(0);
  941. if (added) {
  942. current->add_export_file(path);
  943. } else {
  944. current->remove_export_file(path);
  945. }
  946. }
  947. }
  948. void ProjectExportDialog::_tree_popup_edited(bool p_arrow_clicked) {
  949. Rect2 bounds = include_files->get_custom_popup_rect();
  950. bounds.position += get_global_canvas_transform().get_origin();
  951. bounds.size *= get_global_canvas_transform().get_scale();
  952. if (!is_embedding_subwindows()) {
  953. bounds.position += get_position();
  954. }
  955. file_mode_popup->popup(bounds);
  956. }
  957. void ProjectExportDialog::_set_file_export_mode(int p_id) {
  958. Ref<EditorExportPreset> current = get_current_preset();
  959. if (current.is_null()) {
  960. return;
  961. }
  962. TreeItem *item = include_files->get_edited();
  963. String path = item->get_metadata(0);
  964. EditorExportPreset::FileExportMode file_export_mode = (EditorExportPreset::FileExportMode)p_id;
  965. current->set_file_export_mode(path, file_export_mode);
  966. item->set_metadata(1, file_export_mode);
  967. _propagate_file_export_mode(include_files->get_root(), EditorExportPreset::MODE_FILE_NOT_CUSTOMIZED);
  968. }
  969. void ProjectExportDialog::_patch_tree_button_clicked(Object *p_item, int p_column, int p_id, int p_mouse_button_index) {
  970. TreeItem *ti = Object::cast_to<TreeItem>(p_item);
  971. patch_index = ti->get_metadata(0);
  972. Ref<EditorExportPreset> current = get_current_preset();
  973. ERR_FAIL_COND(current.is_null());
  974. if (p_id == 0) {
  975. Vector<String> preset_patches = current->get_patches();
  976. ERR_FAIL_INDEX(patch_index, preset_patches.size());
  977. patch_erase->set_text(vformat(TTR("Delete patch '%s' from list?"), preset_patches[patch_index].get_file()));
  978. patch_erase->popup_centered();
  979. } else {
  980. patch_dialog->popup_file_dialog();
  981. }
  982. }
  983. void ProjectExportDialog::_patch_tree_item_edited() {
  984. TreeItem *item = patches->get_edited();
  985. if (!item) {
  986. return;
  987. }
  988. Ref<EditorExportPreset> current = get_current_preset();
  989. ERR_FAIL_COND(current.is_null());
  990. int index = item->get_metadata(0);
  991. String patch_path = item->get_text(0);
  992. current->set_patch(index, patch_path);
  993. item->set_tooltip_text(0, patch_path);
  994. }
  995. void ProjectExportDialog::_patch_file_selected(const String &p_path) {
  996. Ref<EditorExportPreset> current = get_current_preset();
  997. ERR_FAIL_COND(current.is_null());
  998. String relative_path = ProjectSettings::get_singleton()->get_resource_path().path_to_file(p_path);
  999. Vector<String> preset_patches = current->get_patches();
  1000. if (patch_index >= preset_patches.size()) {
  1001. current->add_patch(relative_path);
  1002. } else {
  1003. current->set_patch(patch_index, relative_path);
  1004. }
  1005. _update_current_preset();
  1006. }
  1007. void ProjectExportDialog::_patch_delete_confirmed() {
  1008. Ref<EditorExportPreset> current = get_current_preset();
  1009. ERR_FAIL_COND(current.is_null());
  1010. Vector<String> preset_patches = current->get_patches();
  1011. if (patch_index < preset_patches.size()) {
  1012. current->remove_patch(patch_index);
  1013. _update_current_preset();
  1014. }
  1015. }
  1016. void ProjectExportDialog::_patch_add_pack_pressed() {
  1017. Ref<EditorExportPreset> current = get_current_preset();
  1018. ERR_FAIL_COND(current.is_null());
  1019. patch_index = current->get_patches().size();
  1020. patch_dialog->popup_file_dialog();
  1021. }
  1022. void ProjectExportDialog::_export_pck_zip() {
  1023. Ref<EditorExportPreset> current = get_current_preset();
  1024. ERR_FAIL_COND(current.is_null());
  1025. String dir = current->get_export_path().get_base_dir();
  1026. export_pck_zip->set_current_dir(dir);
  1027. export_pck_zip->popup_file_dialog();
  1028. }
  1029. void ProjectExportDialog::_export_pck_zip_selected(const String &p_path) {
  1030. Ref<EditorExportPreset> current = get_current_preset();
  1031. ERR_FAIL_COND(current.is_null());
  1032. Ref<EditorExportPlatform> platform = current->get_platform();
  1033. ERR_FAIL_COND(platform.is_null());
  1034. const Dictionary &fd_option = export_pck_zip->get_selected_options();
  1035. bool export_debug = fd_option.get(TTR("Export With Debug"), true);
  1036. bool export_as_patch = fd_option.get(TTR("Export As Patch"), true);
  1037. EditorSettings::get_singleton()->set_project_metadata("export_options", "export_debug", export_debug);
  1038. EditorSettings::get_singleton()->set_project_metadata("export_options", "export_as_patch", export_as_patch);
  1039. if (p_path.ends_with(".zip")) {
  1040. if (export_as_patch) {
  1041. platform->export_zip_patch(current, export_debug, p_path);
  1042. } else {
  1043. platform->export_zip(current, export_debug, p_path);
  1044. }
  1045. } else if (p_path.ends_with(".pck")) {
  1046. if (export_as_patch) {
  1047. platform->export_pack_patch(current, export_debug, p_path);
  1048. } else {
  1049. platform->export_pack(current, export_debug, p_path);
  1050. }
  1051. } else {
  1052. ERR_FAIL_MSG("Path must end with .pck or .zip");
  1053. }
  1054. }
  1055. void ProjectExportDialog::_open_export_template_manager() {
  1056. hide();
  1057. EditorNode::get_singleton()->open_export_template_manager();
  1058. }
  1059. void ProjectExportDialog::_validate_export_path(const String &p_path) {
  1060. // Disable export via OK button or Enter key if LineEdit has an empty filename
  1061. bool invalid_path = (p_path.get_file().get_basename().is_empty());
  1062. // Check if state change before needlessly messing with signals
  1063. if (invalid_path && export_project->get_ok_button()->is_disabled()) {
  1064. return;
  1065. }
  1066. if (!invalid_path && !export_project->get_ok_button()->is_disabled()) {
  1067. return;
  1068. }
  1069. if (invalid_path) {
  1070. export_project->get_ok_button()->set_disabled(true);
  1071. export_project->get_line_edit()->disconnect(SceneStringName(text_submitted), callable_mp(export_project, &EditorFileDialog::_file_submitted));
  1072. } else {
  1073. export_project->get_ok_button()->set_disabled(false);
  1074. export_project->get_line_edit()->connect(SceneStringName(text_submitted), callable_mp(export_project, &EditorFileDialog::_file_submitted));
  1075. }
  1076. }
  1077. void ProjectExportDialog::_export_project() {
  1078. Ref<EditorExportPreset> current = get_current_preset();
  1079. ERR_FAIL_COND(current.is_null());
  1080. Ref<EditorExportPlatform> platform = current->get_platform();
  1081. ERR_FAIL_COND(platform.is_null());
  1082. export_project->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
  1083. export_project->clear_filters();
  1084. List<String> extension_list = platform->get_binary_extensions(current);
  1085. for (const String &extension : extension_list) {
  1086. // TRANSLATORS: This is the name of a project export file format. %s will be replaced by the platform name.
  1087. export_project->add_filter("*." + extension, vformat(TTR("%s Export"), platform->get_name()));
  1088. }
  1089. if (!current->get_export_path().is_empty()) {
  1090. export_project->set_current_path(current->get_export_path());
  1091. } else {
  1092. if (extension_list.size() >= 1) {
  1093. export_project->set_current_file(default_filename + "." + extension_list.front()->get());
  1094. } else {
  1095. export_project->set_current_file(default_filename);
  1096. }
  1097. }
  1098. // Ensure that signal is connected if previous attempt left it disconnected
  1099. // with _validate_export_path.
  1100. // FIXME: This is a hack, we should instead change EditorFileDialog to allow
  1101. // disabling validation by the "text_submitted" signal.
  1102. if (!export_project->get_line_edit()->is_connected(SceneStringName(text_submitted), callable_mp(export_project, &EditorFileDialog::_file_submitted))) {
  1103. export_project->get_ok_button()->set_disabled(false);
  1104. export_project->get_line_edit()->connect(SceneStringName(text_submitted), callable_mp(export_project, &EditorFileDialog::_file_submitted));
  1105. }
  1106. export_project->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE);
  1107. export_project->popup_file_dialog();
  1108. }
  1109. void ProjectExportDialog::_export_project_to_path(const String &p_path) {
  1110. // Save this name for use in future exports (but drop the file extension)
  1111. default_filename = p_path.get_file().get_basename();
  1112. EditorSettings::get_singleton()->set_project_metadata("export_options", "default_filename", default_filename);
  1113. Ref<EditorExportPreset> current = get_current_preset();
  1114. ERR_FAIL_COND_MSG(current.is_null(), "Failed to start the export: current preset is invalid.");
  1115. Ref<EditorExportPlatform> platform = current->get_platform();
  1116. ERR_FAIL_COND_MSG(platform.is_null(), "Failed to start the export: current preset has no valid platform.");
  1117. current->set_export_path(p_path);
  1118. exporting = true;
  1119. platform->clear_messages();
  1120. current->update_value_overrides();
  1121. Dictionary fd_option = export_project->get_selected_options();
  1122. bool export_debug = fd_option.get(TTR("Export With Debug"), true);
  1123. EditorSettings::get_singleton()->set_project_metadata("export_options", "export_debug", export_debug);
  1124. Error err = platform->export_project(current, export_debug, current->get_export_path(), 0);
  1125. result_dialog_log->clear();
  1126. if (err != ERR_SKIP) {
  1127. if (platform->fill_log_messages(result_dialog_log, err)) {
  1128. result_dialog->popup_centered_ratio(0.5);
  1129. }
  1130. }
  1131. exporting = false;
  1132. }
  1133. void ProjectExportDialog::_export_all_dialog() {
  1134. export_all_dialog->show();
  1135. export_all_dialog->popup_centered(Size2(300, 80));
  1136. }
  1137. void ProjectExportDialog::_export_all_dialog_action(const String &p_str) {
  1138. export_all_dialog->hide();
  1139. _export_all(p_str != "release");
  1140. }
  1141. void ProjectExportDialog::_export_all(bool p_debug) {
  1142. exporting = true;
  1143. bool show_dialog = false;
  1144. { // Scope for the editor progress, we must free it before showing the dialog at the end.
  1145. String export_target = p_debug ? TTR("Debug") : TTR("Release");
  1146. EditorProgress ep("exportall", TTR("Exporting All") + " " + export_target, EditorExport::get_singleton()->get_export_preset_count(), true);
  1147. result_dialog_log->clear();
  1148. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  1149. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_preset(i);
  1150. if (preset.is_null()) {
  1151. exporting = false;
  1152. ERR_FAIL_MSG("Failed to start the export: one of the presets is invalid.");
  1153. }
  1154. Ref<EditorExportPlatform> platform = preset->get_platform();
  1155. if (platform.is_null()) {
  1156. exporting = false;
  1157. ERR_FAIL_MSG("Failed to start the export: one of the presets has no valid platform.");
  1158. }
  1159. ep.step(preset->get_name(), i);
  1160. platform->clear_messages();
  1161. preset->update_value_overrides();
  1162. Error err = platform->export_project(preset, p_debug, preset->get_export_path(), 0);
  1163. if (err == ERR_SKIP) {
  1164. exporting = false;
  1165. return;
  1166. }
  1167. bool has_messages = platform->fill_log_messages(result_dialog_log, err);
  1168. show_dialog = show_dialog || has_messages;
  1169. }
  1170. }
  1171. if (show_dialog) {
  1172. result_dialog->popup_centered_ratio(0.5);
  1173. }
  1174. exporting = false;
  1175. }
  1176. void ProjectExportDialog::_bind_methods() {
  1177. ClassDB::bind_method("set_export_path", &ProjectExportDialog::set_export_path);
  1178. ClassDB::bind_method("get_export_path", &ProjectExportDialog::get_export_path);
  1179. ClassDB::bind_method("get_current_preset", &ProjectExportDialog::get_current_preset);
  1180. ADD_PROPERTY(PropertyInfo(Variant::STRING, "export_path"), "set_export_path", "get_export_path");
  1181. }
  1182. ProjectExportDialog::ProjectExportDialog() {
  1183. set_title(TTR("Export"));
  1184. set_clamp_to_embedder(true);
  1185. VBoxContainer *main_vb = memnew(VBoxContainer);
  1186. add_child(main_vb);
  1187. HSplitContainer *hbox = memnew(HSplitContainer);
  1188. main_vb->add_child(hbox);
  1189. hbox->set_v_size_flags(Control::SIZE_EXPAND_FILL);
  1190. if (EDITOR_GET("interface/touchscreen/enable_touch_optimizations")) {
  1191. hbox->set_touch_dragger_enabled(true);
  1192. }
  1193. // Presets list.
  1194. VBoxContainer *preset_vb = memnew(VBoxContainer);
  1195. preset_vb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
  1196. hbox->add_child(preset_vb);
  1197. Label *l = memnew(Label(TTR("Presets")));
  1198. l->set_theme_type_variation("HeaderSmall");
  1199. HBoxContainer *preset_hb = memnew(HBoxContainer);
  1200. preset_hb->add_child(l);
  1201. preset_hb->add_spacer();
  1202. preset_vb->add_child(preset_hb);
  1203. add_preset = memnew(MenuButton);
  1204. add_preset->set_text(TTR("Add..."));
  1205. add_preset->get_popup()->connect("index_pressed", callable_mp(this, &ProjectExportDialog::_add_preset));
  1206. preset_hb->add_child(add_preset);
  1207. MarginContainer *mc = memnew(MarginContainer);
  1208. preset_vb->add_child(mc);
  1209. mc->set_v_size_flags(Control::SIZE_EXPAND_FILL);
  1210. presets = memnew(ItemList);
  1211. presets->set_theme_type_variation("ItemListSecondary");
  1212. presets->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED);
  1213. SET_DRAG_FORWARDING_GCD(presets, ProjectExportDialog);
  1214. mc->add_child(presets);
  1215. presets->connect(SceneStringName(item_selected), callable_mp(this, &ProjectExportDialog::_edit_preset));
  1216. duplicate_preset = memnew(Button);
  1217. duplicate_preset->set_tooltip_text(TTR("Duplicate"));
  1218. duplicate_preset->set_flat(true);
  1219. preset_hb->add_child(duplicate_preset);
  1220. duplicate_preset->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_duplicate_preset));
  1221. delete_preset = memnew(Button);
  1222. delete_preset->set_tooltip_text(TTR("Delete"));
  1223. delete_preset->set_flat(true);
  1224. preset_hb->add_child(delete_preset);
  1225. delete_preset->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_delete_preset));
  1226. // Preset settings.
  1227. VBoxContainer *settings_vb = memnew(VBoxContainer);
  1228. settings_vb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
  1229. hbox->add_child(settings_vb);
  1230. name = memnew(LineEdit);
  1231. settings_vb->add_margin_child(TTR("Name:"), name);
  1232. name->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_name_changed));
  1233. runnable = memnew(CheckButton);
  1234. runnable->set_text(TTR("Runnable"));
  1235. runnable->set_tooltip_text(TTR("If checked, the preset will be available for use in one-click deploy.\nOnly one preset per platform may be marked as runnable."));
  1236. runnable->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_runnable_pressed));
  1237. advanced_options = memnew(CheckButton);
  1238. advanced_options->set_text(TTR("Advanced Options"));
  1239. advanced_options->set_tooltip_text(TTR("If checked, the advanced options will be shown."));
  1240. advanced_options->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_advanced_options_pressed));
  1241. HBoxContainer *preset_configs_container = memnew(HBoxContainer);
  1242. preset_configs_container->add_spacer(true);
  1243. preset_configs_container->add_child(advanced_options);
  1244. preset_configs_container->add_child(runnable);
  1245. settings_vb->add_child(preset_configs_container);
  1246. export_path = memnew(EditorPropertyPath);
  1247. settings_vb->add_child(export_path);
  1248. export_path->set_label(TTR("Export Path"));
  1249. export_path->set_object_and_property(this, "export_path");
  1250. export_path->set_save_mode();
  1251. export_path->connect("property_changed", callable_mp(this, &ProjectExportDialog::_export_path_changed));
  1252. // Subsections.
  1253. sections = memnew(TabContainer);
  1254. sections->set_use_hidden_tabs_for_min_size(true);
  1255. sections->set_theme_type_variation("TabContainerOdd");
  1256. settings_vb->add_child(sections);
  1257. sections->set_v_size_flags(Control::SIZE_EXPAND_FILL);
  1258. // Main preset parameters.
  1259. parameters = memnew(EditorInspector);
  1260. parameters->set_name(TTRC("Options"));
  1261. parameters->set_mark_unsaved(false);
  1262. parameters->set_v_size_flags(Control::SIZE_EXPAND_FILL);
  1263. parameters->set_use_doc_hints(true);
  1264. sections->add_child(parameters);
  1265. parameters->connect("property_edited", callable_mp(this, &ProjectExportDialog::_update_parameters));
  1266. EditorExport::get_singleton()->connect("export_presets_updated", callable_mp(this, &ProjectExportDialog::_force_update_current_preset_parameters));
  1267. // Resources export parameters.
  1268. ScrollContainer *resources_scroll_container = memnew(ScrollContainer);
  1269. resources_scroll_container->set_name(TTR("Resources"));
  1270. resources_scroll_container->set_horizontal_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED);
  1271. sections->add_child(resources_scroll_container);
  1272. VBoxContainer *resources_vb = memnew(VBoxContainer);
  1273. resources_vb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
  1274. resources_vb->set_v_size_flags(Control::SIZE_EXPAND_FILL);
  1275. resources_scroll_container->add_child(resources_vb);
  1276. export_filter = memnew(OptionButton);
  1277. export_filter->set_accessibility_name(TTRC("Export Mode"));
  1278. export_filter->add_item(TTR("Export all resources in the project"));
  1279. export_filter->add_item(TTR("Export selected scenes (and dependencies)"));
  1280. export_filter->add_item(TTR("Export selected resources (and dependencies)"));
  1281. export_filter->add_item(TTR("Export all resources in the project except resources checked below"));
  1282. export_filter->add_item(TTR("Export as dedicated server"));
  1283. resources_vb->add_margin_child(TTR("Export Mode:"), export_filter);
  1284. export_filter->connect(SceneStringName(item_selected), callable_mp(this, &ProjectExportDialog::_export_type_changed));
  1285. include_label = memnew(Label);
  1286. include_label->set_text(TTR("Resources to export:"));
  1287. resources_vb->add_child(include_label);
  1288. include_margin = memnew(MarginContainer);
  1289. include_margin->set_v_size_flags(Control::SIZE_EXPAND_FILL);
  1290. resources_vb->add_child(include_margin);
  1291. include_files = memnew(Tree);
  1292. include_files->set_custom_minimum_size(Size2(1, 75 * EDSCALE));
  1293. include_margin->add_child(include_files);
  1294. include_files->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED);
  1295. include_files->connect("item_edited", callable_mp(this, &ProjectExportDialog::_tree_changed));
  1296. include_files->connect("check_propagated_to_item", callable_mp(this, &ProjectExportDialog::_check_propagated_to_item));
  1297. include_files->connect("custom_popup_edited", callable_mp(this, &ProjectExportDialog::_tree_popup_edited));
  1298. server_strip_message = memnew(Label);
  1299. server_strip_message->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  1300. server_strip_message->set_visible(false);
  1301. server_strip_message->set_autowrap_mode(TextServer::AUTOWRAP_WORD_SMART);
  1302. server_strip_message->set_custom_minimum_size(Size2(300 * EDSCALE, 1));
  1303. resources_vb->add_child(server_strip_message);
  1304. {
  1305. LocalVector<StringName> resource_names;
  1306. ClassDB::get_inheriters_from_class("Resource", resource_names);
  1307. PackedStringArray strippable;
  1308. for (const StringName &resource_name : resource_names) {
  1309. if (ClassDB::has_method(resource_name, "create_placeholder", true)) {
  1310. strippable.push_back(resource_name);
  1311. }
  1312. }
  1313. strippable.sort();
  1314. String message = TTR("\"Strip Visuals\" will replace the following resources with placeholders:") + " ";
  1315. message += String(", ").join(strippable);
  1316. server_strip_message->set_text(message);
  1317. }
  1318. file_mode_popup = memnew(PopupMenu);
  1319. add_child(file_mode_popup);
  1320. file_mode_popup->add_item(TTR("Strip Visuals"), EditorExportPreset::MODE_FILE_STRIP);
  1321. file_mode_popup->add_item(TTR("Keep"), EditorExportPreset::MODE_FILE_KEEP);
  1322. file_mode_popup->add_item(TTR("Remove"), EditorExportPreset::MODE_FILE_REMOVE);
  1323. file_mode_popup->connect(SceneStringName(id_pressed), callable_mp(this, &ProjectExportDialog::_set_file_export_mode));
  1324. include_filters = memnew(LineEdit);
  1325. include_filters->set_accessibility_name(TTRC("Include Filters"));
  1326. resources_vb->add_margin_child(
  1327. TTR("Filters to export non-resource files/folders\n(comma-separated, e.g: *.json, *.txt, docs/*)"),
  1328. include_filters);
  1329. include_filters->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_filter_changed));
  1330. exclude_filters = memnew(LineEdit);
  1331. exclude_filters->set_accessibility_name(TTRC("Exclude Filters"));
  1332. resources_vb->add_margin_child(
  1333. TTR("Filters to exclude files/folders from project\n(comma-separated, e.g: *.json, *.txt, docs/*)"),
  1334. exclude_filters);
  1335. exclude_filters->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_filter_changed));
  1336. // Patch packages.
  1337. VBoxContainer *patch_vb = memnew(VBoxContainer);
  1338. sections->add_child(patch_vb);
  1339. patch_vb->set_name(TTR("Patches"));
  1340. patches = memnew(Tree);
  1341. patches->set_v_size_flags(Control::SIZE_EXPAND_FILL);
  1342. patches->set_hide_root(true);
  1343. patches->set_auto_translate_mode(AUTO_TRANSLATE_MODE_DISABLED);
  1344. patches->connect("button_clicked", callable_mp(this, &ProjectExportDialog::_patch_tree_button_clicked));
  1345. patches->connect("item_edited", callable_mp(this, &ProjectExportDialog::_patch_tree_item_edited));
  1346. SET_DRAG_FORWARDING_GCD(patches, ProjectExportDialog);
  1347. patches->set_edit_checkbox_cell_only_when_checkbox_is_pressed(true);
  1348. patch_vb->add_margin_child(TTR("Base Packs:"), patches, true);
  1349. patch_dialog = memnew(EditorFileDialog);
  1350. patch_dialog->add_filter("*.pck", TTR("Godot Project Pack"));
  1351. patch_dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
  1352. patch_dialog->set_file_mode(EditorFileDialog::FILE_MODE_OPEN_FILE);
  1353. patch_dialog->connect("file_selected", callable_mp(this, &ProjectExportDialog::_patch_file_selected));
  1354. add_child(patch_dialog);
  1355. patch_erase = memnew(ConfirmationDialog);
  1356. patch_erase->set_ok_button_text(TTR("Delete"));
  1357. patch_erase->connect(SceneStringName(confirmed), callable_mp(this, &ProjectExportDialog::_patch_delete_confirmed));
  1358. add_child(patch_erase);
  1359. patch_add_btn = memnew(Button);
  1360. patch_add_btn->set_text(TTR("Add Pack"));
  1361. patch_add_btn->set_h_size_flags(Control::SIZE_SHRINK_CENTER);
  1362. patch_add_btn->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_patch_add_pack_pressed));
  1363. patch_vb->add_child(patch_add_btn);
  1364. // Feature tags.
  1365. VBoxContainer *feature_vb = memnew(VBoxContainer);
  1366. feature_vb->set_name(TTR("Features"));
  1367. feature_vb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
  1368. custom_features = memnew(LineEdit);
  1369. custom_features->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_custom_features_changed));
  1370. feature_vb->add_margin_child(TTR("Custom (comma-separated):"), custom_features);
  1371. custom_feature_display = memnew(RichTextLabel);
  1372. custom_feature_display->set_custom_minimum_size(Size2(1, 75 * EDSCALE));
  1373. custom_feature_display->set_v_size_flags(Control::SIZE_EXPAND_FILL);
  1374. feature_vb->add_margin_child(TTR("Feature List:"), custom_feature_display, true);
  1375. sections->add_child(feature_vb);
  1376. // Encryption export parameters.
  1377. ScrollContainer *sec_scroll_container = memnew(ScrollContainer);
  1378. sec_scroll_container->set_name(TTR("Encryption"));
  1379. sec_scroll_container->set_horizontal_scroll_mode(ScrollContainer::SCROLL_MODE_DISABLED);
  1380. VBoxContainer *sec_vb = memnew(VBoxContainer);
  1381. sec_vb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
  1382. sec_scroll_container->add_child(sec_vb);
  1383. enc_pck = memnew(CheckButton);
  1384. enc_pck->connect(SceneStringName(toggled), callable_mp(this, &ProjectExportDialog::_enc_pck_changed));
  1385. enc_pck->set_text(TTR("Encrypt Exported PCK"));
  1386. sec_vb->add_child(enc_pck);
  1387. enc_directory = memnew(CheckButton);
  1388. enc_directory->connect(SceneStringName(toggled), callable_mp(this, &ProjectExportDialog::_enc_directory_changed));
  1389. enc_directory->set_text(TTR("Encrypt Index (File Names and Info)"));
  1390. sec_vb->add_child(enc_directory);
  1391. enc_in_filters = memnew(LineEdit);
  1392. enc_in_filters->set_accessibility_name(TTRC("Include Filters"));
  1393. enc_in_filters->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_enc_filters_changed));
  1394. sec_vb->add_margin_child(
  1395. TTR("Filters to include files/folders\n(comma-separated, e.g: *.tscn, *.tres, scenes/*)"),
  1396. enc_in_filters);
  1397. enc_ex_filters = memnew(LineEdit);
  1398. enc_ex_filters->set_accessibility_name(TTRC("Exclude Filters"));
  1399. enc_ex_filters->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_enc_filters_changed));
  1400. sec_vb->add_margin_child(
  1401. TTR("Filters to exclude files/folders\n(comma-separated, e.g: *.ctex, *.import, music/*)"),
  1402. enc_ex_filters);
  1403. script_key = memnew(LineEdit);
  1404. script_key->set_accessibility_name(TTRC("Encryption Key (256-bits as hexadecimal):"));
  1405. script_key->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_script_encryption_key_changed));
  1406. script_key_error = memnew(Label);
  1407. script_key_error->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  1408. script_key_error->set_text(String::utf8("• ") + TTR("Invalid Encryption Key (must be 64 hexadecimal characters long)"));
  1409. script_key_error->add_theme_color_override(SceneStringName(font_color), EditorNode::get_singleton()->get_editor_theme()->get_color(SNAME("error_color"), EditorStringName(Editor)));
  1410. sec_vb->add_margin_child(TTR("Encryption Key (256-bits as hexadecimal):"), script_key);
  1411. sec_vb->add_child(script_key_error);
  1412. sections->add_child(sec_scroll_container);
  1413. seed_input = memnew(LineEdit);
  1414. seed_input->set_accessibility_name(TTRC("Initialization vector seed"));
  1415. seed_input->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_seed_input_changed));
  1416. sec_vb->add_margin_child(TTR("Initialization vector seed"), seed_input);
  1417. Label *sec_info = memnew(Label);
  1418. sec_info->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  1419. sec_info->set_text(TTR("Note: Encryption key needs to be stored in the binary,\nyou need to build the export templates from source."));
  1420. sec_vb->add_child(sec_info);
  1421. LinkButton *sec_more_info = memnew(LinkButton);
  1422. sec_more_info->set_text(TTR("More Info..."));
  1423. sec_more_info->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_open_key_help_link));
  1424. sec_vb->add_child(sec_more_info);
  1425. // Script export parameters.
  1426. VBoxContainer *script_vb = memnew(VBoxContainer);
  1427. script_vb->set_name(TTR("Scripts"));
  1428. script_mode = memnew(OptionButton);
  1429. script_mode->set_accessibility_name(TTRC("GDScript Export Mode:"));
  1430. script_vb->add_margin_child(TTR("GDScript Export Mode:"), script_mode);
  1431. script_mode->add_item(TTR("Text (easier debugging)"), (int)EditorExportPreset::MODE_SCRIPT_TEXT);
  1432. script_mode->add_item(TTR("Binary tokens (faster loading)"), (int)EditorExportPreset::MODE_SCRIPT_BINARY_TOKENS);
  1433. script_mode->add_item(TTR("Compressed binary tokens (smaller files)"), (int)EditorExportPreset::MODE_SCRIPT_BINARY_TOKENS_COMPRESSED);
  1434. script_mode->connect(SceneStringName(item_selected), callable_mp(this, &ProjectExportDialog::_script_export_mode_changed));
  1435. sections->add_child(script_vb);
  1436. sections->connect("tab_changed", callable_mp(this, &ProjectExportDialog::_tab_changed));
  1437. // Disable by default.
  1438. name->set_editable(false);
  1439. export_path->hide();
  1440. advanced_options->set_disabled(true);
  1441. runnable->set_disabled(true);
  1442. duplicate_preset->set_disabled(true);
  1443. delete_preset->set_disabled(true);
  1444. script_key_error->hide();
  1445. sections->hide();
  1446. parameters->edit(nullptr);
  1447. // Deletion dialog.
  1448. delete_confirm = memnew(ConfirmationDialog);
  1449. add_child(delete_confirm);
  1450. delete_confirm->set_ok_button_text(TTR("Delete"));
  1451. delete_confirm->connect(SceneStringName(confirmed), callable_mp(this, &ProjectExportDialog::_delete_preset_confirm));
  1452. // Export buttons, dialogs and errors.
  1453. set_cancel_button_text(TTR("Close"));
  1454. set_ok_button_text(TTR("Export PCK/ZIP..."));
  1455. get_ok_button()->set_tooltip_text(TTR("Export the project resources as a PCK or ZIP package. This is not a playable build, only the project data without a Godot executable."));
  1456. get_ok_button()->set_disabled(true);
  1457. export_button = add_button(TTR("Export Project..."), !DisplayServer::get_singleton()->get_swap_cancel_ok(), "export");
  1458. export_button->set_tooltip_text(TTR("Export the project as a playable build (Godot executable and project data) for the selected preset."));
  1459. export_button->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_export_project));
  1460. // Disable initially before we select a valid preset
  1461. export_button->set_disabled(true);
  1462. export_all_dialog = memnew(ConfirmationDialog);
  1463. add_child(export_all_dialog);
  1464. export_all_dialog->set_title(TTR("Export All"));
  1465. export_all_dialog->set_text(TTR("Choose an export mode:"));
  1466. export_all_dialog->get_ok_button()->hide();
  1467. export_all_dialog->add_button(TTR("Debug"), true, "debug");
  1468. export_all_dialog->add_button(TTR("Release"), true, "release");
  1469. export_all_dialog->connect("custom_action", callable_mp(this, &ProjectExportDialog::_export_all_dialog_action));
  1470. export_all_button = add_button(TTR("Export All..."), !DisplayServer::get_singleton()->get_swap_cancel_ok(), "export");
  1471. export_all_button->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_export_all_dialog));
  1472. export_all_button->set_disabled(true);
  1473. export_pck_zip = memnew(EditorFileDialog);
  1474. export_pck_zip->add_filter("*.zip", TTR("ZIP File"));
  1475. export_pck_zip->add_filter("*.pck", TTR("Godot Project Pack"));
  1476. export_pck_zip->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
  1477. export_pck_zip->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE);
  1478. add_child(export_pck_zip);
  1479. export_pck_zip->connect("file_selected", callable_mp(this, &ProjectExportDialog::_export_pck_zip_selected));
  1480. // Export warnings and errors bottom section.
  1481. export_texture_format_error = memnew(ProjectExportTextureFormatError(this));
  1482. main_vb->add_child(export_texture_format_error);
  1483. export_texture_format_error->hide();
  1484. export_error = memnew(Label);
  1485. export_error->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  1486. main_vb->add_child(export_error);
  1487. export_error->hide();
  1488. export_error->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_WORD_ELLIPSIS);
  1489. export_error->add_theme_color_override(SceneStringName(font_color), EditorNode::get_singleton()->get_editor_theme()->get_color(SNAME("error_color"), EditorStringName(Editor)));
  1490. export_warning = memnew(Label);
  1491. export_warning->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  1492. main_vb->add_child(export_warning);
  1493. export_warning->hide();
  1494. export_warning->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_WORD_ELLIPSIS);
  1495. export_warning->add_theme_color_override(SceneStringName(font_color), EditorNode::get_singleton()->get_editor_theme()->get_color(SNAME("warning_color"), EditorStringName(Editor)));
  1496. export_templates_error = memnew(HBoxContainer);
  1497. main_vb->add_child(export_templates_error);
  1498. export_templates_error->hide();
  1499. Label *export_error2 = memnew(Label);
  1500. export_error2->set_focus_mode(Control::FOCUS_ACCESSIBILITY);
  1501. export_templates_error->add_child(export_error2);
  1502. export_error2->set_text_overrun_behavior(TextServer::OVERRUN_TRIM_WORD_ELLIPSIS);
  1503. export_error2->add_theme_color_override(SceneStringName(font_color), EditorNode::get_singleton()->get_editor_theme()->get_color(SNAME("error_color"), EditorStringName(Editor)));
  1504. export_error2->set_text(String::utf8("• ") + TTR("Export templates for this platform are missing:") + " ");
  1505. result_dialog = memnew(AcceptDialog);
  1506. result_dialog->set_title(TTR("Project Export"));
  1507. result_dialog_log = memnew(RichTextLabel);
  1508. result_dialog_log->set_custom_minimum_size(Size2(300, 80) * EDSCALE);
  1509. result_dialog->add_child(result_dialog_log);
  1510. main_vb->add_child(result_dialog);
  1511. result_dialog->hide();
  1512. LinkButton *download_templates = memnew(LinkButton);
  1513. download_templates->set_text(TTR("Manage Export Templates"));
  1514. download_templates->set_v_size_flags(Control::SIZE_SHRINK_CENTER);
  1515. export_templates_error->add_child(download_templates);
  1516. download_templates->connect(SceneStringName(pressed), callable_mp(this, &ProjectExportDialog::_open_export_template_manager));
  1517. // Export project file dialog.
  1518. export_project = memnew(EditorFileDialog);
  1519. export_project->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
  1520. add_child(export_project);
  1521. export_project->connect("file_selected", callable_mp(this, &ProjectExportDialog::_export_project_to_path));
  1522. export_project->get_line_edit()->connect(SceneStringName(text_changed), callable_mp(this, &ProjectExportDialog::_validate_export_path));
  1523. export_project->add_option(TTR("Export With Debug"), Vector<String>(), EditorSettings::get_singleton()->get_project_metadata("export_options", "export_debug", true));
  1524. export_pck_zip->add_option(TTR("Export With Debug"), Vector<String>(), EditorSettings::get_singleton()->get_project_metadata("export_options", "export_debug", true));
  1525. export_pck_zip->add_option(TTR("Export As Patch"), Vector<String>(), EditorSettings::get_singleton()->get_project_metadata("export_options", "export_as_patch", true));
  1526. set_hide_on_ok(false);
  1527. default_filename = EditorSettings::get_singleton()->get_project_metadata("export_options", "default_filename", "");
  1528. // If no default set, use project name
  1529. if (default_filename.is_empty()) {
  1530. // If no project name defined, use a sane default
  1531. default_filename = GLOBAL_GET("application/config/name");
  1532. if (default_filename.is_empty()) {
  1533. default_filename = "UnnamedProject";
  1534. }
  1535. }
  1536. }