idav: comparison ui/common/types.c

-:3da24640513a
+:e57ca2747782
 #include <string.h>
 #include <stdarg.h>
 #include <cx/list.h>
 #include <cx/array_list.h>
-#include "../ui/tree.h"
+#include "../ui/list.h"
 #include "types.h"
 #include "context.h"
 #include "../ui/image.h"
 static ui_list_init_func default_list_init;
 static void *default_list_init_userdata;
+static ui_list_destroy_func default_list_destroy;
+static void *default_list_destroy_userdata;
 UiObserver* ui_observer_new(ui_callback f, void *data) {
 UiObserver *observer = malloc(sizeof(UiObserver));
 observer->callback = f;
 observer->data = data;
 list->next = ui_list_next;
 list->get = ui_list_get;
 list->count = ui_list_count;
 }
+void uic_ucx_list_destroy(UiContext *ctx, UiList *list, void *unused) {
+cxListFree(list->data);
+ui_free(ctx, list);
+}
 UiList* ui_list_new(UiContext *ctx, const char *name) {
 return ui_list_new2(ctx, name, default_list_init ? default_list_init : uic_ucx_list_init, default_list_init_userdata);
 }
 UiList* ui_list_new2(UiContext *ctx, const char *name, ui_list_init_func listinit, void *userdata) {
 }
 return list;
 }
