LaGUI/resources/la_properties.c

/*
* LaGUI: A graphical application framework.
* Copyright (C) 2022 Wu Yiming
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "../la_5.h"

extern LA MAIN;
extern struct _tnsMain *T;

void *laget_ActiveTheme(void *unused){
    return MAIN.CurrentTheme;
}
void laset_ActiveTheme(void* unused, laTheme* t){
    if(!t) MAIN.CurrentTheme = MAIN.Themes.pFirst;
    else MAIN.CurrentTheme = t;
    la_RefreshThemeColor(MAIN.CurrentTheme);
    la_RegenerateWireColors();
    laRedrawAllWindows();
}
void laset_ThemeName(laTheme *t, char *content){
    strSafeSet(&t->Name, content);
}
void laset_ThemeAuthor(laTheme *t, char *content){
    strSafeSet(&t->Author, content);
}
void laset_ThemeColor(laTheme* t, real* array){
    tnsVectorCopy4d(array,t->Color);
    la_RefreshThemeColor(t);
    laRedrawAllWindows();
}
void laset_ThemeAccentColor(laTheme* t, real* array){
    tnsVectorCopy4d(array,t->AccentColor);
    la_RefreshThemeColor(t);
    laRedrawAllWindows();
}
void laset_ThemeInactiveSaturation(laTheme* t, real a){
    t->InactiveSaturation=a;
    la_RefreshThemeColor(t);
    laRedrawAllWindows();
}
void laset_ThemeInactiveMix(laTheme* t, real a){
    t->InactiveMix=a;
    la_RefreshThemeColor(t);
    laRedrawAllWindows();
}
void laset_ThemeCursorAlpha(laTheme* t, real a){
    t->CursorAlpha=a;
    la_RefreshThemeColorSelf(t);
    laRedrawAllWindows();
}
void laset_ThemeSelectionAlpha(laTheme* t, real a){
    t->SelectionAlpha=a;
    la_RefreshThemeColorSelf(t);
    laRedrawAllWindows();
}
void laset_ThemeNormal(laBoxedTheme* bt, real val){
    bt->NormalY=val;
    la_RefreshBoxedThemeColor(bt);
    laRedrawAllWindows();
}
void laset_ThemeActive(laBoxedTheme* bt, real val){
    bt->ActiveY=val;
    la_RefreshBoxedThemeColor(bt);
    laRedrawAllWindows();
}
void laset_ThemeBorder(laBoxedTheme* bt, real val){
    bt->BorderY=val;
    la_RefreshBoxedThemeColor(bt);
    laRedrawAllWindows();
}
void laset_ThemeText(laBoxedTheme* bt, real val){
    bt->TextY=val;
    la_RefreshBoxedThemeColor(bt);
    laRedrawAllWindows();
}
void laset_ThemeTextActive(laBoxedTheme* bt, real val){
    bt->TextActiveY=val;
    la_RefreshBoxedThemeColor(bt);
    laRedrawAllWindows();
}
void laset_ThemeAlpha(laBoxedTheme* bt, real val){
    bt->Alpha=val;
    la_RefreshBoxedThemeColor(bt);
    laRedrawAllWindows();
}
void laset_ThemeMargins(laBoxedTheme* bt, int index, real val){
    bt->Margins[index]=val;
    la_RefreshBoxedThemeColor(bt);
    laRedrawAllWindows();
}
void laset_ThemePaddings(laBoxedTheme* bt, int index, real val){
    bt->Paddings[index]=val;
    la_RefreshBoxedThemeColor(bt);
    laRedrawAllWindows();
}
void laset_ThemeWireTransparency(laTheme* t, real val){ t->WireTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeWireBrightness(laTheme* t, real val){ t->WireBrightness = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeWireSaturation(laTheme* t, real val){ t->WireSaturation = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeEdgeTransparency(laTheme* t, real val){ t->EdgeTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeEdgeBrightness(laTheme* t, real val){ t->EdgeBrightness = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeVertexTransparency(laTheme* t, real val){ t->VertexTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeVertexBrightness(laTheme* t, real val){ t->VertexBrightness = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeSVertexTransparency(laTheme* t, real val){ t->SelectedVertexTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeSEdgeTransparency(laTheme* t, real val){ t->SelectedEdgeTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_ThemeSFaceTransparency(laTheme* t, real val){ t->SelectedFaceTransparency = val; la_RegenerateWireColors(); laRedrawAllWindows(); }

void laset_WireColorSlices(void* unused, int val){ MAIN.WireColorSlices = val; la_RegenerateWireColors(); laRedrawAllWindows(); }
void laset_WireThickness(void* unused, real val){ MAIN.WireThickness = val;laRedrawAllWindows(); }
void laset_WireSaggyness(void* unused, real val){ MAIN.WireSaggyness = val; laRedrawAllWindows(); }

void* laget_DetachedControllerFirst(void* unused,void* unused2){
    return MAIN.Controllers.pFirst;
}

void laset_UiRowHeight(void* unused, int val){
    MAIN.UiRowHeight = val;
    MAIN.ScaledUiRowHeight=MAIN.UiRowHeight;
    la_RefreshThemeColor(MAIN.CurrentTheme);
    tnsInvalidateFontCache();
    laRedrawAllWindows();
}
void laset_FontSize(void* unused, real val){
    MAIN.FontSize = val;
    MAIN.ScaledUiRowHeight=MAIN.UiRowHeight;
    tnsInvalidateFontCache();
    laRedrawAllWindows();
}
void laset_MarginSize(void* unused, real val){
    MAIN.MarginSize = val;
    la_RefreshThemeColor(MAIN.CurrentTheme);
    laRedrawAllWindows();
}

void laset_ResourcePath(laResourceFolder *rf, char *content){
    strSafeSet(&rf->Path, content);
    laRefreshUDFRegistries();
}

void *laget_Self(void *p, void *UNUSED){
    return p;
}

void *laget_ListNext(laListItem *Item, void *UNUSED){
    return Item->pNext;
}
void *laget_ListPrev(laListItem *Item, void *UNUSED){
    return Item->pPrev;
}
void *laget_List2Next(laListItem2 *Item, void *UNUSED){
    return Item->pNext;
}
void *laget_List2Prev(laListItem2 *Item, void *UNUSED){
    return Item->pPrev;
}
void *laget_PointerListNext(void *UNUSED, laPropIterator *pi){
    pi->Linker = ((laListItemPointer *)pi->Linker)->pNext;
    return pi->Linker->p;
}

void *laget_FirstUiItem(laUiList *uil, void *UNUSED){
    return uil->UiItems.pFirst;
}
void *laget_FirstColumnItem(laUiList *uil, void *UNUSED){
    if (!uil) return 0;
    return uil->Columns.pFirst;
}
int la_ResetUiColum(laColumn *c, int U, int L, int R, int LR, int repos);
void laset_ColumnSP(laColumn *c, real val){
    if (c->LS) c->LS->SP = val;
    if (c->RS) c->RS->SP = val;
}
real laget_ColumnSP(laColumn *c){
    if (c->LS) return c->LS->SP;
    else
        return 0.5;
}
void laset_ColumnSnap(laColumn *c, int val){
    if (c->LS && c->LS->MaxW) c->LS->MaxW = val;
    if (c->RS && c->RS->MaxW) c->RS->MaxW = val;
}
int laget_ColumnSnap(laColumn *c){
    if (c->LS && c->LS->MaxW) return c->LS->MaxW;
    if (c->RS && c->RS->MaxW) return c->RS->MaxW;
    return 20;
}
void laset_SnapState(laColumn *c, int val){
    if (val == 1){
        if (c->LS) c->LS->MaxW = 20;
        if (c->RS) c->RS->MaxW = 0;
    }elif (val == 2){
        if (c->LS) c->LS->MaxW = 0;
        if (c->RS) c->RS->MaxW = 20;
    }else{
        if (c->LS) c->LS->MaxW = 0;
        if (c->RS) c->RS->MaxW = 0;
    }
}
int laget_SnapState(laColumn *c){
    if (c->LS && c->LS->MaxW) return 1;
    if (c->RS && c->RS->MaxW) return 2;
    return 0;
}
void *laget_BoxedTheme(laTheme *theme){
    return theme->BoxedThemes.pFirst;
}
void *laget_BoxedThemeUi(void *UNUSED){
    return ((laTheme *)MAIN.Themes.pFirst)->BoxedThemes.pFirst;
}

void* laget_Main(void *UNUSED, void* UNUSED2){
    return &MAIN;
}

laPropContainer* laget_PropertyNodeType(laProp* p){
    static laPropContainer* pc=0;
    static laPropContainer* ipc=0;
    static laPropContainer* fpc=0;
    switch(p->PropertyType&(~LA_PROP_ARRAY)){
        case LA_PROP_INT: { if(!ipc) ipc=la_ContainerLookup("int_property"); return ipc; }
        case LA_PROP_FLOAT: { if(!fpc) fpc=la_ContainerLookup("float_property"); return fpc; }
        default: { if(!pc) pc=la_ContainerLookup("property_item"); return pc; }
    }
}

void *laget_PropertyItemFirst(laPropContainer *p){
    if (!p) return 0;
    return p->Props.pFirst;
}
void *laget_PropertyItemNext(laProp *p, void *UNUSED){
    return p->Item.pNext;
}
void laget_PropertyName(laProp *p, char *result){
    strCopyFull(result, p ? p->Name : "");
}
void laget_PropertyIdentifier(laProp *p, char *result){
    strCopyFull(result, p ? p->Identifier : "");
}
void laget_PropertyDescription(laProp *p, char *result){
    strCopyFull(result, p ? p->Description : "");
}
int laget_PropertySubContainerIconID(laProp *p){
    if (p->PropertyType != LA_PROP_SUB) return 0;
    if (!p->SubProp){
        p->SubProp = la_ContainerLookup(((laSubProp *)p)->TargetID);
        if (!p->SubProp) return 0;
    }
    return p->SubProp->IconID;
}

int laget_TrashItemInstance(void *a){
    return a;
}

void *laget_ActiveWindow(void *unused){
    return MAIN.CurrentWindow;
}
void *laget_FirstWindow(void *unused, void* unused_iter){
    return MAIN.Windows.pFirst;
}
void *laget_FirstContainer(void *unused, void* unused_iter){
    return MAIN.PropContainers.pFirst;
}
void *laget_WindowFirstLayout(laWindow *window, void* unused_iter){
    return window->Layouts.pFirst;
}
void *laget_FirstHiddenPanel(laWindow *window, void* unused_iter){
    for(laPanel* p=window->Panels.pFirst;p;p=p->Item.pNext){
        if(!p->Show&&!p->LaterDestroy){return p;}
    }
    return 0;
}
void *laget_NextHiddenPanel(laPanel* p, void* unused_iter){
    for(p=p->Item.pNext;p;p=p->Item.pNext){
        if(!p->Show&&!p->LaterDestroy){return p;}
    }
    return 0;
}
void laset_WindowHiddenPanel(laWindow *window, laPanel* p){
    laShowPanelWithExpandEffect(p);
    laPopPanel(p);
    return 0;
}
void laget_PanelTitle(laPanel *p, char *result){
    strCopyFull(result, p->Title->Ptr);
}
void laset_PanelTitle(laPanel *p, char *content){
    strSafeSet(&p->Title, content);
    p->TitleWidth = tnsStringGetWidth(p->Title->Ptr, 0, 0);
}
void laset_PanelSnapDistance(laPanel *p, int index, int n){
    int a;
    if (!n) return;
    switch (index){ //lrtb
    case 0:
        p->SL = p->SL ? n : 0;
        break;
    case 1:
        p->SR = p->SR ? n : 0;
        break;
    case 2:
        p->ST = p->ST ? n : 0;
        break;
    case 3:
        p->SB = p->SB ? n : 0;
        break;
    }
}
void laset_PanelSnapEnable(laPanel *p, int index, int n){
    laWindow *w = MAIN.CurrentWindow;
    int a;
    switch (index){ //lrtb
    case 0:
        p->SL = (n && p->X) ? p->X : 0;
        break;
    case 1:
        p->SR = (n && w ? ((a = MAIN.CurrentWindow->CW - p->X - p->W) ? a : 0) : n);
        break;
    case 2:
        p->ST = (n && p->Y) ? p->Y : 0;
        break;
    case 3:
        p->SB = (n && w ? ((a = MAIN.CurrentWindow->CH - p->Y - p->H) ? a : 0) : n);
        break;
    }
}
void laget_PanelSnapEnable(laPanel *p, int *result){
    result[0] = p->SL ? 1 : 0;
    result[1] = p->SR ? 1 : 0;
    result[2] = p->ST ? 1 : 0;
    result[3] = p->SB ? 1 : 0;
}
void laget_LayoutTitle(laLayout *l, char *result){
    strCopyFull(result, l->ID->Ptr);
}
void laset_LayoutTitle(laLayout *l, char *content){
    strSafeSet(&l->ID, content);
    laRenameWindow(MAIN.CurrentWindow, content);
}
//void* laget_LayoutPanelFirst(laLayout* l) {
//	return l->Panels.pFirst;
//}
void laget_WindowTitle(laWindow *w, char *result){
    strCopyFull(result, w->Title->Ptr);
}
void laset_WindowTitle(laWindow *w, char *content){
    strSafeSet(&w->Title, content);
}
void laset_WindowActiveLayout(laWindow *w, laLayout *l, int UNUSED_State){
    la_StopAllOperators();
    w->CurrentLayout = l;
    laRenameWindow(w, l->ID->Ptr);
    laRedrawCurrentWindow();
}
//void laget_PanelSnappingTrueFalse(laPanel* p, int* result) {
//	result[0] = p->SL > 0 ? 1 : 0;
//	result[1] = p->SR > 0 ? 1 : 0;
//	result[2] = p->ST > 0 ? 1 : 0;
//	result[3] = p->SB > 0 ? 1 : 0;
//}
//void laset_PanelSnappingTrueFalse(laPanel* p,int Index, int n) {
//	int* v = &p->SL;
//	int val = abs(v[Index]);
//	v[Index] = val*(n ? 1 : -1);
//}

void laset_PanelMultisample(void* unused, int value){
    MAIN.PanelMultisample = value;
    tnsReconfigureTextureParameters(value);
    laRedrawAllWindows();
}

void *laget_UiInternalType(void *UNUSED){
    return MAIN.UiTypes.pFirst;
}

void laget_TimeString(laTimeInfo *ti, char *result,char** result_direct){
    sprintf(result, "%d-%.02d-%.02d %.02d:%.02d:%.02d", ti->Year, ti->Month, ti->Day, ti->Hour, ti->Minute, ti->Second);
}
int laget_TimeYear(laTimeInfo *ti){
    return (int)ti->Year;
}
int laget_TimeMonth(laTimeInfo *ti){
    return (int)ti->Month;
}
int laget_TimeDay(laTimeInfo *ti){
    return (int)ti->Day;
}
int laget_TimeHour(laTimeInfo *ti){
    return (int)ti->Hour;
}
int laget_TimeMinute(laTimeInfo *ti){
    return (int)ti->Minute;
}
int laget_TimeSecond(laTimeInfo *ti){
    return (int)ti->Second;
}

void *laget_ConditionerExtra(laUiItem *ui){
    if (ui->Type == &_LA_UI_CONDITION ||
        ui->Type == &_LA_UI_CONDITION_END ||
        ui->Type == &_LA_UI_CONDITION_ELSE ||
        ui->Type == _LA_UI_CONDITION_TOGGLE){
        return ui->Extra;
    }
    return 0;
}
void *laget_CanvasExtra(laUiItem *ui){
    if (ui->Type == _LA_UI_CANVAS){
        return ui->Extra;
    }
    return 0;
}

void laget_UnknownPropertyString(laUDF *udf, char *result, char** here){
    *here="Unknown Property";
}
void laget_MainIdentifier(laUDF *udf, char *result, char** here){
    strcpy(result, "MAIN");
}
void laget_UDFFilePath(laUDF *udf, char *result, char** here){
    *here=udf->FileName->Ptr;
}
void laget_UDFContentNodeFullPath(laUDFContentNode *ucn, char *result, char** here){
    if (ucn->FullPath && ucn->FullPath->Ptr) *here=ucn->FullPath->Ptr;
}
void laget_UDFContentNodeIdentifier(laUDFContentNode *ucn, char *result, char** here){
    if (ucn->Identifier && ucn->Identifier->Ptr) *here=ucn->Identifier->Ptr;
}
void laget_UDFContentInstanceIdentifier(laUDFContentInstance *uci, char *result, char** here){
    if (uci->Identifier && uci->Identifier->Ptr) *here=uci->Identifier->Ptr;
}

void lapost_PropPack(laPropPack *pp);
void laget_ConditionNodePropPath(laUiConditionNode *ucn, char *result, char** here){
    if (!ucn->PP.Go) return;
    la_GetPropPackPath(&ucn->PP, result);
}
void laset_ConditionNodePropPath(laUiConditionNode *ucn, char *content, char** here){
    if (ucn->PP.Go){
        la_FreePropStepCache(ucn->PP.Go);
        ucn->PP.LastPs = ucn->PP.Go = 0;
    }
    la_GetPropFromPath(&ucn->PP, ucn->PP.RawThis, content, 0);
}
void laread_ConditionNodePropPath(laUiConditionNode *ucn, char *Content, char** here){
    if (!Content || !Content[0]) return;
    ucn->PP.Go = CreateNewBuffer(char, strlen(Content) + 1);
    strcpy(ucn->PP.Go, Content);
}
void lapost_ConditionNode(laUiConditionNode *ucn){
    lapost_PropPack(&ucn->PP);
}
void laset_ConditionNodeType(laUiConditionNode *ucn, int Type){
    ucn->Type = Type;
    switch (Type){
    case LA_CONDITION_PROP:
    case LA_CONDITION_INT:
    case LA_CONDITION_FLOAT:
    case LA_CONDITION_STRING:
    case LA_CONDITION_FALSE:
    case LA_CONDITION_TRUE:
        la_ConditionNodeFreeRecursive(ucn->Expression1);
        la_ConditionNodeFreeRecursive(ucn->Expression2);
        ucn->Expression1 = 0;
        ucn->Expression2 = 0;
        if (ucn->PP.LastPs) la_FreePropStepCache(ucn->PP.Go);
        ucn->PP.LastPs = ucn->PP.Go = ucn->PP.RawThis = 0;
        break;
    case LA_CONDITION_NOT:
        la_ConditionNodeFreeRecursive(ucn->Expression2);
        ucn->Expression2 = 0;
        if (ucn->PP.LastPs) la_FreePropStepCache(ucn->PP.Go);
        ucn->PP.LastPs = ucn->PP.Go = ucn->PP.RawThis = 0;
        if (!ucn->Expression1) ucn->Expression1 = laIntExpression(0);
        break;
    default:
        if (!ucn->Expression1) ucn->Expression1 = laIntExpression(0);
        if (!ucn->Expression2) ucn->Expression2 = laIntExpression(1);
        break;
    }
    laRecalcCurrentPanel();
}
void laread_ConditionNodeType(laUiConditionNode *ucn, int Type){
    ucn->Type = Type;
}

void* laget_FirstDriverPage(void* unused, void* unused2){
    return MAIN.Drivers->Pages.pFirst;
}
void* laget_CurrentRackPage(laRackPageCollection* c){
    return c->CurrentPage;
}

void laset_WindowColorSpace(laWindow* w, int space){
    w->OutputColorSpace=space; laRedrawCurrentWindow();
}
void laset_WindowShowStripes(laWindow* w, int stripes){
    w->OutputShowStripes=stripes; laRedrawCurrentWindow();
}

void *tnsget_TnsMain(void *unused,void *unused2){
    return T;
}
void *tnsget_World(void *unused,void *unused2){
    return &T->World;
}
void *tnsread_World(void *unused, void *inst){
}
void *tnsget_detached_FirstRootObject(void *UNUSED1, void *UNUSED2){
    return T->World.RootObjects.pFirst;
}
void *tnsget_detached_FirstTexture(void *UNUSED1, void *UNUSED2){
    return T->Textures.pFirst;
}
void *tnsget_PreviewTexture(void *UNUSED){
    return T->PreviewTexture;
}
void *tnsset_PreviewTexture(void *UNUSED_PARENT, void *tex, int UNUSEDSTATE){
    T->PreviewTexture = tex;
}
void tnsget_ObjectName(tnsObject *s, char *result){
    if (!s->Name) return;
    strCopyFull(result, s->Name->Ptr);
}
void tnsset_ObjectName(tnsObject *s, char *content){
    strSafeSet(&s->Name, content);
}
void *tnsget_NextLinkedObject(tnsObject *o, laPropIterator *pi){
    pi->Linker = ((laListItemPointer *)pi->Linker->pNext);
    return pi->Linker->p;
}
void *tnsget_FirstChildObject(tnsObject *ob){
    return ob->ChildObjects.pFirst;
}

void tnsset_ObjectLocation(tnsObject* o, real val, int n){ o->Location[n]=val; tnsSelfTransformValueChanged(o); laNotifyUsers("tns.world"); }
void tnsset_ObjectRotation(tnsObject* o, real val, int n){ o->Rotation[n]=val; tnsSelfTransformValueChanged(o); laNotifyUsers("tns.world"); }
void tnsset_ObjectScale(tnsObject* o, real val){ o->Scale=val; tnsSelfTransformValueChanged(o); laNotifyUsers("tns.world"); }

void laget_UiTemplateIdentifier(laUiTemplate *uit, char *result, char** here){
    *here=uit->Identifier->Ptr;
}
void laset_UiTemplateIdentifier(laUiTemplate *uit, char *content){
    strSafeSet(&uit->Identifier, content);
}
void laget_UiDataPath(laUiItem *ui, char *result){
    laPropStep *ps = ui->PP.Go;
    if (ui->PP.LastPs || ui->PP.Go){
        for (ps; ps; ps = ps->pNext){
            if (ps->Type == L'@' || ps->Type == L'#' || ps->Type == L'='){
                strcat(result, ps->p);
            }else{
                strcat(result, ps->p->Identifier);
            }
            if (ps->pNext){
                if (ps->pNext->Type == L'.') strcat(result, ".");
                elif (ps->pNext->Type == L'#') strcat(result, "#");
                elif (ps->pNext->Type == L'@') strcat(result, "@");
                elif (ps->pNext->Type == L'=') strcat(result, "= ");
                elif (ps->pNext->Type == L'$') strcat(result, "$");
            }
        }
    }elif (ui->AT){
        strcpy(result, "");
    }
}
void laget_UiOperatorID(laUiItem *ui, char *result, char** here){
    if (ui->AT){
        *here=ui->AT->Identifier;
    }else *result=0;
}
void laread_UiDataPath(laUiItem *ui, char *Content){
    if (!Content || !Content[0]) return;
    ui->PP.Go = CreateNewBuffer(char, strlen(Content) + 1);
    strcpy(ui->PP.Go, Content);
}
void laread_UiOperatorID(laUiItem *ui, char *Content){
    ui->AT = laGetOperatorType(Content);
}

void *laget_PanelTemplate(void *UNUSED, void *UNUSED2){
    return MAIN.PanelTemplates.pFirst;
}
void laget_PanelTemplateCategory(void* rack_unused, laUiTemplate* uit, char* copy, char** ptr){
    if(uit->CategoryName&&uit->CategoryName->Ptr) *ptr=uit->CategoryName->Ptr;
}

void lapost_Window(laWindow *w){
    la_CreateSystemWindow(w);
    MAIN.CurrentWindow = w;
    laStartWindow(w);
}
void lapost_PropPack(laPropPack *pp){
    char *path = pp->Go;
    if (pp->LastPs /* || !path*/) return;
    if ((!path || (path && !path[0])) && pp->RawThis) pp->LastPs = pp->RawThis->LastPs;
    if (pp->RawThis) lapost_PropPack(pp->RawThis);
    pp->Go = 0;
    la_GetPropFromPath(pp, pp->RawThis, path, 0);
    FreeMem(path);
}
void lapost_UiItem(laUiItem *ui){
    lapost_PropPack(&ui->PP);
    //if(ui->Type == _LA_UI_CANVAS) ui->Type->Init(ui);
}
void lapostim_UiItem(laUiItem *ui){
    if (ui->Type && ui->Type->Init && ui->Type != _LA_UI_CANVAS && ui->Type != &_LA_UI_CONDITION) ui->Type->Init(ui);
    ui->State = ui->State ? ui->State : (ui->Type ? LA_UI_NORMAL : 0);

    la_AssignPropExtras(ui);
}
void lapost_Panel(laPanel *p){
    p->PP.EndInstance = p;
    p->PP.LastPs = &p->FakePS;
    p->PP.LastPs->p = _LA_PROP_PANEL;

    la_EnsurePanelExtras(p);

    p->Refresh = LA_TAG_RECALC;
}
void lapost_UserPreferences(void* unused){
    MAIN.ScaledUiRowHeight=MAIN.UiRowHeight;
    tnsInvalidateFontCache();
}

