ui/common/types.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 <stdarg.h>
  33
  34 #include <ucx/list.h>
  35 #include "../ui/tree.h"
  36 #include "types.h"
  37 #include "context.h"
  38
  39 UiObserver* ui_observer_new(ui_callback f, void *data) {
  40     UiObserver *observer = malloc(sizeof(UiObserver));
  41     observer->callback = f;
  42     observer->data = data;
  43     observer->next = NULL;
  44     return observer;
  45 }
  46
  47 UiObserver* ui_obsvlist_add(UiObserver *list, UiObserver *observer) {
  48     if(!list) {
  49         return observer;
  50     } else {
  51         UiObserver *l = list;
  52         while(l->next) {
  53             l = l->next;
  54         }
  55         l->next = observer;
  56         return list;
  57     }
  58 }
  59
  60 UiObserver* ui_add_observer(UiObserver *list, ui_callback f, void *data) {
  61     UiObserver *observer = ui_observer_new(f, data);
  62     return ui_obsvlist_add(list, observer);
  63 }
  64
  65 void ui_notify(UiObserver *observer, void *data) {
  66     ui_notify_except(observer, NULL, data);
  67 }
  68
  69 void ui_notify_except(UiObserver *observer, UiObserver *exc, void *data) {
  70     UiEvent evt;
  71     evt.obj = NULL;
  72     evt.window = NULL;
  73     evt.document = NULL;
  74     evt.eventdata = data;
  75     evt.intval = 0;
  76
  77     while(observer) {
  78         if(observer != exc) {
  79             observer->callback(&evt, observer->data);
  80         }
  81         observer = observer->next;
  82     }
  83 }
  84
  85 void ui_notify_evt(UiObserver *observer, UiEvent *event) {
  86     while(observer) {
  87         observer->callback(event, observer->data);
  88         observer = observer->next;
  89     }
  90 }
  91
  92 /* --------------------------- UiList --------------------------- */
  93
  94 UiList* ui_list_new(UiContext *ctx, char *name) {
  95     UiList *list = malloc(sizeof(UiList));
  96     list->first = ui_list_first;
  97     list->next = ui_list_next;
  98     list->get = ui_list_get;
  99     list->count = ui_list_count;
 100     list->observers = NULL;
 101
 102     list->data = NULL;
 103     list->iter = NULL;
 104
 105     list->update = NULL;
 106     list->obj = NULL;
 107
 108     if(name) {
 109         uic_reg_var(ctx, name, UI_VAR_LIST, list);
 110     }
 111
 112     return list;
 113 }
 114
 115 void ui_list_free(UiList *list) {
 116     ucx_list_free(list->data);
 117     free(list);
 118 }
 119
 120 void* ui_list_first(UiList *list) {
 121     UcxList *elm = list->data;
 122     list->iter = elm;
 123     return elm ? elm->data : NULL;
 124 }
 125
 126 void* ui_list_next(UiList *list) {
 127     UcxList *elm = list->iter;
 128     if(elm) {
 129         elm = elm->next;
 130         if(elm) {
 131             list->iter = elm;
 132             return elm->data;
 133         }
 134     }
 135     return NULL;
 136 }
 137
 138 void* ui_list_get(UiList *list, int i) {
 139     UcxList *elm = ucx_list_get(list->data, i);
 140     if(elm) {
 141         list->iter = elm;
 142         return elm->data;
 143     } else {
 144         return NULL;
 145     }
 146 }
 147
 148 int ui_list_count(UiList *list) {
 149     UcxList *elm = list->data;
 150     return (int)ucx_list_size(elm);
 151 }
 152
 153 void ui_list_append(UiList *list, void *data) {
 154     list->data = ucx_list_append(list->data, data);
 155 }
 156
 157 void ui_list_prepend(UiList *list, void *data) {
 158     list->data = ucx_list_prepend(list->data, data);
 159 }
 160
 161 void ui_list_clear(UiList *list) {
 162     ucx_list_free(list->data);
 163     list->data = NULL;
 164 }
 165
 166 void ui_list_addobsv(UiList *list, ui_callback f, void *data) {
 167     list->observers = ui_add_observer(list->observers, f, data);
 168 }
 169
 170 void ui_list_notify(UiList *list) {
 171     ui_notify(list->observers, list);
 172 }
 173
 174
 175 typedef struct {
 176     int  type;
 177     char *name;
 178 } UiColumn;
 179
 180 UiModel* ui_model(UiContext *ctx, ...) {
 181     UiModel *info = ui_calloc(ctx, 1, sizeof(UiModel));
 182
 183     va_list ap;
 184     va_start(ap, ctx);
 185
 186     UcxList *cols = NULL;
 187     int type;
 188     while((type = va_arg(ap, int)) != -1) {
 189         char *name = va_arg(ap, char*);
 190
 191         UiColumn *column = malloc(sizeof(UiColumn));
 192         column->type = type;
 193         column->name = name;
 194
 195         cols = ucx_list_append(cols, column);
 196     }
 197
 198     va_end(ap);
 199
 200     size_t len = ucx_list_size(cols);
 201     info->columns = len;
 202     info->types = ui_calloc(ctx, len, sizeof(UiModelType));
 203     info->titles = ui_calloc(ctx, len, sizeof(char*));
 204
 205     int i = 0;
 206     UCX_FOREACH(elm, cols) {
 207         UiColumn *c = elm->data;
 208         info->types[i] = c->type;
 209         info->titles[i] = c->name;
 210         free(c);
 211         i++;
 212     }
 213     ucx_list_free(cols);
 214
 215     return info;
 216 }
 217
 218 void ui_model_free(UiContext *ctx, UiModel *mi) {
 219     ucx_mempool_free(ctx->mempool, mi->types);
 220     ucx_mempool_free(ctx->mempool, mi->titles);
 221     ucx_mempool_free(ctx->mempool, mi);
 222 }
 223
 224 // types
 225
 226 // public functions
 227 UiInteger* ui_int_new(UiContext *ctx, char *name) {
 228     UiInteger *i = ui_malloc(ctx, sizeof(UiInteger));
 229     memset(i, 0, sizeof(UiInteger));
 230     if(name) {
 231         uic_reg_var(ctx, name, UI_VAR_INTEGER, i);
 232     }
 233     return i;
 234 }
 235
 236 UiDouble* ui_double_new(UiContext *ctx, char *name) {
 237     UiDouble *d = ui_malloc(ctx, sizeof(UiDouble));
 238     memset(d, 0, sizeof(UiDouble));
 239     if(name) {
 240         uic_reg_var(ctx, name, UI_VAR_DOUBLE, d);
 241     }
 242     return d;
 243 }
 244
 245 UiString* ui_string_new(UiContext *ctx, char *name) {
 246     UiString *s = ui_malloc(ctx, sizeof(UiString));
 247     memset(s, 0, sizeof(UiString));
 248     if(name) {
 249         uic_reg_var(ctx, name, UI_VAR_STRING, s);
 250     }
 251     return s;
 252 }
 253
 254 UiText* ui_text_new(UiContext *ctx, char *name) {
 255     UiText *t = ui_malloc(ctx, sizeof(UiText));
 256     memset(t, 0, sizeof(UiText));
 257     if(name) {
 258         uic_reg_var(ctx, name, UI_VAR_TEXT, t);
 259     }
 260     return t;
 261 }
 262
 263 UiRange* ui_range_new(UiContext *ctx, char *name) {
 264     UiRange *r = ui_malloc(ctx, sizeof(UiRange));
 265     memset(r, 0, sizeof(UiRange));
 266     if(name) {
 267         uic_reg_var(ctx, name, UI_VAR_RANGE, r);
 268     }
 269     return r;
 270 }
 271
 272
 273 // private functions
 274 void uic_int_copy(UiInteger *from, UiInteger *to) {
 275     to->get = from->get;
 276     to->set = from->set;
 277     to->obj = from->obj;
 278 }
 279
 280 void uic_double_copy(UiDouble *from, UiDouble *to) {
 281     to->get = from->get;
 282     to->set = from->set;
 283     to->obj = from->obj;
 284 }
 285
 286 void uic_string_copy(UiString *from, UiString *to) {
 287     to->get = from->get;
 288     to->set = from->set;
 289     to->obj = from->obj;
 290 }
 291
 292 void uic_text_copy(UiText *from, UiText *to) {
 293     to->get = from->get;
 294     to->set = from->set;
 295     to->getsubstr = from->getsubstr;
 296     to->insert = from->insert;
 297     to->setposition = from->setposition;
 298     to->position = from->position;
 299     to->selection = from->selection;
 300     to->length = from->length;
 301     to->remove = from->remove;
 302
 303     to->obj = from->obj;
 304     // do not copy the undo manager
 305 }
 306
 307 void uic_range_copy(UiRange *from, UiRange *to) {
 308     to->get = from->get;
 309     to->set = from->set;
 310     to->setrange = from->setrange;
 311     to->setextent = from->setextent;
 312     to->obj = from->obj;
 313 }
 314
 315 void uic_list_copy(UiList *from, UiList *to) {
 316     to->update = from->update;
 317     to->obj = from->obj;
 318 }
 319
 320
 321 void uic_int_save(UiInteger *i) {
 322     if(!i->obj) return;
 323     i->value = i->get(i);
 324 }
 325
 326 void uic_double_save(UiDouble *d) {
 327     if(!d->obj) return;
 328     d->value = d->get(d);
 329 }
 330
 331 void uic_string_save(UiString *s) {
 332     if(!s->obj) return;
 333     s->get(s);
 334 }
 335
 336 void uic_text_save(UiText *t) {
 337     if(!t->obj) return;
 338     t->get(t);
 339     t->position(t);
 340 }
 341
 342 void uic_range_save(UiRange *r) {
 343     if(!r->obj) return;
 344     r->get(r);
 345 }
 346
 347
 348 void uic_int_unbind(UiInteger *i) {
 349     i->get = NULL;
 350     i->set = NULL;
 351     i->obj = NULL;
 352 }
 353
 354 void uic_double_unbind(UiDouble *d) {
 355     d->get = NULL;
 356     d->set = NULL;
 357     d->obj = NULL;
 358 }
 359
 360 void uic_string_unbind(UiString *s) {
 361     s->get = NULL;
 362     s->set = NULL;
 363     s->obj = NULL;
 364 }
 365
 366 void uic_text_unbind(UiText *t) {
 367     t->set = NULL;
 368     t->get = NULL;
 369     t->getsubstr = NULL;
 370     t->insert = NULL;
 371     t->setposition = NULL;
 372     t->position = NULL;
 373     t->selection = NULL;
 374     t->length = NULL;
 375     t->remove = NULL;
 376     t->obj = NULL;
 377     t->undomgr = NULL;
 378 }
 379
 380 void uic_range_unbind(UiRange *r) {
 381     r->get = NULL;
 382     r->set = NULL;
 383     r->setextent = NULL;
 384     r->setrange = NULL;
 385     r->obj = NULL;
 386 }
 387
 388 void uic_list_unbind(UiList *l) {
 389     l->update = NULL;
 390     l->obj = NULL;
 391 }