code_edit.cpp 117 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348
  1. /**************************************************************************/
  2. /* code_edit.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /**************************************************************************/
  30. #include "code_edit.h"
  31. #include "core/os/keyboard.h"
  32. #include "core/string/string_builder.h"
  33. #include "core/string/ustring.h"
  34. void CodeEdit::_notification(int p_what) {
  35. switch (p_what) {
  36. case NOTIFICATION_THEME_CHANGED: {
  37. set_gutter_width(main_gutter, get_line_height());
  38. set_gutter_width(line_number_gutter, (line_number_digits + 1) * theme_cache.font->get_char_size('0', theme_cache.font_size).width);
  39. set_gutter_width(fold_gutter, get_line_height() / 1.2);
  40. } break;
  41. case NOTIFICATION_DRAW: {
  42. RID ci = get_canvas_item();
  43. const Size2 size = get_size();
  44. const bool caret_visible = is_caret_visible();
  45. const bool rtl = is_layout_rtl();
  46. const int row_height = get_line_height();
  47. if (line_length_guideline_columns.size() > 0) {
  48. const int xmargin_beg = theme_cache.style_normal->get_margin(SIDE_LEFT) + get_total_gutter_width();
  49. const int xmargin_end = size.width - theme_cache.style_normal->get_margin(SIDE_RIGHT) - (is_drawing_minimap() ? get_minimap_width() : 0);
  50. const float char_size = theme_cache.font->get_char_size('0', theme_cache.font_size).width;
  51. for (int i = 0; i < line_length_guideline_columns.size(); i++) {
  52. const int xoffset = xmargin_beg + char_size * (int)line_length_guideline_columns[i] - get_h_scroll();
  53. if (xoffset > xmargin_beg && xoffset < xmargin_end) {
  54. Color guideline_color = (i == 0) ? theme_cache.line_length_guideline_color : theme_cache.line_length_guideline_color * Color(1, 1, 1, 0.5);
  55. if (rtl) {
  56. RenderingServer::get_singleton()->canvas_item_add_line(ci, Point2(size.width - xoffset, 0), Point2(size.width - xoffset, size.height), guideline_color);
  57. continue;
  58. }
  59. RenderingServer::get_singleton()->canvas_item_add_line(ci, Point2(xoffset, 0), Point2(xoffset, size.height), guideline_color);
  60. }
  61. }
  62. }
  63. bool code_completion_below = false;
  64. if (caret_visible && code_completion_active && code_completion_options.size() > 0) {
  65. const int code_completion_options_count = code_completion_options.size();
  66. const int lines = MIN(code_completion_options_count, theme_cache.code_completion_max_lines);
  67. const Size2 icon_area_size(row_height, row_height);
  68. code_completion_rect.size.width = code_completion_longest_line + theme_cache.code_completion_icon_separation + icon_area_size.width + 2;
  69. code_completion_rect.size.height = lines * row_height;
  70. const Point2 caret_pos = get_caret_draw_pos();
  71. const int total_height = theme_cache.code_completion_style->get_minimum_size().y + code_completion_rect.size.height;
  72. const bool can_fit_completion_above = (caret_pos.y - row_height > total_height);
  73. const bool can_fit_completion_below = (caret_pos.y + row_height + total_height <= get_size().height);
  74. if (!can_fit_completion_below && can_fit_completion_above) {
  75. code_completion_rect.position.y = (caret_pos.y - total_height - row_height) + theme_cache.line_spacing;
  76. } else {
  77. code_completion_rect.position.y = caret_pos.y + (theme_cache.line_spacing / 2.0f);
  78. code_completion_below = true;
  79. }
  80. const int scroll_width = code_completion_options_count > theme_cache.code_completion_max_lines ? theme_cache.code_completion_scroll_width : 0;
  81. const int code_completion_base_width = theme_cache.font->get_string_size(code_completion_base, HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).width;
  82. if (caret_pos.x - code_completion_base_width + code_completion_rect.size.width + scroll_width > get_size().width) {
  83. code_completion_rect.position.x = get_size().width - code_completion_rect.size.width - scroll_width;
  84. } else {
  85. code_completion_rect.position.x = caret_pos.x - code_completion_base_width;
  86. }
  87. draw_style_box(theme_cache.code_completion_style, Rect2(code_completion_rect.position - theme_cache.code_completion_style->get_offset(), code_completion_rect.size + theme_cache.code_completion_style->get_minimum_size() + Size2(scroll_width, 0)));
  88. if (theme_cache.code_completion_background_color.a > 0.01) {
  89. RenderingServer::get_singleton()->canvas_item_add_rect(ci, Rect2(code_completion_rect.position, code_completion_rect.size + Size2(scroll_width, 0)), theme_cache.code_completion_background_color);
  90. }
  91. code_completion_scroll_rect.position = code_completion_rect.position + Vector2(code_completion_rect.size.width, 0);
  92. code_completion_scroll_rect.size = Vector2(scroll_width, code_completion_rect.size.height);
  93. code_completion_line_ofs = CLAMP((code_completion_force_item_center < 0 ? code_completion_current_selected : code_completion_force_item_center) - lines / 2, 0, code_completion_options_count - lines);
  94. RenderingServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(code_completion_rect.position.x, code_completion_rect.position.y + (code_completion_current_selected - code_completion_line_ofs) * row_height), Size2(code_completion_rect.size.width, row_height)), theme_cache.code_completion_selected_color);
  95. for (int i = 0; i < lines; i++) {
  96. int l = code_completion_line_ofs + i;
  97. ERR_CONTINUE(l < 0 || l >= code_completion_options_count);
  98. Ref<TextLine> tl;
  99. tl.instantiate();
  100. tl->add_string(code_completion_options[l].display, theme_cache.font, theme_cache.font_size);
  101. int yofs = (row_height - tl->get_size().y) / 2;
  102. Point2 title_pos(code_completion_rect.position.x, code_completion_rect.position.y + i * row_height + yofs);
  103. /* Draw completion icon if it is valid. */
  104. const Ref<Texture2D> &icon = code_completion_options[l].icon;
  105. Rect2 icon_area(code_completion_rect.position.x, code_completion_rect.position.y + i * row_height, icon_area_size.width, icon_area_size.height);
  106. if (icon.is_valid()) {
  107. Size2 icon_size = icon_area.size * 0.7;
  108. icon->draw_rect(ci, Rect2(icon_area.position + (icon_area.size - icon_size) / 2, icon_size));
  109. }
  110. title_pos.x = icon_area.position.x + icon_area.size.width + theme_cache.code_completion_icon_separation;
  111. tl->set_width(code_completion_rect.size.width - (icon_area_size.x + theme_cache.code_completion_icon_separation));
  112. if (rtl) {
  113. if (code_completion_options[l].default_value.get_type() == Variant::COLOR) {
  114. draw_rect(Rect2(Point2(code_completion_rect.position.x, icon_area.position.y), icon_area_size), (Color)code_completion_options[l].default_value);
  115. }
  116. tl->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_RIGHT);
  117. } else {
  118. if (code_completion_options[l].default_value.get_type() == Variant::COLOR) {
  119. draw_rect(Rect2(Point2(code_completion_rect.position.x + code_completion_rect.size.width - icon_area_size.x, icon_area.position.y), icon_area_size), (Color)code_completion_options[l].default_value);
  120. }
  121. tl->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_LEFT);
  122. }
  123. Point2 match_pos = Point2(code_completion_rect.position.x + icon_area_size.x + theme_cache.code_completion_icon_separation, code_completion_rect.position.y + i * row_height);
  124. for (int j = 0; j < code_completion_options[l].matches.size(); j++) {
  125. Pair<int, int> match_segment = code_completion_options[l].matches[j];
  126. int match_offset = theme_cache.font->get_string_size(code_completion_options[l].display.substr(0, match_segment.first), HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).width;
  127. int match_len = theme_cache.font->get_string_size(code_completion_options[l].display.substr(match_segment.first, match_segment.second), HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).width;
  128. draw_rect(Rect2(match_pos + Point2(match_offset, 0), Size2(match_len, row_height)), theme_cache.code_completion_existing_color);
  129. }
  130. tl->draw(ci, title_pos, code_completion_options[l].font_color);
  131. }
  132. /* Draw a small scroll rectangle to show a position in the options. */
  133. if (scroll_width) {
  134. Color scroll_color = is_code_completion_scroll_hovered || is_code_completion_scroll_pressed ? theme_cache.code_completion_scroll_hovered_color : theme_cache.code_completion_scroll_color;
  135. float r = (float)theme_cache.code_completion_max_lines / code_completion_options_count;
  136. float o = (float)code_completion_line_ofs / code_completion_options_count;
  137. draw_rect(Rect2(code_completion_rect.position.x + code_completion_rect.size.width, code_completion_rect.position.y + o * code_completion_rect.size.y, scroll_width, code_completion_rect.size.y * r), scroll_color);
  138. }
  139. }
  140. /* Code hint */
  141. if (caret_visible && !code_hint.is_empty() && (!code_completion_active || (code_completion_below != code_hint_draw_below))) {
  142. const int font_height = theme_cache.font->get_height(theme_cache.font_size);
  143. Vector<String> code_hint_lines = code_hint.split("\n");
  144. int line_count = code_hint_lines.size();
  145. int max_width = 0;
  146. for (int i = 0; i < line_count; i++) {
  147. max_width = MAX(max_width, theme_cache.font->get_string_size(code_hint_lines[i], HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).x);
  148. }
  149. Size2 minsize = theme_cache.code_hint_style->get_minimum_size() + Size2(max_width, line_count * font_height + (theme_cache.line_spacing * line_count - 1));
  150. int offset = theme_cache.font->get_string_size(code_hint_lines[0].substr(0, code_hint_lines[0].find(String::chr(0xFFFF))), HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).x;
  151. if (code_hint_xpos == -0xFFFF) {
  152. code_hint_xpos = get_caret_draw_pos().x - offset;
  153. }
  154. Point2 hint_ofs = Vector2(code_hint_xpos, get_caret_draw_pos().y);
  155. if (code_hint_draw_below) {
  156. hint_ofs.y += theme_cache.line_spacing / 2.0f;
  157. } else {
  158. hint_ofs.y -= (minsize.y + row_height) - theme_cache.line_spacing;
  159. }
  160. draw_style_box(theme_cache.code_hint_style, Rect2(hint_ofs, minsize));
  161. int yofs = 0;
  162. for (int i = 0; i < line_count; i++) {
  163. const String &line = code_hint_lines[i];
  164. int begin = 0;
  165. int end = 0;
  166. if (line.contains(String::chr(0xFFFF))) {
  167. begin = theme_cache.font->get_string_size(line.substr(0, line.find(String::chr(0xFFFF))), HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).x;
  168. end = theme_cache.font->get_string_size(line.substr(0, line.rfind(String::chr(0xFFFF))), HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).x;
  169. }
  170. Point2 round_ofs = hint_ofs + theme_cache.code_hint_style->get_offset() + Vector2(0, theme_cache.font->get_ascent(theme_cache.font_size) + font_height * i + yofs);
  171. round_ofs = round_ofs.round();
  172. draw_string(theme_cache.font, round_ofs, line.replace(String::chr(0xFFFF), ""), HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size, theme_cache.code_hint_color);
  173. if (end > 0) {
  174. // Draw an underline for the currently edited function parameter.
  175. const Vector2 b = hint_ofs + theme_cache.code_hint_style->get_offset() + Vector2(begin, font_height + font_height * i + yofs);
  176. draw_line(b, b + Vector2(end - begin, 0), theme_cache.code_hint_color, 2);
  177. // Draw a translucent text highlight as well.
  178. const Rect2 highlight_rect = Rect2(
  179. b - Vector2(0, font_height),
  180. Vector2(end - begin, font_height));
  181. draw_rect(highlight_rect, theme_cache.code_hint_color * Color(1, 1, 1, 0.2));
  182. }
  183. yofs += theme_cache.line_spacing;
  184. }
  185. }
  186. } break;
  187. }
  188. }
  189. void CodeEdit::_update_theme_item_cache() {
  190. TextEdit::_update_theme_item_cache();
  191. /* Gutters */
  192. theme_cache.code_folding_color = get_theme_color(SNAME("code_folding_color"));
  193. theme_cache.can_fold_icon = get_theme_icon(SNAME("can_fold"));
  194. theme_cache.folded_icon = get_theme_icon(SNAME("folded"));
  195. theme_cache.folded_eol_icon = get_theme_icon(SNAME("folded_eol_icon"));
  196. theme_cache.breakpoint_color = get_theme_color(SNAME("breakpoint_color"));
  197. theme_cache.breakpoint_icon = get_theme_icon(SNAME("breakpoint"));
  198. theme_cache.bookmark_color = get_theme_color(SNAME("bookmark_color"));
  199. theme_cache.bookmark_icon = get_theme_icon(SNAME("bookmark"));
  200. theme_cache.executing_line_color = get_theme_color(SNAME("executing_line_color"));
  201. theme_cache.executing_line_icon = get_theme_icon(SNAME("executing_line"));
  202. theme_cache.line_number_color = get_theme_color(SNAME("line_number_color"));
  203. /* Code Completion */
  204. theme_cache.code_completion_style = get_theme_stylebox(SNAME("completion"));
  205. theme_cache.code_completion_icon_separation = get_theme_constant(SNAME("h_separation"), SNAME("ItemList"));
  206. theme_cache.code_completion_max_width = get_theme_constant(SNAME("completion_max_width"));
  207. theme_cache.code_completion_max_lines = get_theme_constant(SNAME("completion_lines"));
  208. theme_cache.code_completion_scroll_width = get_theme_constant(SNAME("completion_scroll_width"));
  209. theme_cache.code_completion_scroll_color = get_theme_color(SNAME("completion_scroll_color"));
  210. theme_cache.code_completion_scroll_hovered_color = get_theme_color(SNAME("completion_scroll_hovered_color"));
  211. theme_cache.code_completion_background_color = get_theme_color(SNAME("completion_background_color"));
  212. theme_cache.code_completion_selected_color = get_theme_color(SNAME("completion_selected_color"));
  213. theme_cache.code_completion_existing_color = get_theme_color(SNAME("completion_existing_color"));
  214. /* Code hint */
  215. theme_cache.code_hint_style = get_theme_stylebox(SNAME("panel"), SNAME("TooltipPanel"));
  216. theme_cache.code_hint_color = get_theme_color(SNAME("font_color"), SNAME("TooltipLabel"));
  217. /* Line length guideline */
  218. theme_cache.line_length_guideline_color = get_theme_color(SNAME("line_length_guideline_color"));
  219. /* Other visuals */
  220. theme_cache.style_normal = get_theme_stylebox(SNAME("normal"));
  221. theme_cache.font = get_theme_font(SNAME("font"));
  222. theme_cache.font_size = get_theme_font_size(SNAME("font_size"));
  223. theme_cache.line_spacing = get_theme_constant(SNAME("line_spacing"));
  224. }
  225. void CodeEdit::gui_input(const Ref<InputEvent> &p_gui_input) {
  226. Ref<InputEventMouseButton> mb = p_gui_input;
  227. if (mb.is_valid()) {
  228. /* Ignore mouse clicks in IME input mode. */
  229. if (has_ime_text()) {
  230. return;
  231. }
  232. if (is_code_completion_scroll_pressed && mb->get_button_index() == MouseButton::LEFT) {
  233. is_code_completion_scroll_pressed = false;
  234. accept_event();
  235. queue_redraw();
  236. return;
  237. }
  238. if (is_code_completion_drag_started && !mb->is_pressed()) {
  239. is_code_completion_drag_started = false;
  240. accept_event();
  241. queue_redraw();
  242. return;
  243. }
  244. if (code_completion_active && code_completion_rect.has_point(mb->get_position())) {
  245. if (!mb->is_pressed()) {
  246. accept_event();
  247. return;
  248. }
  249. is_code_completion_drag_started = true;
  250. switch (mb->get_button_index()) {
  251. case MouseButton::WHEEL_UP: {
  252. if (code_completion_current_selected > 0) {
  253. code_completion_current_selected--;
  254. code_completion_force_item_center = -1;
  255. queue_redraw();
  256. }
  257. } break;
  258. case MouseButton::WHEEL_DOWN: {
  259. if (code_completion_current_selected < code_completion_options.size() - 1) {
  260. code_completion_current_selected++;
  261. code_completion_force_item_center = -1;
  262. queue_redraw();
  263. }
  264. } break;
  265. case MouseButton::LEFT: {
  266. if (code_completion_force_item_center == -1) {
  267. code_completion_force_item_center = code_completion_current_selected;
  268. }
  269. code_completion_current_selected = CLAMP(code_completion_line_ofs + (mb->get_position().y - code_completion_rect.position.y) / get_line_height(), 0, code_completion_options.size() - 1);
  270. if (mb->is_double_click()) {
  271. confirm_code_completion();
  272. }
  273. queue_redraw();
  274. } break;
  275. default:
  276. break;
  277. }
  278. accept_event();
  279. return;
  280. } else if (code_completion_active && code_completion_scroll_rect.has_point(mb->get_position())) {
  281. if (mb->get_button_index() != MouseButton::LEFT) {
  282. accept_event();
  283. return;
  284. }
  285. if (mb->is_pressed()) {
  286. is_code_completion_drag_started = true;
  287. is_code_completion_scroll_pressed = true;
  288. _update_scroll_selected_line(mb->get_position().y);
  289. queue_redraw();
  290. }
  291. accept_event();
  292. return;
  293. }
  294. cancel_code_completion();
  295. set_code_hint("");
  296. if (mb->is_pressed()) {
  297. Vector2i mpos = mb->get_position();
  298. if (is_layout_rtl()) {
  299. mpos.x = get_size().x - mpos.x;
  300. }
  301. Point2i pos = get_line_column_at_pos(mpos, false);
  302. int line = pos.y;
  303. int col = pos.x;
  304. if (line != -1 && mb->get_button_index() == MouseButton::LEFT) {
  305. if (is_line_folded(line)) {
  306. int wrap_index = get_line_wrap_index_at_column(line, col);
  307. if (wrap_index == get_line_wrap_count(line)) {
  308. int eol_icon_width = theme_cache.folded_eol_icon->get_width();
  309. int left_margin = get_total_gutter_width() + eol_icon_width + get_line_width(line, wrap_index) - get_h_scroll();
  310. if (mpos.x > left_margin && mpos.x <= left_margin + eol_icon_width + 3) {
  311. unfold_line(line);
  312. return;
  313. }
  314. }
  315. }
  316. }
  317. } else {
  318. if (mb->get_button_index() == MouseButton::LEFT) {
  319. if (mb->is_command_or_control_pressed() && !symbol_lookup_word.is_empty()) {
  320. Vector2i mpos = mb->get_position();
  321. if (is_layout_rtl()) {
  322. mpos.x = get_size().x - mpos.x;
  323. }
  324. Point2i pos = get_line_column_at_pos(mpos, false);
  325. int line = pos.y;
  326. int col = pos.x;
  327. if (line != -1) {
  328. emit_signal(SNAME("symbol_lookup"), symbol_lookup_word, line, col);
  329. }
  330. return;
  331. }
  332. }
  333. }
  334. }
  335. Ref<InputEventMouseMotion> mm = p_gui_input;
  336. if (mm.is_valid()) {
  337. Vector2i mpos = mm->get_position();
  338. if (is_layout_rtl()) {
  339. mpos.x = get_size().x - mpos.x;
  340. }
  341. if (symbol_lookup_on_click_enabled) {
  342. if (mm->is_command_or_control_pressed() && mm->get_button_mask().is_empty()) {
  343. symbol_lookup_pos = get_line_column_at_pos(mpos);
  344. symbol_lookup_new_word = get_word_at_pos(mpos);
  345. if (symbol_lookup_new_word != symbol_lookup_word) {
  346. emit_signal(SNAME("symbol_validate"), symbol_lookup_new_word);
  347. }
  348. } else if (!mm->is_command_or_control_pressed() || (!mm->get_button_mask().is_empty() && symbol_lookup_pos != get_line_column_at_pos(mpos))) {
  349. set_symbol_lookup_word_as_valid(false);
  350. }
  351. }
  352. bool scroll_hovered = code_completion_scroll_rect.has_point(mpos);
  353. if (is_code_completion_scroll_hovered != scroll_hovered) {
  354. is_code_completion_scroll_hovered = scroll_hovered;
  355. accept_event();
  356. queue_redraw();
  357. }
  358. if (is_code_completion_scroll_pressed) {
  359. _update_scroll_selected_line(mpos.y);
  360. accept_event();
  361. queue_redraw();
  362. return;
  363. }
  364. if (code_completion_active && code_completion_rect.has_point(mm->get_position())) {
  365. accept_event();
  366. return;
  367. }
  368. }
  369. Ref<InputEventKey> k = p_gui_input;
  370. if (TextEdit::alt_input(p_gui_input)) {
  371. accept_event();
  372. return;
  373. }
  374. bool update_code_completion = false;
  375. if (!k.is_valid()) {
  376. // MouseMotion events should not be handled by TextEdit logic if we're
  377. // currently clicking and dragging from the code completion panel.
  378. if (!mm.is_valid() || !is_code_completion_drag_started) {
  379. TextEdit::gui_input(p_gui_input);
  380. }
  381. return;
  382. }
  383. /* Ctrl + Hover symbols */
  384. bool mac_keys = OS::get_singleton()->has_feature("macos") || OS::get_singleton()->has_feature("web_macos") || OS::get_singleton()->has_feature("web_ios");
  385. if ((mac_keys && k->get_keycode() == Key::META) || (!mac_keys && k->get_keycode() == Key::CTRL)) {
  386. if (symbol_lookup_on_click_enabled) {
  387. if (k->is_pressed() && !is_dragging_cursor()) {
  388. symbol_lookup_new_word = get_word_at_pos(get_local_mouse_pos());
  389. if (symbol_lookup_new_word != symbol_lookup_word) {
  390. emit_signal(SNAME("symbol_validate"), symbol_lookup_new_word);
  391. }
  392. } else {
  393. set_symbol_lookup_word_as_valid(false);
  394. }
  395. }
  396. return;
  397. }
  398. /* If a modifier has been pressed, and nothing else, return. */
  399. if (!k->is_pressed() || k->get_keycode() == Key::CTRL || k->get_keycode() == Key::ALT || k->get_keycode() == Key::SHIFT || k->get_keycode() == Key::META || k->get_keycode() == Key::CAPSLOCK) {
  400. return;
  401. }
  402. // Allow unicode handling if:
  403. // No modifiers are pressed (except Shift and CapsLock)
  404. bool allow_unicode_handling = !(k->is_command_or_control_pressed() || k->is_ctrl_pressed() || k->is_alt_pressed() || k->is_meta_pressed());
  405. /* AUTO-COMPLETE */
  406. if (code_completion_enabled && k->is_action("ui_text_completion_query", true)) {
  407. request_code_completion(true);
  408. accept_event();
  409. return;
  410. }
  411. if (code_completion_active) {
  412. if (k->is_action("ui_up", true)) {
  413. if (code_completion_current_selected > 0) {
  414. code_completion_current_selected--;
  415. } else {
  416. code_completion_current_selected = code_completion_options.size() - 1;
  417. }
  418. code_completion_force_item_center = -1;
  419. queue_redraw();
  420. accept_event();
  421. return;
  422. }
  423. if (k->is_action("ui_down", true)) {
  424. if (code_completion_current_selected < code_completion_options.size() - 1) {
  425. code_completion_current_selected++;
  426. } else {
  427. code_completion_current_selected = 0;
  428. }
  429. code_completion_force_item_center = -1;
  430. queue_redraw();
  431. accept_event();
  432. return;
  433. }
  434. if (k->is_action("ui_page_up", true)) {
  435. code_completion_current_selected = MAX(0, code_completion_current_selected - theme_cache.code_completion_max_lines);
  436. code_completion_force_item_center = -1;
  437. queue_redraw();
  438. accept_event();
  439. return;
  440. }
  441. if (k->is_action("ui_page_down", true)) {
  442. code_completion_current_selected = MIN(code_completion_options.size() - 1, code_completion_current_selected + theme_cache.code_completion_max_lines);
  443. code_completion_force_item_center = -1;
  444. queue_redraw();
  445. accept_event();
  446. return;
  447. }
  448. if (k->is_action("ui_home", true)) {
  449. code_completion_current_selected = 0;
  450. code_completion_force_item_center = -1;
  451. queue_redraw();
  452. accept_event();
  453. return;
  454. }
  455. if (k->is_action("ui_end", true)) {
  456. code_completion_current_selected = code_completion_options.size() - 1;
  457. code_completion_force_item_center = -1;
  458. queue_redraw();
  459. accept_event();
  460. return;
  461. }
  462. if (k->is_action("ui_text_completion_replace", true) || k->is_action("ui_text_completion_accept", true)) {
  463. confirm_code_completion(k->is_action("ui_text_completion_replace", true));
  464. accept_event();
  465. return;
  466. }
  467. if (k->is_action("ui_cancel", true)) {
  468. cancel_code_completion();
  469. accept_event();
  470. return;
  471. }
  472. if (k->is_action("ui_text_backspace", true)) {
  473. backspace();
  474. _filter_code_completion_candidates_impl();
  475. accept_event();
  476. return;
  477. }
  478. if (k->is_action("ui_left", true) || k->is_action("ui_right", true)) {
  479. update_code_completion = true;
  480. } else {
  481. update_code_completion = (allow_unicode_handling && k->get_unicode() >= 32);
  482. }
  483. if (!update_code_completion) {
  484. cancel_code_completion();
  485. }
  486. }
  487. /* MISC */
  488. if (!code_hint.is_empty() && k->is_action("ui_cancel", true)) {
  489. set_code_hint("");
  490. accept_event();
  491. return;
  492. }
  493. if (allow_unicode_handling && k->get_unicode() == ')') {
  494. set_code_hint("");
  495. }
  496. /* Indentation */
  497. if (k->is_action("ui_text_indent", true)) {
  498. do_indent();
  499. accept_event();
  500. return;
  501. }
  502. if (k->is_action("ui_text_dedent", true)) {
  503. unindent_lines();
  504. accept_event();
  505. return;
  506. }
  507. // Override new line actions, for auto indent.
  508. if (k->is_action("ui_text_newline_above", true)) {
  509. _new_line(false, true);
  510. accept_event();
  511. return;
  512. }
  513. if (k->is_action("ui_text_newline_blank", true)) {
  514. _new_line(false);
  515. accept_event();
  516. return;
  517. }
  518. if (k->is_action("ui_text_newline", true)) {
  519. _new_line();
  520. accept_event();
  521. return;
  522. }
  523. // Remove shift, otherwise actions will not match.
  524. k = k->duplicate();
  525. k->set_shift_pressed(false);
  526. if (k->is_action("ui_text_caret_up", true) ||
  527. k->is_action("ui_text_caret_down", true) ||
  528. k->is_action("ui_text_caret_line_start", true) ||
  529. k->is_action("ui_text_caret_line_end", true) ||
  530. k->is_action("ui_text_caret_page_up", true) ||
  531. k->is_action("ui_text_caret_page_down", true)) {
  532. set_code_hint("");
  533. }
  534. TextEdit::gui_input(p_gui_input);
  535. if (update_code_completion) {
  536. _filter_code_completion_candidates_impl();
  537. }
  538. }
  539. /* General overrides */
  540. Control::CursorShape CodeEdit::get_cursor_shape(const Point2 &p_pos) const {
  541. if (!symbol_lookup_word.is_empty()) {
  542. return CURSOR_POINTING_HAND;
  543. }
  544. if ((code_completion_active && code_completion_rect.has_point(p_pos)) || (!is_editable() && (!is_selecting_enabled() || get_line_count() == 0))) {
  545. return CURSOR_ARROW;
  546. }
  547. if (code_completion_active && code_completion_scroll_rect.has_point(p_pos)) {
  548. return CURSOR_ARROW;
  549. }
  550. Point2i pos = get_line_column_at_pos(p_pos, false);
  551. int line = pos.y;
  552. int col = pos.x;
  553. if (line != -1 && is_line_folded(line)) {
  554. int wrap_index = get_line_wrap_index_at_column(line, col);
  555. if (wrap_index == get_line_wrap_count(line)) {
  556. int eol_icon_width = theme_cache.folded_eol_icon->get_width();
  557. int left_margin = get_total_gutter_width() + eol_icon_width + get_line_width(line, wrap_index) - get_h_scroll();
  558. if (p_pos.x > left_margin && p_pos.x <= left_margin + eol_icon_width + 3) {
  559. return CURSOR_POINTING_HAND;
  560. }
  561. }
  562. }
  563. return TextEdit::get_cursor_shape(p_pos);
  564. }
  565. /* Text manipulation */
  566. // Overridable actions
  567. void CodeEdit::_handle_unicode_input_internal(const uint32_t p_unicode, int p_caret) {
  568. start_action(EditAction::ACTION_TYPING);
  569. Vector<int> caret_edit_order = get_caret_index_edit_order();
  570. for (const int &i : caret_edit_order) {
  571. if (p_caret != -1 && p_caret != i) {
  572. continue;
  573. }
  574. bool had_selection = has_selection(i);
  575. String selection_text = (had_selection ? get_selected_text(i) : "");
  576. if (had_selection) {
  577. delete_selection(i);
  578. }
  579. // Remove the old character if in overtype mode and no selection.
  580. if (is_overtype_mode_enabled() && !had_selection) {
  581. // Make sure we don't try and remove empty space.
  582. if (get_caret_column(i) < get_line(get_caret_line(i)).length()) {
  583. remove_text(get_caret_line(i), get_caret_column(i), get_caret_line(i), get_caret_column(i) + 1);
  584. }
  585. }
  586. const char32_t chr[2] = { (char32_t)p_unicode, 0 };
  587. if (auto_brace_completion_enabled) {
  588. int cl = get_caret_line(i);
  589. int cc = get_caret_column(i);
  590. if (had_selection) {
  591. insert_text_at_caret(chr, i);
  592. String close_key = get_auto_brace_completion_close_key(chr);
  593. if (!close_key.is_empty()) {
  594. insert_text_at_caret(selection_text + close_key, i);
  595. set_caret_column(get_caret_column(i) - 1, i == 0, i);
  596. }
  597. } else {
  598. int caret_move_offset = 1;
  599. int post_brace_pair = cc < get_line(cl).length() ? _get_auto_brace_pair_close_at_pos(cl, cc) : -1;
  600. if (has_string_delimiter(chr) && cc > 0 && !is_symbol(get_line(cl)[cc - 1]) && post_brace_pair == -1) {
  601. insert_text_at_caret(chr, i);
  602. } else if (cc < get_line(cl).length() && !is_symbol(get_line(cl)[cc])) {
  603. insert_text_at_caret(chr, i);
  604. } else if (post_brace_pair != -1 && auto_brace_completion_pairs[post_brace_pair].close_key[0] == chr[0]) {
  605. caret_move_offset = auto_brace_completion_pairs[post_brace_pair].close_key.length();
  606. } else if (is_in_comment(cl, cc) != -1 || (is_in_string(cl, cc) != -1 && has_string_delimiter(chr))) {
  607. insert_text_at_caret(chr, i);
  608. } else {
  609. insert_text_at_caret(chr, i);
  610. int pre_brace_pair = _get_auto_brace_pair_open_at_pos(cl, cc + 1);
  611. if (pre_brace_pair != -1) {
  612. insert_text_at_caret(auto_brace_completion_pairs[pre_brace_pair].close_key, i);
  613. }
  614. }
  615. set_caret_column(cc + caret_move_offset, i == 0, i);
  616. }
  617. } else {
  618. insert_text_at_caret(chr, i);
  619. }
  620. }
  621. end_action();
  622. }
  623. void CodeEdit::_backspace_internal(int p_caret) {
  624. if (!is_editable()) {
  625. return;
  626. }
  627. if (has_selection(p_caret)) {
  628. delete_selection(p_caret);
  629. return;
  630. }
  631. begin_complex_operation();
  632. Vector<int> caret_edit_order = get_caret_index_edit_order();
  633. for (const int &i : caret_edit_order) {
  634. if (p_caret != -1 && p_caret != i) {
  635. continue;
  636. }
  637. int cc = get_caret_column(i);
  638. int cl = get_caret_line(i);
  639. if (cc == 0 && cl == 0) {
  640. continue;
  641. }
  642. if (cl > 0 && _is_line_hidden(cl - 1)) {
  643. unfold_line(get_caret_line(i) - 1);
  644. }
  645. int prev_line = cc ? cl : cl - 1;
  646. int prev_column = cc ? (cc - 1) : (get_line(cl - 1).length());
  647. merge_gutters(prev_line, cl);
  648. if (auto_brace_completion_enabled && cc > 0) {
  649. int idx = _get_auto_brace_pair_open_at_pos(cl, cc);
  650. if (idx != -1) {
  651. prev_column = cc - auto_brace_completion_pairs[idx].open_key.length();
  652. if (_get_auto_brace_pair_close_at_pos(cl, cc) == idx) {
  653. remove_text(prev_line, prev_column, cl, cc + auto_brace_completion_pairs[idx].close_key.length());
  654. } else {
  655. remove_text(prev_line, prev_column, cl, cc);
  656. }
  657. set_caret_line(prev_line, false, true, 0, i);
  658. set_caret_column(prev_column, i == 0, i);
  659. adjust_carets_after_edit(i, prev_line, prev_column, cl, cc + auto_brace_completion_pairs[idx].close_key.length());
  660. continue;
  661. }
  662. }
  663. // For space indentation we need to do a basic unindent if there are no chars to the left, acting the same way as tabs.
  664. if (indent_using_spaces && cc != 0) {
  665. if (get_first_non_whitespace_column(cl) >= cc) {
  666. prev_column = cc - _calculate_spaces_till_next_left_indent(cc);
  667. prev_line = cl;
  668. }
  669. }
  670. remove_text(prev_line, prev_column, cl, cc);
  671. set_caret_line(prev_line, false, true, 0, i);
  672. set_caret_column(prev_column, i == 0, i);
  673. adjust_carets_after_edit(i, prev_line, prev_column, cl, cc);
  674. }
  675. merge_overlapping_carets();
  676. end_complex_operation();
  677. }
  678. /* Indent management */
  679. void CodeEdit::set_indent_size(const int p_size) {
  680. ERR_FAIL_COND_MSG(p_size <= 0, "Indend size must be greater than 0.");
  681. if (indent_size == p_size) {
  682. return;
  683. }
  684. indent_size = p_size;
  685. if (indent_using_spaces) {
  686. indent_text = String(" ").repeat(p_size);
  687. } else {
  688. indent_text = "\t";
  689. }
  690. set_tab_size(p_size);
  691. }
  692. int CodeEdit::get_indent_size() const {
  693. return indent_size;
  694. }
  695. void CodeEdit::set_indent_using_spaces(const bool p_use_spaces) {
  696. indent_using_spaces = p_use_spaces;
  697. if (indent_using_spaces) {
  698. indent_text = String(" ").repeat(indent_size);
  699. } else {
  700. indent_text = "\t";
  701. }
  702. }
  703. bool CodeEdit::is_indent_using_spaces() const {
  704. return indent_using_spaces;
  705. }
  706. void CodeEdit::set_auto_indent_enabled(bool p_enabled) {
  707. auto_indent = p_enabled;
  708. }
  709. bool CodeEdit::is_auto_indent_enabled() const {
  710. return auto_indent;
  711. }
  712. void CodeEdit::set_auto_indent_prefixes(const TypedArray<String> &p_prefixes) {
  713. auto_indent_prefixes.clear();
  714. for (int i = 0; i < p_prefixes.size(); i++) {
  715. const String prefix = p_prefixes[i];
  716. auto_indent_prefixes.insert(prefix[0]);
  717. }
  718. }
  719. TypedArray<String> CodeEdit::get_auto_indent_prefixes() const {
  720. TypedArray<String> prefixes;
  721. for (const char32_t &E : auto_indent_prefixes) {
  722. prefixes.push_back(String::chr(E));
  723. }
  724. return prefixes;
  725. }
  726. void CodeEdit::do_indent() {
  727. if (!is_editable()) {
  728. return;
  729. }
  730. if (has_selection()) {
  731. indent_lines();
  732. return;
  733. }
  734. if (!indent_using_spaces) {
  735. insert_text_at_caret("\t");
  736. return;
  737. }
  738. begin_complex_operation();
  739. Vector<int> caret_edit_order = get_caret_index_edit_order();
  740. for (const int &i : caret_edit_order) {
  741. int spaces_to_add = _calculate_spaces_till_next_right_indent(get_caret_column(i));
  742. if (spaces_to_add > 0) {
  743. insert_text_at_caret(String(" ").repeat(spaces_to_add), i);
  744. }
  745. }
  746. end_complex_operation();
  747. }
  748. void CodeEdit::indent_lines() {
  749. if (!is_editable()) {
  750. return;
  751. }
  752. begin_complex_operation();
  753. Vector<int> caret_edit_order = get_caret_index_edit_order();
  754. for (const int &c : caret_edit_order) {
  755. // This value informs us by how much we changed selection position by indenting right.
  756. // Default is 1 for tab indentation.
  757. int selection_offset = 1;
  758. int start_line = get_caret_line(c);
  759. int end_line = start_line;
  760. if (has_selection(c)) {
  761. start_line = get_selection_from_line(c);
  762. end_line = get_selection_to_line(c);
  763. // Ignore the last line if the selection is not past the first column.
  764. if (get_selection_to_column(c) == 0) {
  765. selection_offset = 0;
  766. end_line--;
  767. }
  768. }
  769. for (int i = start_line; i <= end_line; i++) {
  770. const String line_text = get_line(i);
  771. if (line_text.size() == 0 && has_selection(c)) {
  772. continue;
  773. }
  774. if (!indent_using_spaces) {
  775. set_line(i, '\t' + line_text);
  776. continue;
  777. }
  778. // We don't really care where selection is - we just need to know indentation level at the beginning of the line.
  779. // Since we will add this many spaces, we want to move the whole selection and caret by this much.
  780. int spaces_to_add = _calculate_spaces_till_next_right_indent(get_first_non_whitespace_column(i));
  781. set_line(i, String(" ").repeat(spaces_to_add) + line_text);
  782. selection_offset = spaces_to_add;
  783. }
  784. // Fix selection and caret being off after shifting selection right.
  785. if (has_selection(c)) {
  786. select(start_line, get_selection_from_column(c) + selection_offset, get_selection_to_line(c), get_selection_to_column(c) + selection_offset, c);
  787. }
  788. set_caret_column(get_caret_column(c) + selection_offset, false, c);
  789. }
  790. end_complex_operation();
  791. queue_redraw();
  792. }
  793. void CodeEdit::unindent_lines() {
  794. if (!is_editable()) {
  795. return;
  796. }
  797. begin_complex_operation();
  798. Vector<int> caret_edit_order = get_caret_index_edit_order();
  799. for (const int &c : caret_edit_order) {
  800. // Moving caret and selection after unindenting can get tricky because
  801. // changing content of line can move caret and selection on its own (if new line ends before previous position of either)
  802. // therefore we just remember initial values and at the end of the operation offset them by number of removed characters.
  803. int removed_characters = 0;
  804. int initial_selection_end_column = 0;
  805. int initial_cursor_column = get_caret_column(c);
  806. int start_line = get_caret_line(c);
  807. int end_line = start_line;
  808. if (has_selection(c)) {
  809. start_line = get_selection_from_line(c);
  810. end_line = get_selection_to_line(c);
  811. // Ignore the last line if the selection is not past the first column.
  812. initial_selection_end_column = get_selection_to_column(c);
  813. if (initial_selection_end_column == 0) {
  814. end_line--;
  815. }
  816. }
  817. bool first_line_edited = false;
  818. bool last_line_edited = false;
  819. for (int i = start_line; i <= end_line; i++) {
  820. String line_text = get_line(i);
  821. if (line_text.begins_with("\t")) {
  822. line_text = line_text.substr(1, line_text.length());
  823. set_line(i, line_text);
  824. removed_characters = 1;
  825. first_line_edited = (i == start_line) ? true : first_line_edited;
  826. last_line_edited = (i == end_line) ? true : last_line_edited;
  827. continue;
  828. }
  829. if (line_text.begins_with(" ")) {
  830. // When unindenting we aim to remove spaces before line that has selection no matter what is selected.
  831. // Here we remove only enough spaces to align text to nearest full multiple of indentation_size.
  832. // In case where selection begins at the start of indentation_size multiple we remove whole indentation level.
  833. int spaces_to_remove = _calculate_spaces_till_next_left_indent(get_first_non_whitespace_column(i));
  834. line_text = line_text.substr(spaces_to_remove, line_text.length());
  835. set_line(i, line_text);
  836. removed_characters = spaces_to_remove;
  837. first_line_edited = (i == start_line) ? true : first_line_edited;
  838. last_line_edited = (i == end_line) ? true : last_line_edited;
  839. }
  840. }
  841. if (has_selection(c)) {
  842. // Fix selection being off by one on the first line.
  843. if (first_line_edited) {
  844. select(get_selection_from_line(c), get_selection_from_column(c) - removed_characters, get_selection_to_line(c), initial_selection_end_column, c);
  845. }
  846. // Fix selection being off by one on the last line.
  847. if (last_line_edited) {
  848. select(get_selection_from_line(c), get_selection_from_column(c), get_selection_to_line(c), initial_selection_end_column - removed_characters, c);
  849. }
  850. }
  851. set_caret_column(initial_cursor_column - removed_characters, false, c);
  852. }
  853. end_complex_operation();
  854. queue_redraw();
  855. }
  856. void CodeEdit::convert_indent(int p_from_line, int p_to_line) {
  857. if (!is_editable()) {
  858. return;
  859. }
  860. // Check line range.
  861. p_from_line = (p_from_line < 0) ? 0 : p_from_line;
  862. p_to_line = (p_to_line < 0) ? get_line_count() - 1 : p_to_line;
  863. ERR_FAIL_COND(p_from_line >= get_line_count());
  864. ERR_FAIL_COND(p_to_line >= get_line_count());
  865. ERR_FAIL_COND(p_to_line < p_from_line);
  866. // Store caret states.
  867. Vector<int> caret_columns;
  868. Vector<Pair<int, int>> from_selections;
  869. Vector<Pair<int, int>> to_selections;
  870. caret_columns.resize(get_caret_count());
  871. from_selections.resize(get_caret_count());
  872. to_selections.resize(get_caret_count());
  873. for (int c = 0; c < get_caret_count(); c++) {
  874. caret_columns.write[c] = get_caret_column(c);
  875. // Set "selection_from_line" to -1 to allow checking if there was a selection later.
  876. if (!has_selection(c)) {
  877. from_selections.write[c].first = -1;
  878. continue;
  879. }
  880. from_selections.write[c].first = get_selection_from_line(c);
  881. from_selections.write[c].second = get_selection_from_column(c);
  882. to_selections.write[c].first = get_selection_to_line(c);
  883. to_selections.write[c].second = get_selection_to_column(c);
  884. }
  885. // Check lines within range.
  886. const char32_t from_indent_char = indent_using_spaces ? '\t' : ' ';
  887. int size_diff = indent_using_spaces ? indent_size - 1 : -(indent_size - 1);
  888. bool changed_indentation = false;
  889. for (int i = p_from_line; i <= p_to_line; i++) {
  890. String line = get_line(i);
  891. if (line.length() <= 0) {
  892. continue;
  893. }
  894. // Check chars in the line.
  895. int j = 0;
  896. int space_count = 0;
  897. bool line_changed = false;
  898. while (j < line.length() && (line[j] == ' ' || line[j] == '\t')) {
  899. if (line[j] != from_indent_char) {
  900. space_count = 0;
  901. j++;
  902. continue;
  903. }
  904. space_count++;
  905. if (!indent_using_spaces && space_count != indent_size) {
  906. j++;
  907. continue;
  908. }
  909. line_changed = true;
  910. if (!changed_indentation) {
  911. begin_complex_operation();
  912. changed_indentation = true;
  913. }
  914. // Calculate new caret state.
  915. for (int c = 0; c < get_caret_count(); c++) {
  916. if (get_caret_line(c) != i || caret_columns[c] <= j) {
  917. continue;
  918. }
  919. caret_columns.write[c] += size_diff;
  920. if (from_selections.write[c].first == -1) {
  921. continue;
  922. }
  923. from_selections.write[c].second = from_selections[c].first == i ? from_selections[c].second + size_diff : from_selections[c].second;
  924. to_selections.write[c].second = to_selections[c].first == i ? to_selections[c].second + size_diff : to_selections[c].second;
  925. }
  926. // Calculate new line.
  927. line = line.left(j + ((size_diff < 0) ? size_diff : 0)) + indent_text + line.substr(j + 1);
  928. space_count = 0;
  929. j += size_diff;
  930. }
  931. if (line_changed) {
  932. set_line(i, line);
  933. }
  934. }
  935. if (!changed_indentation) {
  936. return;
  937. }
  938. // Restore caret states.
  939. for (int c = 0; c < get_caret_count(); c++) {
  940. set_caret_column(caret_columns[c], c == 0, c);
  941. if (from_selections.write[c].first != -1) {
  942. select(from_selections.write[c].first, from_selections.write[c].second, to_selections.write[c].first, to_selections.write[c].second, c);
  943. }
  944. }
  945. merge_overlapping_carets();
  946. end_complex_operation();
  947. queue_redraw();
  948. }
  949. int CodeEdit::_calculate_spaces_till_next_left_indent(int p_column) const {
  950. int spaces_till_indent = p_column % indent_size;
  951. if (spaces_till_indent == 0) {
  952. spaces_till_indent = indent_size;
  953. }
  954. return spaces_till_indent;
  955. }
  956. int CodeEdit::_calculate_spaces_till_next_right_indent(int p_column) const {
  957. return indent_size - p_column % indent_size;
  958. }
  959. void CodeEdit::_new_line(bool p_split_current_line, bool p_above) {
  960. if (!is_editable()) {
  961. return;
  962. }
  963. begin_complex_operation();
  964. Vector<int> caret_edit_order = get_caret_index_edit_order();
  965. for (const int &i : caret_edit_order) {
  966. // When not splitting the line, we need to factor in indentation from the end of the current line.
  967. const int cc = p_split_current_line ? get_caret_column(i) : get_line(get_caret_line(i)).length();
  968. const int cl = get_caret_line(i);
  969. const String line = get_line(cl);
  970. String ins = "\n";
  971. // Append current indentation.
  972. int space_count = 0;
  973. int line_col = 0;
  974. for (; line_col < cc; line_col++) {
  975. if (line[line_col] == '\t') {
  976. ins += indent_text;
  977. space_count = 0;
  978. continue;
  979. }
  980. if (line[line_col] == ' ') {
  981. space_count++;
  982. if (space_count == indent_size) {
  983. ins += indent_text;
  984. space_count = 0;
  985. }
  986. continue;
  987. }
  988. break;
  989. }
  990. if (is_line_folded(cl)) {
  991. unfold_line(cl);
  992. }
  993. // Indent once again if the previous line needs it, ie ':'.
  994. // Then add an addition new line for any closing pairs aka '()'.
  995. // Skip this in comments or if we are going above.
  996. bool brace_indent = false;
  997. if (auto_indent && !p_above && cc > 0 && is_in_comment(cl) == -1) {
  998. bool should_indent = false;
  999. char32_t indent_char = ' ';
  1000. for (; line_col < cc; line_col++) {
  1001. char32_t c = line[line_col];
  1002. if (auto_indent_prefixes.has(c) && is_in_comment(cl, line_col) == -1) {
  1003. should_indent = true;
  1004. indent_char = c;
  1005. continue;
  1006. }
  1007. // Make sure this is the last char, trailing whitespace or comments are okay.
  1008. // Increment column for comments because the delimiter (#) should be ignored.
  1009. if (should_indent && (!is_whitespace(c) && is_in_comment(cl, line_col + 1) == -1)) {
  1010. should_indent = false;
  1011. }
  1012. }
  1013. if (should_indent) {
  1014. ins += indent_text;
  1015. String closing_pair = get_auto_brace_completion_close_key(String::chr(indent_char));
  1016. if (!closing_pair.is_empty() && line.find(closing_pair, cc) == cc) {
  1017. // No need to move the brace below if we are not taking the text with us.
  1018. if (p_split_current_line) {
  1019. brace_indent = true;
  1020. ins += "\n" + ins.substr(indent_text.size(), ins.length() - 2);
  1021. } else {
  1022. brace_indent = false;
  1023. ins = "\n" + ins.substr(indent_text.size(), ins.length() - 2);
  1024. }
  1025. }
  1026. }
  1027. }
  1028. bool first_line = false;
  1029. if (!p_split_current_line) {
  1030. deselect(i);
  1031. if (p_above) {
  1032. if (cl > 0) {
  1033. set_caret_line(cl - 1, false, true, 0, i);
  1034. set_caret_column(get_line(get_caret_line(i)).length(), i == 0, i);
  1035. } else {
  1036. set_caret_column(0, i == 0, i);
  1037. first_line = true;
  1038. }
  1039. } else {
  1040. set_caret_column(line.length(), i == 0, i);
  1041. }
  1042. }
  1043. insert_text_at_caret(ins, i);
  1044. if (first_line) {
  1045. set_caret_line(0, i == 0, true, 0, i);
  1046. } else if (brace_indent) {
  1047. set_caret_line(get_caret_line(i) - 1, false, true, 0, i);
  1048. set_caret_column(get_line(get_caret_line(i)).length(), i == 0, i);
  1049. }
  1050. }
  1051. end_complex_operation();
  1052. }
  1053. /* Auto brace completion */
  1054. void CodeEdit::set_auto_brace_completion_enabled(bool p_enabled) {
  1055. auto_brace_completion_enabled = p_enabled;
  1056. }
  1057. bool CodeEdit::is_auto_brace_completion_enabled() const {
  1058. return auto_brace_completion_enabled;
  1059. }
  1060. void CodeEdit::set_highlight_matching_braces_enabled(bool p_enabled) {
  1061. highlight_matching_braces_enabled = p_enabled;
  1062. queue_redraw();
  1063. }
  1064. bool CodeEdit::is_highlight_matching_braces_enabled() const {
  1065. return highlight_matching_braces_enabled;
  1066. }
  1067. void CodeEdit::add_auto_brace_completion_pair(const String &p_open_key, const String &p_close_key) {
  1068. ERR_FAIL_COND_MSG(p_open_key.is_empty(), "auto brace completion open key cannot be empty");
  1069. ERR_FAIL_COND_MSG(p_close_key.is_empty(), "auto brace completion close key cannot be empty");
  1070. for (int i = 0; i < p_open_key.length(); i++) {
  1071. ERR_FAIL_COND_MSG(!is_symbol(p_open_key[i]), "auto brace completion open key must be a symbol");
  1072. }
  1073. for (int i = 0; i < p_close_key.length(); i++) {
  1074. ERR_FAIL_COND_MSG(!is_symbol(p_close_key[i]), "auto brace completion close key must be a symbol");
  1075. }
  1076. int at = 0;
  1077. for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
  1078. ERR_FAIL_COND_MSG(auto_brace_completion_pairs[i].open_key == p_open_key, "auto brace completion open key '" + p_open_key + "' already exists.");
  1079. if (p_open_key.length() < auto_brace_completion_pairs[i].open_key.length()) {
  1080. at++;
  1081. }
  1082. }
  1083. BracePair brace_pair;
  1084. brace_pair.open_key = p_open_key;
  1085. brace_pair.close_key = p_close_key;
  1086. auto_brace_completion_pairs.insert(at, brace_pair);
  1087. }
  1088. void CodeEdit::set_auto_brace_completion_pairs(const Dictionary &p_auto_brace_completion_pairs) {
  1089. auto_brace_completion_pairs.clear();
  1090. Array keys = p_auto_brace_completion_pairs.keys();
  1091. for (int i = 0; i < keys.size(); i++) {
  1092. add_auto_brace_completion_pair(keys[i], p_auto_brace_completion_pairs[keys[i]]);
  1093. }
  1094. }
  1095. Dictionary CodeEdit::get_auto_brace_completion_pairs() const {
  1096. Dictionary brace_pairs;
  1097. for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
  1098. brace_pairs[auto_brace_completion_pairs[i].open_key] = auto_brace_completion_pairs[i].close_key;
  1099. }
  1100. return brace_pairs;
  1101. }
  1102. bool CodeEdit::has_auto_brace_completion_open_key(const String &p_open_key) const {
  1103. for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
  1104. if (auto_brace_completion_pairs[i].open_key == p_open_key) {
  1105. return true;
  1106. }
  1107. }
  1108. return false;
  1109. }
  1110. bool CodeEdit::has_auto_brace_completion_close_key(const String &p_close_key) const {
  1111. for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
  1112. if (auto_brace_completion_pairs[i].close_key == p_close_key) {
  1113. return true;
  1114. }
  1115. }
  1116. return false;
  1117. }
  1118. String CodeEdit::get_auto_brace_completion_close_key(const String &p_open_key) const {
  1119. for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
  1120. if (auto_brace_completion_pairs[i].open_key == p_open_key) {
  1121. return auto_brace_completion_pairs[i].close_key;
  1122. }
  1123. }
  1124. return String();
  1125. }
  1126. /* Main Gutter */
  1127. void CodeEdit::_update_draw_main_gutter() {
  1128. set_gutter_draw(main_gutter, draw_breakpoints || draw_bookmarks || draw_executing_lines);
  1129. }
  1130. void CodeEdit::set_draw_breakpoints_gutter(bool p_draw) {
  1131. draw_breakpoints = p_draw;
  1132. set_gutter_clickable(main_gutter, p_draw);
  1133. _update_draw_main_gutter();
  1134. }
  1135. bool CodeEdit::is_drawing_breakpoints_gutter() const {
  1136. return draw_breakpoints;
  1137. }
  1138. void CodeEdit::set_draw_bookmarks_gutter(bool p_draw) {
  1139. draw_bookmarks = p_draw;
  1140. _update_draw_main_gutter();
  1141. }
  1142. bool CodeEdit::is_drawing_bookmarks_gutter() const {
  1143. return draw_bookmarks;
  1144. }
  1145. void CodeEdit::set_draw_executing_lines_gutter(bool p_draw) {
  1146. draw_executing_lines = p_draw;
  1147. _update_draw_main_gutter();
  1148. }
  1149. bool CodeEdit::is_drawing_executing_lines_gutter() const {
  1150. return draw_executing_lines;
  1151. }
  1152. void CodeEdit::_main_gutter_draw_callback(int p_line, int p_gutter, const Rect2 &p_region) {
  1153. if (draw_breakpoints && theme_cache.breakpoint_icon.is_valid()) {
  1154. bool breakpointed = is_line_breakpointed(p_line);
  1155. bool hovering = p_region.has_point(get_local_mouse_pos());
  1156. bool shift_pressed = Input::get_singleton()->is_key_pressed(Key::SHIFT);
  1157. if (breakpointed || (hovering && !is_dragging_cursor() && !shift_pressed)) {
  1158. int padding = p_region.size.x / 6;
  1159. Color use_color = theme_cache.breakpoint_color;
  1160. if (hovering && !shift_pressed) {
  1161. use_color = breakpointed ? use_color.lightened(0.3) : use_color.darkened(0.5);
  1162. }
  1163. Rect2 icon_region = p_region;
  1164. icon_region.position += Point2(padding, padding);
  1165. icon_region.size -= Point2(padding, padding) * 2;
  1166. theme_cache.breakpoint_icon->draw_rect(get_canvas_item(), icon_region, false, use_color);
  1167. }
  1168. }
  1169. if (draw_bookmarks && theme_cache.bookmark_icon.is_valid()) {
  1170. bool bookmarked = is_line_bookmarked(p_line);
  1171. bool hovering = p_region.has_point(get_local_mouse_pos());
  1172. bool shift_pressed = Input::get_singleton()->is_key_pressed(Key::SHIFT);
  1173. if (bookmarked || (hovering && !is_dragging_cursor() && shift_pressed)) {
  1174. int horizontal_padding = p_region.size.x / 2;
  1175. int vertical_padding = p_region.size.y / 4;
  1176. Color use_color = theme_cache.bookmark_color;
  1177. if (hovering && shift_pressed) {
  1178. use_color = bookmarked ? use_color.lightened(0.3) : use_color.darkened(0.5);
  1179. }
  1180. Rect2 icon_region = p_region;
  1181. icon_region.position += Point2(horizontal_padding, 0);
  1182. icon_region.size -= Point2(horizontal_padding * 1.1, vertical_padding);
  1183. theme_cache.bookmark_icon->draw_rect(get_canvas_item(), icon_region, false, use_color);
  1184. }
  1185. }
  1186. if (draw_executing_lines && is_line_executing(p_line) && theme_cache.executing_line_icon.is_valid()) {
  1187. int horizontal_padding = p_region.size.x / 10;
  1188. int vertical_padding = p_region.size.y / 4;
  1189. Rect2 icon_region = p_region;
  1190. icon_region.position += Point2(horizontal_padding, vertical_padding);
  1191. icon_region.size -= Point2(horizontal_padding, vertical_padding) * 2;
  1192. theme_cache.executing_line_icon->draw_rect(get_canvas_item(), icon_region, false, theme_cache.executing_line_color);
  1193. }
  1194. }
  1195. // Breakpoints
  1196. void CodeEdit::set_line_as_breakpoint(int p_line, bool p_breakpointed) {
  1197. ERR_FAIL_INDEX(p_line, get_line_count());
  1198. int mask = get_line_gutter_metadata(p_line, main_gutter);
  1199. set_line_gutter_metadata(p_line, main_gutter, p_breakpointed ? mask | MAIN_GUTTER_BREAKPOINT : mask & ~MAIN_GUTTER_BREAKPOINT);
  1200. if (p_breakpointed) {
  1201. breakpointed_lines[p_line] = true;
  1202. } else if (breakpointed_lines.has(p_line)) {
  1203. breakpointed_lines.erase(p_line);
  1204. }
  1205. emit_signal(SNAME("breakpoint_toggled"), p_line);
  1206. queue_redraw();
  1207. }
  1208. bool CodeEdit::is_line_breakpointed(int p_line) const {
  1209. return (int)get_line_gutter_metadata(p_line, main_gutter) & MAIN_GUTTER_BREAKPOINT;
  1210. }
  1211. void CodeEdit::clear_breakpointed_lines() {
  1212. for (int i = 0; i < get_line_count(); i++) {
  1213. if (is_line_breakpointed(i)) {
  1214. set_line_as_breakpoint(i, false);
  1215. }
  1216. }
  1217. }
  1218. PackedInt32Array CodeEdit::get_breakpointed_lines() const {
  1219. PackedInt32Array ret;
  1220. for (int i = 0; i < get_line_count(); i++) {
  1221. if (is_line_breakpointed(i)) {
  1222. ret.append(i);
  1223. }
  1224. }
  1225. return ret;
  1226. }
  1227. // Bookmarks
  1228. void CodeEdit::set_line_as_bookmarked(int p_line, bool p_bookmarked) {
  1229. int mask = get_line_gutter_metadata(p_line, main_gutter);
  1230. set_line_gutter_metadata(p_line, main_gutter, p_bookmarked ? mask | MAIN_GUTTER_BOOKMARK : mask & ~MAIN_GUTTER_BOOKMARK);
  1231. queue_redraw();
  1232. }
  1233. bool CodeEdit::is_line_bookmarked(int p_line) const {
  1234. return (int)get_line_gutter_metadata(p_line, main_gutter) & MAIN_GUTTER_BOOKMARK;
  1235. }
  1236. void CodeEdit::clear_bookmarked_lines() {
  1237. for (int i = 0; i < get_line_count(); i++) {
  1238. if (is_line_bookmarked(i)) {
  1239. set_line_as_bookmarked(i, false);
  1240. }
  1241. }
  1242. }
  1243. PackedInt32Array CodeEdit::get_bookmarked_lines() const {
  1244. PackedInt32Array ret;
  1245. for (int i = 0; i < get_line_count(); i++) {
  1246. if (is_line_bookmarked(i)) {
  1247. ret.append(i);
  1248. }
  1249. }
  1250. return ret;
  1251. }
  1252. // Executing lines
  1253. void CodeEdit::set_line_as_executing(int p_line, bool p_executing) {
  1254. int mask = get_line_gutter_metadata(p_line, main_gutter);
  1255. set_line_gutter_metadata(p_line, main_gutter, p_executing ? mask | MAIN_GUTTER_EXECUTING : mask & ~MAIN_GUTTER_EXECUTING);
  1256. queue_redraw();
  1257. }
  1258. bool CodeEdit::is_line_executing(int p_line) const {
  1259. return (int)get_line_gutter_metadata(p_line, main_gutter) & MAIN_GUTTER_EXECUTING;
  1260. }
  1261. void CodeEdit::clear_executing_lines() {
  1262. for (int i = 0; i < get_line_count(); i++) {
  1263. if (is_line_executing(i)) {
  1264. set_line_as_executing(i, false);
  1265. }
  1266. }
  1267. }
  1268. PackedInt32Array CodeEdit::get_executing_lines() const {
  1269. PackedInt32Array ret;
  1270. for (int i = 0; i < get_line_count(); i++) {
  1271. if (is_line_executing(i)) {
  1272. ret.append(i);
  1273. }
  1274. }
  1275. return ret;
  1276. }
  1277. /* Line numbers */
  1278. void CodeEdit::set_draw_line_numbers(bool p_draw) {
  1279. set_gutter_draw(line_number_gutter, p_draw);
  1280. }
  1281. bool CodeEdit::is_draw_line_numbers_enabled() const {
  1282. return is_gutter_drawn(line_number_gutter);
  1283. }
  1284. void CodeEdit::set_line_numbers_zero_padded(bool p_zero_padded) {
  1285. p_zero_padded ? line_number_padding = "0" : line_number_padding = " ";
  1286. queue_redraw();
  1287. }
  1288. bool CodeEdit::is_line_numbers_zero_padded() const {
  1289. return line_number_padding == "0";
  1290. }
  1291. void CodeEdit::_line_number_draw_callback(int p_line, int p_gutter, const Rect2 &p_region) {
  1292. String fc = String::num(p_line + 1).lpad(line_number_digits, line_number_padding);
  1293. if (is_localizing_numeral_system()) {
  1294. fc = TS->format_number(fc);
  1295. }
  1296. Ref<TextLine> tl;
  1297. tl.instantiate();
  1298. tl->add_string(fc, theme_cache.font, theme_cache.font_size);
  1299. int yofs = p_region.position.y + (get_line_height() - tl->get_size().y) / 2;
  1300. Color number_color = get_line_gutter_item_color(p_line, line_number_gutter);
  1301. if (number_color == Color(1, 1, 1)) {
  1302. number_color = theme_cache.line_number_color;
  1303. }
  1304. tl->draw(get_canvas_item(), Point2(p_region.position.x, yofs), number_color);
  1305. }
  1306. /* Fold Gutter */
  1307. void CodeEdit::set_draw_fold_gutter(bool p_draw) {
  1308. set_gutter_draw(fold_gutter, p_draw);
  1309. }
  1310. bool CodeEdit::is_drawing_fold_gutter() const {
  1311. return is_gutter_drawn(fold_gutter);
  1312. }
  1313. void CodeEdit::_fold_gutter_draw_callback(int p_line, int p_gutter, Rect2 p_region) {
  1314. if (!can_fold_line(p_line) && !is_line_folded(p_line)) {
  1315. set_line_gutter_clickable(p_line, fold_gutter, false);
  1316. return;
  1317. }
  1318. set_line_gutter_clickable(p_line, fold_gutter, true);
  1319. int horizontal_padding = p_region.size.x / 10;
  1320. int vertical_padding = p_region.size.y / 6;
  1321. p_region.position += Point2(horizontal_padding, vertical_padding);
  1322. p_region.size -= Point2(horizontal_padding, vertical_padding) * 2;
  1323. if (can_fold_line(p_line)) {
  1324. theme_cache.can_fold_icon->draw_rect(get_canvas_item(), p_region, false, theme_cache.code_folding_color);
  1325. return;
  1326. }
  1327. theme_cache.folded_icon->draw_rect(get_canvas_item(), p_region, false, theme_cache.code_folding_color);
  1328. }
  1329. /* Line Folding */
  1330. void CodeEdit::set_line_folding_enabled(bool p_enabled) {
  1331. line_folding_enabled = p_enabled;
  1332. _set_hiding_enabled(p_enabled);
  1333. }
  1334. bool CodeEdit::is_line_folding_enabled() const {
  1335. return line_folding_enabled;
  1336. }
  1337. bool CodeEdit::can_fold_line(int p_line) const {
  1338. ERR_FAIL_INDEX_V(p_line, get_line_count(), false);
  1339. if (!line_folding_enabled) {
  1340. return false;
  1341. }
  1342. if (p_line + 1 >= get_line_count() || get_line(p_line).strip_edges().size() == 0) {
  1343. return false;
  1344. }
  1345. if (_is_line_hidden(p_line) || is_line_folded(p_line)) {
  1346. return false;
  1347. }
  1348. /* Check for full multiline line or block strings / comments. */
  1349. int in_comment = is_in_comment(p_line);
  1350. int in_string = (in_comment == -1) ? is_in_string(p_line) : -1;
  1351. if (in_string != -1 || in_comment != -1) {
  1352. if (get_delimiter_start_position(p_line, get_line(p_line).size() - 1).y != p_line) {
  1353. return false;
  1354. }
  1355. int delimter_end_line = get_delimiter_end_position(p_line, get_line(p_line).size() - 1).y;
  1356. /* No end line, therefore we have a multiline region over the rest of the file. */
  1357. if (delimter_end_line == -1) {
  1358. return true;
  1359. }
  1360. /* End line is the same therefore we have a block. */
  1361. if (delimter_end_line == p_line) {
  1362. /* Check we are the start of the block. */
  1363. if (p_line - 1 >= 0) {
  1364. if ((in_string != -1 && is_in_string(p_line - 1) != -1) || (in_comment != -1 && is_in_comment(p_line - 1) != -1)) {
  1365. return false;
  1366. }
  1367. }
  1368. /* Check it continues for at least one line. */
  1369. return ((in_string != -1 && is_in_string(p_line + 1) != -1) || (in_comment != -1 && is_in_comment(p_line + 1) != -1));
  1370. }
  1371. return ((in_string != -1 && is_in_string(delimter_end_line) != -1) || (in_comment != -1 && is_in_comment(delimter_end_line) != -1));
  1372. }
  1373. /* Otherwise check indent levels. */
  1374. int start_indent = get_indent_level(p_line);
  1375. for (int i = p_line + 1; i < get_line_count(); i++) {
  1376. if (is_in_string(i) != -1 || is_in_comment(i) != -1 || get_line(i).strip_edges().size() == 0) {
  1377. continue;
  1378. }
  1379. return (get_indent_level(i) > start_indent);
  1380. }
  1381. return false;
  1382. }
  1383. void CodeEdit::fold_line(int p_line) {
  1384. ERR_FAIL_INDEX(p_line, get_line_count());
  1385. if (!is_line_folding_enabled() || !can_fold_line(p_line)) {
  1386. return;
  1387. }
  1388. /* Find the last line to be hidden. */
  1389. const int line_count = get_line_count() - 1;
  1390. int end_line = line_count;
  1391. int in_comment = is_in_comment(p_line);
  1392. int in_string = (in_comment == -1) ? is_in_string(p_line) : -1;
  1393. if (in_string != -1 || in_comment != -1) {
  1394. end_line = get_delimiter_end_position(p_line, get_line(p_line).size() - 1).y;
  1395. /* End line is the same therefore we have a block of single line delimiters. */
  1396. if (end_line == p_line) {
  1397. for (int i = p_line + 1; i <= line_count; i++) {
  1398. if ((in_string != -1 && is_in_string(i) == -1) || (in_comment != -1 && is_in_comment(i) == -1)) {
  1399. break;
  1400. }
  1401. end_line = i;
  1402. }
  1403. }
  1404. } else {
  1405. int start_indent = get_indent_level(p_line);
  1406. for (int i = p_line + 1; i <= line_count; i++) {
  1407. if (get_line(i).strip_edges().size() == 0) {
  1408. continue;
  1409. }
  1410. if (get_indent_level(i) > start_indent) {
  1411. end_line = i;
  1412. continue;
  1413. }
  1414. if (is_in_string(i) == -1 && is_in_comment(i) == -1) {
  1415. break;
  1416. }
  1417. }
  1418. }
  1419. for (int i = p_line + 1; i <= end_line; i++) {
  1420. _set_line_as_hidden(i, true);
  1421. }
  1422. for (int i = 0; i < get_caret_count(); i++) {
  1423. // Fix selection.
  1424. if (has_selection(i)) {
  1425. if (_is_line_hidden(get_selection_from_line(i)) && _is_line_hidden(get_selection_to_line(i))) {
  1426. deselect(i);
  1427. } else if (_is_line_hidden(get_selection_from_line(i))) {
  1428. select(p_line, 9999, get_selection_to_line(i), get_selection_to_column(i), i);
  1429. } else if (_is_line_hidden(get_selection_to_line(i))) {
  1430. select(get_selection_from_line(i), get_selection_from_column(i), p_line, 9999, i);
  1431. }
  1432. }
  1433. // Reset caret.
  1434. if (_is_line_hidden(get_caret_line(i))) {
  1435. set_caret_line(p_line, false, false, 0, i);
  1436. set_caret_column(get_line(p_line).length(), false, i);
  1437. }
  1438. }
  1439. merge_overlapping_carets();
  1440. queue_redraw();
  1441. }
  1442. void CodeEdit::unfold_line(int p_line) {
  1443. ERR_FAIL_INDEX(p_line, get_line_count());
  1444. if (!is_line_folded(p_line) && !_is_line_hidden(p_line)) {
  1445. return;
  1446. }
  1447. int fold_start = p_line;
  1448. for (; fold_start > 0; fold_start--) {
  1449. if (is_line_folded(fold_start)) {
  1450. break;
  1451. }
  1452. }
  1453. fold_start = is_line_folded(fold_start) ? fold_start : p_line;
  1454. for (int i = fold_start + 1; i < get_line_count(); i++) {
  1455. if (!_is_line_hidden(i)) {
  1456. break;
  1457. }
  1458. _set_line_as_hidden(i, false);
  1459. }
  1460. queue_redraw();
  1461. }
  1462. void CodeEdit::fold_all_lines() {
  1463. for (int i = 0; i < get_line_count(); i++) {
  1464. fold_line(i);
  1465. }
  1466. queue_redraw();
  1467. }
  1468. void CodeEdit::unfold_all_lines() {
  1469. _unhide_all_lines();
  1470. }
  1471. void CodeEdit::toggle_foldable_line(int p_line) {
  1472. ERR_FAIL_INDEX(p_line, get_line_count());
  1473. if (is_line_folded(p_line)) {
  1474. unfold_line(p_line);
  1475. return;
  1476. }
  1477. fold_line(p_line);
  1478. }
  1479. bool CodeEdit::is_line_folded(int p_line) const {
  1480. ERR_FAIL_INDEX_V(p_line, get_line_count(), false);
  1481. return p_line + 1 < get_line_count() && !_is_line_hidden(p_line) && _is_line_hidden(p_line + 1);
  1482. }
  1483. TypedArray<int> CodeEdit::get_folded_lines() const {
  1484. TypedArray<int> folded_lines;
  1485. for (int i = 0; i < get_line_count(); i++) {
  1486. if (is_line_folded(i)) {
  1487. folded_lines.push_back(i);
  1488. }
  1489. }
  1490. return folded_lines;
  1491. }
  1492. /* Delimiters */
  1493. // Strings
  1494. void CodeEdit::add_string_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only) {
  1495. _add_delimiter(p_start_key, p_end_key, p_line_only, TYPE_STRING);
  1496. }
  1497. void CodeEdit::remove_string_delimiter(const String &p_start_key) {
  1498. _remove_delimiter(p_start_key, TYPE_STRING);
  1499. }
  1500. bool CodeEdit::has_string_delimiter(const String &p_start_key) const {
  1501. return _has_delimiter(p_start_key, TYPE_STRING);
  1502. }
  1503. void CodeEdit::set_string_delimiters(const TypedArray<String> &p_string_delimiters) {
  1504. _set_delimiters(p_string_delimiters, TYPE_STRING);
  1505. }
  1506. void CodeEdit::clear_string_delimiters() {
  1507. _clear_delimiters(TYPE_STRING);
  1508. }
  1509. TypedArray<String> CodeEdit::get_string_delimiters() const {
  1510. return _get_delimiters(TYPE_STRING);
  1511. }
  1512. int CodeEdit::is_in_string(int p_line, int p_column) const {
  1513. return _is_in_delimiter(p_line, p_column, TYPE_STRING);
  1514. }
  1515. // Comments
  1516. void CodeEdit::add_comment_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only) {
  1517. _add_delimiter(p_start_key, p_end_key, p_line_only, TYPE_COMMENT);
  1518. }
  1519. void CodeEdit::remove_comment_delimiter(const String &p_start_key) {
  1520. _remove_delimiter(p_start_key, TYPE_COMMENT);
  1521. }
  1522. bool CodeEdit::has_comment_delimiter(const String &p_start_key) const {
  1523. return _has_delimiter(p_start_key, TYPE_COMMENT);
  1524. }
  1525. void CodeEdit::set_comment_delimiters(const TypedArray<String> &p_comment_delimiters) {
  1526. _set_delimiters(p_comment_delimiters, TYPE_COMMENT);
  1527. }
  1528. void CodeEdit::clear_comment_delimiters() {
  1529. _clear_delimiters(TYPE_COMMENT);
  1530. }
  1531. TypedArray<String> CodeEdit::get_comment_delimiters() const {
  1532. return _get_delimiters(TYPE_COMMENT);
  1533. }
  1534. int CodeEdit::is_in_comment(int p_line, int p_column) const {
  1535. return _is_in_delimiter(p_line, p_column, TYPE_COMMENT);
  1536. }
  1537. String CodeEdit::get_delimiter_start_key(int p_delimiter_idx) const {
  1538. ERR_FAIL_INDEX_V(p_delimiter_idx, delimiters.size(), "");
  1539. return delimiters[p_delimiter_idx].start_key;
  1540. }
  1541. String CodeEdit::get_delimiter_end_key(int p_delimiter_idx) const {
  1542. ERR_FAIL_INDEX_V(p_delimiter_idx, delimiters.size(), "");
  1543. return delimiters[p_delimiter_idx].end_key;
  1544. }
  1545. Point2 CodeEdit::get_delimiter_start_position(int p_line, int p_column) const {
  1546. if (delimiters.size() == 0) {
  1547. return Point2(-1, -1);
  1548. }
  1549. ERR_FAIL_INDEX_V(p_line, get_line_count(), Point2(-1, -1));
  1550. ERR_FAIL_COND_V(p_column - 1 > get_line(p_line).size(), Point2(-1, -1));
  1551. Point2 start_position;
  1552. start_position.y = -1;
  1553. start_position.x = -1;
  1554. bool in_region = ((p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->get()) != -1;
  1555. /* Check the keys for this line. */
  1556. for (const KeyValue<int, int> &E : delimiter_cache[p_line]) {
  1557. if (E.key > p_column) {
  1558. break;
  1559. }
  1560. in_region = E.value != -1;
  1561. start_position.x = in_region ? E.key : -1;
  1562. }
  1563. /* Region was found on this line and is not a multiline continuation. */
  1564. int line_length = get_line(p_line).length();
  1565. if (start_position.x != -1 && line_length > 0 && start_position.x != line_length + 1) {
  1566. start_position.y = p_line;
  1567. return start_position;
  1568. }
  1569. /* Not in a region */
  1570. if (!in_region) {
  1571. return start_position;
  1572. }
  1573. /* Region starts on a previous line */
  1574. for (int i = p_line - 1; i >= 0; i--) {
  1575. if (delimiter_cache[i].size() < 1) {
  1576. continue;
  1577. }
  1578. start_position.y = i;
  1579. start_position.x = delimiter_cache[i].back()->key();
  1580. /* Make sure it's not a multiline continuation. */
  1581. line_length = get_line(i).length();
  1582. if (line_length > 0 && start_position.x != line_length + 1) {
  1583. break;
  1584. }
  1585. }
  1586. return start_position;
  1587. }
  1588. Point2 CodeEdit::get_delimiter_end_position(int p_line, int p_column) const {
  1589. if (delimiters.size() == 0) {
  1590. return Point2(-1, -1);
  1591. }
  1592. ERR_FAIL_INDEX_V(p_line, get_line_count(), Point2(-1, -1));
  1593. ERR_FAIL_COND_V(p_column - 1 > get_line(p_line).size(), Point2(-1, -1));
  1594. Point2 end_position;
  1595. end_position.y = -1;
  1596. end_position.x = -1;
  1597. int region = (p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->value();
  1598. /* Check the keys for this line. */
  1599. for (const KeyValue<int, int> &E : delimiter_cache[p_line]) {
  1600. end_position.x = (E.value == -1) ? E.key : -1;
  1601. if (E.key > p_column) {
  1602. break;
  1603. }
  1604. region = E.value;
  1605. }
  1606. /* Region was found on this line and is not a multiline continuation. */
  1607. if (region != -1 && end_position.x != -1 && (delimiters[region].line_only || end_position.x != get_line(p_line).length() + 1)) {
  1608. end_position.y = p_line;
  1609. return end_position;
  1610. }
  1611. /* Not in a region */
  1612. if (region == -1) {
  1613. end_position.x = -1;
  1614. return end_position;
  1615. }
  1616. /* Region ends on a later line */
  1617. for (int i = p_line + 1; i < get_line_count(); i++) {
  1618. if (delimiter_cache[i].size() < 1 || delimiter_cache[i].front()->value() != -1) {
  1619. continue;
  1620. }
  1621. end_position.x = delimiter_cache[i].front()->key();
  1622. /* Make sure it's not a multiline continuation. */
  1623. if (get_line(i).length() > 0 && end_position.x != get_line(i).length() + 1) {
  1624. end_position.y = i;
  1625. break;
  1626. }
  1627. end_position.x = -1;
  1628. }
  1629. return end_position;
  1630. }
  1631. /* Code hint */
  1632. void CodeEdit::set_code_hint(const String &p_hint) {
  1633. code_hint = p_hint;
  1634. code_hint_xpos = -0xFFFF;
  1635. queue_redraw();
  1636. }
  1637. void CodeEdit::set_code_hint_draw_below(bool p_below) {
  1638. code_hint_draw_below = p_below;
  1639. queue_redraw();
  1640. }
  1641. /* Code Completion */
  1642. void CodeEdit::set_code_completion_enabled(bool p_enable) {
  1643. code_completion_enabled = p_enable;
  1644. }
  1645. bool CodeEdit::is_code_completion_enabled() const {
  1646. return code_completion_enabled;
  1647. }
  1648. void CodeEdit::set_code_completion_prefixes(const TypedArray<String> &p_prefixes) {
  1649. code_completion_prefixes.clear();
  1650. for (int i = 0; i < p_prefixes.size(); i++) {
  1651. const String prefix = p_prefixes[i];
  1652. ERR_CONTINUE_MSG(prefix.is_empty(), "Code completion prefix cannot be empty.");
  1653. code_completion_prefixes.insert(prefix[0]);
  1654. }
  1655. }
  1656. TypedArray<String> CodeEdit::get_code_completion_prefixes() const {
  1657. TypedArray<String> prefixes;
  1658. for (const char32_t &E : code_completion_prefixes) {
  1659. prefixes.push_back(String::chr(E));
  1660. }
  1661. return prefixes;
  1662. }
  1663. String CodeEdit::get_text_for_code_completion() const {
  1664. StringBuilder completion_text;
  1665. const int text_size = get_line_count();
  1666. for (int i = 0; i < text_size; i++) {
  1667. String line = get_line(i);
  1668. if (i == get_caret_line()) {
  1669. completion_text += line.substr(0, get_caret_column());
  1670. /* Not unicode, represents the caret. */
  1671. completion_text += String::chr(0xFFFF);
  1672. completion_text += line.substr(get_caret_column(), line.size());
  1673. } else {
  1674. completion_text += line;
  1675. }
  1676. if (i != text_size - 1) {
  1677. completion_text += "\n";
  1678. }
  1679. }
  1680. return completion_text.as_string();
  1681. }
  1682. void CodeEdit::request_code_completion(bool p_force) {
  1683. if (GDVIRTUAL_CALL(_request_code_completion, p_force)) {
  1684. return;
  1685. }
  1686. /* Don't re-query if all existing options are quoted types, eg path, signal. */
  1687. bool ignored = code_completion_active && !code_completion_options.is_empty();
  1688. if (ignored) {
  1689. ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT;
  1690. const ScriptLanguage::CodeCompletionOption *previous_option = nullptr;
  1691. for (int i = 0; i < code_completion_options.size(); i++) {
  1692. const ScriptLanguage::CodeCompletionOption &current_option = code_completion_options[i];
  1693. if (!previous_option) {
  1694. previous_option = &current_option;
  1695. kind = current_option.kind;
  1696. }
  1697. if (previous_option->kind != current_option.kind) {
  1698. ignored = false;
  1699. break;
  1700. }
  1701. }
  1702. ignored = ignored && (kind == ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH || kind == ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH || kind == ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL);
  1703. }
  1704. if (ignored) {
  1705. return;
  1706. }
  1707. if (p_force) {
  1708. emit_signal(SNAME("code_completion_requested"));
  1709. return;
  1710. }
  1711. String line = get_line(get_caret_line());
  1712. int ofs = CLAMP(get_caret_column(), 0, line.length());
  1713. if (ofs > 0 && (is_in_string(get_caret_line(), ofs) != -1 || !is_symbol(line[ofs - 1]) || code_completion_prefixes.has(line[ofs - 1]))) {
  1714. emit_signal(SNAME("code_completion_requested"));
  1715. } else if (ofs > 1 && line[ofs - 1] == ' ' && code_completion_prefixes.has(line[ofs - 2])) {
  1716. emit_signal(SNAME("code_completion_requested"));
  1717. }
  1718. }
  1719. void CodeEdit::add_code_completion_option(CodeCompletionKind p_type, const String &p_display_text, const String &p_insert_text, const Color &p_text_color, const Ref<Resource> &p_icon, const Variant &p_value, int p_location) {
  1720. ScriptLanguage::CodeCompletionOption completion_option;
  1721. completion_option.kind = (ScriptLanguage::CodeCompletionKind)p_type;
  1722. completion_option.display = p_display_text;
  1723. completion_option.insert_text = p_insert_text;
  1724. completion_option.font_color = p_text_color;
  1725. completion_option.icon = p_icon;
  1726. completion_option.default_value = p_value;
  1727. completion_option.location = p_location;
  1728. code_completion_option_submitted.push_back(completion_option);
  1729. }
  1730. void CodeEdit::update_code_completion_options(bool p_forced) {
  1731. code_completion_forced = p_forced;
  1732. code_completion_option_sources = code_completion_option_submitted;
  1733. code_completion_option_submitted.clear();
  1734. _filter_code_completion_candidates_impl();
  1735. }
  1736. TypedArray<Dictionary> CodeEdit::get_code_completion_options() const {
  1737. if (!code_completion_active) {
  1738. return TypedArray<Dictionary>();
  1739. }
  1740. TypedArray<Dictionary> completion_options;
  1741. completion_options.resize(code_completion_options.size());
  1742. for (int i = 0; i < code_completion_options.size(); i++) {
  1743. Dictionary option;
  1744. option["kind"] = code_completion_options[i].kind;
  1745. option["display_text"] = code_completion_options[i].display;
  1746. option["insert_text"] = code_completion_options[i].insert_text;
  1747. option["font_color"] = code_completion_options[i].font_color;
  1748. option["icon"] = code_completion_options[i].icon;
  1749. option["location"] = code_completion_options[i].location;
  1750. option["default_value"] = code_completion_options[i].default_value;
  1751. completion_options[i] = option;
  1752. }
  1753. return completion_options;
  1754. }
  1755. Dictionary CodeEdit::get_code_completion_option(int p_index) const {
  1756. if (!code_completion_active) {
  1757. return Dictionary();
  1758. }
  1759. ERR_FAIL_INDEX_V(p_index, code_completion_options.size(), Dictionary());
  1760. Dictionary option;
  1761. option["kind"] = code_completion_options[p_index].kind;
  1762. option["display_text"] = code_completion_options[p_index].display;
  1763. option["insert_text"] = code_completion_options[p_index].insert_text;
  1764. option["font_color"] = code_completion_options[p_index].font_color;
  1765. option["icon"] = code_completion_options[p_index].icon;
  1766. option["location"] = code_completion_options[p_index].location;
  1767. option["default_value"] = code_completion_options[p_index].default_value;
  1768. return option;
  1769. }
  1770. int CodeEdit::get_code_completion_selected_index() const {
  1771. return (code_completion_active) ? code_completion_current_selected : -1;
  1772. }
  1773. void CodeEdit::set_code_completion_selected_index(int p_index) {
  1774. if (!code_completion_active) {
  1775. return;
  1776. }
  1777. ERR_FAIL_INDEX(p_index, code_completion_options.size());
  1778. code_completion_current_selected = p_index;
  1779. code_completion_force_item_center = -1;
  1780. queue_redraw();
  1781. }
  1782. void CodeEdit::confirm_code_completion(bool p_replace) {
  1783. if (!is_editable() || !code_completion_active) {
  1784. return;
  1785. }
  1786. if (GDVIRTUAL_CALL(_confirm_code_completion, p_replace)) {
  1787. return;
  1788. }
  1789. char32_t caret_last_completion_char = 0;
  1790. begin_complex_operation();
  1791. Vector<int> caret_edit_order = get_caret_index_edit_order();
  1792. for (const int &i : caret_edit_order) {
  1793. int caret_line = get_caret_line(i);
  1794. const String &insert_text = code_completion_options[code_completion_current_selected].insert_text;
  1795. const String &display_text = code_completion_options[code_completion_current_selected].display;
  1796. if (p_replace) {
  1797. // Find end of current section.
  1798. const String line = get_line(caret_line);
  1799. int caret_col = get_caret_column(i);
  1800. int caret_remove_line = caret_line;
  1801. bool merge_text = true;
  1802. int in_string = is_in_string(caret_line, caret_col);
  1803. if (in_string != -1) {
  1804. Point2 string_end = get_delimiter_end_position(caret_line, caret_col);
  1805. if (string_end.x != -1) {
  1806. merge_text = false;
  1807. caret_remove_line = string_end.y;
  1808. caret_col = string_end.x - 1;
  1809. }
  1810. }
  1811. if (merge_text) {
  1812. for (; caret_col < line.length(); caret_col++) {
  1813. if (is_symbol(line[caret_col])) {
  1814. break;
  1815. }
  1816. }
  1817. }
  1818. // Replace.
  1819. remove_text(caret_line, get_caret_column(i) - code_completion_base.length(), caret_remove_line, caret_col);
  1820. adjust_carets_after_edit(i, caret_line, caret_col - code_completion_base.length(), caret_remove_line, caret_col);
  1821. set_caret_column(get_caret_column(i) - code_completion_base.length(), false, i);
  1822. insert_text_at_caret(insert_text, i);
  1823. } else {
  1824. // Get first non-matching char.
  1825. const String line = get_line(caret_line);
  1826. int caret_col = get_caret_column(i);
  1827. int matching_chars = code_completion_base.length();
  1828. for (; matching_chars <= insert_text.length(); matching_chars++) {
  1829. if (caret_col >= line.length() || line[caret_col] != insert_text[matching_chars]) {
  1830. break;
  1831. }
  1832. caret_col++;
  1833. }
  1834. // Remove base completion text.
  1835. remove_text(caret_line, get_caret_column(i) - code_completion_base.length(), caret_line, get_caret_column(i));
  1836. adjust_carets_after_edit(i, caret_line, get_caret_column(i) - code_completion_base.length(), caret_line, get_caret_column(i));
  1837. set_caret_column(get_caret_column(i) - code_completion_base.length(), false, i);
  1838. // Merge with text.
  1839. insert_text_at_caret(insert_text.substr(0, code_completion_base.length()), i);
  1840. set_caret_column(caret_col, false, i);
  1841. insert_text_at_caret(insert_text.substr(matching_chars), i);
  1842. }
  1843. // Handle merging of symbols eg strings, brackets.
  1844. const String line = get_line(caret_line);
  1845. char32_t next_char = line[get_caret_column(i)];
  1846. char32_t last_completion_char = insert_text[insert_text.length() - 1];
  1847. if (i == 0) {
  1848. caret_last_completion_char = last_completion_char;
  1849. }
  1850. char32_t last_completion_char_display = display_text[display_text.length() - 1];
  1851. bool last_char_matches = (last_completion_char == next_char || last_completion_char_display == next_char);
  1852. int pre_brace_pair = get_caret_column(i) > 0 ? _get_auto_brace_pair_open_at_pos(caret_line, get_caret_column(i)) : -1;
  1853. int post_brace_pair = get_caret_column(i) < get_line(caret_line).length() ? _get_auto_brace_pair_close_at_pos(caret_line, get_caret_column(i)) : -1;
  1854. // Strings do not nest like brackets, so ensure we don't add an additional closing pair.
  1855. if (has_string_delimiter(String::chr(last_completion_char))) {
  1856. if (post_brace_pair != -1 && last_char_matches) {
  1857. remove_text(caret_line, get_caret_column(i), caret_line, get_caret_column(i) + 1);
  1858. adjust_carets_after_edit(i, caret_line, get_caret_column(i), caret_line, get_caret_column(i) + 1);
  1859. }
  1860. } else {
  1861. if (pre_brace_pair != -1 && pre_brace_pair != post_brace_pair && last_char_matches) {
  1862. remove_text(caret_line, get_caret_column(i), caret_line, get_caret_column(i) + 1);
  1863. adjust_carets_after_edit(i, caret_line, get_caret_column(i), caret_line, get_caret_column(i) + 1);
  1864. } else if (auto_brace_completion_enabled && pre_brace_pair != -1) {
  1865. insert_text_at_caret(auto_brace_completion_pairs[pre_brace_pair].close_key, i);
  1866. set_caret_column(get_caret_column(i) - auto_brace_completion_pairs[pre_brace_pair].close_key.length(), i == 0, i);
  1867. }
  1868. }
  1869. if (pre_brace_pair == -1 && post_brace_pair == -1 && get_caret_column(i) > 0 && get_caret_column(i) < get_line(caret_line).length()) {
  1870. pre_brace_pair = _get_auto_brace_pair_open_at_pos(caret_line, get_caret_column(i) + 1);
  1871. if (pre_brace_pair != -1 && pre_brace_pair == _get_auto_brace_pair_close_at_pos(caret_line, get_caret_column(i) - 1)) {
  1872. remove_text(caret_line, get_caret_column(i) - 2, caret_line, get_caret_column(i));
  1873. adjust_carets_after_edit(i, caret_line, get_caret_column(i) - 2, caret_line, get_caret_column(i));
  1874. if (_get_auto_brace_pair_close_at_pos(caret_line, get_caret_column(i) - 1) != pre_brace_pair) {
  1875. set_caret_column(get_caret_column(i) - 1, i == 0, i);
  1876. }
  1877. }
  1878. }
  1879. }
  1880. end_complex_operation();
  1881. cancel_code_completion();
  1882. if (code_completion_prefixes.has(caret_last_completion_char)) {
  1883. request_code_completion();
  1884. }
  1885. }
  1886. void CodeEdit::cancel_code_completion() {
  1887. if (!code_completion_active) {
  1888. return;
  1889. }
  1890. code_completion_forced = false;
  1891. code_completion_active = false;
  1892. is_code_completion_drag_started = false;
  1893. queue_redraw();
  1894. }
  1895. /* Line length guidelines */
  1896. void CodeEdit::set_line_length_guidelines(TypedArray<int> p_guideline_columns) {
  1897. line_length_guideline_columns = p_guideline_columns;
  1898. queue_redraw();
  1899. }
  1900. TypedArray<int> CodeEdit::get_line_length_guidelines() const {
  1901. return line_length_guideline_columns;
  1902. }
  1903. /* Symbol lookup */
  1904. void CodeEdit::set_symbol_lookup_on_click_enabled(bool p_enabled) {
  1905. symbol_lookup_on_click_enabled = p_enabled;
  1906. set_symbol_lookup_word_as_valid(false);
  1907. }
  1908. bool CodeEdit::is_symbol_lookup_on_click_enabled() const {
  1909. return symbol_lookup_on_click_enabled;
  1910. }
  1911. String CodeEdit::get_text_for_symbol_lookup() {
  1912. Point2i mp = get_local_mouse_pos();
  1913. Point2i pos = get_line_column_at_pos(mp, false);
  1914. int line = pos.y;
  1915. int col = pos.x;
  1916. if (line == -1) {
  1917. return String();
  1918. }
  1919. StringBuilder lookup_text;
  1920. const int text_size = get_line_count();
  1921. for (int i = 0; i < text_size; i++) {
  1922. String line_text = get_line(i);
  1923. if (i == line) {
  1924. lookup_text += line_text.substr(0, col);
  1925. /* Not unicode, represents the cursor. */
  1926. lookup_text += String::chr(0xFFFF);
  1927. lookup_text += line_text.substr(col, line_text.size());
  1928. } else {
  1929. lookup_text += line_text;
  1930. }
  1931. if (i != text_size - 1) {
  1932. lookup_text += "\n";
  1933. }
  1934. }
  1935. return lookup_text.as_string();
  1936. }
  1937. void CodeEdit::set_symbol_lookup_word_as_valid(bool p_valid) {
  1938. symbol_lookup_word = p_valid ? symbol_lookup_new_word : "";
  1939. symbol_lookup_new_word = "";
  1940. if (lookup_symbol_word != symbol_lookup_word) {
  1941. _set_symbol_lookup_word(symbol_lookup_word);
  1942. }
  1943. }
  1944. void CodeEdit::_bind_methods() {
  1945. /* Indent management */
  1946. ClassDB::bind_method(D_METHOD("set_indent_size", "size"), &CodeEdit::set_indent_size);
  1947. ClassDB::bind_method(D_METHOD("get_indent_size"), &CodeEdit::get_indent_size);
  1948. ClassDB::bind_method(D_METHOD("set_indent_using_spaces", "use_spaces"), &CodeEdit::set_indent_using_spaces);
  1949. ClassDB::bind_method(D_METHOD("is_indent_using_spaces"), &CodeEdit::is_indent_using_spaces);
  1950. ClassDB::bind_method(D_METHOD("set_auto_indent_enabled", "enable"), &CodeEdit::set_auto_indent_enabled);
  1951. ClassDB::bind_method(D_METHOD("is_auto_indent_enabled"), &CodeEdit::is_auto_indent_enabled);
  1952. ClassDB::bind_method(D_METHOD("set_auto_indent_prefixes", "prefixes"), &CodeEdit::set_auto_indent_prefixes);
  1953. ClassDB::bind_method(D_METHOD("get_auto_indent_prefixes"), &CodeEdit::get_auto_indent_prefixes);
  1954. ClassDB::bind_method(D_METHOD("do_indent"), &CodeEdit::do_indent);
  1955. ClassDB::bind_method(D_METHOD("indent_lines"), &CodeEdit::indent_lines);
  1956. ClassDB::bind_method(D_METHOD("unindent_lines"), &CodeEdit::unindent_lines);
  1957. ClassDB::bind_method(D_METHOD("convert_indent", "from_line", "to_line"), &CodeEdit::convert_indent, DEFVAL(-1), DEFVAL(-1));
  1958. /* Auto brace completion */
  1959. ClassDB::bind_method(D_METHOD("set_auto_brace_completion_enabled", "enable"), &CodeEdit::set_auto_brace_completion_enabled);
  1960. ClassDB::bind_method(D_METHOD("is_auto_brace_completion_enabled"), &CodeEdit::is_auto_brace_completion_enabled);
  1961. ClassDB::bind_method(D_METHOD("set_highlight_matching_braces_enabled", "enable"), &CodeEdit::set_highlight_matching_braces_enabled);
  1962. ClassDB::bind_method(D_METHOD("is_highlight_matching_braces_enabled"), &CodeEdit::is_highlight_matching_braces_enabled);
  1963. ClassDB::bind_method(D_METHOD("add_auto_brace_completion_pair", "start_key", "end_key"), &CodeEdit::add_auto_brace_completion_pair);
  1964. ClassDB::bind_method(D_METHOD("set_auto_brace_completion_pairs", "pairs"), &CodeEdit::set_auto_brace_completion_pairs);
  1965. ClassDB::bind_method(D_METHOD("get_auto_brace_completion_pairs"), &CodeEdit::get_auto_brace_completion_pairs);
  1966. ClassDB::bind_method(D_METHOD("has_auto_brace_completion_open_key", "open_key"), &CodeEdit::has_auto_brace_completion_open_key);
  1967. ClassDB::bind_method(D_METHOD("has_auto_brace_completion_close_key", "close_key"), &CodeEdit::has_auto_brace_completion_close_key);
  1968. ClassDB::bind_method(D_METHOD("get_auto_brace_completion_close_key", "open_key"), &CodeEdit::get_auto_brace_completion_close_key);
  1969. /* Main Gutter */
  1970. ClassDB::bind_method(D_METHOD("set_draw_breakpoints_gutter", "enable"), &CodeEdit::set_draw_breakpoints_gutter);
  1971. ClassDB::bind_method(D_METHOD("is_drawing_breakpoints_gutter"), &CodeEdit::is_drawing_breakpoints_gutter);
  1972. ClassDB::bind_method(D_METHOD("set_draw_bookmarks_gutter", "enable"), &CodeEdit::set_draw_bookmarks_gutter);
  1973. ClassDB::bind_method(D_METHOD("is_drawing_bookmarks_gutter"), &CodeEdit::is_drawing_bookmarks_gutter);
  1974. ClassDB::bind_method(D_METHOD("set_draw_executing_lines_gutter", "enable"), &CodeEdit::set_draw_executing_lines_gutter);
  1975. ClassDB::bind_method(D_METHOD("is_drawing_executing_lines_gutter"), &CodeEdit::is_drawing_executing_lines_gutter);
  1976. // Breakpoints
  1977. ClassDB::bind_method(D_METHOD("set_line_as_breakpoint", "line", "breakpointed"), &CodeEdit::set_line_as_breakpoint);
  1978. ClassDB::bind_method(D_METHOD("is_line_breakpointed", "line"), &CodeEdit::is_line_breakpointed);
  1979. ClassDB::bind_method(D_METHOD("clear_breakpointed_lines"), &CodeEdit::clear_breakpointed_lines);
  1980. ClassDB::bind_method(D_METHOD("get_breakpointed_lines"), &CodeEdit::get_breakpointed_lines);
  1981. // Bookmarks
  1982. ClassDB::bind_method(D_METHOD("set_line_as_bookmarked", "line", "bookmarked"), &CodeEdit::set_line_as_bookmarked);
  1983. ClassDB::bind_method(D_METHOD("is_line_bookmarked", "line"), &CodeEdit::is_line_bookmarked);
  1984. ClassDB::bind_method(D_METHOD("clear_bookmarked_lines"), &CodeEdit::clear_bookmarked_lines);
  1985. ClassDB::bind_method(D_METHOD("get_bookmarked_lines"), &CodeEdit::get_bookmarked_lines);
  1986. // Executing lines
  1987. ClassDB::bind_method(D_METHOD("set_line_as_executing", "line", "executing"), &CodeEdit::set_line_as_executing);
  1988. ClassDB::bind_method(D_METHOD("is_line_executing", "line"), &CodeEdit::is_line_executing);
  1989. ClassDB::bind_method(D_METHOD("clear_executing_lines"), &CodeEdit::clear_executing_lines);
  1990. ClassDB::bind_method(D_METHOD("get_executing_lines"), &CodeEdit::get_executing_lines);
  1991. /* Line numbers */
  1992. ClassDB::bind_method(D_METHOD("set_draw_line_numbers", "enable"), &CodeEdit::set_draw_line_numbers);
  1993. ClassDB::bind_method(D_METHOD("is_draw_line_numbers_enabled"), &CodeEdit::is_draw_line_numbers_enabled);
  1994. ClassDB::bind_method(D_METHOD("set_line_numbers_zero_padded", "enable"), &CodeEdit::set_line_numbers_zero_padded);
  1995. ClassDB::bind_method(D_METHOD("is_line_numbers_zero_padded"), &CodeEdit::is_line_numbers_zero_padded);
  1996. /* Fold Gutter */
  1997. ClassDB::bind_method(D_METHOD("set_draw_fold_gutter", "enable"), &CodeEdit::set_draw_fold_gutter);
  1998. ClassDB::bind_method(D_METHOD("is_drawing_fold_gutter"), &CodeEdit::is_drawing_fold_gutter);
  1999. /* Line folding */
  2000. ClassDB::bind_method(D_METHOD("set_line_folding_enabled", "enabled"), &CodeEdit::set_line_folding_enabled);
  2001. ClassDB::bind_method(D_METHOD("is_line_folding_enabled"), &CodeEdit::is_line_folding_enabled);
  2002. ClassDB::bind_method(D_METHOD("can_fold_line", "line"), &CodeEdit::can_fold_line);
  2003. ClassDB::bind_method(D_METHOD("fold_line", "line"), &CodeEdit::fold_line);
  2004. ClassDB::bind_method(D_METHOD("unfold_line", "line"), &CodeEdit::unfold_line);
  2005. ClassDB::bind_method(D_METHOD("fold_all_lines"), &CodeEdit::fold_all_lines);
  2006. ClassDB::bind_method(D_METHOD("unfold_all_lines"), &CodeEdit::unfold_all_lines);
  2007. ClassDB::bind_method(D_METHOD("toggle_foldable_line", "line"), &CodeEdit::toggle_foldable_line);
  2008. ClassDB::bind_method(D_METHOD("is_line_folded", "line"), &CodeEdit::is_line_folded);
  2009. ClassDB::bind_method(D_METHOD("get_folded_lines"), &CodeEdit::get_folded_lines);
  2010. /* Delimiters */
  2011. // Strings
  2012. ClassDB::bind_method(D_METHOD("add_string_delimiter", "start_key", "end_key", "line_only"), &CodeEdit::add_string_delimiter, DEFVAL(false));
  2013. ClassDB::bind_method(D_METHOD("remove_string_delimiter", "start_key"), &CodeEdit::remove_string_delimiter);
  2014. ClassDB::bind_method(D_METHOD("has_string_delimiter", "start_key"), &CodeEdit::has_string_delimiter);
  2015. ClassDB::bind_method(D_METHOD("set_string_delimiters", "string_delimiters"), &CodeEdit::set_string_delimiters);
  2016. ClassDB::bind_method(D_METHOD("clear_string_delimiters"), &CodeEdit::clear_string_delimiters);
  2017. ClassDB::bind_method(D_METHOD("get_string_delimiters"), &CodeEdit::get_string_delimiters);
  2018. ClassDB::bind_method(D_METHOD("is_in_string", "line", "column"), &CodeEdit::is_in_string, DEFVAL(-1));
  2019. // Comments
  2020. ClassDB::bind_method(D_METHOD("add_comment_delimiter", "start_key", "end_key", "line_only"), &CodeEdit::add_comment_delimiter, DEFVAL(false));
  2021. ClassDB::bind_method(D_METHOD("remove_comment_delimiter", "start_key"), &CodeEdit::remove_comment_delimiter);
  2022. ClassDB::bind_method(D_METHOD("has_comment_delimiter", "start_key"), &CodeEdit::has_comment_delimiter);
  2023. ClassDB::bind_method(D_METHOD("set_comment_delimiters", "comment_delimiters"), &CodeEdit::set_comment_delimiters);
  2024. ClassDB::bind_method(D_METHOD("clear_comment_delimiters"), &CodeEdit::clear_comment_delimiters);
  2025. ClassDB::bind_method(D_METHOD("get_comment_delimiters"), &CodeEdit::get_comment_delimiters);
  2026. ClassDB::bind_method(D_METHOD("is_in_comment", "line", "column"), &CodeEdit::is_in_comment, DEFVAL(-1));
  2027. // Util
  2028. ClassDB::bind_method(D_METHOD("get_delimiter_start_key", "delimiter_index"), &CodeEdit::get_delimiter_start_key);
  2029. ClassDB::bind_method(D_METHOD("get_delimiter_end_key", "delimiter_index"), &CodeEdit::get_delimiter_end_key);
  2030. ClassDB::bind_method(D_METHOD("get_delimiter_start_position", "line", "column"), &CodeEdit::get_delimiter_start_position);
  2031. ClassDB::bind_method(D_METHOD("get_delimiter_end_position", "line", "column"), &CodeEdit::get_delimiter_end_position);
  2032. /* Code hint */
  2033. ClassDB::bind_method(D_METHOD("set_code_hint", "code_hint"), &CodeEdit::set_code_hint);
  2034. ClassDB::bind_method(D_METHOD("set_code_hint_draw_below", "draw_below"), &CodeEdit::set_code_hint_draw_below);
  2035. /* Code Completion */
  2036. BIND_ENUM_CONSTANT(KIND_CLASS);
  2037. BIND_ENUM_CONSTANT(KIND_FUNCTION);
  2038. BIND_ENUM_CONSTANT(KIND_SIGNAL);
  2039. BIND_ENUM_CONSTANT(KIND_VARIABLE);
  2040. BIND_ENUM_CONSTANT(KIND_MEMBER);
  2041. BIND_ENUM_CONSTANT(KIND_ENUM);
  2042. BIND_ENUM_CONSTANT(KIND_CONSTANT);
  2043. BIND_ENUM_CONSTANT(KIND_NODE_PATH);
  2044. BIND_ENUM_CONSTANT(KIND_FILE_PATH);
  2045. BIND_ENUM_CONSTANT(KIND_PLAIN_TEXT);
  2046. BIND_ENUM_CONSTANT(LOCATION_LOCAL);
  2047. BIND_ENUM_CONSTANT(LOCATION_PARENT_MASK);
  2048. BIND_ENUM_CONSTANT(LOCATION_OTHER_USER_CODE)
  2049. BIND_ENUM_CONSTANT(LOCATION_OTHER);
  2050. ClassDB::bind_method(D_METHOD("get_text_for_code_completion"), &CodeEdit::get_text_for_code_completion);
  2051. ClassDB::bind_method(D_METHOD("request_code_completion", "force"), &CodeEdit::request_code_completion, DEFVAL(false));
  2052. ClassDB::bind_method(D_METHOD("add_code_completion_option", "type", "display_text", "insert_text", "text_color", "icon", "value", "location"), &CodeEdit::add_code_completion_option, DEFVAL(Color(1, 1, 1)), DEFVAL(Ref<Resource>()), DEFVAL(Variant::NIL), DEFVAL(LOCATION_OTHER));
  2053. ClassDB::bind_method(D_METHOD("update_code_completion_options", "force"), &CodeEdit::update_code_completion_options);
  2054. ClassDB::bind_method(D_METHOD("get_code_completion_options"), &CodeEdit::get_code_completion_options);
  2055. ClassDB::bind_method(D_METHOD("get_code_completion_option", "index"), &CodeEdit::get_code_completion_option);
  2056. ClassDB::bind_method(D_METHOD("get_code_completion_selected_index"), &CodeEdit::get_code_completion_selected_index);
  2057. ClassDB::bind_method(D_METHOD("set_code_completion_selected_index", "index"), &CodeEdit::set_code_completion_selected_index);
  2058. ClassDB::bind_method(D_METHOD("confirm_code_completion", "replace"), &CodeEdit::confirm_code_completion, DEFVAL(false));
  2059. ClassDB::bind_method(D_METHOD("cancel_code_completion"), &CodeEdit::cancel_code_completion);
  2060. ClassDB::bind_method(D_METHOD("set_code_completion_enabled", "enable"), &CodeEdit::set_code_completion_enabled);
  2061. ClassDB::bind_method(D_METHOD("is_code_completion_enabled"), &CodeEdit::is_code_completion_enabled);
  2062. ClassDB::bind_method(D_METHOD("set_code_completion_prefixes", "prefixes"), &CodeEdit::set_code_completion_prefixes);
  2063. ClassDB::bind_method(D_METHOD("get_code_completion_prefixes"), &CodeEdit::get_code_completion_prefixes);
  2064. // Overridable
  2065. GDVIRTUAL_BIND(_confirm_code_completion, "replace")
  2066. GDVIRTUAL_BIND(_request_code_completion, "force")
  2067. GDVIRTUAL_BIND(_filter_code_completion_candidates, "candidates")
  2068. /* Line length guidelines */
  2069. ClassDB::bind_method(D_METHOD("set_line_length_guidelines", "guideline_columns"), &CodeEdit::set_line_length_guidelines);
  2070. ClassDB::bind_method(D_METHOD("get_line_length_guidelines"), &CodeEdit::get_line_length_guidelines);
  2071. /* Symbol lookup */
  2072. ClassDB::bind_method(D_METHOD("set_symbol_lookup_on_click_enabled", "enable"), &CodeEdit::set_symbol_lookup_on_click_enabled);
  2073. ClassDB::bind_method(D_METHOD("is_symbol_lookup_on_click_enabled"), &CodeEdit::is_symbol_lookup_on_click_enabled);
  2074. ClassDB::bind_method(D_METHOD("get_text_for_symbol_lookup"), &CodeEdit::get_text_for_symbol_lookup);
  2075. ClassDB::bind_method(D_METHOD("set_symbol_lookup_word_as_valid", "valid"), &CodeEdit::set_symbol_lookup_word_as_valid);
  2076. /* Inspector */
  2077. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "symbol_lookup_on_click"), "set_symbol_lookup_on_click_enabled", "is_symbol_lookup_on_click_enabled");
  2078. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "line_folding"), "set_line_folding_enabled", "is_line_folding_enabled");
  2079. ADD_PROPERTY(PropertyInfo(Variant::PACKED_INT32_ARRAY, "line_length_guidelines"), "set_line_length_guidelines", "get_line_length_guidelines");
  2080. ADD_GROUP("Gutters", "gutters_");
  2081. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_breakpoints_gutter"), "set_draw_breakpoints_gutter", "is_drawing_breakpoints_gutter");
  2082. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_bookmarks"), "set_draw_bookmarks_gutter", "is_drawing_bookmarks_gutter");
  2083. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_executing_lines"), "set_draw_executing_lines_gutter", "is_drawing_executing_lines_gutter");
  2084. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_line_numbers"), "set_draw_line_numbers", "is_draw_line_numbers_enabled");
  2085. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_zero_pad_line_numbers"), "set_line_numbers_zero_padded", "is_line_numbers_zero_padded");
  2086. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_fold_gutter"), "set_draw_fold_gutter", "is_drawing_fold_gutter");
  2087. ADD_GROUP("Delimiters", "delimiter_");
  2088. ADD_PROPERTY(PropertyInfo(Variant::PACKED_STRING_ARRAY, "delimiter_strings"), "set_string_delimiters", "get_string_delimiters");
  2089. ADD_PROPERTY(PropertyInfo(Variant::PACKED_STRING_ARRAY, "delimiter_comments"), "set_comment_delimiters", "get_comment_delimiters");
  2090. ADD_GROUP("Code Completion", "code_completion_");
  2091. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "code_completion_enabled"), "set_code_completion_enabled", "is_code_completion_enabled");
  2092. ADD_PROPERTY(PropertyInfo(Variant::PACKED_STRING_ARRAY, "code_completion_prefixes"), "set_code_completion_prefixes", "get_code_completion_prefixes");
  2093. ADD_GROUP("Indentation", "indent_");
  2094. ADD_PROPERTY(PropertyInfo(Variant::INT, "indent_size"), "set_indent_size", "get_indent_size");
  2095. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "indent_use_spaces"), "set_indent_using_spaces", "is_indent_using_spaces");
  2096. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "indent_automatic"), "set_auto_indent_enabled", "is_auto_indent_enabled");
  2097. ADD_PROPERTY(PropertyInfo(Variant::PACKED_STRING_ARRAY, "indent_automatic_prefixes"), "set_auto_indent_prefixes", "get_auto_indent_prefixes");
  2098. ADD_GROUP("Auto Brace Completion", "auto_brace_completion_");
  2099. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_brace_completion_enabled"), "set_auto_brace_completion_enabled", "is_auto_brace_completion_enabled");
  2100. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_brace_completion_highlight_matching"), "set_highlight_matching_braces_enabled", "is_highlight_matching_braces_enabled");
  2101. ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "auto_brace_completion_pairs"), "set_auto_brace_completion_pairs", "get_auto_brace_completion_pairs");
  2102. /* Signals */
  2103. /* Gutters */
  2104. ADD_SIGNAL(MethodInfo("breakpoint_toggled", PropertyInfo(Variant::INT, "line")));
  2105. /* Code Completion */
  2106. ADD_SIGNAL(MethodInfo("code_completion_requested"));
  2107. /* Symbol lookup */
  2108. ADD_SIGNAL(MethodInfo("symbol_lookup", PropertyInfo(Variant::STRING, "symbol"), PropertyInfo(Variant::INT, "line"), PropertyInfo(Variant::INT, "column")));
  2109. ADD_SIGNAL(MethodInfo("symbol_validate", PropertyInfo(Variant::STRING, "symbol")));
  2110. }
  2111. /* Auto brace completion */
  2112. int CodeEdit::_get_auto_brace_pair_open_at_pos(int p_line, int p_col) {
  2113. const String &line = get_line(p_line);
  2114. /* Should be fast enough, expecting low amount of pairs... */
  2115. for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
  2116. const String &open_key = auto_brace_completion_pairs[i].open_key;
  2117. if (p_col - open_key.length() < 0) {
  2118. continue;
  2119. }
  2120. bool is_match = true;
  2121. for (int j = 0; j < open_key.length(); j++) {
  2122. if (line[(p_col - 1) - j] != open_key[(open_key.length() - 1) - j]) {
  2123. is_match = false;
  2124. break;
  2125. }
  2126. }
  2127. if (is_match) {
  2128. return i;
  2129. }
  2130. }
  2131. return -1;
  2132. }
  2133. int CodeEdit::_get_auto_brace_pair_close_at_pos(int p_line, int p_col) {
  2134. const String &line = get_line(p_line);
  2135. /* Should be fast enough, expecting low amount of pairs... */
  2136. for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
  2137. if (p_col + auto_brace_completion_pairs[i].close_key.length() > line.length()) {
  2138. continue;
  2139. }
  2140. bool is_match = true;
  2141. for (int j = 0; j < auto_brace_completion_pairs[i].close_key.length(); j++) {
  2142. if (line[p_col + j] != auto_brace_completion_pairs[i].close_key[j]) {
  2143. is_match = false;
  2144. break;
  2145. }
  2146. }
  2147. if (is_match) {
  2148. return i;
  2149. }
  2150. }
  2151. return -1;
  2152. }
  2153. /* Gutters */
  2154. void CodeEdit::_gutter_clicked(int p_line, int p_gutter) {
  2155. bool shift_pressed = Input::get_singleton()->is_key_pressed(Key::SHIFT);
  2156. if (p_gutter == main_gutter) {
  2157. if (draw_breakpoints && !shift_pressed) {
  2158. set_line_as_breakpoint(p_line, !is_line_breakpointed(p_line));
  2159. } else if (draw_bookmarks && shift_pressed) {
  2160. set_line_as_bookmarked(p_line, !is_line_bookmarked(p_line));
  2161. }
  2162. return;
  2163. }
  2164. if (p_gutter == line_number_gutter) {
  2165. remove_secondary_carets();
  2166. set_selection_mode(TextEdit::SelectionMode::SELECTION_MODE_LINE, p_line, 0);
  2167. select(p_line, 0, p_line + 1, 0);
  2168. set_caret_line(p_line + 1);
  2169. set_caret_column(0);
  2170. return;
  2171. }
  2172. if (p_gutter == fold_gutter) {
  2173. if (is_line_folded(p_line)) {
  2174. unfold_line(p_line);
  2175. } else if (can_fold_line(p_line)) {
  2176. fold_line(p_line);
  2177. }
  2178. return;
  2179. }
  2180. }
  2181. void CodeEdit::_update_gutter_indexes() {
  2182. for (int i = 0; i < get_gutter_count(); i++) {
  2183. if (get_gutter_name(i) == "main_gutter") {
  2184. main_gutter = i;
  2185. continue;
  2186. }
  2187. if (get_gutter_name(i) == "line_numbers") {
  2188. line_number_gutter = i;
  2189. continue;
  2190. }
  2191. if (get_gutter_name(i) == "fold_gutter") {
  2192. fold_gutter = i;
  2193. continue;
  2194. }
  2195. }
  2196. }
  2197. /* Delimiters */
  2198. void CodeEdit::_update_delimiter_cache(int p_from_line, int p_to_line) {
  2199. if (delimiters.size() == 0) {
  2200. return;
  2201. }
  2202. int line_count = get_line_count();
  2203. if (p_to_line == -1) {
  2204. p_to_line = line_count;
  2205. }
  2206. int start_line = MIN(p_from_line, p_to_line);
  2207. int end_line = MAX(p_from_line, p_to_line);
  2208. /* Make sure delimiter_cache has all the lines. */
  2209. if (start_line != end_line) {
  2210. if (p_to_line < p_from_line) {
  2211. for (int i = end_line; i > start_line; i--) {
  2212. delimiter_cache.remove_at(i);
  2213. }
  2214. } else {
  2215. for (int i = start_line; i < end_line; i++) {
  2216. delimiter_cache.insert(i, RBMap<int, int>());
  2217. }
  2218. }
  2219. }
  2220. int in_region = -1;
  2221. for (int i = start_line; i < MIN(end_line + 1, line_count); i++) {
  2222. int current_end_region = (i <= 0 || delimiter_cache[i].size() < 1) ? -1 : delimiter_cache[i].back()->value();
  2223. in_region = (i <= 0 || delimiter_cache[i - 1].size() < 1) ? -1 : delimiter_cache[i - 1].back()->value();
  2224. const String &str = get_line(i);
  2225. const int line_length = str.length();
  2226. delimiter_cache.write[i].clear();
  2227. if (str.length() == 0) {
  2228. if (in_region != -1) {
  2229. delimiter_cache.write[i][0] = in_region;
  2230. }
  2231. if (i == end_line && current_end_region != in_region) {
  2232. end_line++;
  2233. end_line = MIN(end_line, line_count);
  2234. }
  2235. continue;
  2236. }
  2237. int end_region = -1;
  2238. for (int j = 0; j < line_length; j++) {
  2239. int from = j;
  2240. for (; from < line_length; from++) {
  2241. if (str[from] == '\\') {
  2242. from++;
  2243. continue;
  2244. }
  2245. break;
  2246. }
  2247. /* check if we are in entering a region */
  2248. bool same_line = false;
  2249. if (in_region == -1) {
  2250. for (int d = 0; d < delimiters.size(); d++) {
  2251. /* check there is enough room */
  2252. int chars_left = line_length - from;
  2253. int start_key_length = delimiters[d].start_key.length();
  2254. int end_key_length = delimiters[d].end_key.length();
  2255. if (chars_left < start_key_length) {
  2256. continue;
  2257. }
  2258. /* search the line */
  2259. bool match = true;
  2260. const char32_t *start_key = delimiters[d].start_key.get_data();
  2261. for (int k = 0; k < start_key_length; k++) {
  2262. if (start_key[k] != str[from + k]) {
  2263. match = false;
  2264. break;
  2265. }
  2266. }
  2267. if (!match) {
  2268. continue;
  2269. }
  2270. same_line = true;
  2271. in_region = d;
  2272. delimiter_cache.write[i][from + 1] = d;
  2273. from += start_key_length;
  2274. /* check if it's the whole line */
  2275. if (end_key_length == 0 || delimiters[d].line_only || from + end_key_length > line_length) {
  2276. j = line_length;
  2277. if (delimiters[d].line_only) {
  2278. delimiter_cache.write[i][line_length + 1] = -1;
  2279. } else {
  2280. end_region = in_region;
  2281. }
  2282. }
  2283. break;
  2284. }
  2285. if (j == line_length || in_region == -1) {
  2286. continue;
  2287. }
  2288. }
  2289. /* if we are in one find the end key */
  2290. /* search the line */
  2291. int region_end_index = -1;
  2292. int end_key_length = delimiters[in_region].end_key.length();
  2293. const char32_t *end_key = delimiters[in_region].end_key.get_data();
  2294. for (; from < line_length; from++) {
  2295. if (line_length - from < end_key_length) {
  2296. break;
  2297. }
  2298. if (!is_symbol(str[from])) {
  2299. continue;
  2300. }
  2301. if (str[from] == '\\') {
  2302. from++;
  2303. continue;
  2304. }
  2305. region_end_index = from;
  2306. for (int k = 0; k < end_key_length; k++) {
  2307. if (end_key[k] != str[from + k]) {
  2308. region_end_index = -1;
  2309. break;
  2310. }
  2311. }
  2312. if (region_end_index != -1) {
  2313. break;
  2314. }
  2315. }
  2316. j = from + (end_key_length - 1);
  2317. end_region = (region_end_index == -1) ? in_region : -1;
  2318. if (!same_line || region_end_index != -1) {
  2319. delimiter_cache.write[i][j + 1] = end_region;
  2320. }
  2321. in_region = -1;
  2322. }
  2323. if (i == end_line && current_end_region != end_region) {
  2324. end_line++;
  2325. end_line = MIN(end_line, line_count);
  2326. }
  2327. }
  2328. }
  2329. int CodeEdit::_is_in_delimiter(int p_line, int p_column, DelimiterType p_type) const {
  2330. if (delimiters.size() == 0) {
  2331. return -1;
  2332. }
  2333. ERR_FAIL_INDEX_V(p_line, get_line_count(), 0);
  2334. int region = (p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->value();
  2335. bool in_region = region != -1 && delimiters[region].type == p_type;
  2336. for (RBMap<int, int>::Element *E = delimiter_cache[p_line].front(); E; E = E->next()) {
  2337. /* If column is specified, loop until the key is larger then the column. */
  2338. if (p_column != -1) {
  2339. if (E->key() > p_column) {
  2340. break;
  2341. }
  2342. in_region = E->value() != -1 && delimiters[E->value()].type == p_type;
  2343. region = in_region ? E->value() : -1;
  2344. continue;
  2345. }
  2346. /* If no column, calculate if the entire line is a region */
  2347. /* excluding whitespace. */
  2348. const String line = get_line(p_line);
  2349. if (!in_region) {
  2350. if (E->value() == -1 || delimiters[E->value()].type != p_type) {
  2351. break;
  2352. }
  2353. region = E->value();
  2354. in_region = true;
  2355. for (int i = E->key() - 2; i >= 0; i--) {
  2356. if (!is_whitespace(line[i])) {
  2357. return -1;
  2358. }
  2359. }
  2360. }
  2361. if (delimiters[region].line_only) {
  2362. return region;
  2363. }
  2364. int end_col = E->key();
  2365. if (E->value() != -1) {
  2366. if (!E->next()) {
  2367. return region;
  2368. }
  2369. end_col = E->next()->key();
  2370. }
  2371. for (int i = end_col; i < line.length(); i++) {
  2372. if (!is_whitespace(line[i])) {
  2373. return -1;
  2374. }
  2375. }
  2376. return region;
  2377. }
  2378. return in_region ? region : -1;
  2379. }
  2380. void CodeEdit::_add_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only, DelimiterType p_type) {
  2381. // If we are the editor allow "null" as a valid start key, otherwise users cannot add delimiters via the inspector.
  2382. if (!(Engine::get_singleton()->is_editor_hint() && p_start_key == "null")) {
  2383. ERR_FAIL_COND_MSG(p_start_key.is_empty(), "delimiter start key cannot be empty");
  2384. for (int i = 0; i < p_start_key.length(); i++) {
  2385. ERR_FAIL_COND_MSG(!is_symbol(p_start_key[i]), "delimiter must start with a symbol");
  2386. }
  2387. }
  2388. if (p_end_key.length() > 0) {
  2389. for (int i = 0; i < p_end_key.length(); i++) {
  2390. ERR_FAIL_COND_MSG(!is_symbol(p_end_key[i]), "delimiter must end with a symbol");
  2391. }
  2392. }
  2393. int at = 0;
  2394. for (int i = 0; i < delimiters.size(); i++) {
  2395. ERR_FAIL_COND_MSG(delimiters[i].start_key == p_start_key, "delimiter with start key '" + p_start_key + "' already exists.");
  2396. if (p_start_key.length() < delimiters[i].start_key.length()) {
  2397. at++;
  2398. }
  2399. }
  2400. Delimiter delimiter;
  2401. delimiter.type = p_type;
  2402. delimiter.start_key = p_start_key;
  2403. delimiter.end_key = p_end_key;
  2404. delimiter.line_only = p_line_only || p_end_key.is_empty();
  2405. delimiters.insert(at, delimiter);
  2406. if (!setting_delimiters) {
  2407. delimiter_cache.clear();
  2408. _update_delimiter_cache();
  2409. }
  2410. }
  2411. void CodeEdit::_remove_delimiter(const String &p_start_key, DelimiterType p_type) {
  2412. for (int i = 0; i < delimiters.size(); i++) {
  2413. if (delimiters[i].start_key != p_start_key) {
  2414. continue;
  2415. }
  2416. if (delimiters[i].type != p_type) {
  2417. break;
  2418. }
  2419. delimiters.remove_at(i);
  2420. if (!setting_delimiters) {
  2421. delimiter_cache.clear();
  2422. _update_delimiter_cache();
  2423. }
  2424. break;
  2425. }
  2426. }
  2427. bool CodeEdit::_has_delimiter(const String &p_start_key, DelimiterType p_type) const {
  2428. for (int i = 0; i < delimiters.size(); i++) {
  2429. if (delimiters[i].start_key == p_start_key) {
  2430. return delimiters[i].type == p_type;
  2431. }
  2432. }
  2433. return false;
  2434. }
  2435. void CodeEdit::_set_delimiters(const TypedArray<String> &p_delimiters, DelimiterType p_type) {
  2436. setting_delimiters = true;
  2437. _clear_delimiters(p_type);
  2438. for (int i = 0; i < p_delimiters.size(); i++) {
  2439. String key = p_delimiters[i];
  2440. if (key.is_empty()) {
  2441. continue;
  2442. }
  2443. const String start_key = key.get_slice(" ", 0);
  2444. const String end_key = key.get_slice_count(" ") > 1 ? key.get_slice(" ", 1) : String();
  2445. _add_delimiter(start_key, end_key, end_key.is_empty(), p_type);
  2446. }
  2447. setting_delimiters = false;
  2448. _update_delimiter_cache();
  2449. }
  2450. void CodeEdit::_clear_delimiters(DelimiterType p_type) {
  2451. for (int i = delimiters.size() - 1; i >= 0; i--) {
  2452. if (delimiters[i].type == p_type) {
  2453. delimiters.remove_at(i);
  2454. }
  2455. }
  2456. delimiter_cache.clear();
  2457. if (!setting_delimiters) {
  2458. _update_delimiter_cache();
  2459. }
  2460. }
  2461. TypedArray<String> CodeEdit::_get_delimiters(DelimiterType p_type) const {
  2462. TypedArray<String> r_delimiters;
  2463. for (int i = 0; i < delimiters.size(); i++) {
  2464. if (delimiters[i].type != p_type) {
  2465. continue;
  2466. }
  2467. r_delimiters.push_back(delimiters[i].start_key + (delimiters[i].end_key.is_empty() ? "" : " " + delimiters[i].end_key));
  2468. }
  2469. return r_delimiters;
  2470. }
  2471. /* Code Completion */
  2472. void CodeEdit::_update_scroll_selected_line(float p_mouse_y) {
  2473. float percent = (float)(p_mouse_y - code_completion_scroll_rect.position.y) / code_completion_scroll_rect.size.height;
  2474. percent = CLAMP(percent, 0.0f, 1.0f);
  2475. code_completion_current_selected = (int)(percent * (code_completion_options.size() - 1));
  2476. code_completion_force_item_center = -1;
  2477. }
  2478. void CodeEdit::_filter_code_completion_candidates_impl() {
  2479. int line_height = get_line_height();
  2480. if (GDVIRTUAL_IS_OVERRIDDEN(_filter_code_completion_candidates)) {
  2481. code_completion_options.clear();
  2482. code_completion_base = "";
  2483. /* Build options argument. */
  2484. TypedArray<Dictionary> completion_options_sources;
  2485. completion_options_sources.resize(code_completion_option_sources.size());
  2486. int i = 0;
  2487. for (const ScriptLanguage::CodeCompletionOption &E : code_completion_option_sources) {
  2488. Dictionary option;
  2489. option["kind"] = E.kind;
  2490. option["display_text"] = E.display;
  2491. option["insert_text"] = E.insert_text;
  2492. option["font_color"] = E.font_color;
  2493. option["icon"] = E.icon;
  2494. option["default_value"] = E.default_value;
  2495. option["location"] = E.location;
  2496. completion_options_sources[i] = option;
  2497. i++;
  2498. }
  2499. TypedArray<Dictionary> completion_options;
  2500. GDVIRTUAL_CALL(_filter_code_completion_candidates, completion_options_sources, completion_options);
  2501. /* No options to complete, cancel. */
  2502. if (completion_options.size() == 0) {
  2503. cancel_code_completion();
  2504. return;
  2505. }
  2506. /* Convert back into options. */
  2507. int max_width = 0;
  2508. for (i = 0; i < completion_options.size(); i++) {
  2509. ScriptLanguage::CodeCompletionOption option;
  2510. option.kind = (ScriptLanguage::CodeCompletionKind)(int)completion_options[i].get("kind");
  2511. option.display = completion_options[i].get("display_text");
  2512. option.insert_text = completion_options[i].get("insert_text");
  2513. option.font_color = completion_options[i].get("font_color");
  2514. option.icon = completion_options[i].get("icon");
  2515. option.location = completion_options[i].get("location");
  2516. option.default_value = completion_options[i].get("default_value");
  2517. int offset = 0;
  2518. if (option.default_value.get_type() == Variant::COLOR) {
  2519. offset = line_height;
  2520. }
  2521. if (theme_cache.font.is_valid()) {
  2522. max_width = MAX(max_width, theme_cache.font->get_string_size(option.display, HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).width + offset);
  2523. }
  2524. code_completion_options.push_back(option);
  2525. }
  2526. code_completion_longest_line = MIN(max_width, theme_cache.code_completion_max_width * theme_cache.font_size);
  2527. code_completion_current_selected = 0;
  2528. code_completion_force_item_center = -1;
  2529. code_completion_active = true;
  2530. queue_redraw();
  2531. return;
  2532. }
  2533. const int caret_line = get_caret_line();
  2534. const int caret_column = get_caret_column();
  2535. const String line = get_line(caret_line);
  2536. ERR_FAIL_INDEX_MSG(caret_column, line.length() + 1, "Caret column exceeds line length.");
  2537. if (caret_column > 0 && line[caret_column - 1] == '(' && !code_completion_forced) {
  2538. cancel_code_completion();
  2539. return;
  2540. }
  2541. /* Get string status, are we in one or at the close. */
  2542. int in_string = is_in_string(caret_line, caret_column);
  2543. int first_quote_col = -1;
  2544. if (in_string != -1) {
  2545. Point2 string_start_pos = get_delimiter_start_position(caret_line, caret_column);
  2546. first_quote_col = (string_start_pos.y == caret_line) ? string_start_pos.x : -1;
  2547. } else if (caret_column > 0) {
  2548. if (is_in_string(caret_line, caret_column - 1) != -1) {
  2549. first_quote_col = caret_column - 1;
  2550. }
  2551. }
  2552. int cofs = caret_column;
  2553. String string_to_complete;
  2554. bool prev_is_word = false;
  2555. /* Cancel if we are at the close of a string. */
  2556. if (caret_column > 0 && in_string == -1 && first_quote_col == cofs - 1) {
  2557. cancel_code_completion();
  2558. return;
  2559. /* In a string, therefore we are trying to complete the string text. */
  2560. } else if (in_string != -1 && first_quote_col != -1) {
  2561. int key_length = delimiters[in_string].start_key.length();
  2562. string_to_complete = line.substr(first_quote_col - key_length, (cofs - first_quote_col) + key_length);
  2563. /* If we have a space, previous word might be a keyword. eg "func |". */
  2564. } else if (cofs > 0 && line[cofs - 1] == ' ') {
  2565. int ofs = cofs - 1;
  2566. while (ofs > 0 && line[ofs] == ' ') {
  2567. ofs--;
  2568. }
  2569. prev_is_word = !is_symbol(line[ofs]);
  2570. /* Otherwise get current word and set cofs to the start. */
  2571. } else {
  2572. int start_cofs = cofs;
  2573. while (cofs > 0 && line[cofs - 1] > 32 && (line[cofs - 1] == '/' || !is_symbol(line[cofs - 1]))) {
  2574. cofs--;
  2575. }
  2576. string_to_complete = line.substr(cofs, start_cofs - cofs);
  2577. }
  2578. /* If all else fails, check for a prefix. */
  2579. /* Single space between caret and prefix is okay. */
  2580. bool prev_is_prefix = false;
  2581. if (cofs > 0 && code_completion_prefixes.has(line[cofs - 1])) {
  2582. prev_is_prefix = true;
  2583. } else if (cofs > 1 && line[cofs - 1] == ' ' && code_completion_prefixes.has(line[cofs - 2])) {
  2584. prev_is_prefix = true;
  2585. }
  2586. if (!prev_is_word && string_to_complete.is_empty() && (cofs == 0 || !prev_is_prefix)) {
  2587. cancel_code_completion();
  2588. return;
  2589. }
  2590. /* Filter Options. */
  2591. /* For now handle only traditional quoted strings. */
  2592. bool single_quote = in_string != -1 && first_quote_col > 0 && delimiters[in_string].start_key == "'";
  2593. code_completion_options.clear();
  2594. code_completion_base = string_to_complete;
  2595. /* Don't autocomplete setting numerical values. */
  2596. if (code_completion_base.is_numeric()) {
  2597. cancel_code_completion();
  2598. return;
  2599. }
  2600. int max_width = 0;
  2601. String string_to_complete_lower = string_to_complete.to_lower();
  2602. for (ScriptLanguage::CodeCompletionOption &option : code_completion_option_sources) {
  2603. option.matches.clear();
  2604. if (single_quote && option.display.is_quoted()) {
  2605. option.display = option.display.unquote().quote("'");
  2606. }
  2607. int offset = option.default_value.get_type() == Variant::COLOR ? line_height : 0;
  2608. if (in_string != -1) {
  2609. String quote = single_quote ? "'" : "\"";
  2610. option.display = option.display.unquote().quote(quote);
  2611. option.insert_text = option.insert_text.unquote().quote(quote);
  2612. }
  2613. if (option.display.length() == 0) {
  2614. continue;
  2615. }
  2616. if (string_to_complete.length() == 0) {
  2617. option.get_option_characteristics(string_to_complete);
  2618. code_completion_options.push_back(option);
  2619. if (theme_cache.font.is_valid()) {
  2620. max_width = MAX(max_width, theme_cache.font->get_string_size(option.display, HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).width + offset);
  2621. }
  2622. continue;
  2623. }
  2624. String target_lower = option.display.to_lower();
  2625. const char32_t *string_to_complete_char_lower = &string_to_complete_lower[0];
  2626. const char32_t *target_char_lower = &target_lower[0];
  2627. Vector<Vector<Pair<int, int>>> all_possible_subsequence_matches;
  2628. for (int i = 0; *target_char_lower; i++, target_char_lower++) {
  2629. if (*target_char_lower == *string_to_complete_char_lower) {
  2630. all_possible_subsequence_matches.push_back({ { i, 1 } });
  2631. }
  2632. }
  2633. string_to_complete_char_lower++;
  2634. for (int i = 1; *string_to_complete_char_lower && (all_possible_subsequence_matches.size() > 0); i++, string_to_complete_char_lower++) {
  2635. // find all occurrences of ssq_lower to avoid looking everywhere each time
  2636. Vector<int> all_ocurence;
  2637. for (int j = i; j < target_lower.length(); j++) {
  2638. if (target_lower[j] == *string_to_complete_char_lower) {
  2639. all_ocurence.push_back(j);
  2640. }
  2641. }
  2642. Vector<Vector<Pair<int, int>>> next_subsequence_matches;
  2643. for (Vector<Pair<int, int>> &subsequence_matches : all_possible_subsequence_matches) {
  2644. Pair<int, int> match_last_segment = subsequence_matches[subsequence_matches.size() - 1];
  2645. int next_index = match_last_segment.first + match_last_segment.second;
  2646. // get the last index from current sequence
  2647. // and look for next char starting from that index
  2648. if (target_lower[next_index] == *string_to_complete_char_lower) {
  2649. Vector<Pair<int, int>> new_matches = subsequence_matches;
  2650. new_matches.write[new_matches.size() - 1].second++;
  2651. next_subsequence_matches.push_back(new_matches);
  2652. }
  2653. for (int index : all_ocurence) {
  2654. if (index > next_index) {
  2655. Vector<Pair<int, int>> new_matches = subsequence_matches;
  2656. new_matches.push_back({ index, 1 });
  2657. next_subsequence_matches.push_back(new_matches);
  2658. }
  2659. }
  2660. }
  2661. all_possible_subsequence_matches = next_subsequence_matches;
  2662. }
  2663. // go through all possible matches to get the best one as defined by CodeCompletionOptionCompare
  2664. if (all_possible_subsequence_matches.size() > 0) {
  2665. option.matches = all_possible_subsequence_matches[0];
  2666. option.get_option_characteristics(string_to_complete);
  2667. all_possible_subsequence_matches = all_possible_subsequence_matches.slice(1);
  2668. if (all_possible_subsequence_matches.size() > 0) {
  2669. CodeCompletionOptionCompare compare;
  2670. ScriptLanguage::CodeCompletionOption compared_option = option;
  2671. compared_option.clear_characteristics();
  2672. for (Vector<Pair<int, int>> &matches : all_possible_subsequence_matches) {
  2673. compared_option.matches = matches;
  2674. compared_option.get_option_characteristics(string_to_complete);
  2675. if (compare(compared_option, option)) {
  2676. option = compared_option;
  2677. compared_option.clear_characteristics();
  2678. }
  2679. }
  2680. }
  2681. code_completion_options.push_back(option);
  2682. if (theme_cache.font.is_valid()) {
  2683. max_width = MAX(max_width, theme_cache.font->get_string_size(option.display, HORIZONTAL_ALIGNMENT_LEFT, -1, theme_cache.font_size).width + offset);
  2684. }
  2685. }
  2686. }
  2687. /* No options to complete, cancel. */
  2688. if (code_completion_options.size() == 0) {
  2689. cancel_code_completion();
  2690. return;
  2691. }
  2692. /* A perfect match, stop completion. */
  2693. if (code_completion_options.size() == 1 && string_to_complete == code_completion_options[0].display) {
  2694. cancel_code_completion();
  2695. return;
  2696. }
  2697. code_completion_options.sort_custom<CodeCompletionOptionCompare>();
  2698. code_completion_longest_line = MIN(max_width, theme_cache.code_completion_max_width * theme_cache.font_size);
  2699. code_completion_current_selected = 0;
  2700. code_completion_force_item_center = -1;
  2701. code_completion_active = true;
  2702. queue_redraw();
  2703. }
  2704. void CodeEdit::_lines_edited_from(int p_from_line, int p_to_line) {
  2705. _update_delimiter_cache(p_from_line, p_to_line);
  2706. if (p_from_line == p_to_line) {
  2707. return;
  2708. }
  2709. lines_edited_changed += p_to_line - p_from_line;
  2710. lines_edited_from = (lines_edited_from == -1) ? MIN(p_from_line, p_to_line) : MIN(lines_edited_from, MIN(p_from_line, p_to_line));
  2711. lines_edited_to = (lines_edited_to == -1) ? MAX(p_from_line, p_to_line) : MAX(lines_edited_from, MAX(p_from_line, p_to_line));
  2712. }
  2713. void CodeEdit::_text_set() {
  2714. lines_edited_from = 0;
  2715. lines_edited_to = 9999;
  2716. _text_changed();
  2717. }
  2718. void CodeEdit::_text_changed() {
  2719. if (lines_edited_from == -1) {
  2720. return;
  2721. }
  2722. int lc = get_line_count();
  2723. line_number_digits = 1;
  2724. while (lc /= 10) {
  2725. line_number_digits++;
  2726. }
  2727. if (theme_cache.font.is_valid()) {
  2728. set_gutter_width(line_number_gutter, (line_number_digits + 1) * theme_cache.font->get_char_size('0', theme_cache.font_size).width);
  2729. }
  2730. lc = get_line_count();
  2731. List<int> breakpoints;
  2732. for (const KeyValue<int, bool> &E : breakpointed_lines) {
  2733. breakpoints.push_back(E.key);
  2734. }
  2735. for (const int &line : breakpoints) {
  2736. if (line < lines_edited_from || (line < lc && is_line_breakpointed(line))) {
  2737. continue;
  2738. }
  2739. breakpointed_lines.erase(line);
  2740. emit_signal(SNAME("breakpoint_toggled"), line);
  2741. int next_line = line + lines_edited_changed;
  2742. if (next_line > -1 && next_line < lc && is_line_breakpointed(next_line)) {
  2743. emit_signal(SNAME("breakpoint_toggled"), next_line);
  2744. breakpointed_lines[next_line] = true;
  2745. continue;
  2746. }
  2747. }
  2748. lines_edited_from = -1;
  2749. lines_edited_to = -1;
  2750. lines_edited_changed = 0;
  2751. }
  2752. CodeEdit::CodeEdit() {
  2753. /* Indent management */
  2754. auto_indent_prefixes.insert(':');
  2755. auto_indent_prefixes.insert('{');
  2756. auto_indent_prefixes.insert('[');
  2757. auto_indent_prefixes.insert('(');
  2758. /* Auto brace completion */
  2759. add_auto_brace_completion_pair("(", ")");
  2760. add_auto_brace_completion_pair("{", "}");
  2761. add_auto_brace_completion_pair("[", "]");
  2762. add_auto_brace_completion_pair("\"", "\"");
  2763. add_auto_brace_completion_pair("\'", "\'");
  2764. /* Delimiter tracking */
  2765. add_string_delimiter("\"", "\"", false);
  2766. add_string_delimiter("\'", "\'", false);
  2767. /* Text Direction */
  2768. set_layout_direction(LAYOUT_DIRECTION_LTR);
  2769. set_text_direction(TEXT_DIRECTION_LTR);
  2770. /* Gutters */
  2771. int gutter_idx = 0;
  2772. /* Main Gutter */
  2773. add_gutter();
  2774. set_gutter_name(gutter_idx, "main_gutter");
  2775. set_gutter_draw(gutter_idx, false);
  2776. set_gutter_overwritable(gutter_idx, true);
  2777. set_gutter_type(gutter_idx, GUTTER_TYPE_CUSTOM);
  2778. set_gutter_custom_draw(gutter_idx, callable_mp(this, &CodeEdit::_main_gutter_draw_callback));
  2779. gutter_idx++;
  2780. /* Line numbers */
  2781. add_gutter();
  2782. set_gutter_name(gutter_idx, "line_numbers");
  2783. set_gutter_draw(gutter_idx, false);
  2784. set_gutter_type(gutter_idx, GUTTER_TYPE_CUSTOM);
  2785. set_gutter_custom_draw(gutter_idx, callable_mp(this, &CodeEdit::_line_number_draw_callback));
  2786. gutter_idx++;
  2787. /* Fold Gutter */
  2788. add_gutter();
  2789. set_gutter_name(gutter_idx, "fold_gutter");
  2790. set_gutter_draw(gutter_idx, false);
  2791. set_gutter_type(gutter_idx, GUTTER_TYPE_CUSTOM);
  2792. set_gutter_custom_draw(gutter_idx, callable_mp(this, &CodeEdit::_fold_gutter_draw_callback));
  2793. gutter_idx++;
  2794. connect("lines_edited_from", callable_mp(this, &CodeEdit::_lines_edited_from));
  2795. connect("text_set", callable_mp(this, &CodeEdit::_text_set));
  2796. connect("text_changed", callable_mp(this, &CodeEdit::_text_changed));
  2797. connect("gutter_clicked", callable_mp(this, &CodeEdit::_gutter_clicked));
  2798. connect("gutter_added", callable_mp(this, &CodeEdit::_update_gutter_indexes));
  2799. connect("gutter_removed", callable_mp(this, &CodeEdit::_update_gutter_indexes));
  2800. _update_gutter_indexes();
  2801. }
  2802. CodeEdit::~CodeEdit() {
  2803. }
  2804. // Return true if l should come before r
  2805. bool CodeCompletionOptionCompare::operator()(const ScriptLanguage::CodeCompletionOption &l, const ScriptLanguage::CodeCompletionOption &r) const {
  2806. // Check if we are not completing an empty string in this case there is no reason to get matches characteristics.
  2807. TypedArray<int> lcharac = l.get_option_cached_characteristics();
  2808. TypedArray<int> rcharac = r.get_option_cached_characteristics();
  2809. if (lcharac != rcharac) {
  2810. return lcharac < rcharac;
  2811. }
  2812. // to get here they need to have the same size so we can take the size of whichever we want
  2813. for (int i = 0; i < l.matches.size(); ++i) {
  2814. if (l.matches[i].first != r.matches[i].first) {
  2815. return l.matches[i].first < r.matches[i].first;
  2816. }
  2817. if (l.matches[i].second != r.matches[i].second) {
  2818. return l.matches[i].second > r.matches[i].second;
  2819. }
  2820. }
  2821. return l.display < r.display;
  2822. }