idav: comparison ui/common/context.c

-:b34bd1557c6c
+:77254bd6dccb
 UiContext* uic_context(UiObject *toplevel, CxMempool *mp) {
 UiContext *ctx = cxMalloc(mp->allocator, sizeof(UiContext));
 memset(ctx, 0, sizeof(UiContext));
 ctx->mp = mp;
 ctx->allocator = mp->allocator;
+ctx->destroy_handler = cxArrayListCreate(ctx->allocator, NULL, sizeof(UiDestroyHandler), 16);
 ctx->obj = toplevel;
 ctx->vars = cxHashMapCreate(mp->allocator, CX_STORE_POINTERS, 16);
 ctx->documents = cxLinkedListCreate(mp->allocator, cx_cmp_ptr, CX_STORE_POINTERS);
 ctx->group_widgets = cxLinkedListCreate(mp->allocator, cx_cmp_ptr, sizeof(UiGroupWidget));
 ctx->groups = cxArrayListCreate(mp->allocator, cx_cmp_int, sizeof(int), 32);
 ctx->attach_document = uic_context_attach_document;
-ctx->detach_document2 = uic_context_detach_document2;
+ctx->detach_document2 = uic_context_detach_document;
 #if UI_GTK2 || UI_GTK3
 if(toplevel && toplevel->widget) {
 ctx->accel_group = gtk_accel_group_new();
 gtk_window_add_accel_group(GTK_WINDOW(toplevel->widget), ctx->accel_group);
 return ctx;
 }
 UiContext* uic_root_context(UiContext *ctx) {
 return ctx->parent ? uic_root_context(ctx->parent) : ctx;
+}
+void uic_context_add_destructor(UiContext *ctx, cx_destructor_func func, void *data) {
+UiDestroyHandler handler;
+handler.destructor = func;
+handler.data = data;
+cxListAdd(ctx->destroy_handler, &handler);
 }
 void uic_context_prepare_close(UiContext *ctx) {
 cxListClear(ctx->groups);
 cxListClear(ctx->group_widgets);
 static void uic_context_unbind_vars(UiContext *ctx) {
 CxMapIterator mi = cxMapIterator(ctx->vars);
 cx_foreach(CxMapEntry*, entry, mi) {
 UiVar *var = entry->value;
-if(var->from && var->from_ctx && var->from_ctx != ctx) {
+// var->from && var->from_ctx && var->from_ctx != ctx
+if(var->from) {
 uic_save_var2(var);
 uic_copy_binding(var, var->from, FALSE);
-cxMapPut(var->from_ctx->vars_unbound, *entry->key, var->from);
+cxMapPut(var->from->from_ctx->vars_unbound, *entry->key, var->from);
-var->from_ctx = ctx;
+var->from = NULL;
 }
 }
 if(ctx->documents) {
 CxIterator i = cxListIterator(ctx->documents);
 uic_context_unbind_vars(subctx);
 }
 }
 }
-void uic_context_detach_document2(UiContext *ctx, void *document) {
+void uic_context_detach_document(UiContext *ctx, void *document) {
 // find the document in the documents list
 size_t docIndex = cxListFind(ctx->documents, document);
 if(!cxListIndexValid(ctx->documents, docIndex)) {
 return;
 }
 }
 var = ui_malloc(ctx, sizeof(UiVar));
 var->type = type;
 var->value = uic_create_value(ctx, type);
+var->original_value = NULL;
 var->from = NULL;
 var->from_ctx = ctx;
 cxMempoolSetDestructor(var, (cx_destructor_func)uic_unbind_var);
 UiVar* uic_create_value_var(UiContext* ctx, void* value) {
 UiVar *var = (UiVar*)ui_malloc(ctx, sizeof(UiVar));
 var->from = NULL;
 var->from_ctx = ctx;
 var->value = value;
+var->original_value = NULL;
 var->type = UI_VAR_SPECIAL;
 return var;
 }
 void* uic_create_value(UiContext *ctx, UiVarType type) {
 fprintf(stderr, "UI Error: var has incompatible type.\n");
 return;
 }
 void *fromvalue = from->value;
+void *tovalue = to->value;
 // update var
 if(copytodoc) {
-to->from = from;
+to->from = from; // from which UiVar are the bindings copied
-to->from_ctx = from->from_ctx;
+from->original_value = fromvalue; // save original value otherwise it would be lost
+// widgets store a reference to the UiVar with their value
+// the UiVar object must be updated to contain the current value object
+from->value = tovalue;
+} else {
+if(to->original_value) {
+to->value = to->original_value;
+tovalue = to->value;
+}
 }
 ui_setop_enable(TRUE);
 // copy binding
 switch(from->type) {
 default: fprintf(stderr, "uic_copy_binding: wtf!\n"); break;
 case UI_VAR_SPECIAL: break;
 case UI_VAR_INTEGER: {
 UiInteger *f = fromvalue;
-UiInteger *t = to->value;
+UiInteger *t = tovalue;
 if(!f->obj) break;
 uic_int_copy(f, t);
 t->set(t, t->value);
 break;
 }
 case UI_VAR_DOUBLE: {
 UiDouble *f = fromvalue;
-UiDouble *t = to->value;
+UiDouble *t = tovalue;
 if(!f->obj) break;
 uic_double_copy(f, t);
 t->set(t, t->value);
 break;
 }
 case UI_VAR_STRING: {
 UiString *f = fromvalue;
-UiString *t = to->value;
+UiString *t = tovalue;
 if(!f->obj) break;
 uic_string_copy(f, t);
 char *tvalue = t->value.ptr ? t->value.ptr : "";
+char *fvalue = f->value.ptr ? f->value.ptr : "";
 t->set(t, tvalue);
 break;
 }
 case UI_VAR_TEXT: {
 UiText *f = fromvalue;
-UiText *t = to->value;
+UiText *t = tovalue;
 if(!f->obj) break;
 uic_text_copy(f, t);
 t->restore(t);
 break;
 }
 case UI_VAR_LIST: {
-// TODO: not sure how correct this is
+UiList *f = fromvalue;
+UiList *t = tovalue;
-UiList *f = from->value;
+uic_list_copy(f, t);
-UiList *t = to->value;
+ui_list_update(t);
-if (f->obj) {
-t->obj = f->obj;
-t->update = f->update;
-t->getselection = f->getselection;
-t->setselection = f->setselection;
-}
-UiVar tmp = *from;
-*from = *to;
-*to = tmp;
-UiList* t2 = to->value;
-if(t->update) {
-t->update(t, -1);
-}
-ui_notify(t2->observers, NULL); // TODO: why not t?
 break;
 }
 case UI_VAR_RANGE: {
 UiRange *f = fromvalue;
-UiRange *t = to->value;
+UiRange *t = tovalue;
 if(!f->obj) break;
 uic_range_copy(f, t);
 t->setextent(t, t->extent);
 t->setrange(t, t->min, t->max);
 t->set(t, t->value);
 break;
 }
 case UI_VAR_GENERIC: {
 UiGeneric *f = fromvalue;
-UiGeneric *t = to->value;
+UiGeneric *t = tovalue;
 if(!f->obj) break;
 uic_generic_copy(f, t);
 t->set(t, t->value, t->type);
 break;
 }
 case UI_VAR_RANGE: uic_range_unbind(var->value); break;
 case UI_VAR_GENERIC: uic_generic_unbind(var->value); break;
 }
 }
-void uic_reg_var(UiContext *ctx, char *name, UiVarType type, void *value) {
+void uic_reg_var(UiContext *ctx, const char *name, UiVarType type, void *value) {
 // TODO: do we need/want this? Why adding vars to a context after
 // widgets reference these? Workarounds:
 // 1. add vars to ctx before creating ui
 // 2. create ui, create new document with vars, attach doc
 // also it would be possible to create a function, that scans unbound vars
 void ui_attach_document(UiContext *ctx, void *document) {
 uic_context_attach_document(ctx, document);
 }
-void ui_detach_document2(UiContext *ctx, void *document) {
+void ui_detach_document(UiContext *ctx, void *document) {
-uic_context_detach_document2(ctx, document);
+uic_context_detach_document(ctx, document);
 }
 void ui_context_closefunc(UiContext *ctx, ui_callback fnc, void *udata) {
 ctx->close_callback = fnc;
 ctx->close_data = udata;
 }
-UIEXPORT void ui_context_destroy(UiContext *ctx) {
+void ui_context_destroy(UiContext *ctx) {
+CxIterator i = cxListIterator(ctx->destroy_handler);
+cx_foreach(UiDestroyHandler *, h, i) {
+h->destructor(h->data);
+}
 cxMempoolFree(ctx->mp);
+}
+UiContext* ui_context_parent(UiContext *ctx) {
+return ctx->parent;
 }
 void ui_set_group(UiContext *ctx, int group) {
 if(!cxListIndexValid(ctx->groups, cxListFind(ctx->groups, &group))) {

Mercurial > hg > idav / file comparison

comparison: ui/common/context.c

ui/common/context.c