clav.c

   1 /*
   2  * Copyright (c) 2018, S. Gilles <sgilles@math.umd.edu>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software
   5  * for any purpose with or without fee is hereby granted, provided
   6  * that the above copyright notice and this permission notice appear
   7  * in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
  13  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  14  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  15  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  16  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include <errno.h>
  19 #include <locale.h>
  20 #include <stdarg.h>
  21 #include <stdint.h>
  22 #include <stdio.h>
  23 #include <unistd.h>
  24
  25 #include "macros.h"
  26 #include "quiver.h"
  27 #include "ui.h"
  28
  29 /* Quit yet? */
  30 static uint_fast8_t should_quit = 0;
  31
  32 /* if (verbose) printf(...); */
  33 static void
  34 history(int verbose, const char *format, ...)
  35 {
  36         va_list arglist;
  37
  38         if (!verbose) {
  39                 return;
  40         }
  41
  42         printf("action: ");
  43         va_start(arglist, format);
  44         vprintf(format, arglist);
  45         va_end(arglist);
  46         printf("\n");
  47 }
  48
  49 /* Having received some kind of input, change state accordingly */
  50 static int
  51 state_transition(struct ui_event *e, struct quiver *q, int verbose)
  52 {
  53         int ret = 0;
  54         FILE *f = 0;
  55         const char *errstr = 0;
  56
  57         switch (e->type) {
  58         case ET_QUIT:
  59                 should_quit = 1;
  60                 history(verbose, "quit");
  61                 break;
  62         case ET_RENAME:
  63
  64                 if (!e->str ||
  65                     !e->str[0] ||
  66                     e->idx_1 >= q->v_num) {
  67                         break;
  68                 }
  69
  70                 history(verbose, "rename \"%s\" to \"%s\"", q->v[e->idx_1].name,
  71                         e->str);
  72
  73                 if ((ret = quiver_rename_vertex(q, e->idx_1, e->str,
  74                                                 &errstr))) {
  75                         fprintf(stderr, "%s\n", UBSAFES(errstr));
  76                 }
  77
  78                 ui_respond_quiver_change();
  79                 break;
  80         case ET_SAVE:
  81
  82                 if (!e->str ||
  83                     !e->str[0]) {
  84                         break;
  85                 }
  86
  87                 history(verbose, "save to \"%s\"", e->str);
  88
  89                 if (!(f = fopen(e->str, "w"))) {
  90                         ret = errno;
  91                         perror(L("fopen"));
  92                 } else if ((ret = quiver_save_to_file(q, f, &errstr))) {
  93                         fprintf(stderr, "%s\n", UBSAFES(errstr));
  94                 } else {
  95                         ui_respond_successful_save(e->str);
  96                 }
  97
  98                 break;
  99         case ET_LOAD:
 100
 101                 if (!e->str ||
 102                     !e->str[0]) {
 103                         break;
 104                 }
 105
 106                 history(verbose, "load from \"%s\"", e->str);
 107
 108                 if (!(f = fopen(e->str, "r"))) {
 109                         ret = errno;
 110                         perror(L("fopen"));
 111                 } else if ((ret = quiver_load_from_file(q, f, &errstr))) {
 112                         fprintf(stderr, "%s\n", UBSAFES(errstr));
 113                 } else {
 114                         ui_respond_successful_load(e->str);
 115                 }
 116
 117                 ui_respond_quiver_change();
 118                 break;
 119         case ET_MUTATE:
 120
 121                 if (e->idx_1 < q->v_num) {
 122                         history(verbose, "mutate at \"%s\" (%zu)",
 123                                 q->v[e->idx_1].name, e->idx_1);
 124
 125                         if ((ret = quiver_mutate(q, e->idx_1, 0, &errstr))) {
 126                                 fprintf(stderr, "%s\n", UBSAFES(errstr));
 127                         }
 128                 }
 129
 130                 break;
 131         case ET_NEW_VERTEX:
 132
 133                 if (!e->str ||
 134                     !e->str[0]) {
 135                         break;
 136                 }
 137
 138                 history(verbose, "new vertex \"%s\" at (%d, %d)", e->str,
 139                         e->int_1, e->int_2);
 140
 141                 if ((ret = quiver_add_vertex(q, 0, e->str, 1, e->int_1,
 142                                              e->int_2, e->z, &errstr))) {
 143                         fprintf(stderr, "%s\n", UBSAFES(errstr));
 144                 }
 145
 146                 ui_respond_quiver_change();
 147                 break;
 148         case ET_NEW_EDGE:
 149
 150                 if (e->idx_1 < q->v_num &&
 151                     e->idx_2 < q->v_num) {
 152                         history(verbose,
 153                                 "add edge from \"%s\" (%zu) to \"%s\" (%zu), weight %d/%d",
 154                                 q->v[e->idx_1].name, e->idx_1,
 155                                 q->v[e->idx_2].name,
 156                                 e->idx_2, (int) e->a, (int) e->b);
 157
 158                         if ((ret = quiver_add_to_edge(q, e->idx_1, e->idx_2,
 159                                                       e->a, e->b, &errstr))) {
 160                                 fprintf(stderr, "%s\n", UBSAFES(errstr));
 161                         }
 162                 }
 163
 164                 break;
 165         case ET_DELETE_VERTEX:
 166
 167                 if (e->idx_1 < q->v_num) {
 168                         history(verbose, "delete vertex \"%s\" (%zu)",
 169                                 q->v[e->idx_1].name, e->idx_1);
 170
 171                         if ((ret = quiver_delete_vertex(q, e->idx_1,
 172                                                         &errstr))) {
 173                                 fprintf(stderr, "%s\n", UBSAFES(errstr));
 174                         }
 175                 }
 176
 177                 ui_respond_quiver_change();
 178                 break;
 179         case ET_DELETE_EDGE:
 180
 181                 if (e->idx_1 < q->v_num &&
 182                     e->idx_2 < q->v_num) {
 183                         size_t i12 = e->idx_1 * q->v_len + e->idx_2;
 184                         size_t i21 = e->idx_2 * q->v_len + e->idx_1;
 185
 186                         history(verbose,
 187                                 "remove edge between \"%s\" (%zu) and \"%s\" (%zu)",
 188                                 q->v[e->idx_1].name, e->idx_1,
 189                                 q->v[e->idx_2].name,
 190                                 e->idx_2);
 191                         q->e[i12] = (struct rational) { .p = 0, .q = 1 };
 192                         q->e[i21] = (struct rational) { .p = 0, .q = 1 };
 193                 }
 194
 195                 break;
 196         case ET_CHANGE_FATNESS:
 197
 198                 if (e->idx_1 < q->v_num &&
 199                     q->v[e->idx_1].fatness + e->int_1 > 0 &&
 200                     q->v[e->idx_1].fatness + e->int_1 < UINT_FAST8_MAX) {
 201                         history(verbose,
 202                                 "change fatness of vertex \"%s\" (%zu) to %d",
 203                                 q->v[e->idx_1].name, e->idx_1,
 204                                 q->v[e->idx_1].fatness +
 205                                 e->int_1);
 206
 207                         if ((ret = quiver_adjust_fatness(q, e->idx_1, e->int_1,
 208                                                          &errstr))) {
 209                                 fprintf(stderr, "%s\n", UBSAFES(errstr));
 210                         }
 211                 }
 212
 213                 break;
 214         case ET_CHANGE_COLOR:
 215
 216                 if (e->idx_1 < q->v_num) {
 217                         history(verbose,
 218                                 "change color of vertex \"%s\" (%zu) to %#010lx",
 219                                 q->v[e->idx_1].name, e->idx_1, (long int) e->z);
 220
 221                         if ((ret = quiver_color_vertex(q, e->idx_1, e->z,
 222                                                        &errstr))) {
 223                                 fprintf(stderr, "%s\n", UBSAFES(errstr));
 224                         }
 225                 }
 226
 227                 break;
 228         case ET_NONE:
 229                 break;
 230         }
 231
 232         if (f) {
 233                 fclose(f);
 234         }
 235
 236         return ret;
 237 }
 238
 239 /* Main loop */
 240 int
 241 main(int argc, char **argv)
 242 {
 243         int ret;
 244         struct quiver q = { 0 };
 245         int opt;
 246         int verbose = 0;
 247
 248         UNUSED(argc);
 249         UNUSED(argv);
 250         setlocale(LC_ALL, "");
 251
 252         while ((opt = getopt(argc, argv, "v")) != -1) {
 253                 switch (opt) {
 254                 case 'v':
 255                         verbose = 1;
 256                         break;
 257                 }
 258         }
 259
 260         if ((ret = ui_init(&q))) {
 261                 goto done;
 262         }
 263
 264         /* Preload a basic quiver */
 265         size_t va, vb, vc;
 266
 267         quiver_add_vertex(&q, &va, "A", 1, -50, 50, 0x008282b2, 0);
 268         quiver_add_vertex(&q, &vb, "B", 1, 0, -75, 0x008282b2, 0);
 269         quiver_add_vertex(&q, &vc, "C", 1, 75, 0, 0x008282b2, 0);
 270         quiver_add_to_edge(&q, va, vb, 1, 1, 0);
 271         quiver_add_to_edge(&q, vc, va, 1, 1, 0);
 272
 273         if ((ret = ui_respond_quiver_change())) {
 274                 goto done;
 275         }
 276
 277         if ((ret = ui_start_frame())) {
 278                 goto done;
 279         }
 280
 281         uint_fast8_t more_evs = 0;
 282         struct ui_event e = { 0 };
 283
 284         while (!should_quit) {
 285                 /* includes framelimiting delay */
 286                 if ((ret = ui_finish_frame())) {
 287                         goto done;
 288                 }
 289
 290                 more_evs = 1;
 291
 292                 while (more_evs) {
 293                         if ((ret = ui_get_event(&e, &more_evs))) {
 294                                 goto done;
 295                         }
 296
 297                         if (e.type) {
 298                                 state_transition(&e, &q, verbose);
 299                         }
 300                 }
 301
 302                 if ((ret = ui_start_frame())) {
 303                         goto done;
 304                 }
 305         }
 306
 307 done:
 308         ui_teardown();
 309         quiver_clean(&q);
 310
 311         return ret;
 312 }