visual_script_editor.cpp 106 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416
  1. /*************************************************************************/
  2. /* visual_script_editor.h */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* http://www.godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2017 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 "visual_script_editor.h"
  31. #include "editor/editor_node.h"
  32. #include "editor/editor_resource_preview.h"
  33. #include "os/input.h"
  34. #include "os/keyboard.h"
  35. #include "visual_script_expression.h"
  36. #include "visual_script_flow_control.h"
  37. #include "visual_script_func_nodes.h"
  38. #include "visual_script_nodes.h"
  39. #ifdef TOOLS_ENABLED
  40. class VisualScriptEditorSignalEdit : public Object {
  41. GDCLASS(VisualScriptEditorSignalEdit, Object)
  42. StringName sig;
  43. public:
  44. UndoRedo *undo_redo;
  45. Ref<VisualScript> script;
  46. protected:
  47. static void _bind_methods() {
  48. ClassDB::bind_method("_sig_changed", &VisualScriptEditorSignalEdit::_sig_changed);
  49. ADD_SIGNAL(MethodInfo("changed"));
  50. }
  51. void _sig_changed() {
  52. _change_notify();
  53. emit_signal("changed");
  54. }
  55. bool _set(const StringName &p_name, const Variant &p_value) {
  56. if (sig == StringName())
  57. return false;
  58. if (p_name == "argument_count") {
  59. int new_argc = p_value;
  60. int argc = script->custom_signal_get_argument_count(sig);
  61. if (argc == new_argc)
  62. return true;
  63. undo_redo->create_action("Change Signal Arguments");
  64. if (new_argc < argc) {
  65. for (int i = new_argc; i < argc; i++) {
  66. undo_redo->add_do_method(script.ptr(), "custom_signal_remove_argument", sig, new_argc);
  67. undo_redo->add_undo_method(script.ptr(), "custom_signal_add_argument", sig, script->custom_signal_get_argument_name(sig, i), script->custom_signal_get_argument_type(sig, i), -1);
  68. }
  69. } else if (new_argc > argc) {
  70. for (int i = argc; i < new_argc; i++) {
  71. undo_redo->add_do_method(script.ptr(), "custom_signal_add_argument", sig, Variant::NIL, "arg" + itos(i + 1), -1);
  72. undo_redo->add_undo_method(script.ptr(), "custom_signal_remove_argument", sig, argc);
  73. }
  74. }
  75. undo_redo->add_do_method(this, "_sig_changed");
  76. undo_redo->add_undo_method(this, "_sig_changed");
  77. undo_redo->commit_action();
  78. return true;
  79. }
  80. if (String(p_name).begins_with("argument/")) {
  81. int idx = String(p_name).get_slice("/", 1).to_int() - 1;
  82. ERR_FAIL_INDEX_V(idx, script->custom_signal_get_argument_count(sig), false);
  83. String what = String(p_name).get_slice("/", 2);
  84. if (what == "type") {
  85. int old_type = script->custom_signal_get_argument_type(sig, idx);
  86. int new_type = p_value;
  87. undo_redo->create_action("Change Argument Type");
  88. undo_redo->add_do_method(script.ptr(), "custom_signal_set_argument_type", sig, idx, new_type);
  89. undo_redo->add_undo_method(script.ptr(), "custom_signal_set_argument_type", sig, idx, old_type);
  90. undo_redo->commit_action();
  91. return true;
  92. }
  93. if (what == "name") {
  94. String old_name = script->custom_signal_get_argument_name(sig, idx);
  95. String new_name = p_value;
  96. undo_redo->create_action("Change Argument name");
  97. undo_redo->add_do_method(script.ptr(), "custom_signal_set_argument_name", sig, idx, new_name);
  98. undo_redo->add_undo_method(script.ptr(), "custom_signal_set_argument_name", sig, idx, old_name);
  99. undo_redo->commit_action();
  100. return true;
  101. }
  102. }
  103. return false;
  104. }
  105. bool _get(const StringName &p_name, Variant &r_ret) const {
  106. if (sig == StringName())
  107. return false;
  108. if (p_name == "argument_count") {
  109. r_ret = script->custom_signal_get_argument_count(sig);
  110. return true;
  111. }
  112. if (String(p_name).begins_with("argument/")) {
  113. int idx = String(p_name).get_slice("/", 1).to_int() - 1;
  114. ERR_FAIL_INDEX_V(idx, script->custom_signal_get_argument_count(sig), false);
  115. String what = String(p_name).get_slice("/", 2);
  116. if (what == "type") {
  117. r_ret = script->custom_signal_get_argument_type(sig, idx);
  118. return true;
  119. }
  120. if (what == "name") {
  121. r_ret = script->custom_signal_get_argument_name(sig, idx);
  122. return true;
  123. }
  124. }
  125. return false;
  126. }
  127. void _get_property_list(List<PropertyInfo> *p_list) const {
  128. if (sig == StringName())
  129. return;
  130. p_list->push_back(PropertyInfo(Variant::INT, "argument_count", PROPERTY_HINT_RANGE, "0,256"));
  131. String argt = "Variant";
  132. for (int i = 1; i < Variant::VARIANT_MAX; i++) {
  133. argt += "," + Variant::get_type_name(Variant::Type(i));
  134. }
  135. for (int i = 0; i < script->custom_signal_get_argument_count(sig); i++) {
  136. p_list->push_back(PropertyInfo(Variant::INT, "argument/" + itos(i + 1) + "/type", PROPERTY_HINT_ENUM, argt));
  137. p_list->push_back(PropertyInfo(Variant::STRING, "argument/" + itos(i + 1) + "/name"));
  138. }
  139. }
  140. public:
  141. void edit(const StringName &p_sig) {
  142. sig = p_sig;
  143. _change_notify();
  144. }
  145. VisualScriptEditorSignalEdit() { undo_redo = NULL; }
  146. };
  147. class VisualScriptEditorVariableEdit : public Object {
  148. GDCLASS(VisualScriptEditorVariableEdit, Object)
  149. StringName var;
  150. public:
  151. UndoRedo *undo_redo;
  152. Ref<VisualScript> script;
  153. protected:
  154. static void _bind_methods() {
  155. ClassDB::bind_method("_var_changed", &VisualScriptEditorVariableEdit::_var_changed);
  156. ClassDB::bind_method("_var_value_changed", &VisualScriptEditorVariableEdit::_var_value_changed);
  157. ADD_SIGNAL(MethodInfo("changed"));
  158. }
  159. void _var_changed() {
  160. _change_notify();
  161. emit_signal("changed");
  162. }
  163. void _var_value_changed() {
  164. _change_notify("value"); //so the whole tree is not redrawn, makes editing smoother in general
  165. emit_signal("changed");
  166. }
  167. bool _set(const StringName &p_name, const Variant &p_value) {
  168. if (var == StringName())
  169. return false;
  170. if (String(p_name) == "value") {
  171. undo_redo->create_action("Set Variable Default Value");
  172. Variant current = script->get_variable_default_value(var);
  173. undo_redo->add_do_method(script.ptr(), "set_variable_default_value", var, p_value);
  174. undo_redo->add_undo_method(script.ptr(), "set_variable_default_value", var, current);
  175. undo_redo->add_do_method(this, "_var_value_changed");
  176. undo_redo->add_undo_method(this, "_var_value_changed");
  177. undo_redo->commit_action();
  178. return true;
  179. }
  180. Dictionary d = script->call("get_variable_info", var);
  181. if (String(p_name) == "type") {
  182. Dictionary dc = d.copy();
  183. dc["type"] = p_value;
  184. undo_redo->create_action("Set Variable Type");
  185. undo_redo->add_do_method(script.ptr(), "set_variable_info", var, dc);
  186. undo_redo->add_undo_method(script.ptr(), "set_variable_info", var, d);
  187. undo_redo->add_do_method(this, "_var_changed");
  188. undo_redo->add_undo_method(this, "_var_changed");
  189. undo_redo->commit_action();
  190. return true;
  191. }
  192. if (String(p_name) == "hint") {
  193. Dictionary dc = d.copy();
  194. dc["hint"] = p_value;
  195. undo_redo->create_action("Set Variable Type");
  196. undo_redo->add_do_method(script.ptr(), "set_variable_info", var, dc);
  197. undo_redo->add_undo_method(script.ptr(), "set_variable_info", var, d);
  198. undo_redo->add_do_method(this, "_var_changed");
  199. undo_redo->add_undo_method(this, "_var_changed");
  200. undo_redo->commit_action();
  201. return true;
  202. }
  203. if (String(p_name) == "hint_string") {
  204. Dictionary dc = d.copy();
  205. dc["hint_string"] = p_value;
  206. undo_redo->create_action("Set Variable Type");
  207. undo_redo->add_do_method(script.ptr(), "set_variable_info", var, dc);
  208. undo_redo->add_undo_method(script.ptr(), "set_variable_info", var, d);
  209. undo_redo->add_do_method(this, "_var_changed");
  210. undo_redo->add_undo_method(this, "_var_changed");
  211. undo_redo->commit_action();
  212. return true;
  213. }
  214. if (String(p_name) == "export") {
  215. script->set_variable_export(var, p_value);
  216. EditorNode::get_singleton()->get_property_editor()->update_tree();
  217. return true;
  218. }
  219. return false;
  220. }
  221. bool _get(const StringName &p_name, Variant &r_ret) const {
  222. if (var == StringName())
  223. return false;
  224. if (String(p_name) == "value") {
  225. r_ret = script->get_variable_default_value(var);
  226. return true;
  227. }
  228. PropertyInfo pinfo = script->get_variable_info(var);
  229. if (String(p_name) == "type") {
  230. r_ret = pinfo.type;
  231. return true;
  232. }
  233. if (String(p_name) == "hint") {
  234. r_ret = pinfo.hint;
  235. return true;
  236. }
  237. if (String(p_name) == "hint_string") {
  238. r_ret = pinfo.hint_string;
  239. return true;
  240. }
  241. if (String(p_name) == "export") {
  242. r_ret = script->get_variable_export(var);
  243. return true;
  244. }
  245. return false;
  246. }
  247. void _get_property_list(List<PropertyInfo> *p_list) const {
  248. if (var == StringName())
  249. return;
  250. String argt = "Variant";
  251. for (int i = 1; i < Variant::VARIANT_MAX; i++) {
  252. argt += "," + Variant::get_type_name(Variant::Type(i));
  253. }
  254. p_list->push_back(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt));
  255. p_list->push_back(PropertyInfo(script->get_variable_info(var).type, "value", script->get_variable_info(var).hint, script->get_variable_info(var).hint_string, PROPERTY_USAGE_DEFAULT));
  256. p_list->push_back(PropertyInfo(Variant::INT, "hint", PROPERTY_HINT_ENUM, "None,Range,ExpRange,Enum,ExpEasing,Length,SpriteFrame,KeyAccel,BitFlags,AllFlags,File,Dir,GlobalFile,GlobalDir,ResourceType,MultilineText"));
  257. p_list->push_back(PropertyInfo(Variant::STRING, "hint_string"));
  258. p_list->push_back(PropertyInfo(Variant::BOOL, "export"));
  259. }
  260. public:
  261. void edit(const StringName &p_var) {
  262. var = p_var;
  263. _change_notify();
  264. }
  265. VisualScriptEditorVariableEdit() { undo_redo = NULL; }
  266. };
  267. static Color _color_from_type(Variant::Type p_type) {
  268. Color color;
  269. switch (p_type) {
  270. case Variant::NIL: color = Color::html("69ecbd"); break;
  271. case Variant::BOOL: color = Color::html("8da6f0"); break;
  272. case Variant::INT: color = Color::html("7dc6ef"); break;
  273. case Variant::REAL: color = Color::html("61daf4"); break;
  274. case Variant::STRING: color = Color::html("6ba7ec"); break;
  275. case Variant::VECTOR2: color = Color::html("bd91f1"); break;
  276. case Variant::RECT2: color = Color::html("f191a5"); break;
  277. case Variant::VECTOR3: color = Color::html("d67dee"); break;
  278. case Variant::TRANSFORM2D: color = Color::html("c4ec69"); break;
  279. case Variant::PLANE: color = Color::html("f77070"); break;
  280. case Variant::QUAT: color = Color::html("ec69a3"); break;
  281. case Variant::RECT3: color = Color::html("ee7991"); break;
  282. case Variant::BASIS: color = Color::html("e3ec69"); break;
  283. case Variant::TRANSFORM: color = Color::html("f6a86e"); break;
  284. case Variant::COLOR: color = Color::html("9dff70"); break;
  285. case Variant::NODE_PATH: color = Color::html("6993ec"); break;
  286. case Variant::_RID: color = Color::html("69ec9a"); break;
  287. case Variant::OBJECT: color = Color::html("79f3e8"); break;
  288. case Variant::DICTIONARY: color = Color::html("77edb1"); break;
  289. case Variant::ARRAY: color = Color::html("e0e0e0"); break;
  290. case Variant::POOL_BYTE_ARRAY: color = Color::html("aaf4c8"); break;
  291. case Variant::POOL_INT_ARRAY: color = Color::html("afdcf5"); break;
  292. case Variant::POOL_REAL_ARRAY: color = Color::html("97e7f8"); break;
  293. case Variant::POOL_STRING_ARRAY: color = Color::html("9dc4f2"); break;
  294. case Variant::POOL_VECTOR2_ARRAY: color = Color::html("d1b3f5"); break;
  295. case Variant::POOL_VECTOR3_ARRAY: color = Color::html("df9bf2"); break;
  296. case Variant::POOL_COLOR_ARRAY: color = Color::html("e9ff97"); break;
  297. default:
  298. color.set_hsv(p_type / float(Variant::VARIANT_MAX), 0.7, 0.7);
  299. }
  300. return color;
  301. }
  302. void VisualScriptEditor::_update_graph_connections() {
  303. graph->clear_connections();
  304. List<VisualScript::SequenceConnection> sequence_conns;
  305. script->get_sequence_connection_list(edited_func, &sequence_conns);
  306. for (List<VisualScript::SequenceConnection>::Element *E = sequence_conns.front(); E; E = E->next()) {
  307. graph->connect_node(itos(E->get().from_node), E->get().from_output, itos(E->get().to_node), 0);
  308. }
  309. List<VisualScript::DataConnection> data_conns;
  310. script->get_data_connection_list(edited_func, &data_conns);
  311. for (List<VisualScript::DataConnection>::Element *E = data_conns.front(); E; E = E->next()) {
  312. VisualScript::DataConnection dc = E->get();
  313. Ref<VisualScriptNode> from_node = script->get_node(edited_func, E->get().from_node);
  314. Ref<VisualScriptNode> to_node = script->get_node(edited_func, E->get().to_node);
  315. if (to_node->has_input_sequence_port()) {
  316. dc.to_port++;
  317. }
  318. dc.from_port += from_node->get_output_sequence_port_count();
  319. graph->connect_node(itos(E->get().from_node), dc.from_port, itos(E->get().to_node), dc.to_port);
  320. }
  321. }
  322. void VisualScriptEditor::_update_graph(int p_only_id) {
  323. if (updating_graph)
  324. return;
  325. updating_graph = true;
  326. //byebye all nodes
  327. if (p_only_id >= 0) {
  328. if (graph->has_node(itos(p_only_id))) {
  329. Node *gid = graph->get_node(itos(p_only_id));
  330. if (gid)
  331. memdelete(gid);
  332. }
  333. } else {
  334. for (int i = 0; i < graph->get_child_count(); i++) {
  335. if (graph->get_child(i)->cast_to<GraphNode>()) {
  336. memdelete(graph->get_child(i));
  337. i--;
  338. }
  339. }
  340. }
  341. if (!script->has_function(edited_func)) {
  342. graph->hide();
  343. select_func_text->show();
  344. updating_graph = false;
  345. return;
  346. }
  347. graph->show();
  348. select_func_text->hide();
  349. Ref<Texture> type_icons[Variant::VARIANT_MAX] = {
  350. Control::get_icon("MiniVariant", "EditorIcons"),
  351. Control::get_icon("MiniBoolean", "EditorIcons"),
  352. Control::get_icon("MiniInteger", "EditorIcons"),
  353. Control::get_icon("MiniFloat", "EditorIcons"),
  354. Control::get_icon("MiniString", "EditorIcons"),
  355. Control::get_icon("MiniVector2", "EditorIcons"),
  356. Control::get_icon("MiniRect2", "EditorIcons"),
  357. Control::get_icon("MiniVector3", "EditorIcons"),
  358. Control::get_icon("MiniTransform2D", "EditorIcons"),
  359. Control::get_icon("MiniPlane", "EditorIcons"),
  360. Control::get_icon("MiniQuat", "EditorIcons"),
  361. Control::get_icon("MiniAabb", "EditorIcons"),
  362. Control::get_icon("MiniBasis", "EditorIcons"),
  363. Control::get_icon("MiniTransform", "EditorIcons"),
  364. Control::get_icon("MiniColor", "EditorIcons"),
  365. Control::get_icon("MiniPath", "EditorIcons"),
  366. Control::get_icon("MiniRid", "EditorIcons"),
  367. Control::get_icon("MiniObject", "EditorIcons"),
  368. Control::get_icon("MiniDictionary", "EditorIcons"),
  369. Control::get_icon("MiniArray", "EditorIcons"),
  370. Control::get_icon("MiniRawArray", "EditorIcons"),
  371. Control::get_icon("MiniIntArray", "EditorIcons"),
  372. Control::get_icon("MiniFloatArray", "EditorIcons"),
  373. Control::get_icon("MiniStringArray", "EditorIcons"),
  374. Control::get_icon("MiniVector2Array", "EditorIcons"),
  375. Control::get_icon("MiniVector3Array", "EditorIcons"),
  376. Control::get_icon("MiniColorArray", "EditorIcons")
  377. };
  378. Ref<Texture> seq_port = Control::get_icon("VisualShaderPort", "EditorIcons");
  379. List<int> ids;
  380. script->get_node_list(edited_func, &ids);
  381. StringName editor_icons = "EditorIcons";
  382. for (List<int>::Element *E = ids.front(); E; E = E->next()) {
  383. if (p_only_id >= 0 && p_only_id != E->get())
  384. continue;
  385. Ref<VisualScriptNode> node = script->get_node(edited_func, E->get());
  386. Vector2 pos = script->get_node_pos(edited_func, E->get());
  387. GraphNode *gnode = memnew(GraphNode);
  388. gnode->set_title(node->get_caption());
  389. if (error_line == E->get()) {
  390. gnode->set_overlay(GraphNode::OVERLAY_POSITION);
  391. } else if (node->is_breakpoint()) {
  392. gnode->set_overlay(GraphNode::OVERLAY_BREAKPOINT);
  393. }
  394. if (EditorSettings::get_singleton()->has("editors/visual_script/color_" + node->get_category())) {
  395. Color c = EditorSettings::get_singleton()->get("editors/visual_script/color_" + node->get_category());
  396. gnode->set_self_modulate(c);
  397. }
  398. gnode->set_meta("__vnode", node);
  399. gnode->set_name(itos(E->get()));
  400. gnode->connect("dragged", this, "_node_moved", varray(E->get()));
  401. gnode->connect("close_request", this, "_remove_node", varray(E->get()), CONNECT_DEFERRED);
  402. if (E->get() != script->get_function_node_id(edited_func)) {
  403. //function can't be erased
  404. gnode->set_show_close_button(true);
  405. }
  406. if (node->cast_to<VisualScriptExpression>()) {
  407. LineEdit *line_edit = memnew(LineEdit);
  408. line_edit->set_text(node->get_text());
  409. line_edit->set_expand_to_text_length(true);
  410. line_edit->add_font_override("font", get_font("source", "EditorFonts"));
  411. gnode->add_child(line_edit);
  412. line_edit->connect("text_changed", this, "_expression_text_changed", varray(E->get()));
  413. } else {
  414. Label *text = memnew(Label);
  415. text->set_text(node->get_text());
  416. gnode->add_child(text);
  417. }
  418. if (node->cast_to<VisualScriptComment>()) {
  419. Ref<VisualScriptComment> vsc = node;
  420. gnode->set_comment(true);
  421. gnode->set_resizeable(true);
  422. gnode->set_custom_minimum_size(vsc->get_size() * EDSCALE);
  423. gnode->connect("resize_request", this, "_comment_node_resized", varray(E->get()));
  424. }
  425. int slot_idx = 0;
  426. bool single_seq_output = node->get_output_sequence_port_count() == 1 && node->get_output_sequence_port_text(0) == String();
  427. gnode->set_slot(0, node->has_input_sequence_port(), TYPE_SEQUENCE, Color(1, 1, 1, 1), single_seq_output, TYPE_SEQUENCE, Color(1, 1, 1, 1), seq_port, seq_port);
  428. gnode->set_offset(pos * EDSCALE);
  429. slot_idx++;
  430. int mixed_seq_ports = 0;
  431. if (!single_seq_output) {
  432. if (node->has_mixed_input_and_sequence_ports()) {
  433. mixed_seq_ports = node->get_output_sequence_port_count();
  434. } else {
  435. for (int i = 0; i < node->get_output_sequence_port_count(); i++) {
  436. Label *text2 = memnew(Label);
  437. text2->set_text(node->get_output_sequence_port_text(i));
  438. text2->set_align(Label::ALIGN_RIGHT);
  439. gnode->add_child(text2);
  440. gnode->set_slot(slot_idx, false, 0, Color(), true, TYPE_SEQUENCE, Color(1, 1, 1, 1), seq_port, seq_port);
  441. slot_idx++;
  442. }
  443. }
  444. }
  445. for (int i = 0; i < MAX(node->get_output_value_port_count(), MAX(mixed_seq_ports, node->get_input_value_port_count())); i++) {
  446. bool left_ok = false;
  447. Variant::Type left_type = Variant::NIL;
  448. String left_name;
  449. if (i < node->get_input_value_port_count()) {
  450. PropertyInfo pi = node->get_input_value_port_info(i);
  451. left_ok = true;
  452. left_type = pi.type;
  453. left_name = pi.name;
  454. }
  455. bool right_ok = false;
  456. Variant::Type right_type = Variant::NIL;
  457. String right_name;
  458. if (i >= mixed_seq_ports && i < node->get_output_value_port_count() + mixed_seq_ports) {
  459. PropertyInfo pi = node->get_output_value_port_info(i - mixed_seq_ports);
  460. right_ok = true;
  461. right_type = pi.type;
  462. right_name = pi.name;
  463. }
  464. HBoxContainer *hbc = memnew(HBoxContainer);
  465. if (left_ok) {
  466. Ref<Texture> t;
  467. if (left_type >= 0 && left_type < Variant::VARIANT_MAX) {
  468. t = type_icons[left_type];
  469. }
  470. if (t.is_valid()) {
  471. TextureRect *tf = memnew(TextureRect);
  472. tf->set_texture(t);
  473. tf->set_stretch_mode(TextureRect::STRETCH_KEEP_CENTERED);
  474. hbc->add_child(tf);
  475. }
  476. hbc->add_child(memnew(Label(left_name)));
  477. if (left_type != Variant::NIL && !script->is_input_value_port_connected(edited_func, E->get(), i)) {
  478. PropertyInfo pi = node->get_input_value_port_info(i);
  479. Button *button = memnew(Button);
  480. Variant value = node->get_default_input_value(i);
  481. if (value.get_type() != left_type) {
  482. //different type? for now convert
  483. //not the same, reconvert
  484. Variant::CallError ce;
  485. const Variant *existingp = &value;
  486. value = Variant::construct(left_type, &existingp, 1, ce, false);
  487. }
  488. if (left_type == Variant::COLOR) {
  489. button->set_custom_minimum_size(Size2(30, 0) * EDSCALE);
  490. button->connect("draw", this, "_draw_color_over_button", varray(button, value));
  491. } else if (left_type == Variant::OBJECT && Ref<Resource>(value).is_valid()) {
  492. Ref<Resource> res = value;
  493. Array arr;
  494. arr.push_back(button->get_instance_id());
  495. arr.push_back(String(value));
  496. EditorResourcePreview::get_singleton()->queue_edited_resource_preview(res, this, "_button_resource_previewed", arr);
  497. } else if (pi.type == Variant::INT && pi.hint == PROPERTY_HINT_ENUM) {
  498. button->set_text(pi.hint_string.get_slice(",", value));
  499. } else {
  500. button->set_text(value);
  501. }
  502. button->connect("pressed", this, "_default_value_edited", varray(button, E->get(), i));
  503. hbc->add_child(button);
  504. }
  505. } else {
  506. Control *c = memnew(Control);
  507. c->set_custom_minimum_size(Size2(10, 0) * EDSCALE);
  508. hbc->add_child(c);
  509. }
  510. hbc->add_spacer();
  511. if (i < mixed_seq_ports) {
  512. Label *text2 = memnew(Label);
  513. text2->set_text(node->get_output_sequence_port_text(i));
  514. text2->set_align(Label::ALIGN_RIGHT);
  515. hbc->add_child(text2);
  516. }
  517. if (right_ok) {
  518. hbc->add_child(memnew(Label(right_name)));
  519. Ref<Texture> t;
  520. if (right_type >= 0 && right_type < Variant::VARIANT_MAX) {
  521. t = type_icons[right_type];
  522. }
  523. if (t.is_valid()) {
  524. TextureRect *tf = memnew(TextureRect);
  525. tf->set_texture(t);
  526. tf->set_stretch_mode(TextureRect::STRETCH_KEEP_CENTERED);
  527. hbc->add_child(tf);
  528. }
  529. }
  530. gnode->add_child(hbc);
  531. if (i < mixed_seq_ports) {
  532. gnode->set_slot(slot_idx, left_ok, left_type, _color_from_type(left_type), true, TYPE_SEQUENCE, Color(1, 1, 1, 1), Ref<Texture>(), seq_port);
  533. } else {
  534. gnode->set_slot(slot_idx, left_ok, left_type, _color_from_type(left_type), right_ok, right_type, _color_from_type(right_type));
  535. }
  536. slot_idx++;
  537. }
  538. graph->add_child(gnode);
  539. if (gnode->is_comment()) {
  540. graph->move_child(gnode, 0);
  541. }
  542. }
  543. _update_graph_connections();
  544. graph->call_deferred("set_scroll_ofs", script->get_function_scroll(edited_func) * EDSCALE); //may need to adapt a bit, let it do so
  545. updating_graph = false;
  546. }
  547. void VisualScriptEditor::_update_members() {
  548. updating_members = true;
  549. members->clear();
  550. TreeItem *root = members->create_item();
  551. TreeItem *functions = members->create_item(root);
  552. functions->set_selectable(0, false);
  553. functions->set_text(0, TTR("Functions:"));
  554. functions->add_button(0, Control::get_icon("Override", "EditorIcons"), 1);
  555. functions->add_button(0, Control::get_icon("Add", "EditorIcons"), 0);
  556. functions->set_custom_bg_color(0, Control::get_color("prop_section", "Editor"));
  557. List<StringName> func_names;
  558. script->get_function_list(&func_names);
  559. for (List<StringName>::Element *E = func_names.front(); E; E = E->next()) {
  560. TreeItem *ti = members->create_item(functions);
  561. ti->set_text(0, E->get());
  562. ti->set_selectable(0, true);
  563. ti->set_editable(0, true);
  564. //ti->add_button(0,Control::get_icon("Edit","EditorIcons"),0); function arguments are in the node now
  565. //ti->add_button(0, Control::get_icon("Del", "EditorIcons"), 1);
  566. ti->set_metadata(0, E->get());
  567. if (E->get() == edited_func) {
  568. ti->set_custom_bg_color(0, get_color("prop_category", "Editor"));
  569. ti->set_custom_color(0, Color(1, 1, 1, 1));
  570. }
  571. if (selected == E->get())
  572. ti->select(0);
  573. }
  574. TreeItem *variables = members->create_item(root);
  575. variables->set_selectable(0, false);
  576. variables->set_text(0, TTR("Variables:"));
  577. variables->add_button(0, Control::get_icon("Add", "EditorIcons"));
  578. variables->set_custom_bg_color(0, Control::get_color("prop_section", "Editor"));
  579. Ref<Texture> type_icons[Variant::VARIANT_MAX] = {
  580. Control::get_icon("MiniVariant", "EditorIcons"),
  581. Control::get_icon("MiniBoolean", "EditorIcons"),
  582. Control::get_icon("MiniInteger", "EditorIcons"),
  583. Control::get_icon("MiniFloat", "EditorIcons"),
  584. Control::get_icon("MiniString", "EditorIcons"),
  585. Control::get_icon("MiniVector2", "EditorIcons"),
  586. Control::get_icon("MiniRect2", "EditorIcons"),
  587. Control::get_icon("MiniVector3", "EditorIcons"),
  588. Control::get_icon("MiniMatrix32", "EditorIcons"),
  589. Control::get_icon("MiniPlane", "EditorIcons"),
  590. Control::get_icon("MiniQuat", "EditorIcons"),
  591. Control::get_icon("MiniAabb", "EditorIcons"),
  592. Control::get_icon("MiniMatrix3", "EditorIcons"),
  593. Control::get_icon("MiniTransform", "EditorIcons"),
  594. Control::get_icon("MiniColor", "EditorIcons"),
  595. Control::get_icon("MiniPath", "EditorIcons"),
  596. Control::get_icon("MiniRid", "EditorIcons"),
  597. Control::get_icon("MiniObject", "EditorIcons"),
  598. Control::get_icon("MiniDictionary", "EditorIcons"),
  599. Control::get_icon("MiniArray", "EditorIcons"),
  600. Control::get_icon("MiniRawArray", "EditorIcons"),
  601. Control::get_icon("MiniIntArray", "EditorIcons"),
  602. Control::get_icon("MiniFloatArray", "EditorIcons"),
  603. Control::get_icon("MiniStringArray", "EditorIcons"),
  604. Control::get_icon("MiniVector2Array", "EditorIcons"),
  605. Control::get_icon("MiniVector3Array", "EditorIcons"),
  606. Control::get_icon("MiniColorArray", "EditorIcons")
  607. };
  608. List<StringName> var_names;
  609. script->get_variable_list(&var_names);
  610. for (List<StringName>::Element *E = var_names.front(); E; E = E->next()) {
  611. TreeItem *ti = members->create_item(variables);
  612. ti->set_text(0, E->get());
  613. Variant var = script->get_variable_default_value(E->get());
  614. ti->set_suffix(0, "=" + String(var));
  615. ti->set_icon(0, type_icons[script->get_variable_info(E->get()).type]);
  616. ti->set_selectable(0, true);
  617. ti->set_editable(0, true);
  618. //ti->add_button(0, Control::get_icon("Edit", "EditorIcons"), 0);
  619. //ti->add_button(0, Control::get_icon("Del", "EditorIcons"), 1);
  620. ti->set_metadata(0, E->get());
  621. if (selected == E->get())
  622. ti->select(0);
  623. }
  624. TreeItem *_signals = members->create_item(root);
  625. _signals->set_selectable(0, false);
  626. _signals->set_text(0, TTR("Signals:"));
  627. _signals->add_button(0, Control::get_icon("Add", "EditorIcons"));
  628. _signals->set_custom_bg_color(0, Control::get_color("prop_section", "Editor"));
  629. List<StringName> signal_names;
  630. script->get_custom_signal_list(&signal_names);
  631. for (List<StringName>::Element *E = signal_names.front(); E; E = E->next()) {
  632. TreeItem *ti = members->create_item(_signals);
  633. ti->set_text(0, E->get());
  634. ti->set_selectable(0, true);
  635. ti->set_editable(0, true);
  636. //ti->add_button(0, Control::get_icon("Edit", "EditorIcons"), 0);
  637. //ti->add_button(0, Control::get_icon("Del", "EditorIcons"), 1);
  638. ti->set_metadata(0, E->get());
  639. if (selected == E->get())
  640. ti->select(0);
  641. }
  642. String base_type = script->get_instance_base_type();
  643. String icon_type = base_type;
  644. if (!Control::has_icon(base_type, "EditorIcons")) {
  645. icon_type = "Object";
  646. }
  647. base_type_select->set_text(base_type);
  648. base_type_select->set_icon(Control::get_icon(icon_type, "EditorIcons"));
  649. updating_members = false;
  650. }
  651. void VisualScriptEditor::_member_selected() {
  652. if (updating_members)
  653. return;
  654. TreeItem *ti = members->get_selected();
  655. ERR_FAIL_COND(!ti);
  656. selected = ti->get_metadata(0);
  657. //print_line("selected: "+String(selected));
  658. if (ti->get_parent() == members->get_root()->get_children()) {
  659. if (edited_func != selected) {
  660. revert_on_drag = edited_func;
  661. edited_func = selected;
  662. _update_members();
  663. _update_graph();
  664. }
  665. return; //or crash because it will become invalid
  666. }
  667. }
  668. void VisualScriptEditor::_member_edited() {
  669. if (updating_members)
  670. return;
  671. TreeItem *ti = members->get_edited();
  672. ERR_FAIL_COND(!ti);
  673. String name = ti->get_metadata(0);
  674. String new_name = ti->get_text(0);
  675. if (name == new_name)
  676. return;
  677. if (!new_name.is_valid_identifier()) {
  678. EditorNode::get_singleton()->show_warning(TTR("Name is not a valid identifier:") + " " + new_name);
  679. updating_members = true;
  680. ti->set_text(0, name);
  681. updating_members = false;
  682. return;
  683. }
  684. if (script->has_function(new_name) || script->has_variable(new_name) || script->has_custom_signal(new_name)) {
  685. EditorNode::get_singleton()->show_warning(TTR("Name already in use by another func/var/signal:") + " " + new_name);
  686. updating_members = true;
  687. ti->set_text(0, name);
  688. updating_members = false;
  689. return;
  690. }
  691. TreeItem *root = members->get_root();
  692. if (ti->get_parent() == root->get_children()) {
  693. if (edited_func == selected) {
  694. edited_func = new_name;
  695. }
  696. selected = new_name;
  697. int node_id = script->get_function_node_id(name);
  698. Ref<VisualScriptFunction> func;
  699. if (script->has_node(name, node_id)) {
  700. func = script->get_node(name, node_id);
  701. }
  702. undo_redo->create_action(TTR("Rename Function"));
  703. undo_redo->add_do_method(script.ptr(), "rename_function", name, new_name);
  704. undo_redo->add_undo_method(script.ptr(), "rename_function", new_name, name);
  705. if (func.is_valid()) {
  706. undo_redo->add_do_method(func.ptr(), "set_name", new_name);
  707. undo_redo->add_undo_method(func.ptr(), "set_name", name);
  708. }
  709. undo_redo->add_do_method(this, "_update_members");
  710. undo_redo->add_undo_method(this, "_update_members");
  711. undo_redo->add_do_method(this, "_update_graph");
  712. undo_redo->add_undo_method(this, "_update_graph");
  713. undo_redo->commit_action();
  714. // _update_graph();
  715. return; //or crash because it will become invalid
  716. }
  717. if (ti->get_parent() == root->get_children()->get_next()) {
  718. selected = new_name;
  719. undo_redo->create_action(TTR("Rename Variable"));
  720. undo_redo->add_do_method(script.ptr(), "rename_variable", name, new_name);
  721. undo_redo->add_undo_method(script.ptr(), "rename_variable", new_name, name);
  722. undo_redo->add_do_method(this, "_update_members");
  723. undo_redo->add_undo_method(this, "_update_members");
  724. undo_redo->commit_action();
  725. return; //or crash because it will become invalid
  726. }
  727. if (ti->get_parent() == root->get_children()->get_next()->get_next()) {
  728. selected = new_name;
  729. undo_redo->create_action(TTR("Rename Signal"));
  730. undo_redo->add_do_method(script.ptr(), "rename_custom_signal", name, new_name);
  731. undo_redo->add_undo_method(script.ptr(), "rename_custom_signal", new_name, name);
  732. undo_redo->add_do_method(this, "_update_members");
  733. undo_redo->add_undo_method(this, "_update_members");
  734. undo_redo->commit_action();
  735. return; //or crash because it will become invalid
  736. }
  737. }
  738. void VisualScriptEditor::_override_pressed(int p_id) {
  739. //override a virtual function or method from base type
  740. ERR_FAIL_COND(!virtuals_in_menu.has(p_id));
  741. VirtualInMenu vim = virtuals_in_menu[p_id];
  742. String name = _validate_name(vim.name);
  743. selected = name;
  744. edited_func = selected;
  745. Ref<VisualScriptFunction> func_node;
  746. func_node.instance();
  747. func_node->set_name(vim.name);
  748. undo_redo->create_action(TTR("Add Function"));
  749. undo_redo->add_do_method(script.ptr(), "add_function", name);
  750. for (int i = 0; i < vim.args.size(); i++) {
  751. func_node->add_argument(vim.args[i].first, vim.args[i].second);
  752. }
  753. undo_redo->add_do_method(script.ptr(), "add_node", name, script->get_available_id(), func_node);
  754. if (vim.ret != Variant::NIL || vim.ret_variant) {
  755. Ref<VisualScriptReturn> ret_node;
  756. ret_node.instance();
  757. ret_node->set_return_type(vim.ret);
  758. ret_node->set_enable_return_value(true);
  759. ret_node->set_name(vim.name);
  760. undo_redo->add_do_method(script.ptr(), "add_node", name, script->get_available_id() + 1, ret_node, Vector2(500, 0));
  761. }
  762. undo_redo->add_undo_method(script.ptr(), "remove_function", name);
  763. undo_redo->add_do_method(this, "_update_members");
  764. undo_redo->add_undo_method(this, "_update_members");
  765. undo_redo->add_do_method(this, "_update_graph");
  766. undo_redo->add_undo_method(this, "_update_graph");
  767. undo_redo->commit_action();
  768. _update_graph();
  769. }
  770. void VisualScriptEditor::_member_button(Object *p_item, int p_column, int p_button) {
  771. TreeItem *ti = p_item->cast_to<TreeItem>();
  772. TreeItem *root = members->get_root();
  773. if (ti->get_parent() == root) {
  774. //main buttons
  775. if (ti == root->get_children()) {
  776. //add function, this one uses menu
  777. if (p_button == 1) {
  778. new_function_menu->clear();
  779. new_function_menu->set_size(Size2(0, 0));
  780. int idx = 0;
  781. virtuals_in_menu.clear();
  782. List<MethodInfo> mi;
  783. ClassDB::get_method_list(script->get_instance_base_type(), &mi);
  784. for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) {
  785. MethodInfo mi = E->get();
  786. if (mi.flags & METHOD_FLAG_VIRTUAL) {
  787. VirtualInMenu vim;
  788. vim.name = mi.name;
  789. vim.ret = mi.return_val.type;
  790. if (mi.return_val.name != String())
  791. vim.ret_variant = true;
  792. else
  793. vim.ret_variant = false;
  794. String desc;
  795. if (mi.return_val.type == Variant::NIL)
  796. desc = "var";
  797. else
  798. desc = Variant::get_type_name(mi.return_val.type);
  799. desc += " " + mi.name + " ( ";
  800. for (int i = 0; i < mi.arguments.size(); i++) {
  801. if (i > 0)
  802. desc += ", ";
  803. if (mi.arguments[i].type == Variant::NIL)
  804. desc += "var ";
  805. else
  806. desc += Variant::get_type_name(mi.arguments[i].type) + " ";
  807. desc += mi.arguments[i].name;
  808. Pair<Variant::Type, String> p;
  809. p.first = mi.arguments[i].type;
  810. p.second = mi.arguments[i].name;
  811. vim.args.push_back(p);
  812. }
  813. desc += " )";
  814. virtuals_in_menu[idx] = vim;
  815. new_function_menu->add_item(desc, idx);
  816. idx++;
  817. }
  818. }
  819. Rect2 pos = members->get_item_rect(ti);
  820. new_function_menu->set_position(members->get_global_position() + pos.position + Vector2(0, pos.size.y));
  821. new_function_menu->popup();
  822. return;
  823. } else if (p_button == 0) {
  824. String name = _validate_name("new_function");
  825. selected = name;
  826. edited_func = selected;
  827. Ref<VisualScriptFunction> func_node;
  828. func_node.instance();
  829. func_node->set_name(name);
  830. undo_redo->create_action(TTR("Add Function"));
  831. undo_redo->add_do_method(script.ptr(), "add_function", name);
  832. undo_redo->add_do_method(script.ptr(), "add_node", name, script->get_available_id(), func_node);
  833. undo_redo->add_undo_method(script.ptr(), "remove_function", name);
  834. undo_redo->add_do_method(this, "_update_members");
  835. undo_redo->add_undo_method(this, "_update_members");
  836. undo_redo->add_do_method(this, "_update_graph");
  837. undo_redo->add_undo_method(this, "_update_graph");
  838. undo_redo->commit_action();
  839. _update_graph();
  840. }
  841. return; //or crash because it will become invalid
  842. }
  843. if (ti == root->get_children()->get_next()) {
  844. //add variable
  845. String name = _validate_name("new_variable");
  846. selected = name;
  847. undo_redo->create_action(TTR("Add Variable"));
  848. undo_redo->add_do_method(script.ptr(), "add_variable", name);
  849. undo_redo->add_undo_method(script.ptr(), "remove_variable", name);
  850. undo_redo->add_do_method(this, "_update_members");
  851. undo_redo->add_undo_method(this, "_update_members");
  852. undo_redo->commit_action();
  853. return; //or crash because it will become invalid
  854. }
  855. if (ti == root->get_children()->get_next()->get_next()) {
  856. //add variable
  857. String name = _validate_name("new_signal");
  858. selected = name;
  859. undo_redo->create_action(TTR("Add Signal"));
  860. undo_redo->add_do_method(script.ptr(), "add_custom_signal", name);
  861. undo_redo->add_undo_method(script.ptr(), "remove_custom_signal", name);
  862. undo_redo->add_do_method(this, "_update_members");
  863. undo_redo->add_undo_method(this, "_update_members");
  864. undo_redo->commit_action();
  865. return; //or crash because it will become invalid
  866. }
  867. }
  868. }
  869. void VisualScriptEditor::_expression_text_changed(const String &p_text, int p_id) {
  870. Ref<VisualScriptExpression> vse = script->get_node(edited_func, p_id);
  871. if (!vse.is_valid())
  872. return;
  873. updating_graph = true;
  874. undo_redo->create_action(TTR("Change Expression"), UndoRedo::MERGE_ENDS);
  875. undo_redo->add_do_property(vse.ptr(), "expression", p_text);
  876. undo_redo->add_undo_property(vse.ptr(), "expression", vse->get("expression"));
  877. undo_redo->add_do_method(this, "_update_graph", p_id);
  878. undo_redo->add_undo_method(this, "_update_graph", p_id);
  879. undo_redo->commit_action();
  880. Node *node = graph->get_node(itos(p_id));
  881. if (node->cast_to<Control>())
  882. node->cast_to<Control>()->set_size(Vector2(1, 1)); //shrink if text is smaller
  883. updating_graph = false;
  884. }
  885. void VisualScriptEditor::_available_node_doubleclicked() {
  886. TreeItem *item = nodes->get_selected();
  887. if (!item)
  888. return;
  889. String which = item->get_metadata(0);
  890. if (which == String())
  891. return;
  892. Vector2 ofs = graph->get_scroll_ofs() + graph->get_size() * 0.5;
  893. if (graph->is_using_snap()) {
  894. int snap = graph->get_snap();
  895. ofs = ofs.snapped(Vector2(snap, snap));
  896. }
  897. ofs /= EDSCALE;
  898. while (true) {
  899. bool exists = false;
  900. List<int> existing;
  901. script->get_node_list(edited_func, &existing);
  902. for (List<int>::Element *E = existing.front(); E; E = E->next()) {
  903. Point2 pos = script->get_node_pos(edited_func, E->get());
  904. if (pos.distance_to(ofs) < 15) {
  905. ofs += Vector2(graph->get_snap(), graph->get_snap());
  906. exists = true;
  907. break;
  908. }
  909. }
  910. if (exists)
  911. continue;
  912. break;
  913. }
  914. Ref<VisualScriptNode> vnode = VisualScriptLanguage::singleton->create_node_from_name(which);
  915. int new_id = script->get_available_id();
  916. undo_redo->create_action(TTR("Add Node"));
  917. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
  918. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  919. undo_redo->add_do_method(this, "_update_graph");
  920. undo_redo->add_undo_method(this, "_update_graph");
  921. undo_redo->commit_action();
  922. Node *node = graph->get_node(itos(new_id));
  923. if (node) {
  924. graph->set_selected(node);
  925. _node_selected(node);
  926. }
  927. }
  928. void VisualScriptEditor::_update_available_nodes() {
  929. nodes->clear();
  930. TreeItem *root = nodes->create_item();
  931. Map<String, TreeItem *> path_cache;
  932. String filter = node_filter->get_text();
  933. List<String> fnodes;
  934. VisualScriptLanguage::singleton->get_registered_node_names(&fnodes);
  935. for (List<String>::Element *E = fnodes.front(); E; E = E->next()) {
  936. Vector<String> path = E->get().split("/");
  937. if (filter != String() && path.size() && path[path.size() - 1].findn(filter) == -1)
  938. continue;
  939. String sp;
  940. TreeItem *parent = root;
  941. for (int i = 0; i < path.size() - 1; i++) {
  942. if (i > 0)
  943. sp += ",";
  944. sp += path[i];
  945. if (!path_cache.has(sp)) {
  946. TreeItem *pathn = nodes->create_item(parent);
  947. pathn->set_selectable(0, false);
  948. pathn->set_text(0, path[i].capitalize());
  949. path_cache[sp] = pathn;
  950. parent = pathn;
  951. if (filter == String()) {
  952. pathn->set_collapsed(true); //should remember state
  953. }
  954. } else {
  955. parent = path_cache[sp];
  956. }
  957. }
  958. TreeItem *item = nodes->create_item(parent);
  959. item->set_text(0, path[path.size() - 1].capitalize());
  960. item->set_selectable(0, true);
  961. item->set_metadata(0, E->get());
  962. }
  963. }
  964. String VisualScriptEditor::_validate_name(const String &p_name) const {
  965. String valid = p_name;
  966. int counter = 1;
  967. while (true) {
  968. bool exists = script->has_function(valid) || script->has_variable(valid) || script->has_custom_signal(valid);
  969. if (exists) {
  970. counter++;
  971. valid = p_name + "_" + itos(counter);
  972. continue;
  973. }
  974. break;
  975. }
  976. return valid;
  977. }
  978. void VisualScriptEditor::_on_nodes_delete() {
  979. List<int> to_erase;
  980. for (int i = 0; i < graph->get_child_count(); i++) {
  981. GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
  982. if (gn) {
  983. if (gn->is_selected() && gn->is_close_button_visible()) {
  984. to_erase.push_back(gn->get_name().operator String().to_int());
  985. }
  986. }
  987. }
  988. if (to_erase.empty())
  989. return;
  990. undo_redo->create_action("Remove VisualScript Nodes");
  991. for (List<int>::Element *F = to_erase.front(); F; F = F->next()) {
  992. undo_redo->add_do_method(script.ptr(), "remove_node", edited_func, F->get());
  993. undo_redo->add_undo_method(script.ptr(), "add_node", edited_func, F->get(), script->get_node(edited_func, F->get()), script->get_node_pos(edited_func, F->get()));
  994. List<VisualScript::SequenceConnection> sequence_conns;
  995. script->get_sequence_connection_list(edited_func, &sequence_conns);
  996. for (List<VisualScript::SequenceConnection>::Element *E = sequence_conns.front(); E; E = E->next()) {
  997. if (E->get().from_node == F->get() || E->get().to_node == F->get()) {
  998. undo_redo->add_undo_method(script.ptr(), "sequence_connect", edited_func, E->get().from_node, E->get().from_output, E->get().to_node);
  999. }
  1000. }
  1001. List<VisualScript::DataConnection> data_conns;
  1002. script->get_data_connection_list(edited_func, &data_conns);
  1003. for (List<VisualScript::DataConnection>::Element *E = data_conns.front(); E; E = E->next()) {
  1004. if (E->get().from_node == F->get() || E->get().to_node == F->get()) {
  1005. undo_redo->add_undo_method(script.ptr(), "data_connect", edited_func, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
  1006. }
  1007. }
  1008. }
  1009. undo_redo->add_do_method(this, "_update_graph");
  1010. undo_redo->add_undo_method(this, "_update_graph");
  1011. undo_redo->commit_action();
  1012. }
  1013. void VisualScriptEditor::_on_nodes_duplicate() {
  1014. List<int> to_duplicate;
  1015. for (int i = 0; i < graph->get_child_count(); i++) {
  1016. GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
  1017. if (gn) {
  1018. if (gn->is_selected() && gn->is_close_button_visible()) {
  1019. to_duplicate.push_back(gn->get_name().operator String().to_int());
  1020. }
  1021. }
  1022. }
  1023. if (to_duplicate.empty())
  1024. return;
  1025. undo_redo->create_action("Duplicate VisualScript Nodes");
  1026. int idc = script->get_available_id() + 1;
  1027. Set<int> to_select;
  1028. for (List<int>::Element *F = to_duplicate.front(); F; F = F->next()) {
  1029. Ref<VisualScriptNode> node = script->get_node(edited_func, F->get());
  1030. Ref<VisualScriptNode> dupe = node->duplicate();
  1031. int new_id = idc++;
  1032. to_select.insert(new_id);
  1033. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, dupe, script->get_node_pos(edited_func, F->get()) + Vector2(20, 20));
  1034. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  1035. }
  1036. undo_redo->add_do_method(this, "_update_graph");
  1037. undo_redo->add_undo_method(this, "_update_graph");
  1038. undo_redo->commit_action();
  1039. for (int i = 0; i < graph->get_child_count(); i++) {
  1040. GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
  1041. if (gn) {
  1042. int id = gn->get_name().operator String().to_int();
  1043. gn->set_selected(to_select.has(id));
  1044. }
  1045. }
  1046. if (to_select.size()) {
  1047. EditorNode::get_singleton()->push_item(script->get_node(edited_func, to_select.front()->get()).ptr());
  1048. }
  1049. }
  1050. void VisualScriptEditor::_input(const Ref<InputEvent> &p_event) {
  1051. Ref<InputEventMouseButton> mb = p_event;
  1052. if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
  1053. revert_on_drag = String(); //so we can still drag functions
  1054. }
  1055. }
  1056. Variant VisualScriptEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from) {
  1057. if (p_from == nodes) {
  1058. TreeItem *it = nodes->get_item_at_pos(p_point);
  1059. if (!it)
  1060. return Variant();
  1061. String type = it->get_metadata(0);
  1062. if (type == String())
  1063. return Variant();
  1064. Dictionary dd;
  1065. dd["type"] = "visual_script_node_drag";
  1066. dd["node_type"] = type;
  1067. Label *label = memnew(Label);
  1068. label->set_text(it->get_text(0));
  1069. set_drag_preview(label);
  1070. return dd;
  1071. }
  1072. if (p_from == members) {
  1073. TreeItem *it = members->get_item_at_pos(p_point);
  1074. if (!it)
  1075. return Variant();
  1076. String type = it->get_metadata(0);
  1077. if (type == String())
  1078. return Variant();
  1079. Dictionary dd;
  1080. TreeItem *root = members->get_root();
  1081. if (it->get_parent() == root->get_children()) {
  1082. dd["type"] = "visual_script_function_drag";
  1083. dd["function"] = type;
  1084. if (revert_on_drag != String()) {
  1085. edited_func = revert_on_drag; //revert so function does not change
  1086. revert_on_drag = String();
  1087. _update_graph();
  1088. }
  1089. } else if (it->get_parent() == root->get_children()->get_next()) {
  1090. dd["type"] = "visual_script_variable_drag";
  1091. dd["variable"] = type;
  1092. } else if (it->get_parent() == root->get_children()->get_next()->get_next()) {
  1093. dd["type"] = "visual_script_signal_drag";
  1094. dd["signal"] = type;
  1095. } else {
  1096. return Variant();
  1097. }
  1098. Label *label = memnew(Label);
  1099. label->set_text(it->get_text(0));
  1100. set_drag_preview(label);
  1101. return dd;
  1102. }
  1103. return Variant();
  1104. }
  1105. bool VisualScriptEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const {
  1106. if (p_from == graph) {
  1107. Dictionary d = p_data;
  1108. if (d.has("type") &&
  1109. (String(d["type"]) == "visual_script_node_drag" ||
  1110. String(d["type"]) == "visual_script_function_drag" ||
  1111. String(d["type"]) == "visual_script_variable_drag" ||
  1112. String(d["type"]) == "visual_script_signal_drag" ||
  1113. String(d["type"]) == "obj_property" ||
  1114. String(d["type"]) == "resource" ||
  1115. String(d["type"]) == "files" ||
  1116. String(d["type"]) == "nodes")) {
  1117. if (String(d["type"]) == "obj_property") {
  1118. #ifdef OSX_ENABLED
  1119. const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Meta to drop a Getter. Hold Shift to drop a generic signature."));
  1120. #else
  1121. const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Ctrl to drop a Getter. Hold Shift to drop a generic signature."));
  1122. #endif
  1123. }
  1124. if (String(d["type"]) == "nodes") {
  1125. #ifdef OSX_ENABLED
  1126. const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Meta to drop a simple reference to the node."));
  1127. #else
  1128. const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Ctrl to drop a simple reference to the node."));
  1129. #endif
  1130. }
  1131. if (String(d["type"]) == "visual_script_variable_drag") {
  1132. #ifdef OSX_ENABLED
  1133. const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Meta to drop a Variable Setter."));
  1134. #else
  1135. const_cast<VisualScriptEditor *>(this)->_show_hint(TTR("Hold Ctrl to drop a Variable Setter."));
  1136. #endif
  1137. }
  1138. return true;
  1139. }
  1140. }
  1141. return false;
  1142. }
  1143. #ifdef TOOLS_ENABLED
  1144. static Node *_find_script_node(Node *p_edited_scene, Node *p_current_node, const Ref<Script> &script) {
  1145. if (p_edited_scene != p_current_node && p_current_node->get_owner() != p_edited_scene)
  1146. return NULL;
  1147. Ref<Script> scr = p_current_node->get_script();
  1148. if (scr.is_valid() && scr == script)
  1149. return p_current_node;
  1150. for (int i = 0; i < p_current_node->get_child_count(); i++) {
  1151. Node *n = _find_script_node(p_edited_scene, p_current_node->get_child(i), script);
  1152. if (n)
  1153. return n;
  1154. }
  1155. return NULL;
  1156. }
  1157. #endif
  1158. void VisualScriptEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) {
  1159. if (p_from == graph) {
  1160. Dictionary d = p_data;
  1161. if (d.has("type") && String(d["type"]) == "visual_script_node_drag") {
  1162. Vector2 ofs = graph->get_scroll_ofs() + p_point;
  1163. if (graph->is_using_snap()) {
  1164. int snap = graph->get_snap();
  1165. ofs = ofs.snapped(Vector2(snap, snap));
  1166. }
  1167. ofs /= EDSCALE;
  1168. Ref<VisualScriptNode> vnode = VisualScriptLanguage::singleton->create_node_from_name(d["node_type"]);
  1169. int new_id = script->get_available_id();
  1170. undo_redo->create_action(TTR("Add Node"));
  1171. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
  1172. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  1173. undo_redo->add_do_method(this, "_update_graph");
  1174. undo_redo->add_undo_method(this, "_update_graph");
  1175. undo_redo->commit_action();
  1176. Node *node = graph->get_node(itos(new_id));
  1177. if (node) {
  1178. graph->set_selected(node);
  1179. _node_selected(node);
  1180. }
  1181. }
  1182. if (d.has("type") && String(d["type"]) == "visual_script_variable_drag") {
  1183. #ifdef OSX_ENABLED
  1184. bool use_set = Input::get_singleton()->is_key_pressed(KEY_META);
  1185. #else
  1186. bool use_set = Input::get_singleton()->is_key_pressed(KEY_CONTROL);
  1187. #endif
  1188. Vector2 ofs = graph->get_scroll_ofs() + p_point;
  1189. if (graph->is_using_snap()) {
  1190. int snap = graph->get_snap();
  1191. ofs = ofs.snapped(Vector2(snap, snap));
  1192. }
  1193. ofs /= EDSCALE;
  1194. Ref<VisualScriptNode> vnode;
  1195. if (use_set) {
  1196. Ref<VisualScriptVariableSet> vnodes;
  1197. vnodes.instance();
  1198. vnodes->set_variable(d["variable"]);
  1199. vnode = vnodes;
  1200. } else {
  1201. Ref<VisualScriptVariableGet> vnodeg;
  1202. vnodeg.instance();
  1203. vnodeg->set_variable(d["variable"]);
  1204. vnode = vnodeg;
  1205. }
  1206. int new_id = script->get_available_id();
  1207. undo_redo->create_action(TTR("Add Node"));
  1208. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
  1209. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  1210. undo_redo->add_do_method(this, "_update_graph");
  1211. undo_redo->add_undo_method(this, "_update_graph");
  1212. undo_redo->commit_action();
  1213. Node *node = graph->get_node(itos(new_id));
  1214. if (node) {
  1215. graph->set_selected(node);
  1216. _node_selected(node);
  1217. }
  1218. }
  1219. if (d.has("type") && String(d["type"]) == "visual_script_function_drag") {
  1220. Vector2 ofs = graph->get_scroll_ofs() + p_point;
  1221. if (graph->is_using_snap()) {
  1222. int snap = graph->get_snap();
  1223. ofs = ofs.snapped(Vector2(snap, snap));
  1224. }
  1225. ofs /= EDSCALE;
  1226. Ref<VisualScriptFunctionCall> vnode;
  1227. vnode.instance();
  1228. vnode->set_call_mode(VisualScriptFunctionCall::CALL_MODE_SELF);
  1229. int new_id = script->get_available_id();
  1230. undo_redo->create_action(TTR("Add Node"));
  1231. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
  1232. undo_redo->add_do_method(vnode.ptr(), "set_base_type", script->get_instance_base_type());
  1233. undo_redo->add_do_method(vnode.ptr(), "set_function", d["function"]);
  1234. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  1235. undo_redo->add_do_method(this, "_update_graph");
  1236. undo_redo->add_undo_method(this, "_update_graph");
  1237. undo_redo->commit_action();
  1238. Node *node = graph->get_node(itos(new_id));
  1239. if (node) {
  1240. graph->set_selected(node);
  1241. _node_selected(node);
  1242. }
  1243. }
  1244. if (d.has("type") && String(d["type"]) == "visual_script_signal_drag") {
  1245. Vector2 ofs = graph->get_scroll_ofs() + p_point;
  1246. if (graph->is_using_snap()) {
  1247. int snap = graph->get_snap();
  1248. ofs = ofs.snapped(Vector2(snap, snap));
  1249. }
  1250. ofs /= EDSCALE;
  1251. Ref<VisualScriptEmitSignal> vnode;
  1252. vnode.instance();
  1253. vnode->set_signal(d["signal"]);
  1254. int new_id = script->get_available_id();
  1255. undo_redo->create_action(TTR("Add Node"));
  1256. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
  1257. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  1258. undo_redo->add_do_method(this, "_update_graph");
  1259. undo_redo->add_undo_method(this, "_update_graph");
  1260. undo_redo->commit_action();
  1261. Node *node = graph->get_node(itos(new_id));
  1262. if (node) {
  1263. graph->set_selected(node);
  1264. _node_selected(node);
  1265. }
  1266. }
  1267. if (d.has("type") && String(d["type"]) == "resource") {
  1268. Vector2 ofs = graph->get_scroll_ofs() + p_point;
  1269. if (graph->is_using_snap()) {
  1270. int snap = graph->get_snap();
  1271. ofs = ofs.snapped(Vector2(snap, snap));
  1272. }
  1273. ofs /= EDSCALE;
  1274. Ref<VisualScriptPreload> prnode;
  1275. prnode.instance();
  1276. prnode->set_preload(d["resource"]);
  1277. int new_id = script->get_available_id();
  1278. undo_redo->create_action(TTR("Add Preload Node"));
  1279. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, prnode, ofs);
  1280. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  1281. undo_redo->add_do_method(this, "_update_graph");
  1282. undo_redo->add_undo_method(this, "_update_graph");
  1283. undo_redo->commit_action();
  1284. Node *node = graph->get_node(itos(new_id));
  1285. if (node) {
  1286. graph->set_selected(node);
  1287. _node_selected(node);
  1288. }
  1289. }
  1290. if (d.has("type") && String(d["type"]) == "files") {
  1291. Vector2 ofs = graph->get_scroll_ofs() + p_point;
  1292. if (graph->is_using_snap()) {
  1293. int snap = graph->get_snap();
  1294. ofs = ofs.snapped(Vector2(snap, snap));
  1295. }
  1296. ofs /= EDSCALE;
  1297. Array files = d["files"];
  1298. List<int> new_ids;
  1299. int new_id = script->get_available_id();
  1300. if (files.size()) {
  1301. undo_redo->create_action(TTR("Add Preload Node"));
  1302. for (int i = 0; i < files.size(); i++) {
  1303. Ref<Resource> res = ResourceLoader::load(files[i]);
  1304. if (!res.is_valid())
  1305. continue;
  1306. Ref<VisualScriptPreload> prnode;
  1307. prnode.instance();
  1308. prnode->set_preload(res);
  1309. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, prnode, ofs);
  1310. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  1311. new_ids.push_back(new_id);
  1312. new_id++;
  1313. ofs += Vector2(20, 20) * EDSCALE;
  1314. }
  1315. undo_redo->add_do_method(this, "_update_graph");
  1316. undo_redo->add_undo_method(this, "_update_graph");
  1317. undo_redo->commit_action();
  1318. }
  1319. for (List<int>::Element *E = new_ids.front(); E; E = E->next()) {
  1320. Node *node = graph->get_node(itos(E->get()));
  1321. if (node) {
  1322. graph->set_selected(node);
  1323. _node_selected(node);
  1324. }
  1325. }
  1326. }
  1327. if (d.has("type") && String(d["type"]) == "nodes") {
  1328. Node *sn = _find_script_node(get_tree()->get_edited_scene_root(), get_tree()->get_edited_scene_root(), script);
  1329. if (!sn) {
  1330. EditorNode::get_singleton()->show_warning("Can't drop nodes because script '" + get_name() + "' is not used in this scene.");
  1331. return;
  1332. }
  1333. #ifdef OSX_ENABLED
  1334. bool use_node = Input::get_singleton()->is_key_pressed(KEY_META);
  1335. #else
  1336. bool use_node = Input::get_singleton()->is_key_pressed(KEY_CONTROL);
  1337. #endif
  1338. Array nodes = d["nodes"];
  1339. Vector2 ofs = graph->get_scroll_ofs() + p_point;
  1340. if (graph->is_using_snap()) {
  1341. int snap = graph->get_snap();
  1342. ofs = ofs.snapped(Vector2(snap, snap));
  1343. }
  1344. ofs /= EDSCALE;
  1345. undo_redo->create_action(TTR("Add Node(s) From Tree"));
  1346. int base_id = script->get_available_id();
  1347. if (nodes.size() > 1) {
  1348. use_node = true;
  1349. }
  1350. for (int i = 0; i < nodes.size(); i++) {
  1351. NodePath np = nodes[i];
  1352. Node *node = get_node(np);
  1353. if (!node) {
  1354. continue;
  1355. }
  1356. Ref<VisualScriptNode> n;
  1357. if (use_node) {
  1358. Ref<VisualScriptSceneNode> scene_node;
  1359. scene_node.instance();
  1360. scene_node->set_node_path(sn->get_path_to(node));
  1361. n = scene_node;
  1362. } else {
  1363. Ref<VisualScriptFunctionCall> call;
  1364. call.instance();
  1365. call->set_call_mode(VisualScriptFunctionCall::CALL_MODE_NODE_PATH);
  1366. call->set_base_path(sn->get_path_to(node));
  1367. call->set_base_type(node->get_class());
  1368. n = call;
  1369. method_select->select_method_from_instance(node);
  1370. selecting_method_id = base_id;
  1371. }
  1372. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, base_id, n, ofs);
  1373. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, base_id);
  1374. base_id++;
  1375. ofs += Vector2(25, 25);
  1376. }
  1377. undo_redo->add_do_method(this, "_update_graph");
  1378. undo_redo->add_undo_method(this, "_update_graph");
  1379. undo_redo->commit_action();
  1380. }
  1381. if (d.has("type") && String(d["type"]) == "obj_property") {
  1382. Node *sn = _find_script_node(get_tree()->get_edited_scene_root(), get_tree()->get_edited_scene_root(), script);
  1383. if (!sn && !Input::get_singleton()->is_key_pressed(KEY_SHIFT)) {
  1384. EditorNode::get_singleton()->show_warning("Can't drop properties because script '" + get_name() + "' is not used in this scene.\nDrop holding 'Shift' to just copy the signature.");
  1385. return;
  1386. }
  1387. Object *obj = d["object"];
  1388. if (!obj)
  1389. return;
  1390. Node *node = obj->cast_to<Node>();
  1391. Vector2 ofs = graph->get_scroll_ofs() + p_point;
  1392. if (graph->is_using_snap()) {
  1393. int snap = graph->get_snap();
  1394. ofs = ofs.snapped(Vector2(snap, snap));
  1395. }
  1396. ofs /= EDSCALE;
  1397. #ifdef OSX_ENABLED
  1398. bool use_get = Input::get_singleton()->is_key_pressed(KEY_META);
  1399. #else
  1400. bool use_get = Input::get_singleton()->is_key_pressed(KEY_CONTROL);
  1401. #endif
  1402. if (!node || Input::get_singleton()->is_key_pressed(KEY_SHIFT)) {
  1403. if (use_get)
  1404. undo_redo->create_action(TTR("Add Getter Property"));
  1405. else
  1406. undo_redo->create_action(TTR("Add Setter Property"));
  1407. int base_id = script->get_available_id();
  1408. Ref<VisualScriptNode> vnode;
  1409. if (!use_get) {
  1410. Ref<VisualScriptPropertySet> pset;
  1411. pset.instance();
  1412. pset->set_call_mode(VisualScriptPropertySet::CALL_MODE_INSTANCE);
  1413. pset->set_base_type(obj->get_class());
  1414. /*if (use_value) {
  1415. pset->set_use_builtin_value(true);
  1416. pset->set_builtin_value(d["value"]);
  1417. }*/
  1418. vnode = pset;
  1419. } else {
  1420. Ref<VisualScriptPropertyGet> pget;
  1421. pget.instance();
  1422. pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_INSTANCE);
  1423. pget->set_base_type(obj->get_class());
  1424. vnode = pget;
  1425. }
  1426. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, base_id, vnode, ofs);
  1427. undo_redo->add_do_method(vnode.ptr(), "set_property", d["property"]);
  1428. if (!use_get) {
  1429. undo_redo->add_do_method(vnode.ptr(), "set_default_input_value", 0, d["value"]);
  1430. }
  1431. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, base_id);
  1432. undo_redo->add_do_method(this, "_update_graph");
  1433. undo_redo->add_undo_method(this, "_update_graph");
  1434. undo_redo->commit_action();
  1435. } else {
  1436. if (use_get)
  1437. undo_redo->create_action(TTR("Add Getter Property"));
  1438. else
  1439. undo_redo->create_action(TTR("Add Setter Property"));
  1440. int base_id = script->get_available_id();
  1441. Ref<VisualScriptNode> vnode;
  1442. if (!use_get) {
  1443. Ref<VisualScriptPropertySet> pset;
  1444. pset.instance();
  1445. if (sn == node) {
  1446. pset->set_call_mode(VisualScriptPropertySet::CALL_MODE_SELF);
  1447. } else {
  1448. pset->set_call_mode(VisualScriptPropertySet::CALL_MODE_NODE_PATH);
  1449. pset->set_base_path(sn->get_path_to(node));
  1450. }
  1451. vnode = pset;
  1452. } else {
  1453. Ref<VisualScriptPropertyGet> pget;
  1454. pget.instance();
  1455. if (sn == node) {
  1456. pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_SELF);
  1457. } else {
  1458. pget->set_call_mode(VisualScriptPropertyGet::CALL_MODE_NODE_PATH);
  1459. pget->set_base_path(sn->get_path_to(node));
  1460. }
  1461. vnode = pget;
  1462. }
  1463. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, base_id, vnode, ofs);
  1464. undo_redo->add_do_method(vnode.ptr(), "set_property", d["property"]);
  1465. if (!use_get) {
  1466. undo_redo->add_do_method(vnode.ptr(), "set_default_input_value", 0, d["value"]);
  1467. }
  1468. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, base_id);
  1469. undo_redo->add_do_method(this, "_update_graph");
  1470. undo_redo->add_undo_method(this, "_update_graph");
  1471. undo_redo->commit_action();
  1472. }
  1473. }
  1474. }
  1475. }
  1476. void VisualScriptEditor::_selected_method(const String &p_method) {
  1477. Ref<VisualScriptFunctionCall> vsfc = script->get_node(edited_func, selecting_method_id);
  1478. if (!vsfc.is_valid())
  1479. return;
  1480. vsfc->set_function(p_method);
  1481. }
  1482. void VisualScriptEditor::_draw_color_over_button(Object *obj, Color p_color) {
  1483. Button *button = obj->cast_to<Button>();
  1484. if (!button)
  1485. return;
  1486. Ref<StyleBox> normal = get_stylebox("normal", "Button");
  1487. button->draw_rect(Rect2(normal->get_offset(), button->get_size() - normal->get_minimum_size()), p_color);
  1488. }
  1489. void VisualScriptEditor::_button_resource_previewed(const String &p_path, const Ref<Texture> &p_preview, Variant p_ud) {
  1490. Array ud = p_ud;
  1491. ERR_FAIL_COND(ud.size() != 2);
  1492. ObjectID id = ud[0];
  1493. Object *obj = ObjectDB::get_instance(id);
  1494. if (!obj)
  1495. return;
  1496. Button *b = obj->cast_to<Button>();
  1497. ERR_FAIL_COND(!b);
  1498. if (p_preview.is_null()) {
  1499. b->set_text(ud[1]);
  1500. } else {
  1501. b->set_icon(p_preview);
  1502. }
  1503. }
  1504. /////////////////////////
  1505. void VisualScriptEditor::apply_code() {
  1506. }
  1507. Ref<Script> VisualScriptEditor::get_edited_script() const {
  1508. return script;
  1509. }
  1510. Vector<String> VisualScriptEditor::get_functions() {
  1511. return Vector<String>();
  1512. }
  1513. void VisualScriptEditor::set_edited_script(const Ref<Script> &p_script) {
  1514. script = p_script;
  1515. signal_editor->script = p_script;
  1516. signal_editor->undo_redo = undo_redo;
  1517. variable_editor->script = p_script;
  1518. variable_editor->undo_redo = undo_redo;
  1519. script->connect("node_ports_changed", this, "_node_ports_changed");
  1520. _update_members();
  1521. _update_available_nodes();
  1522. }
  1523. void VisualScriptEditor::reload_text() {
  1524. }
  1525. String VisualScriptEditor::get_name() {
  1526. String name;
  1527. if (script->get_path().find("local://") == -1 && script->get_path().find("::") == -1) {
  1528. name = script->get_path().get_file();
  1529. if (is_unsaved()) {
  1530. name += "(*)";
  1531. }
  1532. } else if (script->get_name() != "")
  1533. name = script->get_name();
  1534. else
  1535. name = script->get_class() + "(" + itos(script->get_instance_id()) + ")";
  1536. return name;
  1537. }
  1538. Ref<Texture> VisualScriptEditor::get_icon() {
  1539. return Control::get_icon("VisualScript", "EditorIcons");
  1540. }
  1541. bool VisualScriptEditor::is_unsaved() {
  1542. #ifdef TOOLS_ENABLED
  1543. return script->is_edited() || script->are_subnodes_edited();
  1544. #else
  1545. return false;
  1546. #endif
  1547. }
  1548. Variant VisualScriptEditor::get_edit_state() {
  1549. Dictionary d;
  1550. d["function"] = edited_func;
  1551. d["scroll"] = graph->get_scroll_ofs();
  1552. d["zoom"] = graph->get_zoom();
  1553. d["using_snap"] = graph->is_using_snap();
  1554. d["snap"] = graph->get_snap();
  1555. return d;
  1556. }
  1557. void VisualScriptEditor::set_edit_state(const Variant &p_state) {
  1558. Dictionary d = p_state;
  1559. if (d.has("function")) {
  1560. edited_func = p_state;
  1561. selected = edited_func;
  1562. }
  1563. _update_graph();
  1564. _update_members();
  1565. if (d.has("scroll")) {
  1566. graph->set_scroll_ofs(d["scroll"]);
  1567. }
  1568. if (d.has("zoom")) {
  1569. graph->set_zoom(d["zoom"]);
  1570. }
  1571. if (d.has("snap")) {
  1572. graph->set_snap(d["snap"]);
  1573. }
  1574. if (d.has("snap_enabled")) {
  1575. graph->set_use_snap(d["snap_enabled"]);
  1576. }
  1577. }
  1578. void VisualScriptEditor::_center_on_node(int p_id) {
  1579. Node *n = graph->get_node(itos(p_id));
  1580. if (!n)
  1581. return;
  1582. GraphNode *gn = n->cast_to<GraphNode>();
  1583. if (gn) {
  1584. gn->set_selected(true);
  1585. Vector2 new_scroll = gn->get_offset() - graph->get_size() * 0.5 + gn->get_size() * 0.5;
  1586. graph->set_scroll_ofs(new_scroll);
  1587. script->set_function_scroll(edited_func, new_scroll / EDSCALE);
  1588. script->set_edited(true); //so it's saved
  1589. }
  1590. }
  1591. void VisualScriptEditor::goto_line(int p_line, bool p_with_error) {
  1592. p_line += 1; //add one because script lines begin from 0.
  1593. if (p_with_error)
  1594. error_line = p_line;
  1595. List<StringName> functions;
  1596. script->get_function_list(&functions);
  1597. for (List<StringName>::Element *E = functions.front(); E; E = E->next()) {
  1598. if (script->has_node(E->get(), p_line)) {
  1599. edited_func = E->get();
  1600. selected = edited_func;
  1601. _update_graph();
  1602. _update_members();
  1603. call_deferred("call_deferred", "_center_on_node", p_line); //editor might be just created and size might not exist yet
  1604. return;
  1605. }
  1606. }
  1607. }
  1608. void VisualScriptEditor::trim_trailing_whitespace() {
  1609. }
  1610. void VisualScriptEditor::convert_indent_to_spaces() {
  1611. }
  1612. void VisualScriptEditor::convert_indent_to_tabs() {
  1613. }
  1614. void VisualScriptEditor::ensure_focus() {
  1615. graph->grab_focus();
  1616. }
  1617. void VisualScriptEditor::tag_saved_version() {
  1618. }
  1619. void VisualScriptEditor::reload(bool p_soft) {
  1620. }
  1621. void VisualScriptEditor::get_breakpoints(List<int> *p_breakpoints) {
  1622. List<StringName> functions;
  1623. script->get_function_list(&functions);
  1624. for (List<StringName>::Element *E = functions.front(); E; E = E->next()) {
  1625. List<int> nodes;
  1626. script->get_node_list(E->get(), &nodes);
  1627. for (List<int>::Element *F = nodes.front(); F; F = F->next()) {
  1628. Ref<VisualScriptNode> vsn = script->get_node(E->get(), F->get());
  1629. if (vsn->is_breakpoint()) {
  1630. p_breakpoints->push_back(F->get() - 1); //subtract 1 because breakpoints in text start from zero
  1631. }
  1632. }
  1633. }
  1634. }
  1635. void VisualScriptEditor::add_callback(const String &p_function, PoolStringArray p_args) {
  1636. if (script->has_function(p_function)) {
  1637. edited_func = p_function;
  1638. selected = edited_func;
  1639. _update_members();
  1640. _update_graph();
  1641. return;
  1642. }
  1643. Ref<VisualScriptFunction> func;
  1644. func.instance();
  1645. for (int i = 0; i < p_args.size(); i++) {
  1646. String name = p_args[i];
  1647. Variant::Type type = Variant::NIL;
  1648. if (name.find(":") != -1) {
  1649. String tt = name.get_slice(":", 1);
  1650. name = name.get_slice(":", 0);
  1651. for (int j = 0; j < Variant::VARIANT_MAX; j++) {
  1652. String tname = Variant::get_type_name(Variant::Type(j));
  1653. if (tname == tt) {
  1654. type = Variant::Type(j);
  1655. break;
  1656. }
  1657. }
  1658. }
  1659. func->add_argument(type, name);
  1660. }
  1661. func->set_name(p_function);
  1662. script->add_function(p_function);
  1663. script->add_node(p_function, script->get_available_id(), func);
  1664. edited_func = p_function;
  1665. selected = edited_func;
  1666. _update_members();
  1667. _update_graph();
  1668. graph->call_deferred("set_scroll_ofs", script->get_function_scroll(edited_func)); //for first time it might need to be later
  1669. //undo_redo->clear_history();
  1670. }
  1671. bool VisualScriptEditor::show_members_overview() {
  1672. return false;
  1673. }
  1674. void VisualScriptEditor::update_settings() {
  1675. _update_graph();
  1676. }
  1677. void VisualScriptEditor::set_debugger_active(bool p_active) {
  1678. if (!p_active) {
  1679. error_line = -1;
  1680. _update_graph(); //clear line break
  1681. }
  1682. }
  1683. void VisualScriptEditor::set_tooltip_request_func(String p_method, Object *p_obj) {
  1684. }
  1685. Control *VisualScriptEditor::get_edit_menu() {
  1686. return edit_menu;
  1687. }
  1688. void VisualScriptEditor::_change_base_type() {
  1689. select_base_type->popup_create(true);
  1690. }
  1691. void VisualScriptEditor::clear_edit_menu() {
  1692. memdelete(edit_menu);
  1693. memdelete(left_vsplit);
  1694. }
  1695. void VisualScriptEditor::_change_base_type_callback() {
  1696. String bt = select_base_type->get_selected_type();
  1697. ERR_FAIL_COND(bt == String());
  1698. undo_redo->create_action("Change Base Type");
  1699. undo_redo->add_do_method(script.ptr(), "set_instance_base_type", bt);
  1700. undo_redo->add_undo_method(script.ptr(), "set_instance_base_type", script->get_instance_base_type());
  1701. undo_redo->add_do_method(this, "_update_members");
  1702. undo_redo->add_undo_method(this, "_update_members");
  1703. undo_redo->commit_action();
  1704. }
  1705. void VisualScriptEditor::_node_selected(Node *p_node) {
  1706. Ref<VisualScriptNode> vnode = p_node->get_meta("__vnode");
  1707. if (vnode.is_null())
  1708. return;
  1709. EditorNode::get_singleton()->push_item(vnode.ptr()); //edit node in inspector
  1710. }
  1711. static bool _get_out_slot(const Ref<VisualScriptNode> &p_node, int p_slot, int &r_real_slot, bool &r_sequence) {
  1712. if (p_slot < p_node->get_output_sequence_port_count()) {
  1713. r_sequence = true;
  1714. r_real_slot = p_slot;
  1715. return true;
  1716. }
  1717. r_real_slot = p_slot - p_node->get_output_sequence_port_count();
  1718. r_sequence = false;
  1719. return (r_real_slot < p_node->get_output_value_port_count());
  1720. }
  1721. static bool _get_in_slot(const Ref<VisualScriptNode> &p_node, int p_slot, int &r_real_slot, bool &r_sequence) {
  1722. if (p_slot == 0 && p_node->has_input_sequence_port()) {
  1723. r_sequence = true;
  1724. r_real_slot = 0;
  1725. return true;
  1726. }
  1727. r_real_slot = p_slot - (p_node->has_input_sequence_port() ? 1 : 0);
  1728. r_sequence = false;
  1729. return r_real_slot < p_node->get_input_value_port_count();
  1730. }
  1731. void VisualScriptEditor::_begin_node_move() {
  1732. undo_redo->create_action("Move Node(s)");
  1733. }
  1734. void VisualScriptEditor::_end_node_move() {
  1735. undo_redo->commit_action();
  1736. }
  1737. void VisualScriptEditor::_move_node(String func, int p_id, const Vector2 &p_to) {
  1738. if (func == String(edited_func)) {
  1739. Node *node = graph->get_node(itos(p_id));
  1740. if (node && node->cast_to<GraphNode>())
  1741. node->cast_to<GraphNode>()->set_offset(p_to);
  1742. }
  1743. script->set_node_pos(edited_func, p_id, p_to / EDSCALE);
  1744. }
  1745. void VisualScriptEditor::_node_moved(Vector2 p_from, Vector2 p_to, int p_id) {
  1746. undo_redo->add_do_method(this, "_move_node", String(edited_func), p_id, p_to);
  1747. undo_redo->add_undo_method(this, "_move_node", String(edited_func), p_id, p_from);
  1748. }
  1749. void VisualScriptEditor::_remove_node(int p_id) {
  1750. undo_redo->create_action("Remove VisualScript Node");
  1751. undo_redo->add_do_method(script.ptr(), "remove_node", edited_func, p_id);
  1752. undo_redo->add_undo_method(script.ptr(), "add_node", edited_func, p_id, script->get_node(edited_func, p_id), script->get_node_pos(edited_func, p_id));
  1753. List<VisualScript::SequenceConnection> sequence_conns;
  1754. script->get_sequence_connection_list(edited_func, &sequence_conns);
  1755. for (List<VisualScript::SequenceConnection>::Element *E = sequence_conns.front(); E; E = E->next()) {
  1756. if (E->get().from_node == p_id || E->get().to_node == p_id) {
  1757. undo_redo->add_undo_method(script.ptr(), "sequence_connect", edited_func, E->get().from_node, E->get().from_output, E->get().to_node);
  1758. }
  1759. }
  1760. List<VisualScript::DataConnection> data_conns;
  1761. script->get_data_connection_list(edited_func, &data_conns);
  1762. for (List<VisualScript::DataConnection>::Element *E = data_conns.front(); E; E = E->next()) {
  1763. if (E->get().from_node == p_id || E->get().to_node == p_id) {
  1764. undo_redo->add_undo_method(script.ptr(), "data_connect", edited_func, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
  1765. }
  1766. }
  1767. undo_redo->add_do_method(this, "_update_graph");
  1768. undo_redo->add_undo_method(this, "_update_graph");
  1769. undo_redo->commit_action();
  1770. }
  1771. void VisualScriptEditor::_node_ports_changed(const String &p_func, int p_id) {
  1772. if (p_func != String(edited_func))
  1773. return;
  1774. _update_graph(p_id);
  1775. }
  1776. void VisualScriptEditor::_graph_connected(const String &p_from, int p_from_slot, const String &p_to, int p_to_slot) {
  1777. Ref<VisualScriptNode> from_node = script->get_node(edited_func, p_from.to_int());
  1778. ERR_FAIL_COND(!from_node.is_valid());
  1779. bool from_seq;
  1780. int from_port;
  1781. if (!_get_out_slot(from_node, p_from_slot, from_port, from_seq))
  1782. return; //can't connect this, it' s invalid
  1783. Ref<VisualScriptNode> to_node = script->get_node(edited_func, p_to.to_int());
  1784. ERR_FAIL_COND(!to_node.is_valid());
  1785. bool to_seq;
  1786. int to_port;
  1787. if (!_get_in_slot(to_node, p_to_slot, to_port, to_seq))
  1788. return; //can't connect this, it' s invalid
  1789. ERR_FAIL_COND(from_seq != to_seq);
  1790. undo_redo->create_action("Connect Nodes");
  1791. if (from_seq) {
  1792. undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, p_from.to_int(), from_port, p_to.to_int());
  1793. undo_redo->add_undo_method(script.ptr(), "sequence_disconnect", edited_func, p_from.to_int(), from_port, p_to.to_int());
  1794. } else {
  1795. // disconect current, and connect the new one
  1796. if (script->is_input_value_port_connected(edited_func, p_to.to_int(), to_port)) {
  1797. int conn_from;
  1798. int conn_port;
  1799. script->get_input_value_port_connection_source(edited_func, p_to.to_int(), to_port, &conn_from, &conn_port);
  1800. undo_redo->add_do_method(script.ptr(), "data_disconnect", edited_func, conn_from, conn_port, p_to.to_int(), to_port);
  1801. undo_redo->add_undo_method(script.ptr(), "data_connect", edited_func, conn_from, conn_port, p_to.to_int(), to_port);
  1802. }
  1803. undo_redo->add_do_method(script.ptr(), "data_connect", edited_func, p_from.to_int(), from_port, p_to.to_int(), to_port);
  1804. undo_redo->add_undo_method(script.ptr(), "data_disconnect", edited_func, p_from.to_int(), from_port, p_to.to_int(), to_port);
  1805. //update nodes in sgraph
  1806. undo_redo->add_do_method(this, "_update_graph", p_from.to_int());
  1807. undo_redo->add_do_method(this, "_update_graph", p_to.to_int());
  1808. undo_redo->add_undo_method(this, "_update_graph", p_from.to_int());
  1809. undo_redo->add_undo_method(this, "_update_graph", p_to.to_int());
  1810. }
  1811. undo_redo->add_do_method(this, "_update_graph_connections");
  1812. undo_redo->add_undo_method(this, "_update_graph_connections");
  1813. undo_redo->commit_action();
  1814. }
  1815. void VisualScriptEditor::_graph_disconnected(const String &p_from, int p_from_slot, const String &p_to, int p_to_slot) {
  1816. Ref<VisualScriptNode> from_node = script->get_node(edited_func, p_from.to_int());
  1817. ERR_FAIL_COND(!from_node.is_valid());
  1818. bool from_seq;
  1819. int from_port;
  1820. if (!_get_out_slot(from_node, p_from_slot, from_port, from_seq))
  1821. return; //can't connect this, it' s invalid
  1822. Ref<VisualScriptNode> to_node = script->get_node(edited_func, p_to.to_int());
  1823. ERR_FAIL_COND(!to_node.is_valid());
  1824. bool to_seq;
  1825. int to_port;
  1826. if (!_get_in_slot(to_node, p_to_slot, to_port, to_seq))
  1827. return; //can't connect this, it' s invalid
  1828. ERR_FAIL_COND(from_seq != to_seq);
  1829. undo_redo->create_action("Connect Nodes");
  1830. if (from_seq) {
  1831. undo_redo->add_do_method(script.ptr(), "sequence_disconnect", edited_func, p_from.to_int(), from_port, p_to.to_int());
  1832. undo_redo->add_undo_method(script.ptr(), "sequence_connect", edited_func, p_from.to_int(), from_port, p_to.to_int());
  1833. } else {
  1834. undo_redo->add_do_method(script.ptr(), "data_disconnect", edited_func, p_from.to_int(), from_port, p_to.to_int(), to_port);
  1835. undo_redo->add_undo_method(script.ptr(), "data_connect", edited_func, p_from.to_int(), from_port, p_to.to_int(), to_port);
  1836. //update nodes in sgraph
  1837. undo_redo->add_do_method(this, "_update_graph", p_from.to_int());
  1838. undo_redo->add_do_method(this, "_update_graph", p_to.to_int());
  1839. undo_redo->add_undo_method(this, "_update_graph", p_from.to_int());
  1840. undo_redo->add_undo_method(this, "_update_graph", p_to.to_int());
  1841. }
  1842. undo_redo->add_do_method(this, "_update_graph_connections");
  1843. undo_redo->add_undo_method(this, "_update_graph_connections");
  1844. undo_redo->commit_action();
  1845. }
  1846. void VisualScriptEditor::_graph_connect_to_empty(const String &p_from, int p_from_slot, const Vector2 &p_release_pos) {
  1847. Node *node = graph->get_node(p_from);
  1848. if (!node)
  1849. return;
  1850. GraphNode *gn = node->cast_to<GraphNode>();
  1851. if (!gn)
  1852. return;
  1853. Ref<VisualScriptNode> vsn = script->get_node(edited_func, p_from.to_int());
  1854. if (!vsn.is_valid())
  1855. return;
  1856. if (p_from_slot < vsn->get_output_sequence_port_count()) {
  1857. port_action_popup->clear();
  1858. port_action_popup->add_item(TTR("Condition"), CREATE_COND);
  1859. port_action_popup->add_item(TTR("Sequence"), CREATE_SEQUENCE);
  1860. port_action_popup->add_item(TTR("Switch"), CREATE_SWITCH);
  1861. port_action_popup->add_item(TTR("Iterator"), CREATE_ITERATOR);
  1862. port_action_popup->add_item(TTR("While"), CREATE_WHILE);
  1863. port_action_popup->add_item(TTR("Return"), CREATE_RETURN);
  1864. port_action_node = p_from.to_int();
  1865. port_action_output = p_from_slot;
  1866. } else {
  1867. port_action_popup->clear();
  1868. port_action_popup->add_item(TTR("Call"), CREATE_CALL);
  1869. port_action_popup->add_item(TTR("Get"), CREATE_GET);
  1870. port_action_popup->add_item(TTR("Set"), CREATE_SET);
  1871. port_action_output = p_from_slot - vsn->get_output_sequence_port_count();
  1872. port_action_node = p_from.to_int();
  1873. }
  1874. port_action_pos = p_release_pos;
  1875. port_action_popup->set_size(Size2(1, 1));
  1876. port_action_popup->set_position(graph->get_global_position() + p_release_pos);
  1877. port_action_popup->popup();
  1878. }
  1879. VisualScriptNode::TypeGuess VisualScriptEditor::_guess_output_type(int p_port_action_node, int p_port_action_output, Set<int> &visited_nodes) {
  1880. VisualScriptNode::TypeGuess tg;
  1881. tg.type = Variant::NIL;
  1882. if (visited_nodes.has(p_port_action_node))
  1883. return tg; //no loop
  1884. visited_nodes.insert(p_port_action_node);
  1885. Ref<VisualScriptNode> node = script->get_node(edited_func, p_port_action_node);
  1886. if (!node.is_valid()) {
  1887. return tg;
  1888. }
  1889. Vector<VisualScriptNode::TypeGuess> in_guesses;
  1890. for (int i = 0; i < node->get_input_value_port_count(); i++) {
  1891. PropertyInfo pi = node->get_input_value_port_info(i);
  1892. VisualScriptNode::TypeGuess g;
  1893. g.type = pi.type;
  1894. if (g.type == Variant::NIL || g.type == Variant::OBJECT) {
  1895. //any or object input, must further guess what this is
  1896. int from_node;
  1897. int from_port;
  1898. if (script->get_input_value_port_connection_source(edited_func, p_port_action_node, i, &from_node, &from_port)) {
  1899. g = _guess_output_type(from_node, from_port, visited_nodes);
  1900. } else {
  1901. Variant defval = node->get_default_input_value(i);
  1902. if (defval.get_type() == Variant::OBJECT) {
  1903. Object *obj = defval;
  1904. if (obj) {
  1905. g.type = Variant::OBJECT;
  1906. g.gdclass = obj->get_class();
  1907. g.script = obj->get_script();
  1908. }
  1909. }
  1910. }
  1911. }
  1912. in_guesses.push_back(g);
  1913. }
  1914. return node->guess_output_type(in_guesses.ptr(), p_port_action_output);
  1915. }
  1916. void VisualScriptEditor::_port_action_menu(int p_option) {
  1917. Vector2 ofs = graph->get_scroll_ofs() + port_action_pos;
  1918. if (graph->is_using_snap()) {
  1919. int snap = graph->get_snap();
  1920. ofs = ofs.snapped(Vector2(snap, snap));
  1921. }
  1922. ofs /= EDSCALE;
  1923. bool seq_connect = false;
  1924. Ref<VisualScriptNode> vnode;
  1925. Set<int> vn;
  1926. switch (p_option) {
  1927. case CREATE_CALL: {
  1928. Ref<VisualScriptFunctionCall> n;
  1929. n.instance();
  1930. vnode = n;
  1931. VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
  1932. if (tg.type == Variant::OBJECT) {
  1933. n->set_call_mode(VisualScriptFunctionCall::CALL_MODE_INSTANCE);
  1934. if (tg.gdclass != StringName()) {
  1935. n->set_base_type(tg.gdclass);
  1936. } else {
  1937. n->set_base_type("Object");
  1938. }
  1939. if (tg.script.is_valid()) {
  1940. n->set_base_script(tg.script->get_path());
  1941. new_connect_node_select->select_method_from_script(tg.script);
  1942. } else {
  1943. new_connect_node_select->select_method_from_base_type(n->get_base_type());
  1944. }
  1945. } else {
  1946. n->set_call_mode(VisualScriptFunctionCall::CALL_MODE_BASIC_TYPE);
  1947. n->set_basic_type(tg.type);
  1948. new_connect_node_select->select_method_from_basic_type(tg.type);
  1949. }
  1950. } break;
  1951. case CREATE_SET: {
  1952. Ref<VisualScriptPropertySet> n;
  1953. n.instance();
  1954. vnode = n;
  1955. VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
  1956. if (tg.type == Variant::OBJECT) {
  1957. n->set_call_mode(VisualScriptPropertySet::CALL_MODE_INSTANCE);
  1958. if (tg.gdclass != StringName()) {
  1959. n->set_base_type(tg.gdclass);
  1960. } else {
  1961. n->set_base_type("Object");
  1962. }
  1963. if (tg.script.is_valid()) {
  1964. n->set_base_script(tg.script->get_path());
  1965. new_connect_node_select->select_property_from_script(tg.script);
  1966. } else {
  1967. new_connect_node_select->select_property_from_base_type(n->get_base_type());
  1968. }
  1969. } else {
  1970. n->set_call_mode(VisualScriptPropertySet::CALL_MODE_BASIC_TYPE);
  1971. n->set_basic_type(tg.type);
  1972. new_connect_node_select->select_property_from_basic_type(tg.type);
  1973. }
  1974. } break;
  1975. case CREATE_GET: {
  1976. Ref<VisualScriptPropertyGet> n;
  1977. n.instance();
  1978. vnode = n;
  1979. VisualScriptNode::TypeGuess tg = _guess_output_type(port_action_node, port_action_output, vn);
  1980. if (tg.type == Variant::OBJECT) {
  1981. n->set_call_mode(VisualScriptPropertyGet::CALL_MODE_INSTANCE);
  1982. if (tg.gdclass != StringName()) {
  1983. n->set_base_type(tg.gdclass);
  1984. } else {
  1985. n->set_base_type("Object");
  1986. }
  1987. if (tg.script.is_valid()) {
  1988. n->set_base_script(tg.script->get_path());
  1989. new_connect_node_select->select_property_from_script(tg.script);
  1990. } else {
  1991. new_connect_node_select->select_property_from_base_type(n->get_base_type());
  1992. }
  1993. } else {
  1994. n->set_call_mode(VisualScriptPropertyGet::CALL_MODE_BASIC_TYPE);
  1995. n->set_basic_type(tg.type);
  1996. new_connect_node_select->select_property_from_basic_type(tg.type);
  1997. }
  1998. } break;
  1999. case CREATE_COND: {
  2000. Ref<VisualScriptCondition> n;
  2001. n.instance();
  2002. vnode = n;
  2003. seq_connect = true;
  2004. } break;
  2005. case CREATE_SEQUENCE: {
  2006. Ref<VisualScriptSequence> n;
  2007. n.instance();
  2008. vnode = n;
  2009. seq_connect = true;
  2010. } break;
  2011. case CREATE_SWITCH: {
  2012. Ref<VisualScriptSwitch> n;
  2013. n.instance();
  2014. vnode = n;
  2015. seq_connect = true;
  2016. } break;
  2017. case CREATE_ITERATOR: {
  2018. Ref<VisualScriptIterator> n;
  2019. n.instance();
  2020. vnode = n;
  2021. seq_connect = true;
  2022. } break;
  2023. case CREATE_WHILE: {
  2024. Ref<VisualScriptWhile> n;
  2025. n.instance();
  2026. vnode = n;
  2027. seq_connect = true;
  2028. } break;
  2029. case CREATE_RETURN: {
  2030. Ref<VisualScriptReturn> n;
  2031. n.instance();
  2032. vnode = n;
  2033. seq_connect = true;
  2034. } break;
  2035. }
  2036. int new_id = script->get_available_id();
  2037. undo_redo->create_action(TTR("Add Node"));
  2038. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, vnode, ofs);
  2039. if (seq_connect) {
  2040. undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, port_action_node, port_action_output, new_id);
  2041. }
  2042. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  2043. undo_redo->add_do_method(this, "_update_graph", new_id);
  2044. undo_redo->add_undo_method(this, "_update_graph", new_id);
  2045. undo_redo->commit_action();
  2046. port_action_new_node = new_id;
  2047. }
  2048. void VisualScriptEditor::_selected_connect_node_method_or_setget(const String &p_text) {
  2049. Ref<VisualScriptNode> vsn = script->get_node(edited_func, port_action_new_node);
  2050. if (vsn->cast_to<VisualScriptFunctionCall>()) {
  2051. Ref<VisualScriptFunctionCall> vsfc = vsn;
  2052. vsfc->set_function(p_text);
  2053. script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0);
  2054. }
  2055. if (vsn->cast_to<VisualScriptPropertySet>()) {
  2056. Ref<VisualScriptPropertySet> vsp = vsn;
  2057. vsp->set_property(p_text);
  2058. script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0);
  2059. }
  2060. if (vsn->cast_to<VisualScriptPropertyGet>()) {
  2061. Ref<VisualScriptPropertyGet> vsp = vsn;
  2062. vsp->set_property(p_text);
  2063. script->data_connect(edited_func, port_action_node, port_action_output, port_action_new_node, 0);
  2064. }
  2065. _update_graph(port_action_new_node);
  2066. _update_graph_connections();
  2067. }
  2068. void VisualScriptEditor::_default_value_changed() {
  2069. Ref<VisualScriptNode> vsn = script->get_node(edited_func, editing_id);
  2070. if (vsn.is_null())
  2071. return;
  2072. undo_redo->create_action("Change Input Value");
  2073. undo_redo->add_do_method(vsn.ptr(), "set_default_input_value", editing_input, default_value_edit->get_variant());
  2074. undo_redo->add_undo_method(vsn.ptr(), "set_default_input_value", editing_input, vsn->get_default_input_value(editing_input));
  2075. undo_redo->add_do_method(this, "_update_graph", editing_id);
  2076. undo_redo->add_undo_method(this, "_update_graph", editing_id);
  2077. undo_redo->commit_action();
  2078. }
  2079. void VisualScriptEditor::_default_value_edited(Node *p_button, int p_id, int p_input_port) {
  2080. Ref<VisualScriptNode> vsn = script->get_node(edited_func, p_id);
  2081. if (vsn.is_null())
  2082. return;
  2083. PropertyInfo pinfo = vsn->get_input_value_port_info(p_input_port);
  2084. Variant existing = vsn->get_default_input_value(p_input_port);
  2085. if (pinfo.type != Variant::NIL && existing.get_type() != pinfo.type) {
  2086. Variant::CallError ce;
  2087. const Variant *existingp = &existing;
  2088. existing = Variant::construct(pinfo.type, &existingp, 1, ce, false);
  2089. }
  2090. default_value_edit->set_position(p_button->cast_to<Control>()->get_global_position() + Vector2(0, p_button->cast_to<Control>()->get_size().y));
  2091. default_value_edit->set_size(Size2(1, 1));
  2092. if (default_value_edit->edit(NULL, pinfo.name, pinfo.type, existing, pinfo.hint, pinfo.hint_string)) {
  2093. if (pinfo.hint == PROPERTY_HINT_MULTILINE_TEXT)
  2094. default_value_edit->popup_centered_ratio();
  2095. else
  2096. default_value_edit->popup();
  2097. }
  2098. editing_id = p_id;
  2099. editing_input = p_input_port;
  2100. }
  2101. void VisualScriptEditor::_show_hint(const String &p_hint) {
  2102. hint_text->set_text(p_hint);
  2103. hint_text->show();
  2104. hint_text_timer->start();
  2105. }
  2106. void VisualScriptEditor::_hide_timer() {
  2107. hint_text->hide();
  2108. }
  2109. void VisualScriptEditor::_node_filter_changed(const String &p_text) {
  2110. _update_available_nodes();
  2111. }
  2112. void VisualScriptEditor::_notification(int p_what) {
  2113. if (p_what == NOTIFICATION_READY) {
  2114. node_filter->add_icon_override("right_icon", Control::get_icon("Search", "EditorIcons"));
  2115. variable_editor->connect("changed", this, "_update_members");
  2116. signal_editor->connect("changed", this, "_update_members");
  2117. }
  2118. if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {
  2119. left_vsplit->set_visible(is_visible_in_tree());
  2120. }
  2121. }
  2122. void VisualScriptEditor::_graph_ofs_changed(const Vector2 &p_ofs) {
  2123. if (updating_graph || !script.is_valid())
  2124. return;
  2125. updating_graph = true;
  2126. if (script->has_function(edited_func)) {
  2127. script->set_function_scroll(edited_func, graph->get_scroll_ofs() / EDSCALE);
  2128. script->set_edited(true);
  2129. }
  2130. updating_graph = false;
  2131. }
  2132. void VisualScriptEditor::_comment_node_resized(const Vector2 &p_new_size, int p_node) {
  2133. if (updating_graph)
  2134. return;
  2135. Ref<VisualScriptComment> vsc = script->get_node(edited_func, p_node);
  2136. if (vsc.is_null())
  2137. return;
  2138. Node *node = graph->get_node(itos(p_node));
  2139. if (!node)
  2140. return;
  2141. GraphNode *gn = node->cast_to<GraphNode>();
  2142. if (!gn)
  2143. return;
  2144. updating_graph = true;
  2145. graph->set_block_minimum_size_adjust(true); //faster resize
  2146. undo_redo->create_action("Resize Comment", UndoRedo::MERGE_ENDS);
  2147. undo_redo->add_do_method(vsc.ptr(), "set_size", p_new_size / EDSCALE);
  2148. undo_redo->add_undo_method(vsc.ptr(), "set_size", vsc->get_size());
  2149. undo_redo->commit_action();
  2150. gn->set_custom_minimum_size(p_new_size); //for this time since graph update is blocked
  2151. gn->set_size(Size2(1, 1));
  2152. graph->set_block_minimum_size_adjust(false);
  2153. updating_graph = false;
  2154. }
  2155. void VisualScriptEditor::_menu_option(int p_what) {
  2156. switch (p_what) {
  2157. case EDIT_DELETE_NODES: {
  2158. _on_nodes_delete();
  2159. } break;
  2160. case EDIT_TOGGLE_BREAKPOINT: {
  2161. List<String> reselect;
  2162. for (int i = 0; i < graph->get_child_count(); i++) {
  2163. GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
  2164. if (gn) {
  2165. if (gn->is_selected()) {
  2166. int id = String(gn->get_name()).to_int();
  2167. Ref<VisualScriptNode> vsn = script->get_node(edited_func, id);
  2168. if (vsn.is_valid()) {
  2169. vsn->set_breakpoint(!vsn->is_breakpoint());
  2170. reselect.push_back(gn->get_name());
  2171. }
  2172. }
  2173. }
  2174. }
  2175. _update_graph();
  2176. for (List<String>::Element *E = reselect.front(); E; E = E->next()) {
  2177. GraphNode *gn = graph->get_node(E->get())->cast_to<GraphNode>();
  2178. gn->set_selected(true);
  2179. }
  2180. } break;
  2181. case EDIT_FIND_NODE_TYPE: {
  2182. //popup disappearing grabs focus to owner, so use call deferred
  2183. node_filter->call_deferred("grab_focus");
  2184. node_filter->call_deferred("select_all");
  2185. } break;
  2186. case EDIT_COPY_NODES:
  2187. case EDIT_CUT_NODES: {
  2188. if (!script->has_function(edited_func))
  2189. break;
  2190. clipboard->nodes.clear();
  2191. clipboard->data_connections.clear();
  2192. clipboard->sequence_connections.clear();
  2193. for (int i = 0; i < graph->get_child_count(); i++) {
  2194. GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
  2195. if (gn) {
  2196. if (gn->is_selected()) {
  2197. int id = String(gn->get_name()).to_int();
  2198. Ref<VisualScriptNode> node = script->get_node(edited_func, id);
  2199. if (node->cast_to<VisualScriptFunction>()) {
  2200. EditorNode::get_singleton()->show_warning("Can't copy the function node.");
  2201. return;
  2202. }
  2203. if (node.is_valid()) {
  2204. clipboard->nodes[id] = node->duplicate();
  2205. clipboard->nodes_positions[id] = script->get_node_pos(edited_func, id);
  2206. }
  2207. }
  2208. }
  2209. }
  2210. if (clipboard->nodes.empty())
  2211. break;
  2212. List<VisualScript::SequenceConnection> sequence_connections;
  2213. script->get_sequence_connection_list(edited_func, &sequence_connections);
  2214. for (List<VisualScript::SequenceConnection>::Element *E = sequence_connections.front(); E; E = E->next()) {
  2215. if (clipboard->nodes.has(E->get().from_node) && clipboard->nodes.has(E->get().to_node)) {
  2216. clipboard->sequence_connections.insert(E->get());
  2217. }
  2218. }
  2219. List<VisualScript::DataConnection> data_connections;
  2220. script->get_data_connection_list(edited_func, &data_connections);
  2221. for (List<VisualScript::DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
  2222. if (clipboard->nodes.has(E->get().from_node) && clipboard->nodes.has(E->get().to_node)) {
  2223. clipboard->data_connections.insert(E->get());
  2224. }
  2225. }
  2226. if (p_what == EDIT_CUT_NODES) {
  2227. _on_nodes_delete(); // oh yeah, also delete on cut
  2228. }
  2229. } break;
  2230. case EDIT_PASTE_NODES: {
  2231. if (!script->has_function(edited_func))
  2232. break;
  2233. if (clipboard->nodes.empty()) {
  2234. EditorNode::get_singleton()->show_warning("Clipboard is empty!");
  2235. break;
  2236. }
  2237. Map<int, int> remap;
  2238. undo_redo->create_action("Paste VisualScript Nodes");
  2239. int idc = script->get_available_id() + 1;
  2240. Set<int> to_select;
  2241. Set<Vector2> existing_positions;
  2242. {
  2243. List<int> nodes;
  2244. script->get_node_list(edited_func, &nodes);
  2245. for (List<int>::Element *E = nodes.front(); E; E = E->next()) {
  2246. Vector2 pos = script->get_node_pos(edited_func, E->get()).snapped(Vector2(2, 2));
  2247. existing_positions.insert(pos);
  2248. }
  2249. }
  2250. for (Map<int, Ref<VisualScriptNode> >::Element *E = clipboard->nodes.front(); E; E = E->next()) {
  2251. Ref<VisualScriptNode> node = E->get()->duplicate();
  2252. int new_id = idc++;
  2253. to_select.insert(new_id);
  2254. remap[E->key()] = new_id;
  2255. Vector2 paste_pos = clipboard->nodes_positions[E->key()];
  2256. while (existing_positions.has(paste_pos.snapped(Vector2(2, 2)))) {
  2257. paste_pos += Vector2(20, 20) * EDSCALE;
  2258. }
  2259. undo_redo->add_do_method(script.ptr(), "add_node", edited_func, new_id, node, paste_pos);
  2260. undo_redo->add_undo_method(script.ptr(), "remove_node", edited_func, new_id);
  2261. }
  2262. for (Set<VisualScript::SequenceConnection>::Element *E = clipboard->sequence_connections.front(); E; E = E->next()) {
  2263. undo_redo->add_do_method(script.ptr(), "sequence_connect", edited_func, remap[E->get().from_node], E->get().from_output, remap[E->get().to_node]);
  2264. undo_redo->add_undo_method(script.ptr(), "sequence_disconnect", edited_func, remap[E->get().from_node], E->get().from_output, remap[E->get().to_node]);
  2265. }
  2266. for (Set<VisualScript::DataConnection>::Element *E = clipboard->data_connections.front(); E; E = E->next()) {
  2267. undo_redo->add_do_method(script.ptr(), "data_connect", edited_func, remap[E->get().from_node], E->get().from_port, remap[E->get().to_node], E->get().to_port);
  2268. undo_redo->add_undo_method(script.ptr(), "data_disconnect", edited_func, remap[E->get().from_node], E->get().from_port, remap[E->get().to_node], E->get().to_port);
  2269. }
  2270. undo_redo->add_do_method(this, "_update_graph");
  2271. undo_redo->add_undo_method(this, "_update_graph");
  2272. undo_redo->commit_action();
  2273. for (int i = 0; i < graph->get_child_count(); i++) {
  2274. GraphNode *gn = graph->get_child(i)->cast_to<GraphNode>();
  2275. if (gn) {
  2276. int id = gn->get_name().operator String().to_int();
  2277. gn->set_selected(to_select.has(id));
  2278. }
  2279. }
  2280. } break;
  2281. }
  2282. }
  2283. void VisualScriptEditor::_member_rmb_selected(const Vector2 &p_pos) {
  2284. TreeItem *ti = members->get_selected();
  2285. ERR_FAIL_COND(!ti);
  2286. member_popup->clear();
  2287. member_popup->set_position(members->get_global_position() + p_pos);
  2288. member_popup->set_size(Vector2());
  2289. TreeItem *root = members->get_root();
  2290. Ref<Texture> del_icon = Control::get_icon("Del", "EditorIcons");
  2291. Ref<Texture> edit_icon = Control::get_icon("Edit", "EditorIcons");
  2292. if (ti->get_parent() == root->get_children()) {
  2293. member_type = MEMBER_FUNCTION;
  2294. member_name = ti->get_text(0);
  2295. member_popup->add_icon_item(del_icon, TTR("Remove Function"), MEMBER_REMOVE);
  2296. member_popup->popup();
  2297. return;
  2298. }
  2299. if (ti->get_parent() == root->get_children()->get_next()) {
  2300. member_type = MEMBER_VARIABLE;
  2301. member_name = ti->get_text(0);
  2302. member_popup->add_icon_item(edit_icon, TTR("Edit Variable"), MEMBER_EDIT);
  2303. member_popup->add_separator();
  2304. member_popup->add_icon_item(del_icon, TTR("Remove Variable"), MEMBER_REMOVE);
  2305. member_popup->popup();
  2306. return;
  2307. }
  2308. if (ti->get_parent() == root->get_children()->get_next()->get_next()) {
  2309. member_type = MEMBER_SIGNAL;
  2310. member_name = ti->get_text(0);
  2311. member_popup->add_icon_item(edit_icon, TTR("Edit Signal"), MEMBER_EDIT);
  2312. member_popup->add_separator();
  2313. member_popup->add_icon_item(del_icon, TTR("Remove Signal"), MEMBER_REMOVE);
  2314. member_popup->popup();
  2315. return;
  2316. }
  2317. }
  2318. void VisualScriptEditor::_member_option(int p_option) {
  2319. switch (member_type) {
  2320. case MEMBER_FUNCTION: {
  2321. if (p_option == MEMBER_REMOVE) {
  2322. //delete the function
  2323. String name = member_name;
  2324. undo_redo->create_action(TTR("Remove Function"));
  2325. undo_redo->add_do_method(script.ptr(), "remove_function", name);
  2326. undo_redo->add_undo_method(script.ptr(), "add_function", name);
  2327. List<int> nodes;
  2328. script->get_node_list(name, &nodes);
  2329. for (List<int>::Element *E = nodes.front(); E; E = E->next()) {
  2330. undo_redo->add_undo_method(script.ptr(), "add_node", name, E->get(), script->get_node(name, E->get()), script->get_node_pos(name, E->get()));
  2331. }
  2332. List<VisualScript::SequenceConnection> seq_connections;
  2333. script->get_sequence_connection_list(name, &seq_connections);
  2334. for (List<VisualScript::SequenceConnection>::Element *E = seq_connections.front(); E; E = E->next()) {
  2335. undo_redo->add_undo_method(script.ptr(), "sequence_connect", name, E->get().from_node, E->get().from_output, E->get().to_node);
  2336. }
  2337. List<VisualScript::DataConnection> data_connections;
  2338. script->get_data_connection_list(name, &data_connections);
  2339. for (List<VisualScript::DataConnection>::Element *E = data_connections.front(); E; E = E->next()) {
  2340. undo_redo->add_undo_method(script.ptr(), "data_connect", name, E->get().from_node, E->get().from_port, E->get().to_node, E->get().to_port);
  2341. }
  2342. /*
  2343. for(int i=0;i<script->function_get_argument_count(name);i++) {
  2344. undo_redo->add_undo_method(script.ptr(),"function_add_argument",name,script->function_get_argument_name(name,i),script->function_get_argument_type(name,i));
  2345. }
  2346. */
  2347. undo_redo->add_do_method(this, "_update_members");
  2348. undo_redo->add_undo_method(this, "_update_members");
  2349. undo_redo->add_do_method(this, "_update_graph");
  2350. undo_redo->add_undo_method(this, "_update_graph");
  2351. undo_redo->commit_action();
  2352. }
  2353. } break;
  2354. case MEMBER_VARIABLE: {
  2355. String name = member_name;
  2356. if (p_option == MEMBER_REMOVE) {
  2357. undo_redo->create_action(TTR("Remove Variable"));
  2358. undo_redo->add_do_method(script.ptr(), "remove_variable", name);
  2359. undo_redo->add_undo_method(script.ptr(), "add_variable", name, script->get_variable_default_value(name));
  2360. undo_redo->add_undo_method(script.ptr(), "set_variable_info", name, script->call("get_variable_info", name)); //return as dict
  2361. undo_redo->add_do_method(this, "_update_members");
  2362. undo_redo->add_undo_method(this, "_update_members");
  2363. undo_redo->commit_action();
  2364. } else if (p_option == MEMBER_EDIT) {
  2365. variable_editor->edit(name);
  2366. edit_variable_dialog->set_title(TTR("Editing Variable:") + " " + name);
  2367. edit_variable_dialog->popup_centered_minsize(Size2(400, 200) * EDSCALE);
  2368. }
  2369. } break;
  2370. case MEMBER_SIGNAL: {
  2371. String name = member_name;
  2372. if (p_option == MEMBER_REMOVE) {
  2373. undo_redo->create_action(TTR("Remove Signal"));
  2374. undo_redo->add_do_method(script.ptr(), "remove_custom_signal", name);
  2375. undo_redo->add_undo_method(script.ptr(), "add_custom_signal", name);
  2376. for (int i = 0; i < script->custom_signal_get_argument_count(name); i++) {
  2377. undo_redo->add_undo_method(script.ptr(), "custom_signal_add_argument", name, script->custom_signal_get_argument_name(name, i), script->custom_signal_get_argument_type(name, i));
  2378. }
  2379. undo_redo->add_do_method(this, "_update_members");
  2380. undo_redo->add_undo_method(this, "_update_members");
  2381. undo_redo->commit_action();
  2382. } else if (p_option == MEMBER_EDIT) {
  2383. signal_editor->edit(name);
  2384. edit_signal_dialog->set_title(TTR("Editing Signal:") + " " + name);
  2385. edit_signal_dialog->popup_centered_minsize(Size2(400, 300) * EDSCALE);
  2386. }
  2387. } break;
  2388. }
  2389. }
  2390. void VisualScriptEditor::_bind_methods() {
  2391. ClassDB::bind_method("_member_button", &VisualScriptEditor::_member_button);
  2392. ClassDB::bind_method("_member_edited", &VisualScriptEditor::_member_edited);
  2393. ClassDB::bind_method("_member_selected", &VisualScriptEditor::_member_selected);
  2394. ClassDB::bind_method("_update_members", &VisualScriptEditor::_update_members);
  2395. ClassDB::bind_method("_change_base_type", &VisualScriptEditor::_change_base_type);
  2396. ClassDB::bind_method("_change_base_type_callback", &VisualScriptEditor::_change_base_type_callback);
  2397. ClassDB::bind_method("_override_pressed", &VisualScriptEditor::_override_pressed);
  2398. ClassDB::bind_method("_node_selected", &VisualScriptEditor::_node_selected);
  2399. ClassDB::bind_method("_node_moved", &VisualScriptEditor::_node_moved);
  2400. ClassDB::bind_method("_move_node", &VisualScriptEditor::_move_node);
  2401. ClassDB::bind_method("_begin_node_move", &VisualScriptEditor::_begin_node_move);
  2402. ClassDB::bind_method("_end_node_move", &VisualScriptEditor::_end_node_move);
  2403. ClassDB::bind_method("_remove_node", &VisualScriptEditor::_remove_node);
  2404. ClassDB::bind_method("_update_graph", &VisualScriptEditor::_update_graph, DEFVAL(-1));
  2405. ClassDB::bind_method("_node_ports_changed", &VisualScriptEditor::_node_ports_changed);
  2406. ClassDB::bind_method("_available_node_doubleclicked", &VisualScriptEditor::_available_node_doubleclicked);
  2407. ClassDB::bind_method("_default_value_edited", &VisualScriptEditor::_default_value_edited);
  2408. ClassDB::bind_method("_default_value_changed", &VisualScriptEditor::_default_value_changed);
  2409. ClassDB::bind_method("_menu_option", &VisualScriptEditor::_menu_option);
  2410. ClassDB::bind_method("_graph_ofs_changed", &VisualScriptEditor::_graph_ofs_changed);
  2411. ClassDB::bind_method("_center_on_node", &VisualScriptEditor::_center_on_node);
  2412. ClassDB::bind_method("_comment_node_resized", &VisualScriptEditor::_comment_node_resized);
  2413. ClassDB::bind_method("_button_resource_previewed", &VisualScriptEditor::_button_resource_previewed);
  2414. ClassDB::bind_method("_port_action_menu", &VisualScriptEditor::_port_action_menu);
  2415. ClassDB::bind_method("_selected_connect_node_method_or_setget", &VisualScriptEditor::_selected_connect_node_method_or_setget);
  2416. ClassDB::bind_method("_expression_text_changed", &VisualScriptEditor::_expression_text_changed);
  2417. ClassDB::bind_method("get_drag_data_fw", &VisualScriptEditor::get_drag_data_fw);
  2418. ClassDB::bind_method("can_drop_data_fw", &VisualScriptEditor::can_drop_data_fw);
  2419. ClassDB::bind_method("drop_data_fw", &VisualScriptEditor::drop_data_fw);
  2420. ClassDB::bind_method("_input", &VisualScriptEditor::_input);
  2421. ClassDB::bind_method("_on_nodes_delete", &VisualScriptEditor::_on_nodes_delete);
  2422. ClassDB::bind_method("_on_nodes_duplicate", &VisualScriptEditor::_on_nodes_duplicate);
  2423. ClassDB::bind_method("_hide_timer", &VisualScriptEditor::_hide_timer);
  2424. ClassDB::bind_method("_graph_connected", &VisualScriptEditor::_graph_connected);
  2425. ClassDB::bind_method("_graph_disconnected", &VisualScriptEditor::_graph_disconnected);
  2426. ClassDB::bind_method("_graph_connect_to_empty", &VisualScriptEditor::_graph_connect_to_empty);
  2427. ClassDB::bind_method("_update_graph_connections", &VisualScriptEditor::_update_graph_connections);
  2428. ClassDB::bind_method("_node_filter_changed", &VisualScriptEditor::_node_filter_changed);
  2429. ClassDB::bind_method("_selected_method", &VisualScriptEditor::_selected_method);
  2430. ClassDB::bind_method("_draw_color_over_button", &VisualScriptEditor::_draw_color_over_button);
  2431. ClassDB::bind_method("_member_rmb_selected", &VisualScriptEditor::_member_rmb_selected);
  2432. ClassDB::bind_method("_member_option", &VisualScriptEditor::_member_option);
  2433. }
  2434. VisualScriptEditor::VisualScriptEditor() {
  2435. if (!clipboard) {
  2436. clipboard = memnew(Clipboard);
  2437. }
  2438. updating_graph = false;
  2439. edit_menu = memnew(MenuButton);
  2440. edit_menu->set_text(TTR("Edit"));
  2441. edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/delete_selected"), EDIT_DELETE_NODES);
  2442. edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/toggle_breakpoint"), EDIT_TOGGLE_BREAKPOINT);
  2443. edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/find_node_type"), EDIT_FIND_NODE_TYPE);
  2444. edit_menu->get_popup()->add_separator();
  2445. edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/copy_nodes"), EDIT_COPY_NODES);
  2446. edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/cut_nodes"), EDIT_CUT_NODES);
  2447. edit_menu->get_popup()->add_shortcut(ED_GET_SHORTCUT("visual_script_editor/paste_nodes"), EDIT_PASTE_NODES);
  2448. edit_menu->get_popup()->connect("id_pressed", this, "_menu_option");
  2449. left_vsplit = memnew(VSplitContainer);
  2450. ScriptEditor::get_singleton()->get_left_list_split()->call_deferred("add_child", left_vsplit); //add but wait until done settig up this
  2451. left_vsplit->set_v_size_flags(SIZE_EXPAND_FILL);
  2452. left_vsplit->set_stretch_ratio(2);
  2453. left_vsplit->hide();
  2454. VBoxContainer *left_vb = memnew(VBoxContainer);
  2455. left_vsplit->add_child(left_vb);
  2456. left_vb->set_v_size_flags(SIZE_EXPAND_FILL);
  2457. //left_vb->set_custom_minimum_size(Size2(230, 1) * EDSCALE);
  2458. base_type_select = memnew(Button);
  2459. left_vb->add_margin_child(TTR("Base Type:"), base_type_select);
  2460. base_type_select->connect("pressed", this, "_change_base_type");
  2461. members = memnew(Tree);
  2462. left_vb->add_margin_child(TTR("Members:"), members, true);
  2463. members->set_hide_root(true);
  2464. members->connect("button_pressed", this, "_member_button");
  2465. members->connect("item_edited", this, "_member_edited");
  2466. members->connect("cell_selected", this, "_member_selected", varray(), CONNECT_DEFERRED);
  2467. members->set_single_select_cell_editing_only_when_already_selected(true);
  2468. members->set_hide_folding(true);
  2469. members->set_drag_forwarding(this);
  2470. VBoxContainer *left_vb2 = memnew(VBoxContainer);
  2471. left_vsplit->add_child(left_vb2);
  2472. left_vb2->set_v_size_flags(SIZE_EXPAND_FILL);
  2473. VBoxContainer *vbc_nodes = memnew(VBoxContainer);
  2474. HBoxContainer *hbc_nodes = memnew(HBoxContainer);
  2475. node_filter = memnew(LineEdit);
  2476. node_filter->connect("text_changed", this, "_node_filter_changed");
  2477. hbc_nodes->add_child(node_filter);
  2478. node_filter->set_h_size_flags(SIZE_EXPAND_FILL);
  2479. vbc_nodes->add_child(hbc_nodes);
  2480. nodes = memnew(Tree);
  2481. vbc_nodes->add_child(nodes);
  2482. nodes->set_v_size_flags(SIZE_EXPAND_FILL);
  2483. left_vb2->add_margin_child(TTR("Available Nodes:"), vbc_nodes, true);
  2484. nodes->set_hide_root(true);
  2485. nodes->connect("item_activated", this, "_available_node_doubleclicked");
  2486. nodes->set_drag_forwarding(this);
  2487. graph = memnew(GraphEdit);
  2488. add_child(graph);
  2489. graph->set_area_as_parent_rect();
  2490. graph->set_h_size_flags(SIZE_EXPAND_FILL);
  2491. graph->connect("node_selected", this, "_node_selected");
  2492. graph->connect("_begin_node_move", this, "_begin_node_move");
  2493. graph->connect("_end_node_move", this, "_end_node_move");
  2494. graph->connect("delete_nodes_request", this, "_on_nodes_delete");
  2495. graph->connect("duplicate_nodes_request", this, "_on_nodes_duplicate");
  2496. graph->set_drag_forwarding(this);
  2497. graph->hide();
  2498. graph->connect("scroll_offset_changed", this, "_graph_ofs_changed");
  2499. select_func_text = memnew(Label);
  2500. select_func_text->set_text(TTR("Select or create a function to edit graph"));
  2501. select_func_text->set_align(Label::ALIGN_CENTER);
  2502. select_func_text->set_valign(Label::VALIGN_CENTER);
  2503. select_func_text->set_h_size_flags(SIZE_EXPAND_FILL);
  2504. add_child(select_func_text);
  2505. graph->set_area_as_parent_rect();
  2506. hint_text = memnew(Label);
  2507. hint_text->set_anchor_and_margin(MARGIN_TOP, ANCHOR_END, 100);
  2508. hint_text->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 0);
  2509. hint_text->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0);
  2510. hint_text->set_align(Label::ALIGN_CENTER);
  2511. hint_text->set_valign(Label::VALIGN_CENTER);
  2512. graph->add_child(hint_text);
  2513. hint_text_timer = memnew(Timer);
  2514. hint_text_timer->set_wait_time(4);
  2515. hint_text_timer->connect("timeout", this, "_hide_timer");
  2516. add_child(hint_text_timer);
  2517. //allowed casts (connections)
  2518. for (int i = 0; i < Variant::VARIANT_MAX; i++) {
  2519. graph->add_valid_connection_type(Variant::NIL, i);
  2520. graph->add_valid_connection_type(i, Variant::NIL);
  2521. for (int j = 0; j < Variant::VARIANT_MAX; j++) {
  2522. if (Variant::can_convert(Variant::Type(i), Variant::Type(j))) {
  2523. graph->add_valid_connection_type(i, j);
  2524. }
  2525. }
  2526. graph->add_valid_right_disconnect_type(i);
  2527. }
  2528. graph->add_valid_left_disconnect_type(TYPE_SEQUENCE);
  2529. graph->connect("connection_request", this, "_graph_connected");
  2530. graph->connect("disconnection_request", this, "_graph_disconnected");
  2531. graph->connect("connection_to_empty", this, "_graph_connect_to_empty");
  2532. edit_signal_dialog = memnew(AcceptDialog);
  2533. edit_signal_dialog->get_ok()->set_text(TTR("Close"));
  2534. add_child(edit_signal_dialog);
  2535. edit_signal_dialog->set_title(TTR("Edit Signal Arguments:"));
  2536. signal_editor = memnew(VisualScriptEditorSignalEdit);
  2537. edit_signal_edit = memnew(PropertyEditor);
  2538. edit_signal_edit->hide_top_label();
  2539. edit_signal_dialog->add_child(edit_signal_edit);
  2540. edit_signal_edit->edit(signal_editor);
  2541. edit_variable_dialog = memnew(AcceptDialog);
  2542. edit_variable_dialog->get_ok()->set_text(TTR("Close"));
  2543. add_child(edit_variable_dialog);
  2544. edit_variable_dialog->set_title(TTR("Edit Variable:"));
  2545. variable_editor = memnew(VisualScriptEditorVariableEdit);
  2546. edit_variable_edit = memnew(PropertyEditor);
  2547. edit_variable_edit->hide_top_label();
  2548. edit_variable_dialog->add_child(edit_variable_edit);
  2549. edit_variable_edit->edit(variable_editor);
  2550. select_base_type = memnew(CreateDialog);
  2551. select_base_type->set_base_type("Object"); //anything goes
  2552. select_base_type->connect("create", this, "_change_base_type_callback");
  2553. select_base_type->get_ok()->set_text(TTR("Change"));
  2554. add_child(select_base_type);
  2555. undo_redo = EditorNode::get_singleton()->get_undo_redo();
  2556. new_function_menu = memnew(PopupMenu);
  2557. new_function_menu->connect("id_pressed", this, "_override_pressed");
  2558. add_child(new_function_menu);
  2559. updating_members = false;
  2560. set_process_input(true); //for revert on drag
  2561. set_process_unhandled_input(true); //for revert on drag
  2562. default_value_edit = memnew(CustomPropertyEditor);
  2563. add_child(default_value_edit);
  2564. default_value_edit->connect("variant_changed", this, "_default_value_changed");
  2565. method_select = memnew(PropertySelector);
  2566. add_child(method_select);
  2567. method_select->connect("selected", this, "_selected_method");
  2568. error_line = -1;
  2569. new_connect_node_select = memnew(PropertySelector);
  2570. add_child(new_connect_node_select);
  2571. new_connect_node_select->connect("selected", this, "_selected_connect_node_method_or_setget");
  2572. port_action_popup = memnew(PopupMenu);
  2573. add_child(port_action_popup);
  2574. port_action_popup->connect("id_pressed", this, "_port_action_menu");
  2575. member_popup = memnew(PopupMenu);
  2576. add_child(member_popup);
  2577. members->connect("item_rmb_selected", this, "_member_rmb_selected");
  2578. members->set_allow_rmb_select(true);
  2579. member_popup->connect("id_pressed", this, "_member_option");
  2580. }
  2581. VisualScriptEditor::~VisualScriptEditor() {
  2582. undo_redo->clear_history(); //avoid crashes
  2583. memdelete(signal_editor);
  2584. memdelete(variable_editor);
  2585. }
  2586. static ScriptEditorBase *create_editor(const Ref<Script> &p_script) {
  2587. if (p_script->cast_to<VisualScript>()) {
  2588. return memnew(VisualScriptEditor);
  2589. }
  2590. return NULL;
  2591. }
  2592. VisualScriptEditor::Clipboard *VisualScriptEditor::clipboard = NULL;
  2593. void VisualScriptEditor::free_clipboard() {
  2594. if (clipboard)
  2595. memdelete(clipboard);
  2596. }
  2597. static void register_editor_callback() {
  2598. ScriptEditor::register_create_script_editor_function(create_editor);
  2599. EditorSettings::get_singleton()->set("editors/visual_script/color_functions", Color(1, 0.9, 0.9));
  2600. EditorSettings::get_singleton()->set("editors/visual_script/color_data", Color(0.9, 1.0, 0.9));
  2601. EditorSettings::get_singleton()->set("editors/visual_script/color_operators", Color(0.9, 0.9, 1.0));
  2602. EditorSettings::get_singleton()->set("editors/visual_script/color_flow_control", Color(1.0, 1.0, 1.0));
  2603. EditorSettings::get_singleton()->set("editors/visual_script/color_custom", Color(0.8, 1.0, 1.0));
  2604. EditorSettings::get_singleton()->set("editors/visual_script/color_constants", Color(1.0, 0.8, 1.0));
  2605. ED_SHORTCUT("visual_script_editor/delete_selected", TTR("Delete Selected"));
  2606. ED_SHORTCUT("visual_script_editor/toggle_breakpoint", TTR("Toggle Breakpoint"), KEY_F9);
  2607. ED_SHORTCUT("visual_script_editor/find_node_type", TTR("Find Node Type"), KEY_MASK_CMD + KEY_F);
  2608. ED_SHORTCUT("visual_script_editor/copy_nodes", TTR("Copy Nodes"), KEY_MASK_CMD + KEY_C);
  2609. ED_SHORTCUT("visual_script_editor/cut_nodes", TTR("Cut Nodes"), KEY_MASK_CMD + KEY_X);
  2610. ED_SHORTCUT("visual_script_editor/paste_nodes", TTR("Paste Nodes"), KEY_MASK_CMD + KEY_V);
  2611. }
  2612. void VisualScriptEditor::register_editor() {
  2613. //too early to register stuff here, request a callback
  2614. EditorNode::add_plugin_init_callback(register_editor_callback);
  2615. }
  2616. #endif