Mercurial > hg > toolkit / file revision

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2025 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "text.h"
#include "container.h"

#include <cx/string.h>


/* ------------------------------ Text Area ------------------------------ */

UIWIDGET ui_textarea_create(UiObject *obj, UiTextAreaArgs args) {
    Arg xargs[16];
    int n = 0;
    
    XtSetArg(xargs[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
    
    UiContainerPrivate *ctn = ui_obj_container(obj);
    UI_APPLY_LAYOUT(ctn->layout, args);
    
    Widget parent = ctn->prepare(ctn, xargs, &n);
    char *name = args.name ? (char*)args.name : "textarea";
    XtSetArg(xargs[n], XmNwidth, 100); n++;
    Widget widget = XmCreateScrolledText(parent, name, xargs, n);
    XtManageChild(widget);
    
    UiVar* var = uic_widget_var(obj->ctx, obj->ctx, args.value, args.varname, UI_VAR_TEXT);
    
    UiTextArea *textarea = malloc(sizeof(UiTextArea));
    memset(textarea, 0, sizeof(UiTextArea));
    textarea->obj = obj;
    textarea->var = var;
    
    if(var) {
        UiText *value = var->value;
        if(value->value.ptr) {
            XmTextSetString(widget, value->value.ptr);
            value->value.free(value->value.ptr);
            value->value.ptr = NULL;
        }
        
        value->set = ui_textarea_set;
        value->get = ui_textarea_get;
        value->getsubstr = ui_textarea_getsubstr;
        value->insert = ui_textarea_insert;
        value->setposition = ui_textarea_setposition;
        value->position = ui_textarea_position;
        value->selection = ui_textarea_selection;
        value->length = ui_textarea_length;
        value->value.ptr = NULL;
        value->obj = widget;
        
        if(!value->undomgr) {
            value->undomgr = ui_create_undomgr();
        }
        
        XtAddCallback(
                widget,
                XmNmodifyVerifyCallback,
                (XtCallbackProc)ui_text_modify_callback,
                var);
    }
    
    return widget;
}

char* ui_textarea_get(UiText *text) {
    if(text->value.ptr) {
        text->value.free(text->value.ptr);
    }
    char *str = XmTextGetString(text->obj);
    text->value.ptr = str;
    text->value.free = (ui_freefunc)XtFree;
    return str;
}

void ui_textarea_set(UiText *text, const char *str) {
    XmTextSetString(text->obj, (char*)str);
    if(text->value.ptr) {
        text->value.free(text->value.ptr);
    }
    text->value.ptr = NULL;
}

char* ui_textarea_getsubstr(UiText *text, int begin, int end) {
    if(text->value.ptr) {
        text->value.free(text->value.ptr);
    }
    int length = end - begin;
    char *str = XtMalloc(length + 1);
    XmTextGetSubstring(text->obj, begin, length, length + 1, str);
    text->value.ptr = str;
    text->value.free = (ui_freefunc)XtFree;
    return str;
}

void ui_textarea_insert(UiText *text, int pos, char *str) {
    text->value.ptr = NULL;
    XmTextInsert(text->obj, pos, str);
    if(text->value.ptr) {
        text->value.free(text->value.ptr);
    }
}

void ui_textarea_setposition(UiText *text, int pos) {
    XmTextSetInsertionPosition(text->obj, pos);
}

int ui_textarea_position(UiText *text) {
    long begin;
    long end;
    XmTextGetSelectionPosition(text->obj, &begin, &end);
    text->pos = begin;
    return text->pos;
}

void ui_textarea_selection(UiText *text, int *begin, int *end) {
    XmTextGetSelectionPosition(text->obj, (long*)begin, (long*)end);
}

int ui_textarea_length(UiText *text) {
    return (int)XmTextGetLastPosition(text->obj);
}



UiUndoMgr* ui_create_undomgr() {
    UiUndoMgr *mgr = malloc(sizeof(UiUndoMgr));
    mgr->begin = NULL;
    mgr->end = NULL;
    mgr->cur = NULL;
    mgr->length = 0;
    mgr->event = 1;
    return mgr;
}

void ui_destroy_undomgr(UiUndoMgr *mgr) {
    UiTextBufOp *op = mgr->begin;
    while(op) {
        UiTextBufOp *nextOp = op->next;
        if(op->text) {
            free(op->text);
        }
        free(op);
        op = nextOp;
    }
    free(mgr);
}

void ui_text_selection_callback(
        Widget widget,
        UiTextArea *textarea,
        XtPointer data)
{
    long left = 0;
    long right = 0;
    XmTextGetSelectionPosition(widget, &left, &right);
    int sel = left < right ? 1 : 0;
    if(sel != textarea->last_selection_state) {
        if(sel) {
            ui_set_group(textarea->obj->ctx, UI_GROUP_SELECTION);
        } else {
            ui_unset_group(textarea->obj->ctx, UI_GROUP_SELECTION);
        }
    }
    textarea->last_selection_state = sel;
}

void ui_text_modify_callback(Widget widget, UiVar *var, XtPointer data) {
    UiText *value = var->value;
    if(!value->obj) {
        // TODO: bug, fix
        return;
    }
    if(!value->undomgr) {
        value->undomgr = ui_create_undomgr();
    }
    
    XmTextVerifyCallbackStruct *txv = (XmTextVerifyCallbackStruct*)data;
    int type = txv->text->length > 0 ? UI_TEXTBUF_INSERT : UI_TEXTBUF_DELETE;
    UiUndoMgr *mgr = value->undomgr;
    if(!mgr->event) {
        return;
    }
    
    char *text = txv->text->ptr;
    int length = txv->text->length;
    
    if(mgr->cur) {
        UiTextBufOp *elm = mgr->cur->next;
        if(elm) {
            mgr->cur->next = NULL;
            mgr->end = mgr->cur;
            while(elm) {
                elm->prev = NULL;   
                UiTextBufOp *next = elm->next;
                ui_free_textbuf_op(elm);
                elm = next;
            }
        }
        
        UiTextBufOp *last_op = mgr->cur;
        if(
            last_op->type == UI_TEXTBUF_INSERT &&
            ui_check_insertstr(last_op->text, last_op->len, text, length) == 0)
        {
            // append text to last op       
            int ln = last_op->len;
            char *newtext = malloc(ln + length + 1);
            memcpy(newtext, last_op->text, ln);
            memcpy(newtext+ln, text, length);
            newtext[ln+length] = '\0';
            
            last_op->text = newtext;
            last_op->len = ln + length;
            last_op->end += length;
            
            return;
        }
    }
    
    char *str;
    if(type == UI_TEXTBUF_INSERT) {
        str = malloc(length + 1);
        memcpy(str, text, length);
        str[length] = 0;
    } else {
        length = txv->endPos - txv->startPos;
        str = malloc(length + 1);
        XmTextGetSubstring(value->obj, txv->startPos, length, length+1, str);
    }
    
    UiTextBufOp *op = malloc(sizeof(UiTextBufOp));
    op->prev = NULL;
    op->next = NULL;
    op->type = type;
    op->start = txv->startPos;
    op->end = txv->endPos + 1;
    op->len = length;
    op->text = str;
    
    cx_linked_list_add(
            (void**)&mgr->begin,
            (void**)&mgr->end,
            offsetof(UiTextBufOp, prev),
            offsetof(UiTextBufOp, next),
            op);
    
    mgr->cur = op;
}

int ui_check_insertstr(char *oldstr, int oldlen, char *newstr, int newlen) {
    // return 1 if oldstr + newstr are one word
    
    int has_space = 0;
    for(int i=0;i<oldlen;i++) {
        if(oldstr[i] < 33) {
            has_space = 1;
            break;
        }
    }
    
    for(int i=0;i<newlen;i++) {
        if(has_space && newstr[i] > 32) {
            return 1;
        }
    }
    
    return 0;
}

void ui_free_textbuf_op(UiTextBufOp *op) {
    if(op->text) {
        free(op->text);
    }
    free(op);
}


void ui_text_undo(UiText *value) {
    UiUndoMgr *mgr = value->undomgr;
    
    if(mgr->cur) {
        UiTextBufOp *op = mgr->cur;
        mgr->event = 0;
        switch(op->type) {
            case UI_TEXTBUF_INSERT: {
                XmTextReplace(value->obj, op->start, op->end, "");
                break;
            }
            case UI_TEXTBUF_DELETE: {
                XmTextInsert(value->obj, op->start, op->text);
                break;
            }
        }
        mgr->event = 1;
        mgr->cur = mgr->cur->prev;
    }
}

void ui_text_redo(UiText *value) {
    UiUndoMgr *mgr = value->undomgr;
    
    UiTextBufOp *elm = NULL;
    if(mgr->cur) {
        if(mgr->cur->next) {
            elm = mgr->cur->next;
        }
    } else if(mgr->begin) {
        elm = mgr->begin;
    }
    
    if(elm) {
        UiTextBufOp *op = elm;
        mgr->event = 0;
        switch(op->type) {
            case UI_TEXTBUF_INSERT: {
                XmTextInsert(value->obj, op->start, op->text);
                break;
            }
            case UI_TEXTBUF_DELETE: {
                XmTextReplace(value->obj, op->start, op->end, "");
                break;
            }
        }
        mgr->event = 1;
        mgr->cur = elm;
    }
}



/* ------------------------------ Text Field ------------------------------ */

static UIWIDGET create_textfield(UiObject *obj, UiTextFieldArgs args, int frameless, int password) {
    Arg xargs[16];
    int n = 0;
    
    if(frameless) {
        XtSetArg(xargs[n], XmNshadowThickness, 0);
        n++;
    }
    if(password) {
        // TODO
    }
    
    UiContainerPrivate *ctn = ui_obj_container(obj);
    UI_APPLY_LAYOUT(ctn->layout, args);
    
    Widget parent = ctn->prepare(ctn, xargs, &n);
    char *name = args.name ? (char*)args.name : "textfield";
    Widget textfield = XmCreateTextField(parent, name, xargs, n);
    XtManageChild(textfield);
    
    ui_set_widget_groups(obj->ctx, textfield, args.groups);
    
    UiVar* var = uic_widget_var(obj->ctx, obj->ctx, args.value, args.varname, UI_VAR_STRING);
    if(var) {
        UiString *value = (UiString*)var->value;
        value->obj = textfield;
        value->get = ui_textfield_get;
        value->set = ui_textfield_set;
        
        if(value->value.ptr) {
            ui_textfield_set(value, value->value.ptr);
        }
    }
    
    return textfield;
}

UIWIDGET ui_textfield_create(UiObject *obj, UiTextFieldArgs args) {
    return create_textfield(obj, args, FALSE, FALSE);
}

UIWIDGET ui_frameless_textfield_create(UiObject* obj, UiTextFieldArgs args) {
    return create_textfield(obj, args, TRUE, FALSE);
}

UIWIDGET ui_passwordfield_create(UiObject* obj, UiTextFieldArgs args) {
    return create_textfield(obj, args, FALSE, FALSE);
}

char* ui_textfield_get(UiString *str) {
    str->value.free(str->value.ptr);
    char *value = XmTextFieldGetString(str->obj);
    str->value.ptr = value;
    str->value.free = (ui_freefunc)XtFree;
    return value;
}

void ui_textfield_set(UiString *str, const char *value) {
    XmTextFieldSetString(str->obj, (void*)value);
    str->value.ptr = NULL;
    str->value.free(str->value.ptr);
}





/* -------------------- path bar -------------------- */

#define XNECreateText(parent,name,args,count)   XmCreateTextField(parent,name,args,count)
#define XNETextSetString(widget,value)          XmTextFieldSetString(widget,value)
#define XNETextGetString(widget)                XmTextFieldGetString(widget)
#define XNETextGetLastPosition(widget)          XmTextFieldGetLastPosition(widget)  
#define XNETextSetInsertionPosition(widget, i)  XmTextFieldSetInsertionPosition(widget, i)  
#define XNETextSetSelection(w, f, l, t)         XmTextFieldSetSelection(w, f, l, t)

typedef void(*updatedir_callback)(void*,char*,int);

typedef struct PathBar {  
    Widget widget;
    Widget textfield;
    
    Widget focus_widget;
    
    Widget left;
    Widget right;
    Dimension lw;
    Dimension rw;
    
    int shift;
    
    UiPathElm *current_pathelms;
    Widget *pathSegments;
    size_t numSegments;
    size_t segmentAlloc;
    
    char *path;
    int selection;
    Boolean input;
    
    int focus;
    
    updatedir_callback updateDir;
    void *updateDirData;
    
    ui_pathelm_func getpathelm;
    void *getpathelmdata;
} PathBar;

void PathBarSetPath(PathBar *bar, const char *path);

void pathbar_resize(Widget w, PathBar *p, XtPointer d)
{
    Dimension width, height;
    XtVaGetValues(w, XmNwidth, &width, XmNheight, &height, NULL);
    
    Dimension *segW = (void*)XtCalloc(p->numSegments, sizeof(Dimension));
    
    Dimension maxHeight = 0;
    
    /* get width/height from all widgets */
    Dimension pathWidth = 0;
    for(int i=0;i<p->numSegments;i++) {
        Dimension segWidth;
        Dimension segHeight;
        XtVaGetValues(p->pathSegments[i], XmNwidth, &segWidth, XmNheight, &segHeight, NULL);
        segW[i] = segWidth;
        pathWidth += segWidth;
        if(segHeight > maxHeight) {
            maxHeight = segHeight;
        }
    }
    Dimension tfHeight;
    XtVaGetValues(p->textfield, XmNheight, &tfHeight, NULL);
    if(tfHeight > maxHeight) {
        maxHeight = tfHeight;
    }
    
    Boolean arrows = False;
    if(pathWidth + 10 > width) {
        arrows = True;
        pathWidth += p->lw + p->rw;
    }
    
    /* calc max visible widgets */
    int start = 0;
    if(arrows) {
        Dimension vis = p->lw+p->rw;
        for(int i=p->numSegments;i>0;i--) {
            Dimension segWidth = segW[i-1];
            if(vis + segWidth + 10 > width) {
                start = i;
                arrows = True;
                break;
            }
            vis += segWidth;
        }
    } else {
        p->shift = 0;
    }
    
    int leftShift = 0;
    if(p->shift < 0) {
        if(start + p->shift < 0) {
            leftShift = start;
            start = 0;
            p->shift = -leftShift;
        } else {
            leftShift = -p->shift; /* negative shift */
            start += p->shift;
        }
    }
    
    int x = 0;
    if(arrows) {
        XtManageChild(p->left);
        XtManageChild(p->right);
        x = p->lw;
    } else {
        XtUnmanageChild(p->left);
        XtUnmanageChild(p->right);
    }
    
    for(int i=0;i<p->numSegments;i++) {
        if(i >= start && i < p->numSegments - leftShift && !p->input) {
            XtVaSetValues(p->pathSegments[i], XmNx, x, XmNy, 0, XmNheight, maxHeight, NULL);
            x += segW[i];
            XtManageChild(p->pathSegments[i]);
        } else {
            XtUnmanageChild(p->pathSegments[i]);
        }
    }
    
    if(arrows) {
        XtVaSetValues(p->left, XmNx, 0, XmNy, 0, XmNheight, maxHeight, NULL);
        XtVaSetValues(p->right, XmNx, x, XmNy, 0, XmNheight, maxHeight, NULL);
    }
    
    free(segW);
    
    Dimension rw, rh;
    XtMakeResizeRequest(w, width, maxHeight, &rw, &rh);
    
    XtVaSetValues(p->textfield, XmNwidth, rw, XmNheight, rh, NULL);
}

static void pathbarActivateTF(PathBar *p)
{
    XtUnmanageChild(p->left);
    XtUnmanageChild(p->right);
    XNETextSetSelection(p->textfield, 0, XNETextGetLastPosition(p->textfield), 0);
    XtManageChild(p->textfield);
    p->input = 1;

    XmProcessTraversal(p->textfield, XmTRAVERSE_CURRENT);

    pathbar_resize(p->widget, p, NULL);
}

void PathBarActivateTextfield(PathBar *p)
{
    p->focus = 1;
    pathbarActivateTF(p);
}

void pathbar_input(Widget w, PathBar *p, XtPointer c)
{
    XmDrawingAreaCallbackStruct *cbs = (XmDrawingAreaCallbackStruct*)c;
    XEvent *xevent = cbs->event;
    
    if (cbs->reason == XmCR_INPUT) {
        if (xevent->xany.type == ButtonPress) {
            p->focus = 0;
            pathbarActivateTF(p);
        }
    }
}

void pathbar_losingfocus(Widget w, PathBar *p, XtPointer c)
{
    if(--p->focus < 0) {
        p->input = False;
        XtUnmanageChild(p->textfield);
    }
}

static cxmutstr concat_path_s(cxstring base, cxstring path) {
    if(!path.ptr) {
        path = CX_STR("");
    }
    
    int add_separator = 0;
    if(base.length != 0 && base.ptr[base.length-1] == '/') {
        if(path.ptr[0] == '/') {
            base.length--;
        }
    } else {
        if(path.length == 0 || path.ptr[0] != '/') {
            add_separator = 1;
        }
    }
    
    cxmutstr url;
    if(add_separator) {
        url = cx_strcat(3, base, CX_STR("/"), path);
    } else {
        url = cx_strcat(2, base, path);
    }
    
    return url;
}

static char* ConcatPath(const char *path1, const char *path2) {
    return concat_path_s(cx_str(path1), cx_str(path2)).ptr;
}

void pathbar_pathinput(Widget w, PathBar *p, XtPointer d)
{
    char *newpath = XNETextGetString(p->textfield);
    if(newpath) {
        if(newpath[0] == '~') {
            char *p = newpath+1;
            char *home = getenv("HOME");
            char *cp = ConcatPath(home, p);
            XtFree(newpath);
            newpath = cp;
        } else if(newpath[0] != '/') {
            char curdir[2048];
            curdir[0] = 0;
            getcwd(curdir, 2048);
            char *cp = ConcatPath(curdir, newpath);
            XtFree(newpath);
            newpath = cp;
        }
        
        /* update path */
        PathBarSetPath(p, newpath);
        if(p->updateDir) {
            p->updateDir(p->updateDirData, newpath, -1);
        }
        XtFree(newpath);
        
        /* hide textfield and show path as buttons */
        XtUnmanageChild(p->textfield);
        pathbar_resize(p->widget, p, NULL);
        
        if(p->focus_widget) {
            XmProcessTraversal(p->focus_widget, XmTRAVERSE_CURRENT);
        }
    }
}

void pathbar_shift_left(Widget w, PathBar *p, XtPointer d)
{
    p->shift--;
    pathbar_resize(p->widget, p, NULL);
}

void pathbar_shift_right(Widget w, PathBar *p, XtPointer d)
{
    if(p->shift < 0) {
        p->shift++;
    }
    pathbar_resize(p->widget, p, NULL);
}

static void pathTextEH(Widget widget, XtPointer data, XEvent *event, Boolean *dispatch) {
    PathBar *pb = data;
    if(event->type == KeyReleaseMask) {
        if(event->xkey.keycode == 9) {
            XtUnmanageChild(pb->textfield);
            pathbar_resize(pb->widget, pb, NULL);
            *dispatch = False;
        } else if(event->xkey.keycode == 36) {
            pathbar_pathinput(pb->textfield, pb, NULL);
            *dispatch = False;
        }
    }
}

PathBar* CreatePathBar(Widget parent, ArgList args, int n)
{
    PathBar *bar = (PathBar*)XtMalloc(sizeof(PathBar));
    bar->path = NULL;
    bar->updateDir = NULL;
    bar->updateDirData = NULL;
    
    bar->focus_widget = NULL;
    
    bar->getpathelm = NULL;
    bar->getpathelmdata = NULL;
    bar->current_pathelms = NULL;
    
    bar->shift = 0;
    
    XtSetArg(args[n], XmNmarginWidth, 0); n++;
    XtSetArg(args[n], XmNmarginHeight, 0); n++;
    bar->widget = XmCreateDrawingArea(parent, "pathbar", args, n);
    XtAddCallback(
            bar->widget,
            XmNresizeCallback,
            (XtCallbackProc)pathbar_resize,
            bar);
    XtAddCallback(
            bar->widget,
            XmNinputCallback,
            (XtCallbackProc)pathbar_input,
            bar);
    
    Arg a[4];
    XtSetArg(a[0], XmNshadowThickness, 0);
    XtSetArg(a[1], XmNx, 0);
    XtSetArg(a[2], XmNy, 0);
    bar->textfield = XNECreateText(bar->widget, "pbtext", a, 3);
    bar->input = 0;
    XtAddCallback(
            bar->textfield,
            XmNlosingFocusCallback,
            (XtCallbackProc)pathbar_losingfocus,
            bar);
    XtAddCallback(bar->textfield, XmNactivateCallback,
                 (XtCallbackProc)pathbar_pathinput, bar);
    XtAddEventHandler(bar->textfield, KeyPressMask | KeyReleaseMask, FALSE, pathTextEH, bar);
    
    XtSetArg(a[0], XmNarrowDirection, XmARROW_LEFT);
    bar->left = XmCreateArrowButton(bar->widget, "pbbutton", a, 1);
    XtSetArg(a[0], XmNarrowDirection, XmARROW_RIGHT);
    bar->right = XmCreateArrowButton(bar->widget, "pbbutton", a, 1);
    XtAddCallback(
                bar->left,
                XmNactivateCallback,
                (XtCallbackProc)pathbar_shift_left,
                bar);
    XtAddCallback(
                bar->right,
                XmNactivateCallback,
                (XtCallbackProc)pathbar_shift_right,
                bar);
    
    Pixel bg;
    XtVaGetValues(bar->textfield, XmNbackground, &bg, NULL);
    XtVaSetValues(bar->widget, XmNbackground, bg, NULL);
    
    XtManageChild(bar->left);
    XtManageChild(bar->right);
    
    XtVaGetValues(bar->left, XmNwidth, &bar->lw, NULL);
    XtVaGetValues(bar->right, XmNwidth, &bar->rw, NULL);
    
    bar->segmentAlloc = 16;
    bar->numSegments = 0;
    bar->pathSegments = (Widget*)XtCalloc(16, sizeof(Widget));
    
    bar->selection = 0;
    
    return bar;
}

void PathBarChangeDir(Widget w, PathBar *bar, XtPointer c)
{
    XmToggleButtonSetState(bar->pathSegments[bar->selection], False, False);
    
    int i;
    for(i=0;i<bar->numSegments;i++) {  
        if(bar->pathSegments[i] == w) {
            bar->selection = i;
            XmToggleButtonSetState(w, True, False);
            break;
        }
    }
    
    UiPathElm elm = bar->current_pathelms[i];
    cxmutstr name = cx_strdup(cx_strn(elm.name, elm.name_len));
    if(bar->updateDir) {
        bar->updateDir(bar->updateDirData, name.ptr, i);
    }
    free(name.ptr);
}

static void ui_pathelm_destroy(UiPathElm *elms, size_t nelm) {
    for(int i=0;i<nelm;i++) {
        free(elms[i].name);
        free(elms[i].path);
    }
    free(elms);
}

void PathBarSetPath(PathBar *bar, const char *path)
{
    if(bar->path) {
        free(bar->path);
    }
    bar->path = strdup(path);
    
    for(int i=0;i<bar->numSegments;i++) {
        XtDestroyWidget(bar->pathSegments[i]);
    }
    XtUnmanageChild(bar->textfield);
    XtManageChild(bar->left);
    XtManageChild(bar->right);
    bar->input = False;
    
    Arg args[4];
    XmString str;
    
    bar->numSegments = 0;
    
    ui_pathelm_destroy(bar->current_pathelms, bar->numSegments);
    size_t nelm = 0;
    UiPathElm* path_elm = bar->getpathelm(bar->path, strlen(bar->path), &nelm, bar->getpathelmdata);
    if (!path_elm) {
        return;
    }
    bar->current_pathelms = path_elm;
    bar->numSegments = nelm;
    bar->pathSegments = realloc(bar->pathSegments, nelm * sizeof(Widget*));
    
    for(int i=0;i<nelm;i++) {
        UiPathElm elm = path_elm[i];
        
        cxmutstr name = cx_strdup(cx_strn(elm.name, elm.name_len));
        str = XmStringCreateLocalized(elm.name);
        free(name.ptr);
        
        XtSetArg(args[0], XmNlabelString, str);
        XtSetArg(args[1], XmNfillOnSelect, True);
        XtSetArg(args[2], XmNindicatorOn, False);
        Widget button = XmCreateToggleButton(bar->widget, "pbbutton", args, 3);
        XtAddCallback(
                button,
                XmNvalueChangedCallback,
                (XtCallbackProc)PathBarChangeDir,
                bar);
        XmStringFree(str);
        
        bar->pathSegments[i] = button;
    }
    
    bar->selection = bar->numSegments-1;
    XmToggleButtonSetState(bar->pathSegments[bar->selection], True, False);
    
    XNETextSetString(bar->textfield, (char*)path);
    XNETextSetInsertionPosition(bar->textfield, XNETextGetLastPosition(bar->textfield));
    
    pathbar_resize(bar->widget, bar, NULL);
}

void PathBarDestroy(PathBar *pathbar) {
    if(pathbar->path) {
        XtFree(pathbar->path);
    }
    XtFree((void*)pathbar->pathSegments);
    XtFree((void*)pathbar);
}


/* ---------------------------- Path Text Field ---------------------------- */

static void destroy_pathbar(Widget w, XtPointer *data, XtPointer d) {
    PathBar *pathbar = (PathBar*)data;
    // TODO: check if there is somonething missing
    XtFree((void*)pathbar->pathSegments);
    XtFree((void*)pathbar);
}

// TODO: move to common
static UiPathElm* default_pathelm_func(const char* full_path, size_t len, size_t* ret_nelm, void* data) {
    cxstring *pathelms;
    size_t nelm = cx_strsplit_a(cxDefaultAllocator, cx_strn(full_path, len), CX_STR("/"), 4096, &pathelms);

    if (nelm == 0) {
        *ret_nelm = 0;
        return NULL;
    }

    UiPathElm* elms = (UiPathElm*)calloc(nelm, sizeof(UiPathElm));
    size_t n = nelm;
    int j = 0;
    for (int i = 0; i < nelm; i++) {
        cxstring c = pathelms[i];
        if (c.length == 0) {
            if (i == 0) {
                c.length = 1;
            }
            else {
                n--;
                continue;
            }
        }

        cxmutstr m = cx_strdup(c);
        elms[j].name = m.ptr;
        elms[j].name_len = m.length;
        
        size_t elm_path_len = c.ptr + c.length - full_path;
        cxmutstr elm_path = cx_strdup(cx_strn(full_path, elm_path_len));
        elms[j].path = elm_path.ptr;
        elms[j].path_len = elm_path.length;

        j++;
    }
    *ret_nelm = n;

    return elms;
}

static void pathbar_activate(void *data, char *path, int index) {
    UiEventData *event = data;
    UiEvent evt;
    evt.obj = event->obj;
    evt.window = evt.obj->window;
    evt.document = evt.obj->ctx->document;
    evt.eventdata = path;
    evt.intval = index;
    event->callback(&evt, event->userdata);
}

UIWIDGET ui_path_textfield_create(UiObject* obj, UiPathTextFieldArgs args) {
    Arg xargs[16];
    int n = 0;
    
    UiContainerPrivate *ctn = ui_obj_container(obj);
    UI_APPLY_LAYOUT(ctn->layout, args);
    
    Widget parent = ctn->prepare(ctn, xargs, &n);
    // TODO: name
    

    PathBar *pathbar = CreatePathBar(parent, xargs, n);
    if(!args.getpathelm) {
        pathbar->getpathelm= default_pathelm_func;
    } else {
        pathbar->getpathelm = args.getpathelm;
        pathbar->getpathelmdata = args.getpathelmdata;
    }
    
    
    XtManageChild(pathbar->widget);
    ctn->add(ctn, pathbar->widget);
    
    UiVar* var = uic_widget_var(obj->ctx, obj->ctx, args.value, args.varname, UI_VAR_STRING);
    if (var) {
        UiString* value = (UiString*)var->value;
        value->obj = pathbar;
        value->get = ui_path_textfield_get;
        value->set = ui_path_textfield_set;
        
        if(value->value.ptr) {
            char *str = strdup(value->value.ptr);
            ui_string_set(value, str);
            free(str);
        }
    }
    
    if(args.onactivate) {
        UiEventData *eventdata = malloc(sizeof(UiEventData));
        eventdata->callback = args.onactivate;
        eventdata->userdata = args.onactivatedata;
        eventdata->obj = obj;
        eventdata->value = 0;
        
        pathbar->updateDir = pathbar_activate;
        pathbar->updateDirData = eventdata;
        
        XtAddCallback(
                pathbar->widget,
                XmNdestroyCallback,
                (XtCallbackProc)ui_destroy_eventdata,
                eventdata);
    }
    
    XtAddCallback(
            pathbar->widget,
            XmNdestroyCallback,
            (XtCallbackProc)destroy_pathbar,
            pathbar);
    
    return pathbar->widget;
}

char* ui_path_textfield_get(UiString *str) {
    PathBar *pathbar = str->obj;
    str->value.free(str->value.ptr);
    char *value = XmTextFieldGetString(pathbar->textfield);
    str->value.ptr = value;
    str->value.free = (ui_freefunc)XtFree;
    return value;
}

void ui_path_textfield_set(UiString *str, const char *value) {
    PathBarSetPath(str->obj, value);
}