ui/common/context.c

   1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   3  *
   4  * Copyright 2017 Olaf Wintermann. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  *   1. Redistributions of source code must retain the above copyright
  10  *      notice, this list of conditions and the following disclaimer.
  11  *
  12  *   2. Redistributions in binary form must reproduce the above copyright
  13  *      notice, this list of conditions and the following disclaimer in the
  14  *      documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <inttypes.h>
  33 #include <stdarg.h>
  34
  35 #include "context.h"
  36 #include "../ui/window.h"
  37 #include "document.h"
  38 #include "types.h"
  39
  40 static UiContext* global_context;
  41
  42 void uic_init_global_context(void) {
  43     UcxMempool *mp = ucx_mempool_new(32);
  44     global_context = uic_context(NULL, mp);
  45 }
  46
  47 UiContext* ui_global_context(void) {
  48     return global_context;
  49 }
  50
  51 UiContext* uic_context(UiObject *toplevel, UcxMempool *mp) {
  52     UiContext *ctx = ucx_mempool_malloc(mp, sizeof(UiContext));
  53     memset(ctx, 0, sizeof(UiContext));
  54     ctx->mempool = mp;
  55     ctx->obj = toplevel;
  56     ctx->vars = ucx_map_new_a(mp->allocator, 16);
  57
  58     ctx->attach_document = uic_context_attach_document;
  59     ctx->detach_document2 = uic_context_detach_document2;
  60
  61 #ifdef UI_GTK
  62     if(toplevel && toplevel->widget) {
  63         ctx->accel_group = gtk_accel_group_new();
  64         gtk_window_add_accel_group(GTK_WINDOW(toplevel->widget), ctx->accel_group);
  65     }
  66 #endif
  67
  68     return ctx;
  69 }
  70
  71 UiContext* uic_root_context(UiContext *ctx) {
  72     return ctx->parent ? uic_root_context(ctx->parent) : ctx;
  73 }
  74
  75 void uic_context_attach_document(UiContext *ctx, void *document) {
  76     ctx->documents = ucx_list_append_a(ctx->mempool->allocator, ctx->documents, document);
  77     ctx->document = ctx->documents->data;
  78
  79     UiContext *doc_ctx = ui_document_context(document);
  80
  81     // check if any parent context has an unbound variable with the same name
  82     // as any document variable
  83     UiContext *var_ctx = ctx;
  84     while(var_ctx) {
  85         if(var_ctx->vars_unbound && var_ctx->vars_unbound->count > 0) {
  86             UcxMapIterator i = ucx_map_iterator(var_ctx->vars_unbound);
  87             UiVar *var;
  88             // rmkeys holds all keys, that shall be removed from vars_unbound
  89             UcxKey *rmkeys = calloc(var_ctx->vars_unbound->count, sizeof(UcxKey));
  90             size_t numkeys = 0;
  91             UCX_MAP_FOREACH(key, var, i) {
  92                 UiVar *docvar = ucx_map_get(doc_ctx->vars, key);
  93                 if(docvar) {
  94                     // bind var to document var
  95                     uic_copy_binding(var, docvar, TRUE);
  96                     rmkeys[numkeys++] = key; // save the key for removal
  97                 }
  98             }
  99             // now that we may have bound some vars to the document,
 100             // we can remove them from the unbound map
 101             for(size_t k=0;k<numkeys;k++) {
 102                 ucx_map_remove(var_ctx->vars_unbound, rmkeys[k]);
 103             }
 104         }
 105
 106         var_ctx = ctx->parent;
 107     }
 108 }
 109
 110 static void uic_context_unbind_vars(UiContext *ctx) {
 111     UcxMapIterator i = ucx_map_iterator(ctx->vars);
 112     UiVar *var;
 113     UCX_MAP_FOREACH(key, var, i) {
 114         if(var->from && var->from_ctx) {
 115             uic_save_var2(var);
 116             uic_copy_binding(var, var->from, FALSE);
 117             ucx_map_put(var->from_ctx->vars_unbound, key, var->from);
 118             var->from_ctx = ctx;
 119         }
 120     }
 121
 122     UCX_FOREACH(elm, ctx->documents) {
 123         UiContext *subctx = ui_document_context(elm->data);
 124         uic_context_unbind_vars(subctx);
 125     }
 126 }
 127
 128 void uic_context_detach_document2(UiContext *ctx, void *document) {
 129     // find the document in the documents list
 130     UcxList *doc = NULL;
 131     UCX_FOREACH(elm, ctx->documents) {
 132         if(elm->data == document) {
 133             doc = elm;
 134             break;
 135         }
 136     }
 137     if(!doc) {
 138         return; // document is not a subdocument of this context
 139     }
 140
 141     ctx->documents = ucx_list_remove_a(ctx->mempool->allocator, ctx->documents, doc);
 142     ctx->document = ctx->documents ? ctx->documents->data : NULL;
 143
 144     UiContext *docctx = ui_document_context(document);
 145     uic_context_unbind_vars(docctx); // unbind all doc/subdoc vars from the parent
 146 }
 147
 148 void uic_context_detach_all(UiContext *ctx) {
 149     UcxList *ls = ucx_list_clone(ctx->documents, NULL, NULL);
 150     UCX_FOREACH(elm, ls) {
 151         ctx->detach_document2(ctx, elm->data);
 152     }
 153     ucx_list_free(ls);
 154 }
 155
 156 static UiVar* ctx_getvar(UiContext *ctx, UcxKey key) {
 157     UiVar *var = ucx_map_get(ctx->vars, key);
 158     if(!var) {
 159         UCX_FOREACH(elm, ctx->documents) {
 160             UiContext *subctx = ui_document_context(elm->data);
 161             var = ctx_getvar(subctx, key);
 162             if(var) {
 163                 break;
 164             }
 165         }
 166     }
 167     return var;
 168 }
 169
 170 UiVar* uic_get_var(UiContext *ctx, const char *name) {
 171     UcxKey key = ucx_key(name, strlen(name));
 172     return ctx_getvar(ctx, key);
 173 }
 174
 175 UiVar* uic_create_var(UiContext *ctx, const char *name, UiVarType type) {
 176     UiVar *var = uic_get_var(ctx, name);
 177     if(var) {
 178         if(var->type == type) {
 179             return var;
 180         } else {
 181             fprintf(stderr, "UiError: var '%s' already bound with different type\n", name);
 182         }
 183     }
 184
 185     var = ui_malloc(ctx, sizeof(UiVar));
 186     var->type = type;
 187     var->value = uic_create_value(ctx, type);
 188     var->from = NULL;
 189     var->from_ctx = ctx;
 190
 191     if(!ctx->vars_unbound) {
 192         ctx->vars_unbound = ucx_map_new_a(ctx->mempool->allocator, 16);
 193     }
 194     ucx_map_cstr_put(ctx->vars_unbound, name, var);
 195
 196     return var;
 197 }
 198
 199 void* uic_create_value(UiContext *ctx, UiVarType type) {
 200     void *val = NULL;
 201     switch(type) {
 202         case UI_VAR_SPECIAL: break;
 203         case UI_VAR_INTEGER: {
 204             val = ui_int_new(ctx, NULL);
 205             break;
 206         }
 207         case UI_VAR_DOUBLE: {
 208             val = ui_double_new(ctx, NULL);
 209             break;
 210         }
 211         case UI_VAR_STRING: {
 212             val = ui_string_new(ctx, NULL);
 213             break;
 214         }
 215         case UI_VAR_TEXT: {
 216             val = ui_text_new(ctx, NULL);
 217             break;
 218         }
 219         case UI_VAR_LIST: {
 220             val = ui_list_new(ctx, NULL);
 221             break;
 222         }
 223         case UI_VAR_RANGE: {
 224             val = ui_range_new(ctx, NULL);
 225             break;
 226         }
 227     }
 228     return val;
 229 }
 230
 231 void uic_copy_binding(UiVar *from, UiVar *to, UiBool copytodoc) {
 232     // check type
 233     if(from->type != to->type) {
 234         fprintf(stderr, "UI Error: var has incompatible type.\n");
 235         return;
 236     }
 237
 238     void *fromvalue = from->value;
 239     // update var
 240     if(copytodoc) {
 241         to->from = from;
 242         to->from_ctx = from->from_ctx;
 243     }
 244
 245     // copy binding
 246     // we don't copy the observer, because the from var has never one
 247     switch(from->type) {
 248         default: fprintf(stderr, "uic_copy_binding: wtf!\n"); break;
 249         case UI_VAR_SPECIAL: break;
 250         case UI_VAR_INTEGER: {
 251             UiInteger *f = fromvalue;
 252             UiInteger *t = to->value;
 253             if(!f->obj) break;
 254             uic_int_copy(f, t);
 255             t->set(t, t->value);
 256             break;
 257         }
 258         case UI_VAR_DOUBLE: {
 259             UiDouble *f = fromvalue;
 260             UiDouble *t = to->value;
 261             if(!f->obj) break;
 262             uic_double_copy(f, t);
 263             t->set(t, t->value);
 264             break;
 265         }
 266         case UI_VAR_STRING: {
 267             UiString *f = fromvalue;
 268             UiString *t = to->value;
 269             if(!f->obj) break;
 270             uic_string_copy(f, t);
 271             char *tvalue = t->value.ptr ? t->value.ptr : "";
 272             t->set(t, tvalue);
 273             break;
 274         }
 275         case UI_VAR_TEXT: {
 276             UiText *f = fromvalue;
 277             UiText *t = to->value;
 278             if(!f->obj) break;
 279             uic_text_copy(f, t);
 280             char *tvalue = t->value.ptr ? t->value.ptr : "";
 281             t->set(t, tvalue);
 282             t->setposition(t, t->pos);
 283             break;
 284         }
 285         case UI_VAR_LIST: {
 286             UiList *f = fromvalue;
 287             UiList *t = to->value;
 288             if(!f->obj) break;
 289             uic_list_copy(f, t);
 290             t->update(t, -1);
 291             break;
 292         }
 293         case UI_VAR_RANGE: {
 294             UiRange *f = fromvalue;
 295             UiRange *t = to->value;
 296             if(!f->obj) break;
 297             uic_range_copy(f, t);
 298             t->setextent(t, t->extent);
 299             t->setrange(t, t->min, t->max);
 300             t->set(t, t->value);
 301             break;
 302         }
 303     }
 304 }
 305
 306 void uic_save_var2(UiVar *var) {
 307     switch(var->type) {
 308         case UI_VAR_SPECIAL: break;
 309         case UI_VAR_INTEGER: uic_int_save(var->value); break;
 310         case UI_VAR_DOUBLE: uic_double_save(var->value); break;
 311         case UI_VAR_STRING: uic_string_save(var->value); break;
 312         case UI_VAR_TEXT: uic_text_save(var->value); break;
 313         case UI_VAR_LIST: break;
 314         case UI_VAR_RANGE: uic_range_save(var->value); break;
 315     }
 316 }
 317
 318 void uic_unbind_var(UiVar *var) {
 319     switch(var->type) {
 320         case UI_VAR_SPECIAL: break;
 321         case UI_VAR_INTEGER: uic_int_unbind(var->value); break;
 322         case UI_VAR_DOUBLE: uic_double_unbind(var->value); break;
 323         case UI_VAR_STRING: uic_string_unbind(var->value); break;
 324         case UI_VAR_TEXT: uic_text_unbind(var->value); break;
 325         case UI_VAR_LIST: uic_list_unbind(var->value); break;
 326         case UI_VAR_RANGE: uic_range_unbind(var->value); break;
 327     }
 328 }
 329
 330 void uic_reg_var(UiContext *ctx, char *name, UiVarType type, void *value) {
 331     // TODO: do we need/want this? Why adding vars to a context after
 332     // widgets reference these? Workarounds:
 333     // 1. add vars to ctx before creating ui
 334     // 2. create ui, create new document with vars, attach doc
 335     // also it would be possible to create a function, that scans unbound vars
 336     // and connects them to available vars
 337     /*
 338     UiContext *rootctx = uic_root_context(ctx);
 339     UiVar *b = NULL;
 340     if(rootctx->bound) {
 341         // some widgets are already bound to some vars
 342         b = ucx_map_cstr_get(rootctx->bound, name);
 343         if(b) {
 344             // a widget is bound to a var with this name
 345             // if ctx is the root context we can remove the var from bound
 346             // because set_doc or detach can't fuck things up
 347             if(ctx == rootctx) {
 348                 ucx_map_cstr_remove(ctx->bound, name);
 349                 // TODO: free stuff
 350             }
 351         }
 352     }
 353     */
 354
 355     // create new var and add it to doc's vars
 356     UiVar *var = ui_malloc(ctx, sizeof(UiVar));
 357     var->type = type;
 358     var->value = value;
 359     var->from = NULL;
 360     var->from_ctx = ctx;
 361     size_t oldcount = ctx->vars->count;
 362     ucx_map_cstr_put(ctx->vars, name, var);
 363     if(ctx->vars->count != oldcount + 1) {
 364         fprintf(stderr, "UiError: var '%s' already exists\n", name);
 365     }
 366
 367     // TODO: remove?
 368     // a widget is already bound to a var with this name
 369     // copy the binding (like uic_context_set_document)
 370     /*
 371     if(b) {
 372         uic_copy_binding(b, var, TRUE);
 373     }
 374     */
 375 }
 376
 377 void uic_remove_bound_var(UiContext *ctx, UiVar *var) {
 378     // TODO: implement
 379     printf("TODO: implement uic_remove_bound_var\n");
 380 }
 381
 382
 383 // public API
 384
 385 void ui_attach_document(UiContext *ctx, void *document) {
 386     uic_context_attach_document(ctx, document);
 387 }
 388
 389 void ui_detach_document2(UiContext *ctx, void *document) {
 390     uic_context_detach_document2(ctx, document);
 391 }
 392
 393 void ui_context_closefunc(UiContext *ctx, ui_callback fnc, void *udata) {
 394     ctx->close_callback = fnc;
 395     ctx->close_data = udata;
 396 }
 397
 398
 399 void ui_set_group(UiContext *ctx, int group) {
 400     if(ucx_list_find(ctx->groups, (void*)(intptr_t)group, NULL, NULL) == -1) {
 401         ctx->groups = ucx_list_append_a(ctx->mempool->allocator, ctx->groups, (void*)(intptr_t)group);
 402     }
 403
 404     // enable/disable group widgets
 405     uic_check_group_widgets(ctx);
 406 }
 407
 408 void ui_unset_group(UiContext *ctx, int group) {
 409     int i = ucx_list_find(ctx->groups, (void*)(intptr_t)group, NULL, NULL);
 410     if(i != -1) {
 411         UcxList *elm = ucx_list_get(ctx->groups, i);
 412         ctx->groups = ucx_list_remove_a(ctx->mempool->allocator, ctx->groups, elm);
 413     }
 414
 415     // enable/disable group widgets
 416     uic_check_group_widgets(ctx);
 417 }
 418
 419 int* ui_active_groups(UiContext *ctx, int *ngroups) {
 420     if(!ctx->groups) {
 421         return NULL;
 422     }
 423
 424     int nelm = ucx_list_size(ctx->groups);
 425     int *groups = calloc(sizeof(int), nelm);
 426
 427     int i = 0;
 428     UCX_FOREACH(elm, ctx->groups) {
 429         groups[i++] = (intptr_t)elm->data;
 430     }
 431
 432     *ngroups = nelm;
 433     return groups;
 434 }
 435
 436 void uic_check_group_widgets(UiContext *ctx) {
 437     int ngroups = 0;
 438     int *groups = ui_active_groups(ctx, &ngroups);
 439
 440     UCX_FOREACH(elm, ctx->group_widgets) {
 441         UiGroupWidget *gw = elm->data;
 442         char *check = calloc(1, gw->numgroups);
 443
 444         for(int i=0;i<ngroups;i++) {
 445             for(int k=0;k<gw->numgroups;k++) {
 446                 if(groups[i] == gw->groups[k]) {
 447                     check[k] = 1;
 448                 }
 449             }
 450         }
 451
 452         int enable = 1;
 453         for(int i=0;i<gw->numgroups;i++) {
 454             if(check[i] == 0) {
 455                 enable = 0;
 456                 break;
 457             }
 458         }
 459         gw->enable(gw->widget, enable);
 460     }
 461
 462     if(groups) {
 463         free(groups);
 464     }
 465 }
 466
 467 void ui_widget_set_groups(UiContext *ctx, UIWIDGET widget, ui_enablefunc enable, ...) {
 468     // get groups
 469     UcxList *groups = NULL;
 470     va_list ap;
 471     va_start(ap, enable);
 472     int group;
 473     while((group = va_arg(ap, int)) != -1) {
 474         groups = ucx_list_append(groups, (void*)(intptr_t)group);
 475     }
 476     va_end(ap);
 477
 478     uic_add_group_widget(ctx, widget, enable, groups);
 479
 480     ucx_list_free(groups);
 481 }
 482
 483 void uic_add_group_widget(UiContext *ctx, void *widget, ui_enablefunc enable, UcxList *groups) {
 484     UcxMempool *mp = ctx->mempool;
 485     UiGroupWidget *gw = ucx_mempool_malloc(mp, sizeof(UiGroupWidget));
 486
 487     gw->widget = widget;
 488     gw->enable = enable;
 489     gw->numgroups = ucx_list_size(groups);
 490     gw->groups = ucx_mempool_calloc(mp, gw->numgroups, sizeof(int));
 491     int i = 0;
 492     UCX_FOREACH(elm, groups) {
 493         gw->groups[i++] = (intptr_t)elm->data;
 494     }
 495
 496     ctx->group_widgets = ucx_list_append_a(
 497             mp->allocator,
 498             ctx->group_widgets,
 499             gw);
 500 }
 501
 502 void* ui_malloc(UiContext *ctx, size_t size) {
 503     return ctx ? ucx_mempool_malloc(ctx->mempool, size) : NULL;
 504 }
 505
 506 void* ui_calloc(UiContext *ctx, size_t nelem, size_t elsize) {
 507     return ctx ? ucx_mempool_calloc(ctx->mempool, nelem, elsize) : NULL;
 508 }
 509
 510 void ui_free(UiContext *ctx, void *ptr) {
 511     if(ctx) {
 512         ucx_mempool_free(ctx->mempool, ptr);
 513     }
 514 }
 515
 516 void* ui_realloc(UiContext *ctx, void *ptr, size_t size) {
 517     return ctx ? ucx_mempool_realloc(ctx->mempool, ptr, size) : NULL;
 518 }
 519