//void laget_DetachedPropContainerID(laProp* p, char * result) {
//	strcpy(result, p->Detached->Container->Identifier);
//}
//void laget_DetachedPropPropID(laProp* p, char * result) {
//	strcpy(result, p->Detached->Identifier);
//}
//void laset_DetachedPropContainerID(laProp* p, char * content) {
//	p->Description = CreateNewBuffer(char, 128);
//	strcpy(p->Description, content);
//}
//void laset_DetachedPropPropID(laProp* p, char * content) {
//	p->Name = CreateNewBuffer(char, 128);
//	strcpy(p->Name, content);
//}
void laread_DetachedPropRename(laProp *p, char *content){
    p->Identifier = CreateNewBuffer(char, 128);
    strcpy(p->Identifier, content);
}
void laget_DetachedPropPath(laProp *p, char *result, char** here){
    la_GetPropPackPath(&p->DetachedPP, result);
}
void laread_DetachedPropPath(laProp *p, char *content){
    p->DetachedPP.Go = CreateNewBuffer(char, 128);
    strcpy(p->DetachedPP.Go, content);
}
void lapost_DetachedProp(laProp *Prop){
    laPropContainer *pc = 0;
    laSubProp *np = 0;
    laIntProp *ip;
    laFloatProp *fp;
    laEnumProp *ep;
    laSubProp *sp;
    char *path = Prop->DetachedPP.Go;
    char *id = Prop->Identifier;
    laPropPack TempPP = {0};
    laListItem Item;

    Prop->DetachedPP.Go = 0;
    memcpy(&Item, &Prop->Item, sizeof(laListItem));

    la_GetPropFromPath(&TempPP, Prop->DetachedPP.RawThis, path, 0);
    //FreeMem(path);

    memcpy(Prop, TempPP.LastPs->p, la_GetPropertySize(TempPP.LastPs->p->PropertyType));

    memcpy(&Prop->DetachedPP, &TempPP, sizeof(laPropPack));
    memcpy(&Prop->Item, &Item, sizeof(laListItem));

    switch (Prop->PropertyType){
    case LA_PROP_INT:
    case LA_PROP_INT | LA_PROP_ARRAY:
        ip = Prop;
        ip->Detached = CreateNewBuffer(int, Prop->Len ? Prop->Len : 1);
        break;
    case LA_PROP_FLOAT:
    case LA_PROP_FLOAT | LA_PROP_ARRAY:
        fp = Prop;
        fp->Detached = CreateNewBuffer(real, Prop->Len ? Prop->Len : 1);
        break;
    case LA_PROP_ENUM:
    case LA_PROP_ENUM | LA_PROP_ARRAY:
        ep = Prop;
        ep->Detached = CreateNewBuffer(int, 1);
        ep->Detached[0] = ((laEnumItem *)ep->Items.pFirst)->Index;
    }

    Prop->Identifier = id;
}

void latouched_NodeInSocket(void* unused, int hint){
    laDriverRequestRebuild(); laMappingRequestRebuild();
}

int lafilter_NodeCategory(void* unused, laNodeCategory* c){
    if(c->For&MAIN.FilterNodeCategory) return 1; return 0;
}

void tnspost_Object(tnsObject *o){
    /* what */
}
void tnspropagate_Object(tnsObject* o, laUDF* udf, int force){
    for(laListItemPointer* lip=o->ChildObjects.pFirst;lip;lip=lip->pNext){ if(!lip->p) continue;
        if(force || !laget_InstanceActiveUDF(lip->p)){ laset_InstanceUDF(lip->p, udf); tnspropagate_Object(lip->p,udf,force); }
    }
}
void tnstouched_Object(tnsObject *o, int hint){
    printf("touched\n");
    if(o->Type==TNS_OBJECT_MESH && (hint&TNS_HINT_GEOMETRY)){
        tnsInvalidateMeshBatch(o);
    }
    laNotifyUsers("tns.world");
}

int tnsget_MeshObjectVertSize(tnsMeshObject* o){ return o->totv*sizeof(tnsVert);/*can't use maxv*/ }
int tnsget_MeshObjectEdgeSize(tnsMeshObject* o){ return o->tote*sizeof(tnsEdge);/*can't use maxv*/ }
void* tnsget_MeshObjectFaceRaw(tnsMeshObject* o, int* r_size, int* r_is_copy){
    if(o->Mode==TNS_MESH_EDIT_MODE) return;
    int* arr=0; int next=0,max=0; int i=0;
    arrEnsureLength(&arr, i, &max, sizeof(int));
    arr[i]=o->totf; i++;
    for(int f=0;f<o->totf;f++){
        arrEnsureLength(&arr, i+o->f[f].looplen+2, &max, sizeof(int));
        arr[i]=o->f[f].looplen; i++;
        arr[i]=o->f[f].flags; i++;
        for(int l=0;l<o->f[f].looplen;l++){
            arr[i]=o->f[f].loop[l]; i++;
        }
    }
    *r_size = i*sizeof(int);
    *r_is_copy = 1;
    return arr; 
}
void tnsset_MeshObjectFaceRaw(tnsMeshObject* o, int* data, int s){
    if(o->f){
        for(int fi=0;fi<o->totf;fi++){
            if(o->f[fi].loop){ free(o->f[fi].loop); o->f[fi].loop=0; }
        }
        arrFree(&o->f, &o->maxf); o->totf=0; 
    }
    if(!data) return;
    int totf=data[0]; int i=1;
    o->f=calloc(1,sizeof(tnsFace)*totf); o->maxf=o->totf=totf;
    for(int fi=0;fi<totf;fi++){
        tnsFace*f=&o->f[fi];
        f->looplen=data[i]; i++;
        f->flags=data[i]; i++;
        f->loop=calloc(1,sizeof(int)*f->looplen);
        for(int li=0;li<f->looplen;li++){
            f->loop[li]=data[i]; i++;
        }
    }
}


