*/}}

la_data.c 186 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721
  1. /*
  2. * LaGUI: A graphical application framework.
  3. * Copyright (C) 2022-2023 Wu Yiming
  4. *
  5. * This program is free software: you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation, either version 3 of the License, or
  8. * (at your option) any later version.
  9. *
  10. * This program is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17. */
  18. #include "la_5.h"
  19. extern LA MAIN;
  20. const char* LA_UDF_EXTENSION_STRINGS[]={
  21. "LA_UDF_EXTENSION_FLOAT32",
  22. "LA_UDF_EXTENSION_RAW",
  23. "LA_UDF_EXTENSION_QUICK_SEEK",
  24. "",
  25. };
  26. int la_IsThisProp(laProp *p, char *id){
  27. return (!strcmp(p->Identifier, id));
  28. }
  29. laProp *la_PropLookup(laListHandle *lst, char *ID){
  30. laProp *p = 0, *ip;
  31. if (!lst) return 0;
  32. p = lstFindItem(ID, la_IsThisProp, lst);
  33. if (!p) if (strSame(ID, "identifier")){
  34. for (ip = lst->pFirst; ip; ip = ip->Item.pNext){
  35. if (ip->Tag & LA_AS_IDENTIFIER) return ip;
  36. }
  37. }
  38. return p;
  39. }
  40. laProp *la_PropLookupIdentifierItem(laListHandle *lst){
  41. laProp *p;
  42. if (!lst) return 0;
  43. for (p = lst->pFirst; p; p = p->Item.pNext){
  44. if (p->Tag & LA_AS_IDENTIFIER) return p;
  45. elif (la_IsThisProp(p, "identifier")) return p;
  46. }
  47. return 0;
  48. }
  49. int la_IsThisContainer(laPropContainer *p, char *id){
  50. return (!strcmp(p->Identifier, id));
  51. }
  52. laPropContainer *la_ContainerLookup(char *ID){
  53. laPropContainer* pc= lstFindItem(ID, la_IsThisContainer, &MAIN.PropContainers);
  54. return pc;
  55. }
  56. void la_CopyPropPack(laPropPack* From, laPropPack* To) {
  57. laPropStep* ps,*fps,*LastPs=0;
  58. To->RawThis = From->RawThis;
  59. To->EndInstance = From->EndInstance;
  60. la_FreePropStepCache(To->Go);
  61. To->Go = To->LastPs = 0;
  62. for (fps = From->Go; fps; fps = fps->pNext) {
  63. ps = memAcquireSimple(sizeof(laPropStep));
  64. ps->p = fps->p;
  65. ps->UseInstance = fps->UseInstance;
  66. ps->Type = fps->Type;
  67. if (LastPs)LastPs->pNext = ps;
  68. else {
  69. To->Go = ps;
  70. }
  71. LastPs = ps;
  72. }
  73. if(!LastPs){ To->LastPs = From->LastPs; }
  74. else{ To->LastPs =LastPs; }
  75. }
  76. laListHandle* laGetUserList(void* HyperUserMem, laProp* Which, int* IsLocal){
  77. laListHandle* users;
  78. if(Which && Which->Container){
  79. laPropContainer* pc=Which->Container;
  80. if(pc->OtherAlloc || (!pc->Hyper)){
  81. *IsLocal=1;
  82. return &pc->LocalUsers;
  83. }
  84. }
  85. *IsLocal=0;
  86. return memGetUserList(HyperUserMem);
  87. }
  88. laItemUserLinker *laUseDataBlock(void *HyperUserMem, laProp *Which, unsigned int FrameDistinguish, void *User, laUserRemoveFunc Remover, int ForceRecalc){
  89. laItemUserLinker *iul; laItemUserLinkerLocal *iull; int local;
  90. if (!HyperUserMem) return 0;
  91. laListHandle* users = laGetUserList(HyperUserMem, Which, &local); if(!users) return 0;
  92. for (iul = users->pFirst; iul; iul = iul->Pointer.pNext){
  93. if(local && (iull=iul) && iull->Instance!=HyperUserMem) continue;
  94. if (iul->Which == Which && iul->Pointer.p == User){
  95. iul->FrameDistinguish = FrameDistinguish;
  96. if(ForceRecalc) iul->ForceRecalc = ForceRecalc;
  97. return iul;
  98. }
  99. }
  100. iul = lstAppendPointerSized(users, User, local?sizeof(laItemUserLinkerLocal):sizeof(laItemUserLinker));
  101. iul->Which = Which;
  102. iul->FrameDistinguish = FrameDistinguish;
  103. iul->Remove = Remover;
  104. iul->ForceRecalc = ForceRecalc;
  105. if(local){ iull=iul; iull->Instance=HyperUserMem; }
  106. return iul;
  107. }
  108. void laStopUsingDataBlock(void *HyperUserMem, laProp *prop, laPanel* p){
  109. laItemUserLinker *iul,*next_iul; laItemUserLinkerLocal *iull; int local;
  110. if (!HyperUserMem) return;
  111. laListHandle* users = laGetUserList(HyperUserMem, prop, &local); if(!users) return;
  112. for (iul = users->pFirst; iul; iul = next_iul){
  113. next_iul = iul->Pointer.pNext;
  114. if(local && (iull=iul) && iull->Instance!=HyperUserMem) continue;
  115. if (/*prop == iul->Which &&*/ iul->Pointer.p == p||iul->Additional==p){
  116. lstRemoveItem(users,iul);
  117. memFree(iul);
  118. }
  119. }
  120. }
  121. void laDataBlockNoLongerExists(void *HyperUserMem, laListHandle* UserList){
  122. laItemUserLinker *iul,*next_iul;
  123. for (iul = UserList->pFirst; iul; iul = next_iul){
  124. next_iul = iul->Pointer.pNext;
  125. iul->Remove(HyperUserMem, iul);
  126. lstRemoveItem(UserList,iul);
  127. memFree(iul);
  128. }
  129. }
  130. void la_PrintUserList(void* HyperUserMem){
  131. laItemUserLinker* iul, * next_iul; laItemUserLinkerLocal* iull; int local;
  132. if (!HyperUserMem) return;
  133. laListHandle* users = laGetUserList(HyperUserMem, 0, &local); if (!users) return;
  134. for (iul = users->pFirst; iul; iul = next_iul) {
  135. next_iul = iul->Pointer.pNext;
  136. printf("p %x which %s add %x\n", iul->Pointer.p, iul->Which ? iul->Which->Identifier : "-", iul->Additional);
  137. }
  138. }
  139. //laProp* la_GetGeneralPropFromPath(laProp* General, const char * Path) {
  140. // laProp* p;
  141. // laListHandle* lst = &General->Sub;
  142. // laStringSplitor* ss = strSplitPathByDot(Path);
  143. // laStringPart* sp = ss->parts.pFirst;
  144. //
  145. // while (sp) {
  146. // p = la_PropLookup(lst, sp->Content);
  147. // lst = &p->Sub;
  148. // sp = sp->Item.pNext;
  149. // }
  150. //
  151. // strDestroyStringSplitor(&ss);
  152. // return p;
  153. //}
  154. //laProp* la_GetPropFromPath(laPropPack* Base,const char * Path) {
  155. // laProp* p,*LastP=Base?Base->P:0;
  156. // laListHandle* lst;
  157. // laStringSplitor* ss = strSplitPathByDot(Path);
  158. // laStringPart* sp = ss->parts.pFirst;
  159. //
  160. // if(!Base || !Base->P)
  161. // lst = &MAIN.DataRoot.Root->Sub;
  162. // else lst = &Base->P->Sub;
  163. //
  164. //
  165. // while (sp) {
  166. // p = la_PropLookup(lst, sp->Content);
  167. // if (!p && LastP) {
  168. // p = la_PropLookup(&la_GetGeneralProp(LastP)->Sub, sp->Content);
  169. // }
  170. // LastP = p;
  171. // lst = &p->Sub;
  172. // sp = sp->Item.pNext;
  173. // }
  174. //
  175. // strDestroyStringSplitor(&ss);
  176. //
  177. // return p;
  178. //}
  179. void la_NewPropStep(laPropPack *Self, laProp *P, void *UseInstance, char Type){
  180. laPropStep *ps = memAcquireSimple(sizeof(laPropStep));
  181. if (Type == U'.' || Type == U'$'){
  182. ps->p = P;
  183. ps->UseInstance = UseInstance;
  184. ps->Type = Type;
  185. }elif (Type == U'@' || Type == U'=' || Type == U'#'){
  186. ps->p = CreateNewBuffer(char, strlen(P) + 1);
  187. strcpy(ps->p, P);
  188. ps->UseInstance = UseInstance;
  189. ps->Type = Type;
  190. }
  191. if (!Self->Go){
  192. Self->Go = ps;
  193. Self->LastPs = ps;
  194. }else{
  195. Self->LastPs->pNext = ps;
  196. Self->LastPs = ps;
  197. }
  198. }
  199. void la_FreePropStepCache(laPropStep *GoTarget){
  200. if (!GoTarget) return;
  201. if (GoTarget->pNext){
  202. la_FreePropStepCache(GoTarget->pNext);
  203. }
  204. if (GoTarget->Type == U'@' || GoTarget->Type == U'=' || GoTarget->Type == U'#') FreeMem(GoTarget->p);
  205. memFree(GoTarget);
  206. }
  207. void *la_FindMatchingInstance(void *From, laProp *Sub, laProp *p, laPropStep *Value){
  208. laPropPack Fake;
  209. laPropStep FakePs;
  210. laPropIterator pi = {0};
  211. void *Inst;
  212. char _buf[LA_RAW_CSTR_MAX_LEN]={0}; char*buf=_buf;
  213. int val;
  214. Fake.LastPs = &FakePs;
  215. FakePs.p = p;
  216. Inst = laGetInstance(Sub, From, &pi);
  217. if (p->PropertyType == LA_PROP_STRING){
  218. _buf[0] = 0;
  219. FakePs.UseInstance = Inst;
  220. laGetString(&Fake, _buf, &buf);
  221. while (!strSame(buf, Value->p)){
  222. Inst = laGetNextInstance(Sub, Inst, &pi);
  223. if (!Inst) return 0;
  224. _buf[0] = 0;
  225. FakePs.UseInstance = Inst;
  226. laGetString(&Fake, _buf, &buf);
  227. }
  228. return Inst;
  229. }elif (p->PropertyType == LA_PROP_INT){
  230. FakePs.UseInstance = Inst;
  231. val = laGetInt(&Fake); char buf[64]; int compareval=0;
  232. int status=sscanf(buf,"%d",&compareval);
  233. while (status && status!=EOF && val != compareval){
  234. Inst = laGetNextInstance(Sub, From, &pi);
  235. if (!Inst) return 0;
  236. FakePs.UseInstance = Inst;
  237. val = laGetInt(&Fake);
  238. }
  239. return Inst;
  240. }
  241. }
  242. int la_GetPropFromPath(laPropPack *Self, laPropPack *Base, const char *Path, void **SpecifiedInstance){
  243. laProp *p = 0;
  244. laListHandle *lst=0, *lstB = 0;
  245. laStringSplitor *ss = strSplitPath(Path,0);
  246. laStringPart *sp = ss ? ss->parts.pFirst : 0;
  247. int InstanceNum = 0;
  248. if ((!ss && !Base) || !MAIN.DataRoot.Root){ strDestroyStringSplitor(&ss); return 0; }
  249. if (!Base || !Base->LastPs){
  250. lst = &MAIN.DataRoot.Root->Props;
  251. Self->RawThis = 0;
  252. }else{
  253. Self->RawThis = Base;
  254. if (Base->LastPs->p->PropertyType==LA_PROP_SUB && ((laSubProp*)Base->LastPs->p)->GetType && Base->EndInstance){
  255. laPropContainer* pc=((laSubProp*)Base->LastPs->p)->GetType(Base->EndInstance);
  256. lst = &pc->Props;
  257. lstB = pc ? &pc->Props : 0;
  258. }
  259. if(!lst){
  260. if (!Base->LastPs->p->SubProp){
  261. laProp *p = Base->LastPs->p;
  262. p->SubProp = la_ContainerLookup(((laSubProp *)p)->TargetID);
  263. }
  264. if(Base->LastPs->p->SubProp) lst = &Base->LastPs->p->SubProp->Props;
  265. }
  266. lstB = Base->LastPs->p->SubExtra ? &Base->LastPs->p->SubExtra->Props : 0;
  267. if (!Path || !Path[0] || !ss){
  268. if (Base){
  269. Self->LastPs = Base->LastPs;
  270. //Self->ReusedPs = 1;
  271. //la_NewPropStep(Self, Base->LastPs->p,Base->LastPs->UseInstance,Base->LastPs->Type);
  272. }
  273. }
  274. }
  275. while (sp){
  276. if (sp->Type == U'.' || sp->Type == U'$'){
  277. void *inst = 0;
  278. p = la_PropLookup(lst, sp->Content);
  279. if (!p) p = la_PropLookup(lstB, sp->Content);
  280. if (!p){
  281. la_FreePropStepCache(Self->Go);
  282. Self->Go = Self->LastPs = 0;
  283. strDestroyStringSplitor(&ss);
  284. return 0; // |-----------------Here Should Include Dollar Instance
  285. } // V
  286. if (sp->Type == U'$'){
  287. inst = SpecifiedInstance[InstanceNum];
  288. InstanceNum++;
  289. }else
  290. inst = 0;
  291. /*if(Base == &MAIN.PropMatcherContextP->PropLinkPP)la_NewPropStep(Self, p, inst, '*');
  292. else */
  293. la_NewPropStep(Self, p, inst, sp->Type);
  294. if (p->PropertyType == LA_PROP_SUB && !p->SubProp){
  295. p->SubProp = la_ContainerLookup(((laSubProp *)p)->TargetID);
  296. }
  297. lst = p->SubProp ? &p->SubProp->Props : 0;
  298. lstB = p->SubExtra ? &p->SubExtra->Props : 0;
  299. }else{
  300. if (sp->Type == U'@' || sp->Type == U'=' || sp->Type == U'#'){ // || sp->Type== U'~'
  301. la_NewPropStep(Self, sp->Content, 0, sp->Type);
  302. }
  303. }
  304. sp = sp->Item.pNext;
  305. }
  306. strDestroyStringSplitor(&ss);
  307. return 1;
  308. }
  309. void la_StepPropPack(laPropPack *pp){
  310. laPropStep *ps = pp->Go;
  311. laPropPack *This = pp->RawThis;
  312. laPropIterator pi;
  313. laProp *Lookup;
  314. laPropStep *Value;
  315. void *UseInstance = 0;
  316. if (This){
  317. UseInstance = This->EndInstance;
  318. if (ps) ps->UseInstance = UseInstance;
  319. }else{
  320. if (!ps) return;
  321. UseInstance = MAIN.DataRoot.RootInstance;
  322. ps->UseInstance = UseInstance;
  323. }
  324. if (This && !ps){
  325. pp->EndInstance = UseInstance;
  326. pp->LastPs = This->LastPs;
  327. return;
  328. }
  329. while (ps){
  330. // Looks like we have these kind of access grammar:
  331. // sub.prop
  332. // sub@prop=str_or_int
  333. // sub#identifier
  334. // TODO: Add sub~index grammar
  335. if (ps->p->PropertyType == LA_PROP_SUB){
  336. if (ps->Type == U'@' || ps->Type == U'#'){
  337. }
  338. if (ps->Type == U'$') UseInstance = ps->UseInstance;
  339. elif (ps->pNext && ps->pNext->Type != U'.'){
  340. if (ps->pNext->Type == U'@'){
  341. Value = ps->pNext->pNext;
  342. Lookup = la_PropLookup(&ps->p->SubProp->Props, ps->pNext->p);
  343. }elif (ps->pNext->Type == U'#'){
  344. Value = ps->pNext;
  345. Lookup = la_PropLookupIdentifierItem(&ps->p->SubProp->Props);
  346. }
  347. if (Value->Type == U'=' || Value->Type == U'#'){ //MUST!
  348. UseInstance = la_FindMatchingInstance(ps->UseInstance, ps->p, Lookup, Value);
  349. }
  350. Value->UseInstance = UseInstance;
  351. if(Value->pNext) Value->pNext->UseInstance = UseInstance;
  352. ps = Value->pNext;
  353. continue;
  354. }else{
  355. void *inst;
  356. if(((laSubProp*)ps->p)->IsDetached){ UseInstance = ((laSubProp*)ps->p)->Detached; }
  357. else{
  358. inst = laGetActiveInstanceStrict(ps->p, UseInstance);
  359. if (!inst) inst = laGetInstance(ps->p, UseInstance, 0);
  360. UseInstance = inst;
  361. }
  362. }
  363. if (!ps->pNext){
  364. pp->EndInstance = UseInstance;
  365. break;
  366. }else{
  367. ps->pNext->UseInstance = UseInstance;
  368. ps = ps->pNext;
  369. }
  370. continue;
  371. }else{
  372. ps->UseInstance = UseInstance;
  373. if (!ps->pNext){
  374. pp->EndInstance = UseInstance;
  375. break;
  376. }else{
  377. ps->pNext->UseInstance = ps;
  378. UseInstance = ps;
  379. ps = ps->pNext;
  380. }
  381. }
  382. }
  383. }
  384. void la_RemovePropUserNode(laPropStep *ps){
  385. laPropUserPanel *pup = 0;
  386. laPropUser *pu = 0;
  387. for (pup = ps->p->UserPanels.pFirst; pup; pup = pup->Item.pNext){
  388. if (pup->Panel == MAIN.PropMatcherContextP) break;
  389. }
  390. if (!pup) return;
  391. for (pu = pup->UserPacks.pFirst; pu; pu = pu->Item.pNext){
  392. if (pu->User == ps) break;
  393. }
  394. //if (!pu)printf("PROP USER NODE NOT FOUND!\laPropUserPanel:%d,%s,Ps:%s\n",pup->Panel,pup->Panel->Title->Ptr,ps->p->Identifier);
  395. //else {
  396. if (pu){
  397. lstRemoveItem(&pup->UserPacks, pu);
  398. memFree(pu);
  399. if (!pup->UserPacks.pFirst){
  400. lstRemoveItem(&ps->p->UserPanels, pup);
  401. memFree(pup);
  402. }
  403. }
  404. //}
  405. }
  406. void la_AddPropUserNode(laPropStep *ps){
  407. laPropUserPanel *pup = 0;
  408. laPropUser *pu = 0;
  409. for (pup = ps->p->UserPanels.pFirst; pup; pup = pup->Item.pNext){
  410. if (pup->Panel == MAIN.PropMatcherContextP) break;
  411. }
  412. if (!pup){
  413. pup = memAcquireSimple(sizeof(laPropUserPanel));
  414. pup->Panel = MAIN.PropMatcherContextP;
  415. lstAppendItem(&ps->p->UserPanels, pup);
  416. }
  417. for (pu = pup->UserPacks.pFirst; pu; pu = pu->Item.pNext){
  418. if (pu->User == ps){
  419. pu->FrameDistinguish = MAIN.PropMatcherContextP->FrameDistinguish;
  420. return;
  421. }
  422. }
  423. //ELSE
  424. pu = memAcquireSimple(sizeof(laPropUser));
  425. pu->User = ps;
  426. pu->FrameDistinguish = MAIN.PropMatcherContextP->FrameDistinguish;
  427. lstAppendItem(&pup->UserPacks, pu);
  428. }
  429. void la_UsePropPack(laPropPack *pp, int ForceRecalc){
  430. laPropStep *ps = 0;
  431. //if(pp->LastPs && pp->LastPs->p)printf("%s\n",pp->LastPs->p->Identifier);
  432. if((!pp->Go) && pp->LastPs){
  433. if (pp->LastPs->Type==U'.'){
  434. laUseDataBlock(pp->RawThis->LastPs->UseInstance, pp->LastPs->p, MAIN.PropMatcherContextP->FrameDistinguish, MAIN.PropMatcherContextP, la_PropPanelUserRemover, ForceRecalc);
  435. }
  436. }
  437. for (ps = pp->Go; ps; ps = ps->pNext){
  438. if (ps->Type==U'.'){
  439. laUseDataBlock(ps->UseInstance, ps->p, MAIN.PropMatcherContextP->FrameDistinguish, MAIN.PropMatcherContextP, la_PropPanelUserRemover, ForceRecalc);
  440. }
  441. }
  442. }
  443. void la_StopUsingPropPack(laPropPack *pp){
  444. laPropStep *ps;
  445. if((!pp->Go) && pp->LastPs){
  446. if (pp->LastPs->Type==U'.'&&pp->LastPs->p->Container &&pp->LastPs->p->Container->Hyper){
  447. laStopUsingDataBlock(pp->RawThis->LastPs->UseInstance, pp->LastPs->p, MAIN.PropMatcherContextP);
  448. }
  449. }
  450. for (ps = pp->Go; ps; ps = ps->pNext){
  451. if (ps->Type==U'.'&&ps->p->Container&&ps->p->Container->Hyper){
  452. laStopUsingDataBlock(ps->UseInstance, ps->p, MAIN.PropMatcherContextP);
  453. }
  454. //la_RemovePropUserNode(ps);
  455. }
  456. }
  457. void laNotifyUsersPP(laPropPack *pp){
  458. if(!pp->LastPs) return;
  459. void *hi = pp->LastPs->UseInstance;
  460. laItemUserLinker *iul; laItemUserLinkerLocal *iull; int local;
  461. if (!hi) return;
  462. laListHandle* users = laGetUserList(hi, pp->LastPs->p, &local); if(!users) return;
  463. for (iul = users->pFirst; iul; iul = iul->Pointer.pNext){
  464. if(local && (iull=iul) && iull->Instance!=hi) continue;
  465. if (iul->Remove == la_PropPanelUserRemover){
  466. laPanel *p = iul->Pointer.p;
  467. if (iul->Which == pp->LastPs->p && iul->FrameDistinguish == p->FrameDistinguish){
  468. //laSpinLock(&MAIN.csNotifier);
  469. if ((iul->Which->PropertyType & LA_PROP_SUB) || iul->ForceRecalc) laRecalcPanel(p);
  470. else laRedrawPanel(p);
  471. //laSpinUnlock(&MAIN.csNotifier);
  472. }
  473. }
  474. }
  475. }
  476. void laNotifyUsersPPPath(laPropPack *pp, char *path){
  477. laPropPack PP = {0};
  478. if(!path){ laNotifyUsersPP(pp); return; }
  479. la_GetPropFromPath(&PP, pp, path, 0);
  480. la_StepPropPack(&PP);
  481. laNotifyUsersPP(&PP);
  482. la_FreePropStepCache(PP.Go);
  483. }
  484. void laNotifySubPropUsers(laProp *prop, void *Instance){
  485. void *hi = Instance;
  486. laItemUserLinker *iul; laItemUserLinkerLocal *iull; int local;
  487. if (!hi) return;
  488. laListHandle* users = laGetUserList(hi, prop, &local); if(!users) return;
  489. for (iul = users->pFirst; iul; iul = iul->Pointer.pNext){
  490. if(local && (iull=iul) && iull->Instance!=hi) continue;
  491. if (iul->Remove == la_PropPanelUserRemover){
  492. laPanel *p = iul->Pointer.p;
  493. if (iul->Which == prop && iul->FrameDistinguish == p->FrameDistinguish){
  494. //laSpinLock(&MAIN.csNotifier);
  495. laRecalcPanel(p);
  496. //laSpinUnlock(&MAIN.csNotifier);
  497. }
  498. }
  499. }
  500. }
  501. void laNotifyInstanceUsers(void *Instance){
  502. void *hi = Instance;
  503. laItemUserLinker *iul; laItemUserLinkerLocal *iull; int local; if (!hi) return;
  504. laListHandle* users = laGetUserList(hi, 0, &local); if(!users) return;
  505. for (iul = users->pFirst; iul; iul = iul->Pointer.pNext){
  506. if(local && (iull=iul) && iull->Instance!=hi) continue;
  507. if (iul->Remove == la_PropPanelUserRemover){
  508. laPanel *p = iul->Pointer.p;
  509. if (iul->FrameDistinguish == p->FrameDistinguish){
  510. laRedrawPanel(p);
  511. if(iul->Which&&iul->Which->PropertyType==LA_PROP_SUB){ laRecalcPanel(p); }
  512. }
  513. }
  514. }
  515. }
  516. void laNotifyUsers(char *Path){
  517. laPropPack PP = {0};
  518. la_GetPropFromPath(&PP, 0, Path, 0);
  519. la_StepPropPack(&PP);
  520. laNotifyUsersPP(&PP);
  521. la_FreePropStepCache(PP.Go);
  522. }
  523. void laThreadNotifyUsers(char *Path){
  524. laThreadNotifier *tn = CreateNew(laThreadNotifier);
  525. strCopyFull(tn->Path, Path);
  526. //laSpinLock(&MAIN.csNotifier);
  527. lstAppendItem(&MAIN.ThreadNotifiers, tn);
  528. //laSpinUnlock(&MAIN.csNotifier);
  529. }
  530. void la_PanelResetDetachedReference(laPanel*p,void*Old,void*New){
  531. for(laSubProp* sp=p->PropLinkContainer->Props.pFirst;sp;sp=sp->Base.Item.pNext){
  532. if(sp->Base.PropertyType!=LA_PROP_SUB) continue;
  533. if(sp->Detached == Old){ memAssignRef(sp, &sp->Detached, New); }
  534. }
  535. for(laPanel* sp=p->SubPanels.pFirst;sp;sp=sp->Item.pNext){
  536. la_PanelResetDetachedReference(sp,Old,New);
  537. }
  538. }
  539. void la_NotifyDetachedRecursive(laBlock* b, void* Old, void* New){
  540. if(b->B1){ la_NotifyDetachedRecursive(b->B1,Old,New);la_NotifyDetachedRecursive(b->B2,Old,New); return; }
  541. for(laPanel* p=b->Panels.pFirst;p;p=p->Item.pNext){
  542. la_PanelResetDetachedReference(p,Old,New);
  543. }
  544. }
  545. void laNotifyDetached(void* OldInstance, void* NewInstance){
  546. for(laWindow* w=MAIN.Windows.pFirst;w;w=w->Item.pNext){
  547. for(laLayout* l=w->Layouts.pFirst;l;l=l->Item.pNext){
  548. la_NotifyDetachedRecursive(l->FirstBlock,OldInstance,NewInstance);
  549. }
  550. for(laPanel* p=w->Panels.pFirst;p;p=p->Item.pNext){
  551. la_PanelResetDetachedReference(p,OldInstance,NewInstance);
  552. }
  553. }
  554. }
  555. void laDetachedTrySet(char* prop_identifier,void* NewInstance){
  556. laPanel* p=MAIN.CurrentPanel; for(laSubProp* sp=p->PropLinkContainer->Props.pFirst;sp;sp=sp->Base.Item.pNext){
  557. if(sp->Base.PropertyType!=LA_PROP_SUB){ continue; }
  558. if(strSame(sp->Base.Identifier,prop_identifier)){ memAssignRef(sp,&sp->Detached,NewInstance); }
  559. }
  560. }
  561. void la_SetPropMathcerContext(laPanel *p){
  562. MAIN.PropMatcherContextP = p;
  563. }
  564. int laget_InstanceHyperLevel(void* instance){
  565. int level; memGetHead(instance,&level);
  566. return level;
  567. }
  568. int laget_InstanceModified(void* instance){
  569. int level; laMemNodeHyper* m=memGetHead(instance,&level);
  570. if(level==2) return m->Modified?1:0;
  571. return 0;
  572. }
  573. void* laget_InstanceUDF(void* unused, laPropIterator* unusedpi){
  574. return MAIN.ManagedUDFs.pFirst;
  575. }
  576. void* laget_InstanceActiveUDF(void* instance){
  577. int level; laMemNodeHyper* m=memGetHead(instance,&level);
  578. if(level==2) return m->FromFile;
  579. return 0;
  580. }
  581. void* laget_DummyManagedUDFSingle(void* unused){
  582. return MAIN.DummyManageUDFSingle;
  583. }
  584. void* laget_DummyManagedUDFSingleForce(void* unused){
  585. return MAIN.DummyManageUDFSingleForce;
  586. }
  587. void laset_InstanceUDFFromSingle(void* instance, laUDF* udf){
  588. if(!MAIN._CONTAINER_SETTING || !MAIN._CONTAINER_SETTING->UDFPropagate || !instance){ return; }
  589. if(udf == MAIN.DummyManageUDF){
  590. laInvoke(0, "LA_managed_save_new_file", 0,0,0,0);
  591. }
  592. MAIN._CONTAINER_SETTING->UDFPropagate(instance,udf,0);
  593. }
  594. void laset_InstanceUDFFromSingleForce(void* instance, laUDF* udf){
  595. if(!MAIN._CONTAINER_SETTING || !MAIN._CONTAINER_SETTING->UDFPropagate || !instance){ return; }
  596. if(udf == MAIN.DummyManageUDF){
  597. laInvoke(0, "LA_managed_save_new_file", 0,0,0,0);
  598. }
  599. MAIN._CONTAINER_SETTING->UDFPropagate(instance,udf,0);
  600. }
  601. void laset_InstanceUDF(void* instance, void* set){
  602. int level; laMemNodeHyper* m=memGetHead(instance,&level);
  603. if(level==2) memAssignRef(instance, &m->FromFile, set);
  604. if(set == MAIN.DummyManageUDF){
  605. laInvoke(0, "LA_managed_save_new_file", 0,0,0,0);
  606. }
  607. }
  608. void* laget_InstanceSelf(void* instace){
  609. return instace;
  610. }
  611. const char* LA_N_A="N/A";
  612. void *la_GetReadDBInstNUID(char *ReferReadNUID);
  613. void laget_InstanceUID(void* instance, char* buf, char** ptr){
  614. int level; laMemNodeHyper* m=memGetHead(instance,&level);
  615. if(level!=2||!m) return; *ptr=LA_N_A;
  616. *ptr=m->NUID.String;
  617. }
  618. void laset_InstanceUID(void* instance, char* buf){
  619. int level; laMemNodeHyper* m=memGetHead(instance,&level);
  620. if(level!=2||!m) return;
  621. char _buf[40];
  622. if(!buf[0]){ memCreateNUID(_buf,m); buf=_buf; }
  623. laListHandle *l = hsh65536DoHashNUID(&MAIN.DBInst2, m->NUID.String);
  624. laMemNodeHyper* im=0;
  625. for (im = l->pFirst; im; im = m->Item.pNext){ if(im==m) break; }
  626. if(im){ lstRemoveItem(l,im); laListHandle *nl = hsh65536DoHashNUID(&MAIN.DBInst2, buf); lstAppendItem(nl,im); }else{ im=m; /* Unlikely */ }
  627. sprintf(m->NUID.String,"%.30s",buf);
  628. }
  629. void* laget_SaverDummy(void* instance, laPropIterator* pi){
  630. laSubProp* p=MAIN._PROP_SETTING; laListHandle* l = (((char*)instance)+p->ListHandleOffset);
  631. if(!l->pFirst){
  632. laSaverDummy* sd=memAcquireHyper(sizeof(laSaverDummy)); lstAppendItem(l,sd);
  633. }
  634. while(l->pFirst!=l->pLast){ memLeave(lstPopItem(l)); }
  635. return l->pFirst;
  636. }
  637. laSaverDummy* laGetSaverDummy(void* instance, laSubProp* p){
  638. laListHandle* l = (((char*)instance)+p->ListHandleOffset);
  639. if(!l->pFirst){ laSaverDummy* sd=memAcquireHyper(sizeof(laSaverDummy)); lstAppendItem(l,sd); }
  640. while(l->pFirst!=l->pLast){ memLeave(lstPopItem(l)); }
  641. return l->pFirst;
  642. }
  643. void laPurgeSaverDummy(void* instance, laSubProp* p){
  644. laListHandle* l = (((char*)instance)+p->ListHandleOffset);
  645. while(l->pFirst){ memLeave(lstPopItem(l)); }
  646. }
  647. void la_FreeProperty(laProp* p){
  648. laIntProp *ip;laFloatProp *fp;laEnumProp *ep;laSubProp *sp;
  649. if(p->DetachedPP.Go){
  650. la_FreePropStepCache(p->DetachedPP.Go);
  651. switch (p->PropertyType){
  652. case LA_PROP_INT:
  653. case LA_PROP_INT | LA_PROP_ARRAY:
  654. ip = p; free(ip->Detached);
  655. break;
  656. case LA_PROP_FLOAT:
  657. case LA_PROP_FLOAT | LA_PROP_ARRAY:
  658. fp = p; free(fp->Detached);
  659. break;
  660. case LA_PROP_ENUM:
  661. case LA_PROP_ENUM | LA_PROP_ARRAY:
  662. ep = p; free(ep->Detached);
  663. }
  664. }
  665. if(p->PropertyType&LA_PROP_ENUM){ ep = p; laEnumItem* ei; while(ei=lstPopItem(&ep->Items)){ memFree(ei); } }
  666. memFree(p);
  667. }
  668. void la_FreePropertyContainer(laPropContainer* pc){
  669. laProp* p;
  670. while(p=lstPopItem(&pc->Props)){
  671. la_FreeProperty(p);
  672. }
  673. memFree(pc);
  674. }
  675. laPropContainer *laAddPropertyContainer(const char *Identifier, const char *Name, const char *Description, uint32_t IconID,
  676. laUiDefineFunc DefaultUiDefine,
  677. int NodeSize, laContainerPostReadFunc PostRead, laContainerPostReadFunc PostReadIm, int IsHyper){
  678. laPropContainer *pc = memAcquire(sizeof(laPropContainer));
  679. pc->Identifier = Identifier;
  680. pc->Name = Name;
  681. pc->Description = Description;
  682. pc->UiDefine = DefaultUiDefine;
  683. pc->IconID = IconID ? IconID : U'📦';
  684. pc->OtherAlloc = (IsHyper&LA_PROP_OTHER_ALLOC)?1:0;
  685. pc->Hyper = pc->OtherAlloc?0:(IsHyper&LA_PROP_HYPER_BITS);
  686. pc->PostRead = PostRead;
  687. pc->PostReadIm = PostReadIm;
  688. pc->NodeSize = NodeSize;
  689. if (!pc->OtherAlloc){
  690. laAddSubGroup(pc, "__file", "File", "The file this block came from/saves to", "managed_udf",
  691. 0,LA_WIDGET_COLLECTION_SELECTOR,laui_ManagedUDFItem,-1,laget_InstanceUDF,laget_InstanceActiveUDF,laget_ListNext,laset_InstanceUDF,0,0,0,LA_UDF_REFER|LA_UDF_IGNORE);
  692. laAddIntProperty(pc, "__hyper", "Hyper", "Hyper level of this data block", 0,0,0,0,0,0,0,0,-1,laget_InstanceHyperLevel,0,0,0,0,0,0,0,0,0,LA_READ_ONLY|LA_UDF_IGNORE);
  693. laProp* p=laAddEnumProperty(pc, "__modified", "Modified", "Data block is modified", LA_WIDGET_ENUM_ICON_PLAIN,0,0,0,0,-1,laget_InstanceModified,0,0,0,0,0,0,0,0,LA_READ_ONLY|LA_UDF_IGNORE);
  694. laAddEnumItemAs(p, "MODIFIED", "Modified", "Data block is modified", 1, U'🌑');
  695. laAddEnumItemAs(p, "CLEAN", "Clean", "Data block is clean", 0, 0);
  696. laAddStringProperty(pc, "__uid","UID","UID for shared resoure lookup",0,0,0,0,0,-1,0,laget_InstanceUID,laset_InstanceUID,0,LA_UDF_IGNORE);
  697. }
  698. laAddSubGroup(pc, "__self", "Self", "Own instance", Identifier,0,0,0,-1,0,laget_InstanceSelf,0,0,0,0,0,LA_UDF_REFER|LA_UDF_IGNORE);
  699. lstAppendItem(&MAIN.PropContainers, pc);
  700. return pc;
  701. }
  702. void laPropContainerExtraFunctions(laPropContainer* pc, laContainerBeforeFreeF BeforeFree, laContainerResetF Reset, laContainerUndoTouchedF Touched, laContainerpUDFPropagateF UDFPropagate, laUiDefineFunc MenuUi){
  703. pc->BeforeFree=BeforeFree; pc->Reset=Reset; pc->UndoTouched=Touched; pc->UDFPropagate=UDFPropagate; pc->MenuUiDefine=MenuUi;
  704. if(!pc->OtherAlloc && UDFPropagate){
  705. laAddOperatorProperty(pc,"__udf_propagate","Propagate","Propagate UDF to all child nodes", "LA_udf_propagate", 0,0);
  706. laAddSubGroup(pc,"__single_udf_propagate","Save to","Assign file to all child nodes (From a ingle-instanced parent)","managed_udf",
  707. 0,LA_WIDGET_COLLECTION_SELECTOR,laui_ManagedUDFItem,-1,laget_InstanceUDF,laget_DummyManagedUDFSingle,laget_ListNext,laset_InstanceUDFFromSingle,0,0,0,LA_UDF_REFER|LA_UDF_IGNORE);
  708. //laAddSubGroup(pc,"__single_udf_propagate_force","Force","Assign file to all child nodes (From a ingle-instanced parent)","managed_udf",
  709. // 0,LA_WIDGET_COLLECTION_SELECTOR,laui_ManagedUDFItem,-1,laget_InstanceUDF,laget_DummyManagedUDFSingleForce,laget_ListNext,laset_InstanceUDFFromSingleForce,0,0,0,LA_UDF_REFER|LA_UDF_IGNORE);
  710. }
  711. }
  712. laProp* laPropContainerManageable(laPropContainer* pc, int offset_of_dummy_list){
  713. if(!pc || pc->OtherAlloc || !offset_of_dummy_list) return 0;
  714. if(!MAIN.SaverDummyContainer){
  715. MAIN.SaverDummyContainer = laAddPropertyContainer("la_saver_dummy","Saver Dummy","Saver dummy",0,0,sizeof(laSaverDummy),0,0,2);
  716. laAddSubGroup(MAIN.SaverDummyContainer, "__file", "File", "The file this block came from/saves to", "managed_udf",
  717. 0,LA_WIDGET_COLLECTION_SELECTOR,laui_ManagedUDFItem,-1,laget_InstanceUDF,laget_InstanceActiveUDF,laget_ListNext,laset_InstanceUDF,0,0,0,LA_UDF_REFER|LA_UDF_IGNORE);
  718. }
  719. pc->SaverDummy=laAddSubGroup(pc,"__single_saver_dummy","Saver","Saver dummy","la_saver_dummy",0,0,0,-1,0,0,0,0,0,0,offset_of_dummy_list,0);
  720. return pc->SaverDummy;
  721. }
  722. void laContainerAnimationFunctions(laPropContainer* pc, laActionHolderVerifyF ActionHolderVerify){
  723. pc->ActionHolderVerify=ActionHolderVerify;
  724. }
  725. int la_GetKeyablePropertyStorageSize(laProp* p){
  726. switch(p->PropertyType){
  727. case LA_PROP_INT: case LA_PROP_FLOAT: case LA_PROP_ENUM:
  728. return sizeof(uint64_t);
  729. case LA_PROP_INT | LA_PROP_ARRAY: case LA_PROP_FLOAT | LA_PROP_ARRAY: case LA_PROP_ENUM | LA_PROP_ARRAY:
  730. if(p->GetLen){ return 0; }
  731. return sizeof(uint64_t)*p->Len;
  732. case LA_PROP_SUB: case LA_PROP_OPERATOR: case LA_PROP_STRING: case LA_PROP_RAW: default:
  733. return 0;
  734. }
  735. }
  736. int la_GetPropertySize(int Type){
  737. switch (Type){
  738. case LA_PROP_INT:
  739. case LA_PROP_INT | LA_PROP_ARRAY:
  740. return sizeof(laIntProp);
  741. case LA_PROP_FLOAT:
  742. case LA_PROP_FLOAT | LA_PROP_ARRAY:
  743. return sizeof(laFloatProp);
  744. case LA_PROP_ENUM:
  745. case LA_PROP_ENUM | LA_PROP_ARRAY:
  746. return sizeof(laEnumProp);
  747. case LA_PROP_SUB: return sizeof(laSubProp);
  748. case LA_PROP_OPERATOR: return sizeof(laOperatorProp);
  749. case LA_PROP_STRING: return sizeof(laStringProp);
  750. case LA_PROP_RAW: return sizeof(laRawProp);
  751. }
  752. return 0;
  753. }
  754. const char LA_PROP_STR_INT[] = "LA_PROP_INT";
  755. const char LA_PROP_STR_INT_ARR[] = "LA_PROP_INT_ARR";
  756. const char LA_PROP_STR_FLOAT[] = "LA_PROP_FLOAT";
  757. const char LA_PROP_STR_FLOAT_ARR[] = "LA_PROP_FLOAT_ARR";
  758. const char LA_PROP_STR_ENUM[] = "LA_PROP_ENUM";
  759. const char LA_PROP_STR_ENUM_ARR[] = "LA_PROP_ENUM_ARR";
  760. const char LA_PROP_STR_ACT[] = "LA_PROP_ACT";
  761. const char LA_PROP_STR_STR[] = "LA_PROP_STR";
  762. const char LA_PROP_STR_SUB[] = "LA_PROP_SUB";
  763. const char *la_GetPropertyTypeString(int Type){
  764. switch (Type){
  765. case LA_PROP_INT:
  766. return LA_PROP_STR_INT;
  767. case LA_PROP_INT | LA_PROP_ARRAY:
  768. return LA_PROP_STR_INT_ARR;
  769. case LA_PROP_FLOAT:
  770. return LA_PROP_STR_FLOAT;
  771. case LA_PROP_FLOAT | LA_PROP_ARRAY:
  772. return LA_PROP_STR_FLOAT_ARR;
  773. case LA_PROP_ENUM:
  774. return LA_PROP_STR_ENUM;
  775. case LA_PROP_ENUM | LA_PROP_ARRAY:
  776. return LA_PROP_STR_ENUM_ARR;
  777. case LA_PROP_SUB:
  778. return LA_PROP_STR_SUB;
  779. case LA_PROP_OPERATOR:
  780. return LA_PROP_STR_ACT;
  781. case LA_PROP_STRING:
  782. return LA_PROP_STR_STR;
  783. }
  784. return 0;
  785. }
  786. void la_AssignPropertyGeneralSub(laProp *p){
  787. switch (p->PropertyType){
  788. case LA_PROP_INT: p->SubProp = MAIN.GeneralIntSub; break;
  789. case LA_PROP_INT | LA_PROP_ARRAY: p->SubProp = MAIN.GeneralIntArraySub; break;
  790. case LA_PROP_FLOAT: p->SubProp = MAIN.GeneralFloatSub; break;
  791. case LA_PROP_FLOAT | LA_PROP_ARRAY: p->SubProp = MAIN.GeneralFloatArraySub; break;
  792. case LA_PROP_ENUM: p->SubProp = MAIN.GeneralEnumSub; break;
  793. case LA_PROP_ENUM | LA_PROP_ARRAY: p->SubProp = MAIN.GeneralEnumArraySub; break;
  794. case LA_PROP_STRING: p->SubProp = MAIN.GeneralStringSub; break;
  795. case LA_PROP_OPERATOR: p->SubProp = MAIN.GeneralOperatorSub; break;
  796. case LA_PROP_SUB: p->SubExtra = MAIN.GeneralCollectionSub; break;
  797. case LA_PROP_RAW: p->SubExtra = MAIN.GeneralRawSub; break;
  798. }
  799. }
  800. laProp *la_CreateProperty(laPropContainer *Container, int Type, const char *Identifier, const char *Name, const char *Description,
  801. const char *Prefix, const char *Unit, laWidget* DefaultWidget, u64bit Tag){
  802. laProp *p = memAcquire(la_GetPropertySize(Type));
  803. p->Identifier = Identifier;
  804. p->Name = Name;
  805. p->Description = Description;
  806. p->Prefix = Prefix;
  807. p->Unit = Unit;
  808. if(DefaultWidget){ p->DefaultUiType = DefaultWidget->Type; p->DefaultFlags = DefaultWidget->Flags; }
  809. p->PropertyType = Type;
  810. p->Tag = Tag;
  811. p->Container = Container;
  812. if (Container) lstAppendItem(&Container->Props, p);
  813. p->UDFIsRefer = (Tag & LA_UDF_REFER) ? 1 : 0;
  814. p->UDFIgnore = (Tag & LA_UDF_IGNORE) ? 1 : 0;
  815. p->UDFOnly = (Tag & LA_UDF_ONLY) ? 1 : 0;
  816. p->ReadOnly = (Tag & LA_READ_ONLY) ? 1 : 0;
  817. p->IsRadAngle = (Tag & LA_RAD_ANGLE)? 1 : 0;
  818. p->UDFHideInSave = ((Tag & LA_HIDE_IN_SAVE) || p->UDFIgnore)? 1 : 0;
  819. p->UDFReadProgress = (Tag & LA_PROP_READ_PROGRESS)?1:0;
  820. p->CanTranslate = (Tag & LA_TRANSLATE)?1:0;
  821. if(p->IsRadAngle&&(!p->Unit)) p->Unit="°";
  822. p->Keyable = (Tag & LA_PROP_KEYABLE)? 1 : 0;
  823. if(Tag&LA_PROP_ROTATION){ p->KeySpecialInterpolation=LA_PROP_KEY_INTERPOLATION_ROTATION; }
  824. return p;
  825. }
  826. void la_ClearDetachedProp(laPanel* p){
  827. laProp *np; while(np=lstPopItem(&p->PropLinkContainer->Props)){ free(np->Identifier); memFree(np); }
  828. }
  829. laProp *la_MakeDetachedProp(laPanel* p, const char *From, const char *Rename){
  830. laIntProp *ip;
  831. laFloatProp *fp;
  832. laEnumProp *ep;
  833. laSubProp *sp;
  834. laPropPack TempPP = {0};
  835. int result = 0;
  836. result = la_GetPropFromPath(&TempPP, 0, From, 0);
  837. if(!result) return 0;
  838. laProp *np = memAcquire(la_GetPropertySize(TempPP.LastPs->p->PropertyType));
  839. memcpy(np, TempPP.LastPs->p, la_GetPropertySize(TempPP.LastPs->p->PropertyType));
  840. np->Identifier = CreateNewBuffer(char, 128);
  841. strcpy(np->Identifier, Rename);
  842. np->DetachedPP.Go = 0;
  843. np->DetachedPP.RawThis = 0;
  844. np->DetachedPP.LastPs = 0;
  845. la_CopyPropPack(&TempPP, &np->DetachedPP);
  846. switch (np->PropertyType){
  847. case LA_PROP_INT:
  848. case LA_PROP_INT | LA_PROP_ARRAY:
  849. ip = np; if(!np->Len){ np->Len=1; }
  850. ip->Detached = CreateNewBuffer(int, np->Len);
  851. for(int i=0;i<np->Len;i++){ ((int*)ip->Detached)[i]=ip->DefVal; }
  852. break;
  853. case LA_PROP_FLOAT:
  854. case LA_PROP_FLOAT | LA_PROP_ARRAY:
  855. fp = np; if(!np->Len){ np->Len=1; }
  856. fp->Detached = CreateNewBuffer(real, np->Len);
  857. for(int i=0;i<np->Len;i++){ ((real*)fp->Detached)[i]=fp->DefVal; }
  858. break;
  859. case LA_PROP_ENUM:
  860. case LA_PROP_ENUM | LA_PROP_ARRAY:
  861. ep = np;
  862. ep->Detached = CreateNewBuffer(int, 1);
  863. ep->Detached[0] = ep->DefVal;
  864. break;
  865. case LA_PROP_SUB:
  866. sp=np; sp->GetCategory=((laSubProp*)np)->GetCategory;
  867. sp->IsDetached=1;
  868. break;
  869. }
  870. lstAppendItem(&p->PropLinkContainer->Props, np);
  871. la_AssignPropertyGeneralSub(np);
  872. la_FreePropStepCache(TempPP.Go);
  873. return np;
  874. }
  875. laProp *laAddIntProperty(laPropContainer *Container, const char *Identifier, const char *Name, const char *Description, laWidget* DefaultWidget,
  876. const char *Prefix, const char *Unit, int Max, int Min, int Step, int DefVal, const int *DefArr,
  877. int OffsetSize, laIntGetF Get, laIntSetF Set, int ArrayLength, laArrayGetLenF GetLen,
  878. laIntArraySetF SetArr, laIntArrayGetAllF GetAll, laIntArraySetAllF SetAll, laIntArraySetAllArrayF SetAllArr,
  879. laIntReadF Read, laIntArrayReadAllF ReadAll,
  880. u64bit Tag){
  881. laIntProp *p = la_CreateProperty(Container, LA_PROP_INT, Identifier, Name, Description, Prefix, Unit, DefaultWidget, Tag);
  882. if (ArrayLength > 1){
  883. p->Base.Len = ArrayLength;
  884. p->Base.PropertyType |= LA_PROP_ARRAY;
  885. }else if (GetLen)
  886. p->Base.GetLen = GetLen;
  887. p->Get = Get;
  888. p->Set = Set;
  889. p->SetAll = SetAll;
  890. p->GetAll = GetAll;
  891. p->SetAllArr = SetAllArr;
  892. p->SetArr = SetArr;
  893. p->DefArr = DefArr;
  894. p->DefVal = DefVal;
  895. p->Max = Max;
  896. p->Min = Min;
  897. p->Step = Step ? Step : 1;
  898. p->Base.Offset = OffsetSize;
  899. p->Base.OffsetIsPointer = (Tag&LA_UDF_REFER) ? 1 : 0;
  900. p->Read = Read;
  901. p->ReadAll = ReadAll;
  902. la_AssignPropertyGeneralSub(p);
  903. return p;
  904. }
  905. laProp *laAddFloatProperty(laPropContainer *Container, const char *Identifier, const char *Name, const char *Description, laWidget* DefaultWidget,
  906. const char *Prefix, const char *Unit, real Max, real Min, real Step, real DefVal, const real *DefArr,
  907. int OffsetSize, laFloatGetF Get, laFloatSetF Set, int ArrayLength, laArrayGetLenF GetLen,
  908. laFloatArraySetF SetArr, laFloatArrayGetAllF GetAll, laFloatArraySetAllF SetAll, laFloatArraySetAllArrayF SetAllArr,
  909. laFloatReadF Read, laFloatArrayReadAllF ReadAll,
  910. u64bit Tag){
  911. laFloatProp *p = la_CreateProperty(Container, LA_PROP_FLOAT, Identifier, Name, Description, Prefix, Unit, DefaultWidget, Tag);
  912. if (ArrayLength > 1){
  913. p->Base.Len = ArrayLength;
  914. p->Base.PropertyType |= LA_PROP_ARRAY;
  915. }else if (GetLen)
  916. p->Base.GetLen = GetLen;
  917. p->Get = Get;
  918. p->Set = Set;
  919. p->SetAll = SetAll;
  920. p->GetAll = GetAll;
  921. p->SetAllArr = SetAllArr;
  922. p->SetArr = SetArr;
  923. p->DefArr = DefArr;
  924. p->DefVal = DefVal;
  925. p->Max = Max;
  926. p->Min = Min;
  927. p->Step = Step ? Step : 0.01;
  928. p->Base.Offset = OffsetSize;
  929. p->Base.OffsetIsPointer = (Tag&LA_UDF_REFER) ? 1 : 0;
  930. p->Read = Read;
  931. p->ReadAll = ReadAll;
  932. la_AssignPropertyGeneralSub(p);
  933. return p;
  934. }
  935. laProp *laAddEnumProperty(laPropContainer *Container, const char *Identifier, const char *Name, const char *Description, laWidget* DefaultWidget,
  936. const char *Prefix, const char *Unit, int DefVal, const int *DefArr,
  937. int OffsetSize, laEnumGetF Get, laEnumSetF Set, int ArrayLength, laArrayGetLenF GetLen,
  938. laEnumArraySetF SetArr, laEnumArrayGetAllF GetAll, laEnumArraySetAllF SetAll,
  939. laEnumReadF Read, laEnumArrayReadAllF ReadAll,
  940. u64bit Tag){
  941. laEnumProp *p = la_CreateProperty(Container, LA_PROP_ENUM, Identifier, Name, Description, Prefix, Unit, DefaultWidget, Tag);
  942. if (ArrayLength > 1){
  943. p->Base.Len = ArrayLength;
  944. p->Base.PropertyType |= LA_PROP_ARRAY;
  945. }else if (GetLen)
  946. p->Base.GetLen = GetLen;
  947. p->Get = Get;
  948. p->Set = Set;
  949. p->SetAll = SetAll;
  950. p->GetAll = GetAll;
  951. p->SetArr = SetArr;
  952. p->DefArr = DefArr;
  953. p->DefVal = DefVal;
  954. p->Base.Offset = OffsetSize;
  955. p->Base.OffsetIsPointer = (Tag&LA_UDF_REFER) ? 1 : 0;
  956. p->Read = Read;
  957. p->ReadAll = ReadAll;
  958. la_AssignPropertyGeneralSub(p);
  959. return p;
  960. }
  961. int laAddEnumItem(laProp *p, const char *Identifier, const char *Name, const char *Description, uint32_t IconID){
  962. laEnumItem *ei = memAcquire(sizeof(laEnumItem));
  963. laEnumProp *ep = p;
  964. ei->Identifier = Identifier;
  965. ei->Name = Name;
  966. ei->Description = Description;
  967. ei->IconID = IconID;
  968. ei->Index = ep->Items.pLast ? ((laEnumItem *)ep->Items.pLast)->Index + 1 : 0;
  969. lstAppendItem(&ep->Items, ei);
  970. return 1;
  971. }
  972. int laAddEnumItemAs(laProp *p, const char *Identifier, const char *Name, const char *Description, int Index, uint32_t IconID){
  973. laEnumItem *ei = memAcquire(sizeof(laEnumItem));
  974. laEnumProp *ep = p;
  975. ei->Identifier = Identifier;
  976. ei->Name = Name;
  977. ei->Description = Description;
  978. ei->IconID = IconID;
  979. ei->Index = Index;
  980. lstAppendItem(&ep->Items, ei);
  981. return 1;
  982. }
  983. laProp *laAddStringProperty(laPropContainer *Container, const char *Identifier, const char *Name, const char *Description, laWidget* DefaultWidget,
  984. const char *Prefix, const char *Unit, const char *DefStr,
  985. int IsSafeString, int OffsetSize, laStringGetLenF GetLen, laStringGetF Get, laStringSetF Set,
  986. laStringReadF Read,
  987. u64bit Tag){
  988. laStringProp *p = la_CreateProperty(Container, LA_PROP_STRING, Identifier, Name, Description, Prefix, Unit, DefaultWidget, Tag);
  989. p->Get = Get;
  990. p->Set = Set;
  991. p->Getstrlen = GetLen;
  992. p->DefStr = DefStr;
  993. p->Base.Offset = OffsetSize;
  994. p->Base.OffsetIsPointer = (Tag&LA_UDF_LOCAL) ? 0 : 1;
  995. p->Read = Read;
  996. p->IsSafeString = IsSafeString;
  997. la_AssignPropertyGeneralSub(p);
  998. return p;
  999. }
  1000. laProp *laAddSubGroup(laPropContainer *Container, const char *Identifier, const char *Name, const char *Description,
  1001. const char *TargetId, laGetNodeTypeFunc GetType, laWidget* DefaultWidget, laUiDefineFunc DefaultUiDef,
  1002. int OffsetSize, laSubGetInstanceF Get, laSubGetInstanceF GetActive, laSubGetNextF GetNext, laSubSetInstanceF Set,
  1003. laSubGetStateF GetState, laSubSetStateF SetState, int ListHandleOffset, u64bit Tag){
  1004. laSubProp *p = la_CreateProperty(Container, LA_PROP_SUB, Identifier, Name, Description, 0, 0, DefaultWidget, Tag);
  1005. p->Base.Offset = OffsetSize;
  1006. p->Get = Get;
  1007. p->GetNext = GetNext;
  1008. p->GetActive = GetActive;
  1009. p->Set = Set;
  1010. p->GetState = GetState;
  1011. p->SetState = SetState;
  1012. p->TargetID = TargetId;
  1013. p->Base.OffsetIsPointer = (Tag & LA_UDF_LOCAL) ? 0 : 1;
  1014. p->Base.UiDefine = DefaultUiDef;
  1015. p->GetType = GetType;
  1016. p->ListHandleOffset = ListHandleOffset;
  1017. p->Base.UDFNoCreate = (Tag & LA_UDF_LOCAL) ? 1 : 0;
  1018. if (Tag & LA_UDF_SINGLE || (p->Base.OffsetIsPointer && !p->ListHandleOffset && !p->GetNext && !(Tag & LA_UDF_REFER))) p->Base.UDFIsSingle = 1;
  1019. la_AssignPropertyGeneralSub(p);
  1020. return p;
  1021. }
  1022. void laSubGroupExtraFunctions(laProp* p, laSubUIFilterF* UiFilter, laSubSaveFilterF* SaveFilter, laSubUIThemeF* GetTheme, laSubUIGapF GetGap, laSubUICategoryF GetCategory){
  1023. laSubProp *sp=p;
  1024. sp->UiFilter=UiFilter; sp->SaveFilter=SaveFilter; sp->GetTheme=GetTheme; sp->GetGap=GetGap; sp->GetCategory=GetCategory;
  1025. }
  1026. void laSubGroupDetachable(laProp *SubProp, laSubTypeDetachedGet DetachedGet, laSubTypeDetachedGetNext DetachedGetNext){
  1027. laSubProp *sp = SubProp;
  1028. SubProp->Tag |= LA_DETACHABLE;
  1029. sp->DetachedGet = DetachedGet;
  1030. sp->DetachedGetNext = DetachedGetNext;
  1031. }
  1032. laProp *laAddOperatorProperty(laPropContainer *Container, const char *Identifier, const char *Name, const char *Description,
  1033. const char *OperatorID, uint32_t IconID, laWidget* DefaultWidget){
  1034. laOperatorProp *p = la_CreateProperty(Container, LA_PROP_OPERATOR, Identifier, Name, Description, 0, 0, DefaultWidget, 0);
  1035. p->OperatorID = OperatorID;
  1036. p->Base.IconID = IconID;
  1037. la_AssignPropertyGeneralSub(p);
  1038. return p;
  1039. }
  1040. laProp *laAddRawProperty(laPropContainer *Container, const char *Identifier, const char *Name, const char *Description, int OffsetSize, laRawGetSizeF GetSize, laRawGetF RawGet, laRawSetF RawSet, u64bit Tag){
  1041. if(!RawGet && !GetSize) return 0;
  1042. laRawProp *p = la_CreateProperty(Container, LA_PROP_RAW, Identifier, Name, Description, 0, 0, 0, Tag);
  1043. p->Base.Offset = OffsetSize;
  1044. p->Base.OffsetIsPointer = (Tag & LA_UDF_LOCAL) ? 0 : 1;
  1045. p->RawGet=RawGet;
  1046. p->RawGetSize=GetSize;
  1047. p->RawSet=RawSet;
  1048. la_AssignPropertyGeneralSub(p);
  1049. return p;
  1050. }
  1051. //void laPropertySignal(laProp* p, int Throw, int Catch) {
  1052. // p->SignalThrow = Throw;
  1053. // p->SignalCatch = Catch;
  1054. //}
  1055. int laIsPropertyReadOnly(laPropPack *pp){
  1056. if (pp && pp->LastPs && pp->LastPs->p->ReadOnly) return 1;
  1057. return 0;
  1058. }
  1059. int laGetPrefixP(laPropPack *p, char buf[8][64]){
  1060. char *prefix = transLate(p->LastPs->p->Prefix);
  1061. int i = 0, row = 0;
  1062. if (!prefix) return 0;
  1063. int len=strlen(prefix);
  1064. while ((prefix[i] != U'\0') && (i+=1+strGetStringTerminateBy(&prefix[i], U',', &buf[row]))){
  1065. row++; if(i>=len){break;}
  1066. }
  1067. return 1;
  1068. }
  1069. int laGetPrefix(laProp *p, char buf[8][64]){
  1070. char *prefix = transLate(p->Prefix);
  1071. int i = 0, row = 0;
  1072. if (!prefix) return 0;
  1073. while ((prefix[i] != U'\0') && (i += 1 + strGetStringTerminateBy(&prefix[i], U',', &buf[row]))) row++;
  1074. return 1;
  1075. }
  1076. laPropContainer* laGetInstanceType(laPropPack* pp, void* instance){
  1077. if(pp->LastPs->p->PropertyType != LA_PROP_SUB) return 0;
  1078. laSubProp* sp = pp->LastPs->p;
  1079. if(instance && sp->GetType){ return sp->GetType(instance); }
  1080. return pp->LastPs->p->SubProp;
  1081. }
  1082. laUiDefineFunc laGetPropertyUiDefine(laPropPack* pp, void* instance){
  1083. if(pp->LastPs->p->UiDefine) return pp->LastPs->p->UiDefine;
  1084. laPropContainer* pc=laGetInstanceType(pp, instance);
  1085. if(pc && pc->UiDefine) return pc->UiDefine;
  1086. return laui_SubPropInfoDefault;
  1087. }
  1088. laPropContainer* la_EnsureSubTarget(laSubProp* sp, void* optional_instance){
  1089. if(sp->Base.PropertyType!=LA_PROP_SUB){return sp->Base.SubProp;}
  1090. if(optional_instance && sp->GetType) return sp->GetType(optional_instance);
  1091. if(sp->Base.SubProp){ return sp->Base.SubProp; }
  1092. if(sp->TargetID)sp->Base.SubProp=la_ContainerLookup(sp->TargetID); return sp->Base.SubProp;
  1093. }
  1094. int laReadInt(laPropPack *pp, int n){
  1095. if (pp->LastPs->p->PropertyType & LA_PROP_INT){
  1096. laIntProp *p = pp->LastPs->p;
  1097. if (p->Read) p->Read(pp->LastPs->UseInstance, n);
  1098. else
  1099. laSetInt(pp, n);
  1100. laNotifyUsersPP(pp);
  1101. return 1;
  1102. }
  1103. return 0;
  1104. }
  1105. int laSetInt(laPropPack *pp, int n){
  1106. if (pp->LastPs->p->PropertyType & LA_PROP_INT){
  1107. laIntProp *p = pp->LastPs->p;
  1108. if (p->Max != p->Min){
  1109. n = n > p->Max ? p->Max : (n < p->Min ? p->Min : n);
  1110. }
  1111. if (p->Base.DetachedPP.LastPs){
  1112. p->Detached[0] = n;
  1113. laNotifyUsersPP(pp);
  1114. return 1;
  1115. }
  1116. if (p->Set) p->Set(pp->LastPs->UseInstance, n);
  1117. elif (pp->LastPs->p->Offset>=0){
  1118. if (!p->Base.ElementBytes || p->Base.ElementBytes == 4){
  1119. if (pp->LastPs->p->OffsetIsPointer) (**((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1120. else (*((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1121. }elif (p->Base.ElementBytes == 2){
  1122. if (pp->LastPs->p->OffsetIsPointer) (**((short **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1123. else (*((short *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1124. }elif (p->Base.ElementBytes == 1){
  1125. if (pp->LastPs->p->OffsetIsPointer) (**((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1126. else (*((BYTE *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1127. }
  1128. }
  1129. laNotifyUsersPP(pp);
  1130. return 1;
  1131. }
  1132. return 0;
  1133. }
  1134. int laGetInt(laPropPack *pp){
  1135. int n;
  1136. if (pp->LastPs->p->PropertyType & LA_PROP_INT){
  1137. laIntProp *p = pp->LastPs->p;
  1138. if (p->Base.DetachedPP.LastPs){
  1139. return p->Detached[0];
  1140. }
  1141. if (!pp->LastPs->UseInstance) return 0;
  1142. if (((laIntProp *)pp->LastPs->p)->Get) return ((laIntProp *)pp->LastPs->p)->Get(pp->LastPs->UseInstance);
  1143. elif (pp->LastPs->p->Offset>=0){
  1144. if (!p->Base.ElementBytes || p->Base.ElementBytes == 4){
  1145. if (pp->LastPs->p->OffsetIsPointer) n = (**((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1146. else n = (*((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1147. }elif (p->Base.ElementBytes == 2){
  1148. if (pp->LastPs->p->OffsetIsPointer) n = (**((short **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1149. else n = (*((short *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1150. }elif (p->Base.ElementBytes == 1){
  1151. if (pp->LastPs->p->OffsetIsPointer) n = (**((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1152. else n = (*((BYTE *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1153. }
  1154. return n;
  1155. }
  1156. }
  1157. return 0;
  1158. }
  1159. int laReadFloat(laPropPack *pp, real n){
  1160. if (pp->LastPs->p->PropertyType & LA_PROP_FLOAT){
  1161. laFloatProp *p = pp->LastPs->p;
  1162. if (p->Read) p->Read(pp->LastPs->UseInstance, n);
  1163. else
  1164. laSetFloat(pp, n);
  1165. laNotifyUsersPP(pp);
  1166. return 1;
  1167. }
  1168. return 0;
  1169. }
  1170. int laSetFloat(laPropPack *pp, real n){
  1171. if (pp->LastPs->p->PropertyType & LA_PROP_FLOAT){
  1172. laFloatProp *p = pp->LastPs->p;
  1173. if (p->Max != p->Min){
  1174. n = n > p->Max ? p->Max : (n < p->Min ? p->Min : n);
  1175. }
  1176. if (p->Base.DetachedPP.LastPs){
  1177. p->Detached[0] = n;
  1178. laNotifyUsersPP(pp);
  1179. return 1;
  1180. }
  1181. if (p->Set) p->Set(pp->LastPs->UseInstance, n);
  1182. elif (pp->LastPs->p->Offset>=0){
  1183. if (pp->LastPs->p->OffsetIsPointer) (**((real **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1184. else (*((real *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1185. }
  1186. laNotifyUsersPP(pp);
  1187. return 1;
  1188. }
  1189. return 0;
  1190. }
  1191. real laGetFloat(laPropPack *pp){
  1192. if (pp->LastPs->p->PropertyType & LA_PROP_FLOAT){
  1193. laFloatProp *p = pp->LastPs->p;
  1194. if (p->Base.DetachedPP.LastPs){
  1195. return p->Detached[0];
  1196. }
  1197. if (!pp->LastPs->UseInstance) return 0;
  1198. if (((laFloatProp *)pp->LastPs->p)->Get) return ((laFloatProp *)pp->LastPs->p)->Get(pp->LastPs->UseInstance);
  1199. elif (pp->LastPs->p->Offset>=0){
  1200. if (pp->LastPs->p->OffsetIsPointer) return (**((real **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1201. else return (*((real *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1202. }
  1203. }
  1204. return 0;
  1205. }
  1206. int laGetArrayLength(laPropPack *pp){
  1207. if (!pp->LastPs->p) return 0;
  1208. if (pp->LastPs->p->GetLen) return pp->LastPs->p->GetLen(pp->LastPs->UseInstance);
  1209. else{
  1210. if(pp->LastPs->p->Len==0) pp->LastPs->p->Len=1;
  1211. return pp->LastPs->p->Len;
  1212. }
  1213. }
  1214. int laSetIntArraySingle(laPropPack *pp, int index, int n){
  1215. laIntProp *p = pp->LastPs->p;
  1216. if (p->Max != p->Min){
  1217. n = n > p->Max ? p->Max : (n < p->Min ? p->Min : n);
  1218. }
  1219. if (p->Base.DetachedPP.LastPs){
  1220. p->Detached[index] = n;
  1221. laNotifyUsersPP(pp);
  1222. return;
  1223. }
  1224. if (!pp->LastPs->UseInstance) return 0;
  1225. if (pp->LastPs->p->PropertyType & LA_PROP_INT){
  1226. if (p->SetArr){
  1227. p->SetArr(pp->LastPs->UseInstance, index, n);
  1228. laNotifyUsersPP(pp);
  1229. return 1;
  1230. }elif(p->SetAllArr){
  1231. int len = laGetArrayLength(pp); int* t=malloc(len*sizeof(int));
  1232. laGetIntArray(pp, t); t[index]=n;
  1233. laSetIntArrayAllArray(pp, t); free(t);
  1234. return 1;
  1235. }elif(p->Set){
  1236. laSetInt(pp, n);
  1237. return 1;
  1238. }elif (pp->LastPs->p->Offset>=0){
  1239. int *src = (pp->LastPs->p->OffsetIsPointer) ? ((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1240. switch(pp->LastPs->p->ElementBytes){
  1241. default: case 4: src[index] = n; break;
  1242. case 2: ((short*)src)[index]=n; break;
  1243. case 1: ((char*)src)[index]=n; break;
  1244. }
  1245. laNotifyUsersPP(pp); return 1;
  1246. }
  1247. }
  1248. return 0;
  1249. }
  1250. int laSetIntArrayAll(laPropPack *pp, int n){
  1251. laIntProp *p = pp->LastPs->p;
  1252. if (p->Max != p->Min){
  1253. n = n > p->Max ? p->Max : (n < p->Min ? p->Min : n);
  1254. }
  1255. if (p->Base.DetachedPP.LastPs){
  1256. int i = 0, len = laGetArrayLength(pp);
  1257. for (i; i < len; i++){
  1258. p->Detached[i] = n;
  1259. }
  1260. laNotifyUsersPP(pp);
  1261. return 1;
  1262. }
  1263. if (!pp->LastPs->UseInstance) return 0;
  1264. if (pp->LastPs->p->PropertyType & LA_PROP_INT){
  1265. if (p->SetAll) p->SetAll(pp->LastPs->UseInstance, n);
  1266. else if (p->SetArr){
  1267. int i = 0, len = laGetArrayLength(pp);
  1268. for (i; i < len; i++){
  1269. p->SetArr(pp->LastPs->UseInstance, i, n);
  1270. }
  1271. }elif (pp->LastPs->p->Offset>=0){
  1272. int *src = (pp->LastPs->p->OffsetIsPointer) ? ((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1273. int i = 0, len = laGetArrayLength(pp);
  1274. for (i; i < len; i++){
  1275. switch(pp->LastPs->p->ElementBytes){
  1276. default: case 4: src[i] = n; break;
  1277. case 2: ((short*)src)[i]=n; break;
  1278. case 1: ((char*)src)[i]=n; break;
  1279. }
  1280. }
  1281. }
  1282. laNotifyUsersPP(pp);
  1283. return 1;
  1284. }
  1285. return 0;
  1286. }
  1287. int laReadIntArrayAllArray(laPropPack *pp, int *arr){
  1288. if (pp->LastPs->p->PropertyType & LA_PROP_INT){
  1289. if (((laIntProp *)pp->LastPs->p)->Base.DetachedPP.LastPs){
  1290. int i = 0, len = laGetArrayLength(pp);
  1291. for (i; i < len; i++){
  1292. ((laIntProp *)pp->LastPs->p)->Detached[i] = arr[i];
  1293. }
  1294. return 1;
  1295. }
  1296. if (!pp->LastPs->UseInstance) return 0;
  1297. if (((laIntProp *)pp->LastPs->p)->SetAllArr) ((laIntProp *)pp->LastPs->p)->SetAllArr(pp->LastPs->UseInstance, arr);
  1298. else
  1299. laSetIntArrayAllArray(pp, arr);
  1300. laNotifyUsersPP(pp);
  1301. return 1;
  1302. }
  1303. return 0;
  1304. }
  1305. int laSetIntArrayAllArray(laPropPack *pp, int *arr){
  1306. if (pp->LastPs->p->PropertyType & LA_PROP_INT){
  1307. if (((laIntProp *)pp->LastPs->p)->Base.DetachedPP.LastPs){
  1308. int i = 0, len = laGetArrayLength(pp);
  1309. for (i; i < len; i++){
  1310. ((laIntProp *)pp->LastPs->p)->Detached[i] = arr[i];
  1311. }
  1312. laNotifyUsersPP(pp);
  1313. return 1;
  1314. }
  1315. if (!pp->LastPs->UseInstance) return 0;
  1316. if (((laIntProp *)pp->LastPs->p)->SetAllArr) ((laIntProp *)pp->LastPs->p)->SetAllArr(pp->LastPs->UseInstance, arr);
  1317. else if (((laIntProp *)pp->LastPs->p)->SetArr){
  1318. int i = 0, len = laGetArrayLength(pp);
  1319. for (i; i < len; i++){
  1320. ((laIntProp *)pp->LastPs->p)->SetArr(pp->LastPs->UseInstance, i, arr[i]);
  1321. }
  1322. }else if (pp->LastPs->p->Offset>=0){
  1323. int *src = (pp->LastPs->p->OffsetIsPointer) ? ((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1324. int i = 0, len = laGetArrayLength(pp);
  1325. for (i; i < len; i++){
  1326. switch(pp->LastPs->p->ElementBytes){
  1327. default: case 4: src[i] =arr[i]; break;
  1328. case 2: ((short*)src)[i]=arr[i]; break;
  1329. case 1: ((char*)src)[i]=arr[i]; break;
  1330. }
  1331. }
  1332. }
  1333. laNotifyUsersPP(pp);
  1334. return 1;
  1335. }
  1336. return 0;
  1337. }
  1338. int laGetIntArray(laPropPack *pp, int *result){
  1339. if (pp->LastPs->p->PropertyType & LA_PROP_INT){
  1340. laIntProp *p = pp->LastPs->p;
  1341. if (p->Base.DetachedPP.LastPs){
  1342. int len = laGetArrayLength(pp);
  1343. memcpy(result, p->Detached, len * sizeof(int));
  1344. return 1;
  1345. }
  1346. if (!pp->LastPs->UseInstance) return 0;
  1347. if (!((laIntProp *)pp->LastPs->p)->GetAll){
  1348. int len = laGetArrayLength(pp);
  1349. if(len==1){ *result=laGetInt(pp); return 1; }
  1350. if(pp->LastPs->p->Offset>=0){
  1351. int *src = (pp->LastPs->p->OffsetIsPointer) ? ((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1352. switch(pp->LastPs->p->ElementBytes){
  1353. default: case 4: memcpy(result, src, len * sizeof(int)); break;
  1354. case 2: for(int i=0;i<len;i++){ result[i]=((short*)src)[i]; } break;
  1355. case 1: for(int i=0;i<len;i++){ result[i]=((char*)src)[i]; } break;
  1356. }
  1357. }else{ *result=0; }
  1358. return 1;
  1359. }else{
  1360. ((laIntProp *)pp->LastPs->p)->GetAll(pp->LastPs->UseInstance, result);
  1361. return 1;
  1362. }
  1363. }
  1364. return 0;
  1365. }
  1366. int laSetFloatArraySingle(laPropPack *pp, int index, real n){
  1367. laFloatProp *p = pp->LastPs->p;
  1368. if (p->Max != p->Min){
  1369. n = n > p->Max ? p->Max : (n < p->Min ? p->Min : n);
  1370. }
  1371. if (p->Base.DetachedPP.LastPs){
  1372. p->Detached[index] = n;
  1373. laNotifyUsersPP(pp);
  1374. return 1;
  1375. }
  1376. if (!pp->LastPs->UseInstance) return 0;
  1377. if (pp->LastPs->p->PropertyType & LA_PROP_FLOAT){
  1378. if (p->SetArr){
  1379. p->SetArr(pp->LastPs->UseInstance, index, n);
  1380. laNotifyUsersPP(pp);
  1381. return 1;
  1382. }elif(p->SetAllArr){
  1383. int len = laGetArrayLength(pp); real* t=malloc(len*sizeof(real));
  1384. laGetFloatArray(pp, t); t[index]=n;
  1385. laSetFloatArrayAllArray(pp, t); free(t);
  1386. return 1;
  1387. }elif(p->Set){
  1388. laSetFloat(pp, n);
  1389. return 1;
  1390. }elif (pp->LastPs->p->Offset>=0){
  1391. real *src = (pp->LastPs->p->OffsetIsPointer) ? ((real **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((real *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1392. src[index] = n;
  1393. laNotifyUsersPP(pp);
  1394. return 1;
  1395. }
  1396. }
  1397. return 0;
  1398. }
  1399. int laSetFloatArrayAll(laPropPack *pp, real n){
  1400. laFloatProp *p = pp->LastPs->p;
  1401. if (p->Max != p->Min){
  1402. n = n > p->Max ? p->Max : (n < p->Min ? p->Min : n);
  1403. }
  1404. if (p->Base.DetachedPP.LastPs){
  1405. int i = 0, len = laGetArrayLength(pp);
  1406. for (i; i < len; i++){
  1407. p->Detached[i] = n;
  1408. }
  1409. laNotifyUsersPP(pp);
  1410. return 1;
  1411. }
  1412. if (!pp->LastPs->UseInstance) return 0;
  1413. if (pp->LastPs->p->PropertyType & LA_PROP_FLOAT){
  1414. if (p->SetAll) p->SetAll(pp->LastPs->UseInstance, n);
  1415. else if (p->SetArr){
  1416. int i = 0, len = laGetArrayLength(pp);
  1417. for (i; i < len; i++){
  1418. p->SetArr(pp->LastPs->UseInstance, i, n);
  1419. }
  1420. }else if (pp->LastPs->p->Offset>=0){
  1421. real *src = (pp->LastPs->p->OffsetIsPointer) ? ((real **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((real *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1422. int i = 0, len = laGetArrayLength(pp);
  1423. for (i; i < len; i++){ src[i] = n; }
  1424. }
  1425. laNotifyUsersPP(pp);
  1426. return 1;
  1427. }
  1428. return 0;
  1429. }
  1430. int laReadFloatArrayAllArray(laPropPack *pp, real *arr){
  1431. if (((laFloatProp *)pp->LastPs->p)->Base.DetachedPP.LastPs){
  1432. int i = 0, len = laGetArrayLength(pp);
  1433. for (i; i < len; i++){
  1434. ((laFloatProp *)pp->LastPs->p)->Detached[i] = arr[i];
  1435. }
  1436. return 1;
  1437. }
  1438. if (!pp->LastPs->UseInstance) return 0;
  1439. if (pp->LastPs->p->PropertyType & LA_PROP_FLOAT){
  1440. if (((laFloatProp *)pp->LastPs->p)->ReadAll) ((laFloatProp *)pp->LastPs->p)->ReadAll(pp->LastPs->UseInstance, arr);
  1441. else if (((laFloatProp *)pp->LastPs->p)->SetArr){
  1442. int i = 0, len = laGetArrayLength(pp);
  1443. for (i; i < len; i++){
  1444. ((laFloatProp *)pp->LastPs->p)->SetArr(pp->LastPs->UseInstance, i, arr[i]);
  1445. }
  1446. }else if (pp->LastPs->p->Offset>=0){
  1447. real *src = (pp->LastPs->p->OffsetIsPointer) ? ((real **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((real *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1448. int i = 0, len = laGetArrayLength(pp);
  1449. for (i; i < len; i++){ src[i] = arr[i]; }
  1450. }
  1451. laNotifyUsersPP(pp);
  1452. return 1;
  1453. }
  1454. return 0;
  1455. }
  1456. int laSetFloatArrayAllArray(laPropPack *pp, real *arr){
  1457. if (((laFloatProp *)pp->LastPs->p)->Base.DetachedPP.LastPs){
  1458. int i = 0, len = laGetArrayLength(pp);
  1459. for (i; i < len; i++){
  1460. ((laFloatProp *)pp->LastPs->p)->Detached[i] = arr[i];
  1461. }
  1462. laNotifyUsersPP(pp);
  1463. return 1;
  1464. }
  1465. if (!pp->LastPs->UseInstance) return 0;
  1466. if (pp->LastPs->p->PropertyType & LA_PROP_FLOAT){
  1467. if (((laFloatProp *)pp->LastPs->p)->SetAllArr) ((laFloatProp *)pp->LastPs->p)->SetAllArr(pp->LastPs->UseInstance, arr);
  1468. else if (((laFloatProp *)pp->LastPs->p)->SetArr){
  1469. int i = 0, len = laGetArrayLength(pp);
  1470. for (i; i < len; i++){
  1471. ((laFloatProp *)pp->LastPs->p)->SetArr(pp->LastPs->UseInstance, i, arr[i]);
  1472. }
  1473. }else if (pp->LastPs->p->Offset>=0){
  1474. real *src = (pp->LastPs->p->OffsetIsPointer) ? ((real **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((real *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1475. int i = 0, len = laGetArrayLength(pp);
  1476. for (i; i < len; i++){ src[i] = arr[i]; }
  1477. }
  1478. laNotifyUsersPP(pp);
  1479. return 1;
  1480. }
  1481. return 0;
  1482. }
  1483. int laGetFloatArray(laPropPack *pp, real *result){
  1484. if (pp->LastPs->p->PropertyType & LA_PROP_FLOAT){
  1485. laFloatProp *p = pp->LastPs->p;
  1486. if (p->Base.DetachedPP.LastPs){
  1487. int len = laGetArrayLength(pp);
  1488. memcpy(result, p->Detached, len * sizeof(real));
  1489. return 1;
  1490. }
  1491. if (!pp->LastPs->UseInstance) return 0;
  1492. if (!((laFloatProp *)pp->LastPs->p)->GetAll){
  1493. int len = laGetArrayLength(pp);
  1494. if(len==1){ *result=laGetFloat(pp); return 1; }
  1495. if(pp->LastPs->p->Offset>=0){
  1496. real *src = (pp->LastPs->p->OffsetIsPointer) ? ((real **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) : ((real *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1497. memcpy(result, src, len * sizeof(real));
  1498. }else{ *result=0; }
  1499. return 1;
  1500. }else{
  1501. ((laFloatProp *)pp->LastPs->p)->GetAll(pp->LastPs->UseInstance, result);
  1502. return 1;
  1503. }
  1504. }
  1505. return 0;
  1506. }
  1507. int laReadEnum(laPropPack *pp, int n){
  1508. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1509. if (((laEnumProp *)pp->LastPs->p)->Read) ((laEnumProp *)pp->LastPs->p)->Read(pp->LastPs->UseInstance, n);
  1510. else laSetEnum(pp, n);
  1511. laNotifyUsersPP(pp);
  1512. return 1;
  1513. }
  1514. return 0;
  1515. }
  1516. int laSetEnumExternal(laPropPack *pp, int n){
  1517. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1518. laEnumProp *ep = pp->LastPs->p;
  1519. laEnumItem *ei;
  1520. int i = 0;
  1521. for (ei = ep->Items.pFirst; ei; ei = ei->Item.pNext){
  1522. if (i == n) break; i++;
  1523. }
  1524. laSetEnum(pp, ei->Index);
  1525. }
  1526. return 0;
  1527. }
  1528. int laSetEnum(laPropPack *pp, int n){
  1529. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1530. laEnumProp *p = pp->LastPs->p;
  1531. if (p->Base.DetachedPP.LastPs){
  1532. p->Detached[0] = n;
  1533. laNotifyUsersPP(pp);
  1534. return 1;
  1535. }
  1536. if (!pp->LastPs->UseInstance) return 0;
  1537. if (p->Set) p->Set(pp->LastPs->UseInstance, n);
  1538. elif(p->Base.Offset>=0) {
  1539. if (!p->Base.ElementBytes || p->Base.ElementBytes == 4){
  1540. if (pp->LastPs->p->OffsetIsPointer) (**((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1541. else (*((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1542. }elif (p->Base.ElementBytes == 2){
  1543. if (pp->LastPs->p->OffsetIsPointer) (**((short **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1544. else (*((short *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1545. }elif (p->Base.ElementBytes == 1){
  1546. if (pp->LastPs->p->OffsetIsPointer) (**((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1547. else (*((BYTE *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset))) = n;
  1548. }
  1549. }
  1550. laNotifyUsersPP(pp);
  1551. return 1;
  1552. }
  1553. return 0;
  1554. }
  1555. int laReadEnumArrayAll(laPropPack *pp, int *n){
  1556. int i, len = pp->LastPs->p->Len;
  1557. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1558. if (((laEnumProp *)pp->LastPs->p)->ReadAll) ((laEnumProp *)pp->LastPs->p)->ReadAll(pp->LastPs->UseInstance, n);
  1559. else
  1560. for (i = 0; i < len; i++){
  1561. laSetEnumArrayIndexed(pp, i, n[i]);
  1562. }
  1563. laNotifyUsersPP(pp);
  1564. return 1;
  1565. }
  1566. return 0;
  1567. }
  1568. int laSetEnumArrayIndexedExternal(laPropPack *pp, int index, int n){
  1569. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1570. laEnumProp *ep = pp->LastPs->p;
  1571. laEnumItem *ei;
  1572. int i = 0;
  1573. for (ei = ep->Items.pFirst; ei; ei = ei->Item.pNext){
  1574. if (i == n) break;
  1575. i++;
  1576. }
  1577. laSetEnumArrayIndexed(pp, index,ei->Index);
  1578. }
  1579. return 0;
  1580. }
  1581. int laSetEnumArrayIndexed(laPropPack *pp, int index, int n){
  1582. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1583. laEnumProp *p = pp->LastPs->p;
  1584. if (p->Base.DetachedPP.LastPs){
  1585. p->Detached[index] = n;
  1586. laNotifyUsersPP(pp);return 1;
  1587. }
  1588. if (!pp->LastPs->UseInstance) return 0;
  1589. if (p->SetArr) p->SetArr(pp->LastPs->UseInstance, index, n);
  1590. elif(p->Set && index==0){ laSetEnum(pp, n); }
  1591. elif(p->Base.Offset>=0){
  1592. if (!p->Base.ElementBytes || p->Base.ElementBytes == 4){
  1593. if (pp->LastPs->p->OffsetIsPointer) (**((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + sizeof(int) * index))) = n;
  1594. else (*((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + sizeof(int) * index))) = n;
  1595. }elif (p->Base.ElementBytes == 2){
  1596. if (pp->LastPs->p->OffsetIsPointer) (**((short **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + sizeof(short) * index))) = n;
  1597. else (*((short *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + sizeof(short) * index))) = n;
  1598. }elif (p->Base.ElementBytes == 1){
  1599. if (pp->LastPs->p->OffsetIsPointer) (**((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + sizeof(char) * index))) = n;
  1600. else (*((BYTE *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + sizeof(char) * index))) = n;
  1601. }
  1602. }
  1603. laNotifyUsersPP(pp);
  1604. return 1;
  1605. }
  1606. return 0;
  1607. }
  1608. int laSetEnumArrayAllArray(laPropPack* pp, laEnumItem** ei){
  1609. int len=laGetArrayLength(pp);
  1610. for(int i=0;i<len;i++){
  1611. laSetEnumArrayIndexed(pp,i,ei[i]->Index);
  1612. }
  1613. return 0;
  1614. }
  1615. int laSetEnumArrayAll(laPropPack* pp, int EnumN){
  1616. int len=laGetArrayLength(pp);
  1617. laEnumProp *ep = pp->LastPs->p; laEnumItem *ei;
  1618. int i = 0; for (ei = ep->Items.pFirst; ei; ei = ei->Item.pNext){ if (i == EnumN) break; i++; }
  1619. for(int i=0;i<len;i++){
  1620. laSetEnumArrayIndexed(pp,i,ei->Index);
  1621. }
  1622. return 0;
  1623. }
  1624. laEnumItem *laGetEnum(laPropPack *pp){
  1625. int n;
  1626. laEnumItem *ei;
  1627. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1628. laEnumProp *p = pp->LastPs->p;
  1629. if (p->Base.DetachedPP.LastPs){
  1630. n = p->Detached[0];
  1631. }elif (!pp->LastPs->UseInstance) return 0;
  1632. elif (p->Get) n = p->Get(pp->LastPs->UseInstance);
  1633. elif(p->Base.Offset>=0){
  1634. if (!pp->LastPs->UseInstance) n = 0;
  1635. elif (!p->Base.ElementBytes || p->Base.ElementBytes == 4){
  1636. if (pp->LastPs->p->OffsetIsPointer) n = (**((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1637. else n = (*((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1638. }elif (p->Base.ElementBytes == 2){
  1639. if (pp->LastPs->p->OffsetIsPointer) n = (**((short **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1640. else n = (*((short *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1641. }elif (p->Base.ElementBytes == 1){
  1642. if (pp->LastPs->p->OffsetIsPointer) n = (**((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1643. else n = (*((BYTE *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)));
  1644. }
  1645. }
  1646. for (ei = p->Items.pFirst; ei; ei = ei->Item.pNext){
  1647. if (n == ei->Index) return ei;
  1648. }
  1649. }
  1650. return ((laEnumProp *)pp->LastPs->p)->Items.pFirst;
  1651. }
  1652. laEnumItem *laGetEnumArrayIndexed(laPropPack *pp, int index){
  1653. int n;
  1654. int i = 0;
  1655. laEnumItem *ei;
  1656. int result[16];
  1657. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1658. laEnumProp *p = pp->LastPs->p;
  1659. if (p->Base.DetachedPP.LastPs){
  1660. n = p->Detached[index];
  1661. }elif (!p->GetAll){
  1662. if(laGetArrayLength(pp)==1){return laGetEnum(pp);}
  1663. if(p->Base.Offset>=0){
  1664. if (!pp->LastPs->UseInstance) n = 0;
  1665. elif (!p->Base.ElementBytes || p->Base.ElementBytes == 4){
  1666. if (pp->LastPs->p->OffsetIsPointer) n = (**((int **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) + index * sizeof(int));
  1667. else n = (*((int *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + index * sizeof(int))));
  1668. }elif (p->Base.ElementBytes == 2){
  1669. if (pp->LastPs->p->OffsetIsPointer) n = (**((short **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) + index * sizeof(short));
  1670. else n = (*((short *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + index * sizeof(short))));
  1671. }elif (p->Base.ElementBytes == 1){
  1672. if (pp->LastPs->p->OffsetIsPointer) n = (**((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset)) + index * sizeof(char));
  1673. else n = (*((BYTE *)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset + index * sizeof(char))));
  1674. }
  1675. }
  1676. }else{
  1677. if (!pp->LastPs->UseInstance) n = 0;
  1678. else{
  1679. p->GetAll(pp->LastPs->UseInstance, result);
  1680. n = result[index];
  1681. }
  1682. }
  1683. for (ei = p->Items.pFirst; ei; ei = ei->Item.pNext){
  1684. if (n == ei->Index) return ei;
  1685. }
  1686. }
  1687. return 0;
  1688. }
  1689. int laGetEnumArray(laPropPack *pp, laEnumItem **result){
  1690. int len = laGetArrayLength(pp);
  1691. int i = 0;
  1692. laEnumItem *ei;
  1693. int Results[16];
  1694. laEnumProp *p = pp->LastPs->p;
  1695. if (p->Base.DetachedPP.LastPs){
  1696. for (int i = 0; i < len; i++){
  1697. Results[i] = p->Detached[i];
  1698. for (ei = ((laEnumProp *)pp->LastPs->p)->Items.pFirst; ei; ei = ei->Item.pNext){
  1699. if (ei->Index == Results[i]){result[i] = ei; break;}
  1700. }
  1701. }
  1702. }elif (!((laEnumProp *)pp->LastPs->p)->GetAll){
  1703. for (i; i < len; i++){
  1704. result[i] = laGetEnumArrayIndexed(pp, i);
  1705. }
  1706. return 1;
  1707. }else{
  1708. int a = 0;
  1709. ((laEnumProp *)pp->LastPs->p)->GetAll(pp->LastPs->UseInstance, Results);
  1710. for (i = 0; i < len; i++){
  1711. for (ei = ((laEnumProp *)pp->LastPs->p)->Items.pFirst; ei; ei = ei->Item.pNext){
  1712. if (ei->Index == Results[i]){ result[i] = ei; break; }
  1713. }
  1714. }
  1715. }
  1716. }
  1717. laEnumItem *laGetEnumFromIdentifier(laEnumProp *p, char *Identifier){
  1718. laEnumItem *ei;
  1719. for (ei = p->Items.pFirst; ei; ei = ei->Item.pNext){
  1720. if (!strcmp(ei->Identifier, Identifier)) return ei;
  1721. }
  1722. return p->Items.pFirst;
  1723. }
  1724. int laEnumHasIcon(laPropPack *pp){
  1725. laEnumProp *p = pp->LastPs->p;
  1726. laEnumItem *ei;
  1727. if ((p->Base.PropertyType & LA_PROP_ENUM) != LA_PROP_ENUM) return 0;
  1728. for (ei = p->Items.pFirst; ei; ei = ei->Item.pNext){
  1729. if (ei->IconID) return 1;
  1730. }
  1731. return 0;
  1732. }
  1733. int laGetEnumEntryLen(laPropPack *pp){
  1734. int i = 0;
  1735. laEnumItem *ei;
  1736. if (pp->LastPs->p->PropertyType & LA_PROP_ENUM){
  1737. if (((laEnumProp *)pp->LastPs->p)->GetLen) return ((laEnumProp *)pp->LastPs->p)->GetLen(pp->LastPs->UseInstance);
  1738. for (ei = ((laEnumProp *)pp->LastPs->p)->Items.pFirst; ei; ei = ei->Item.pNext){
  1739. i += 1;
  1740. }
  1741. return i;
  1742. }
  1743. return 0;
  1744. }
  1745. int laReadString(laPropPack *pp, char *str){
  1746. if (pp->LastPs->p->PropertyType == LA_PROP_STRING){
  1747. if (((laStringProp *)pp->LastPs->p)->Read) ((laStringProp *)pp->LastPs->p)->Read(pp->LastPs->UseInstance, str);
  1748. else
  1749. laSetString(pp, str);
  1750. laNotifyUsersPP(pp);
  1751. return 1;
  1752. }
  1753. return 0;
  1754. }
  1755. int laSetString(laPropPack *pp, char *str){
  1756. char **add = 0;
  1757. if (pp->LastPs->p->PropertyType == LA_PROP_STRING){
  1758. laStringProp *p = pp->LastPs->p;
  1759. if (p->Base.DetachedPP.LastPs){
  1760. strCopyFull(p->Detached, str);
  1761. laNotifyUsersPP(pp);
  1762. return 1;
  1763. }
  1764. if (p->Set){
  1765. p->Set(pp->LastPs->UseInstance, str);
  1766. laNotifyUsersPP(pp);
  1767. return 1;
  1768. }
  1769. if (!pp->LastPs->UseInstance) return 0;
  1770. if (p->IsSafeString){
  1771. add = ((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1772. strSafeSet(add, str);
  1773. laNotifyUsersPP(pp);
  1774. return 1;
  1775. }
  1776. if (p->Base.Offset){
  1777. if (p->Base.OffsetIsPointer){
  1778. add = ((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1779. if (!(*add)) return 0;
  1780. strCopyFull(*add, str);
  1781. }else strCopyFull(((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset), str);
  1782. }
  1783. laNotifyUsersPP(pp);
  1784. return 1;
  1785. }
  1786. return 0;
  1787. }
  1788. int laGetString(laPropPack *pp, char *result, char** direct_result){
  1789. if (pp->LastPs->p->PropertyType == LA_PROP_STRING){
  1790. laStringProp *p = pp->LastPs->p;
  1791. if (p->Base.DetachedPP.LastPs){
  1792. strCopyFull(result, p->Detached);
  1793. return 1;
  1794. }
  1795. if (!pp->LastPs->UseInstance) return 0;
  1796. if (p->Get){ p->Get(pp->LastPs->UseInstance, result, direct_result); return 1; }
  1797. if (pp->LastPs->p->Offset>=0){
  1798. if (p->IsSafeString){
  1799. laSafeString **add = ((laSafeString **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1800. //printf(" -- %s\n",p->Base.Identifier);
  1801. if ((!pp->LastPs->UseInstance) || (!*add)) return 0;
  1802. if((*add)->Ptr){ *direct_result = (*add)->Ptr; return 1;}
  1803. return 0;
  1804. }else{
  1805. if (pp->LastPs->p->OffsetIsPointer) *direct_result=*((char **)((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset));
  1806. else *direct_result=((BYTE *)pp->LastPs->UseInstance + pp->LastPs->p->Offset);
  1807. }
  1808. }
  1809. return 1;
  1810. }
  1811. return 0;
  1812. }
  1813. void *laGetInstance(laProp *sub, void *FromInstance, laPropIterator *Iter){
  1814. laSubProp *sp = sub;
  1815. laPropIterator IT = {0};
  1816. if (!Iter) Iter = &IT;
  1817. if (Iter) Iter->Parent = FromInstance;
  1818. if (sub->PropertyType == LA_PROP_SUB){
  1819. if (sp->Base.DetachedPP.LastPs){ if(sp->DetachedGet) return sp->DetachedGet(0, Iter);
  1820. return sp->Detached;
  1821. }
  1822. if (!FromInstance) return 0;
  1823. if (sp->Get) return sp->Get(FromInstance, Iter);
  1824. else if (sp->ListHandleOffset){
  1825. void *address = *((u64bit*)((BYTE *)FromInstance + sp->ListHandleOffset));
  1826. return address;
  1827. }else return laGetActiveInstance(sub, FromInstance, Iter);
  1828. }
  1829. return 0;
  1830. }
  1831. void *laGetNextInstance(laProp *sub, void *ThisInstance, laPropIterator *Iter){
  1832. laSubProp *sp = sub;
  1833. if (sub->PropertyType == LA_PROP_SUB){
  1834. if (sp->Base.DetachedPP.LastPs && sp->DetachedGetNext) return sp->DetachedGetNext(ThisInstance, Iter);
  1835. if (!ThisInstance) return 0;
  1836. if (sp->GetNext) return (sp->GetNext(ThisInstance, Iter));
  1837. else if (sp->ListHandleOffset){
  1838. laListItem *li = ThisInstance;
  1839. return li->pNext;
  1840. }
  1841. }
  1842. return 0;
  1843. }
  1844. void *laGetActiveInstanceStrict(laProp *sub, void *FromInstance){
  1845. laSubProp *sp = sub;
  1846. if (sub->PropertyType == LA_PROP_SUB){
  1847. if (sp->Base.DetachedPP.LastPs){
  1848. return sp->Detached;
  1849. }
  1850. if (!FromInstance) return 0;
  1851. if (sp->GetActive) return sp->GetActive(FromInstance, 0);
  1852. if (sub->Offset>=0){
  1853. if (sub->OffsetIsPointer /*&& (sp->Get||sp->ListHandleOffset)*/){
  1854. void **a = (void **)((BYTE *)FromInstance + sub->Offset); return *a;
  1855. }else return ((BYTE *)FromInstance + sub->Offset);
  1856. }
  1857. }
  1858. return 0; // laGetInstance(sub, FromInstance, 0);
  1859. }
  1860. void *laGetActiveInstance(laProp *sub, void *FromInstance, laPropIterator *Iter){
  1861. laSubProp *sp = sub;
  1862. if (sub->PropertyType == LA_PROP_SUB){
  1863. if (sp->Base.DetachedPP.LastPs){
  1864. return sp->Detached;
  1865. }
  1866. if (!FromInstance) return 0;
  1867. if (sp->GetActive) return sp->GetActive(FromInstance, Iter);
  1868. if (sp->Get) return laGetInstance(sub, FromInstance, Iter);
  1869. if (sub->Offset>=0){
  1870. if (sub->OffsetIsPointer){
  1871. void **a = (void **)((BYTE *)FromInstance + sub->Offset); return *a;
  1872. }else return ((BYTE *)FromInstance + sub->Offset);
  1873. }
  1874. }
  1875. return 0;
  1876. }
  1877. void laSetActiveInstance(laProp *sub, void *FromInstance, void *Instance){
  1878. laSubProp *sp = sub;
  1879. if (sub->PropertyType == LA_PROP_SUB){
  1880. MAIN._CONTAINER_SETTING=sub->Container;
  1881. MAIN._PROP_SETTING=sub;
  1882. if (sp->Base.DetachedPP.LastPs){
  1883. memAssignRef(sp, &sp->Detached, Instance);
  1884. laNotifySubPropUsers(sp, FromInstance);
  1885. return;
  1886. }
  1887. if (!FromInstance) return;
  1888. if (sp->SetState){
  1889. laNotifySubPropUsers(sp, FromInstance);
  1890. sp->SetState(FromInstance, Instance, LA_UI_ACTIVE);
  1891. }
  1892. if (sp->Set){
  1893. laNotifySubPropUsers(sp, FromInstance);
  1894. sp->Set(FromInstance, Instance);
  1895. }
  1896. if (sub->OffsetIsPointer && sub->Offset>=0){
  1897. void **a = (void **)((BYTE *)FromInstance + sub->Offset);
  1898. laNotifySubPropUsers(sp, FromInstance);
  1899. memAssignRefSafe(sub->Container->Hyper?sp:0,FromInstance, a, Instance);
  1900. }
  1901. }
  1902. return;
  1903. }
  1904. void laAppendInstance(laSubProp *sub, void *FromInstance, void *Instance){
  1905. if (sub->ListHandleOffset){
  1906. lstAppendItem((BYTE *)FromInstance + sub->ListHandleOffset, Instance);
  1907. }
  1908. }
  1909. void* laGetRaw(laPropPack *pp, int* r_size, int* return_is_a_copy){
  1910. if (pp->LastPs->p->PropertyType == LA_PROP_RAW){
  1911. laRawProp* rp=pp->LastPs->p;
  1912. if(rp->RawGet){ return rp->RawGet(pp->LastPs->UseInstance, r_size, return_is_a_copy); }
  1913. int s=rp->RawGetSize(pp->LastPs->UseInstance); void* data=0;
  1914. if(rp->Base.OffsetIsPointer){ data=*((void**)(((char*)pp->LastPs->UseInstance)+rp->Base.Offset)); }
  1915. else{ data=((char*)pp->LastPs->UseInstance)+rp->Base.Offset; }
  1916. *return_is_a_copy=0; if(r_size) *r_size=s;
  1917. return data;
  1918. } return 0;
  1919. }
  1920. int laSetRaw(laPropPack *pp, void* data, int _size){
  1921. if (pp->LastPs->p->PropertyType == LA_PROP_RAW){ laRawProp* rp=pp->LastPs->p;
  1922. if(rp->RawSet){ rp->RawSet(pp->LastPs->UseInstance, data, _size); return 1; }
  1923. if(rp->Base.OffsetIsPointer){ void** target=(((char*)pp->LastPs->UseInstance)+rp->Base.Offset); if(*target) free(*target);
  1924. void* newd=_size?calloc(1,_size):0; if(_size)memcpy(newd, data, _size); (*target)=newd;
  1925. }
  1926. else{ memcpy(((char*)pp->LastPs->UseInstance)+rp->Base.Offset,data,_size); }
  1927. return 1;
  1928. } return 0;
  1929. }
  1930. int laTryGetInstanceIdentifier(void* Instance, laPropContainer* pc, char* identifier, char** here){
  1931. if(!Instance || !pc) return 0;
  1932. laProp* p=la_PropLookupIdentifierItem(&pc->Props);
  1933. if(p){
  1934. laPropPack PP={0}; laPropStep PS={0};
  1935. PS.p=p; PS.Type='.'; PS.UseInstance=Instance; PP.LastPs=&PS; PP.EndInstance=Instance;
  1936. if(p->PropertyType==LA_PROP_STRING){ laGetString(&PP,identifier,here); }
  1937. elif(p->PropertyType&LA_PROP_INT){ int r[16]={0}; laGetIntArray(&PP,r); sprintf("(%s=%d)",p->Identifier,r[0]); }
  1938. elif(p->PropertyType&LA_PROP_FLOAT){ real r[16]={0}; laGetFloatArray(&PP,r); sprintf("(%s=%lf)",p->Identifier,r[0]); }
  1939. elif(p->PropertyType&LA_PROP_ENUM){ laEnumItem *r[16]={0}; laGetEnumArray(&PP,r); sprintf("(%s=%lf)",p->Identifier,r[0]?r[0]->Identifier:"?"); }
  1940. else{ sprintf("(%.6x)",identifier); }
  1941. return 1;
  1942. }
  1943. return 0;
  1944. }
  1945. int laGetIntRange(laPropPack *pp, int *min, int *max){
  1946. laIntProp *p = pp->LastPs->p;
  1947. if (p->Max != p->Min){
  1948. *min = p->Min;
  1949. *max = p->Max;
  1950. return 1;
  1951. }
  1952. return 0;
  1953. }
  1954. int laGetFloatRange(laPropPack *pp, real *min, real *max){
  1955. laFloatProp *p = pp->LastPs->p;
  1956. if (p->Max != p->Min){
  1957. *min = p->Min;
  1958. *max = p->Max;
  1959. return 1;
  1960. }
  1961. return 0;
  1962. }
  1963. int laCanGetState(laProp *sub){ laSubProp *sp = sub; if (sub->PropertyType == LA_PROP_SUB){ if (sp->GetState) return 1; } return 0; }
  1964. int laCanGetTheme(laProp *sub){ laSubProp *sp = sub; if (sub->PropertyType == LA_PROP_SUB){ if (sp->GetTheme) return 1; } return 0; }
  1965. int laCanGetGap(laProp *sub){ laSubProp *sp = sub; if (sub->PropertyType == LA_PROP_SUB){ if (sp->GetGap) return 1; } return 0; }
  1966. int laCanGetCategory(laProp *sub){ laSubProp *sp = sub; if (sub->PropertyType == LA_PROP_SUB){ if (sp->GetCategory) return 1; } return 0; }
  1967. int laGetUiState(laProp *sub, void *Instance){
  1968. laSubProp *sp = sub; if (sub->PropertyType == LA_PROP_SUB){ if (sp->GetState) return sp->GetState(Instance); } return 0;
  1969. }
  1970. laBoxedTheme* laGetUiTheme(laProp *sub, void* parent, void *Instance){
  1971. laSubProp *sp = sub; if (sub->PropertyType == LA_PROP_SUB){ if (sp->GetTheme) return sp->GetTheme(parent,Instance); } return 0;
  1972. }
  1973. int laGetUiGap(laProp *sub, void* parent, void *Instance){
  1974. laSubProp *sp = sub; if (sub->PropertyType == LA_PROP_SUB){ if (sp->GetGap) return sp->GetGap(parent,Instance); } return 0;
  1975. }
  1976. void laGetCategory(laProp *sub, void* parent, void *Instance, char* buf, char** buf_ptr){
  1977. laSubProp *sp = sub; if (sub->PropertyType == LA_PROP_SUB){ if (sp->GetCategory) sp->GetCategory(parent,Instance, buf, buf_ptr); }
  1978. }
  1979. int laSetState(laProp *sub, void *FromInstance, void *Instance, int State){
  1980. laSubProp *sp = sub;
  1981. if (sub->PropertyType == LA_PROP_SUB){
  1982. if (sp->SetState){
  1983. laNotifySubPropUsers(sub, FromInstance);
  1984. return sp->SetState(FromInstance, Instance, State);
  1985. }
  1986. }
  1987. return 0;
  1988. }
  1989. int laActuateProp(laPropPack *This, laPropPack *RunPP, laOperator *OptionalFrom, laEvent *e){
  1990. if (RunPP->LastPs->p->PropertyType & LA_PROP_OPERATOR){
  1991. if (!((laOperatorProp *)RunPP->LastPs->p)->OperatorType){
  1992. ((laOperatorProp *)RunPP->LastPs->p)->OperatorType = laGetOperatorType(((laOperatorProp *)RunPP->LastPs->p)->OperatorID);
  1993. }
  1994. return laInvokeP(OptionalFrom, ((laOperatorProp *)RunPP->LastPs->p)->OperatorType, e, This, 0, 0); //ARGS
  1995. }
  1996. }
  1997. void laMarkPropChanged(laPropPack* pp){
  1998. if(!pp) return;
  1999. if(!pp->Go){ if(pp->LastPs&&pp->LastPs->p->Container && pp->LastPs->p->Container->Hyper==2 && pp->LastPs->UseInstance){
  2000. laMemNodeHyper* m=memGetHead(pp->LastPs->UseInstance,0); m->Modified=1; } }
  2001. else for(laPropStep* ps=pp->Go;ps;ps=ps->pNext){
  2002. if(ps->Type=='.' && ps->p->Container->Hyper==2 && ps->UseInstance){
  2003. laMemNodeHyper* m=memGetHead(ps->UseInstance,0); m->Modified=1; }
  2004. }
  2005. laMarkPropChanged(pp->RawThis);
  2006. }
  2007. void laMarkMemChanged(void* memuser){
  2008. int level; laMemNodeHyper* m=memGetHead(memuser,&level); if(level!=2) return;
  2009. m->Modified=1;
  2010. }
  2011. void laMarkMemClean(void* memuser){
  2012. int level; laMemNodeHyper* m=memGetHead(memuser,&level); if(level!=2) return;
  2013. m->Modified=0;
  2014. }
  2015. laPropContainer *la_SetGeneralRoot(laPropContainer **GeneralRoot, const char *Identifier, const char *Name, const char *Description){
  2016. laPropContainer* ret =memAcquire(sizeof(laPropContainer));
  2017. *GeneralRoot = ret;
  2018. ret->Identifier = Identifier;
  2019. ret->Name = Name;
  2020. ret->Description = Description;
  2021. ret->OtherAlloc=1;
  2022. lstAppendItem(&MAIN.PropContainers, ret);
  2023. return ret;
  2024. }
  2025. void laSetRootInstance(void *root){
  2026. MAIN.DataRoot.RootInstance = root;
  2027. }
  2028. laPropContainer *laDefineRoot(){
  2029. if (!MAIN.DataRoot.Root) MAIN.DataRoot.Root = laAddPropertyContainer("root", "__ROOT__", "Root Node In NUL4.0 Data System", U'🞈', 0, 0, 0, 0, 2|LA_PROP_OTHER_ALLOC);
  2030. return MAIN.DataRoot.Root;
  2031. }
  2032. void laThrowToTrashBin(void *Data, char *ContainerString){
  2033. laPropContainer *pc = la_ContainerLookup(ContainerString);
  2034. lstAppendItem(&pc->TrashBin, Data);
  2035. }
  2036. int laValidateHyper2(laPropContainer* pc, laPropContainer* ParentHyper2, laSafeString** errors){
  2037. int pass=1;
  2038. for(laProp* p=pc->Props.pFirst;p;p=p->Item.pNext){
  2039. if(p->PropertyType!=LA_PROP_SUB) continue;
  2040. laSubProp* sp=p;
  2041. if(!p->SubProp && !sp->GetType){
  2042. p->SubProp=la_ContainerLookup(sp->TargetID);
  2043. if(!p->SubProp){
  2044. strSafePrint(errors, "Unable to locate property container \"%s\".\n", sp->TargetID); pass=0; continue; }
  2045. laPropContainer* spc=p->SubProp;
  2046. laPropContainer* sNoHyper2 = ParentHyper2;
  2047. if(!ParentHyper2){
  2048. if(pc->Hyper==2 && (!(p->UDFNoCreate||p->UDFIsRefer||p->UDFIsSingle))){
  2049. sNoHyper2=pc; }
  2050. }
  2051. if(sNoHyper2){
  2052. if(spc->Hyper==2 && !sp->Base.UDFIsRefer){ strSafePrint(errors,\
  2053. "Hyper2 list (\"%s\") under another Hyper2 container (\"%s\") is not allowed.\n",
  2054. sp->TargetID, sNoHyper2->Identifier); pass=0; }
  2055. }
  2056. if(!laValidateHyper2(p->SubProp, sNoHyper2, errors)){pass=0;}
  2057. if(ParentHyper2) ParentHyper2->validated=1;
  2058. }
  2059. }
  2060. return pass;
  2061. }
  2062. int laValidateProperties(){
  2063. laSafeString* errors=0; int pass=1;
  2064. for(laPropContainer* pc=MAIN.PropContainers.pFirst;pc;pc=pc->Item.pNext){
  2065. if(pc->validated){continue;}
  2066. if(!laValidateHyper2(pc, 0, &errors)){ pass=0; }
  2067. pc->validated=1;
  2068. }
  2069. if(!pass){
  2070. printf("laValidateHyper2 Failed:\n"); printf(errors->Ptr);
  2071. }
  2072. return pass;
  2073. }
  2074. //==================================[RW]
  2075. void la_GetWorkingDirectoryInternal(){
  2076. char mbuf[2048]; getcwd(mbuf,2048);
  2077. int len=strlen(mbuf);if(mbuf[len]!=LA_PATH_SEP){ mbuf[len]=LA_PATH_SEP; mbuf[len+1]=0; }
  2078. strSafeSet(&MAIN.WorkingDirectory, mbuf);
  2079. }
  2080. int laGetRelativeDirectory(char *FullFrom, char *FullTo, char *Result){
  2081. return 0;
  2082. //WIN32_FIND_DATA fd;
  2083. //HANDLE h;
  2084. //char *PathFrom = 0, *PathTo = 0;
  2085. //char FullFromP[1024], FullToP[1024]={0};
  2086. //char *FileNameOnly = 0;
  2087. //int seg, i;
  2088. //
  2089. //Result[0] = 0;
  2090. //
  2091. //if (!FullFrom || !FullTo || FullFrom[0] != FullTo[0])
  2092. // return 0;
  2093. //
  2094. //strcpy(FullFromP, FullFrom);
  2095. //strcpy(FullToP, FullTo);
  2096. //
  2097. //while (h = FindFirstFile(FullFromP, &fd))
  2098. //{
  2099. // if (h == INVALID_HANDLE_VALUE || (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)))
  2100. // {
  2101. // strDiscardLastSegmentSeperateBy(FullFromP, '/');
  2102. // continue;
  2103. // }
  2104. // break;
  2105. //}
  2106. //
  2107. //while (h = FindFirstFile(FullToP, &fd))
  2108. //{
  2109. // if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
  2110. // {
  2111. // FileNameOnly = strGetLastSegment(FullToP, '/');
  2112. // strDiscardLastSegmentSeperateBy(FullToP, '/');
  2113. // continue;
  2114. // }
  2115. // elif (h == INVALID_HANDLE_VALUE)
  2116. // {
  2117. // strDiscardLastSegmentSeperateBy(FullToP, '/');
  2118. // continue;
  2119. // }
  2120. // break;
  2121. //}
  2122. //
  2123. //strDiscardSameBeginningSeperatedBy(FullFromP, FullToP, &PathFrom, &PathTo, '/');
  2124. //
  2125. //seg = strCountSegmentSeperateBy(PathFrom, '/');
  2126. //
  2127. //for (i = 0; i < seg; i++)
  2128. //{
  2129. // strcat(Result, "../");
  2130. //}
  2131. //
  2132. //strcat(Result, PathTo);
  2133. //
  2134. //if (FileNameOnly)
  2135. //{
  2136. // strcat(Result, "/");
  2137. // strcat(Result, FileNameOnly);
  2138. //}
  2139. //
  2140. //return 1;
  2141. }
  2142. void laGetUDFRelativeDirectory(laUDF *From, laUDF *To, char *Result){
  2143. if (!From || !To) return;
  2144. laGetRelativeDirectory(From->FileName->Ptr, To->FileName->Ptr, Result);
  2145. }
  2146. void laGetFullPath(char *FullFrom, char *Relative, char *Result){
  2147. //WIN32_FIND_DATA fd;
  2148. //HANDLE h;
  2149. //char *PathFrom = 0, *PathTo = 0;
  2150. //char FullFromP[1024] = {0};
  2151. //int seg, i;
  2152. //
  2153. //Result[0] = 0;
  2154. //
  2155. //if (!FullFrom)
  2156. // return 0;
  2157. //
  2158. //strcpy(FullFromP, FullFrom);
  2159. //
  2160. //while (h = FindFirstFile(FullFromP, &fd))
  2161. //{
  2162. // if (h == INVALID_HANDLE_VALUE || (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)))
  2163. // {
  2164. // strDiscardLastSegmentSeperateBy(FullFromP, '/');
  2165. // continue;
  2166. // }
  2167. // break;
  2168. //}
  2169. //strcpy(Result, FullFromP);
  2170. ////strcat(Result, "/");
  2171. //strcat(Result, Relative);
  2172. }
  2173. laUDF *laPrepareUDF(char *FileName){
  2174. laUDF *udf = memAcquire(sizeof(laUDF));
  2175. strSafeSet(&udf->FileName, FileName);
  2176. return udf;
  2177. }
  2178. int laWriteProp(laUDF *udf, char *Path){
  2179. laUDFPropSegment *ps = CreateNew(laUDFPropSegment);
  2180. strSafeSet(&ps->Path, Path);
  2181. la_GetPropFromPath(&ps->PP, 0, Path, 0);
  2182. la_StepPropPack(&ps->PP);
  2183. lstAppendItem(&udf->PropsToOperate, ps);
  2184. udf->NumSegmets++;
  2185. }
  2186. int laWritePropP(laUDF *udf, laPropPack *pp){
  2187. char buf[LA_RAW_CSTR_MAX_LEN] = {0};
  2188. laUDFPropSegment *ps = CreateNew(laUDFPropSegment);
  2189. ps->PPP = pp;
  2190. udf->NumSegmets++;
  2191. //la_GetPropPackFullPath(pp, Buf);
  2192. //strSafeSet(&ps->Path, Buf);
  2193. lstAppendItem(&udf->PropsToOperate, ps);
  2194. }
  2195. int la_IncludeHyper2Instance(laUDF *udf, laPropContainer* pc, void* Instance){
  2196. laUDFH2Instance *h2 = memAcquire(sizeof(laUDFH2Instance));
  2197. h2->pc=pc; h2->Instance = Instance;
  2198. lstAppendItem(&udf->H2Instances, h2);
  2199. udf->HasInstances=1;
  2200. }
  2201. int la_ClearHyper2Instances(laUDF* udf){
  2202. laUDFH2Instance *h2;
  2203. while(h2=lstPopItem(&udf->H2Instances)){ memFree(h2); }
  2204. udf->HasInstances=0;
  2205. }
  2206. //void la_UDFAppendPointerRecord(void* UseInstance, laSubProp* p, void** PendingReference,void* ReadInstance) {
  2207. // //laUDFPointerRecord* upr = &MAIN.PendingPointers[MAIN.NextPendingPointer];
  2208. // //if (!ReadInstance) return;
  2209. // //upr->ReadInstance = ReadInstance;
  2210. // //upr->PendingReference = PendingReference;
  2211. // //upr->SubProp = p;
  2212. // //upr->UseInstance = UseInstance;
  2213. // //MAIN.NextPendingPointer++;
  2214. //}
  2215. //void la_UDFAppendNUIDRecord(void* UseInstance, laSubProp* p, void** PendingReference, char * ReadNUID) {
  2216. // //laUDFPointerRecord* upr = &MAIN.PendingPointers[MAIN.NextPendingPointer];
  2217. // //if (!ReadNUID) return;
  2218. // //upr->NUID = CreateNewBuffer(char, 23);
  2219. // //strcpy(upr->NUID, ReadNUID);
  2220. // //upr->PendingReference = PendingReference;
  2221. // //upr->SubProp = p;
  2222. // //upr->UseInstance = UseInstance;
  2223. // //MAIN.NextPendingPointer++;
  2224. //}
  2225. //void la_UDFAppendPointerSync(void* ReadInstance, void* ActualInstance) {
  2226. // //laUDFPointerSync* ups = CreateNew(laUDFPointerSync);
  2227. // //ups->ReadPointer = ReadInstance;
  2228. // //ups->ActualPointer = ActualInstance;
  2229. // //hsh65536InsertItem(&MAIN.PointerSync, ups, ReadInstance);
  2230. //}
  2231. //void la_UDFAppendNUIDSync(char * ReadNUID, void* ActualInstance) {
  2232. // //laUDFPointerSync* ups = CreateNew(laUDFPointerSync);
  2233. // //ups->NUID = CreateNewBuffer(char, 23);
  2234. // //memcpy(ups->NUID, ReadNUID,sizeof(char)*23);
  2235. // //ups->ActualPointer = ActualInstance;
  2236. // //hsh65536InsertItem(&MAIN.PointerSync, ups, (long)ReadNUID[15]);
  2237. //}
  2238. void la_UDFAppendSharedTypePointer(char *ID, void *Pointer){
  2239. laSharedTypeItem *sti = memAcquireSimple(sizeof(laSharedTypeItem));
  2240. strCopyFull(sti->ID, ID);
  2241. sti->Pointer = Pointer;
  2242. lstAppendItem(&MAIN.SharedTypePointerSync, sti);
  2243. }
  2244. #define la_UseUDF(udf) udf->Used = 1
  2245. u64bit la_Tell(laUDF *udf){
  2246. if (udf->DiskFile) return ftell(udf->DiskFile);
  2247. else return udf->Seek;
  2248. }
  2249. int la_Seek(laUDF *udf, u64bit Offset){
  2250. if (udf->DiskFile) return fseek(udf->DiskFile, Offset, SEEK_SET);
  2251. udf->Seek = Offset;
  2252. return 1;
  2253. }
  2254. u64bit la_FileSize(laUDF* udf){
  2255. if(udf->DiskFile){ u64bit a=ftell(udf->DiskFile); fseek(udf->DiskFile,0,SEEK_END); u64bit sz=ftell(udf->DiskFile); fseek(udf->DiskFile,a,SEEK_SET); return sz; }
  2256. return udf->FileContentSize;
  2257. }
  2258. void la_WriteString(laUDF *udf, char *String){
  2259. short size = strlen(String);
  2260. fwrite(&size, sizeof(short), 1, udf->DiskFile);
  2261. if (size) fwrite(String, size*sizeof(char), 1, udf->DiskFile);
  2262. }
  2263. void la_WriteOnlyString(laUDF *udf, char *String){
  2264. fwrite(String, strlen(String), 1, udf->DiskFile);
  2265. }
  2266. void la_WriteOnlyMBString(laUDF *udf, char *String){
  2267. fwrite(String, strlen(String), 1, udf->DiskFile);
  2268. }
  2269. void la_WriteInt(laUDF *udf, int Data){
  2270. fwrite(&Data, sizeof(int), 1, udf->DiskFile);
  2271. }
  2272. void la_WriteUByte(laUDF *udf, unsigned char Data){
  2273. fwrite(&Data, sizeof(unsigned char), 1, udf->DiskFile);
  2274. }
  2275. void la_WriteShort(laUDF *udf, short Data){
  2276. fwrite(&Data, sizeof(short), 1, udf->DiskFile);
  2277. }
  2278. void la_WriteLong(laUDF *udf, u64bit Data){
  2279. fwrite(&Data, sizeof(u64bit), 1, udf->DiskFile);
  2280. }
  2281. void la_WritePointer(laUDF *udf, void *Data){
  2282. fwrite(&Data, sizeof(void *), 1, udf->DiskFile);
  2283. }
  2284. void la_WriteFloat(laUDF *udf, real Data){
  2285. fwrite(&Data, sizeof(real), 1, udf->DiskFile);
  2286. }
  2287. void la_WriteSized(laUDF *udf, void* Data, int size){
  2288. printf("%x %d\n",Data,size);
  2289. fwrite(Data, size, 1, udf->DiskFile);
  2290. }
  2291. short la_ReadShort(laUDF *udf){
  2292. short result;
  2293. if(!udf->FileContent){ fread(&result, sizeof(short), 1, udf->DiskFile); }
  2294. else{ memcpy(&result, udf->FileContent + udf->Seek, sizeof(short)); udf->Seek += sizeof(short); }
  2295. return result;
  2296. }
  2297. u8bit la_ReadUByte(laUDF *udf){
  2298. u8bit result;
  2299. if(!udf->FileContent){ fread(&result, sizeof(u8bit), 1, udf->DiskFile); }
  2300. else{ memcpy(&result, udf->FileContent + udf->Seek, sizeof(u8bit)); udf->Seek += sizeof(u8bit); }
  2301. return result;
  2302. }
  2303. int la_ReadInt(laUDF *udf){
  2304. int result;
  2305. if(!udf->FileContent){ fread(&result, sizeof(int), 1, udf->DiskFile); }
  2306. else{ memcpy(&result, udf->FileContent + udf->Seek, sizeof(int)); udf->Seek += sizeof(int); }
  2307. return result;
  2308. }
  2309. u64bit la_ReadLong(laUDF *udf){
  2310. u64bit result;
  2311. if(!udf->FileContent){ fread(&result, sizeof(u64bit), 1, udf->DiskFile); }
  2312. else{ memcpy(&result, udf->FileContent + udf->Seek, sizeof(u64bit)); udf->Seek += sizeof(u64bit); }
  2313. return result;
  2314. }
  2315. void *la_ReadPointer(laUDF *udf){
  2316. u64bit result = 0;
  2317. if(!udf->FileContent){ fread(&result, sizeof(u64bit), 1, udf->DiskFile); }
  2318. else{ memcpy(&result, udf->FileContent + udf->Seek, sizeof(u64bit)); udf->Seek += sizeof(u64bit); }
  2319. return (void *)result;
  2320. }
  2321. real la_ReadFloat(laUDF *udf){
  2322. real result;
  2323. if(!udf->FileContent){ fread(&result, sizeof(real), 1, udf->DiskFile); }
  2324. else{ memcpy(&result, udf->FileContent + udf->Seek, sizeof(real)); udf->Seek += sizeof(real); }
  2325. return result;
  2326. }
  2327. void la_ReadString(laUDF *udf, char *buffer){
  2328. short len = la_ReadShort(udf);
  2329. if (len){
  2330. if(!udf->FileContent){ fread(buffer, sizeof(char) * len, 1, udf->DiskFile); }
  2331. else{ memcpy(buffer, udf->FileContent + udf->Seek, sizeof(char) * len); udf->Seek += sizeof(char) * len; }
  2332. }
  2333. buffer[len] = 0;
  2334. }
  2335. void la_ReadOnlyString(laUDF *udf, short len, char *buffer){
  2336. if(!udf->FileContent){ fread(buffer, sizeof(char) * len, 1, udf->DiskFile); }
  2337. else{ memcpy(buffer, udf->FileContent + udf->Seek, sizeof(char) * len); udf->Seek += sizeof(char) * len; }
  2338. buffer[len] = 0;
  2339. }
  2340. void la_ReadHyperData(laUDF *udf, void* HyperUserMem){
  2341. short NumUsers, i;
  2342. //void *CreatorInstance = la_ReadLong(udf);
  2343. laMemNodeHyper h_ = {0};
  2344. laMemNodeHyper *h=HyperUserMem?memGetHead(HyperUserMem, 0):&h_;
  2345. //la_UDFAppendPointerRecord(0, 0, &h->CreatedBy,CreatorInstance);
  2346. la_ReadString(udf, h->NUID.String);
  2347. h->TimeCreated.Year = la_ReadShort(udf);
  2348. h->TimeCreated.Month = la_ReadUByte(udf);
  2349. h->TimeCreated.Day = la_ReadUByte(udf);
  2350. h->TimeCreated.Hour = la_ReadUByte(udf);
  2351. h->TimeCreated.Minute = la_ReadUByte(udf);
  2352. h->TimeCreated.Second = la_ReadUByte(udf);
  2353. }
  2354. void la_PeekHyperUID(laUDF *udf, char* buf){
  2355. int pos=la_Tell(udf);
  2356. la_ReadString(udf, buf);
  2357. la_Seek(udf, pos);
  2358. }
  2359. void la_ReadBuffer(laUDF *udf, u64bit Size, void *Result){
  2360. if(!udf->FileContent){ fread(Result, Size, 1, udf->DiskFile); }
  2361. else{ memcpy(Result, udf->FileContent + udf->Seek, Size); udf->Seek += Size; }
  2362. }
  2363. void* la_ReadRaw(laUDF *udf, int* _sz){
  2364. int _size = la_ReadInt(udf);
  2365. if(_sz){
  2366. if (_size){
  2367. void* data=calloc(1,_size);
  2368. la_ReadBuffer(udf, _size, data);
  2369. if(_sz) *_sz=_size;
  2370. return data;
  2371. } return 0;
  2372. }else{
  2373. la_Seek(udf, la_Tell(udf)+_size); return 0;
  2374. }
  2375. }
  2376. void la_WriteSingleProperty(laUDF *udf, void *FromInstance, laProp *p){
  2377. la_WriteString(udf, p->Identifier);
  2378. }
  2379. void la_GetPropPackFullPath(laPropPack *pp, char *result){
  2380. char buf[1024], upbuf[1024]={0}; if(!pp){result[0]=0; return;}
  2381. laPropStep *ps;
  2382. buf[0] = U'\0';
  2383. upbuf[0] = 0;
  2384. if (pp->Go){
  2385. for (ps = pp->Go; ps; ps = ps->pNext){
  2386. //if (!ps->p||!ps->p->Identifier) strcat(buf, "?");
  2387. if(ps->Type=='.') strcat(buf, ps->p->Identifier);
  2388. if(ps->Type=='#' ||ps->Type=='@' ||ps->Type=='=') {char b2[2]={0}; b2[0]= ps->Type; strcat(buf, b2); strcat(buf, ps->p);}
  2389. if (ps->pNext && ps->pNext->Type=='.') strcat(buf, ".");
  2390. }
  2391. }else{
  2392. if(pp->LastPs){ if(pp->LastPs->p->Identifier) strcat(buf, pp->LastPs->p->Identifier); else { strcat(buf,"?"); } }
  2393. if (pp->RawThis && pp->RawThis->LastPs->p != pp->LastPs->p) strcat(buf, pp->LastPs->p->Identifier);
  2394. }
  2395. if (pp->RawThis){
  2396. la_GetPropPackFullPath(pp->RawThis, upbuf);
  2397. if (pp->RawThis->LastPs->p != pp->LastPs->p) strcat(upbuf, ".");
  2398. strcat(upbuf, buf);
  2399. strCopyFull(result, upbuf);
  2400. }else
  2401. strCopyFull(result, buf);
  2402. }
  2403. void la_GetPropPackPath(laPropPack *pp, char *result){
  2404. char buf[1024], upbuf[1024]={0};
  2405. laPropStep *ps;
  2406. buf[0] = U'\0';
  2407. upbuf[0] = 0;
  2408. char Sep[2] = {0};
  2409. for (ps = pp->Go; ps; ps = ps->pNext){
  2410. if (!ps->p->Identifier) break;
  2411. if (ps->Type == U'.' || !ps->Type) strcat(buf, ps->p->Identifier);
  2412. else
  2413. strcat(buf, ps->p);
  2414. if (ps->pNext) strcat(buf, (Sep[0] = ((laPropStep *)ps->pNext)->Type) ? Sep : ".");
  2415. }
  2416. strCopyFull(result, buf);
  2417. }
  2418. int la_ReadIntProp(laUDF *udf, laPropPack *pp){
  2419. laProp *p;
  2420. int Data[16] = {0};
  2421. int len = 0;
  2422. int i;
  2423. if (!pp){
  2424. int mode = la_ReadShort(udf);
  2425. if (mode == LA_UDF_ARRAY_MARK_32){
  2426. len = la_ReadShort(udf);
  2427. for (i = 0; i < len; i++)
  2428. la_ReadInt(udf);
  2429. }else
  2430. Data[0] = la_ReadInt(udf);
  2431. return Data[0];
  2432. }
  2433. p = pp->LastPs->p;
  2434. short mark=la_ReadShort(udf);
  2435. if(mark==LA_UDF_ARRAY_MARK_64 || mark==LA_UDF_ARRAY_MARK_32){ len = la_ReadShort(udf);
  2436. for(i=0;i<len;i++){ Data[i] = la_ReadInt(udf); }
  2437. }else{
  2438. Data[0] = la_ReadInt(udf);
  2439. }
  2440. if (p->PropertyType & LA_PROP_ARRAY){
  2441. if (pp) laReadIntArrayAllArray(pp, Data);
  2442. }else{
  2443. if (pp) laReadInt(pp, Data[0]);
  2444. }
  2445. return Data[0];
  2446. }
  2447. real la_ReadFloatProp(laUDF *udf, laPropPack *pp){
  2448. laProp *p;
  2449. real Data[16] = {0};
  2450. int len = 0; int i;
  2451. if (!pp){
  2452. int mode = la_ReadShort(udf);
  2453. if (mode == LA_UDF_ARRAY_MARK_64){
  2454. len = la_ReadShort(udf);
  2455. for (i = 0; i < len; i++)
  2456. la_ReadFloat(udf);
  2457. }else
  2458. Data[0] = la_ReadFloat(udf);
  2459. return Data[0];
  2460. }
  2461. p = pp->LastPs->p;
  2462. short mark=la_ReadShort(udf);
  2463. if(mark==LA_UDF_ARRAY_MARK_64 || mark==LA_UDF_ARRAY_MARK_32){ len = la_ReadShort(udf);
  2464. for(i=0;i<len;i++){ Data[i] = la_ReadFloat(udf); }
  2465. }else{
  2466. Data[0] = la_ReadFloat(udf);
  2467. }
  2468. if (p->PropertyType & LA_PROP_ARRAY){
  2469. if (pp) laReadFloatArrayAllArray(pp, Data);
  2470. }else{
  2471. if (pp) laReadFloat(pp, Data[0]);
  2472. }
  2473. return Data[0];
  2474. }
  2475. void la_ReadStringProp(laUDF *udf, laPropPack *pp){
  2476. char buf[LA_RAW_CSTR_MAX_LEN]={0}; //XXX: long string not correct...
  2477. int len = 0;
  2478. int i;
  2479. buf[0] = 0;
  2480. la_ReadShort(udf);
  2481. la_ReadString(udf, buf);
  2482. if (pp) laReadString(pp, buf);
  2483. }
  2484. void la_ReadStringPropAsIdentifier(laUDF *udf, char *buf){
  2485. //char buf[LA_RAW_CSTR_MAX_LEN]={0};
  2486. int len = 0;
  2487. int i;
  2488. buf[0] = 0;
  2489. la_ReadShort(udf);
  2490. la_ReadString(udf, buf);
  2491. }
  2492. void la_WriteIntProp(laUDF *udf, laPropPack *pp){
  2493. laProp *p = pp->LastPs->p;
  2494. int Data[16] = {0};
  2495. int len = 0;
  2496. int i;
  2497. if (p->PropertyType & LA_PROP_ARRAY){
  2498. la_WriteShort(udf, LA_UDF_ARRAY_MARK_32);
  2499. laGetIntArray(pp, Data);
  2500. len = laGetArrayLength(pp);
  2501. la_WriteShort(udf, len);
  2502. for (i = 0; i < len; i++){
  2503. la_WriteInt(udf, Data[i]);
  2504. }
  2505. }else{
  2506. la_WriteShort(udf, LA_UDF_REGULAR_MARK_32);
  2507. Data[0] = laGetInt(pp);
  2508. la_WriteInt(udf, Data[0]);
  2509. }
  2510. }
  2511. void la_WriteFloatProp(laUDF *udf, laPropPack *pp){
  2512. laProp *p = pp->LastPs->p;
  2513. real Data[16] = {0};
  2514. int len = 0;
  2515. int i;
  2516. if (p->PropertyType & LA_PROP_ARRAY){
  2517. la_WriteShort(udf, LA_UDF_ARRAY_MARK_64);
  2518. laGetFloatArray(pp, Data);
  2519. len = laGetArrayLength(pp);
  2520. la_WriteShort(udf, len);
  2521. for (i = 0; i < len; i++){
  2522. la_WriteFloat(udf, Data[i]);
  2523. }
  2524. }else{
  2525. la_WriteShort(udf, LA_UDF_REGULAR_MARK_64);
  2526. Data[0] = laGetFloat(pp);
  2527. la_WriteFloat(udf, Data[0]);
  2528. }
  2529. }
  2530. void la_WriteStringProp(laUDF *udf, laPropPack *pp){
  2531. laProp *p = pp->LastPs->p;
  2532. char _buf[LA_RAW_CSTR_MAX_LEN]={0}; char* buf=_buf;
  2533. int len = 0;
  2534. int i;
  2535. buf[0] = 0;
  2536. la_WriteShort(udf, LA_UDF_STRING_MARK);
  2537. laGetString(pp, _buf, &buf);
  2538. la_WriteString(udf, buf);
  2539. }
  2540. void la_ReadEnumProp(laUDF *udf, laPropPack *pp, char* orig_string){
  2541. laProp *p;
  2542. int Data[16] = {0};
  2543. int len = 0;
  2544. int i;
  2545. char buf[LA_RAW_CSTR_MAX_LEN]={0};
  2546. if (!pp){
  2547. int mode = la_ReadShort(udf);
  2548. if (mode == LA_UDF_ARRAY_MARK_32){
  2549. len = la_ReadShort(udf);
  2550. for (i = 0; i < len; i++)
  2551. la_ReadString(udf, buf); //la_ReadInt(udf);
  2552. }else
  2553. la_ReadString(udf, buf); //la_ReadInt(udf);
  2554. if(orig_string)strcpy(orig_string, buf);
  2555. return;
  2556. }
  2557. p = pp->LastPs->p;
  2558. if (p->PropertyType & LA_PROP_ARRAY){
  2559. la_ReadShort(udf);
  2560. len = la_ReadShort(udf);
  2561. for (i = 0; i < len; i++){
  2562. la_ReadString(udf, buf);
  2563. Data[i] = laGetEnumFromIdentifier(p, buf)->Index;
  2564. //Data[i] = la_ReadInt(udf);
  2565. }
  2566. if (pp) laReadEnumArrayAll(pp, Data);
  2567. }else{
  2568. la_ReadShort(udf);
  2569. la_ReadString(udf, buf);
  2570. Data[0] = laGetEnumFromIdentifier(p, buf)->Index;
  2571. //Data[0] = la_ReadInt(udf);
  2572. if (pp) laReadEnum(pp, Data[0]);
  2573. }
  2574. }
  2575. void la_WriteEnumProp(laUDF *udf, laPropPack *pp){
  2576. laProp *p = pp->LastPs->p;
  2577. laEnumItem *Data[16] = {0};
  2578. int len = 0;
  2579. int i;
  2580. if (p->PropertyType & LA_PROP_ARRAY){
  2581. la_WriteShort(udf, (LA_UDF_ARRAY_MARK_32 | LA_UDF_STRING_MARK));
  2582. laGetEnumArray(pp, Data);
  2583. len = laGetArrayLength(pp);
  2584. la_WriteShort(udf, len);
  2585. for (i = 0; i < len; i++){
  2586. la_WriteString(udf, Data[i]->Identifier);
  2587. //la_WriteInt(udf, Data[i]->Index);
  2588. }
  2589. }else{
  2590. la_WriteShort(udf, LA_UDF_STRING_MARK);
  2591. Data[0] = laGetEnum(pp);
  2592. la_WriteString(udf, Data[0]->Identifier);
  2593. //la_WriteInt(udf, Data[0]->Index);
  2594. }
  2595. }
  2596. void la_ReadRawProp(laUDF *udf, laPropPack *pp){
  2597. la_ReadShort(udf);//mark
  2598. if (pp) {
  2599. int _size=0;
  2600. void* data=la_ReadRaw(udf,&_size);
  2601. laSetRaw(pp, data, _size); free(data);
  2602. }else{
  2603. la_ReadRaw(udf,0);
  2604. }
  2605. }
  2606. void la_WriteRawProp(laUDF *udf, laPropPack *pp){
  2607. laProp *p = pp->LastPs->p;
  2608. void* data; int _size=0, IsCopy=0;
  2609. data=laGetRaw(pp, &_size, &IsCopy);
  2610. la_WriteShort(udf, LA_UDF_RAW_MARK);
  2611. if(!data){ _size=0; }
  2612. la_WriteInt(udf,_size);
  2613. if(_size){ la_WriteSized(udf,data,_size); }
  2614. if(IsCopy && data){ free(data); }
  2615. }
  2616. void la_WriteHyperData(laUDF *udf, void *HyperUserMem){
  2617. int loc = 0, res = 0, i = 0;
  2618. laItemUserLinker *iul;
  2619. laMemNodeHyper* h=memGetHead(HyperUserMem, 0);
  2620. //la_WriteLong(udf, h->CreatedBy);
  2621. la_WriteString(udf, h->NUID.String);
  2622. la_WriteShort(udf, h->TimeCreated.Year);
  2623. la_WriteUByte(udf, h->TimeCreated.Month);
  2624. la_WriteUByte(udf, h->TimeCreated.Day);
  2625. la_WriteUByte(udf, h->TimeCreated.Hour);
  2626. la_WriteUByte(udf, h->TimeCreated.Minute);
  2627. la_WriteUByte(udf, h->TimeCreated.Second);
  2628. }
  2629. laSharedTypeItem *la_ReferringToSharedResource(void *p){
  2630. laSharedTypeItem *sti;
  2631. for (sti = MAIN.SharedTypePointerSync.pFirst; sti; sti = sti->Item.pNext){
  2632. if (sti->Pointer == p)
  2633. return sti;
  2634. }
  2635. return 0;
  2636. }
  2637. void *la_FindSharedResouce(char *id){
  2638. laSharedTypeItem *sti;
  2639. for (sti = MAIN.SharedTypePointerSync.pFirst; sti; sti = sti->Item.pNext){
  2640. if (strSame(id, sti->ID))
  2641. return sti->Pointer;
  2642. }
  2643. return 0;
  2644. }
  2645. void la_AppendHyperRecord(laUDF *udf, void *HyperUserMem, laPropContainer* pc, u64bit Seek){
  2646. // this happens when theres a type{base{} ... } like tnsobject, should not be problematic...?
  2647. if(lstHasPointer(&udf->HyperRecords, HyperUserMem)) return;
  2648. laUDFHyperRecordItem *hri = lstAppendPointerSized(&udf->HyperRecords, HyperUserMem, sizeof(laUDFHyperRecordItem));
  2649. hri->Seek = Seek;
  2650. hri->pc = pc;
  2651. }
  2652. void* la_NextH2Instance(laUDF* udf){
  2653. udf->CurrentH2Instance=(udf->CurrentH2Instance?udf->CurrentH2Instance->Item.pNext:0);
  2654. }
  2655. int la_WriteProp(laUDF *udf, laPropPack *pp, int FromThis, int UseInstanceList){
  2656. laProp *p = pp->LastPs->p, *subp = 0;
  2657. laPropStep SubPS = {0};
  2658. laPropPack SubPP = {0};
  2659. laPropIterator pi = {0};
  2660. laSharedTypeItem *sti;
  2661. laMemNodeHyper *hi;
  2662. void *inst = 0;
  2663. u64bit pReserve = 0, pContinue = 0;
  2664. int ItemNum = 0, PropNum = 0;
  2665. int counted = 0;
  2666. u64bit pEachCount;
  2667. SubPP.LastPs = &SubPS;
  2668. if (p->PropertyType == LA_PROP_OPERATOR) return 0;
  2669. if ((!pp->RawThis) || FromThis){
  2670. char FullPath[1024]={0};
  2671. FullPath[0] = 0;
  2672. la_GetPropPackFullPath(pp, FullPath);
  2673. la_WriteString(udf, FullPath);
  2674. }else{
  2675. la_WriteString(udf, p->Identifier);
  2676. }
  2677. switch (p->PropertyType){
  2678. case LA_PROP_SUB:
  2679. if (p->UDFIsRefer){
  2680. inst = laGetActiveInstanceStrict(p, pp->LastPs->UseInstance);
  2681. if (sti = la_ReferringToSharedResource(inst)){
  2682. la_WriteShort(udf, LA_UDF_SHARE_RESOURCE);
  2683. la_WriteString(udf, sti->ID);
  2684. }else{
  2685. if (!p->SubProp){
  2686. p->SubProp = la_ContainerLookup(((laSubProp *)p)->TargetID);
  2687. }
  2688. if (p->SubProp->Hyper == 2){
  2689. la_WriteShort(udf, LA_UDF_REFER | LA_UDF_HYPER_ITEM);
  2690. if (!inst) la_WriteString(udf, "");
  2691. else
  2692. la_WriteString(udf, ((laMemNodeHyper *)memGetHead(inst,0))->NUID.String);
  2693. udf->TotalRefs++;
  2694. }else{
  2695. la_WriteShort(udf, LA_UDF_REFER);
  2696. la_WritePointer(udf, inst);
  2697. }
  2698. pp->EndInstance = inst;
  2699. }
  2700. udf->TotalRefs++;
  2701. }else{
  2702. la_EnsureSubTarget(p,0);
  2703. la_WriteShort(udf, LA_UDF_COLLECTION);
  2704. pReserve = la_Tell(udf); la_WriteInt(udf, 0); //num items
  2705. if (((laSubProp*)p)->GetType) la_WriteInt(udf, LA_UDF_VARIABLE_NODE_SIZE);
  2706. else la_WriteInt(udf, LA_UDF_FIXED_NODE_SIZE);
  2707. la_WriteShort(udf, LA_UDF_ACTIVE);
  2708. la_WritePointer(udf, laGetActiveInstance(p, pp->LastPs->UseInstance, &pi));
  2709. if (FromThis){
  2710. inst = pp->EndInstance;
  2711. }else{
  2712. inst = laGetInstance(p, pp->LastPs->UseInstance, &pi);
  2713. pp->EndInstance = inst;
  2714. }
  2715. while (inst){
  2716. if(((laSubProp*)p)->SaveFilter && (!((laSubProp*)p)->SaveFilter(pp->LastPs->UseInstance, inst))){
  2717. inst = laGetNextInstance(p, inst, &pi); pp->EndInstance = inst; continue;
  2718. }
  2719. laPropContainer* pc=p->SubProp; int need_type=0;
  2720. if (((laSubProp*)p)->GetType){ pc=((laSubProp*)p)->GetType(inst); need_type=1; }
  2721. if (pc->Hyper == 2){
  2722. void* compare=udf->CurrentH2Instance?udf->CurrentH2Instance->Instance:0;
  2723. if((!p->UDFIsSingle) && UseInstanceList && inst!=compare){
  2724. inst = laGetNextInstance(p, inst, &pi); pp->EndInstance = inst; continue;}
  2725. if(need_type){ la_WriteString(udf, pc->Identifier); }
  2726. hi = inst;
  2727. la_WriteShort(udf, LA_UDF_HYPER_ITEM);
  2728. la_AppendHyperRecord(udf, inst, p->SubProp, la_Tell(udf));
  2729. la_WriteHyperData(udf, inst);
  2730. memMarkClean(inst);
  2731. }else{
  2732. if(need_type){ la_WriteString(udf, pc->Identifier); }
  2733. la_WriteShort(udf, LA_UDF_ITEM);
  2734. }
  2735. ItemNum++;
  2736. la_WritePointer(udf, inst);
  2737. la_WriteInt(udf, laGetUiState(p, pp->LastPs->UseInstance));
  2738. PropNum=0; pEachCount = la_Tell(udf); la_WriteShort(udf, 0);
  2739. for (subp = pc->Props.pFirst; subp; subp = subp->Item.pNext){
  2740. if (subp->UDFIgnore) continue;
  2741. SubPP.RawThis = pp;
  2742. SubPS.p = subp;
  2743. SubPS.UseInstance = inst;
  2744. if (la_WriteProp(udf, &SubPP, 0, UseInstanceList)) PropNum++;
  2745. }
  2746. if (FromThis){ inst = 0; }else{
  2747. inst = laGetNextInstance(p, inst, &pi);
  2748. pp->EndInstance = inst;
  2749. if(UseInstanceList&&pc->Hyper==2&&(!p->UDFIsSingle)&&(!p->UDFNoCreate)){
  2750. la_NextH2Instance(udf); if(!udf->CurrentH2Instance) inst=0; }
  2751. }
  2752. pContinue = la_Tell(udf);
  2753. la_Seek(udf, pEachCount); la_WriteShort(udf, PropNum);
  2754. la_Seek(udf, pContinue);
  2755. }
  2756. pContinue = la_Tell(udf);
  2757. la_Seek(udf, pReserve); la_WriteInt(udf, ItemNum);
  2758. la_Seek(udf, pContinue);
  2759. }
  2760. break;
  2761. case LA_PROP_INT:
  2762. case LA_PROP_ARRAY | LA_PROP_INT:
  2763. la_WriteIntProp(udf, pp);
  2764. break;
  2765. case LA_PROP_FLOAT:
  2766. case LA_PROP_ARRAY | LA_PROP_FLOAT:
  2767. la_WriteFloatProp(udf, pp);
  2768. break;
  2769. case LA_PROP_STRING:
  2770. la_WriteStringProp(udf, pp);
  2771. break;
  2772. case LA_PROP_ENUM:
  2773. case LA_PROP_ARRAY | LA_PROP_ENUM:
  2774. la_WriteEnumProp(udf, pp);
  2775. break;
  2776. case LA_PROP_RAW:
  2777. la_WriteRawProp(udf, pp);
  2778. break;
  2779. default:
  2780. break;
  2781. }
  2782. return 1;
  2783. }
  2784. void la_AddPostReadNode(void *Instance, laContainerPostReadFunc Func){
  2785. laUDFPostRead *upr = lstAppendPointerSized(&MAIN.PostReadNodes, Instance, sizeof(laUDFPostRead));
  2786. upr->Instance = Instance;
  2787. upr->Func = Func;
  2788. }
  2789. void *la_GetReadDBInstNUID(char *ReferReadNUID){
  2790. if (!ReferReadNUID) return 0;
  2791. laListHandle *l = hsh65536DoHashNUID(&MAIN.DBInst2, ReferReadNUID);
  2792. for (laMemNodeHyper* m = l->pFirst; m; m = m->Item.pNext){
  2793. if (!strcmp(ReferReadNUID, m->NUID.String))
  2794. return ((unsigned char*)m)+sizeof(laMemNodeHyper);
  2795. }
  2796. return 0;
  2797. }
  2798. void *la_GetReadDBInstPtr(void *ReferRead){
  2799. if (!ReferRead) return 0;
  2800. laListHandle *l = hsh65536DoHashLongPtr(&MAIN.DBInst1, ReferRead);
  2801. for (laMemNode* m = l->pFirst; m; m = m->Item.pNext){
  2802. if (ReferRead == m->ReadInstance)
  2803. return ((unsigned char*)m)+sizeof(laMemNode);
  2804. }
  2805. return 0;
  2806. }
  2807. void la_AddDataInst(void *ReadInstance, char *ReadNUID, void *ActualInstance){
  2808. laListHandle* l=0;
  2809. void* head=memGetHead(ActualInstance, 0);
  2810. if (ReadNUID) l = hsh65536DoHashNUID(&MAIN.DBInst2, ReadNUID);
  2811. else { l = hsh65536DoHashLongPtr(&MAIN.DBInst1, ReadInstance); ((laMemNode*)head)->ReadInstance = ReadInstance; }
  2812. lstPushItem(l, head); //always push so we get the latest during ptr sync.
  2813. }
  2814. laPtrSync *la_AddPtrSyncDirect(void *Refer, void *Parent, laProp *Sub){
  2815. laPtrSync *ps = memAcquireSimple(sizeof(laPtrSync));
  2816. ps->RefDB = Refer;
  2817. ps->Parent = Parent;
  2818. ps->Prop = Sub;
  2819. return ps;
  2820. }
  2821. laPtrSyncCommand *la_AddPtrSyncCommand(void *ReadRefer, void *ParentInst, char *ReadNUID, laProp *Sub){
  2822. laPtrSyncCommand *psc = memAcquireSimple(sizeof(laPtrSyncCommand));
  2823. psc->Target = la_AddPtrSyncDirect(0, ParentInst, Sub);
  2824. psc->ReadInstance = ReadRefer;
  2825. if (ReadNUID){ strcpy(psc->ReadNUID.String, ReadNUID); lstAppendItem(&MAIN.PtrSyncHyper2Commands, psc); }
  2826. else{ lstAppendItem(&MAIN.PtrSyncAddressCommands, psc); }
  2827. return psc;
  2828. }
  2829. void la_ResetInstance(void* inst, laPropContainer* pc, int IsListItem);
  2830. void laRequestAdditionalRegistry(laUDFRegistry* r);
  2831. laUDFOwnHyperItem* laNewHyperResource(char* uid);
  2832. laUDFOwnHyperItem* laFindHyperResource(char* uid);
  2833. void la_LoadAdditionalRegistries(){
  2834. laUDFRegistry* r;
  2835. while(r=lstPopPointer(&MAIN.PendingResourceRequests)){
  2836. laManagedUDF* m;
  2837. logPrint("[INFO] Loading additional resource: %s\n",r->Path->Ptr);
  2838. laUDF* udf = laOpenUDF(r->Path->Ptr, 1, 0, &m);
  2839. if (udf){ laExtractUDF(udf, m, LA_UDF_MODE_OVERWRITE); laCloseUDF(udf); }else{ logPrint("[WARN] Can't open resource: %s\n",r->Path->Ptr); }
  2840. }
  2841. }
  2842. void la_ExecutePtrSyncCommand(int Mode){
  2843. int i;
  2844. laPtrSyncCommand *psc,*NextPSC;
  2845. laPtrSync *ps;
  2846. void *dbi;
  2847. laListHandle *lps, *ldbi;
  2848. laListHandle L2 = {0};
  2849. int FailCount = 0, AllCount = 0;
  2850. while (psc = lstPopItem(&MAIN.PtrSyncAddressCommands)){
  2851. ps = psc->Target; dbi=0; if (psc->ReadInstance) dbi = la_GetReadDBInstPtr(psc->ReadInstance);
  2852. if (dbi){
  2853. //if (Mode == LA_udf_read)dbi->ReadInst = dbi->ActualInst; //??
  2854. ps->RefDB = dbi; laSetActiveInstance(ps->Prop, ps->Parent, dbi);
  2855. }else{ FailCount++; }
  2856. AllCount++; memFree(psc);
  2857. }
  2858. laUDFOwnHyperItem* ohi;
  2859. for(psc=MAIN.PtrSyncHyper2Commands.pFirst;psc;psc=NextPSC){
  2860. NextPSC=psc->Item.pNext; ps = psc->Target; dbi=0; if (psc->ReadNUID.String[0]) dbi = la_GetReadDBInstNUID(psc->ReadNUID.String);
  2861. if (dbi){
  2862. //if (Mode == LA_udf_read)dbi->ReadInst = dbi->ActualInst; //??
  2863. ps->RefDB = dbi; laSetActiveInstance(ps->Prop, ps->Parent, dbi);
  2864. lstRemoveItem(&MAIN.PtrSyncHyper2Commands,psc);memFree(psc);
  2865. }else{
  2866. if(!(ohi=laFindHyperResource(psc->ReadNUID.String))){
  2867. logPrint("Can't find resource %s\n", psc->ReadNUID.String);
  2868. lstRemoveItem(&MAIN.PtrSyncHyper2Commands,psc);memFree(psc);
  2869. FailCount++;
  2870. }else{
  2871. laRequestAdditionalRegistry(ohi->Registry);
  2872. lstRemoveItem(&MAIN.PtrSyncHyper2Commands,psc);
  2873. lstPushItem(&MAIN.PtrSyncHyper2Commands,psc); continue;
  2874. }
  2875. }
  2876. AllCount++;
  2877. }
  2878. logPrint("Reference Match: Total %d, Failed %d\n", AllCount, FailCount);
  2879. la_LoadAdditionalRegistries();
  2880. }
  2881. int la_ExtractFakeProp(laUDF *udf){
  2882. char buf[LA_RAW_CSTR_MAX_LEN] = {0};
  2883. void *Instance = 0;
  2884. void *ReadInstance;
  2885. int ReadState;
  2886. int NumItems;
  2887. short PropNumPerItem;
  2888. void *ActiveInstance;
  2889. int i, j;
  2890. int ItemType;
  2891. short mode, len;
  2892. int VariableNodeSize;
  2893. short PreMode;
  2894. mode = la_ReadShort(udf);
  2895. switch (mode){
  2896. case LA_UDF_REGULAR_MARK_32:
  2897. la_ReadInt(udf);
  2898. break;
  2899. case LA_UDF_REGULAR_MARK_64:
  2900. la_ReadFloat(udf);
  2901. break;
  2902. case (LA_UDF_ARRAY_MARK_32 | LA_UDF_STRING_MARK):
  2903. len = la_ReadShort(udf);
  2904. for (i = 0; i < len; i++)
  2905. la_ReadString(udf, buf);
  2906. break;
  2907. case LA_UDF_ARRAY_MARK_32:
  2908. len = la_ReadShort(udf);
  2909. for (i = 0; i < len; i++)
  2910. la_ReadInt(udf);
  2911. break;
  2912. case LA_UDF_ARRAY_MARK_64:
  2913. len = la_ReadShort(udf);
  2914. for (i = 0; i < len; i++)
  2915. la_ReadFloat(udf);
  2916. break;
  2917. case LA_UDF_STRING_MARK:
  2918. la_ReadString(udf, buf);
  2919. break;
  2920. case LA_UDF_SHARE_RESOURCE:
  2921. la_ReadString(udf, buf);
  2922. break;
  2923. case LA_UDF_REFER:
  2924. la_ReadPointer(udf);
  2925. break;
  2926. case (short)(LA_UDF_REFER | LA_UDF_HYPER_ITEM):
  2927. la_ReadString(udf, buf);
  2928. break;
  2929. case LA_UDF_COLLECTION:
  2930. NumItems = la_ReadInt(udf);
  2931. VariableNodeSize = la_ReadInt(udf);
  2932. VariableNodeSize = (VariableNodeSize == LA_UDF_VARIABLE_NODE_SIZE) ? 1 : 0;
  2933. la_ReadShort(udf); //active mark
  2934. ActiveInstance = la_ReadPointer(udf);
  2935. for (i = 0; i < NumItems; i++){
  2936. if(VariableNodeSize){ la_ReadString(udf,buf); }
  2937. ItemType = la_ReadShort(udf);
  2938. if (ItemType == LA_UDF_HYPER_ITEM){ la_ReadHyperData(udf, 0); }
  2939. ReadInstance = la_ReadPointer(udf);
  2940. ReadState = la_ReadInt(udf);
  2941. PropNumPerItem=la_ReadShort(udf);
  2942. for (j = 0; j < PropNumPerItem; j++){
  2943. la_ReadString(udf, buf);
  2944. la_ExtractFakeProp(udf);
  2945. }
  2946. }
  2947. break;
  2948. case LA_PROP_RAW:
  2949. la_ReadRawProp(udf, 0);
  2950. break;
  2951. default:
  2952. ReadState = ReadState;
  2953. break;
  2954. }
  2955. return 0;
  2956. }
  2957. int la_ExtractProp(laUDF *udf, laManagedUDF* mUDF, laPropPack *pp, void *ParentInst, int Mode){
  2958. laPropStep SubPS = {0};
  2959. laPropPack SubPP = {0};
  2960. char buf[LA_RAW_CSTR_MAX_LEN] = {0};
  2961. laProp *p = pp->LastPs->p, *subp;
  2962. short SubMode, ItemType = 0;
  2963. void *Instance = 0;
  2964. void *ReadInstance;
  2965. int ReadState;
  2966. int NumItems;
  2967. short PropNumPerItem;
  2968. void *ActiveInstance;
  2969. short PreReadMode;
  2970. int i, j;
  2971. int VariableNodeSize;
  2972. char NodeType[128]={0};
  2973. int EStatus = 0;
  2974. real ReadF;
  2975. int ReadI;
  2976. int IsExceptionNode = 0;
  2977. SubPP.LastPs = &SubPS;
  2978. switch (p->PropertyType){
  2979. case LA_PROP_SUB:
  2980. la_EnsureSubTarget(p, 0);
  2981. SubMode = la_ReadShort(udf);
  2982. if (SubMode == LA_UDF_SHARE_RESOURCE){
  2983. la_ReadString(udf, buf);
  2984. laSetActiveInstance(p, pp->LastPs->UseInstance, la_FindSharedResouce(buf));
  2985. }elif (SubMode == LA_UDF_REFER){
  2986. Instance = la_ReadPointer(udf);
  2987. if (Instance && p->Offset>=0){
  2988. if (p->OffsetIsPointer) la_AddPtrSyncCommand(Instance, ParentInst, 0, p);
  2989. else la_AddDataInst(Instance, 0, ((BYTE *)pp->LastPs->UseInstance + p->Offset));
  2990. }
  2991. }elif (SubMode == (short)(LA_UDF_REFER | LA_UDF_HYPER_ITEM)){
  2992. char NUID[32]={0};
  2993. NUID[0] = 0;
  2994. la_ReadString(udf, NUID);
  2995. if (NUID[0]){
  2996. la_AddPtrSyncCommand(0, ParentInst, NUID, p);
  2997. }
  2998. }elif (SubMode == LA_UDF_COLLECTION){
  2999. laProp **PreList = 0; void *ThisDBInst = 0;
  3000. NumItems = la_ReadInt(udf);
  3001. VariableNodeSize = la_ReadInt(udf);
  3002. VariableNodeSize = (VariableNodeSize == LA_UDF_VARIABLE_NODE_SIZE) ? 1 : 0;
  3003. la_ReadShort(udf); //active mark
  3004. ActiveInstance = la_ReadPointer(udf);
  3005. if (NumItems == 0) break;
  3006. if (p->UDFNoCreate){
  3007. laPropIterator PI = {0};
  3008. ItemType = la_ReadShort(udf);
  3009. Instance = laGetInstance(p, pp->LastPs->UseInstance, &PI);
  3010. la_ResetInstance(Instance, p->SubProp,0);
  3011. if (ItemType == LA_UDF_HYPER_ITEM){
  3012. if (p->SubProp->Hyper == 2){
  3013. if (!IsExceptionNode) la_ReadHyperData(udf, Instance);
  3014. else la_ReadHyperData(udf, 0);
  3015. if(mUDF) memAssignRef(Instance, &((laMemNodeHyper*)memGetHead(Instance, 0))->FromFile, mUDF);
  3016. memMarkClean(Instance);
  3017. }else la_ReadHyperData(udf, 0);
  3018. if(Mode==LA_UDF_MODE_APPEND){ lstAppendPointer(&MAIN.RenewHyper2s,Instance); }
  3019. }
  3020. if (p->SubProp->PostRead) la_AddPostReadNode(Instance, p->SubProp->PostRead);
  3021. ReadInstance = la_ReadPointer(udf);
  3022. ReadState = la_ReadInt(udf);
  3023. ThisDBInst=Instance;
  3024. PropNumPerItem = la_ReadShort(udf);
  3025. for (j = 0; j < PropNumPerItem; j++){
  3026. int result;
  3027. la_ReadString(udf, buf);
  3028. subp = la_PropLookup(&p->SubProp->Props, buf);
  3029. SubPP.RawThis = pp;
  3030. SubPS.p = subp;
  3031. SubPS.UseInstance = Instance;
  3032. if ((!subp) ||subp->UDFIgnore){la_ExtractFakeProp(udf); continue;}
  3033. if (subp&&!subp->SubProp){ subp->SubProp = la_ContainerLookup(((laSubProp *)subp)->TargetID); }
  3034. result = (IsExceptionNode||!subp) ? result = la_ExtractFakeProp(udf) : la_ExtractProp(udf, mUDF, &SubPP, ThisDBInst, Mode);
  3035. EStatus = result ? result : EStatus;
  3036. }
  3037. if (p->SubProp->PostReadIm) p->SubProp->PostReadIm(Instance);
  3038. }else{
  3039. if(Mode==LA_UDF_MODE_APPEND && p->UDFIsSingle){
  3040. logPrint("[Note] Mode is APPEND but property '%s' only allows one instance, will overwrite.\n", p->Identifier);
  3041. }
  3042. for (i = 0; i < NumItems; i++){
  3043. int RealSize=0; laUDF *SaveUDF = 0; int SaveItemType = 0;IsExceptionNode = 0; Instance=0;
  3044. laPropContainer* pc=p->SubProp;
  3045. if(VariableNodeSize){ la_ReadString(udf, NodeType); pc=la_ContainerLookup(NodeType);
  3046. if(!pc){pc=p->SubProp;} RealSize=pc->NodeSize;
  3047. }
  3048. ItemType = la_ReadShort(udf);
  3049. if(p->UDFReadProgress){ laShowProgress((real)i/NumItems,-1); } //printf("add pc %s\n",pc->Identifier);
  3050. if(pc==LA_PC_SOCKET_OUT || pc==LA_PC_SOCKET_IN){ laGraphRequestRebuild(); }
  3051. int replaced=0;
  3052. if (udf){
  3053. int IsItem=((laSubProp*)p)->ListHandleOffset?1:0;
  3054. RealSize = RealSize ? RealSize : p->SubProp->NodeSize;
  3055. if (!IsExceptionNode){
  3056. if (p->UDFIsSingle && (pp->EndInstance=laGetActiveInstanceStrict(pp->LastPs->p,pp->LastPs->UseInstance))){
  3057. Instance = pp->EndInstance; la_ResetInstance(Instance, pc, IsItem); replaced=1;
  3058. }
  3059. else{
  3060. // if overwrite, find the instance here for hyper2, if not Hyper 2 then notice can't overwrite.
  3061. if (pc->Hyper == 2){
  3062. if(Mode==LA_UDF_MODE_OVERWRITE && ItemType == LA_UDF_HYPER_ITEM){
  3063. laUID uid; la_PeekHyperUID(udf, &uid.String);
  3064. Instance = la_GetReadDBInstNUID(uid.String);
  3065. if(Instance){ la_ResetInstance(Instance, pc,IsItem); replaced=1; }
  3066. else{ /*logPrint("[Note] Hyper2 item [%s] from property '%s' hasn't been loaded yet, will append.\n", uid.String, p->Identifier);*/ }
  3067. }
  3068. if(!Instance) Instance = memAcquireHyperNoAppend(RealSize);
  3069. memMarkClean(Instance);
  3070. }elif (pc->Hyper == 1) Instance = memAcquire(RealSize);
  3071. else Instance = memAcquireSimple(RealSize);
  3072. }
  3073. }
  3074. if (ItemType == LA_UDF_HYPER_ITEM){
  3075. if (pc->Hyper == 2){
  3076. la_ReadHyperData(udf, Instance);
  3077. if(mUDF) memAssignRef(Instance, &((laMemNodeHyper*)memGetHead(Instance, 0))->FromFile, mUDF);
  3078. }
  3079. else la_ReadHyperData(udf, 0);
  3080. if(Mode==LA_UDF_MODE_APPEND){ lstAppendPointer(&MAIN.RenewHyper2s,Instance); }
  3081. }
  3082. if (!IsExceptionNode){
  3083. if (pc->PostRead) la_AddPostReadNode(Instance, pc->PostRead);
  3084. }
  3085. ReadInstance = la_ReadPointer(udf);
  3086. ReadState = la_ReadInt(udf);
  3087. if (!IsExceptionNode && !replaced){
  3088. la_AddDataInst(ReadInstance, pc->Hyper == 2 ? ((laMemNodeHyper *)memGetHead(Instance,0))->NUID.String : 0, Instance);
  3089. }
  3090. ThisDBInst = Instance;
  3091. PropNumPerItem = la_ReadShort(udf);
  3092. for (j = 0; j < PropNumPerItem; j++){
  3093. u64bit ThisSeek;
  3094. la_ReadString(udf, buf);
  3095. subp = la_PropLookup(&pc->Props, buf);
  3096. if ((!subp) || subp->UDFIgnore) la_ExtractFakeProp(udf);
  3097. else{
  3098. int result;
  3099. ThisSeek = la_Tell(udf);
  3100. SubPP.RawThis = pp; SubPS.p = subp; SubPS.UseInstance = Instance;
  3101. la_EnsureSubTarget(subp, 0);
  3102. result = IsExceptionNode ? la_ExtractFakeProp(udf) : la_ExtractProp(udf, mUDF, &SubPP, ThisDBInst, Mode);
  3103. EStatus = result ? result : EStatus;
  3104. }
  3105. }
  3106. if (!IsExceptionNode && !replaced){
  3107. if (pc->PostReadIm) pc->PostReadIm(Instance);
  3108. if (pp->LastPs->UseInstance){
  3109. if (!p->UDFIsSingle){
  3110. if (((laSubProp *)p)->ListHandleOffset){
  3111. laListHandle* inst_lst=(BYTE *)pp->LastPs->UseInstance + ((laSubProp *)p)->ListHandleOffset;
  3112. if(p->Container->SaverDummy && p==p->Container->SaverDummy){ laPurgeSaverDummy(pp->LastPs->UseInstance,p); }
  3113. lstAppendItem(inst_lst, Instance);
  3114. }else{ lstAppendItem(&pc->FailedNodes, Instance); EStatus = 1; }
  3115. }else{ if (!p->UDFNoCreate){ laSetActiveInstance(p, pp->LastPs->UseInstance, Instance); } }
  3116. if (ReadInstance == ActiveInstance) laSetActiveInstance(p, pp->LastPs->UseInstance, Instance);
  3117. }else{
  3118. if (!p->UDFIsSingle){ lstAppendItem(&pc->FailedNodes, Instance); EStatus = 1; }
  3119. }
  3120. }
  3121. }
  3122. }
  3123. }
  3124. if (PreList) memFree(PreList);
  3125. }
  3126. break;
  3127. case LA_PROP_INT:
  3128. case LA_PROP_ARRAY | LA_PROP_INT:
  3129. ReadI = la_ReadIntProp(udf, pp);
  3130. break;
  3131. case LA_PROP_FLOAT:
  3132. case LA_PROP_ARRAY | LA_PROP_FLOAT:
  3133. ReadF = la_ReadFloatProp(udf, pp);
  3134. break;
  3135. case LA_PROP_STRING:
  3136. la_ReadStringProp(udf, pp);
  3137. break;
  3138. case LA_PROP_ENUM:
  3139. case LA_PROP_ARRAY | LA_PROP_ENUM:
  3140. la_ReadEnumProp(udf, pp, buf);
  3141. break;
  3142. case LA_PROP_RAW:
  3143. la_ReadRawProp(udf, pp);
  3144. break;
  3145. default:
  3146. break;
  3147. }
  3148. return EStatus;
  3149. }
  3150. int la_RematchPointers(int Mode){
  3151. laUDFPostRead *uprd;
  3152. void* inst;
  3153. la_ExecutePtrSyncCommand(Mode);
  3154. while(uprd=lstPopItem(&MAIN.PostReadNodes)){ uprd->Func(uprd->Instance); memFree(uprd); }
  3155. while(inst=lstPopPointer(&MAIN.RenewHyper2s)){ laMemNodeHyper* h=memGetHead(inst,0);memMakeHyperData(h);memAssignRef(h,&h->FromFile,0); }
  3156. }
  3157. int la_WriteHyperRecords(laUDF *udf){
  3158. int i = 0;
  3159. u64bit CountSeek = la_Tell(udf);
  3160. u64bit EndSeek;
  3161. laUDFHyperRecordItem *hri;
  3162. laMemNodeHyper* h;
  3163. la_WriteLong(udf, 0);
  3164. while (hri = lstPopItem(&udf->HyperRecords)){
  3165. h=memGetHead(hri->HyperUserMem, 0);
  3166. la_WriteString(udf, h->NUID.String);
  3167. if(hri->pc) la_WriteString(udf, hri->pc->Identifier); else la_WriteString(udf, "");
  3168. la_WritePointer(udf, hri->Seek);
  3169. i++; memFree(hri);
  3170. }
  3171. EndSeek = la_Tell(udf);
  3172. la_Seek(udf, CountSeek); la_WriteLong(udf, i); la_Seek(udf, EndSeek);
  3173. return i;
  3174. }
  3175. int la_WritePropQuickSeek(laUDF *udf){
  3176. for(laUDFPropSegment* ps=udf->PropsToOperate.pFirst;ps;ps=ps->Item.pNext){
  3177. la_WriteString(udf,SSTR(ps->Path)); la_WriteLong(udf,ps->WriteQuickSeek);
  3178. }
  3179. }
  3180. int laPackUDF(laUDF *udf, int UseInstanceList, int DoBackup){
  3181. laUDFPropSegment *ps;
  3182. short NumSegments = 0;
  3183. u64bit RefPos;
  3184. u64bit nuidSeekRef;
  3185. u64bit nuidActualSeek;
  3186. char Root[1024]={0};
  3187. char FilePath[1024]={0};
  3188. if(DoBackup){
  3189. char BackupPath[1024]; sprintf(BackupPath,"%s~",SSTR(udf->FileName));
  3190. if(laCopyFile(BackupPath,udf->FileName->Ptr)){
  3191. logPrintNew("UDF backup written to \"%s\".\n", BackupPath);
  3192. }else{
  3193. logPrintNew("Error trying to back up \"%s\".\n", SSTR(udf->FileName));
  3194. }
  3195. }
  3196. udf->DiskFile = fopen(udf->FileName->Ptr, "wb");
  3197. if (!udf->DiskFile) return 0;
  3198. la_WriteOnlyMBString(udf, LA_UDF_IDENTIFIER);
  3199. u64bit SizeAndExt=la_Tell(udf);
  3200. // reserved for extension switches and file size verifications.
  3201. la_WritePointer(udf, 0);
  3202. RefPos = la_Tell(udf);
  3203. la_WriteLong(udf, 0); //How Many Refs.
  3204. la_WriteShort(udf, udf->NumSegmets);
  3205. la_WriteLong(udf, LA_UDF_NUID_SEEK);
  3206. nuidSeekRef = la_Tell(udf);
  3207. la_WritePointer(udf, 0); //Seek pos for nuid list;
  3208. logPrint("Packing %s:\n", udf->FileName->Ptr);
  3209. udf->CurrentH2Instance=udf->H2Instances.pFirst;
  3210. for(laUDFPropSegment* ps=udf->PropsToOperate.pFirst;ps;ps=ps->Item.pNext){
  3211. printf(" %-15s\n", ps->Path ? ps->Path->Ptr : ps->PPP->LastPs->p->Identifier);
  3212. ps->WriteQuickSeek = la_Tell(udf);
  3213. la_WriteProp(udf, ps->PPP ? ps->PPP : &ps->PP, ps->PPP ? 1 : 0, UseInstanceList);
  3214. }
  3215. logPrint("[ALL DONE]\n\n");
  3216. nuidActualSeek = la_Tell(udf);
  3217. la_WritePropQuickSeek(udf);
  3218. la_WriteHyperRecords(udf);
  3219. u64bit ActualSize=la_Tell(udf);
  3220. la_Seek(udf, RefPos); la_WriteLong(udf, udf->TotalRefs);
  3221. la_Seek(udf, nuidSeekRef); la_WritePointer(udf, nuidActualSeek);
  3222. la_Seek(udf, SizeAndExt); la_WritePointer(udf, ((ActualSize&(0x0000ffffffffffff))<<16)|LA_UDF_EXTENSIONS_ENABLED);
  3223. udf->Modified = 0;
  3224. while(ps = lstPopItem(&udf->PropsToOperate)){
  3225. la_FreePropStepCache(ps->PP.Go);
  3226. strSafeDestroy(&ps->Path);
  3227. FreeMem(ps);
  3228. }
  3229. laCloseUDF(udf);
  3230. laHideProgress();
  3231. return 1;
  3232. }
  3233. void laExtractProp(laUDF *udf, char* Path){
  3234. laUDFPropSegment *ps = CreateNew(laUDFPropSegment);
  3235. strSafeSet(&ps->Path, Path);
  3236. }
  3237. int la_PropIsSelected(laUDF* udf, char* Path){
  3238. if(!udf->PropsToOperate.pFirst) return 1;
  3239. for(laUDFPropSegment* ps=udf->PropsToOperate.pFirst;ps;ps=ps->Item.pNext){
  3240. if(strSame(SSTR(ps->Path),Path)) return 1;
  3241. }
  3242. return 0;
  3243. }
  3244. int laExtractUDF(laUDF *udf, laManagedUDF* mUDF, int Mode){
  3245. char Identifier[9] = {0};
  3246. char buf[1024]={0};
  3247. short Version, NumSegments;
  3248. //laPropStep SubPS = { 0 };
  3249. int PointerBits;
  3250. laPropPack SubPP = {0};
  3251. int i;
  3252. int EStatus = 0;
  3253. u64bit SeekRef;
  3254. int IsPart;
  3255. ma_device_stop(&MAIN.Audio->AudioDevice);
  3256. if(MAIN.InitArgs.HasAudio) laSpinLock(&MAIN.Audio->AudioStatusLock);
  3257. MAIN.IsReadingUDF = 1;
  3258. la_ReadBuffer(udf, sizeof(LA_UDF_IDENTIFIER) - 1, Identifier);
  3259. // file size verification and extension switches.
  3260. u64bit verification=la_ReadPointer(udf);
  3261. u64bit FileSize=verification>>16; int Extensions=verification&LA_UDF_ALL_EXTENSIONS;
  3262. if(FileSize && FileSize<la_FileSize(udf)){ logPrintNew("UDF verification failed for %s\n", udf->FileName->Ptr); return 0; }
  3263. /*udf->TotalRefs = */ la_ReadLong(udf);
  3264. NumSegments = la_ReadShort(udf);
  3265. la_ReadLong(udf); //seek mark
  3266. SeekRef = la_ReadPointer(udf);
  3267. logPrintNew("Extracting UDF [0x%x] %s:\n", udf->Extensions, udf->FileName->Ptr);
  3268. //MAIN.NextPendingPointer = 0;
  3269. //MAIN.PendingPointers = CreateNewBuffer(laUDFPointerRecord, udf->TotalRefs);
  3270. //SubPP.LastPs = &SubP;
  3271. for (i = 0; i < NumSegments; i++){
  3272. void *dbi = 0;
  3273. int result, LastOffset, selected=0;
  3274. la_ReadString(udf, buf);
  3275. LastOffset = strlen(buf) - 1;
  3276. buf[LastOffset] = buf[LastOffset] == U'.' ? 0 : buf[LastOffset];
  3277. logPrint(" Prop Segment \"%s\" ...", buf);
  3278. selected = la_PropIsSelected(udf, buf);
  3279. la_GetPropFromPath(&SubPP, 0, buf, 0);
  3280. la_StepPropPack(&SubPP);
  3281. dbi = SubPP.EndInstance; //la_GetWriteDBInst(SubPP.EndInstance);
  3282. result = (SubPP.LastPs&&SubPP.LastPs->p&&selected)?
  3283. la_ExtractProp(udf, mUDF, &SubPP, dbi, Mode):
  3284. la_ExtractFakeProp(udf);
  3285. EStatus = result ? result : EStatus;
  3286. //if(SubPP.LastPs->p->PropertyType!=LA_PROP_RAW){
  3287. // laNotifyUsersPP(&SubPP);
  3288. //}
  3289. logPrint(" [Done]\n", buf);
  3290. la_FreePropStepCache(SubPP.Go);
  3291. SubPP.Go = 0;
  3292. }
  3293. la_RematchPointers(Mode);
  3294. laHideProgress();
  3295. MAIN.IsReadingUDF = 0;
  3296. laUDFPropSegment* ps; while (ps = lstPopItem(&udf->PropsToOperate)){ strSafeDestroy(&ps->Path); FreeMem(ps); }
  3297. if(MAIN.InitArgs.HasAudio) laSpinUnlock(&MAIN.Audio->AudioStatusLock);
  3298. return EStatus;
  3299. }
  3300. int laExtractQuickRaw(FILE* fp, char* path, uint8_t** buf, size_t* size){
  3301. laUDF _udf={0},*udf=&_udf; udf->DiskFile = fp;
  3302. char str[128];
  3303. char Identifier[32];
  3304. la_Seek(udf,0);
  3305. la_ReadBuffer(udf, sizeof(LA_UDF_IDENTIFIER) - 1, Identifier);
  3306. u64bit verification=la_ReadPointer(udf);
  3307. u64bit FileSize=verification>>16; int Extensions=verification&LA_UDF_ALL_EXTENSIONS;
  3308. if(FileSize && FileSize<la_FileSize(udf)){ return 0; }
  3309. if(!(Extensions & LA_UDF_EXTENSION_QUICK_SEEK)){ return 0; }
  3310. /*udf->TotalRefs = */ la_ReadLong(udf);
  3311. short NumSegments = la_ReadShort(udf);
  3312. la_ReadLong(udf); //seek mark
  3313. off_t SeekRef = la_ReadPointer(udf);
  3314. la_Seek(udf,SeekRef);
  3315. for(int i=0;i<NumSegments;i++){
  3316. la_ReadString(udf,str);
  3317. int Seek = la_ReadLong(udf);
  3318. if(strSame(str,path)){
  3319. la_Seek(udf,Seek);
  3320. la_ReadString(udf, str); // prop name
  3321. la_ReadShort(udf);// raw mark
  3322. void* data=la_ReadRaw(udf,size);
  3323. *buf=data; if(data){ return 1; }
  3324. break;
  3325. }
  3326. }
  3327. return 0;
  3328. }
  3329. laManagedUDF* la_FindManagedUDF(char* FileName){
  3330. for(laManagedUDF* m=MAIN.ManagedUDFs.pFirst;m;m=m->Item.pNext){
  3331. if(m->udf&&m->udf->FileName&&!strcmp(m->udf->FileName->Ptr,FileName)) return m;
  3332. }
  3333. return 0;
  3334. }
  3335. laManagedUDF* la_EnsureManagedUDF(char* FileName, int PutAtTop){
  3336. laManagedUDF* m;
  3337. if(!(m=la_FindManagedUDF(FileName))){
  3338. m=memAcquire(sizeof(laManagedUDF)); strSafeSet(&m->BaseName, strGetLastSegment(FileName,LA_PATH_SEP));
  3339. if(PutAtTop) lstPushItem(&MAIN.ManagedUDFs, m); else lstAppendItem(&MAIN.ManagedUDFs, m);
  3340. }
  3341. return m;
  3342. }
  3343. void la_MakeDummyManagedUDF(){
  3344. MAIN.DummyManageUDF=la_EnsureManagedUDF("< Save as a new file >", 1);
  3345. if(!MAIN.DummyManageUDFSingle){
  3346. MAIN.DummyManageUDFSingle=memAcquire(sizeof(laManagedUDF)); strSafeSet(&MAIN.DummyManageUDFSingle->BaseName, "< Choose file >");
  3347. MAIN.DummyManageUDFSingleForce=memAcquire(sizeof(laManagedUDF)); strSafeSet(&MAIN.DummyManageUDFSingleForce->BaseName, "< Force >");
  3348. }
  3349. }
  3350. laManagedSaveProp* laSaveProp(char* path){
  3351. if(!path || !path[0]) return; laManagedSaveProp* msp=0;
  3352. for(laManagedSaveProp* m=MAIN.ManagedSaveProps.pFirst;m;m=m->Item.pNext){
  3353. if(!strcmp(m->Path->Ptr,path)){ msp=m; break; }
  3354. }
  3355. if(!msp){ msp=memAcquireSimple(sizeof(laManagedSaveProp)); lstAppendItem(&MAIN.ManagedSaveProps, msp); }
  3356. strSafeSet(&msp->Path, path);
  3357. return msp;
  3358. }
  3359. void laSaveAlongside(laManagedSaveProp* parent, char* path){
  3360. if(!path || !path[0] || !parent) return; laManagedSaveProp* msp=0;
  3361. for(laManagedSaveProp* m=parent->SaveAlongside.pFirst;m;m=m->Item.pNext){
  3362. if(!strcmp(m->Path->Ptr,path)){ msp=m; break; }
  3363. }
  3364. if(!msp){ msp=memAcquireSimple(sizeof(laManagedSaveProp)); lstAppendItem(&parent->SaveAlongside, msp); }
  3365. strSafeSet(&msp->Path, path);
  3366. }
  3367. void laClearSaveProp(){
  3368. laManagedSaveProp* m; while(m=lstPopItem(&MAIN.ManagedSaveProps)) {
  3369. laManagedSaveProp* ma; while(ma=lstPopItem(&m->SaveAlongside)){ strSafeDestroy(&ma->Path); memFree(ma); }
  3370. strSafeDestroy(&m->Path); memFree(m);
  3371. }
  3372. }
  3373. int la_ScanForModifiedRecursive(laPropPack* pp, int ReturnIfAnyMod, int ReturnIfAnyEmpty, int* rempty, int RegisterToUDF){
  3374. int result=0;
  3375. laProp* p=pp->LastPs->p; laPropIterator pi={0};
  3376. if(p->PropertyType!=LA_PROP_SUB || p->UDFIsRefer || p->UDFIgnore || p->UDFOnly) return 0;
  3377. la_EnsureSubTarget(p, 0); //if(p->SubProp && p->SubProp->Hyper!=2) return 0;
  3378. void* inst = laGetInstance(p, pp->LastPs->UseInstance, &pi);
  3379. while(inst){
  3380. laPropContainer* pc=la_EnsureSubTarget(p, inst);
  3381. if(pc->Hyper!=2){
  3382. laPropPack spp={0}; laPropStep sps={0}; spp.LastPs=&sps;
  3383. for(laProp* sp=pc->Props.pFirst;sp;sp=sp->Item.pNext){
  3384. sps.UseInstance=inst; sps.p=sp;
  3385. if(sp->PropertyType==LA_PROP_SUB) {
  3386. result|=la_ScanForModifiedRecursive(&spp, ReturnIfAnyMod, ReturnIfAnyEmpty, rempty, RegisterToUDF);
  3387. if((ReturnIfAnyMod||ReturnIfAnyEmpty)&&result)return result;
  3388. }
  3389. }
  3390. }else{
  3391. laMemNodeHyper* m = memGetHead(inst,0);
  3392. if(!m->FromFile || m->FromFile==MAIN.DummyManageUDF){ result|=1; if(rempty)*rempty|=1; if((ReturnIfAnyMod||ReturnIfAnyEmpty)&&result)return result; }
  3393. if((!p->UDFIsSingle)&&(!p->UDFNoCreate)&&RegisterToUDF&&m->FromFile&&m->FromFile->udf){ la_IncludeHyper2Instance(m->FromFile->udf, pc, inst); }
  3394. if(m->Modified){
  3395. if(m->FromFile && m->FromFile->udf){ m->FromFile->udf->Modified=1; }
  3396. result|=1; if(ReturnIfAnyMod&&result)return result;
  3397. }
  3398. }
  3399. inst=laGetNextInstance(p,inst,&pi);
  3400. }
  3401. return result;
  3402. }
  3403. int laRegisterModifications(int ReturnIfAnyMod, int ReturnIfAnyEmpty, int* rempty, int RegisterToUDF){
  3404. int result=0, registered; if(RegisterToUDF){ReturnIfAnyMod=ReturnIfAnyEmpty=0;}
  3405. for(laManagedUDF* m=MAIN.ManagedUDFs.pFirst;m;m=m->Item.pNext){
  3406. if(!m->udf)continue;
  3407. m->udf->Modified=0;
  3408. la_ClearHyper2Instances(m->udf);
  3409. }
  3410. for(laManagedSaveProp* msp=MAIN.ManagedSaveProps.pFirst;msp;msp=msp->Item.pNext){
  3411. laPropPack PP={0}; registered=0;
  3412. if(msp->Path&&msp->Path->Ptr&&la_GetPropFromPath(&PP, 0, msp->Path->Ptr, 0)){
  3413. la_StepPropPack(&PP);
  3414. result|=la_ScanForModifiedRecursive(&PP, ReturnIfAnyMod, ReturnIfAnyEmpty, rempty, RegisterToUDF);
  3415. for(laManagedUDF* m=MAIN.ManagedUDFs.pFirst;m;m=m->Item.pNext){
  3416. if(!m->udf)continue;
  3417. if(m->udf->HasInstances){ laWriteProp(m->udf,SSTR(msp->Path));
  3418. for(laManagedSaveProp* am=msp->SaveAlongside.pFirst;am;am=am->Item.pNext){
  3419. laWriteProp(m->udf,SSTR(am->Path));
  3420. }
  3421. m->udf->HasInstances=0;
  3422. }
  3423. }
  3424. if((ReturnIfAnyMod||ReturnIfAnyEmpty)&&result)return result;
  3425. la_FreePropStepCache(PP.Go);
  3426. }
  3427. }
  3428. return result;
  3429. }
  3430. void la_ReadUDFToMemory(laUDF *udf){
  3431. if (udf->FileContent)
  3432. return;
  3433. fseek(udf->DiskFile, 0, SEEK_END);
  3434. u64bit SeekEnd = ftell(udf->DiskFile);
  3435. fseek(udf->DiskFile, 0, SEEK_SET);
  3436. udf->FileContent = calloc(1, SeekEnd);
  3437. udf->FileContentSize=SeekEnd;
  3438. fread(udf->FileContent, SeekEnd, 1, udf->DiskFile);
  3439. udf->Seek = 0;
  3440. }
  3441. void la_ReadOwnHyperItems(laUDF *udf, laUDFRegistry* r){
  3442. int Count, i;
  3443. laUDFOwnHyperItem *ohi;
  3444. Count = la_ReadLong(udf);
  3445. int Seek;
  3446. char name[256]; laUID uid;
  3447. for (i = 0; i < Count; i++){
  3448. la_ReadString(udf, uid.String);
  3449. la_ReadString(udf, name);
  3450. Seek=la_ReadPointer(udf);
  3451. laPropContainer* pc = la_ContainerLookup(name);
  3452. if(!laFindHyperResource(uid.String)){
  3453. ohi = laNewHyperResource(uid.String);
  3454. ohi->Registry = r;
  3455. ohi->Seek = Seek;
  3456. strcpy(ohi->NUID.String, uid.String);
  3457. //logPrint("Found Resource: %s | %s\n",ohi->NUID.String,name);
  3458. } else {logPrint("Duplicated Resource: %s | %s\n",uid.String,name);}
  3459. }
  3460. }
  3461. int la_ReadPropQuickSeek(laUDF *udf){
  3462. char* buf[128];
  3463. for(int i=0;i<udf->NumSegmets;i++){
  3464. laUDFPropQuickSeek *qs = memAcquireSimple(sizeof(laUDFPropQuickSeek));
  3465. la_ReadString(udf,buf); strSafeSet(&qs->Path,buf);
  3466. qs->QuickSeek = la_ReadLong(udf);
  3467. lstAppendItem(&udf->QuickSeeks,qs);
  3468. //logPrint(" %dx QuickSeeks\n",qs->QuickSeek,SSTR(qs->Path));
  3469. }
  3470. }
  3471. laUDF *laOpenUDF(char *FileName, int ReadToMemory, laUDFRegistry* ReadRegistryRef, laManagedUDF** UseManaged){
  3472. char Identifier[9] = {0};
  3473. u64bit SeekRef;
  3474. laUDF *udf;
  3475. u64bit extensions;
  3476. char FilePath[1024]={0};
  3477. udf=memAcquire(sizeof(laUDF));
  3478. strSafeSet(&udf->FileName, FileName);
  3479. udf->DiskFile = fopen(udf->FileName->Ptr, "rb");
  3480. if (!udf->DiskFile) return 0;
  3481. if(ReadToMemory){ la_ReadUDFToMemory(udf); fclose(udf->DiskFile); udf->DiskFile = 0; }
  3482. la_ReadBuffer(udf, sizeof(LA_UDF_IDENTIFIER) - 1, Identifier);
  3483. if (!strSame(Identifier, LA_UDF_IDENTIFIER)){ laCloseUDF(udf); logPrintNew("\"%s\" is not a UDF file.\n", FileName); return 0; }
  3484. if(UseManaged){
  3485. laManagedUDF* m=la_EnsureManagedUDF(FileName, 0);
  3486. if(!m->udf) m->udf=udf; udf->Managed=1; *UseManaged=m;
  3487. }
  3488. extensions = la_ReadPointer(udf);
  3489. udf->Extensions = extensions & LA_UDF_ALL_EXTENSIONS;
  3490. if((udf->Extensions | LA_UDF_EXTENSIONS_ENABLED)!=LA_UDF_EXTENSIONS_ENABLED){
  3491. logPrint("Unsupported UDF extension 0x%x (0x%x enabled), it's probably saved with a newer version of the program.\n",
  3492. udf->Extensions,LA_UDF_EXTENSIONS_ENABLED);
  3493. laCloseUDF(udf);
  3494. return 0;
  3495. }
  3496. udf->TotalRefs = la_ReadLong(udf); //total refs
  3497. udf->NumSegmets = la_ReadShort(udf); //num segments
  3498. la_ReadLong(udf); //seek mark
  3499. SeekRef = la_ReadPointer(udf);
  3500. la_Seek(udf, SeekRef);
  3501. if(ReadRegistryRef){
  3502. if(udf->Extensions & LA_UDF_EXTENSION_QUICK_SEEK){
  3503. la_ReadPropQuickSeek(udf);
  3504. }
  3505. la_ReadOwnHyperItems(udf, ReadRegistryRef);
  3506. }
  3507. la_Seek(udf, 0);
  3508. udf->Opened = 1;
  3509. return udf;
  3510. }
  3511. void laCloseUDF(laUDF *udf){
  3512. laUDFOwnHyperItem *ohi;
  3513. laUDFHyperRecordItem *hri;
  3514. laUDFPropSegment *ps;
  3515. laUDFPropQuickSeek *qs;
  3516. if (udf->DiskFile){ fclose(udf->DiskFile); udf->DiskFile=0; };
  3517. while (lstPopPointer(&udf->OwnHyperItems));
  3518. while (lstPopPointer(&udf->HyperRecords));
  3519. while (qs = lstPopItem(&udf->QuickSeeks)){ strSafeDestroy(&qs->Path); memFree(qs); }
  3520. if(udf->CurrentH2Instance){ logPrint("[WARN] udf->CurrentH2Instance!=0 after UDF packing.\n"); udf->CurrentH2Instance=0; }
  3521. udf->NumSegmets=0;
  3522. la_ClearHyper2Instances(udf);
  3523. if(udf->FileContent) FreeMem(udf->FileContent);
  3524. if(!udf->Managed){ strSafeDestroy(&udf->FileName); memFree(udf); }
  3525. }
  3526. int laLoadHyperResources(char* uid_search){
  3527. int count=0;
  3528. logPrintNew("Loading extra resources \"%s\"\n",uid_search);
  3529. for(laUDFOwnHyperItem* ohi=MAIN.UDFResources.pFirst;ohi;ohi=ohi->Item.pNext){
  3530. if(strstr(ohi->NUID.String,uid_search)){ laRequestAdditionalRegistry(ohi->Registry); count++; };
  3531. }
  3532. if(count){ la_LoadAdditionalRegistries(); } return count;
  3533. }
  3534. laUDFOwnHyperItem* laFindHyperResource(char* uid){
  3535. for(laUDFOwnHyperItem* ohi=MAIN.UDFResources.pFirst;ohi;ohi=ohi->Item.pNext){
  3536. if(!strcmp(uid, ohi->NUID.String)) return ohi;
  3537. }
  3538. return 0;
  3539. }
  3540. laUDFOwnHyperItem* laNewHyperResource(char* uid){
  3541. laUDFOwnHyperItem* ohi = memAcquireSimple(sizeof(laUDFOwnHyperItem));
  3542. lstAppendItem(&MAIN.UDFResources, ohi); return ohi;
  3543. }
  3544. laUDFRegistry* laFindUDFRegistry(char* Path){
  3545. for(laUDFRegistry* r=MAIN.ResourceRegistries.pFirst;r;r=r->Item.pNext){
  3546. if(r->Path && !strcmp(Path, r->Path->Ptr)) return r;
  3547. }
  3548. return 0;
  3549. }
  3550. laUDFRegistry* laCreateUDFRegistry(char* Path){
  3551. if(!Path) return 0;
  3552. laUDFRegistry* r = memAcquire(sizeof(laUDFRegistry));
  3553. strSafeSet(&r->Path, Path);
  3554. lstAppendItem(&MAIN.ResourceRegistries, r);
  3555. return r;
  3556. }
  3557. void laRequestAdditionalRegistry(laUDFRegistry* r){
  3558. if(la_FindManagedUDF(r->Path->Ptr)) return;
  3559. if(lstHasPointer(&MAIN.PendingResourceRequests, r)) return;
  3560. logPrint("[INFO] Request additional resources in: %s\n", r->Path->Ptr);
  3561. lstAppendPointer(&MAIN.PendingResourceRequests,r);
  3562. }
  3563. void laClearUDFRegistries(){
  3564. laUDFOwnHyperItem* ohi; laUDFRegistry* r;
  3565. while(ohi=lstPopItem(&MAIN.UDFResources)) memFree(ohi);
  3566. while(r=lstPopItem(&MAIN.ResourceRegistries)){
  3567. strSafeDestroy(&r->Path); memFree(r);
  3568. }
  3569. }
  3570. void laGetSubResourceDirectories(char* rootpath_with_slash, laListHandle* out){
  3571. laSafeString*s=0; strSafePrint(&s, "%sUDFExtra" LA_PATH_SEPSTR, rootpath_with_slash); lstAppendPointer(out,s);
  3572. char Final[1024];
  3573. sprintf(Final, "%s.udfextra",rootpath_with_slash);
  3574. FILE* f=fopen(Final, "r"); if(!f){ return; }
  3575. char dir[1024];
  3576. while(fgets(dir,1024,f)){ laSafeString*s=0; strSafePrint(&s, "%s%s" LA_PATH_SEPSTR, rootpath_with_slash, dir); lstAppendPointer(out,s); }
  3577. fclose(f);
  3578. }
  3579. void laRefreshUDFResourcesIn(char* rootpath){
  3580. char Final[2048];
  3581. int NumFiles=-1;
  3582. int len = strlen(rootpath);
  3583. if (rootpath[len - 1] != LA_PATH_SEP) strcat(rootpath, LA_PATH_SEPSTR);
  3584. #ifdef __linux__
  3585. struct dirent **NameList=0;
  3586. NumFiles=scandir(rootpath,&NameList,0,alphasort);
  3587. for(int i=0;i<NumFiles;i++){
  3588. struct dirent* d = NameList[i]; int dlen;
  3589. char *format = strGetLastSegment(d->d_name, '.'); int file_okay=0;
  3590. for(laExtensionType* et=MAIN.ExtraExtensions.pFirst;et;et=et->Item.pNext){ if(et->FileType==LA_FILETYPE_UDF && strSame(et->Extension,format)){file_okay=1;break;} }
  3591. if(!file_okay) continue;
  3592. struct stat s;
  3593. sprintf(Final, "%s%s",rootpath,d->d_name);
  3594. stat(Final, &s);
  3595. if (!S_ISDIR(s.st_mode)){
  3596. if(!laFindUDFRegistry(Final)){
  3597. laUDFRegistry* r = laCreateUDFRegistry(Final);
  3598. laUDF* udf = laOpenUDF(Final, 0, r, 0);
  3599. if(udf) laCloseUDF(udf);
  3600. }
  3601. }
  3602. }
  3603. for (int i=0;i<NumFiles;i++){ free(NameList[i]); } if(NameList) free(NameList);
  3604. #endif
  3605. #ifdef _WIN32
  3606. WIN32_FIND_DATA FindFileData;
  3607. HANDLE hFind;
  3608. SYSTEMTIME stUTC, stLocal;
  3609. char Lookup[PATH_MAX];
  3610. strCopyFull(Lookup, rootpath); strcat(Lookup, "*.*");
  3611. hFind = FindFirstFile(Lookup, &FindFileData);
  3612. if (hFind == INVALID_HANDLE_VALUE) return;
  3613. while (1){
  3614. NumFiles++;
  3615. char* format = strGetLastSegment(FindFileData.cFileName, '.'); int file_okay = 0;
  3616. for (laExtensionType* et = MAIN.ExtraExtensions.pFirst; et; et = et->Item.pNext) { if (et->FileType == LA_FILETYPE_UDF && strSame(et->Extension, format)) { file_okay = 1; break; } }
  3617. if (file_okay) {
  3618. sprintf(Final, "%s%s", rootpath, FindFileData.cFileName);
  3619. struct stat s; stat(Final, &s);
  3620. if (!(s.st_mode & S_IFDIR)) {
  3621. if (!laFindUDFRegistry(Final)) {
  3622. laUDFRegistry* r = laCreateUDFRegistry(Final);
  3623. laUDF* udf = laOpenUDF(Final, 0, r, 0);
  3624. if (udf) laCloseUDF(udf);
  3625. }
  3626. }
  3627. }
  3628. if (!FindNextFile(hFind, &FindFileData))
  3629. break;
  3630. }
  3631. #endif
  3632. if (NumFiles >= 0) {
  3633. laListHandle additionals = { 0 }; laSafeString* s;
  3634. laGetSubResourceDirectories(rootpath, &additionals);
  3635. while (s = lstPopPointer(&additionals)) { laRefreshUDFResourcesIn(s->Ptr); strSafeDestroy(&s); }
  3636. }
  3637. }
  3638. void laRefreshUDFRegistries(){
  3639. laClearUDFRegistries();
  3640. char LookupM[PATH_MAX];
  3641. for(laResourceFolder* rf = MAIN.ResourceFolders.pFirst;rf;rf=rf->Item.pNext){
  3642. if(!rf->Path) continue;
  3643. realpath(rf->Path->Ptr, LookupM);
  3644. laRefreshUDFResourcesIn(LookupM);
  3645. }
  3646. }
  3647. void laStopManageUDF(laManagedUDF* m){
  3648. if(!m) return;
  3649. lstRemoveItem(&MAIN.ManagedUDFs,m);
  3650. if(m->udf) { m->udf->Managed=0; laCloseUDF(m->udf); };
  3651. strSafeDestroy(&m->BaseName);
  3652. memFree(m);
  3653. }
  3654. void laClearManagedUDF(){
  3655. laManagedUDF* m;
  3656. while(m=MAIN.ManagedUDFs.pFirst){ laStopManageUDF(m); }
  3657. }
  3658. void laSaveManagedUDF(){
  3659. laRegisterModifications(0,0,0,1);
  3660. if(MAIN.PreSave){ MAIN.PreSave(); }
  3661. for(laManagedUDF* m=MAIN.ManagedUDFs.pFirst;m;m=m->Item.pNext){
  3662. if(!m->udf) continue;
  3663. if(m->udf->PropsToOperate.pFirst){ laPackUDF(m->udf, 1, 1); }
  3664. laCloseUDF(m->udf);// just in case
  3665. }
  3666. if(MAIN.PostSave){ MAIN.PostSave(); }
  3667. }
  3668. void laPropagateUDF(laPropContainer* pc, void* inst, int force){
  3669. if(!pc->UDFPropagate) return;
  3670. void* udf=laget_InstanceActiveUDF(inst); if(udf==MAIN.DummyManageUDF) return;
  3671. pc->UDFPropagate(inst, udf, force);
  3672. }
  3673. void laSetSaveCallback(laPreSaveF PreSave, laPostSaveF PostSave){
  3674. MAIN.PreSave=PreSave;
  3675. MAIN.PostSave=PostSave;
  3676. }
  3677. //==========================================================================[Manifest]
  3678. void laAddResourceFolder(char* Path){
  3679. laResourceFolder* rf=memAcquire(sizeof(laResourceFolder));
  3680. if(Path) strSafeSet(&rf->Path, Path);
  3681. lstAppendItem(&MAIN.ResourceFolders, rf);
  3682. }
  3683. void laRemoveResourceFolder(laResourceFolder* rf){
  3684. strSafeDestroy(&rf->Path);
  3685. lstRemoveItem(&MAIN.ResourceFolders, rf);
  3686. memFree(rf);
  3687. }
  3688. void la_ClearUDFRegistryAndFolders(){
  3689. laResourceFolder* rf; while(rf=MAIN.ResourceFolders.pFirst){ laRemoveResourceFolder(rf); }
  3690. laClearUDFRegistries();
  3691. }
  3692. //==========================================================================[undo]
  3693. void laPushDifferenceOnly(char* Description, u64bit hint){
  3694. laDiff* d=memAcquire(sizeof(laDiff));
  3695. lstAppendItem(&MAIN.Differences, d);
  3696. if(MAIN.HeadDifference && Description) strSafeSet(&MAIN.HeadDifference->Description,Description);
  3697. d->Hint=hint; MAIN.HeadDifference=d;
  3698. laNotifyUsers("la.differences");
  3699. }
  3700. void laPushDifferences(char* Description, u64bit hint){
  3701. memFreeRemainingLeftNodes();
  3702. laPushDifferenceOnly(Description,hint);
  3703. }
  3704. void la_FreeInstance(void* inst, laPropContainer* pc, int no_free);
  3705. void la_FreeDBInst(laDBInst* dbi, int no_freeinst, int cleanup_only, int SkipInstances);
  3706. void la_FreeDBProp(laDBProp* dbp, int cleanup_only, int SkipInstances){
  3707. //printf("free dbp %s %x\n",dbp->p->Identifier,dbp);
  3708. if(dbp->p->PropertyType==LA_PROP_SUB){
  3709. if((((laSubProp*)dbp->p)->ListHandleOffset||dbp->p->UDFNoCreate||dbp->p->UDFIsSingle)&&(!dbp->p->UDFIsRefer)&&(!SkipInstances)){
  3710. laDBSubProp* dsp=dbp; laDBInst* si;
  3711. //printf("fdbp %s %x %x %x\n",dbp->p->Identifier,dsp->Instances.pFirst,dsp->Instances.pLast,((laListItem*)dsp->Instances.pFirst)->pNext);
  3712. while(si=lstPopItem(&dsp->Instances)){ la_FreeDBInst(si,dbp->p->UDFNoCreate||(!dbp->p->OffsetIsPointer),cleanup_only,SkipInstances); }
  3713. } // prevent freeing the data;
  3714. }elif(dbp->p->PropertyType==LA_PROP_STRING && ((laStringProp*)dbp->p)->IsSafeString){
  3715. strSafeSet(&dbp->Data,0);
  3716. }elif(dbp->p->PropertyType==LA_PROP_RAW){
  3717. //printf("raw dbp %s\n",dbp->p->Identifier);
  3718. free(dbp->Data);
  3719. }else{
  3720. //printf("-data- %x\n",dbp->Data);
  3721. memFree(dbp->Data);
  3722. }
  3723. memFree(dbp);
  3724. }
  3725. void la_FreeDBInst(laDBInst* dbi, int no_freeinst, int cleanup_only, int SkipInstances){
  3726. laListHandle* l=hsh65536DoHashLongPtr(MAIN.DBInstLink,dbi->OriginalInstance); lstRemoveItem(l, &dbi->Item2);
  3727. //printf("free dbi %s %x\n", dbi->pc->Identifier,dbi);
  3728. laDBProp* dbp; while(dbp=lstPopItem(&dbi->Props)){ la_FreeDBProp(dbp, cleanup_only,SkipInstances); }
  3729. if(dbi->OriginalInstance && (!cleanup_only)) la_FreeInstance(dbi->OriginalInstance, dbi->pc, no_freeinst);
  3730. memFree(dbi);
  3731. }
  3732. void la_FreeDiffCommand(laDiffCommand* dc, laDiff* d, int FromLeft){
  3733. //printf("freedc %s\n",dc->p->Identifier);
  3734. if(dc->p->PropertyType==LA_PROP_SUB && (((laSubProp*)dc->p)->ListHandleOffset||dc->p->UDFNoCreate||dc->p->UDFIsSingle) && (!dc->p->UDFIsRefer)){
  3735. laDiffCommandInst* dci; laDiffCommandSub* dcs=dc;
  3736. while(dci=lstPopItem(&dcs->AddedInst)){ if(!FromLeft) la_FreeDBInst(dci->DBInst,(dc->p->UDFNoCreate||(!dc->p->OffsetIsPointer)),0,0); memFree(dci); }
  3737. while(dci=lstPopItem(&dcs->MovedInst)){ memFree(dci); }
  3738. while(dci=lstPopItem(&dcs->RemovedInst)){ if(FromLeft) la_FreeDBInst(dci->DBInst,(dc->p->UDFNoCreate||(!dc->p->OffsetIsPointer)),0,1); memFree(dci); }
  3739. }elif(dc->p->PropertyType==LA_PROP_STRING && ((laStringProp*)dc->p)->IsSafeString){
  3740. strSafeSet(&dc->Data,0);
  3741. }elif(dc->p->PropertyType==LA_PROP_RAW){
  3742. //printf("raw %s\n",dc->p->Identifier);
  3743. free(dc->Data);
  3744. }
  3745. memFree(dc);
  3746. }
  3747. void la_FreeDifference(laDiff* d, int FromLeft){
  3748. laDiffCommand* dc; laDiffCommandCustom* dcc; laDiffExtraTouched* det;
  3749. while(dc=lstPopItem(&d->Commands)){ la_FreeDiffCommand(dc,d,FromLeft); }
  3750. while(dcc=lstPopItem(&d->CustomCommands)){ if(dcc->Free) dcc->Free(dcc->Data, FromLeft); }
  3751. while(det=lstPopItem(&d->ExtraTouched)){ memFree(det); }
  3752. //if(d->Description&&d->Description->Ptr){printf("%s\n",d->Description->Ptr);}
  3753. strSafeDestroy(&d->Description);
  3754. }
  3755. void laFreeNewerDifferences(){
  3756. laDiff* PrevD;
  3757. if(MAIN.HeadDifference==MAIN.Differences.pLast) return;
  3758. for(laDiff* d=MAIN.Differences.pLast;d;d=PrevD){
  3759. PrevD=d->Item.pPrev;
  3760. lstRemoveItem(&MAIN.Differences,d);
  3761. la_FreeDifference(d,0);
  3762. if(MAIN.HeadDifference==d){ MAIN.HeadDifference=PrevD; laPushDifferenceOnly(0,0); break; }
  3763. }
  3764. }
  3765. void laFreeOlderDifferences(int KeepHowMany){
  3766. laDiff* endd; int count=0;
  3767. for(endd=MAIN.HeadDifference;endd;endd=endd->Item.pPrev){
  3768. if(count>=KeepHowMany) break; count++;
  3769. }
  3770. if(!endd) return; laDiff* d,*NextD;
  3771. while(d=lstPopItem(&MAIN.Differences)){
  3772. NextD=MAIN.Differences.pFirst;
  3773. la_FreeDifference(d,1);
  3774. if(MAIN.HeadDifference==d){ MAIN.HeadDifference=NextD; laPushDifferenceOnly(0,0); break; }
  3775. if(d==endd){ break; }
  3776. }
  3777. }
  3778. void la_FreeAllDifferences(){
  3779. laFreeNewerDifferences();
  3780. laFreeOlderDifferences(1);
  3781. }
  3782. void la_NoLongerRecordUndo(){
  3783. la_FreeAllDifferences();
  3784. laDBProp*dbp; while(dbp=lstPopItem(&MAIN.RootDBInst.Props)){ la_FreeDBProp(dbp,1,0); }
  3785. laDBRecordedProp* p; while(p=lstPopItem(&MAIN.DBRecordedProps)){ strSafeDestroy(&p->OriginalPath); memFree(p); }
  3786. hshFree(&MAIN.DBInstLink);
  3787. }
  3788. void la_RelinkDBInst(laDBInst* dbi, void* New_OriginalInstance){
  3789. if(dbi->OriginalInstance){
  3790. laListHandle* l=hsh65536DoHashLongPtr(MAIN.DBInstLink,dbi->OriginalInstance); lstRemoveItem(l, &dbi->Item2);
  3791. }
  3792. dbi->OriginalInstance = New_OriginalInstance;
  3793. laListHandle* l=hsh65536DoHashLongPtr(MAIN.DBInstLink,dbi->OriginalInstance); lstPushItem(l, &dbi->Item2);
  3794. }
  3795. laDBInst* laAddDBInst(laDBProp* parent, void* inst, laPropContainer* pc, laDiff* Begin){
  3796. laDBInst* dbi=memAcquire(sizeof(laDBInst)); if(!Begin) Begin=MAIN.HeadDifference;
  3797. dbi->pc=pc;
  3798. if(parent){ lstAppendItem(&((laDBSubProp*)parent)->Instances, dbi); }
  3799. la_RelinkDBInst(dbi, inst);
  3800. return dbi;
  3801. }
  3802. laDBProp* laAddDBProp(laDBInst* dbi, laProp* p, void* data){
  3803. int size=sizeof(laDBProp);
  3804. if(p->PropertyType==LA_PROP_SUB && (!p->UDFIsRefer)){size=sizeof(laDBSubProp);}
  3805. elif(p->PropertyType==LA_PROP_RAW){size=sizeof(laDBRawProp);}
  3806. laDBProp* dbp=memAcquire(size);
  3807. dbp->p=p; dbp->Data=data;
  3808. lstAppendItem(&dbi->Props, dbp);
  3809. return dbp;
  3810. }
  3811. void laAddDBPReferAcquire(laDBProp* dbp){
  3812. if(!dbp->Data) return; if(!lstHasPointer(&MAIN.DBInstPendingAcquireDBP, dbp)) lstAppendPointer(&MAIN.DBInstPendingAcquireDBP, dbp);
  3813. }
  3814. void laAddDiffCMDReferAcquire(laDiffCommand* ds){
  3815. if(!ds->Data) return; if(!lstHasPointer(&MAIN.DBInstPendingAcquireDiffCMD, ds)) lstAppendPointer(&MAIN.DBInstPendingAcquireDiffCMD, ds);
  3816. }
  3817. laDiffCommand* la_GiveDiffCommand(laDiff* diff, laDBInst* Instance, laProp* p, void* Data){
  3818. for(laDiffCommand* dc=diff->Commands.pFirst;dc;dc=dc->Item.pNext){
  3819. if(dc->Instance == Instance && dc->p == p) return dc;
  3820. }
  3821. int size=sizeof(laDiffCommand);
  3822. if(p->PropertyType==LA_PROP_SUB && (!(p->UDFIsRefer||p->UDFIsSingle||p->UDFNoCreate))){size=sizeof(laDiffCommandSub);}
  3823. elif(p->PropertyType==LA_PROP_RAW){size=sizeof(laDiffCommandRaw);}
  3824. laDiffCommand* dc = memAcquire(size);
  3825. dc->Instance=Instance; dc->p=p; dc->Data = Data;
  3826. lstAppendItem(&diff->Commands,dc);
  3827. return dc;
  3828. }
  3829. void la_GiveExtraTouched(laDiff* diff, laDBInst* dbi){
  3830. if(!dbi->pc->UndoTouched) return;
  3831. laDiffExtraTouched* det=memAcquire(sizeof(laDiffExtraTouched));
  3832. det->dbi=dbi; lstAppendItem(&diff->ExtraTouched,det);
  3833. }
  3834. int la_AddIntDBProp(laDBInst* dbi, laDBProp* dbp, laDiff* diff, laPropPack *pp){
  3835. laProp *p = pp->LastPs->p; int *Data; int len = laGetArrayLength(pp); int ret=0;
  3836. Data= memAcquireSimple(sizeof(int)*len);
  3837. laGetIntArray(pp, Data); if(diff&&dbp){
  3838. if(memcmp(dbp->Data, Data, sizeof(int)*len)){ la_GiveDiffCommand(diff, dbi, p, dbp->Data); dbp->Data=Data; ret=1; } else memFree(Data);
  3839. }
  3840. else laAddDBProp(dbi, p, Data);
  3841. return ret;
  3842. }
  3843. int la_AddFloatDBProp(laDBInst* dbi, laDBProp* dbp, laDiff* diff, laPropPack *pp){
  3844. laProp *p = pp->LastPs->p; real *Data; int len = laGetArrayLength(pp); int ret=0;
  3845. Data= memAcquireSimple(sizeof(real)*len);
  3846. laGetFloatArray(pp, Data); if(diff&&dbp){
  3847. if(memcmp(dbp->Data, Data, sizeof(real)*len)){ la_GiveDiffCommand(diff, dbi, p, dbp->Data); dbp->Data=Data; ret=1; } else memFree(Data);
  3848. }
  3849. else laAddDBProp(dbi, p, Data);
  3850. return ret;
  3851. }
  3852. int la_AddStringDBProp(laDBInst* dbi, laDBProp* dbp, laDiff* diff, laPropPack *pp){
  3853. laProp *p = pp->LastPs->p; char _buf[LA_RAW_CSTR_MAX_LEN]={0}; char* buf=_buf; int ret=0;
  3854. laGetString(pp, _buf, &buf); if(diff&&dbp){
  3855. if((!dbp->Data&&buf[0]) || (buf[0] && strcmp(buf, ((laSafeString*)dbp->Data)->Ptr)) || (!buf[0]&&dbp->Data)){
  3856. laDiffCommand* dc=la_GiveDiffCommand(diff, dbi, p, dbp->Data); dbp->Data=0; strSafeSet(&dbp->Data, buf); ret=1; }
  3857. }else{
  3858. laDBProp* dbp=laAddDBProp(dbi, p, 0); strSafeSet(&dbp->Data, buf);
  3859. }
  3860. return ret;
  3861. }
  3862. int la_AddEnumDBProp(laDBInst* dbi, laDBProp* dbp, laDiff* diff, laPropPack *pp){
  3863. laProp *p = pp->LastPs->p; laEnumItem **Data=0; int len = laGetArrayLength(pp); int ret=0;
  3864. Data= memAcquireSimple(sizeof(laEnumItem*)*len);
  3865. laGetEnumArray(pp, Data); if(diff&&dbp){
  3866. if(memcmp(dbp->Data, Data, sizeof(laEnumItem*)*len)){ la_GiveDiffCommand(diff, dbi, p, dbp->Data); dbp->Data=Data; ret=1; } else memFree(Data);
  3867. }else laAddDBProp(dbi, p, Data);
  3868. return ret;
  3869. }
  3870. int la_AddRawDBProp(laDBInst* dbi, laDBRawProp* dbp, laDiff* diff, laPropPack *pp){
  3871. laProp *p = pp->LastPs->p; int *Data; int s=0; int ret=0; int IsCopy=0;
  3872. Data=laGetRaw(pp,&s,&IsCopy); if(diff&&dbp){
  3873. if(dbp->DataSize!=s || (!dbp->Data&&Data) || (!Data&&dbp->Data) || (dbp->Data&&Data&&memcmp(dbp->Data, Data, s))){
  3874. //printf("s%d %x %d \n",s,Data,dbp->DataSize);
  3875. void* NewData=(s&&Data)?calloc(1,s):0;
  3876. if(s&&Data)memcpy(NewData, Data, s);
  3877. laDiffCommandRaw* dcr=la_GiveDiffCommand(diff, dbi, p, dbp->Data);
  3878. dcr->DataSize=dbp->DataSize; dbp->Data=NewData; dbp->DataSize=s; ret=1;
  3879. }
  3880. }
  3881. else{
  3882. void* NewData=s?calloc(1,s):0; if(s) memcpy(NewData, Data, s);
  3883. laDBRawProp* dbp=laAddDBProp(dbi, p, NewData); dbp->DataSize=s;
  3884. }
  3885. if(IsCopy){ free(Data); }
  3886. return ret;
  3887. }
  3888. laDiffCommandInst* la_NewDiffCommandInst(laDBInst* DBInst, laDBInst* Prev, laDBInst* Next){
  3889. laDiffCommandInst* dci=memAcquire(sizeof(laDiffCommandInst));
  3890. dci->DBInst = DBInst; dci->OriginalPrev = Prev; dci->OriginalNext = Next;
  3891. dci->BeforePrev = DBInst->Item.pPrev; dci->BeforeNext = DBInst->Item.pNext;
  3892. return dci;
  3893. }
  3894. laDBInst* la_GetDiffDBInst(laListHandle* NewAdded, laListHandle* Master, void* instance){
  3895. if(!instance) return 0;
  3896. for(laDiffTemp* dt=NewAdded->pFirst;dt;dt=dt->Item.pNext){
  3897. if(((laDBInst*)dt->p)->OriginalInstance == instance) return dt->p;
  3898. }
  3899. for(laDBInst* dbi=Master->pFirst;dbi;dbi=dbi->Item.pNext){
  3900. if(dbi->OriginalInstance==instance) return dbi;
  3901. }
  3902. return 0;
  3903. }
  3904. int la_GenerateListDifferences(laDBInst* dbi, laDBSubProp* dbp, laPropPack* pp, laDiff* diff){
  3905. laProp *p = pp->LastPs->p, *subp = 0;
  3906. laPropIterator pi={0};
  3907. void* inst; int any=0;
  3908. laListHandle New={0}, NewAdded={0}, NewDeleted={0}, NewMoved={0};
  3909. inst = laGetInstance(p, pp->LastPs->UseInstance, &pi);
  3910. pp->EndInstance = inst;
  3911. while (inst){
  3912. if(p->UDFIsSingle){ memTake(inst); /* For single must take or it will be freed. */ }
  3913. lstAppendPointer(&New, inst);
  3914. inst = laGetNextInstance(p, inst, &pi);
  3915. pp->EndInstance = inst;
  3916. }
  3917. for(laDBInst* dbi=dbp->Instances.pFirst;dbi;dbi=dbi->Item.pNext){
  3918. void* OldPrev=dbi->Item.pPrev?((laDBInst*)dbi->Item.pPrev)->OriginalInstance:0;
  3919. void* OldNext=dbi->Item.pNext?((laDBInst*)dbi->Item.pNext)->OriginalInstance:0;
  3920. int found=0; for(laListItemPointer* lip=New.pFirst;lip;lip=lip->pNext){
  3921. void* NewPrev=lip->pPrev?((laListItemPointer*)lip->pPrev)->p:0;
  3922. void* NewNext=lip->pNext?((laListItemPointer*)lip->pNext)->p:0;
  3923. if(lip->p == dbi->OriginalInstance){
  3924. found=1;
  3925. if(OldPrev==NewPrev && OldNext==NewNext){break;}
  3926. else{ laDiffTemp* dt=lstAppendPointerSized(&NewMoved, dbi, sizeof(laDiffTemp));
  3927. dt->tPrev=dbi->Item.pPrev; dt->tNext=dbi->Item.pNext; dt->nPrev=NewPrev; dt->nNext=NewNext;break;}
  3928. }
  3929. }
  3930. if(!found){
  3931. laDiffTemp* dt=lstAppendPointerSized(&NewDeleted, dbi, sizeof(laDiffTemp));dt->tPrev=dbi->Item.pPrev;dt->tNext=dbi->Item.pNext; any++;
  3932. }
  3933. }
  3934. for(laListItemPointer* lip=New.pFirst;lip;lip=lip->pNext){
  3935. int found=0; for(laDBInst* dbi=dbp->Instances.pFirst;dbi;dbi=dbi->Item.pNext){
  3936. if(lip->p == dbi->OriginalInstance){ found=1; }
  3937. }
  3938. if(!found){ any++;
  3939. laDiffTemp* dt=lstAppendPointerSized(&NewAdded, lip->p, sizeof(laDiffTemp));
  3940. void* NewPrev=lip->pPrev?((laListItemPointer*)lip->pPrev)->p:0;
  3941. void* NewNext=lip->pNext?((laListItemPointer*)lip->pNext)->p:0;
  3942. dt->tPrev=NewPrev; dt->tNext=NewNext;
  3943. laPropContainer* spc=p->SubProp; if(((laSubProp*)p)->GetType){spc=((laSubProp*)p)->GetType(lip->p);}
  3944. laDBInst* newdbi=laAddDBInst(0, lip->p, spc, diff); dt->p=newdbi;
  3945. for (subp = spc->Props.pFirst; subp; subp = subp->Item.pNext){
  3946. if (subp->UDFIgnore || subp->UDFOnly) continue;
  3947. if (subp->PropertyType == LA_PROP_OPERATOR) continue;
  3948. laPropStep SubPS = {0}; laPropPack SubPP = {0}; laPropIterator pi={0};
  3949. SubPP.RawThis = pp; SubPS.p = subp; SubPS.UseInstance = lip->p; SubPP.LastPs=&SubPS;
  3950. any+=laIterateDB(newdbi, &SubPP, 0, 0);
  3951. }
  3952. }
  3953. }
  3954. for(laDiffTemp* lip=NewAdded.pFirst;lip;lip=lip->Item.pNext){
  3955. laDBInst* newdbi=lip->p;
  3956. lip->tPrev = la_GetDiffDBInst(&NewAdded, &dbp->Instances, lip->tPrev);
  3957. lip->tNext = la_GetDiffDBInst(&NewAdded, &dbp->Instances, lip->tNext);
  3958. }
  3959. for(laDiffTemp* lip=NewMoved.pFirst;lip;lip=lip->Item.pNext){
  3960. laDBInst* newdbi=lip->p;
  3961. lip->tPrev = la_GetDiffDBInst(&NewAdded, &dbp->Instances, lip->nPrev);
  3962. lip->tNext = la_GetDiffDBInst(&NewAdded, &dbp->Instances, lip->nNext);
  3963. }
  3964. laDiffCommandSub* dc=(NewAdded.pFirst||NewDeleted.pFirst||NewMoved.pFirst)?la_GiveDiffCommand(diff, dbi, p, 0):0;
  3965. for(laDiffTemp* lip=NewAdded.pFirst;lip;lip=lip->Item.pNext){
  3966. lstAppendItem(&dc->AddedInst, la_NewDiffCommandInst(lip->p, 0, 0));
  3967. laDBInst* newdbi=lip->p;
  3968. newdbi->Item.pPrev = lip->tPrev; newdbi->Item.pNext = lip->tNext;
  3969. if(!newdbi->Item.pPrev){dbp->Instances.pFirst=newdbi;}
  3970. if(!newdbi->Item.pNext){dbp->Instances.pLast=newdbi;}
  3971. }
  3972. for(laDiffTemp* lip=NewMoved.pFirst;lip;lip=lip->Item.pNext){
  3973. laDBInst* dbi=lip->p; lstAppendItem(&dc->MovedInst, la_NewDiffCommandInst(dbi, lip->tPrev, lip->tNext));
  3974. laDBInst* newdbi=lip->p;
  3975. newdbi->Item.pPrev = lip->tPrev; newdbi->Item.pNext = lip->tNext;
  3976. if(!dbi->Item.pPrev){dbp->Instances.pFirst=dbi;}
  3977. if(!dbi->Item.pNext){dbp->Instances.pLast=dbi;}
  3978. }
  3979. if(!New.pFirst){ dbp->Instances.pFirst=dbp->Instances.pLast=0; }
  3980. for(laDiffTemp* lip=NewDeleted.pFirst;lip;lip=lip->Item.pNext){printf("deleted %x %x\n", dbi, dbi->OriginalInstance);
  3981. laDBInst* dbi=lip->p; lstAppendItem(&dc->RemovedInst, la_NewDiffCommandInst(dbi, lip->tPrev, lip->tNext));
  3982. memTake(dbi->OriginalInstance);
  3983. //if(!dbi->Item.pPrev){dbp->Instances.pFirst=dbi->Item.pNext;}
  3984. //if(!dbi->Item.pNext){dbp->Instances.pLast=dbi->Item.pPrev;}
  3985. dbi->Item.pPrev=dbi->Item.pNext=0; //lstRemoveItem(&dbp->Instances, dbi);
  3986. laPropStep SubPS = {0}; laPropPack SubPP = {0}; laPropIterator pi={0}; laDBProp* dpi=0; SubPP.LastPs = &SubPS;
  3987. laPropContainer* spc=p->SubProp; if(((laSubProp*)p)->GetType){spc=((laSubProp*)p)->GetType(dbi->OriginalInstance);}
  3988. dpi=dbi->Props.pFirst;
  3989. for (subp = spc->Props.pFirst; subp; subp = subp->Item.pNext){
  3990. if (subp->PropertyType == LA_PROP_OPERATOR) continue;
  3991. if (subp->UDFIgnore || subp->UDFOnly) continue;
  3992. if((!dpi)||dpi->p!=subp) printf("Prop doesn't match\n");
  3993. SubPP.RawThis = pp; SubPS.p = subp; SubPS.UseInstance = dbi->OriginalInstance;
  3994. int thisany=laIterateDB(dbi, &SubPP, diff, dpi);
  3995. dpi=dpi->Item.pNext;
  3996. if(thisany){ any+=thisany; la_GiveExtraTouched(diff,dbi); }
  3997. }
  3998. dbi=dbi->Item.pNext;
  3999. }
  4000. //printf("%x ~ %x\n", dbp->Instances.pFirst, dbp->Instances.pLast);
  4001. //laListItem* item = laGetInstance(p, pp->LastPs->UseInstance, &pi);
  4002. //while (item){
  4003. // printf(" %x [%x] %x\n",item->pPrev, item, item->pNext);
  4004. // item = laGetNextInstance(p, item, &pi);
  4005. //}
  4006. return any;
  4007. }
  4008. int laIterateDB(laDBInst* parent, laPropPack* pp, laDiff* diff, laDBProp* dp){
  4009. laProp *p = pp->LastPs->p, *subp = 0;
  4010. laPropStep SubPS = {0}; laPropPack SubPP = {0}; laPropIterator pi={0};
  4011. laDBProp* dbp; laDBSubProp* dsp; laDBInst* dbi; laDBProp* dpi=0;
  4012. void *inst = 0;
  4013. SubPP.LastPs = &SubPS;
  4014. int any=0;
  4015. switch (p->PropertyType){
  4016. case LA_PROP_SUB:
  4017. if (p->UDFIsRefer){ if(!parent) return 0;
  4018. inst = laGetActiveInstanceStrict(p, pp->LastPs->UseInstance);
  4019. if(diff){
  4020. if(inst!=dp->Data) la_GiveDiffCommand(diff, parent, p, dp->Data); dp->Data=inst; any++;
  4021. }else{
  4022. laDBProp* rdbp=laAddDBProp(parent, p, inst);
  4023. }
  4024. }else{
  4025. if (!p->SubProp) p->SubProp = la_ContainerLookup(((laSubProp *)p)->TargetID);
  4026. if(diff){ any+=la_GenerateListDifferences(parent, dp, pp, diff); dsp=dp; dbi=dsp->Instances.pFirst; dbp=dsp; }
  4027. else{ dbp=laAddDBProp(parent, p, laGetActiveInstance(p, pp->LastPs->UseInstance, &pi)); }
  4028. inst = laGetInstance(p, pp->LastPs->UseInstance, &pi);
  4029. pp->EndInstance = inst;
  4030. while (inst){ //printf("work %x\n",inst);
  4031. laPropContainer* spc=p->SubProp; if(((laSubProp*)p)->GetType){spc=((laSubProp*)p)->GetType(inst);}
  4032. if(!spc){ inst = laGetNextInstance(p, inst, &pi); continue; } // unlikely, because not registered
  4033. if(diff){
  4034. if(dbi->OriginalInstance != inst){
  4035. printf("dbi/inst doesn't match.\n"); }
  4036. dpi=dbi->Props.pFirst;
  4037. }else{ dbi = laAddDBInst(dbp, inst, spc, 0); }
  4038. for (subp = spc->Props.pFirst; subp; subp = subp->Item.pNext){
  4039. if (subp->PropertyType == LA_PROP_OPERATOR) continue;
  4040. if (subp->UDFIgnore || subp->UDFOnly) continue;
  4041. if(diff && ((!dpi)||dpi->p!=subp)){
  4042. printf("Prop doesn't match\n");}
  4043. SubPP.RawThis = pp; SubPS.p = subp; SubPS.UseInstance = inst;
  4044. int thisany=laIterateDB(dbi, &SubPP, diff, dpi);
  4045. if(diff && dpi){ dpi=dpi->Item.pNext;
  4046. if(thisany){ any+=thisany;
  4047. la_GiveExtraTouched(diff,dbi); }
  4048. }
  4049. }
  4050. inst = laGetNextInstance(p, inst, &pi);
  4051. pp->EndInstance = inst;
  4052. if(diff){ dbi=dbi->Item.pNext; }
  4053. }
  4054. }
  4055. break;
  4056. case LA_PROP_INT: case LA_PROP_ARRAY | LA_PROP_INT:
  4057. any+=la_AddIntDBProp(parent, dp, diff, pp); break;
  4058. case LA_PROP_FLOAT: case LA_PROP_ARRAY | LA_PROP_FLOAT:
  4059. any+=la_AddFloatDBProp(parent, dp, diff, pp); break;
  4060. case LA_PROP_STRING:
  4061. any+=la_AddStringDBProp(parent, dp, diff, pp); break;
  4062. case LA_PROP_ENUM: case LA_PROP_ARRAY | LA_PROP_ENUM:
  4063. any+=la_AddEnumDBProp(parent, dp, diff, pp); break;
  4064. case LA_PROP_RAW:
  4065. any+=la_AddRawDBProp(parent,dp,diff,pp); break;
  4066. default: break;
  4067. }
  4068. return any;
  4069. }
  4070. void la_RestoreIntDBProp(laDBProp* dbp, laDiffCommand* dc){
  4071. laPropPack pp={0}; laPropStep ps={0}; ps.p=dc->p; pp.LastPs=&ps; ps.UseInstance=dc->Instance->OriginalInstance;
  4072. int *Data; Data=dc->Data; dc->Data=dbp->Data; dbp->Data=Data;
  4073. laSetIntArrayAllArray(&pp, dbp->Data);
  4074. }
  4075. void la_RestoreFloatDBProp(laDBProp* dbp, laDiffCommand* dc){
  4076. laPropPack pp={0}; laPropStep ps={0}; ps.p=dc->p; pp.LastPs=&ps; ps.UseInstance=dc->Instance->OriginalInstance;
  4077. int *Data; Data=dc->Data; dc->Data=dbp->Data; dbp->Data=Data;
  4078. laSetFloatArrayAllArray(&pp, dbp->Data);
  4079. }
  4080. void la_RestoreStringDBProp(laDBProp* dbp, laDiffCommand* dc){
  4081. laPropPack pp={0}; laPropStep ps={0}; ps.p=dc->p; pp.LastPs=&ps; ps.UseInstance=dc->Instance->OriginalInstance;
  4082. int *Data; Data=dc->Data; dc->Data=dbp->Data; dbp->Data=Data;
  4083. laSetString(&pp, dbp->Data?((laSafeString*)dbp->Data)->Ptr:0);
  4084. }
  4085. void la_RestoreEnumDBProp(laDBProp* dbp, laDiffCommand* dc){
  4086. laPropPack pp={0}; laPropStep ps={0}; ps.p=dc->p; pp.LastPs=&ps; ps.UseInstance=dc->Instance->OriginalInstance;
  4087. int *Data; Data=dc->Data; dc->Data=dbp->Data; dbp->Data=Data;
  4088. laSetEnumArrayAllArray(&pp, dbp->Data);
  4089. }
  4090. void la_RestoreRawDBProp(laDBRawProp* dbp, laDiffCommandRaw* dc){
  4091. laPropPack pp={0}; laPropStep ps={0}; ps.p=dc->p; pp.LastPs=&ps; ps.UseInstance=dc->Instance->OriginalInstance;
  4092. int *Data; Data=dc->Data; dc->Data=dbp->Data; dbp->Data=Data; LA_SWAP(int, dc->DataSize, dbp->DataSize);
  4093. laSetRaw(&pp,dbp->Data,dbp->DataSize);
  4094. }
  4095. void la_AddUndoPostNode(laDBInst* dbi){
  4096. if((!dbi->pc) || (!dbi->pc->UndoTouched)) return;
  4097. for(laDiffPost* dp=MAIN.DiffTouched.pLast;dp;dp=dp->Item.pPrev){ if(dp->instance==dbi->OriginalInstance&&dp->Touched==dbi->pc->UndoTouched) return; }
  4098. laDiffPost* dp=lstAppendPointerSized(&MAIN.DiffTouched, dbi->OriginalInstance, sizeof(laDiffPost));
  4099. dp->Touched=dbi->pc->UndoTouched;
  4100. }
  4101. void la_ExecUndoPtrSync(laDiff* d){
  4102. int hint=d->Hint; laDiffPtrSync* dps; laDiffPost* dp; laDBInstPendingRelink* dpr;
  4103. while(dp=lstPopItem(&MAIN.DiffTouched)){
  4104. dp->Touched(dp->instance, hint);
  4105. memFree(dp);
  4106. }
  4107. for(laDiffExtraTouched*det=d->ExtraTouched.pFirst;det;det=det->Item.pNext){
  4108. det->dbi->pc->UndoTouched(det->dbi->OriginalInstance, hint);
  4109. }
  4110. }
  4111. void la_FreeInstance(void* inst, laPropContainer* pc, int no_free){
  4112. //if(p->PropertyType!=LA_PROP_SUB) return;
  4113. //if(!p->SubProp || ((laSubProp*)p)->TargetID) p->SubProp=la_ContainerLookup(((laSubProp*)p)->TargetID);
  4114. //laPropContainer* pc=p->SubProp; if(((laSubProp*)p)->GetType) pc=((laSubProp*)p)->GetType(inst);
  4115. //printf("freeinst %s %x\n",pc->Name,inst);
  4116. if(pc->BeforeFree) pc->BeforeFree(inst);
  4117. laPropStep SubPS = {0}; laPropPack SubPP = {0}; laPropIterator pi={0}; SubPP.LastPs=&SubPS;
  4118. for(laProp* p=pc->Props.pFirst;p;p=p->Item.pNext){
  4119. if(p->PropertyType==LA_PROP_STRING && ((laStringProp*)p)->IsSafeString){ SubPS.p=p; SubPS.UseInstance=inst; laSetString(&SubPP, 0); continue; }
  4120. //if(p->PropertyType!=LA_PROP_SUB || p->UDFIsRefer) continue;
  4121. //void* si = laGetInstance(p, SubPP.LastPs->UseInstance, &pi); SubPP.EndInstance = si; void* NextSi=0;
  4122. //printf("freeinst p %s\n",p->Name);
  4123. //while (si){
  4124. // printf("%x --inst %x\n",SubPP.LastPs->UseInstance,si);
  4125. // NextSi = laGetNextInstance(p, si, &pi);
  4126. // if(!p->UDFNoCreate){ laSubProp* sp=p;
  4127. // if(!sp->ListHandleOffset){ logPrint("[WARN] prop '%s' UDFNoCreate==0 and no ListHandleOffset. Node not removed.\n", p->Identifier); }
  4128. // else{ lstRemoveItem(inst + sp->ListHandleOffset, si); }
  4129. // }
  4130. // la_FreeInstance(si, p, p->UDFNoCreate||(!p->OffsetIsPointer));
  4131. // si=NextSi; SubPP.EndInstance = si;
  4132. //}
  4133. }
  4134. if(!no_free && !pc->OtherAlloc) memFree(inst);
  4135. }
  4136. void la_ResetInstance(void* inst, laPropContainer* pc, int IsListItem){
  4137. if(pc->SaverDummy) laMarkMemClean(((char*)inst)+((laSubProp*)pc->SaverDummy)->ListHandleOffset);
  4138. if(pc->Reset) pc->Reset(inst); //else { int a=IsListItem?sizeof(laListItem):0; memset(((char*)inst)+a,0,pc->NodeSize-a); }
  4139. }
  4140. laListHandle* la_GetOriginalListHandle(laDiffCommandSub* dcs){
  4141. laProp*p =dcs->Base.p;
  4142. if(p->PropertyType!=LA_PROP_SUB||p->UDFIsRefer||!((laSubProp*)p)->ListHandleOffset) return 0;
  4143. laSubProp* sp=dcs->Base.p;
  4144. void* addr=((char*)dcs->Base.Instance->OriginalInstance)+((laSubProp*)p)->ListHandleOffset;
  4145. return addr;
  4146. }
  4147. void la_UndoListDifferences(laDBSubProp* dsp, laDiffCommandSub* dcs){
  4148. laListHandle* ol=la_GetOriginalListHandle(dcs);
  4149. for(laDiffCommandInst* dci=dcs->AddedInst.pFirst;dci;dci=dci->Item.pNext){
  4150. if(dcs->Base.p->UDFNoCreate){ la_ResetInstance(dci->DBInst->OriginalInstance,dci->DBInst->pc,((laSubProp*)dcs->Base.p)->ListHandleOffset?1:0); continue; }
  4151. dci->OriginalPrev = dci->DBInst->Item.pPrev; dci->OriginalNext = dci->DBInst->Item.pNext;
  4152. //if(dsp->Instances.pFirst == dci->DBInst){ dsp->Instances.pFirst=dci->DBInst->Item.pNext; ol->pFirst=dci->DBInst->Item.pNext?((laDBInst*)dci->DBInst->Item.pNext)->OriginalInstance:0; }
  4153. //if(dsp->Instances.pLast == dci->DBInst){ dsp->Instances.pLast=dci->DBInst->Item.pPrev; ol->pLast=dci->DBInst->Item.pPrev?((laDBInst*)dci->DBInst->Item.pPrev)->OriginalInstance:0; }
  4154. //dci->DBInst->Item.pPrev = dci->DBInst->Item.pNext=0;
  4155. }
  4156. for(laDiffCommandInst* dci=dcs->AddedInst.pFirst;dci;dci=dci->Item.pNext){
  4157. if(dcs->Base.p->UDFNoCreate){ continue; }
  4158. lstRemoveItem(&dsp->Instances, dci->DBInst); lstRemoveItem(ol, dci->DBInst->OriginalInstance);
  4159. laListItem* li = dci->DBInst->OriginalInstance;
  4160. }
  4161. for(laDiffCommandInst* dci=dcs->RemovedInst.pFirst;dci;dci=dci->Item.pNext){ if(dcs->Base.p->UDFNoCreate) continue;
  4162. dci->DBInst->Item.pPrev = dci->OriginalPrev;
  4163. dci->DBInst->Item.pNext = dci->OriginalNext; printf("add removed %s %x \n",dci->DBInst->pc->Identifier, dci->DBInst->OriginalInstance);
  4164. void* orig = dci->DBInst->OriginalInstance;
  4165. }
  4166. for(laDiffCommandInst* dci=dcs->RemovedInst.pFirst;dci;dci=dci->Item.pNext){ if(dcs->Base.p->UDFNoCreate) continue;
  4167. ((laListItem*)dci->DBInst->OriginalInstance)->pPrev=dci->OriginalPrev?dci->OriginalPrev->OriginalInstance:0;
  4168. ((laListItem*)dci->DBInst->OriginalInstance)->pNext=dci->OriginalNext?dci->OriginalNext->OriginalInstance:0;
  4169. if(!dci->DBInst->Item.pPrev){ dsp->Instances.pFirst=dci->DBInst; ol->pFirst=dci->DBInst->OriginalInstance; }
  4170. if(!dci->DBInst->Item.pNext){ dsp->Instances.pLast=dci->DBInst; ol->pLast=dci->DBInst->OriginalInstance; }
  4171. }
  4172. for(laDiffCommandInst* dci=dcs->MovedInst.pFirst;dci;dci=dci->Item.pNext){
  4173. dci->DBInst->Item.pPrev = dci->BeforePrev; ((laListItem*)dci->DBInst->OriginalInstance)->pPrev=dci->BeforePrev?dci->BeforePrev->OriginalInstance:0;
  4174. dci->DBInst->Item.pNext = dci->BeforeNext; ((laListItem*)dci->DBInst->OriginalInstance)->pNext=dci->BeforeNext?dci->BeforeNext->OriginalInstance:0;
  4175. if(!dci->DBInst->Item.pPrev){ dsp->Instances.pFirst=dci->DBInst; ol->pFirst=dci->DBInst->OriginalInstance; }
  4176. if(!dci->DBInst->Item.pNext){ dsp->Instances.pLast=dci->DBInst; ol->pLast=dci->DBInst->OriginalInstance; }
  4177. }
  4178. }
  4179. void la_RedoListDifferences(laDBSubProp* dsp, laDiffCommandSub* dcs){
  4180. laListHandle* ol=la_GetOriginalListHandle(dcs);
  4181. for(laDiffCommandInst* dci=dcs->RemovedInst.pFirst;dci;dci=dci->Item.pNext){
  4182. if(dcs->Base.p->UDFNoCreate){ la_ResetInstance(dci->DBInst->OriginalInstance,dci->DBInst->pc,((laSubProp*)dcs->Base.p)->ListHandleOffset?1:0); continue; }
  4183. //dci->OriginalPrev = dci->DBInst->Item.pPrev;
  4184. //dci->OriginalNext = dci->DBInst->Item.pNext;
  4185. lstRemoveItem(&dsp->Instances, dci->DBInst); lstRemoveItem(ol, dci->DBInst->OriginalInstance);
  4186. laListItem* li = dci->DBInst->OriginalInstance;
  4187. printf("remove %x \n", dci->DBInst->OriginalInstance);
  4188. }
  4189. for(laDiffCommandInst* dci=dcs->AddedInst.pFirst;dci;dci=dci->Item.pNext){ if(dcs->Base.p->UDFNoCreate) continue;
  4190. dci->DBInst->Item.pPrev = dci->OriginalPrev;
  4191. dci->DBInst->Item.pNext = dci->OriginalNext;
  4192. void* orig = dci->DBInst->OriginalInstance;
  4193. }
  4194. for(laDiffCommandInst* dci=dcs->AddedInst.pFirst;dci;dci=dci->Item.pNext){ if(dcs->Base.p->UDFNoCreate) continue;
  4195. ((laListItem*)dci->DBInst->OriginalInstance)->pPrev=dci->OriginalPrev?dci->OriginalPrev->OriginalInstance:0;
  4196. ((laListItem*)dci->DBInst->OriginalInstance)->pNext=dci->OriginalNext?dci->OriginalNext->OriginalInstance:0;
  4197. if(!dci->DBInst->Item.pPrev){ dsp->Instances.pFirst=dci->DBInst; ol->pFirst=dci->DBInst->OriginalInstance; }
  4198. if(!dci->DBInst->Item.pNext){ dsp->Instances.pLast=dci->DBInst; ol->pLast=dci->DBInst->OriginalInstance; }
  4199. }
  4200. for(laDiffCommandInst* dci=dcs->MovedInst.pFirst;dci;dci=dci->Item.pNext){
  4201. dci->DBInst->Item.pPrev = dci->OriginalPrev; ((laListItem*)dci->DBInst->OriginalInstance)->pPrev=dci->OriginalPrev?dci->OriginalPrev->OriginalInstance:0;
  4202. dci->DBInst->Item.pNext = dci->OriginalNext; ((laListItem*)dci->DBInst->OriginalInstance)->pNext=dci->OriginalNext?dci->OriginalNext->OriginalInstance:0;
  4203. if(!dci->DBInst->Item.pPrev){ dsp->Instances.pFirst=dci->DBInst; ol->pFirst=dci->DBInst->OriginalInstance; }
  4204. if(!dci->DBInst->Item.pNext){ dsp->Instances.pLast=dci->DBInst; ol->pLast=dci->DBInst->OriginalInstance; }
  4205. }
  4206. }
  4207. laDBProp* la_FindDBProp(laDBInst* dbi, laProp* p){
  4208. for(laDBProp* dbp=dbi->Props.pFirst;dbp;dbp=dbp->Item.pNext){
  4209. if(dbp->p==p) return dbp;
  4210. }
  4211. return 0;
  4212. }
  4213. void tnsPrintMaterials();
  4214. laDiff* laSwapDBState(int Redo){
  4215. laDiff* diff=MAIN.HeadDifference; if(!diff) return 0;
  4216. if(Redo){ if(diff==MAIN.Differences.pLast) return 0; }else{ diff=diff->Item.pPrev; if(!diff) return 0; }
  4217. for(laDiffCommand* dc=diff->Commands.pFirst;dc;dc=dc->Item.pNext){
  4218. //printf("do %s\n",dc->p->Identifier);
  4219. laDBProp* dbp=la_FindDBProp(dc->Instance, dc->p);
  4220. if(!dbp){ printf("Can't find dbp from prop!\n");}
  4221. switch (dc->p->PropertyType){
  4222. case LA_PROP_SUB:
  4223. if(dc->p->UDFIsRefer){
  4224. LA_SWAP(void*,dc->Data,dbp->Data);
  4225. laSetActiveInstance(dbp->p, dc->Instance->OriginalInstance, dbp->Data);
  4226. }else{
  4227. if(Redo) la_RedoListDifferences(dbp,dc);
  4228. else la_UndoListDifferences(dbp,dc);
  4229. }
  4230. la_AddUndoPostNode(dc->Instance);
  4231. break;
  4232. case LA_PROP_INT: case LA_PROP_ARRAY | LA_PROP_INT:
  4233. la_RestoreIntDBProp(dbp, dc); la_AddUndoPostNode(dc->Instance); break;
  4234. case LA_PROP_FLOAT: case LA_PROP_ARRAY | LA_PROP_FLOAT:
  4235. la_RestoreFloatDBProp(dbp, dc); la_AddUndoPostNode(dc->Instance); break;
  4236. case LA_PROP_STRING:
  4237. la_RestoreStringDBProp(dbp, dc); la_AddUndoPostNode(dc->Instance); break;
  4238. case LA_PROP_ENUM: case LA_PROP_ARRAY | LA_PROP_ENUM:
  4239. la_RestoreEnumDBProp(dbp, dc); la_AddUndoPostNode(dc->Instance); break;
  4240. case LA_PROP_RAW:
  4241. la_RestoreRawDBProp(dbp, dc); la_AddUndoPostNode(dc->Instance); break;
  4242. default: break;
  4243. }
  4244. laPropPack PP={0}; laPropStep PS={0}; PP.LastPs=&PS; PS.p=dbp->p; PS.UseInstance=dc->Instance->OriginalInstance;
  4245. laNotifyUsersPP(&PP);
  4246. }
  4247. for(laDiffCommandCustom* dcc=diff->CustomCommands.pFirst;dcc;dcc=dcc->Item.pNext){
  4248. if(Redo){ if(dcc->Redo) dcc->Redo(dcc->Data); } else { if(dcc->Undo) dcc->Undo(dcc->Data); }
  4249. }
  4250. tnsPrintMaterials();
  4251. if(Redo){ MAIN.HeadDifference=diff->Item.pNext; }
  4252. else{ MAIN.HeadDifference=diff; }
  4253. return diff;
  4254. }
  4255. void laUndo(){ laDiff* d; if(d=laSwapDBState(0)){ la_ExecUndoPtrSync(d); laNotifyUsers("la.differences"); } }
  4256. void laRedo(){ laDiff* d; if(d=laSwapDBState(1)){ la_ExecUndoPtrSync(d); laNotifyUsers("la.differences"); } }
  4257. void laPrintDBInst(laDBInst* dbi, int Level){
  4258. if(dbi!=&MAIN.RootDBInst){
  4259. printf("%*c", Level, ' ');
  4260. printf("%s | %.6x [%.6x] %.6x | %.6x [%.6x] %.6x\n",
  4261. dbi->pc->Identifier, dbi->Item.pPrev, dbi, dbi->Item.pNext,
  4262. dbi->Item.pPrev?((laDBInst*)dbi->Item.pPrev)->OriginalInstance:0, dbi->OriginalInstance, dbi->Item.pNext?((laDBInst*)dbi->Item.pNext)->OriginalInstance:0);
  4263. }else{
  4264. printf("Root:\n");
  4265. }
  4266. for(laDBProp* dbp=dbi->Props.pFirst;dbp;dbp=dbp->Item.pNext){
  4267. if(dbp->p->PropertyType==LA_PROP_SUB && !dbp->p->UDFIsRefer){
  4268. laDBSubProp* dsp=dbp;
  4269. for(laDBInst* dbii=dsp->Instances.pFirst;dbii;dbii=dbii->Item.pNext){
  4270. laPrintDBInst(dbii, Level+4);
  4271. }
  4272. }
  4273. }
  4274. }
  4275. void laPrintDBInstInfo(){
  4276. laPrintDBInst(&MAIN.RootDBInst, 0);
  4277. }
  4278. void laAddRootDBInst(char* path){
  4279. laPropPack PP={0};
  4280. if(!la_GetPropFromPath(&PP,0,path,0)) return;
  4281. if(!MAIN.DBInstLink){ hsh65536Init(&MAIN.DBInstLink); }
  4282. la_StepPropPack(&PP);
  4283. laIterateDB(&MAIN.RootDBInst, &PP, 0, 0);
  4284. la_FreePropStepCache(PP.Go);
  4285. laDBRecordedProp* rp=lstAppendPointerSized(&MAIN.DBRecordedProps, 0, sizeof(laDBRecordedProp));
  4286. strSafeSet(&rp->OriginalPath,path);
  4287. }
  4288. void laPropPackToLocal(laPropPack* ToPP, laPropPack* pp){
  4289. if(pp->RawThis) laPropPackToLocal(ToPP, pp->RawThis);
  4290. for(laPropStep* ps=pp->Go;ps;ps=ps->pNext){
  4291. la_NewPropStep(ToPP, ps->p, ps->UseInstance, '.');
  4292. }
  4293. ToPP->EndInstance = pp->EndInstance;
  4294. }
  4295. laDBProp* laFindDBProp(laDBInst* parent, laProp* p, void* Instance, laDBInst** r_DBInst){
  4296. laDBProp* rp=0;
  4297. for(laDBProp* dp=parent->Props.pFirst;dp;dp=dp->Item.pNext){
  4298. if(dp->p == p) {rp=dp; break;}
  4299. } if(!rp) return 0;
  4300. if(rp->p->PropertyType==LA_PROP_SUB && !rp->p->UDFIsRefer && r_DBInst && Instance){
  4301. laDBSubProp* dsp=rp; for(laDBInst* dbii=dsp->Instances.pFirst;dbii;dbii=dbii->Item.pNext){
  4302. if(dbii->OriginalInstance == Instance) { *r_DBInst=dbii; break; }
  4303. }
  4304. }
  4305. return rp;
  4306. }
  4307. laDBProp* laFindStartingDBProp(laProp* p, void* Instance, laPropContainer* InstancePC, laDBInst** r_DBInst){
  4308. if(!Instance||Instance==MAIN.DataRoot.RootInstance){
  4309. for(laDBProp*dbp=MAIN.RootDBInst.Props.pFirst;dbp;dbp=dbp->Item.pNext){
  4310. if(dbp->p == p){ *r_DBInst=&MAIN.RootDBInst; return dbp; }
  4311. }
  4312. } /* If root not found try to find it in the hash. */
  4313. if(!MAIN.DBInstLink){ return 0; }
  4314. laListHandle* l=hsh65536DoHashLongPtr(MAIN.DBInstLink, Instance); if(!l) return 0;
  4315. for(laListItem* li=l->pFirst;li;li=li->pNext){
  4316. laDBInst* dbi=(laDBInst*)(((char*)li)-sizeof(laListItem)); if(dbi->OriginalInstance==Instance && dbi->pc==InstancePC){
  4317. if(p){ for(laDBProp*dbp=dbi->Props.pFirst;dbp;dbp=dbp->Item.pNext){ if(dbp->p == p){ *r_DBInst=dbi; return dbp; } } }
  4318. else{ *r_DBInst=dbi; return 0; }
  4319. }
  4320. }
  4321. return 0;
  4322. }
  4323. void laRecordCustomDifferences(void* Data, laDiffCommandUndoF Undo, laDiffCommandRedoF Redo, laDiffCommandFreeF Free){
  4324. laDiffCommandCustom* dcc=memAcquire(sizeof(laDiffCommandCustom));
  4325. dcc->Data=Data; dcc->Undo=Undo; dcc->Redo=Redo; dcc->Free=Free;
  4326. lstAppendItem(&MAIN.HeadDifference->CustomCommands,dcc);
  4327. }
  4328. int laRecordDifferences(laPropPack* base, char* path){
  4329. laPropPack PP={0};
  4330. if(!la_GetPropFromPath(&PP,base,path,0)) return 0;
  4331. la_StepPropPack(&PP);
  4332. //laPropPackToLocal(&LocalPP, &PP);
  4333. int success=0;
  4334. laDBInst* FromDBI; //=laSkipDB(&LocalPP, &MAIN.RootDBInst, &dbp);
  4335. laDBProp* dbp=laFindStartingDBProp(PP.LastPs->p, PP.LastPs->UseInstance, PP.LastPs->p->Container, &FromDBI);
  4336. if(FromDBI && dbp){
  4337. laFreeNewerDifferences();
  4338. laIterateDB(FromDBI, &PP, MAIN.HeadDifference, dbp);
  4339. if(MAIN.HeadDifference->Commands.pFirst){ success = 1; }
  4340. }else{
  4341. success = 0; //printf("Prop not recorded as DBInst.\n");
  4342. }
  4343. la_FreePropStepCache(PP.Go);
  4344. return success;
  4345. }
  4346. int laRecordInstanceDifferences(void* instance, const char* container){
  4347. laPropContainer* pc=la_ContainerLookup(container); if(!pc) return 0;
  4348. laDBInst* FromDBI=0;
  4349. laFindStartingDBProp(0,instance,pc,&FromDBI); if(!FromDBI) return 0;
  4350. laPropPack PP={0}; laPropStep PS={0}; PS.UseInstance=instance; PP.LastPs=&PS;
  4351. int freed=0, success=0, any=0;
  4352. for(laProp* p=pc->Props.pFirst;p;p=p->Item.pNext){
  4353. PS.p = p; laDBProp* dbp=laFindDBProp(FromDBI, p, 0,0);
  4354. if(FromDBI && dbp){
  4355. if(!freed){ laFreeNewerDifferences(); freed=1; }
  4356. any+=laIterateDB(FromDBI, &PP, MAIN.HeadDifference, dbp);
  4357. if(MAIN.HeadDifference->Commands.pFirst){ success = 1; }
  4358. }
  4359. }
  4360. if(any){ la_GiveExtraTouched(MAIN.HeadDifference,FromDBI); }
  4361. return success;
  4362. }
  4363. void laRecordAndPush(laPropPack* base, char* path, char* description, uint64_t hint){
  4364. if(laRecordDifferences(base, path)){ laPushDifferences(description, hint); }
  4365. }
  4366. void laRecordAndPushProp(laPropPack* base, char* path){
  4367. char buf[256]={0};
  4368. if(laRecordDifferences(base, path)){
  4369. la_GetPropPackFullPath(base,&buf[strlen(buf)]);if(path){sprintf(&buf[strlen(buf)],"%s%s",base?".":"",path);}
  4370. laPushDifferences(buf, 0);
  4371. }
  4372. }
  4373. void laRecordEverythingAndPush(){
  4374. for(laDBRecordedProp* rp=MAIN.DBRecordedProps.pFirst;rp;rp=rp->Item.pNext){
  4375. laRecordAndPushProp(0, rp->OriginalPath->Ptr);
  4376. }
  4377. if(MAIN.PushEverything){ MAIN.PushEverything(); }
  4378. }
  4379. void laSetDiffCallback(laDiffPushEverythingF PushEverything){
  4380. MAIN.PushEverything=PushEverything;
  4381. }