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;
}

void* 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);
}
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(transLate(p->Title->Ptr), 0,0);
}
void laread_PanelTitle(laPanel *p, char *content){
    strSafeSet(&p->Title, content);
}
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;
    if(!w->win){return;}
    laRenameWindow(w, l->ID->Ptr);
    laRedrawCurrentWindow();
}
void* laget_WindowActiveLayout(laWindow *w, void* unused){
    return w->CurrentLayout;
}
//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; if(w->win) laRedrawCurrentWindow();
}
void laset_WindowShowStripes(laWindow* w, int stripes){
    w->OutputShowStripes=stripes; if(w->win) 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){
    laStartWindow(w);
}
int la_CreateSystemWindow(laWindow *window, int synctovbank);
void lapostim_Window(laWindow *w){
    w->IsFullScreen=0;
    la_CreateSystemWindow(w,MAIN.Windows.pFirst==MAIN.Windows.pLast);
    la_AssignWindowPP(w);
    MAIN.CurrentWindow = 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* laget_SavePanel(laWindow* w, laPropIterator* pi){
    for(laPanel* p=w->Panels.pFirst;p;p=p->Item.pNext){ if(!p->Mode || p->IsMenuPanel || p->PanelTemplate) return p; }
    return 0;
}
void* lagetnext_SavePanel(laPanel* p, laPropIterator* pi){
    for(p=p->Item.pNext;p;p=p->Item.pNext){ if(!p->Mode || p->IsMenuPanel || p->PanelTemplate) return p; }
    return 0;
}
void lapost_Panel(laPanel *p){
    p->PP.EndInstance = p;
    p->PP.LastPs = &p->FakePS;
    p->PP.LastPs->p = _LA_PROP_PANEL;

    la_EnsurePanelExtras(p);

    laRecalcPanel(p);
    p->FrameDistinguish = 100;
    if(p->IsMenuPanel || p->Block) p->Show=1;

    laUiTemplate* uit=p->PanelTemplate;
    if(uit&&uit->PropFunc){ uit->PropFunc(p); }
    if(uit){
        uit->Define(&p->UI, &p->PP, &p->PropLinkPP, 0, 0);
        if(p->Mode) laui_DefaultPanelTitleBar(&p->TitleBar, &p->PP, &p->PropLinkPP, uit->Header);
    }
    if(p->IsMenuPanel){ laui_DefaultMenuBarActual(&p->TitleBar, &p->PP, &p->PropLinkPP, 0, 0); }
    //if(p->Title) p->TitleWidth = tnsStringGetWidth(transLate(p->Title->Ptr), 0, 0);
    XSync(MAIN.dpy,0);
}
void lapost_Block(laBlock *b){
    la_AssignBlockPP(b);
}
void lapost_UserPreferences(void* unused){
    //MAIN.ScaledUiRowHeight=MAIN.UiRowHeight;
    //tnsInvalidateFontCache();
}
void laset_ColorPickerGamma(void* unused, real gamma){
    MAIN.ColorPickerGamma=gamma; laRedrawCurrentWindow();
}

//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 0;
    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 lareset_RackPage(laRackPage* rp){
    laNodeRack* r; while(r=rp->Racks.pFirst){
        laBaseNode* bn; while(bn=r->Nodes.pFirst){
            bn->Type->Destroy(bn); lstRemoveItem(&r->Nodes,bn);
        }
        lstRemoveItem(&r->ParentPage->Racks, r); memLeave(r);
    }
}

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, "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);
            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);
            
            _LA_PROP_WINDOW=laAddSubGroup(p, "windows", "Windows", "All windows inside this application", "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);
            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|LA_TRANSLATE);
            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);{
            laPropContainerExtraFunctions(p,0,lareset_RackPage,0,0,0);
            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", "Solid shadow 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", 0);
                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),LA_UDF_IGNORE);
            
            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);
            }
            ep = laAddEnumProperty(p, "save_preferences_on_exit", "Save On Exit", "Save user preferences before exiting the program", 0,0,0,0,0,offsetof(LA, SavePreferenceOnExit), 0,0,0,0,0,0,0,0,0,0);{
                laAddEnumItemAs(ep, "NONE", "Don't save", "Not saving user preferences on exit", 0,0);
                laAddEnumItemAs(ep, "SAVE", "Save", "Saving user preferences on exit", 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);

            laAddFloatProperty(p, "color_picker_gamma", "Color Picker Gamma", "Allows less saturated colors to have more areas", 0,0,0,3.0,1.0, 0.05,1.5, 0,offsetof(LA, ColorPickerGamma), 0,laset_ColorPickerGamma,0,0,0,0,0,0,0,0,0);
        }

        p = laAddPropertyContainer("la_translation_language", "Language", "Translation language pack", 0,0,sizeof(laTranslationNode), 0,0,1);{
            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,0, sizeof(laWindow), lapost_Window, lapostim_Window,1);{
            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, laget_WindowActiveLayout,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,laget_SavePanel,0,lagetnext_SavePanel,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|LA_UDF_IGNORE);
            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|LA_UDF_IGNORE);
            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|LA_UDF_IGNORE);
            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);
            }
            laAddIntProperty(p, "is_fullscreen", "Is Fullscreen", "Is the window fullscreen", 0,0,0,0,0,0,0,0,offsetof(laWindow, IsFullScreen),0,0,0,0,0,0,0,0,0,0,LA_READ_ONLY);
        }

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

        p = laAddPropertyContainer("ui_block", "Ui Block", "Property container for single ui block", 0,0, sizeof(laBlock), lapost_Block,0,1);{
            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);
            laAddSubGroup(p, "parent", "Parent", "Parent block reference", "ui_block",0,0,0,offsetof(laBlock, parent), 0,0,0,0,0,0,0,LA_UDF_REFER);
            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, laread_PanelTitle,LA_AS_IDENTIFIER|LA_TRANSLATE);
            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,LA_UDF_IGNORE);
            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,LA_UDF_IGNORE);
            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|LA_UDF_IGNORE);
            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|LA_UDF_IGNORE);
            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|LA_UDF_IGNORE);
            laAddSubGroup(p, "template","Template", "Panel template", "panel_template",0,0,0,offsetof(laPanel, PanelTemplate), 0,0,0,0,0,0,0,LA_UDF_REFER);
            laAddSubGroup(p, "block", "Block", "Block reference of this panel", "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,LA_TRANSLATE);
            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);
    }
}