laPropContainer* tnsget_ObjectType(tnsObject* o){
    switch(o->Type){
    case TNS_OBJECT_EMPTY: default: return TNS_PC_OBJECT_GENERIC;
    case TNS_OBJECT_CAMERA: return TNS_PC_OBJECT_CAMERA;
    case TNS_OBJECT_MESH:   return TNS_PC_OBJECT_MESH;
    case TNS_OBJECT_LIGHT:  return TNS_PC_OBJECT_LIGHT;
    }
}

void lareset_Main(void* Unused){
    return;
}

laPropContainer* LA_PC_SOCKET_IN;
laPropContainer* LA_PC_SOCKET_OUT;
laPropContainer* LA_PROP_SOCKET_SOURCE;
laPropContainer* LA_PROP_SOCKET_OUT;
laPropContainer* LA_PC_MAPPER;
laPropContainer* TNS_PC_OBJECT_GENERIC;
laPropContainer* TNS_PC_OBJECT_CAMERA;
laPropContainer* TNS_PC_OBJECT_LIGHT;
laPropContainer* TNS_PC_OBJECT_MESH;

laProp* LA_PROP_CONTROLLER;

void la_RegisterGeneralProps(){
    laPropContainer *p, *ip, *p2, *ip2, *sp1, *sp2;
    laProp *ep;
    laPropPack pp;
    laSubProp *sp;
    laKeyMapper *km;

    p = la_SetGeneralRoot(&MAIN.GeneralIntSub, "__general_int__", "Genral Int Operations", "Genral Int Operations");
    laAddOperatorProperty(p, "restore", "Restore Default", "Restore the property to the original value", "LA_int_restore_default", L'⭯', 0);
    laAddOperatorProperty(p, "set_max", "Set Max", "Set The Property To The Max Value", "LA_int_set_max", 0, 0);
    laAddOperatorProperty(p, "set_min", "Set Min", "Set The Property To The Min Value", "LA_int_set_min", 0, 0);
    laAddOperatorProperty(p, "hyper_data", "View Hyper Data", "Show Properties Of Specific Data Block", "LA_view_hyper_data", L'🛈', 0);

    p = la_SetGeneralRoot(&MAIN.GeneralIntArraySub, "__general_int_arr__", "Genral Int Array Operations", "Genral Int Array Operations");
    laAddOperatorProperty(p, "restore", "Restore Default", "Restore the property to the original value", "LA_int_array_restore_default", L'⭯', 0);
    laAddOperatorProperty(p, "set_max", "Set Max", "Set The Property To The Max Value", "LA_int_array_set_max", 0, 0);
    laAddOperatorProperty(p, "set_min", "Set Min", "Set The Property To The Min Value", "LA_int_array_set_min", 0, 0);
    laAddOperatorProperty(p, "hyper_data", "View Hyper Data", "Show Properties Of Specific Data Block", "LA_view_hyper_data", L'🛈', 0);

    p = la_SetGeneralRoot(&MAIN.GeneralFloatSub, "__general_real__", "Genral Float Operations", "Genral Float Operations");
    laAddOperatorProperty(p, "restore", "Restore Default", "Restore the property to the original value", "LA_real_restore_default", L'⭯', 0);
    laAddOperatorProperty(p, "set_max", "Set Max", "Set The Property To The Max Value", "LA_real_set_max", 0, 0);
    laAddOperatorProperty(p, "set_min", "Set Min", "Set The Property To The Min Value", "LA_real_set_min", 0, 0);
    laAddOperatorProperty(p, "hyper_data", "View Hyper Data", "Show Properties Of Specific Data Block", "LA_view_hyper_data", L'🛈', 0);

    p = la_SetGeneralRoot(&MAIN.GeneralFloatArraySub, "__general_real_arr__", "Genral Float Array Operations", "Genral Float Array Operations");
    laAddOperatorProperty(p, "restore", "Restore Default", "Restore the property to the original value", "LA_real_array_restore_default", L'⭯', 0);
    laAddOperatorProperty(p, "set_max", "Set Max", "Set The Property To The Max Value", "LA_real_array_set_max", 0, 0);
    laAddOperatorProperty(p, "set_min", "Set Min", "Set The Property To The Min Value", "LA_real_array_set_min", 0, 0);
    laAddOperatorProperty(p, "hyper_data", "View Hyper Data", "Show Properties Of Specific Data Block", "LA_view_hyper_data", L'🛈', 0);

    p = la_SetGeneralRoot(&MAIN.GeneralEnumSub, "__general_enum__", "Genral Enum Operations", "Genral Enum Operations");
    laAddOperatorProperty(p, "restore", "Restore Default", "Restore the property to the original value", "LA_enum_restore_default", L'⭯', 0);
    p = la_SetGeneralRoot(&MAIN.GeneralEnumArraySub, "__general_enum_arr__", "Genral Enum Array Operations", "Genral Enum Array Operations");
    laAddOperatorProperty(p, "restore", "Restore Default", "Restore the property to the original value", "LA_enum_array_restore_default", L'⭯', 0);
    
    p = la_SetGeneralRoot(&MAIN.GeneralStringSub, "__general_string__", "Genral String Operations", "Genral String Operations");
    laAddOperatorProperty(p, "get_folder_path", "Get Folder Path", "Get a folder path", "LA_string_get_folder_path", L'📁', 0);
    laAddOperatorProperty(p, "get_file_path", "Get File Path", "Get a file path", "LA_string_get_file_path", L'🖹', 0);
    laAddOperatorProperty(p, "copy", "Copy", "Copy to clipboard", "LA_string_copy", 0, 0);
    laAddOperatorProperty(p, "paste", "Paste", "Paste from clipboard", "LA_system_paste", 0, 0);
    laAddOperatorProperty(p, "restore", "Restore Default", "Restore Default Value", "LA_string_set_default", L'⭯', 0);
    p->UiDefine=laui_StringPropUiDefine;

    p = la_SetGeneralRoot(&MAIN.GeneralOperatorSub, "__general_operator__", "Genral Operator Operations", "Genral Operator Operations");

    p = la_SetGeneralRoot(&MAIN.GeneralCollectionSub, "__general_collection__", "Genral Collection Operations", "Genral Collection Operations");
    laAddOperatorProperty(p, "put_data_block", "Put", "Append Pending Data Block Here", "LA_sub_put_data_block", L'🔗', 0);
    laAddOperatorProperty(p, "save_instance", "Save Instance", "Save instance as a udf block", "LA_udf_save_instance", 0, 0);
}