-void ui_list_free(UiList *list) {
+void ui_list_free(UiContext *ctx, UiList *list) {
-cxListFree(list->data);
+if(!default_list_destroy) {
-free(list);
+uic_ucx_list_destroy(ctx, list, NULL);
+} else {
+default_list_destroy(ctx, list, default_list_destroy_userdata);
+}
 }
 void* ui_list_first(UiList *list) {
 list->iter = (void*)(intptr_t)0;
 return cxListAt(list->data, 0);
 char *name;
 } UiColumn;
 UiModel* ui_model(UiContext *ctx, ...) {
 UiModel *info = ui_calloc(ctx, 1, sizeof(UiModel));
+info->ctx = ctx;
 va_list ap;
 va_start(ap, ctx);
 CxList *cols = cxArrayListCreate(cxDefaultAllocator, NULL, sizeof(UiColumn), 32);
 return info;
 }
 #define UI_MODEL_DEFAULT_ALLOC_SIZE 16
+static void model_notify_observer(UiModel *model, int insert, int delete) {
+UiModelChangeObserver *obs = model->observer;
+while(obs) {
+obs->update(model, obs->userdata, insert, delete);
+obs = obs->next;
+}
+}
 UiModel* ui_model_new(UiContext *ctx) {
 UiModel *info = ui_calloc(ctx, 1, sizeof(UiModel));
+info->ctx = ctx;
 info->alloc = UI_MODEL_DEFAULT_ALLOC_SIZE;
 info->types = ui_calloc(ctx, UI_MODEL_DEFAULT_ALLOC_SIZE, sizeof(UiModelType));
 info->titles = ui_calloc(ctx, UI_MODEL_DEFAULT_ALLOC_SIZE, sizeof(char*));
 info->columnsize = ui_calloc(ctx, UI_MODEL_DEFAULT_ALLOC_SIZE, sizeof(int));
 return info;
 }
-void ui_model_add_column(UiContext *ctx, UiModel *model, UiModelType type, const char *title, int width) {
+void ui_model_add_column(UiModel *model, UiModelType type, const char *title, int width) {
+UiContext *ctx = model->ctx;
 if(model->columns >= model->alloc) {
 model->alloc += UI_MODEL_DEFAULT_ALLOC_SIZE;
 model->types = ui_realloc(ctx, model->types, model->alloc * sizeof(UiModelType));
 model->titles = ui_realloc(ctx, model->titles, model->alloc * sizeof(char*));
 model->columnsize = ui_realloc(ctx, model->columnsize, model->alloc * sizeof(int));
 }
-model->types[model->columns] = type;
+int index = model->columns;
-model->titles[model->columns] = ui_strdup(ctx, title);
+model->types[index] = type;
-model->columnsize[model->columns] = width;
+model->titles[index] = ui_strdup(ctx, title);
+model->columnsize[index] = width;
+model_notify_observer(model, index, -1);
 model->columns++;
 }
 UiModel* ui_model_copy(UiContext *ctx, UiModel* model) {
 const CxAllocator* a = ctx ? ctx->allocator : cxDefaultAllocator;
 UiModel* newmodel = cxMalloc(a, sizeof(UiModel));
+newmodel->ctx = ctx;
 *newmodel = *model;
 newmodel->types = cxCalloc(a, model->columns, sizeof(UiModelType));
 memcpy(newmodel->types, model->types, model->columns);
 memcpy(newmodel->columnsize, model->columnsize, model->columns*sizeof(int));
 return newmodel;
 }
-void ui_model_free(UiContext *ctx, UiModel *mi) {
+void ui_model_ref(UiModel *model) {
-const CxAllocator* a = ctx ? ctx->allocator : cxDefaultAllocator;
+model->ref++;
+}
+void ui_model_unref(UiModel *model) {
+if(--model->ref == 0) {
+ui_model_free(model);
+}
+}
+void ui_model_add_observer(UiModel *model, ui_model_update_func update, void *data) {
+UiModelChangeObserver *observer = ui_malloc(model->ctx, sizeof(UiModelChangeObserver));
+observer->update = update;
+observer->userdata = data;
+observer->next = NULL;
+if(model->observer) {
+UiModelChangeObserver *last = model->observer;
+while(last->next) {
+last = last->next;
+}
+last->next = observer;
+} else {
+model->observer = observer;
+}
+}
+void ui_model_remove_observer(UiModel *model, void *data) {
+if(model->observer) {
+UiModelChangeObserver *obs = model->observer;
+UiModelChangeObserver *prev = NULL;
+while(obs) {
+if(obs->userdata == data) {
+// remove
+if(prev) {
+prev->next = obs->next;
+} else {
+model->observer = obs->next;
+}
+// free
+ui_free(model->ctx, obs);
+break;
+}
+prev = obs;
+obs = obs->next;
+}
+}
+}
+void ui_model_free(UiModel *mi) {
+UiContext *ctx = mi->ctx;
+const CxAllocator* a = ctx->allocator;
 for(int i=0;i<mi->columns;i++) {
 ui_free(ctx, mi->titles[i]);
+}
+UiModelChangeObserver *obs = mi->observer;
+while(obs) {
+UiModelChangeObserver *n = obs->next;
+cxFree(a, obs);
+obs = n;
 }
 cxFree(a, mi->types);
 cxFree(a, mi->titles);
 cxFree(a, mi->columnsize);
 cxFree(a, mi);
 list->setselection(list, sel);
 }
 }
 UIEXPORT void ui_listselection_free(UiListSelection selection) {
-if (selection.rows) {
+free(selection.rows);
-free(selection.rows);
-}
 }
 UIEXPORT UiStr ui_str(char *cstr) {
 return (UiStr) { cstr, NULL };
 }
 destr->observer = observer;
 cxMempoolSetDestructor(destr, (cx_destructor_func)observer_destructor);
 }
 static int ui_set_op = 0;
+static int ui_onchange_events_enabled = TRUE;
 void ui_setop_enable(int set) {
 ui_set_op = set;
 }
 int ui_get_setop(void) {
 return ui_set_op;
+}
+void ui_onchange_events_enable(UiBool enable) {
+ui_onchange_events_enabled = enable;
+}
+UiBool ui_onchange_events_is_enabled(void) {
+return ui_onchange_events_enabled;
 }
 /* ---------------- List initializers and wrapper functions ---------------- */
 void ui_global_list_initializer(ui_list_init_func func, void *userdata) {
 default_list_init = func;
 default_list_init_userdata = userdata;
 }
+void ui_global_list_destructor(ui_list_destroy_func func, void *userdata) {
+default_list_destroy = func;
+default_list_destroy_userdata = userdata;
+}
 void ui_list_class_set_first(UiList *list, void*(*first)(UiList *list)) {
 list->first = first;
 }
 void ui_list_class_set_next(UiList *list, void*(*next)(UiList *list)) {

Mercurial > hg > idav / file comparison

comparison: ui/common/types.c

ui/common/types.c