--- a/ui/motif/text.c Sun May 23 09:44:43 2021 +0200
+++ b/ui/motif/text.c Sat Jan 04 16:38:48 2025 +0100
@@ -28,461 +28,666 @@
#include <stdio.h>
#include <stdlib.h>
+#include <unistd.h>
#include "text.h"
#include "container.h"
-
-UIWIDGET ui_textarea_var(UiObject *obj, UiVar *var) {
- UiContainer *ct = uic_get_current_container(obj);
- int n = 0;
- Arg args[16];
-
- //XtSetArg(args[n], XmNeditable, TRUE);
- //n++;
- XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT);
- n++;
-
- Widget parent = ct->prepare(ct, args, &n, TRUE);
- Widget text_area = XmCreateScrolledText(parent, "text_area", args, n);
- ct->add(ct, XtParent(text_area));
- XtManageChild(text_area);
-
- UiTextArea *uitext = ucx_mempool_malloc(
- obj->ctx->mempool,
- sizeof(UiTextArea));
- uitext->ctx = obj->ctx;
- uitext->last_selection_state = 0;
- XtAddCallback(
- text_area,
- XmNmotionVerifyCallback,
- (XtCallbackProc)ui_text_selection_callback,
- uitext);
-
- // bind value
- if(var->value) {
- UiText *value = var->value;
- if(value->value.ptr) {
- XmTextSetString(text_area, value->value.ptr);
- value->value.free(value->value.ptr);
- }
-
- 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 = text_area;
-
- if(!value->undomgr) {
- value->undomgr = ui_create_undomgr();
- }
-
- XtAddCallback(
- text_area,
- XmNmodifyVerifyCallback,
- (XtCallbackProc)ui_text_modify_callback,
- var);
- }
-
- return text_area;
-}
-
-UIWIDGET ui_textarea(UiObject *obj, UiText *value) {
- UiVar *var = malloc(sizeof(UiVar));
- var->value = value;
- var->type = UI_VAR_SPECIAL;
- return ui_textarea_var(obj, var);
-}
-
-UIWIDGET ui_textarea_nv(UiObject *obj, char *varname) {
- UiVar *var = uic_create_var(obj->ctx, varname, UI_VAR_TEXT);
- if(var) {
- return ui_textarea_var(obj, var);
- } else {
- // TODO: error
- }
- return NULL;
-}
+#include <cx/string.h>
-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, char *str) {
- XmTextSetString(text->obj, 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);
-}
-
-
-void ui_text_set(UiText *text, char *str) {
- if(text->set) {
- text->set(text, str);
- } else {
- if(text->value.ptr) {
- text->value.free(text->value.ptr);
- }
- text->value.ptr = XtNewString(str);
- text->value.free = (ui_freefunc)XtFree;
- }
-}
-
-char* ui_text_get(UiText *text) {
- if(text->get) {
- return text->get(text);
- } else {
- return text->value.ptr;
- }
-}
-UiUndoMgr* ui_create_undomgr() {
- UiUndoMgr *mgr = malloc(sizeof(UiUndoMgr));
- mgr->begin = NULL;
- mgr->cur = NULL;
- mgr->length = 0;
- mgr->event = 1;
- return 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->ctx, UI_GROUP_SELECTION);
- } else {
- ui_unset_group(textarea->ctx, UI_GROUP_SELECTION);
- }
- }
- textarea->last_selection_state = sel;
-}
+/* ------------------------------ Text Field ------------------------------ */
-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) {
- UcxList *elm = mgr->cur->next;
- if(elm) {
- mgr->cur->next = NULL;
- while(elm) {
- elm->prev = NULL;
- UcxList *next = elm->next;
- ui_free_textbuf_op(elm->data);
- free(elm);
- elm = next;
- }
- }
-
- if(type == UI_TEXTBUF_INSERT) {
- UiTextBufOp *last_op = mgr->cur->data;
- 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);
- }
+static UIWIDGET create_textfield(UiObject *obj, UiTextFieldArgs args, int frameless, int password) {
+ Arg xargs[16];
+ int n = 0;
- UiTextBufOp *op = malloc(sizeof(UiTextBufOp));
- op->type = type;
- op->start = txv->startPos;
- op->end = txv->endPos + 1;
- op->len = length;
- op->text = str;
-
- UcxList *elm = ucx_list_append(NULL, op);
- mgr->cur = elm;
- mgr->begin = ucx_list_concat(mgr->begin, elm);
-}
-
-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->data;
- 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;
-
- UcxList *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->data;
- 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;
- }
-}
-
-
-/* ------------------------- textfield ------------------------- */
-
-static UIWIDGET create_textfield(UiObject *obj, int width, UiBool frameless, UiBool password, UiString *value) {
- UiContainer *ct = uic_get_current_container(obj);
- int n = 0;
- Arg args[16];
- XtSetArg(args[n], XmNeditMode, XmSINGLE_LINE_EDIT);
- n++;
- if(width > 0) {
- XtSetArg(args[n], XmNcolumns, width / 2 + 1);
- n++;
- }
if(frameless) {
- XtSetArg(args[n], XmNshadowThickness, 0);
+ XtSetArg(xargs[n], XmNshadowThickness, 0);
n++;
}
if(password) {
// TODO
}
- Widget parent = ct->prepare(ct, args, &n, FALSE);
- Widget textfield = XmCreateText(parent, "text_field", args, n);
- ct->add(ct, textfield);
+ 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);
- // bind value
- if(value) {
+ 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) {
- XmTextSetString(textfield, value->value.ptr);
- value->value.free(value->value.ptr);
+ ui_textfield_set(value, value->value.ptr);
}
-
- value->set = ui_textfield_set;
- value->get = ui_textfield_get;
- value->value.ptr = NULL;
- value->obj = textfield;
}
return textfield;
}
-static UIWIDGET create_textfield_nv(UiObject *obj, int width, UiBool frameless, UiBool password, char *varname) {
- UiVar *var = uic_create_var(obj->ctx, varname, UI_VAR_STRING);
- if(var) {
- UiString *value = var->value;
- return ui_textfield(obj, value);
- } else {
- // TODO: error
- }
- return NULL;
+UIWIDGET ui_textfield_create(UiObject *obj, UiTextFieldArgs args) {
+ return create_textfield(obj, args, FALSE, FALSE);
}
-UIWIDGET ui_textfield(UiObject *obj, UiString *value) {
- return create_textfield(obj, 0, FALSE, FALSE, value);
-}
-
-UIWIDGET ui_textfield_nv(UiObject *obj, char *varname) {
- return create_textfield_nv(obj, 0, FALSE, FALSE, varname);
-}
-
-UIWIDGET ui_textfield_w(UiObject *obj, int width, UiString *value) {
- return create_textfield(obj, width, FALSE, FALSE, value);
-}
-
-UIWIDGET ui_textfield_wnv(UiObject *obj, int width, char *varname) {
- return create_textfield_nv(obj, width, FALSE, FALSE, varname);
+UIWIDGET ui_frameless_textfield_create(UiObject* obj, UiTextFieldArgs args) {
+ return create_textfield(obj, args, TRUE, FALSE);
}
-UIWIDGET ui_frameless_textfield(UiObject *obj, UiString *value) {
- return create_textfield(obj, 0, TRUE, FALSE, value);
-}
-
-UIWIDGET ui_frameless_textfield_nv(UiObject *obj, char *varname) {
- return create_textfield_nv(obj, 0, TRUE, FALSE, varname);
-}
-
-UIWIDGET ui_passwordfield(UiObject *obj, UiString *value) {
- return create_textfield(obj, 0, FALSE, TRUE, value);
+UIWIDGET ui_passwordfield_create(UiObject* obj, UiTextFieldArgs args) {
+ return create_textfield(obj, args, FALSE, FALSE);
}
-UIWIDGET ui_passwordfield_nv(UiObject *obj, char *varname) {
- return create_textfield_nv(obj, 0, FALSE, TRUE, varname);
-}
-
-UIWIDGET ui_passwordfield_w(UiObject *obj, int width, UiString *value) {
- return create_textfield(obj, width, FALSE, TRUE, value);
-}
-
-UIWIDGET ui_passwordfield_wnv(UiObject *obj, int width, char *varname) {
- return create_textfield_nv(obj, width, FALSE, TRUE, varname);
-}
-
-
char* ui_textfield_get(UiString *str) {
- if(str->value.ptr) {
- str->value.free(str->value.ptr);
- }
- char *value = XmTextGetString(str->obj);
+ 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, char *value) {
- XmTextSetString(str->obj, value);
- if(str->value.ptr) {
- str->value.free(str->value.ptr);
+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);
}
- str->value.ptr = 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);
+}