project_export.cpp 44 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339
  1. /*************************************************************************/
  2. /* project_export.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
  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/compressed_translation.h"
  32. #include "core/io/image_loader.h"
  33. #include "core/io/resource_loader.h"
  34. #include "core/io/resource_saver.h"
  35. #include "core/os/dir_access.h"
  36. #include "core/os/file_access.h"
  37. #include "core/os/os.h"
  38. #include "core/project_settings.h"
  39. #include "editor_data.h"
  40. #include "editor_node.h"
  41. #include "editor_settings.h"
  42. #include "scene/gui/box_container.h"
  43. #include "scene/gui/margin_container.h"
  44. #include "scene/gui/scroll_container.h"
  45. #include "scene/gui/tab_container.h"
  46. void ProjectExportDialog::_notification(int p_what) {
  47. switch (p_what) {
  48. case NOTIFICATION_READY: {
  49. duplicate_preset->set_icon(get_icon("Duplicate", "EditorIcons"));
  50. delete_preset->set_icon(get_icon("Remove", "EditorIcons"));
  51. connect("confirmed", this, "_export_pck_zip");
  52. custom_feature_display->get_parent_control()->add_style_override("panel", get_stylebox("bg", "Tree"));
  53. } break;
  54. case NOTIFICATION_POPUP_HIDE: {
  55. EditorSettings::get_singleton()->set_project_metadata("dialog_bounds", "export", get_rect());
  56. } break;
  57. case NOTIFICATION_THEME_CHANGED: {
  58. duplicate_preset->set_icon(get_icon("Duplicate", "EditorIcons"));
  59. delete_preset->set_icon(get_icon("Remove", "EditorIcons"));
  60. Control *panel = custom_feature_display->get_parent_control();
  61. if (panel)
  62. panel->add_style_override("panel", get_stylebox("bg", "Tree"));
  63. } break;
  64. }
  65. }
  66. void ProjectExportDialog::popup_export() {
  67. add_preset->get_popup()->clear();
  68. for (int i = 0; i < EditorExport::get_singleton()->get_export_platform_count(); i++) {
  69. Ref<EditorExportPlatform> plat = EditorExport::get_singleton()->get_export_platform(i);
  70. add_preset->get_popup()->add_icon_item(plat->get_logo(), plat->get_name());
  71. }
  72. _update_presets();
  73. if (presets->get_current() >= 0) {
  74. _update_current_preset(); // triggers rescan for templates if newly installed
  75. }
  76. // Restore valid window bounds or pop up at default size.
  77. Rect2 saved_size = EditorSettings::get_singleton()->get_project_metadata("dialog_bounds", "export", Rect2());
  78. if (saved_size != Rect2()) {
  79. popup(saved_size);
  80. } else {
  81. Size2 popup_size = Size2(900, 700) * editor_get_scale();
  82. Size2 window_size = get_viewport_rect().size;
  83. popup_size.x = MIN(window_size.x * 0.8, popup_size.x);
  84. popup_size.y = MIN(window_size.y * 0.8, popup_size.y);
  85. popup_centered(popup_size);
  86. }
  87. }
  88. void ProjectExportDialog::_add_preset(int p_platform) {
  89. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_platform(p_platform)->create_preset();
  90. ERR_FAIL_COND(!preset.is_valid());
  91. String name = EditorExport::get_singleton()->get_export_platform(p_platform)->get_name();
  92. bool make_runnable = true;
  93. int attempt = 1;
  94. while (true) {
  95. bool valid = true;
  96. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  97. Ref<EditorExportPreset> p = EditorExport::get_singleton()->get_export_preset(i);
  98. if (p->get_platform() == preset->get_platform() && p->is_runnable()) {
  99. make_runnable = false;
  100. }
  101. if (p->get_name() == name) {
  102. valid = false;
  103. break;
  104. }
  105. }
  106. if (valid)
  107. break;
  108. attempt++;
  109. name = EditorExport::get_singleton()->get_export_platform(p_platform)->get_name() + " " + itos(attempt);
  110. }
  111. preset->set_name(name);
  112. if (make_runnable)
  113. preset->set_runnable(make_runnable);
  114. EditorExport::get_singleton()->add_export_preset(preset);
  115. _update_presets();
  116. _edit_preset(EditorExport::get_singleton()->get_export_preset_count() - 1);
  117. }
  118. void ProjectExportDialog::_update_current_preset() {
  119. _edit_preset(presets->get_current());
  120. }
  121. void ProjectExportDialog::_update_presets() {
  122. updating = true;
  123. Ref<EditorExportPreset> current;
  124. if (presets->get_current() >= 0 && presets->get_current() < presets->get_item_count())
  125. current = get_current_preset();
  126. int current_idx = -1;
  127. presets->clear();
  128. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  129. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_preset(i);
  130. if (preset == current) {
  131. current_idx = i;
  132. }
  133. String name = preset->get_name();
  134. if (preset->is_runnable())
  135. name += " (" + TTR("Runnable") + ")";
  136. presets->add_item(name, preset->get_platform()->get_logo());
  137. }
  138. if (current_idx != -1) {
  139. presets->select(current_idx);
  140. }
  141. updating = false;
  142. }
  143. void ProjectExportDialog::_update_export_all() {
  144. bool can_export = EditorExport::get_singleton()->get_export_preset_count() > 0 ? true : false;
  145. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  146. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_preset(i);
  147. bool needs_templates;
  148. String error;
  149. if (preset->get_export_path() == "" || !preset->get_platform()->can_export(preset, error, needs_templates)) {
  150. can_export = false;
  151. break;
  152. }
  153. }
  154. if (can_export) {
  155. export_all_button->set_disabled(false);
  156. } else {
  157. export_all_button->set_disabled(true);
  158. }
  159. }
  160. void ProjectExportDialog::_edit_preset(int p_index) {
  161. if (p_index < 0 || p_index >= presets->get_item_count()) {
  162. name->set_text("");
  163. name->set_editable(false);
  164. export_path->hide();
  165. runnable->set_disabled(true);
  166. parameters->edit(NULL);
  167. presets->unselect_all();
  168. duplicate_preset->set_disabled(true);
  169. delete_preset->set_disabled(true);
  170. sections->hide();
  171. patches->clear();
  172. export_error->hide();
  173. export_templates_error->hide();
  174. return;
  175. }
  176. Ref<EditorExportPreset> current = EditorExport::get_singleton()->get_export_preset(p_index);
  177. ERR_FAIL_COND(current.is_null());
  178. updating = true;
  179. presets->select(p_index);
  180. sections->show();
  181. name->set_editable(true);
  182. export_path->show();
  183. duplicate_preset->set_disabled(false);
  184. delete_preset->set_disabled(false);
  185. name->set_text(current->get_name());
  186. List<String> extension_list = current->get_platform()->get_binary_extensions(current);
  187. Vector<String> extension_vector;
  188. for (int i = 0; i < extension_list.size(); i++) {
  189. extension_vector.push_back("*." + extension_list[i]);
  190. }
  191. export_path->setup(extension_vector, false, true);
  192. export_path->update_property();
  193. runnable->set_disabled(false);
  194. runnable->set_pressed(current->is_runnable());
  195. parameters->edit(current.ptr());
  196. export_filter->select(current->get_export_filter());
  197. include_filters->set_text(current->get_include_filter());
  198. exclude_filters->set_text(current->get_exclude_filter());
  199. patches->clear();
  200. TreeItem *patch_root = patches->create_item();
  201. Vector<String> patchlist = current->get_patches();
  202. for (int i = 0; i < patchlist.size(); i++) {
  203. TreeItem *patch = patches->create_item(patch_root);
  204. patch->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
  205. String file = patchlist[i].get_file();
  206. patch->set_editable(0, true);
  207. patch->set_text(0, file.get_file().replace("*", ""));
  208. if (file.ends_with("*"))
  209. patch->set_checked(0, true);
  210. patch->set_tooltip(0, patchlist[i]);
  211. patch->set_metadata(0, i);
  212. patch->add_button(0, get_icon("Remove", "EditorIcons"), 0);
  213. patch->add_button(0, get_icon("folder", "FileDialog"), 1);
  214. }
  215. TreeItem *patch_add = patches->create_item(patch_root);
  216. patch_add->set_metadata(0, patchlist.size());
  217. if (patchlist.size() == 0)
  218. patch_add->set_text(0, "Add initial export...");
  219. else
  220. patch_add->set_text(0, "Add previous patches...");
  221. patch_add->add_button(0, get_icon("folder", "FileDialog"), 1);
  222. _fill_resource_tree();
  223. bool needs_templates;
  224. String error;
  225. if (!current->get_platform()->can_export(current, error, needs_templates)) {
  226. if (error != String()) {
  227. Vector<String> items = error.split("\n", false);
  228. error = "";
  229. for (int i = 0; i < items.size(); i++) {
  230. if (i > 0)
  231. error += "\n";
  232. error += " - " + items[i];
  233. }
  234. export_error->set_text(error);
  235. export_error->show();
  236. } else {
  237. export_error->hide();
  238. }
  239. if (needs_templates)
  240. export_templates_error->show();
  241. else
  242. export_templates_error->hide();
  243. export_button->set_disabled(true);
  244. } else {
  245. export_error->hide();
  246. export_templates_error->hide();
  247. export_button->set_disabled(false);
  248. }
  249. custom_features->set_text(current->get_custom_features());
  250. _update_feature_list();
  251. _update_export_all();
  252. minimum_size_changed();
  253. int script_export_mode = current->get_script_export_mode();
  254. script_mode->select(script_export_mode);
  255. String key = current->get_script_encryption_key();
  256. if (!updating_script_key) {
  257. script_key->set_text(key);
  258. }
  259. if (script_export_mode == EditorExportPreset::MODE_SCRIPT_ENCRYPTED) {
  260. script_key->set_editable(true);
  261. bool key_valid = _validate_script_encryption_key(key);
  262. if (key_valid) {
  263. script_key_error->hide();
  264. } else {
  265. script_key_error->show();
  266. }
  267. } else {
  268. script_key->set_editable(false);
  269. script_key_error->hide();
  270. }
  271. updating = false;
  272. }
  273. void ProjectExportDialog::_update_feature_list() {
  274. Ref<EditorExportPreset> current = get_current_preset();
  275. ERR_FAIL_COND(current.is_null());
  276. Set<String> fset;
  277. List<String> features;
  278. current->get_platform()->get_platform_features(&features);
  279. current->get_platform()->get_preset_features(current, &features);
  280. String custom = current->get_custom_features();
  281. Vector<String> custom_list = custom.split(",");
  282. for (int i = 0; i < custom_list.size(); i++) {
  283. String f = custom_list[i].strip_edges();
  284. if (f != String()) {
  285. features.push_back(f);
  286. }
  287. }
  288. for (List<String>::Element *E = features.front(); E; E = E->next()) {
  289. fset.insert(E->get());
  290. }
  291. custom_feature_display->clear();
  292. for (Set<String>::Element *E = fset.front(); E; E = E->next()) {
  293. String f = E->get();
  294. if (E->next()) {
  295. f += ", ";
  296. }
  297. custom_feature_display->add_text(f);
  298. }
  299. }
  300. void ProjectExportDialog::_custom_features_changed(const String &p_text) {
  301. if (updating)
  302. return;
  303. Ref<EditorExportPreset> current = get_current_preset();
  304. ERR_FAIL_COND(current.is_null());
  305. current->set_custom_features(p_text);
  306. _update_feature_list();
  307. }
  308. void ProjectExportDialog::_tab_changed(int) {
  309. _update_feature_list();
  310. }
  311. void ProjectExportDialog::_patch_button_pressed(Object *p_item, int p_column, int p_id) {
  312. TreeItem *ti = (TreeItem *)p_item;
  313. patch_index = ti->get_metadata(0);
  314. Ref<EditorExportPreset> current = get_current_preset();
  315. ERR_FAIL_COND(current.is_null());
  316. if (p_id == 0) {
  317. Vector<String> patches = current->get_patches();
  318. ERR_FAIL_INDEX(patch_index, patches.size());
  319. patch_erase->set_text(vformat(TTR("Delete patch '%s' from list?"), patches[patch_index].get_file()));
  320. patch_erase->popup_centered_minsize();
  321. } else {
  322. patch_dialog->popup_centered_ratio();
  323. }
  324. }
  325. void ProjectExportDialog::_patch_edited() {
  326. TreeItem *item = patches->get_edited();
  327. if (!item)
  328. return;
  329. int index = item->get_metadata(0);
  330. Ref<EditorExportPreset> current = get_current_preset();
  331. ERR_FAIL_COND(current.is_null());
  332. Vector<String> patches = current->get_patches();
  333. ERR_FAIL_INDEX(index, patches.size());
  334. String patch = patches[index].replace("*", "");
  335. if (item->is_checked(0)) {
  336. patch += "*";
  337. }
  338. current->set_patch(index, patch);
  339. }
  340. void ProjectExportDialog::_patch_selected(const String &p_path) {
  341. Ref<EditorExportPreset> current = get_current_preset();
  342. ERR_FAIL_COND(current.is_null());
  343. Vector<String> patches = current->get_patches();
  344. if (patch_index >= patches.size()) {
  345. current->add_patch(ProjectSettings::get_singleton()->get_resource_path().path_to(p_path) + "*");
  346. } else {
  347. String enabled = patches[patch_index].ends_with("*") ? String("*") : String();
  348. current->set_patch(patch_index, ProjectSettings::get_singleton()->get_resource_path().path_to(p_path) + enabled);
  349. }
  350. _update_current_preset();
  351. }
  352. void ProjectExportDialog::_patch_deleted() {
  353. Ref<EditorExportPreset> current = get_current_preset();
  354. ERR_FAIL_COND(current.is_null());
  355. Vector<String> patches = current->get_patches();
  356. if (patch_index < patches.size()) {
  357. current->remove_patch(patch_index);
  358. _update_current_preset();
  359. }
  360. }
  361. void ProjectExportDialog::_update_parameters(const String &p_edited_property) {
  362. _update_current_preset();
  363. }
  364. void ProjectExportDialog::_runnable_pressed() {
  365. if (updating)
  366. return;
  367. Ref<EditorExportPreset> current = get_current_preset();
  368. ERR_FAIL_COND(current.is_null());
  369. if (runnable->is_pressed()) {
  370. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  371. Ref<EditorExportPreset> p = EditorExport::get_singleton()->get_export_preset(i);
  372. if (p->get_platform() == current->get_platform()) {
  373. p->set_runnable(current == p);
  374. }
  375. }
  376. } else {
  377. current->set_runnable(false);
  378. }
  379. _update_presets();
  380. }
  381. void ProjectExportDialog::_name_changed(const String &p_string) {
  382. if (updating)
  383. return;
  384. Ref<EditorExportPreset> current = get_current_preset();
  385. ERR_FAIL_COND(current.is_null());
  386. current->set_name(p_string);
  387. _update_presets();
  388. }
  389. void ProjectExportDialog::set_export_path(const String &p_value) {
  390. Ref<EditorExportPreset> current = get_current_preset();
  391. ERR_FAIL_COND(current.is_null());
  392. current->set_export_path(p_value);
  393. }
  394. String ProjectExportDialog::get_export_path() {
  395. Ref<EditorExportPreset> current = get_current_preset();
  396. ERR_FAIL_COND_V(current.is_null(), String(""));
  397. return current->get_export_path();
  398. }
  399. Ref<EditorExportPreset> ProjectExportDialog::get_current_preset() const {
  400. return EditorExport::get_singleton()->get_export_preset(presets->get_current());
  401. }
  402. void ProjectExportDialog::_export_path_changed(const StringName &p_property, const Variant &p_value, const String &p_field, bool p_changing) {
  403. if (updating)
  404. return;
  405. Ref<EditorExportPreset> current = get_current_preset();
  406. ERR_FAIL_COND(current.is_null());
  407. current->set_export_path(p_value);
  408. _update_presets();
  409. }
  410. void ProjectExportDialog::_script_export_mode_changed(int p_mode) {
  411. if (updating)
  412. return;
  413. Ref<EditorExportPreset> current = get_current_preset();
  414. ERR_FAIL_COND(current.is_null());
  415. current->set_script_export_mode(p_mode);
  416. _update_current_preset();
  417. }
  418. void ProjectExportDialog::_script_encryption_key_changed(const String &p_key) {
  419. if (updating)
  420. return;
  421. Ref<EditorExportPreset> current = get_current_preset();
  422. ERR_FAIL_COND(current.is_null());
  423. current->set_script_encryption_key(p_key);
  424. updating_script_key = true;
  425. _update_current_preset();
  426. updating_script_key = false;
  427. }
  428. bool ProjectExportDialog::_validate_script_encryption_key(const String &p_key) {
  429. bool is_valid = false;
  430. if (!p_key.empty() && p_key.is_valid_hex_number(false) && p_key.length() == 64) {
  431. is_valid = true;
  432. }
  433. return is_valid;
  434. }
  435. void ProjectExportDialog::_duplicate_preset() {
  436. Ref<EditorExportPreset> current = get_current_preset();
  437. if (current.is_null())
  438. return;
  439. Ref<EditorExportPreset> preset = current->get_platform()->create_preset();
  440. ERR_FAIL_COND(!preset.is_valid());
  441. String name = current->get_name() + "" + itos(1);
  442. bool make_runnable = true;
  443. int attempt = 2;
  444. while (true) {
  445. bool valid = true;
  446. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  447. Ref<EditorExportPreset> p = EditorExport::get_singleton()->get_export_preset(i);
  448. if (p->get_platform() == preset->get_platform() && p->is_runnable()) {
  449. make_runnable = false;
  450. }
  451. if (p->get_name() == name) {
  452. valid = false;
  453. break;
  454. }
  455. }
  456. if (valid)
  457. break;
  458. attempt++;
  459. name = current->get_name() + " " + itos(attempt);
  460. }
  461. preset->set_name(name);
  462. if (make_runnable)
  463. preset->set_runnable(make_runnable);
  464. preset->set_export_filter(current->get_export_filter());
  465. preset->set_include_filter(current->get_include_filter());
  466. preset->set_exclude_filter(current->get_exclude_filter());
  467. Vector<String> list = current->get_patches();
  468. for (int i = 0; i < list.size(); i++) {
  469. preset->add_patch(list[i]);
  470. }
  471. preset->set_custom_features(current->get_custom_features());
  472. for (const List<PropertyInfo>::Element *E = current->get_properties().front(); E; E = E->next()) {
  473. preset->set(E->get().name, current->get(E->get().name));
  474. }
  475. EditorExport::get_singleton()->add_export_preset(preset);
  476. _update_presets();
  477. _edit_preset(EditorExport::get_singleton()->get_export_preset_count() - 1);
  478. }
  479. void ProjectExportDialog::_delete_preset() {
  480. Ref<EditorExportPreset> current = get_current_preset();
  481. if (current.is_null())
  482. return;
  483. delete_confirm->set_text(vformat(TTR("Delete preset '%s'?"), current->get_name()));
  484. delete_confirm->popup_centered_minsize();
  485. }
  486. void ProjectExportDialog::_delete_preset_confirm() {
  487. int idx = presets->get_current();
  488. _edit_preset(-1);
  489. export_button->set_disabled(true);
  490. EditorExport::get_singleton()->remove_export_preset(idx);
  491. _update_presets();
  492. }
  493. Variant ProjectExportDialog::get_drag_data_fw(const Point2 &p_point, Control *p_from) {
  494. if (p_from == presets) {
  495. int pos = presets->get_item_at_position(p_point, true);
  496. if (pos >= 0) {
  497. Dictionary d;
  498. d["type"] = "export_preset";
  499. d["preset"] = pos;
  500. HBoxContainer *drag = memnew(HBoxContainer);
  501. TextureRect *tr = memnew(TextureRect);
  502. tr->set_texture(presets->get_item_icon(pos));
  503. drag->add_child(tr);
  504. Label *label = memnew(Label);
  505. label->set_text(presets->get_item_text(pos));
  506. drag->add_child(label);
  507. set_drag_preview(drag);
  508. return d;
  509. }
  510. } else if (p_from == patches) {
  511. TreeItem *item = patches->get_item_at_position(p_point);
  512. if (item && item->get_cell_mode(0) == TreeItem::CELL_MODE_CHECK) {
  513. int metadata = item->get_metadata(0);
  514. Dictionary d;
  515. d["type"] = "export_patch";
  516. d["patch"] = metadata;
  517. Label *label = memnew(Label);
  518. label->set_text(item->get_text(0));
  519. set_drag_preview(label);
  520. return d;
  521. }
  522. }
  523. return Variant();
  524. }
  525. bool ProjectExportDialog::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const {
  526. if (p_from == presets) {
  527. Dictionary d = p_data;
  528. if (!d.has("type") || String(d["type"]) != "export_preset")
  529. return false;
  530. if (presets->get_item_at_position(p_point, true) < 0 && !presets->is_pos_at_end_of_items(p_point))
  531. return false;
  532. } else if (p_from == patches) {
  533. Dictionary d = p_data;
  534. if (!d.has("type") || String(d["type"]) != "export_patch")
  535. return false;
  536. patches->set_drop_mode_flags(Tree::DROP_MODE_ON_ITEM);
  537. TreeItem *item = patches->get_item_at_position(p_point);
  538. if (!item) {
  539. return false;
  540. }
  541. }
  542. return true;
  543. }
  544. void ProjectExportDialog::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) {
  545. if (p_from == presets) {
  546. Dictionary d = p_data;
  547. int from_pos = d["preset"];
  548. int to_pos = -1;
  549. if (presets->get_item_at_position(p_point, true) >= 0) {
  550. to_pos = presets->get_item_at_position(p_point, true);
  551. }
  552. if (to_pos == -1 && !presets->is_pos_at_end_of_items(p_point))
  553. return;
  554. if (to_pos == from_pos)
  555. return;
  556. else if (to_pos > from_pos) {
  557. to_pos--;
  558. }
  559. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_preset(from_pos);
  560. EditorExport::get_singleton()->remove_export_preset(from_pos);
  561. EditorExport::get_singleton()->add_export_preset(preset, to_pos);
  562. _update_presets();
  563. if (to_pos >= 0)
  564. _edit_preset(to_pos);
  565. else
  566. _edit_preset(presets->get_item_count() - 1);
  567. } else if (p_from == patches) {
  568. Dictionary d = p_data;
  569. if (!d.has("type") || String(d["type"]) != "export_patch")
  570. return;
  571. int from_pos = d["patch"];
  572. TreeItem *item = patches->get_item_at_position(p_point);
  573. if (!item)
  574. return;
  575. int to_pos = item->get_cell_mode(0) == TreeItem::CELL_MODE_CHECK ? int(item->get_metadata(0)) : -1;
  576. if (to_pos == from_pos)
  577. return;
  578. else if (to_pos > from_pos) {
  579. to_pos--;
  580. }
  581. Ref<EditorExportPreset> preset = get_current_preset();
  582. String patch = preset->get_patch(from_pos);
  583. preset->remove_patch(from_pos);
  584. preset->add_patch(patch, to_pos);
  585. _update_current_preset();
  586. }
  587. }
  588. void ProjectExportDialog::_export_type_changed(int p_which) {
  589. if (updating)
  590. return;
  591. Ref<EditorExportPreset> current = get_current_preset();
  592. if (current.is_null())
  593. return;
  594. current->set_export_filter(EditorExportPreset::ExportFilter(p_which));
  595. updating = true;
  596. _fill_resource_tree();
  597. updating = false;
  598. }
  599. void ProjectExportDialog::_filter_changed(const String &p_filter) {
  600. if (updating)
  601. return;
  602. Ref<EditorExportPreset> current = get_current_preset();
  603. if (current.is_null())
  604. return;
  605. current->set_include_filter(include_filters->get_text());
  606. current->set_exclude_filter(exclude_filters->get_text());
  607. }
  608. void ProjectExportDialog::_fill_resource_tree() {
  609. include_files->clear();
  610. include_label->hide();
  611. include_margin->hide();
  612. Ref<EditorExportPreset> current = get_current_preset();
  613. if (current.is_null())
  614. return;
  615. EditorExportPreset::ExportFilter f = current->get_export_filter();
  616. if (f == EditorExportPreset::EXPORT_ALL_RESOURCES) {
  617. return;
  618. }
  619. include_label->show();
  620. include_margin->show();
  621. TreeItem *root = include_files->create_item();
  622. _fill_tree(EditorFileSystem::get_singleton()->get_filesystem(), root, current, f == EditorExportPreset::EXPORT_SELECTED_SCENES);
  623. }
  624. bool ProjectExportDialog::_fill_tree(EditorFileSystemDirectory *p_dir, TreeItem *p_item, Ref<EditorExportPreset> &current, bool p_only_scenes) {
  625. p_item->set_icon(0, get_icon("folder", "FileDialog"));
  626. p_item->set_text(0, p_dir->get_name() + "/");
  627. bool used = false;
  628. for (int i = 0; i < p_dir->get_subdir_count(); i++) {
  629. TreeItem *subdir = include_files->create_item(p_item);
  630. if (_fill_tree(p_dir->get_subdir(i), subdir, current, p_only_scenes)) {
  631. used = true;
  632. } else {
  633. memdelete(subdir);
  634. }
  635. }
  636. for (int i = 0; i < p_dir->get_file_count(); i++) {
  637. String type = p_dir->get_file_type(i);
  638. if (p_only_scenes && type != "PackedScene")
  639. continue;
  640. TreeItem *file = include_files->create_item(p_item);
  641. file->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
  642. file->set_text(0, p_dir->get_file(i));
  643. String path = p_dir->get_file_path(i);
  644. file->set_icon(0, EditorNode::get_singleton()->get_class_icon(type));
  645. file->set_editable(0, true);
  646. file->set_checked(0, current->has_export_file(path));
  647. file->set_metadata(0, path);
  648. used = true;
  649. }
  650. return used;
  651. }
  652. void ProjectExportDialog::_tree_changed() {
  653. if (updating)
  654. return;
  655. Ref<EditorExportPreset> current = get_current_preset();
  656. if (current.is_null())
  657. return;
  658. TreeItem *item = include_files->get_edited();
  659. if (!item)
  660. return;
  661. String path = item->get_metadata(0);
  662. bool added = item->is_checked(0);
  663. if (added) {
  664. current->add_export_file(path);
  665. } else {
  666. current->remove_export_file(path);
  667. }
  668. }
  669. void ProjectExportDialog::_export_pck_zip() {
  670. export_pck_zip->popup_centered_ratio();
  671. }
  672. void ProjectExportDialog::_export_pck_zip_selected(const String &p_path) {
  673. Ref<EditorExportPreset> current = get_current_preset();
  674. ERR_FAIL_COND(current.is_null());
  675. Ref<EditorExportPlatform> platform = current->get_platform();
  676. ERR_FAIL_COND(platform.is_null());
  677. if (p_path.ends_with(".zip")) {
  678. platform->export_zip(current, export_pck_zip_debug->is_pressed(), p_path);
  679. } else if (p_path.ends_with(".pck")) {
  680. platform->export_pack(current, export_pck_zip_debug->is_pressed(), p_path);
  681. }
  682. }
  683. void ProjectExportDialog::_open_export_template_manager() {
  684. EditorNode::get_singleton()->open_export_template_manager();
  685. hide();
  686. }
  687. void ProjectExportDialog::_validate_export_path(const String &p_path) {
  688. // Disable export via OK button or Enter key if LineEdit has an empty filename
  689. bool invalid_path = (p_path.get_file().get_basename() == "");
  690. // Check if state change before needlessly messing with signals
  691. if (invalid_path && export_project->get_ok()->is_disabled())
  692. return;
  693. if (!invalid_path && !export_project->get_ok()->is_disabled())
  694. return;
  695. if (invalid_path) {
  696. export_project->get_ok()->set_disabled(true);
  697. export_project->get_line_edit()->disconnect("text_entered", export_project, "_file_entered");
  698. } else {
  699. export_project->get_ok()->set_disabled(false);
  700. export_project->get_line_edit()->connect("text_entered", export_project, "_file_entered");
  701. }
  702. }
  703. void ProjectExportDialog::_export_project() {
  704. Ref<EditorExportPreset> current = get_current_preset();
  705. ERR_FAIL_COND(current.is_null());
  706. Ref<EditorExportPlatform> platform = current->get_platform();
  707. ERR_FAIL_COND(platform.is_null());
  708. export_project->set_access(FileDialog::ACCESS_FILESYSTEM);
  709. export_project->clear_filters();
  710. List<String> extension_list = platform->get_binary_extensions(current);
  711. for (int i = 0; i < extension_list.size(); i++) {
  712. export_project->add_filter("*." + extension_list[i] + " ; " + platform->get_name() + " Export");
  713. }
  714. if (current->get_export_path() != "") {
  715. export_project->set_current_path(current->get_export_path());
  716. } else {
  717. if (extension_list.size() >= 1) {
  718. export_project->set_current_file(default_filename + "." + extension_list[0]);
  719. } else {
  720. export_project->set_current_file(default_filename);
  721. }
  722. }
  723. // Ensure that signal is connected if previous attempt left it disconnected with _validate_export_path
  724. if (!export_project->get_line_edit()->is_connected("text_entered", export_project, "_file_entered")) {
  725. export_project->get_ok()->set_disabled(false);
  726. export_project->get_line_edit()->connect("text_entered", export_project, "_file_entered");
  727. }
  728. export_project->set_mode(FileDialog::MODE_SAVE_FILE);
  729. export_project->popup_centered_ratio();
  730. }
  731. void ProjectExportDialog::_export_project_to_path(const String &p_path) {
  732. // Save this name for use in future exports (but drop the file extension)
  733. default_filename = p_path.get_file().get_basename();
  734. EditorSettings::get_singleton()->set_project_metadata("export_options", "default_filename", default_filename);
  735. Ref<EditorExportPreset> current = get_current_preset();
  736. ERR_FAIL_COND(current.is_null());
  737. Ref<EditorExportPlatform> platform = current->get_platform();
  738. ERR_FAIL_COND(platform.is_null());
  739. current->set_export_path(p_path);
  740. Error err = platform->export_project(current, export_debug->is_pressed(), p_path, 0);
  741. if (err != OK) {
  742. if (err == ERR_FILE_NOT_FOUND) {
  743. error_dialog->set_text(vformat(TTR("Failed to export the project for platform '%s'.\nExport templates seem to be missing or invalid."), platform->get_name()));
  744. } else { // Assume misconfiguration. FIXME: Improve error handling and preset config validation.
  745. error_dialog->set_text(vformat(TTR("Failed to export the project for platform '%s'.\nThis might be due to a configuration issue in the export preset or your export settings."), platform->get_name()));
  746. }
  747. ERR_PRINTS(vformat("Failed to export the project for platform '%s'.", platform->get_name()));
  748. error_dialog->show();
  749. error_dialog->popup_centered_minsize(Size2(300, 80));
  750. }
  751. }
  752. void ProjectExportDialog::_export_all_dialog() {
  753. export_all_dialog->show();
  754. export_all_dialog->popup_centered_minsize(Size2(300, 80));
  755. }
  756. void ProjectExportDialog::_export_all_dialog_action(const String &p_str) {
  757. export_all_dialog->hide();
  758. _export_all(p_str == "release" ? false : true);
  759. }
  760. void ProjectExportDialog::_export_all(bool p_debug) {
  761. String mode = p_debug ? TTR("Debug") : TTR("Release");
  762. EditorProgress ep("exportall", TTR("Exporting All") + " " + mode, EditorExport::get_singleton()->get_export_preset_count());
  763. for (int i = 0; i < EditorExport::get_singleton()->get_export_preset_count(); i++) {
  764. Ref<EditorExportPreset> preset = EditorExport::get_singleton()->get_export_preset(i);
  765. ERR_FAIL_COND(preset.is_null());
  766. Ref<EditorExportPlatform> platform = preset->get_platform();
  767. ERR_FAIL_COND(platform.is_null());
  768. ep.step(preset->get_name(), i);
  769. Error err = platform->export_project(preset, p_debug, preset->get_export_path(), 0);
  770. if (err != OK) {
  771. if (err == ERR_FILE_BAD_PATH) {
  772. error_dialog->set_text(TTR("The given export path doesn't exist:") + "\n" + preset->get_export_path().get_base_dir());
  773. } else {
  774. error_dialog->set_text(TTR("Export templates for this platform are missing/corrupted:") + " " + platform->get_name());
  775. }
  776. error_dialog->show();
  777. error_dialog->popup_centered_minsize(Size2(300, 80));
  778. ERR_PRINT("Failed to export project");
  779. }
  780. }
  781. }
  782. void ProjectExportDialog::_bind_methods() {
  783. ClassDB::bind_method("_add_preset", &ProjectExportDialog::_add_preset);
  784. ClassDB::bind_method("_edit_preset", &ProjectExportDialog::_edit_preset);
  785. ClassDB::bind_method("_update_parameters", &ProjectExportDialog::_update_parameters);
  786. ClassDB::bind_method("_runnable_pressed", &ProjectExportDialog::_runnable_pressed);
  787. ClassDB::bind_method("_name_changed", &ProjectExportDialog::_name_changed);
  788. ClassDB::bind_method("_duplicate_preset", &ProjectExportDialog::_duplicate_preset);
  789. ClassDB::bind_method("_delete_preset", &ProjectExportDialog::_delete_preset);
  790. ClassDB::bind_method("_delete_preset_confirm", &ProjectExportDialog::_delete_preset_confirm);
  791. ClassDB::bind_method("get_drag_data_fw", &ProjectExportDialog::get_drag_data_fw);
  792. ClassDB::bind_method("can_drop_data_fw", &ProjectExportDialog::can_drop_data_fw);
  793. ClassDB::bind_method("drop_data_fw", &ProjectExportDialog::drop_data_fw);
  794. ClassDB::bind_method("_export_type_changed", &ProjectExportDialog::_export_type_changed);
  795. ClassDB::bind_method("_filter_changed", &ProjectExportDialog::_filter_changed);
  796. ClassDB::bind_method("_tree_changed", &ProjectExportDialog::_tree_changed);
  797. ClassDB::bind_method("_patch_button_pressed", &ProjectExportDialog::_patch_button_pressed);
  798. ClassDB::bind_method("_patch_selected", &ProjectExportDialog::_patch_selected);
  799. ClassDB::bind_method("_patch_deleted", &ProjectExportDialog::_patch_deleted);
  800. ClassDB::bind_method("_patch_edited", &ProjectExportDialog::_patch_edited);
  801. ClassDB::bind_method("_export_pck_zip", &ProjectExportDialog::_export_pck_zip);
  802. ClassDB::bind_method("_export_pck_zip_selected", &ProjectExportDialog::_export_pck_zip_selected);
  803. ClassDB::bind_method("_open_export_template_manager", &ProjectExportDialog::_open_export_template_manager);
  804. ClassDB::bind_method("_validate_export_path", &ProjectExportDialog::_validate_export_path);
  805. ClassDB::bind_method("_export_path_changed", &ProjectExportDialog::_export_path_changed);
  806. ClassDB::bind_method("_script_export_mode_changed", &ProjectExportDialog::_script_export_mode_changed);
  807. ClassDB::bind_method("_script_encryption_key_changed", &ProjectExportDialog::_script_encryption_key_changed);
  808. ClassDB::bind_method("_export_project", &ProjectExportDialog::_export_project);
  809. ClassDB::bind_method("_export_project_to_path", &ProjectExportDialog::_export_project_to_path);
  810. ClassDB::bind_method("_export_all", &ProjectExportDialog::_export_all);
  811. ClassDB::bind_method("_export_all_dialog", &ProjectExportDialog::_export_all_dialog);
  812. ClassDB::bind_method("_export_all_dialog_action", &ProjectExportDialog::_export_all_dialog_action);
  813. ClassDB::bind_method("_custom_features_changed", &ProjectExportDialog::_custom_features_changed);
  814. ClassDB::bind_method("_tab_changed", &ProjectExportDialog::_tab_changed);
  815. ClassDB::bind_method("set_export_path", &ProjectExportDialog::set_export_path);
  816. ClassDB::bind_method("get_export_path", &ProjectExportDialog::get_export_path);
  817. ClassDB::bind_method("get_current_preset", &ProjectExportDialog::get_current_preset);
  818. ADD_PROPERTY(PropertyInfo(Variant::STRING, "export_path"), "set_export_path", "get_export_path");
  819. }
  820. ProjectExportDialog::ProjectExportDialog() {
  821. set_title(TTR("Export"));
  822. set_resizable(true);
  823. VBoxContainer *main_vb = memnew(VBoxContainer);
  824. add_child(main_vb);
  825. HSplitContainer *hbox = memnew(HSplitContainer);
  826. main_vb->add_child(hbox);
  827. hbox->set_v_size_flags(SIZE_EXPAND_FILL);
  828. VBoxContainer *preset_vb = memnew(VBoxContainer);
  829. preset_vb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
  830. hbox->add_child(preset_vb);
  831. HBoxContainer *preset_hb = memnew(HBoxContainer);
  832. preset_hb->add_child(memnew(Label(TTR("Presets"))));
  833. preset_hb->add_spacer();
  834. preset_vb->add_child(preset_hb);
  835. add_preset = memnew(MenuButton);
  836. add_preset->set_text(TTR("Add..."));
  837. add_preset->get_popup()->connect("index_pressed", this, "_add_preset");
  838. preset_hb->add_child(add_preset);
  839. MarginContainer *mc = memnew(MarginContainer);
  840. preset_vb->add_child(mc);
  841. mc->set_v_size_flags(SIZE_EXPAND_FILL);
  842. presets = memnew(ItemList);
  843. presets->set_drag_forwarding(this);
  844. mc->add_child(presets);
  845. presets->connect("item_selected", this, "_edit_preset");
  846. duplicate_preset = memnew(ToolButton);
  847. preset_hb->add_child(duplicate_preset);
  848. duplicate_preset->connect("pressed", this, "_duplicate_preset");
  849. delete_preset = memnew(ToolButton);
  850. preset_hb->add_child(delete_preset);
  851. delete_preset->connect("pressed", this, "_delete_preset");
  852. VBoxContainer *settings_vb = memnew(VBoxContainer);
  853. settings_vb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
  854. hbox->add_child(settings_vb);
  855. name = memnew(LineEdit);
  856. settings_vb->add_margin_child(TTR("Name:"), name);
  857. name->connect("text_changed", this, "_name_changed");
  858. runnable = memnew(CheckButton);
  859. runnable->set_text(TTR("Runnable"));
  860. runnable->set_tooltip(TTR("If checked, the preset will be available for use in one-click deploy.\nOnly one preset per platform may be marked as runnable."));
  861. runnable->connect("pressed", this, "_runnable_pressed");
  862. settings_vb->add_child(runnable);
  863. export_path = memnew(EditorPropertyPath);
  864. settings_vb->add_child(export_path);
  865. export_path->set_label(TTR("Export Path"));
  866. export_path->set_object_and_property(this, "export_path");
  867. export_path->set_save_mode();
  868. export_path->connect("property_changed", this, "_export_path_changed");
  869. sections = memnew(TabContainer);
  870. sections->set_tab_align(TabContainer::ALIGN_LEFT);
  871. settings_vb->add_child(sections);
  872. sections->set_v_size_flags(SIZE_EXPAND_FILL);
  873. parameters = memnew(EditorInspector);
  874. sections->add_child(parameters);
  875. parameters->set_name(TTR("Options"));
  876. parameters->set_v_size_flags(SIZE_EXPAND_FILL);
  877. parameters->connect("property_edited", this, "_update_parameters");
  878. VBoxContainer *resources_vb = memnew(VBoxContainer);
  879. sections->add_child(resources_vb);
  880. resources_vb->set_name(TTR("Resources"));
  881. export_filter = memnew(OptionButton);
  882. export_filter->add_item(TTR("Export all resources in the project"));
  883. export_filter->add_item(TTR("Export selected scenes (and dependencies)"));
  884. export_filter->add_item(TTR("Export selected resources (and dependencies)"));
  885. resources_vb->add_margin_child(TTR("Export Mode:"), export_filter);
  886. export_filter->connect("item_selected", this, "_export_type_changed");
  887. include_label = memnew(Label);
  888. include_label->set_text(TTR("Resources to export:"));
  889. resources_vb->add_child(include_label);
  890. include_margin = memnew(MarginContainer);
  891. include_margin->set_v_size_flags(SIZE_EXPAND_FILL);
  892. resources_vb->add_child(include_margin);
  893. include_files = memnew(Tree);
  894. include_margin->add_child(include_files);
  895. include_files->connect("item_edited", this, "_tree_changed");
  896. include_filters = memnew(LineEdit);
  897. resources_vb->add_margin_child(TTR("Filters to export non-resource files (comma separated, e.g: *.json, *.txt)"), include_filters);
  898. include_filters->connect("text_changed", this, "_filter_changed");
  899. exclude_filters = memnew(LineEdit);
  900. resources_vb->add_margin_child(TTR("Filters to exclude files from project (comma separated, e.g: *.json, *.txt)"), exclude_filters);
  901. exclude_filters->connect("text_changed", this, "_filter_changed");
  902. VBoxContainer *patch_vb = memnew(VBoxContainer);
  903. sections->add_child(patch_vb);
  904. patch_vb->set_name(TTR("Patches"));
  905. patches = memnew(Tree);
  906. patch_vb->add_child(patches);
  907. patches->set_v_size_flags(SIZE_EXPAND_FILL);
  908. patches->set_hide_root(true);
  909. patches->connect("button_pressed", this, "_patch_button_pressed");
  910. patches->connect("item_edited", this, "_patch_edited");
  911. patches->set_drag_forwarding(this);
  912. patches->set_edit_checkbox_cell_only_when_checkbox_is_pressed(true);
  913. HBoxContainer *patches_hb = memnew(HBoxContainer);
  914. patch_vb->add_child(patches_hb);
  915. patches_hb->add_spacer();
  916. patch_export = memnew(Button);
  917. patch_export->set_text(TTR("Make Patch"));
  918. patches_hb->add_child(patch_export);
  919. patches_hb->add_spacer();
  920. patch_dialog = memnew(FileDialog);
  921. patch_dialog->add_filter("*.pck ; Pack File");
  922. patch_dialog->set_mode(FileDialog::MODE_OPEN_FILE);
  923. patch_dialog->connect("file_selected", this, "_patch_selected");
  924. add_child(patch_dialog);
  925. patch_erase = memnew(ConfirmationDialog);
  926. patch_erase->get_ok()->set_text(TTR("Delete"));
  927. patch_erase->connect("confirmed", this, "_patch_deleted");
  928. add_child(patch_erase);
  929. VBoxContainer *feature_vb = memnew(VBoxContainer);
  930. feature_vb->set_name(TTR("Features"));
  931. custom_features = memnew(LineEdit);
  932. custom_features->connect("text_changed", this, "_custom_features_changed");
  933. feature_vb->add_margin_child(TTR("Custom (comma-separated):"), custom_features);
  934. Panel *features_panel = memnew(Panel);
  935. custom_feature_display = memnew(RichTextLabel);
  936. features_panel->add_child(custom_feature_display);
  937. custom_feature_display->set_anchors_and_margins_preset(Control::PRESET_WIDE, Control::PRESET_MODE_MINSIZE, 10 * EDSCALE);
  938. custom_feature_display->set_v_size_flags(SIZE_EXPAND_FILL);
  939. feature_vb->add_margin_child(TTR("Feature List:"), features_panel, true);
  940. sections->add_child(feature_vb);
  941. updating_script_key = false;
  942. VBoxContainer *script_vb = memnew(VBoxContainer);
  943. script_vb->set_name(TTR("Script"));
  944. script_mode = memnew(OptionButton);
  945. script_vb->add_margin_child(TTR("Script Export Mode:"), script_mode);
  946. script_mode->add_item(TTR("Text"), (int)EditorExportPreset::MODE_SCRIPT_TEXT);
  947. script_mode->add_item(TTR("Compiled"), (int)EditorExportPreset::MODE_SCRIPT_COMPILED);
  948. script_mode->add_item(TTR("Encrypted (Provide Key Below)"), (int)EditorExportPreset::MODE_SCRIPT_ENCRYPTED);
  949. script_mode->connect("item_selected", this, "_script_export_mode_changed");
  950. script_key = memnew(LineEdit);
  951. script_key->connect("text_changed", this, "_script_encryption_key_changed");
  952. script_key_error = memnew(Label);
  953. script_key_error->set_text("- " + TTR("Invalid Encryption Key (must be 64 characters long)"));
  954. script_key_error->add_color_override("font_color", EditorNode::get_singleton()->get_gui_base()->get_color("error_color", "Editor"));
  955. script_vb->add_margin_child(TTR("Script Encryption Key (256-bits as hex):"), script_key);
  956. script_vb->add_child(script_key_error);
  957. sections->add_child(script_vb);
  958. sections->connect("tab_changed", this, "_tab_changed");
  959. //disable by default
  960. name->set_editable(false);
  961. export_path->hide();
  962. runnable->set_disabled(true);
  963. duplicate_preset->set_disabled(true);
  964. delete_preset->set_disabled(true);
  965. script_key_error->hide();
  966. sections->hide();
  967. parameters->edit(NULL);
  968. delete_confirm = memnew(ConfirmationDialog);
  969. add_child(delete_confirm);
  970. delete_confirm->get_ok()->set_text(TTR("Delete"));
  971. delete_confirm->connect("confirmed", this, "_delete_preset_confirm");
  972. updating = false;
  973. get_cancel()->set_text(TTR("Close"));
  974. get_ok()->set_text(TTR("Export PCK/Zip"));
  975. export_button = add_button(TTR("Export Project"), !OS::get_singleton()->get_swap_ok_cancel(), "export");
  976. export_button->connect("pressed", this, "_export_project");
  977. // Disable initially before we select a valid preset
  978. export_button->set_disabled(true);
  979. export_all_dialog = memnew(ConfirmationDialog);
  980. add_child(export_all_dialog);
  981. export_all_dialog->set_title("Export All");
  982. export_all_dialog->set_text(TTR("Export mode?"));
  983. export_all_dialog->get_ok()->hide();
  984. export_all_dialog->add_button(TTR("Debug"), true, "debug");
  985. export_all_dialog->add_button(TTR("Release"), true, "release");
  986. export_all_dialog->connect("custom_action", this, "_export_all_dialog_action");
  987. export_all_button = add_button(TTR("Export All"), !OS::get_singleton()->get_swap_ok_cancel(), "export");
  988. export_all_button->connect("pressed", this, "_export_all_dialog");
  989. export_all_button->set_disabled(true);
  990. export_pck_zip = memnew(FileDialog);
  991. export_pck_zip->add_filter("*.zip ; ZIP File");
  992. export_pck_zip->add_filter("*.pck ; Godot Game Pack");
  993. export_pck_zip->set_access(FileDialog::ACCESS_FILESYSTEM);
  994. export_pck_zip->set_mode(FileDialog::MODE_SAVE_FILE);
  995. add_child(export_pck_zip);
  996. export_pck_zip->connect("file_selected", this, "_export_pck_zip_selected");
  997. export_error = memnew(Label);
  998. main_vb->add_child(export_error);
  999. export_error->hide();
  1000. export_error->add_color_override("font_color", EditorNode::get_singleton()->get_gui_base()->get_color("error_color", "Editor"));
  1001. export_templates_error = memnew(HBoxContainer);
  1002. main_vb->add_child(export_templates_error);
  1003. export_templates_error->hide();
  1004. Label *export_error2 = memnew(Label);
  1005. export_templates_error->add_child(export_error2);
  1006. export_error2->add_color_override("font_color", EditorNode::get_singleton()->get_gui_base()->get_color("error_color", "Editor"));
  1007. export_error2->set_text(" - " + TTR("Export templates for this platform are missing:") + " ");
  1008. error_dialog = memnew(AcceptDialog);
  1009. error_dialog->set_title("Error");
  1010. error_dialog->set_text(TTR("Export templates for this platform are missing/corrupted:") + " ");
  1011. main_vb->add_child(error_dialog);
  1012. error_dialog->hide();
  1013. LinkButton *download_templates = memnew(LinkButton);
  1014. download_templates->set_text(TTR("Manage Export Templates"));
  1015. download_templates->set_v_size_flags(SIZE_SHRINK_CENTER);
  1016. export_templates_error->add_child(download_templates);
  1017. download_templates->connect("pressed", this, "_open_export_template_manager");
  1018. export_project = memnew(FileDialog);
  1019. export_project->set_access(FileDialog::ACCESS_FILESYSTEM);
  1020. add_child(export_project);
  1021. export_project->connect("file_selected", this, "_export_project_to_path");
  1022. export_project->get_line_edit()->connect("text_changed", this, "_validate_export_path");
  1023. export_debug = memnew(CheckBox);
  1024. export_debug->set_text(TTR("Export With Debug"));
  1025. export_debug->set_pressed(true);
  1026. export_project->get_vbox()->add_child(export_debug);
  1027. export_pck_zip_debug = memnew(CheckBox);
  1028. export_pck_zip_debug->set_text(TTR("Export With Debug"));
  1029. export_pck_zip_debug->set_pressed(true);
  1030. export_pck_zip->get_vbox()->add_child(export_pck_zip_debug);
  1031. set_hide_on_ok(false);
  1032. editor_icons = "EditorIcons";
  1033. default_filename = EditorSettings::get_singleton()->get_project_metadata("export_options", "default_filename", "");
  1034. // If no default set, use project name
  1035. if (default_filename == "") {
  1036. // If no project name defined, use a sane default
  1037. default_filename = ProjectSettings::get_singleton()->get("application/config/name");
  1038. if (default_filename == "") {
  1039. default_filename = "UnnamedProject";
  1040. }
  1041. }
  1042. _update_export_all();
  1043. }
  1044. ProjectExportDialog::~ProjectExportDialog() {
  1045. }