void la_RegisterInternalProps(){
    laPropContainer *p, *ip, *p2, *ip2, *sp1, *sp2;
    laProp *ep;
    laPropPack pp;
    laSubProp *sp;
    laKeyMapper *km;
    laCanvasTemplate *v2dt;

    {

        la_UDFAppendSharedTypePointer("_LA_ROOT_NODE_", &MAIN);
        la_UDFAppendSharedTypePointer("_TNS_ROOT_NODE_", T);

        // THEME ==================================================================================================
        {
            p = laDefineRoot();

            laAddPropertyContainer("any_pointer", "Any Pointer", "A pointer that is not exposed to access", 0, 0, sizeof(void*), 0, 0, LA_PROP_OTHER_ALLOC);

            laAddSubGroup(p, "windows", "Windows", "All Registered Windows Of This Application", "ui_window",0, 0, 0, -1, laget_FirstWindow, laget_ActiveWindow, laget_ListNext, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "tns","TNS", "TNS Kernel Main Structure", "tns_main",0, 0, 0, -1, tnsget_TnsMain, 0, 0, 0, 0, 0, 0, LA_UDF_SINGLE | LA_UDF_LOCAL);
            laAddSubGroup(p, "la","LA", "LA Main Structure", "la_main",0, 0, laui_SubPropInfoDefault, -1, laget_Main, 0, 0, 0, 0, 0, 0, LA_UDF_SINGLE | LA_UDF_LOCAL);

            p = laAddPropertyContainer("boxed_theme", "Boxed Theme", "A Single Theme Item For One Or Multiple Kinds Of UiItems", 0, laui_BoxedThemeItem, sizeof(laBoxedTheme), 0, 0, 1);{
                laAddStringProperty(p, "name", "Name", "Boxed Theme Name", 0, 0, 0, 0, 1, offsetof(laBoxedTheme, Name), 0, 0, 0, 0, LA_AS_IDENTIFIER);
                laAddFloatProperty(p, "margins", "Margins", "Margins On Four Sides", 0, "Left,Right,Top,Bottom", 0, 1, -1, 0.05, 1, 0, offsetof(laBoxedTheme, Margins), 0, 0, 4, 0, laset_ThemeMargins, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "paddings", "Paddings", "Paddings On Four Sides", 0, "Left,Right,Top,Bottom", 0, 1, -1, 0.05, 1, 0, offsetof(laBoxedTheme, Paddings), 0, 0, 4, 0, laset_ThemePaddings, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "normal", "Normal", "Background brightness", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laBoxedTheme, NormalY), 0, laset_ThemeNormal, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "active", "Active", "Background brightness in active state", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laBoxedTheme, ActiveY), 0, laset_ThemeActive, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "border", "Border", "Border brightness", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laBoxedTheme, BorderY), 0, laset_ThemeBorder, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "text", "Text", "Text brightness", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laBoxedTheme, TextY), 0, laset_ThemeText, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "text_active", "Text Active", "Text brightness in active state", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laBoxedTheme, TextActiveY), 0, laset_ThemeTextActive, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "alpha", "Alpha", "Background alpha", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laBoxedTheme, Alpha), 0, laset_ThemeAlpha, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddSubGroup(p, "back_ref", "Back Ref", "Boxed theme internal back-ref", "any_pointer",0, 0, 0, offsetof(laBoxedTheme, BackRef), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
                laAddSubGroup(p, "parent", "Parent", "Parent Theme", "theme",0, 0, 0, offsetof(laBoxedTheme, Parent), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            }

            p = laAddPropertyContainer("theme", "Theme Package", "A Package With ALl Types Of Theme For Ui Items", 0, laui_Theme, sizeof(laTheme), 0, 0, 2);{
                laAddStringProperty(p, "name", "Name", "Theme Name", 0, 0, 0, 0, 1, offsetof(laTheme, Name), 0, 0, 0, 0, LA_AS_IDENTIFIER);
                laAddStringProperty(p, "author", "Author", "The Author's Name", 0, 0, 0, 0, 1, offsetof(laTheme, Author), 0, 0, 0, 0, 0);
                laAddSubGroup(p, "boxed_themes", "Boxed Themes", "The Boxed Theme For Single UiItem Or Panel", "boxed_theme",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(laTheme, BoxedThemes), 0);
                laAddFloatProperty(p, "color", "Color", "Base color of the theme", LA_WIDGET_FLOAT_COLOR, "R,G,B,A", 0, 1, 0, 0.025, 1, 0, offsetof(laTheme, Color), 0, 0, 4, 0, 0, 0, 0, laset_ThemeColor, 0, 0, 0);
                laAddFloatProperty(p, "accent_color", "Accent Color", "Theme accent color for hightlight etc", LA_WIDGET_FLOAT_COLOR, "R,G,B,A", 0, 1, 0, 0.025, 1, 0, offsetof(laTheme, AccentColor), 0, 0, 4, 0, 0, 0, 0, laset_ThemeAccentColor, 0, 0, 0);
                laAddFloatProperty(p, "inactive_saturation", "Inactive Saturation", "Reduced saturation on inactive widgets", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laTheme, InactiveSaturation), 0, 0, 1, 0, 0, 0, 0, laset_ThemeInactiveSaturation, 0, 0, 0);
                laAddFloatProperty(p, "inactive_mix", "Inactive Mix", "Reduced alpha on inactive widgets", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laTheme, InactiveMix), 0, 0, 1, 0, 0, 0, 0, laset_ThemeInactiveMix, 0, 0, 0);
                laAddFloatProperty(p, "cursor_alpha", "Cursor Alpha", "Transparency of the cursor", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laTheme, CursorAlpha), 0, 0, 1, 0, 0, 0, 0, laset_ThemeCursorAlpha, 0, 0, 0);
                laAddFloatProperty(p, "selection_alpha", "Selection Alpha", "Transparency of selection backgrounds", 0, 0, 0, 1, 0, 0.025, 1, 0, offsetof(laTheme, SelectionAlpha), 0, 0, 1, 0, 0, 0, 0, laset_ThemeSelectionAlpha, 0, 0, 0);
                laAddFloatProperty(p, "wire_transparency", "Wire Transparency", "Alpha of the wire color", 0, 0, 0, 1, 0, 0.05, 0.7, 0, offsetof(laTheme, WireTransparency), 0, laset_ThemeWireTransparency, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "wire_saturation", "Wire Saturation", "Saturation of the wires", 0, 0, 0, 1, 0, 0.05, 0.8, 0, offsetof(laTheme, WireSaturation), 0, laset_ThemeWireSaturation, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "wire_brightness", "Wire Brightness", "Brightness of the wires", 0, 0, 0, 1, 0, 0.05, 0.8, 0, offsetof(laTheme, WireBrightness), 0, laset_ThemeWireBrightness, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "edge_transparency", "Edge Transparency", "Transparency of the edge color", 0, 0, 0, 1, 0, 0.05, 0.7, 0, offsetof(laTheme, EdgeTransparency), 0, laset_ThemeEdgeTransparency, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "edge_brightness", "Edge Brightness", "Brightness of the edge color", 0, 0, 0, 1, 0, 0.05, 0.7, 0, offsetof(laTheme, EdgeBrightness), 0, laset_ThemeEdgeBrightness, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "vertex_transparency", "Edge Transparency", "Transparency of the vertex color", 0, 0, 0, 1, 0, 0.05, 0.7, 0, offsetof(laTheme, VertexTransparency), 0, laset_ThemeVertexTransparency, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "vertex_brightness", "Edge Brightness", "Brightness of the vertex color", 0, 0, 0, 1, 0, 0.05, 0.7, 0, offsetof(laTheme, VertexBrightness), 0, laset_ThemeVertexBrightness, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "svertex_transparency", "Selected Vertex Transparency", "Transparency of selected vertices", 0, 0, 0, 1, 0, 0.05, 0.7, 0, offsetof(laTheme, SelectedVertexTransparency), 0, laset_ThemeSVertexTransparency, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "sedge_transparency", "Selected Edge Transparency", "Transparency of selected edges", 0, 0, 0, 1, 0, 0.05, 0.7, 0, offsetof(laTheme, SelectedEdgeTransparency), 0, laset_ThemeSEdgeTransparency, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                laAddFloatProperty(p, "sface_transparency", "Selected Face Transparency", "Transparency of selected faces", 0, 0, 0, 1, 0, 0.05, 0.7, 0, offsetof(laTheme, SelectedFaceTransparency), 0, laset_ThemeSFaceTransparency, 0, 0, 0, 0, 0, 0, 0, 0, 0);

                laAddOperatorProperty(p, "delete", "Delete", "Delete this theme", "LA_delete_theme", 0, 0);
            }
        }

        // TIME INFO =========================================================================================

        p = laAddPropertyContainer("time_info", "Time Info", "Time Information Y/M/D/H/M/S", L'🕒', 0, sizeof(laTimeInfo), 0, 0, LA_PROP_OTHER_ALLOC);{
            laAddIntProperty(p, "year", "Year", "Year Value", 0, 0, 0, 0, 0, 0, 0, 0, 0, laget_TimeYear, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "month", "Month", "Month Value", 0, 0, 0, 0, 0, 0, 0, 0, 0, laget_TimeMonth, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "day", "Day", "Day Value", 0, 0, 0, 0, 0, 0, 0, 0, 0, laget_TimeDay, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "hour", "Hour", "Hour Value", 0, 0, 0, 0, 0, 0, 0, 0, 0, laget_TimeHour, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "minute", "Minute", "Minute Value", 0, 0, 0, 0, 0, 0, 0, 0, 0, laget_TimeMinute, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "second", "Second", "Second Value", 0, 0, 0, 0, 0, 0, 0, 0, 0, laget_TimeSecond, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddStringProperty(p, "time_string", "Time String", "Full String In \"Y-M-D H:M:S\" Format", 0, 0, 0, 0, 0, 0, 0, laget_TimeString, 0, 0,LA_READ_ONLY);
        }

        // LA MAIN =========================================================================================

        p = laAddPropertyContainer("la_main", "LA Root", "LA Root Structure", L'🖴', 0, sizeof(LA), 0, 0, 2|LA_PROP_OTHER_ALLOC);{
            laAddSubGroup(p, "logs", "Logs", "Application logs", "la_log",0, 0, laui_LogItem, -1, 0, 0, 0, 0, 0, 0, offsetof(LA, Logs), LA_UDF_IGNORE|LA_READ_ONLY);
            laAddSubGroup(p, "differences", "Differences", "Difference stack (for undo/redo)", "la_difference",0, 0, 0, offsetof(LA, HeadDifference), 0, 0, 0, 0, 0, 0, offsetof(LA, Differences), LA_UDF_IGNORE|LA_READ_ONLY);
            
            _LA_PROP_WINDOW=laAddSubGroup(p, "windows", "Windows", "All Windows Under LA Control", "ui_window",0, 0, 0, offsetof(LA, CurrentWindow), laget_FirstWindow, 0, laget_ListNext, 0, 0, 0, offsetof(LA, Windows), 0);
            la_UDFAppendSharedTypePointer("_LA_PROP_WINDOW", _LA_PROP_WINDOW);
            laAddSubGroup(p, "data", "Data", "Data Root Control", "property_container",0, 0, 0, offsetof(LA, DataRoot.Root), 0, 0, 0, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "prop_containers", "Sub Type", "Sub Type Property Container", "property_container",0, 0, 0, -1, laget_FirstContainer, 0, laget_ListNext, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "managed_props", "Managed Props", "Managed properties for saving", "managed_prop",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(LA, ManagedSaveProps), LA_UDF_IGNORE|LA_READ_ONLY);
            laAddSubGroup(p, "managed_udfs", "Managed UDFs", "Managed UDFs for saving", "managed_udf", 0, 0, laui_ManagedUDFOps, -1, 0, 0, 0, 0, 0, 0, offsetof(LA, ManagedUDFs), LA_UDF_IGNORE|LA_READ_ONLY);
            laAddSubGroup(p, "user_preferences", "User Preference", "Kernel Settings For LA Main Structure", "la_user_preference",0, 0, 0, -1, laget_Main, 0, 0, 0, 0, 0, 0, LA_UDF_LOCAL);
            sp=laAddSubGroup(p, "panel_templates", "Panel Templates", "Panel templates used to create new panel", "panel_template",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(LA, PanelTemplates), 0);
            laSubGroupExtraFunctions(sp,0,0,0,laget_PanelTemplateCategory);

            laAddSubGroup(p, "themes", "Themes", "Themes Loded In The Program", "theme",0, 0, laui_Theme, -1, 0, laget_ActiveTheme, 0, laset_ActiveTheme, 0, 0, offsetof(LA,Themes), 0);

            sp=laAddSubGroup(p, "controllers", "Controllers", "Detected game controllers","la_controller",laget_ControllerType,0,0,-1,0,0,0,0,0,0,offsetof(LA,Controllers),0);
            laSubGroupDetachable(sp, laget_DetachedControllerFirst, laget_ListNext);
            LA_PROP_CONTROLLER=sp;

            sp=laAddSubGroup(p, "node_categories", "Node Categories", "Node categories","la_node_category",0,0,0,offsetof(LA,CurrentNodeCategory),0,0,0,0,0,0,offsetof(LA,NodeCategories),0);
            laSubGroupExtraFunctions(sp,lafilter_NodeCategory,0,0,0);

            laAddSubGroup(p, "input_mapping", "Input Mapping", "Input mapping page collection","la_input_mapping_collection",0,0,0,offsetof(LA,InputMapping),0,0,0,0,0,0,0,LA_UDF_SINGLE);
            laAddSubGroup(p, "drivers", "Drivers", "Driver page collection","la_driver_collection",0,0,0,offsetof(LA,Drivers),0,0,0,0,0,0,0,LA_UDF_SINGLE);

            laAddStringProperty(p, "identifier", "Identifier", "Identifier", 0, 0, 0, 0, 0, 0, 0, laget_MainIdentifier, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
            laAddSubGroup(p, "test_ucn", "TEST UCN", "---", "udf_content_node",0, 0, 0, offsetof(LA, TEST_Link), 0, 0, 0, 0, 0, 0, 0, 0);
            
            laAddIntProperty(p, "example_int", "Example Integer", "Example integer", 0, 0, 0, 100, 0, 1, 50, 0, offsetof(LA, example_int), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddStringProperty(p, "example_string", "Example String", "Example string", 0, 0, 0, 0, 1, offsetof(LA,example_string), 0, 0, 0, 0, 0);
            laAddStringProperty(p, "unknown_prop", "Unknown Property", "Placeholder for unknown property, probably due to a wrong property path, or not setting LA_AS_IDENTIFIER in any of the properties.",
                LA_WIDGET_STRING_PLAIN, 0, 0, 0, 0, 0, 0, laget_UnknownPropertyString, 0, 0, LA_READ_ONLY);
        
        }

        p = laAddPropertyContainer("la_node_category", "Node Category", "Node category", 0, laui_IdentifierOnly, sizeof(laNodeCategory), 0, 0, 1);{
            laAddStringProperty(p, "name", "Name", "Name of the page", 0, 0, 0, 0, 1, offsetof(laNodeCategory, Name), 0, 0, 0, 0, LA_AS_IDENTIFIER);
            laAddIntProperty(p, "for_racks", "For Rack Types", "For rack types", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeCategory, For), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_READ_ONLY);
        }

        p = laAddPropertyContainer("la_input_mapping_collection", "Input Mapping Collection", "Input mapping collection", 0, 0, sizeof(laRackPageCollection), 0, 0, 1);{
            laAddSubGroup(p, "pages", "Pages", "Rack pages","la_rack_page",0,0,0,offsetof(laRackPageCollection,CurrentPage),0,0,0,0,0,0,offsetof(laRackPageCollection,Pages),0);
            laAddSubGroup(p, "current_page", "Current Page", "Current page","la_rack_page",0,0,0,offsetof(laRackPageCollection,CurrentPage),0,0,0,0,0,0,0,LA_UDF_REFER);
        }
        p = laAddPropertyContainer("la_driver_collection", "Driver Collection", "Driver collection", 0, 0, sizeof(laRackPageCollection), 0, 0, 1);{
            laAddSubGroup(p, "pages", "Pages", "Rack pages","la_rack_page",0,0,0,-1,0,laget_CurrentRackPage,0,0,0,0,offsetof(laRackPageCollection,Pages),0);
            sp=laAddSubGroup(p, "current_page", "Current Page", "Current page","la_rack_page",0,0,0,offsetof(laRackPageCollection,CurrentPage),0,0,0,0,0,0,0,LA_UDF_REFER);
            laSubGroupDetachable(sp,laget_FirstDriverPage,laget_ListNext);
        }

        p = laAddPropertyContainer("la_rack_page", "Rack Page", "A page of nodes", 0, laui_IdentifierOnly, sizeof(laRackPage), 0, 0, 2);{
            laAddStringProperty(p, "name", "Name", "Name of the page", 0, 0, 0, 0, 1, offsetof(laRackPage, Name), 0, 0, 0, 0, LA_AS_IDENTIFIER);
            laAddIntProperty(p,"type", "Type", "Type of the rack", 0,0,0,0,0,0,0,0,offsetof(laRackPage,RackType),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
            laAddIntProperty(p,"has_rack", "Has Rack", "Has rack", 0,0,0,0,0,0,0,0,offsetof(laRackPage,Racks.pFirst),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY|LA_UDF_IGNORE);
            laAddSubGroup(p, "racks", "Racks", "Racks for nodes","la_node_rack",0,0,0,-1,0,0,0,0,0,0,offsetof(laRackPage,Racks),0);
            laAddOperatorProperty(p,"add_rack","Add Rack", "Add a rack into the page", "LA_add_rack", '+', 0);
        }

        //p = laAddPropertyContainer("udf_fail_node", "UDF Failed Node", "Single Wild Data Block Reference", laui_UDFFailNodeItem, sizeof(laUDFFailNode), 0, 0, 0, 0, 0); {
        //	laAddSubGroup(p, "instance", "Instance", "Actual Data Block Instance", "property_trash_item",0, 0, 0 Item.p), 0, 0, 0, 0, 0, 0, 0, 0,
        //		0, 0,
        //		0);
        //	laAddSubGroup(p, "target_container", "Target Container", "The Container The Data Block Belongs To", "property_container",0, 0, 0 pc), 0, 0, 0, 0, 0, 0, 0, 0,
        //		0, 0,
        //		0);
        //}
        
        p = laAddPropertyContainer("la_difference", "Difference", "A difference stack item (undo/redo).", 0, laui_IdentifierOnly, sizeof(laDiff), 0, 0, 1);{
            laAddStringProperty(p, "description", "Description", "Description of this recorded change", LA_WIDGET_STRING_PLAIN, 0, 0, 0, 1, offsetof(laDiff, Description), 0, 0, 0, 0, LA_READ_ONLY|LA_AS_IDENTIFIER);
        }

        p = laAddPropertyContainer("la_log", "Resource Folder", "A resource folder to search for UDF references.", 0, laui_ResourceFolderItem, sizeof(laLogEntry), 0, 0, 1);{
            laAddStringProperty(p, "content", "Content", "Content of the log", LA_WIDGET_STRING_PLAIN, 0, 0, 0, 1, offsetof(laLogEntry, Content), 0, 0, 0, 0, LA_READ_ONLY);
        }

        p = laAddPropertyContainer("la_resource_folder", "Resource Folder", "A resource folder to search for UDF references.", 0, laui_ResourceFolderItem, sizeof(laResourceFolder), 0, 0, 1);{
            laAddStringProperty(p, "path", "Path", "Path", 0, 0, 0, 0, 1, offsetof(laResourceFolder, Path), 0, 0, laset_ResourcePath, 0, 0);
            laAddOperatorProperty(p, "remove", "Remove", "Remove this resource folder entry", "LA_remove_resource_folder", L'❌', 0);
        }

        p = laAddPropertyContainer("managed_udf", "Managed UDF", "Managed UDF files", L'🖹', laui_ManagedUDFItem, sizeof(laManagedUDF), 0, 0, 0);{
            laAddStringProperty(p, "basename", "Base Name", "Base name of the file (withiout directory)", 0, 0, 0, 0, 1, offsetof(laManagedUDF, BaseName), 0, 0, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
            laAddSubGroup(p, "udf", "UDF", "Reference to target UDF file", "udf",0, 0, 0, offsetof(laManagedUDF, udf), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
        }
        p = laAddPropertyContainer("udf", "UDF File", "UDF file block", L'🖹', 0, sizeof(laUDF), 0, 0, 0);{
            laAddStringProperty(p, "path", "Path", "File Path", 0, 0, 0, 0, 1, offsetof(laUDF, FileName), 0, 0, 0, 0, LA_READ_ONLY);
            ep=laAddEnumProperty(p, "modified", "Modified", "File modified", LA_WIDGET_ENUM_ICON_PLAIN,0,0,0,0,offsetof(laUDF, Modified),0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
            laAddEnumItemAs(ep, "MODIFIED", "Modified", "There are unsaved changes bound to this file", 1, L'🌑');
            laAddEnumItemAs(ep, "CLEAN", "Clean", "File data is untouched", 0, 0);
            ep->ElementBytes=2;
        }

        p = laAddPropertyContainer("udf_content_node", "UDF Content Node", "Type Structure For Previewing,Selecting,Linking UDF Contnet", L'🖹', 0, 0, 0, 0, 0);{
            laAddStringProperty(p, "full_path", "Full Path", "Full Path", 0, 0, 0, 0, 0, 0, 0, laget_UDFContentNodeFullPath, 0, 0,LA_READ_ONLY);
            laAddStringProperty(p, "identifier", "Identifier", "Self Identifier", 0, 0, 0, 0, 0, 0, 0, laget_UDFContentNodeIdentifier, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
            laAddIntProperty(p, "file_seek", "File Seek", "Prop Beginner's Location In The File", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laUDFContentNode, FileSeek), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddSubGroup(p, "instances", "Instances", "Instance Nodes (Only SubProps)", "udf_content_instance",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(laUDFContentNode, Instances), 0);
            laAddSubGroup(p, "parent", "Parent", "Parent Instance Node", "udf_content_node",0, 0, 0, offsetof(laUDFContentNode, Parent), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "pc", "Prop Container", "This Property Container", "property_package",0, 0, 0, offsetof(laUDFContentNode, PP), 0, 0, 0, 0, 0, 0, 0, LA_UDF_LOCAL | LA_UDF_REFER);
        }

        p = laAddPropertyContainer("udf_content_instance", "UDF Content Instance", "Instance/FileSeek Storage For Previewing,Selecting,Linking UDF Contnet", L'🖹', 0, 0, 0, 0, 0);{
            laAddStringProperty(p, "identifier", "Identifier", "Self Identifier", 0, 0, 0, 0, 0, 0, 0, laget_UDFContentInstanceIdentifier, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "file_seek", "File Seek", "Instance's Location In The File", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laUDFContentInstance, FileSeek), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
            laAddSubGroup(p, "children", "Children", "Child Properties (Only SubProps)", "udf_content_node",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(laUDFContentInstance, Children), 0);
            laAddSubGroup(p, "parent", "Parent", "Parent Property Node", "udf_content_node",0, 0, 0, offsetof(laUDFContentInstance, Parent), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
        }
        
        p = laAddPropertyContainer("managed_prop", "Managed Property", "Managed property for detecting changes for saving files", 0, 0, sizeof(laManagedSaveProp), 0, 0, 0);{
            laAddStringProperty(p, "path", "Path", "Property path", 0, 0, 0, 0, 1, offsetof(laManagedSaveProp, Path), 0, 0, 0, 0, LA_READ_ONLY);
        }

        p = laAddPropertyContainer("int_property", "Int Property", "Int property specific info", L'i', laui_IntPropInfo, sizeof(laIntProp), 0, 0, 1);{
            laAddIntProperty(p, "range", "Range", "Range of the property", 0, "Min,Max", 0, 0, 0, 0, 0, 0, offsetof(laIntProp, Min), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "default", "Default", "Default value", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laIntProp, DefVal), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "step", "Step", "Ui step of the value", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laIntProp, Step), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddSubGroup(p, "base", "Base", "Property Base", "property_item", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_SINGLE|LA_UDF_LOCAL);
        } MAIN.ContainerInt = p;

        p = laAddPropertyContainer("float_property", "Float Property", "Float property specific info", L'i', laui_FloatPropInfo, sizeof(laFloatProp), 0, 0, 1);{
            laAddFloatProperty(p, "range", "Range", "Range of the property", 0, "Min,Max", 0, 0, 0, 0, 0, 0, offsetof(laFloatProp, Min), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddFloatProperty(p, "default", "Default", "Default value", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laFloatProp, DefVal), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddFloatProperty(p, "step", "Step", "Ui step of the value", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laFloatProp, Step), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddSubGroup(p, "base","Base", "Property Base", "property_item", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_SINGLE|LA_UDF_LOCAL);
        } MAIN.ContainerFloat = p;

        // USER PREF ========================================================

        p = laAddPropertyContainer("la_user_preference", "User Preference", "Kernel settings for LA main structure", L'⚙', 0, sizeof(LA), lapost_UserPreferences, 0, 2|LA_PROP_OTHER_ALLOC);{
            laPropContainerExtraFunctions(p,0,lareset_Main,0,0,0);
            laAddFloatProperty(p, "idle_time", "Idle time", "Time out on no input to show tooltips", 0, 0, 0, 2.0, 0.3, 0.05, 0.75, 0, offsetof(LA, IdleTime), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "top_framerate", "Top Framerate", "Framerate limiter for drawing the user interface", 0, 0, 0, 60, 25, 1, 60, 0, offsetof(LA, TopFramerate), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "valuator_threshold", "Valuator Threshold", "Drag How Many Pixels Trigger A Change In Valuator", 0, 0, 0, 10, 1, 1, 3, 0, offsetof(LA, ValuatorThreshold), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "scroll_speed", "Scrolling Speed", "How Many Pixels To Move When Scrolling Using Mouse Wheel", 0, 0, 0, 10, 1, 1, 3, 0, offsetof(LA, ScrollingSpeed), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddFloatProperty(p, "animation_speed", "Animation Speed", "Ui Animation Speed", 0, 0, 0, 0.6, 0.1, 0.05, 0.2, 0, offsetof(LA, AnimationSpeed), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddFloatProperty(p, "panel_animation_speed", "Panel Animation Speed", "Panel Animation Speed", 0, 0, 0, 0.6, 0.1, 0.05, 0.2, 0, offsetof(LA, PanelAnimationSpeed), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddFloatProperty(p, "zoom_speed_2d", "Zoom Speed 2D", "2D Canvas Zooming Speed", 0, 0, 0, 0.5, 0.01, 0.01, 0.01, 0, offsetof(LA, ZoomSpeed2D), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "tooltip_close_distance", "Tooltip Close Distance", "The tooltip will hide if mouse moved away further", 0, 0, 0, 100, 0, 1, 40, 0, offsetof(LA, TooltipCloseDistance), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            ep = laAddEnumProperty(p, "panel_multisample", "Panel Multisample", "Multisample mode for drawing panels", 0, 0, 0, 0, 0, offsetof(LA, PanelMultisample), 0, laset_PanelMultisample, 0, 0, 0, 0, 0, 0, 0, 0);{
                laAddEnumItemAs(ep, "none", "None", "Don't use multisample", 0,0);
                laAddEnumItemAs(ep, "2", "2X", "2X multisample", 2, 0);
                laAddEnumItemAs(ep, "4", "4X", "4X multisample", 4, 0);
                laAddEnumItemAs(ep, "8", "8X", "8X multisample", 8, 0);
                laAddEnumItemAs(ep, "16", "16X", "16X multisample", 16, 0);
            }
            
            laAddFloatProperty(p, "margin_size", "Margin Size", "The global margin factor", 0, 0, 0, 2.0f, 0.1f, 0.02, 1.0f, 0, offsetof(LA, MarginSize), 0, laset_MarginSize, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddFloatProperty(p, "font_size", "Font Size", "The height of the font related to the row height", 0, 0, 0, 1.0f, 0.1f, 0.02, 0.75, 0, offsetof(LA, FontSize), 0, laset_FontSize, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "interface_size", "Interface Size", "The height of one row of UI item", 0, 0, 0, 64, 16, 1, 40, 0, offsetof(LA, UiRowHeight), 0, laset_UiRowHeight, 0, 0, 0, 0, 0, 0, 0, 0, 0);

            laAddFloatProperty(p, "floating_alpha", "Shadow Alpha", "Shadow Transparency For Floating Panels", 0, 0, 0, 1, 0, 0.01, 0.7, 0, offsetof(LA, FloatingAlpha), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "solid_shadow_length", "Solid Shadow Length", "Solod Length For Floating Panels", 0, 0, 0, 40, 0, 1, 6, 0, offsetof(LA, SolidShadowLength), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "wire_color_slices", "Wire color slices ", "How many slices of color to give to node sockets", 0, 0, 0, 32, 1, 1, 16, 0, offsetof(LA, WireColorSlices), 0, laset_WireColorSlices, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddFloatProperty(p, "wire_thickness", "Wire thickness", "How thick is a wire", 0, 0, 0, 10, 0.1, 0.5, 5, 0, offsetof(LA, WireThickness), 0, laset_WireThickness, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddFloatProperty(p, "wire_saggyness", "Wire saggyness", "How saggy is a wire", 0, 0, 0, 20, 0, 0.5, 5, 0, offsetof(LA, WireSaggyness), 0, laset_WireSaggyness, 0, 0, 0, 0, 0, 0, 0, 0, 0);

            ep = laAddEnumProperty(p, "enable_translation", "Enable Translation", "Translate user interface into another language", 0, 0, 0, 1, 0, offsetof(LA, Translation.EnableTranslation), 0, transState, 0, 0, 0, 0, 0, 0, 0, 0);{
                laAddEnumItem(ep, "no", "No", "Use original english string", L'🗩');
                laAddEnumItem(ep, "yes", "Yes", "Use translated string", 0);
            }
            laAddSubGroup(p, "languages", "Language", "The language list in the software", "la_translation_language",0, 0, laui_IdentifierOnly, offsetof(LA, Translation.CurrentLanguage), 0, 0, 0, 0, 0, 0, offsetof(LA, Translation.Languages), 0);
            
            laAddSubGroup(p, "resource_folders", "Resource Folders", "Folders to search for resources", "la_resource_folder",0,0,0, -1, 0, 0, 0, 0, 0, 0, offsetof(LA, ResourceFolders), 0);
            ep = laAddEnumProperty(p, "manager_default_view", "UDF Manager Default View", "Prefer to show data blocks or files when saving", 0, 0, 0, 0, 0, offsetof(LA, ManagerDefaultView), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);{
                laAddEnumItemAs(ep, "DATA_BLOCKS", "Data Blocks", "All data blocks", 0, 0);
                laAddEnumItemAs(ep, "FILES", "Files", "All Files", 1, 0);
            }
        
            laAddIntProperty(p, "wacom_device_stylus", "Stylus Device", "Wacom stylus device ID", LA_WIDGET_INT_PLAIN, 0, 0, 0, 0, 0, 0, 0, offsetof(LA, WacomDeviceStylus), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_READ_ONLY|LA_UDF_IGNORE);
            laAddIntProperty(p, "wacom_device_eraser", "Eraser Device", "Wacom eraser device ID", LA_WIDGET_INT_PLAIN, 0, 0, 0, 0, 0, 0, 0, offsetof(LA, WacomDeviceEraser), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_READ_ONLY|LA_UDF_IGNORE);
        }

        p = laAddPropertyContainer("la_translation_language", "Language", "Translation language pack", 0, 0, sizeof(laTranslationNode), 0, 0, 2);{
            laAddStringProperty(p, "name", "Name", "The name of this language", 0, 0, 0, "Unknown", 1, offsetof(laTranslationNode, LanguageName), 0, 0, 0, 0, LA_AS_IDENTIFIER);
        }

        p = laAddPropertyContainer("la_extension_type", "Extension Type", "File extension and its matching type for file filtering", 0, 0, sizeof(laExtensionType), 0, 0, 0);{
            laAddStringProperty(p, "extension", "Extension", "File extension string", LA_WIDGET_STRING_PLAIN, 0, 0, 0, 0, offsetof(laExtensionType, Extension), 0, 0, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
        }

        // UI WINDOW ========================================================================================

        p = laAddPropertyContainer("ui_window", "Window Node", "Property Container For A System Window", 0, laui_SubPropInfoDefault, sizeof(laWindow), lapost_Window, 0, 2);{
            laAddStringProperty(p, "title", "Title", "The Title/Name Of A Panel", 0, 0, 0, 0, 1, offsetof(laWindow, Title), 0, 0, 0, 0, LA_AS_IDENTIFIER);
            laAddSubGroup(p, "layouts", "Layouts", "Layout List Of The Whole Window", "ui_layout",0, 0, 0, offsetof(laWindow, CurrentLayout), laget_WindowFirstLayout, 0, laget_ListNext, 0, 0, laset_WindowActiveLayout, offsetof(laWindow, Layouts), 0);
            _LA_PROP_PANEL = laAddSubGroup(p, "panels", "Panels", "Panel list of this window", "ui_panel",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(laWindow, Panels), 0);
            la_UDFAppendSharedTypePointer("_LA_PROP_PANEL", _LA_PROP_PANEL);
            laAddSubGroup(p, "maximized_block", "Maximized Block", "Maximized block in this window", "ui_block",0, 0, 0, offsetof(laWindow, MaximizedBlock), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "maximized_ui", "Maximized Ui", "Maximized ui in this window", "ui_item",0, 0, 0, offsetof(laWindow, MaximizedUi), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "panels_hidden", "Hidden Panels", "Hidden panels of this window", "ui_panel",0, 0, 0, -1, laget_FirstHiddenPanel, 0, laget_NextHiddenPanel, laset_WindowHiddenPanel, 0, 0, 0, LA_UDF_IGNORE);
            laAddIntProperty(p, "position", "Position", "The Position Of A Window", 0, "X,Y", "px", 0, 0, 1, 0, 0, offsetof(laWindow, X), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "size", "Size", "The Size Of A Window", 0, "W,H", "px", 0, 0, 0, 0, 0, offsetof(laWindow, W), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "client_size", "Client Area Size", "Display Canvans Size Of A Window", 0, "W,H", "px", 0, 0, 1, 0, 0, offsetof(laWindow, CW), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddStringProperty(p, "operator_hints", "Operator Hints", "Operator hints if there's any", LA_WIDGET_STRING_PLAIN, 0, 0, 0, 1, offsetof(laWindow, OperatorHints), 0, 0, 0, 0, LA_READ_ONLY);
            ep = laAddEnumProperty(p, "output_color_space", "Output Color Space", "Output color space of this window, set this to the monitor's color space to get accurate result", 0, 0, 0, 0, 0, offsetof(laWindow, OutputColorSpace), 0, laset_WindowColorSpace, 0, 0, 0, 0, 0, 0, 0, 0);{
                laAddEnumItemAs(ep, "SRGB", "sRGB", "Standard sRGB diplay", TNS_COLOR_SPACE_SRGB, 0);
                laAddEnumItemAs(ep, "CLAY", "Clay", "Clay color space (AdobeRGB 1998 compatible)", TNS_COLOR_SPACE_CLAY, 0);
            }
            ep = laAddEnumProperty(p, "output_show_overflow", "Show Overflow", "Show stripes on overflowing colors", LA_WIDGET_ENUM_HIGHLIGHT, 0, 0, 0, 0, offsetof(laWindow, OutputShowStripes), 0, laset_WindowShowStripes, 0, 0, 0, 0, 0, 0, 0, 0);{
                laAddEnumItemAs(ep, "NONE", "None", "Don't show overflow", 0, 0);
                laAddEnumItemAs(ep, "STRIPES", "Stripes", "Show overflowing colors as stripes", 1, 0);
            }
        }

        // UI LAYOUT ========================================================================================

        p = laAddPropertyContainer("ui_block", "Layout Node", "Property Container For Single Layout", 0, laui_LayoutListItem, sizeof(laBlock), 0, 0, 0);{
            laAddIntProperty(p, "location", "Location", "Block Location", 0, "X,Y", "px", 0, 0, 1, 0, 0, offsetof(laBlock, X), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "size", "Size", "Block Size", 0, "W,H", "px", 0, 0, 1, 0, 0, offsetof(laBlock, W), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddFloatProperty(p, "split_ratio", "Split Ratio", "Split Ratio On Two Subs", 0, 0, 0, 1, 0, 0.05, 0.5, 0, offsetof(laBlock, SplitRatio), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "vertical", "Vertical", "Is Vertival Or Not", 0, 0, 0, 1, 0, 1, 0, 0, offsetof(laBlock, Vertical), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "panel_list", "Panel List", "Panels Under This Block", "ui_panel",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(laBlock, Panels), 0);
            laAddSubGroup(p, "current_panel", "Current Panel", "Current Selected Tab Panel", "ui_panel",0, 0, 0, offsetof(laBlock, CurrentPanel), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "sub1", "Sub 1", "Sub Block 1", "ui_block",0, 0, 0, offsetof(laBlock, B1), 0, 0, 0, 0, 0, 0, 0, LA_UDF_SINGLE);
            laAddSubGroup(p, "sub2", "Sub 2", "Sub Block 2", "ui_block",0, 0, 0, offsetof(laBlock, B2), 0, 0, 0, 0, 0, 0, 0, LA_UDF_SINGLE);
            laAddOperatorProperty(p, "fold", "Fold", "Fold the title bar", "LA_block_fold_title", 0, 0);
            laAddOperatorProperty(p, "maximize", "Maximize", "Maximize the block", "LA_block_maximize", 0, 0);
        }

        p = laAddPropertyContainer("ui_layout", "Layout Node", "Property Container For Single Layout", 0, laui_LayoutListItem, sizeof(laLayout), 0, 0, 2);{
            laAddStringProperty(p, "title", "Title", "The Title/Name Of A Panel", 0, 0, 0, 0, 1, offsetof(laLayout, ID), 0, 0, 0, 0, LA_AS_IDENTIFIER);
            _LA_PROP_BLOCK = laAddSubGroup(p, "root_block", "Root Block", "Root Block For Panel Docking", "ui_block",0, 0, 0, offsetof(laLayout, FirstBlock), 0, 0, 0, 0, 0, 0, 0, LA_UDF_SINGLE);
            la_UDFAppendSharedTypePointer("_LA_PROP_BLOCK", _LA_PROP_BLOCK);
        }

        // UI PANEL =========================================================================================

        p = laAddPropertyContainer("ui_panel", "Panel Node", "Property Container For General Panels", 0, laui_PanelListItem, sizeof(laPanel), lapost_Panel, 0, 1);{
            laAddStringProperty(p, "title", "Title", "The Title/Name Of A Panel", 0, 0, 0, 0, 1, offsetof(laPanel, Title), 0, 0, laset_PanelTitle, 0, LA_AS_IDENTIFIER);
            laAddIntProperty(p, "position", "Position", "The Position Of A Panel", 0, "X,Y", "px", 0, 0, 1, 0, 0, offsetof(laPanel, X), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "size", "Size", "The Size Of A Panel", 0, "Width,Height", "px", 0, 0, 1, 0, 0, offsetof(laPanel, W), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "real_xywh", "Real Placemnt", "Placeent Data In Structure", 0, "X,Y,W,H", "px", 0, 0, 1, 0, 0, offsetof(laPanel, TX), 0, 0, 4, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            ep = laAddEnumProperty(p, "snap_enable", "Snap Enable", "Enable Snapping To Edges", 0, "Left,Right,Top,Bottom", 0, 0, 0, 0, 0, 0, 4, 0, laset_PanelSnapEnable, laget_PanelSnapEnable, 0, 0, 0, 0);{
                laAddEnumItem(ep, "no", "No Snap", "Not Snapped to edge", 0);
                laAddEnumItem(ep, "yes", "Snap", "Snapped to edge", L'🞉');
            } //don't swap order with the one below
            laAddIntProperty(p, "snap", "Snap Distance", "Snapping Distance To Edges", 0, "Left,Right,Top,Bottom", "px", 0, 0, 1, 0, 0, offsetof(laPanel, SL), 0, 0, 4, 0, laset_PanelSnapDistance, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "show", "Show", "The Panel Is Shown Or Not", 0, 0, 0, 0, 0, 1, 0, 0, offsetof(laPanel, Show), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "mode", "Mode", "Normal/Floating/Static/Modal etc.", 0, 0, 0, 0, 0, 1, 0, 0, offsetof(laPanel, Mode), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            ep = laAddEnumProperty(p, "is_menu_panel", "Is Menu Panel", "Is Menu Panel", 0, 0, 0, 0, 0, offsetof(laPanel, IsMenuPanel), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);{
                ep->ElementBytes = 1;
                laAddEnumItem(ep, "false", "False", "Not A Menu Panel", L'❌');
                laAddEnumItem(ep, "true", "IsTrue", "Is A Menu Panel", L'🗩');
            }
            laAddOperatorProperty(p, "hide", "Hide", "Hide this panel", "LA_hide_panel", L'🗕', 0);
            laAddOperatorProperty(p, "dock", "Dock", "Dock this panel", "LA_dock_panel", L'🗖', 0);
            laAddOperatorProperty(p, "close", "Close", "Close this panel", "LA_block_close_panel", L'❌', 0);
            //laAddSubGroup(p, "Detached Props", "Detached Props", "detached_prop",0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laPanel, PropLinkContainer->Props), 0);
            laAddSubGroup(p, "uil","Ui List", "Panel Main Ui List", "ui_list",0, 0, 0, offsetof(laPanel, UI), 0, 0, 0, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "title_uil","Title Ui List", "Panel Title Ui List", "ui_list",0, 0, 0,  offsetof(laPanel, TitleBar), 0, 0, 0, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "pp","Prop Pack", "Panel Base With Own Instance", "property_package",0, 0, 0, offsetof(laPanel, PP), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "fake_pp","Fake Prop Pack", "Fake Prop Pack", "property_package",0, 0, 0, offsetof(laPanel, PropLinkPP), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "parent_block","Parent Block", "The Block That Directly Links This Panel In", "ui_block",0, 0, 0, offsetof(laPanel, Block), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
        }

        // UI ITEM ==========================================================================================

        p = laAddPropertyContainer("ui_list", "Ui List", "Property Container For Ui List Sub Type", L'⮑', 0, sizeof(laUiList), 0, 0, 0);{
            laAddStringProperty(p, "tab_name", "Tab Name", "The Name Of A Tab", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_AS_IDENTIFIER);
            _LA_PROP_UI_ITEM = laAddSubGroup(p, "ui_items", "Ui Items", "Ui Items Listed In Ui List", "ui_item",0, 0, 0, -1, laget_FirstUiItem, 0, laget_ListNext, 0, 0, 0, offsetof(laUiList, UiItems), 0);
            la_UDFAppendSharedTypePointer("_LA_PROP_UI_ITEM", _LA_PROP_UI_ITEM);
            laAddSubGroup(p, "column_items", "Column Items", "Ui Items Listed In Ui List", "ui_column",0, 0, 0, -1, laget_FirstColumnItem, 0, 0, 0, 0, 0, offsetof(laUiList, Columns), 0);
            laAddIntProperty(p, "pan", "Pan", "Cavans Panning Pixels", 0, "Pan X,Pan Y", "px", 10000, 0, 1, 0, 0, offsetof(laUiList, PanX), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "instance", "Instance", "Collection Instance For Every Item", "ui_instance",0, 0, 0, offsetof(laUiList, Instance), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);

            laAddIntProperty(p, "height_coeff", "Height Coefficiency", "How Many Rows A Ui Should Take Or Reserve", 0, 0, "Rows", 0, 0, 1, 0, 0, offsetof(laUiList, HeightCoeff), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
                ->ElementBytes = 2;
            laAddIntProperty(p, "icon_id", "Icon ID", "Icon ID For This Ui List", 0, 0, "#", 1800, 32, 1, 0, 0, offsetof(laUiList, IconID), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
                ->ElementBytes = 2;
        }
        p = laAddPropertyContainer("ui_instance", "Instance", "UiList Instance Entry", L'🗇', 0, sizeof(laColumn), 0, 0, 0);{
            //nothing needed
        }
        p = laAddPropertyContainer("ui_column", "Ui Column", "A Column Handles The Aligning Of Ui Items", L'◫', laui_IdentifierOnly, sizeof(laColumn), 0, 0, 0);{
            laAddFloatProperty(p, "split_at", "Split At", "Split Width Percentage From Left", 0, 0, 0, 1, 0, 0.01, 0.5, 0, 0, laget_ColumnSP, laset_ColumnSP, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_IGNORE);
            laAddFloatProperty(p, "real_split", "Real Split", "Float Value Split Pos In Real Strucutre", 0, 0, 0, 1, 0, 0.01, 0.5, 0, offsetof(laColumn, SP), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "snap_width", "Snap Width", "Snap Width Of A Column", 0, 0, 0, 200, 20, 1, 30, 0, 0, laget_ColumnSnap, laset_ColumnSnap, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_IGNORE);
            laAddIntProperty(p, "real_snap", "Real Snap", "Int Snap Value In Real Structure", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laColumn, MaxW), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            ep = laAddEnumProperty(p, "snap_state", "Sub Snap State", "How To Snap Sub Columns", 0, 0, 0, 0, 0, 0, laget_SnapState, laset_SnapState, 0, 0, 0, 0, 0, 0, 0, LA_UDF_IGNORE);{
                laAddEnumItem(ep, "none", "None", "No Snapping", 0);
                laAddEnumItem(ep, "left", "Left", "Snap At Left", L'⮄');
                laAddEnumItem(ep, "right", "Right", "Snap At Right", L'⮆');
            }
            laAddSubGroup(p, "left", "Left Sub Column", "Left Sub Column", "ui_column",0, 0, 0, offsetof(laColumn, LS), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "right", "Right Sub Column", "Right Sub Column", "ui_column",0, 0, 0, offsetof(laColumn, RS), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "self", "Self", "Self Display", "ui_column",0, LA_WIDGET_COLUMN_VIEWER, 0, -1, laget_Self, 0, 0, 0, 0, 0, 0, LA_UDF_REFER | LA_AS_IDENTIFIER);
        }
        p = laAddPropertyContainer("panel_template", "Panel Template", "Panel template for creating new panels", 0, 0, sizeof(laUiTemplate), 0, 0, 0);{
            laAddStringProperty(p, "identifier", "Identifier", "Identifier Of This Template", 0, 0, 0, 0, 1, offsetof(laUiTemplate, Identifier), 0, 0, 0, 0, LA_AS_IDENTIFIER);
            laAddStringProperty(p, "title", "Title", "Panel title", 0, 0, 0, 0, 1, offsetof(laUiTemplate, Title), 0, 0, 0, 0, 0);
            laAddIntProperty(p, "define_func", "Define Func", "Define Function Distinguish(Internal Only)", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laUiTemplate, Define), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_IGNORE|LA_READ_ONLY);
        }

        p = laAddPropertyContainer("ui_item", "Ui Item", "Property Container For Ui Items", 0, 0, sizeof(laUiItem), lapost_UiItem, lapostim_UiItem, 0);{
            laAddIntProperty(p, "location", "Location", "The Ui's Location In A UiList(Prop For Live Edit Only)", 0, "Up", "Down", 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_AS_IDENTIFIER);
            laAddIntProperty(p, "state", "State", "The Ui's Internal State", 0, 0, 0, 0, 0, 1, 0, 0, offsetof(laUiItem, State), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "column_layout", "Column Layout", "The Ui's Column Layout", 0, 0, 0, 10, -10, 1, 0, 0, offsetof(laUiItem, SymbolID), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
                ->ElementBytes = sizeof(short);
            //ep = laAddEnumProperty(p, "type", "Type", "The Type Of This Ui Item", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_IGNORE);{
            //    laAddEnumItemAs(ep, "button", "Button", "Button (Pure Operator)", LA_UI_INTERNAL_BUTTON, L'🔨');
            //    laAddEnumItemAs(ep, "property_watcher", "Property Watcher", "Property Watcher For Int/Float/Enum", LA_UI_INTERNAL_WATCHER, L'🔑');
            //    laAddEnumItemAs(ep, "group", "Group", "A Group That Holds A Sub-UiList", LA_UI_INTERNAL_GROUP, L'📁');
            //    laAddEnumItemAs(ep, "tab", "Tab", "A Tab Root That Holds Multiple Sub-UiList", LA_UI_INTERNAL_TAB, L'📑');
            //    laAddEnumItemAs(ep, "label", "Label", "A Static Label", LA_UI_INTERNAL_LABEL, 0);
            //    laAddEnumItemAs(ep, "3d_view", "3D View", "Integrated 3D View UI Item", LA_UI_INTERNAL_3D_VIEW, 0);
            //    laAddEnumItemAs(ep, "2d_view", "2D View", "Integrated 2D View UI Item", LA_UI_INTERNAL_2D_VIEW, L'🖻');
            //    laAddEnumItemAs(ep, "column_adjuster", "Column Adjuster", "To Adjust Column Width", LA_UI_INTERNAL_ADJUSTER, L'↔');
            //    laAddEnumItemAs(ep, "bracket_begin", "Bracket Begin", "Bracket Beginner Used To Set Ui Conditions", LA_UI_INTERNAL_BRACKET_BEGIN, '{');
            //    laAddEnumItemAs(ep, "bracket_else", "Bracket Else", "Bracket Else Block Beginner", LA_UI_INTERNAL_BRACKET_ELSE, 0);
            //    laAddEnumItemAs(ep, "folder_begin", "Folder Begin", "Folder Beginner Used To Toggle Some Display", LA_UI_INTERNAL_FOLDER_BEGIN, '{');
            //    laAddEnumItemAs(ep, "bracket_end", "Bracket End", "Bracket Closer", LA_UI_INTERNAL_BRACKET_END, '}');
            //    laAddEnumItemAs(ep, "aligner", "Aligner", "Align Column Heights", LA_UI_INTERNAL_ALIGNER, 0);
            //    laAddEnumItemAs(ep, "menu", "Menu", "Menu Activiator", LA_UI_INTERNAL_MENU, L'🗩');
            //}
            laAddStringProperty(p, "path", "Path", "Data Path", 0, 0, 0, 0, 0, 0, 0, laget_UiDataPath, 0, laread_UiDataPath,LA_READ_ONLY);
            laAddStringProperty(p, "actuator_id", "Operator ID", "Pure Operator With No 'This' Pointer", 0, 0, 0, 0, 0, 0, 0, laget_UiOperatorID, 0, laread_UiOperatorID,LA_READ_ONLY);
            laAddSubGroup(p, "pp", "Prop Pack", "Property Package In ui->PP Entry", "property_package",0, 0, 0, offsetof(laUiItem, PP), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "extra_pp", "Extra Prop Pack", "Property Package In ui->ExtraPP Entry", "property_package",0, 0, 0, offsetof(laUiItem, ExtraPP), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "go", "Prop Step Go", "Go Entry (For Determin If This Is A Prop Or Not)", "property_step",0, 0, 0, offsetof(laUiItem, PP.Go), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER | LA_UDF_IGNORE);
            laAddSubGroup(p, "raw_this", "Prop Raw This", "ui->PP.RawThis Entry", "property_package",0, 0, 0, offsetof(laUiItem, PP.RawThis), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            //ep = laAddSubGroup(p, "Ui Template", "A Template Used To Create Sub Ui", "ui_template",0, LA_WIDGET_COLLECTION_SELECTOR, 0, offsetof(laUiItem, Template), laget_PanelTemplate, 0, laget_ListNext, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            //laSubGroupDetachable(ep, laget_UiTemplate, laget_ListNext);
            laAddSubGroup(p, "current_page", "Current Page", "Current Page In Sub Ui List", "ui_list",0, 0, 0, offsetof(laUiItem, Page), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "internal_type", "Ui Internal Type", "Ui Internal Type", "ui_type",0, 0, 0, offsetof(laUiItem, Type), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "on_column", "On Column", "Ui On Which Column", "ui_column",0, 0, 0, offsetof(laUiItem, C), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddSubGroup(p, "sub", "Sub UI", "Sub Ui Lists For Tabs And Collection", "ui_list",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(laUiItem, Subs), 0);
            laAddStringProperty(p, "extra_args", "Extra Arguments", "Extra Arguments For This Ui Item", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddStringProperty(p, "display", "Display", "Display String For Label", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            //laAddSubGroup(p, "Condition Ui Extra Data", "Condition Ui Extra Data For Linkage And Conditioning", "ui_condition_extra_data",0, 0, 0, offsetof(laUiItem, Extra), laget_ConditionerExtra, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            //laAddSubGroup(p, "2d_extra", "2D View Extra Data", "2D View Ui States And Modes Storage", 0,0, 0, 0, offsetof(laUiItem, Extra), laget_CanvasExtra, 0, 0, 0, 0, 0, 0, 0);
            laAddOperatorProperty(p, "maximize", "Maximize", "Maximize this UI item", "LA_canvas_ui_maximize", 0, 0);
        }

        p = laAddPropertyContainer("ui_type", "Ui Type", "Ui Type Descriptor", 0, laui_IdentifierOnly, sizeof(laUiType), 0, 0, 0);{
            laAddStringProperty(p, "identifier", "Identifier", "Identifier Of This Ui Type", 0, 0, 0, 0, 0, offsetof(laUiType, Identifier), 0, 0, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
        }

        // NODE ================================================================================================

        p = laAddPropertyContainer("la_out_socket", "Output Socket", "Output socket for nodes", 0, 0, sizeof(laNodeOutSocket), 0, 0, 1);{
            laAddStringProperty(p, "label", "Label", "Socket's label", 0, 0, 0, 0, 1, offsetof(laNodeOutSocket, Label), 0, 0, 0, 0, LA_AS_IDENTIFIER);
            laAddIntProperty(p, "data_type", "Data type", "User defined data type", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeOutSocket, DataType), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "array_length", "Array Length", "Array length of data", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeOutSocket, ArrLen), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddSubGroup(p, "parent", "Parent", "Parent node", "la_base_node",0, 0, 0, offsetof(laNodeOutSocket, Parent), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
        } LA_PC_SOCKET_OUT = p;
        p = laAddPropertyContainer("la_in_socket", "Input Socket", "Input socket for nodest", 0, 0, sizeof(laNodeInSocket), 0, 0, 1);{
            laAddStringProperty(p, "label", "Label", "Socket's label", 0, 0, 0, 0, 1, offsetof(laNodeInSocket, Label), 0, 0, 0, 0, LA_AS_IDENTIFIER);
            sp=laAddSubGroup(p, "source", "Source", "Source socket", "la_out_socket",0, 0, offsetof(laNodeInSocket, Source), 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            LA_PROP_SOCKET_SOURCE=sp;
            laAddIntProperty(p, "data_type", "Data type", "User defined data type", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeInSocket, DataType), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "color_id", "Color ID", "Color ID of the source wire", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeInSocket, ColorId), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0);
            laAddIntProperty(p, "array_length", "Array Length", "Array length of data", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeInSocket, ArrLen), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
        } LA_PC_SOCKET_IN = p;
        laPropContainerExtraFunctions(p,0,0,latouched_NodeInSocket,0,0);

        p = laAddPropertyContainer("la_value_mapper", "Value Mapper", "Value mapper", 0, 0, sizeof(laValueMapper), 0, 0, 1);{
            laAddSubGroup(p, "points", "Points", "Points inside the mapper", "la_value_mapper_point",0, 0, -1, 0, 0, 0, 0, 0, 0, 0, offsetof(laValueMapper, Points), 0);
            laAddFloatProperty(p, "in_range", "Input Range", "Input range from 0 to 1", 0, "Min,Max", 0, 0, 0, 0, 0, 0, offsetof(laValueMapper, InRange), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddFloatProperty(p, "out_range", "Output Range", "Output range from 0 to 1", 0, "Min,Max", 0, 0, 0, 0, 0, 0, offsetof(laValueMapper, OutRange), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0);
        } LA_PC_MAPPER=p;
        p = laAddPropertyContainer("la_value_mapper_point", "Value Mapper", "Value mapper", 0, 0, sizeof(laValueMapperPoint), 0, 0, 1);{
            laAddFloatProperty(p, "position", "Position", "XY Position ranging from 0 to 1", 0, "X,Y", 0, 0, 0, 0, 0, 0, offsetof(laValueMapperPoint, x), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0);
        }
        

        // PROPERTIES ==========================================================================================

        p = laAddPropertyContainer("property_item", "Property Item", "Property Item For Data Types Like Int/Float/Enum/String/SubType", L'🔌', 0, sizeof(laProp), 0, 0, 1);{
            laAddStringProperty(p, "identifier", "Identifier", "Property Unique Identifier", LA_WIDGET_STRING_PLAIN, 0, 0, 0, 0, 0, 0, laget_PropertyIdentifier, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
            laAddStringProperty(p, "name", "Name", "Property Display Name", 0, 0, 0, 0, 0, offsetof(laProp, Name), 0, 0, 0, 0,LA_READ_ONLY);
            laAddStringProperty(p, "description", "Description", "Property Description", 0, 0, 0, 0, 0, offsetof(laProp, Description), 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "prop_type", "Property Type", "Property Type(Like Int/Float/Enunm/Sub)", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laProp, PropertyType), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
            laAddIntProperty(p, "icon_id", "Icon Id", "Icon ID For Current Container", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laProp, IconID), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddIntProperty(p, "sub_icon_id", "Icon Id", "Icon ID For Current Container", 0, 0, 0, 0, 0, 0, 0, 0, 0, laget_PropertySubContainerIconID, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "sub", "Sub Type", "Sub Type Property Container", "property_container",0, 0, 0, offsetof(laProp, SubProp), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
        }

        p = laAddPropertyContainer("property_container", "Property Container", "Property Container For Some Property Items", L'🔌', 0, sizeof(laPropContainer), 0, 0, 1);{
            laAddStringProperty(p, "identifier", "Identifier", "Property Unique Identifier", LA_WIDGET_STRING_PLAIN, 0, 0, 0, 0, offsetof(laPropContainer, Identifier), 0, 0, 0, 0, LA_AS_IDENTIFIER | LA_UDF_IGNORE|LA_READ_ONLY);
            laAddStringProperty(p, "name", "Name", "Property Display Name", 0, 0, 0, 0, 0, offsetof(laPropContainer, Name), 0, 0, 0, 0, LA_UDF_IGNORE|LA_READ_ONLY);
            laAddStringProperty(p, "description", "Description", "Property Description", 0, 0, 0, 0, 0, offsetof(laPropContainer, Name), 0, 0, 0, 0, LA_UDF_IGNORE|LA_READ_ONLY);
            laAddIntProperty(p, "icon_id", "Icon Id", "Icon ID For Current Container", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laPropContainer, IconID), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            laAddSubGroup(p, "properties", "Properties", "Single Property", "property_item", laget_PropertyNodeType, 0, 0, -1, laget_PropertyItemFirst, laget_PropertyItemFirst, laget_PropertyItemNext, 0, 0, 0, 0, LA_UDF_IGNORE);
            _LA_PROP_FAILED_ITEM = laAddSubGroup(p, "failed_nodes", "Failed Nodes", "Used To Store UDF Failed Nodes", "property_trash_item",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(laPropContainer, FailedNodes), LA_UDF_IGNORE);
            _LA_PROP_TRASH_ITEM = laAddSubGroup(p, "trash_bin", "Trash Bin", "Used To Store Unlinked Items", "property_trash_item",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(laPropContainer, TrashBin), LA_UDF_IGNORE);
            laAddOperatorProperty(p, "restore_all", "Restore All", "Restore All Trash Items Or Failed Nodes To A User Selected Linkage", "LA_sub_restore_data_block", L'⭯', 0);
        }

        p = laAddPropertyContainer("property_trash_item", "Trash Item", "Single Trash Item", 0, 0, 0, 0, 0, 0);{
            laAddIntProperty(p, "instance_int", "Instance", "Memory Address Of This Data Block (INT Represent)", 0, 0, 0, 0, 0, 0, 0, 0, 0, laget_TrashItemInstance, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
            laAddSubGroup(p, "instance", "Instance", "Single Memory Address Of This Data Block", "property_trash_item",0, 0, 0, -1, 0, laget_TrashItemInstance, 0, 0, 0, 0, 0, LA_UDF_REFER | LA_UDF_IGNORE);
            laAddOperatorProperty(p, "restore", "Restore", "Restore Data Block To A User Selected Linkage", "LA_sub_restore_data_block", L'⭯', 0);
        }

        p = laAddPropertyContainer("property_package", "Property Package", "Property Package For Data Access (Mainly UI)", L'🔌', 0, sizeof(laPropPack), 0, 0, 0);{
            laAddSubGroup(p, "last_step", "Last Step", "Last Prop Step(Segment)", "property_step",0, 0, 0, offsetof(laPropPack, LastPs), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER | LA_UDF_IGNORE);
        }
        p = laAddPropertyContainer("property_step", "Property Step", "Property Segment Item", 0, 0, sizeof(laPropStep), 0, 0, 0);{
            laAddSubGroup(p, "property", "Property", "Property Reference", "property_item",0, 0, 0, offsetof(laPropStep, p), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
        }
        p = laAddPropertyContainer("detached_prop", "Detached Prop", "Detached Prop", L'🔌', 0, sizeof(laSubProp) + 48, lapost_DetachedProp, 0, 0);{
            laAddSubGroup(p, "raw_this", "Raw This", "Raw This Pointer", "property_package",0, 0, 0, offsetof(laProp, DetachedPP.RawThis), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
            laAddStringProperty(p, "path", "Path", "Data Path", 0, 0, 0, 0, 0, 0, 0, laget_DetachedPropPath, 0, laread_DetachedPropPath, 0);
            laAddStringProperty(p, "rename", "Rename", "Rename", 0, 0, 0, 0, 0, offsetof(laProp, Identifier), 0, 0, 0, laread_DetachedPropRename, 0);
        }

    }

    // TNS WORLD ============================================================================================

    p = laAddPropertyContainer("tns_main", "TNS Main", "Render Kernel Root Structure", 0, 0, sizeof(tnsMain), 0, 0, 2);{
        laAddSubGroup(p, "world", "World", "World Descriptor", "tns_world",0, 0, 0, offsetof(tnsMain, World), 0, 0, 0, 0, 0, 0, 0, LA_UDF_SINGLE | LA_UDF_LOCAL);

        sp = laAddSubGroup(p, "texture_list", "Texture List", "List Of All Textures Under TNS Management", "tns_texture",0, 0, 0, -1, 0, tnsget_PreviewTexture, 0, 0, 0, tnsset_PreviewTexture, offsetof(tnsMain, Textures), LA_UDF_IGNORE);
        laSubGroupDetachable(sp, tnsget_detached_FirstTexture, laget_ListNext);

        //laAddSubGroup(p, "Render Buffers", "Storing All Render Buffers In Current Program Instance", "tns_render_buffer",0, 0, 0, offsetof(tnsMain, ActiveRenderBuffer), 0, 0, 0, 0, 0, 0, 0, 0, offsetof(tnsMain, RenderBuffers), 0);
    }

    p = laAddPropertyContainer("tns_texture", "TNS Texture Item", "A Texture Descriptor With GL Handle", 0, 0, sizeof(tnsTexture), 0, 0, 0);{
        laAddIntProperty(p, "gl_handle", "OpenGL Handle", "OpenGL Handle Of This Texture", LA_WIDGET_INT_PLAIN, 0, 0, 0, 0, 0, 0, 0, offsetof(tnsTexture, GLTexHandle), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_AS_IDENTIFIER|LA_READ_ONLY);
        laAddIntProperty(p, "size", "Size", "Width And Height", 0, "Width,Height", "px", 0, 0, 0, 0, 0, offsetof(tnsTexture, Width), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
        ep = laAddEnumProperty(p, "internal_type", "Internal Type", "Internal bits type", LA_WIDGET_ENUM_CYCLE, 0, 0, 0, 0, offsetof(tnsTexture, GLTexBitsType), 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);{
            laAddEnumItemAs(ep, "rgba", "GL_RGBA", "GL_RGBA", GL_RGBA8,0);
            laAddEnumItemAs(ep, "rgb", "GL_RGB", "GL_RGB", GL_RGB8,0);
            laAddEnumItemAs(ep, "rg", "GL_RG", "GL_RG", GL_RG8,0);
            laAddEnumItemAs(ep, "r", "GL_RED", "GL_RED", GL_R8,0);
            laAddEnumItemAs(ep, "rgba32f", "GL_RGBA32F", "GL_RGBA32F", GL_RGBA32F,0);
            laAddEnumItemAs(ep, "rgb32f", "GL_RGB32F", "GL_RGB32F", GL_RGB32F,0);
            laAddEnumItemAs(ep, "rg32f", "GL_RG32F", "GL_RG32F", GL_RG32F,0);
            laAddEnumItemAs(ep, "r32f", "GL_R32F", "GL_R32F", GL_R32F,0);
            laAddEnumItemAs(ep, "rgba32i", "GL_RGBA32I", "GL_R32I", GL_RGBA32I,0);
            laAddEnumItemAs(ep, "rgb32i", "GL_RGB32I", "GL_R32I", GL_RGB32I,0);
            laAddEnumItemAs(ep, "rg32i", "GL_RG32I", "GL_R32I", GL_RG32I,0);
            laAddEnumItemAs(ep, "r32i", "GL_R32I", "GL_R32I", GL_R32I,0);
            laAddEnumItemAs(ep, "depth", "GL_DEPTH_COMPONENT32F", "GL_DEPTH_COMPONENT32F", GL_DEPTH_COMPONENT32F,0);
        }
        p->Template2D = la_GetCanvasTemplate(0, "la_CanvasDrawTexture");
    }

    p = laAddPropertyContainer("tns_world", "World", "3D World Structure", 0, 0, sizeof(tnsWorld), 0, 0, 2|LA_PROP_OTHER_ALLOC);{
        sp = laAddSubGroup(p, "root_objects", "Root Objects", "List of all root objects", "tns_object",0, 0, 0, 0, 0, 0, 0, 0, 0, 0, offsetof(tnsWorld, RootObjects), 0);
        laSubGroupDetachable(sp, tnsget_detached_FirstRootObject, laget_ListNext);
        sp = laAddSubGroup(p, "objects", "Objects", "List of all objects", "tns_object",tnsget_ObjectType, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(tnsWorld, AllObjects), 0);
    }

    p = laAddPropertyContainer("tns_child_object", "Child Object", "Child object linker", 0, 0, sizeof(laListItemPointer), 0, 0, 0);{
        laAddSubGroup(p, "object", "Object", "Object link", "tns_object",tnsget_ObjectType, 0, 0, offsetof(laListItemPointer, p), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
    }

    p = laAddPropertyContainer("tns_object", "Object", "3D Object Item", 0, 0, sizeof(tnsObject), tnspost_Object, 0, 2);{
        laPropContainerExtraFunctions(p,0,0,0,tnspropagate_Object,0);
        TNS_PC_OBJECT_GENERIC=p;
        laAddStringProperty(p, "name", "Object Name", "The Name Of The Object", 0, 0, 0, 0, 1, offsetof(tnsObject, Name), 0, 0, 0, 0, LA_AS_IDENTIFIER);
        laAddIntProperty(p,"flags","Flags","Flags",0,0,0,0,0,0,0,0,offsetof(tnsObject,Flags),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        ep = laAddEnumProperty(p, "show", "Show", "Show object in the viewport", 0, 0, 0, 0, 0, offsetof(tnsObject, Show), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);{
            laAddEnumItem(ep, "false", "False", "False", L'🌔');
            laAddEnumItem(ep, "true", "IsTrue", "IsTrue", L'🌑');
        }
        ep = laAddEnumProperty(p, "show_on_render", "Show On Render", "Show on render", 0, 0, 0, 0, 0, offsetof(tnsObject, ShowOnRender), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);{
            laAddEnumItem(ep, "false", "False", "False", L'🚫');
            laAddEnumItem(ep, "true", "IsTrue", "IsTrue", L'📷');
        }
        ep = laAddEnumProperty(p, "type", "Type", "Object Type Like Mesh,Camera And Lamp", 0, 0, 0, 0, 0, offsetof(tnsObject, Type), 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_READ_ONLY);{
            laAddEnumItemAs(ep, "EMPTY", "Empty", "Empty object, not rendered", 0, L'➕');
            laAddEnumItemAs(ep, "CAMERA", "Camera", "Camera object, to render a scene", TNS_OBJECT_CAMERA, L'📷');
            laAddEnumItemAs(ep, "LIGHT", "Lamp", "Lamp object, to illuminate the scene", TNS_OBJECT_LIGHT, 0);
            laAddEnumItemAs(ep, "MESH", "Mesh", "Mesh object, made of verts/edges/faces", TNS_OBJECT_MESH, 0);
        }
        laAddFloatProperty(p, "location", "Location", "XYZ Location In Local Coordinates", 0, "X,Y,Z", 0, 0, 0, 0.1, 0, 0, offsetof(tnsObject, Location), 0, 0, 3, 0, tnsset_ObjectLocation, 0, 0, 0, 0, 0, 0);
        laAddFloatProperty(p, "rotation", "Rotation", "Rotation In Local Coordinates", 0, "X,Y,Z", 0, 0, 0, 0, 0, 0, offsetof(tnsObject, Rotation), 0, 0, 3, 0, tnsset_ObjectRotation, 0, 0, 0, 0, 0, 0);
        laAddFloatProperty(p, "scale", "Scale", "Local Uniform Scale", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(tnsObject, Scale), 0, tnsset_ObjectScale, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        laAddFloatProperty(p, "glocation", "Global Location", "Location in global coordinates", 0, "X,Y,Z", 0, 0, 0, 0.1, 0, 0, offsetof(tnsObject, GLocation), 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0);
        laAddFloatProperty(p, "grotation", "Global Rotation", "Rotation in global coordinates", 0, "X,Y,Z", 0, 0, 0, 0, 0, 0, offsetof(tnsObject, GRotation), 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0);
        laAddFloatProperty(p, "gscale", "Global Scale", "Global uniform scale", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(tnsObject, GScale), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        laAddFloatProperty(p, "global_mat", "Global Matrix", "Global transformation matrix", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(tnsObject, GlobalTransform), 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, LA_READ_ONLY);
        laAddFloatProperty(p, "local_mat", "Local Matrix", "Local transformation matrix", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(tnsObject, SelfTransform), 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, LA_READ_ONLY);
        ep = laAddEnumProperty(p, "rotation_mode", "Rotation Mode", "Rotation Mode Of This Object(e.g. XYZ/XZY/Quaternion...)", 0, 0, 0, 0, 0, offsetof(tnsObject, RotationMode), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);{
            laAddEnumItem(ep, "xyz", "XYZ", "XYZ Euler Mode", 0); laAddEnumItem(ep, "xzy", "XZY", "XZY Euler Mode", 0);
            laAddEnumItem(ep, "yxz", "YXZ", "YXZ Euler Mode", 0); laAddEnumItem(ep, "yzx", "YZX", "YZX Euler Mode", 0);
            laAddEnumItem(ep, "zxy", "ZXY", "ZXY Euler Mode", 0); laAddEnumItem(ep, "zyx", "ZYX", "ZYX Euler Mode", 0);
            laAddEnumItem(ep, "quaternion", "Quaternion", "Quaternion Mode", 0);
        }
        laAddSubGroup(p, "active", "Active", "Active reference", "tns_object",0, 0, 0, offsetof(tnsObject, Active), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER|LA_READ_ONLY);
        laAddSubGroup(p, "in_root", "In Root", "Root object of this object", "tns_object",0, 0, 0, offsetof(tnsObject, InRoot), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
        laAddSubGroup(p, "parent", "Parent", "Object parent", "tns_object",0, 0, 0, offsetof(tnsObject, ParentObject), 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
        laAddSubGroup(p, "children", "Children", "The Children Of This Object", "tns_child_object",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(tnsObject, ChildObjects), 0);
    }
    p = laAddPropertyContainer("tns_mesh_object", "Mesh Object", "Mesh object", 0, 0, sizeof(tnsMeshObject), tnspost_Object, 0, 2);{
        laPropContainerExtraFunctions(p,0,0,tnstouched_Object,tnspropagate_Object,0);
        TNS_PC_OBJECT_MESH=p;
        laAddStringProperty(p, "name", "Object Name", "The Name Of The Object", 0, 0, 0, 0, 1, offsetof(tnsObject, Name), 0, 0, 0, 0, LA_AS_IDENTIFIER);
        laAddSubGroup(p, "base", "Base", "Object base", "tns_object",0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_LOCAL);
        ep = laAddEnumProperty(p, "mode", "Mode", "Mesh object mode", 0, 0, 0, 0, 0, offsetof(tnsMeshObject, Mode), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);{
            laAddEnumItemAs(ep, "OBJECT", "Object", "Object mode", TNS_MESH_OBJECT_MODE, 0);
            laAddEnumItemAs(ep, "EDIT", "Edit", "Edit mode", TNS_MESH_EDIT_MODE, 0);
        }
        laAddSubGroup(p, "mv", "MMesh Verts", "Vertices of editing mesh", "tns_mvert",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(tnsMeshObject, mv), 0);
        laAddSubGroup(p, "me", "MMesh Edges", "Edges of editing mesh", "tns_medge",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(tnsMeshObject, me), 0);
        laAddSubGroup(p, "mf", "MMesh Faces", "Faces of editing mesh", "tns_mface",0, 0, 0, -1, 0, 0, 0, 0, 0, 0, offsetof(tnsMeshObject, mf), 0);
        laAddIntProperty(p, "totmv", "MVert Count", "Total MVert", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, totmv),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        laAddIntProperty(p, "totme", "MEdge Count", "Total MEdge", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, totme),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        laAddIntProperty(p, "totmf", "MFace Count", "Total MFace", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, totmf),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        laAddRawProperty(p, "v", "Verts", "Verts", offsetof(tnsMeshObject, v), tnsget_MeshObjectVertSize, 0, 0, LA_READ_ONLY);
        laAddRawProperty(p, "e", "Edges", "Edges", offsetof(tnsMeshObject, e), tnsget_MeshObjectEdgeSize, 0, 0, LA_READ_ONLY);
        laAddRawProperty(p, "f", "Faces", "Faces", offsetof(tnsMeshObject, f), 0, tnsget_MeshObjectFaceRaw, tnsset_MeshObjectFaceRaw, LA_READ_ONLY);
        laAddIntProperty(p, "totv", "Vert Count", "Total Vert", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, totv),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        laAddIntProperty(p, "tote", "Edge Count", "Total Edge", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, tote),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        laAddIntProperty(p, "totf", "Face Count", "Total Face", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, totf),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        //laAddIntProperty(p, "maxv", "Max Vert", "Max Vert count", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, maxv),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        //laAddIntProperty(p, "maxe", "Max Edge", "Max Edge count", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, maxe),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        //laAddIntProperty(p, "maxf", "Max Face", "Max Face count", 0,0,0,0,0,0,0,0,offsetof(tnsMeshObject, maxf),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
    }
    p = laAddPropertyContainer("tns_camera", "Camera", "Camera object", L'📷', 0, sizeof(tnsCamera), 0, 0, 2);{
        laPropContainerExtraFunctions(p,0,0,0,tnspropagate_Object,0);
        TNS_PC_OBJECT_CAMERA=p;
        laAddStringProperty(p, "name", "Object Name", "The Name Of The Object", 0, 0, 0, 0, 1, offsetof(tnsObject, Name), 0, 0, 0, 0, LA_AS_IDENTIFIER);
        laAddSubGroup(p, "base", "Base", "Object base", "tns_object",0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_LOCAL);
        ep = laAddEnumProperty(p, "camera_type", "Camera Type", "Type Of A Camera, Like Perspective Or Fisheye", 0, 0, 0, 0, 0, offsetof(tnsCamera, CameraType), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);{
            laAddEnumItem(ep, "PERSP", "Perspective", "Camera in linear perspective", 0);
            laAddEnumItem(ep, "ORTHO", "Orthographic", "Camera in orthographic view", 0);
        }
        laAddFloatProperty(p, "fov", "FOV", "Field Of View", 0, 0, "^", rad(160), rad(1), rad(0.1), rad(60), 0, offsetof(tnsCamera, FOV), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_RAD_ANGLE);
        laAddFloatProperty(p, "depth_range", "Depth Range", "Depth Range To Map From 0 To 1", 0, "Near,Far", 0, 0, 0, 0.1, 0, 0, offsetof(tnsCamera, ZMin), 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0);
        laAddFloatProperty(p, "focus_distance", "Focus Distance", "For Viewing Camera To Determin Zooming Center", 0, 0, 0, 0, 0, 0.1, 100, 0, offsetof(tnsCamera, FocusDistance), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        laAddFloatProperty(p, "orth_scale", "Scale", "Orthographical Camera Scale", 0, 0, "^^", 1000, 0.001, 0.1, 1, 0, offsetof(tnsCamera, OrthScale), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        laAddOperatorProperty(p, "set_active", "Set Active", "Set this camera as the active one", "TNS_set_active_camera", 0, 0);
    }
    p = laAddPropertyContainer("tns_light", "Light", "Light object", L'🔅', 0, sizeof(tnsLight), 0, 0, 2);{
        laPropContainerExtraFunctions(p,0,0,0,tnspropagate_Object,0);
        TNS_PC_OBJECT_LIGHT=p;
        laAddStringProperty(p, "name", "Object Name", "The Name Of The Object", 0, 0, 0, 0, 1, offsetof(tnsObject, Name), 0, 0, 0, 0, LA_AS_IDENTIFIER);
        laAddSubGroup(p, "base", "Base", "Object base", "tns_object",0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_LOCAL);
        ep = laAddEnumProperty(p, "unidirectional", "UniDirectional", "UniDirectional lighting", 0, 0, 0, 0, 0, offsetof(tnsLight, UniDirectional), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);{
            laAddEnumItem(ep, "NONE", "Perspective", "Camera in linear perspective", 0);
            laAddEnumItem(ep, "orthographic", "Orthographic", "Camera in orthographic view", 0);
        }
    }

    p = laAddPropertyContainer("tns_mvert", "MVert", "MMesh vert", 0, 0, sizeof(tnsMVert), 0, 0, 0);{
        laAddFloatProperty(p, "p", "Position", "Position", 0, "X,Y,Z", 0,0,0,0,0,0, offsetof(tnsMVert, p),0,0,3,0,0,0,0,0,0,0,0);
        laAddFloatProperty(p, "n", "Normal", "Normal", 0, "X,Y,Z", 0,0,0,0,0,0, offsetof(tnsMVert, n),0,0,3,0,0,0,0,0,0,0,0);
        laAddIntProperty(p,"i","Index","Index",0,0,0,0,0,0,0,0,offsetof(tnsMVert, i),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        laAddIntProperty(p,"flags","Flags","Flags",0,0,0,0,0,0,0,0,offsetof(tnsMVert, flags),0,0,0,0,0,0,0,0,0,0,0);
        laAddSubGroup(p, "elink", "Edge Link", "Edge link", "tns_medge_link",0,0,0,-1,0,0,0,0,0,0,offsetof(tnsMVert, elink),0);
    }
    p = laAddPropertyContainer("tns_medge", "MEdge", "MMesh edge", 0, 0, sizeof(tnsMEdge), 0, 0, 0);{
        laAddIntProperty(p,"i","Index","Index",0,0,0,0,0,0,0,0,offsetof(tnsMEdge, i),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        laAddIntProperty(p,"flags","Flags","Flags",0,0,0,0,0,0,0,0,offsetof(tnsMEdge, flags),0,0,0,0,0,0,0,0,0,0,0);
        laAddSubGroup(p, "vl", "vl", "Left vert", "tns_mvert",0,0,0,offsetof(tnsMEdge, vl),0,0,0,0,0,0,0,LA_UDF_REFER);
        laAddSubGroup(p, "vr", "vr", "Right vert", "tns_mvert",0,0,0,offsetof(tnsMEdge, vr),0,0,0,0,0,0,0,LA_UDF_REFER);
        laAddSubGroup(p, "fl", "fl", "Left face", "tns_mface",0,0,0,offsetof(tnsMEdge, fl),0,0,0,0,0,0,0,LA_UDF_REFER);
        laAddSubGroup(p, "fr", "fr", "Right face", "tns_mface",0,0,0,offsetof(tnsMEdge, fr),0,0,0,0,0,0,0,LA_UDF_REFER);
    }
    p = laAddPropertyContainer("tns_mface", "MFace", "MMesh face", 0, 0, sizeof(tnsMFace), 0, 0, 0);{
        laAddIntProperty(p,"i","Index","Index",0,0,0,0,0,0,0,0,offsetof(tnsMFace, i),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        laAddIntProperty(p,"flags","Flags","Flags",0,0,0,0,0,0,0,0,offsetof(tnsMFace, flags),0,0,0,0,0,0,0,0,0,0,0);
        laAddSubGroup(p, "l", "Loop", "Loop", "tns_loop",0,0,0,-1,0,0,0,0,0,0,offsetof(tnsMFace, l),0);
        laAddIntProperty(p,"looplen","Loop Length","Loop length",0,0,0,0,0,0,0,0,offsetof(tnsMFace, looplen),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY)->ElementBytes=2;
        laAddFloatProperty(p, "n", "Normal", "Normal", 0, "X,Y,Z", 0,0,0,0,0,0, offsetof(tnsMFace, n),0,0,3,0,0,0,0,0,0,0,0);
        //laAddFloatProperty(p, "gn", "Global Normal", "Global normal", 0, "X,Y,Z", 0,0,0,0,0,0, offsetof(tnsMFace, gn),0,0,3,0,0,0,0,0,0,0,0);
        laAddFloatProperty(p, "c", "Center", "Center", 0, "X,Y,Z", 0,0,0,0,0,0, offsetof(tnsMFace, c),0,0,3,0,0,0,0,0,0,0,0);
    }
    p = laAddPropertyContainer("tns_medge_link", "MEdge Link", "MEdge Link", 0, 0, sizeof(laListItemPointer), 0, 0, 0);{
        laAddSubGroup(p, "e", "Edge", "Edge", "tns_medge",0,0,0,offsetof(laListItemPointer, p),0,0,0,0,0,0,0,LA_UDF_REFER);
    }
    p = laAddPropertyContainer("tns_loop", "MFace Loop", "MFace Loop", 0, 0, sizeof(laListItemPointer), 0, 0, 0);{
        laAddSubGroup(p, "e", "Edge", "Edge", "tns_medge",0,0,0,offsetof(laListItemPointer, p),0,0,0,0,0,0,0,LA_UDF_REFER);
    }
}