gui/graph_canvas.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains implementation of graph canvas object
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include <locale.h>
  28
  29 #include "graph_canvas.h"
  30 #include "../dbus_constants.h"
  31
  32 struct graph_canvas
  33 {
  34   graph_proxy_handle graph;
  35   canvas_handle canvas;
  36   struct list_head clients;
  37 };
  38
  39 struct client
  40 {
  41   struct list_head siblings;
  42   uint64_t id;
  43   canvas_module_handle canvas_module;
  44   struct list_head ports;
  45   struct graph_canvas * owner_ptr;
  46 };
  47
  48 struct port
  49 {
  50   struct list_head siblings;
  51   uint64_t id;
  52   canvas_port_handle canvas_port;
  53   struct graph_canvas * graph_canvas;
  54 };
  55
  56 static
  57 struct client *
  58 find_client(
  59   struct graph_canvas * graph_canvas_ptr,
  60   uint64_t id)
  61 {
  62   struct list_head * node_ptr;
  63   struct client * client_ptr;
  64
  65   list_for_each(node_ptr, &graph_canvas_ptr->clients)
  66   {
  67     client_ptr = list_entry(node_ptr, struct client, siblings);
  68     if (client_ptr->id == id)
  69     {
  70       return client_ptr;
  71     }
  72   }
  73
  74   return NULL;
  75 }
  76
  77 static
  78 struct port *
  79 find_port(
  80   struct client * client_ptr,
  81   uint64_t id)
  82 {
  83   struct list_head * node_ptr;
  84   struct port * port_ptr;
  85
  86   list_for_each(node_ptr, &client_ptr->ports)
  87   {
  88     port_ptr = list_entry(node_ptr, struct port, siblings);
  89     if (port_ptr->id == id)
  90     {
  91       return port_ptr;
  92     }
  93   }
  94
  95   return NULL;
  96 }
  97
  98 #define port1_ptr ((struct port *)port1_context)
  99 #define port2_ptr ((struct port *)port2_context)
 100
 101 static
 102 void
 103 connect_request(
 104   void * port1_context,
 105   void * port2_context)
 106 {
 107   log_info("connect request(%"PRIu64", %"PRIu64")", port1_ptr->id, port2_ptr->id);
 108
 109   ASSERT(port1_ptr->graph_canvas == port2_ptr->graph_canvas);
 110
 111   graph_proxy_connect_ports(port1_ptr->graph_canvas->graph, port1_ptr->id, port2_ptr->id);
 112 }
 113
 114 void
 115 disconnect_request(
 116   void * port1_context,
 117   void * port2_context)
 118 {
 119   log_info("disconnect request(%"PRIu64", %"PRIu64")", port1_ptr->id, port2_ptr->id);
 120
 121   ASSERT(port1_ptr->graph_canvas == port2_ptr->graph_canvas);
 122
 123   graph_proxy_disconnect_ports(port1_ptr->graph_canvas->graph, port1_ptr->id, port2_ptr->id);
 124 }
 125
 126 #undef port1_ptr
 127 #undef port2_ptr
 128
 129 #define client_ptr ((struct client *)module_context)
 130
 131 void
 132 module_location_changed(
 133   void * module_context,
 134   double x,
 135   double y)
 136 {
 137   char x_str[100];
 138   char y_str[100];
 139   char * locale;
 140
 141   log_info("module_location_changed(id = %3llu, x = %6.1f, y = %6.1f)", (unsigned long long)client_ptr->id, x, y);
 142
 143   locale = strdup(setlocale(LC_NUMERIC, NULL));
 144   if (locale == NULL)
 145   {
 146     log_error("strdup() failed for locale string");
 147     return;
 148   }
 149
 150   setlocale(LC_NUMERIC, "POSIX");
 151   sprintf(x_str, "%f", x);
 152   sprintf(y_str, "%f", y);
 153   setlocale(LC_NUMERIC, locale);
 154   free(locale);
 155
 156   graph_proxy_dict_entry_set(
 157     client_ptr->owner_ptr->graph,
 158     GRAPH_DICT_OBJECT_TYPE_CLIENT,
 159     client_ptr->id,
 160     URI_CANVAS_X,
 161     x_str);
 162
 163   graph_proxy_dict_entry_set(
 164     client_ptr->owner_ptr->graph,
 165     GRAPH_DICT_OBJECT_TYPE_CLIENT,
 166     client_ptr->id,
 167     URI_CANVAS_Y,
 168     y_str);
 169 }
 170
 171 #undef client_ptr
 172
 173 bool
 174 graph_canvas_create(
 175   int width,
 176   int height,
 177   graph_canvas_handle * graph_canvas_handle_ptr)
 178 {
 179   struct graph_canvas * graph_canvas_ptr;
 180
 181   graph_canvas_ptr = malloc(sizeof(struct graph_canvas));
 182   if (graph_canvas_ptr == NULL)
 183   {
 184     return false;
 185   }
 186
 187   if (!canvas_create(width, height, connect_request, disconnect_request, module_location_changed, &graph_canvas_ptr->canvas))
 188   {
 189     free(graph_canvas_ptr);
 190     return false;
 191   }
 192
 193   graph_canvas_ptr->graph = NULL;
 194   INIT_LIST_HEAD(&graph_canvas_ptr->clients);
 195
 196   *graph_canvas_handle_ptr = (graph_canvas_handle)graph_canvas_ptr;
 197
 198   return true;
 199 }
 200
 201 #define graph_canvas_ptr ((struct graph_canvas *)graph_canvas)
 202
 203 static
 204 void
 205 clear(
 206   void * graph_canvas)
 207 {
 208   log_info("canvas::clear()");
 209   canvas_clear(graph_canvas_ptr->canvas);
 210 }
 211
 212 static
 213 void
 214 client_appeared(
 215   void * graph_canvas,
 216   uint64_t id,
 217   const char * name)
 218 {
 219   struct client * client_ptr;
 220   char * x_str;
 221   char * y_str;
 222   double x;
 223   double y;
 224   char * locale;
 225   double width;
 226   double height;
 227
 228   log_info("canvas::client_appeared(%"PRIu64", \"%s\")", id, name);
 229
 230   canvas_get_size(graph_canvas_ptr->canvas, &width, &height);
 231   //log_debug("width %f, height %f", width, height);
 232
 233   client_ptr = malloc(sizeof(struct client));
 234   if (client_ptr == NULL)
 235   {
 236     log_error("allocation of memory for struct client failed");
 237     return;
 238   }
 239
 240   client_ptr->id = id;
 241   INIT_LIST_HEAD(&client_ptr->ports);
 242   client_ptr->owner_ptr = graph_canvas_ptr;
 243
 244   x = 0;
 245   y = 0;
 246
 247   if (!graph_proxy_dict_entry_get(
 248         client_ptr->owner_ptr->graph,
 249         GRAPH_DICT_OBJECT_TYPE_CLIENT,
 250         id,
 251         URI_CANVAS_X,
 252         &x_str))
 253   {
 254     x_str = NULL;
 255     x = width / 2 - 200 + rand() % 300;
 256   }
 257
 258   if (!graph_proxy_dict_entry_get(
 259         client_ptr->owner_ptr->graph,
 260         GRAPH_DICT_OBJECT_TYPE_CLIENT,
 261         id,
 262         URI_CANVAS_Y,
 263         &y_str))
 264   {
 265     y_str = NULL;
 266     y = height / 2 - 200 + rand() % 300;
 267   }
 268
 269   if (x_str != NULL || y_str != NULL)
 270   {
 271     locale = strdup(setlocale(LC_NUMERIC, NULL));
 272     if (locale == NULL)
 273     {
 274       log_error("strdup() failed for locale string");
 275     }
 276     else
 277     {
 278       setlocale(LC_NUMERIC, "POSIX");
 279       if (x_str != NULL)
 280       {
 281         //log_info("converting %s", x_str);
 282         sscanf(x_str, "%lf", &x);
 283       }
 284       if (y_str != NULL)
 285       {
 286         //log_info("converting %s", y_str);
 287         sscanf(y_str, "%lf", &y);
 288       }
 289       setlocale(LC_NUMERIC, locale);
 290       free(locale);
 291     }
 292
 293     if (x_str != NULL)
 294     {
 295       free(x_str);
 296     }
 297
 298     if (y_str != NULL)
 299     {
 300       free(y_str);
 301     }
 302   }
 303
 304   if (!canvas_create_module(graph_canvas_ptr->canvas, name, x, y, true, true, client_ptr, &client_ptr->canvas_module))
 305   {
 306     log_error("canvas_create_module(\"%s\") failed", name);
 307     free(client_ptr);
 308     return;
 309   }
 310
 311   if (x_str == NULL || y_str == NULL)
 312   { /* we have generated random value, store it */
 313     module_location_changed(client_ptr, x, y);
 314   }
 315
 316   list_add_tail(&client_ptr->siblings, &graph_canvas_ptr->clients);
 317 }
 318
 319 static
 320 void
 321 client_disappeared(
 322   void * graph_canvas,
 323   uint64_t id)
 324 {
 325   struct client * client_ptr;
 326
 327   log_info("canvas::client_disappeared(%"PRIu64")", id);
 328
 329   client_ptr = find_client(graph_canvas_ptr, id);
 330   if (client_ptr == NULL)
 331   {
 332     log_error("cannot find disappearing client %"PRIu64"", id);
 333     return;
 334   }
 335
 336   list_del(&client_ptr->siblings);
 337   canvas_destroy_module(graph_canvas_ptr->canvas, client_ptr->canvas_module);
 338   free(client_ptr);
 339 }
 340
 341 static void client_renamed(void * graph_canvas, uint64_t id, const char * old_name, const char * new_name)
 342 {
 343   struct client * client_ptr;
 344
 345   log_info("canvas::client_renamed(%"PRIu64", '%s', '%s')", id, old_name, new_name);
 346
 347   client_ptr = find_client(graph_canvas_ptr, id);
 348   if (client_ptr == NULL)
 349   {
 350     log_error("cannot find renamed client %"PRIu64, id);
 351     return;
 352   }
 353
 354   canvas_set_module_name(client_ptr->canvas_module, new_name);
 355 }
 356
 357 static
 358 void
 359 port_appeared(
 360   void * graph_canvas,
 361   uint64_t client_id,
 362   uint64_t port_id,
 363   const char * port_name,
 364   bool is_input,
 365   bool is_terminal,
 366   bool is_midi)
 367 {
 368   int color;
 369   struct client * client_ptr;
 370   struct port * port_ptr;
 371
 372   log_info("canvas::port_appeared(%"PRIu64", %"PRIu64", \"%s\")", client_id, port_id, port_name);
 373
 374   client_ptr = find_client(graph_canvas_ptr, client_id);
 375   if (client_ptr == NULL)
 376   {
 377     log_error("cannot find client %"PRIu64" of appearing port %"PRIu64" \"%s\"", client_id, port_id, port_name);
 378     return;
 379   }
 380
 381   port_ptr = malloc(sizeof(struct port));
 382   if (port_ptr == NULL)
 383   {
 384     log_error("allocation of memory for struct port failed");
 385     return;
 386   }
 387
 388   port_ptr->id = port_id;
 389   port_ptr->graph_canvas = graph_canvas_ptr;
 390
 391   // Darkest tango palette colour, with S -= 6, V -= 6, w/ transparency
 392   if (is_midi)
 393   {
 394     color = 0x960909C0;
 395   }
 396   else
 397   {
 398     color = 0x244678C0;
 399   }
 400
 401   if (!canvas_create_port(graph_canvas_ptr->canvas, client_ptr->canvas_module, port_name, is_input, color, port_ptr, &port_ptr->canvas_port))
 402   {
 403     log_error("canvas_create_port(\"%s\") failed", port_name);
 404     free(client_ptr);
 405     return;
 406   }
 407
 408   list_add_tail(&port_ptr->siblings, &client_ptr->ports);
 409 }
 410
 411 static
 412 void
 413 port_disappeared(
 414   void * graph_canvas,
 415   uint64_t client_id,
 416   uint64_t port_id)
 417 {
 418   struct client * client_ptr;
 419   struct port * port_ptr;
 420
 421   log_info("canvas::port_disappeared(%"PRIu64", %"PRIu64")", client_id, port_id);
 422
 423   client_ptr = find_client(graph_canvas_ptr, client_id);
 424   if (client_ptr == NULL)
 425   {
 426     log_error("cannot find client %"PRIu64" of disappearing port %"PRIu64"", client_id, port_id);
 427     return;
 428   }
 429
 430   port_ptr = find_port(client_ptr, port_id);
 431   if (client_ptr == NULL)
 432   {
 433     log_error("cannot find disappearing port %"PRIu64" of client %"PRIu64"", port_id, client_id);
 434     return;
 435   }
 436
 437   list_del(&port_ptr->siblings);
 438   canvas_destroy_port(graph_canvas_ptr->canvas, port_ptr->canvas_port);
 439   free(port_ptr);
 440 }
 441
 442 static
 443 void
 444 port_renamed(
 445   void * graph_canvas,
 446   uint64_t client_id,
 447   uint64_t port_id,
 448   const char * old_port_name,
 449   const char * new_port_name)
 450 {
 451   struct client * client_ptr;
 452   struct port * port_ptr;
 453
 454   log_info("canvas::port_renamed(%"PRIu64", %"PRIu64", '%s', '%s')", client_id, port_id, old_port_name, new_port_name);
 455
 456   client_ptr = find_client(graph_canvas_ptr, client_id);
 457   if (client_ptr == NULL)
 458   {
 459     log_error("cannot find client %"PRIu64" of renamed port %"PRIu64"", client_id, port_id);
 460     return;
 461   }
 462
 463   port_ptr = find_port(client_ptr, port_id);
 464   if (client_ptr == NULL)
 465   {
 466     log_error("cannot find renamed port %"PRIu64" of client %"PRIu64"", port_id, client_id);
 467     return;
 468   }
 469
 470   canvas_set_port_name(port_ptr->canvas_port, new_port_name);
 471 }
 472
 473 static
 474 void
 475 ports_connected(
 476   void * graph_canvas,
 477   uint64_t client1_id,
 478   uint64_t port1_id,
 479   uint64_t client2_id,
 480   uint64_t port2_id)
 481 {
 482   struct client * client1_ptr;
 483   struct port * port1_ptr;
 484   struct client * client2_ptr;
 485   struct port * port2_ptr;
 486
 487   log_info("canvas::ports_connected(%"PRIu64", %"PRIu64", %"PRIu64", %"PRIu64")", client1_id, port1_id, client2_id, port2_id);
 488
 489   client1_ptr = find_client(graph_canvas_ptr, client1_id);
 490   if (client1_ptr == NULL)
 491   {
 492     log_error("cannot find client %"PRIu64" of connected port %"PRIu64"", client1_id, port1_id);
 493     return;
 494   }
 495
 496   port1_ptr = find_port(client1_ptr, port1_id);
 497   if (client1_ptr == NULL)
 498   {
 499     log_error("cannot find connected port %"PRIu64" of client %"PRIu64"", port1_id, client1_id);
 500     return;
 501   }
 502
 503   client2_ptr = find_client(graph_canvas_ptr, client2_id);
 504   if (client2_ptr == NULL)
 505   {
 506     log_error("cannot find client %"PRIu64" of connected port %"PRIu64"", client2_id, port2_id);
 507     return;
 508   }
 509
 510   port2_ptr = find_port(client2_ptr, port2_id);
 511   if (client2_ptr == NULL)
 512   {
 513     log_error("cannot find connected port %"PRIu64" of client %"PRIu64"", port2_id, client2_id);
 514     return;
 515   }
 516
 517   canvas_add_connection(
 518     graph_canvas_ptr->canvas,
 519     port1_ptr->canvas_port,
 520     port2_ptr->canvas_port,
 521     canvas_get_port_color(port1_ptr->canvas_port) + 0x22222200);
 522 }
 523
 524 static
 525 void
 526 ports_disconnected(
 527   void * graph_canvas,
 528   uint64_t client1_id,
 529   uint64_t port1_id,
 530   uint64_t client2_id,
 531   uint64_t port2_id)
 532 {
 533   struct client * client1_ptr;
 534   struct port * port1_ptr;
 535   struct client * client2_ptr;
 536   struct port * port2_ptr;
 537
 538   log_info("canvas::ports_disconnected(%"PRIu64", %"PRIu64", %"PRIu64", %"PRIu64")", client1_id, port1_id, client2_id, port2_id);
 539
 540   client1_ptr = find_client(graph_canvas_ptr, client1_id);
 541   if (client1_ptr == NULL)
 542   {
 543     log_error("cannot find client %"PRIu64" of disconnected port %"PRIu64"", client1_id, port1_id);
 544     return;
 545   }
 546
 547   port1_ptr = find_port(client1_ptr, port1_id);
 548   if (client1_ptr == NULL)
 549   {
 550     log_error("cannot find disconnected port %"PRIu64" of client %"PRIu64"", port1_id, client1_id);
 551     return;
 552   }
 553
 554   client2_ptr = find_client(graph_canvas_ptr, client2_id);
 555   if (client2_ptr == NULL)
 556   {
 557     log_error("cannot find client %"PRIu64" of disconnected port %"PRIu64"", client2_id, port2_id);
 558     return;
 559   }
 560
 561   port2_ptr = find_port(client2_ptr, port2_id);
 562   if (client2_ptr == NULL)
 563   {
 564     log_error("cannot find disconnected port %"PRIu64" of client %"PRIu64"", port2_id, client2_id);
 565     return;
 566   }
 567
 568   canvas_remove_connection(
 569     graph_canvas_ptr->canvas,
 570     port1_ptr->canvas_port,
 571     port2_ptr->canvas_port);
 572 }
 573
 574 void
 575 graph_canvas_destroy(
 576   graph_canvas_handle graph_canvas)
 577 {
 578   if (graph_canvas_ptr->graph != NULL)
 579   {
 580     graph_canvas_detach(graph_canvas);
 581   }
 582
 583   free(graph_canvas_ptr);
 584 }
 585
 586 bool
 587 graph_canvas_attach(
 588   graph_canvas_handle graph_canvas,
 589   graph_proxy_handle graph)
 590 {
 591   ASSERT(graph_canvas_ptr->graph == NULL);
 592
 593   if (!graph_proxy_attach(
 594         graph,
 595         graph_canvas,
 596         clear,
 597         client_appeared,
 598         client_renamed,
 599         client_disappeared,
 600         port_appeared,
 601         port_renamed,
 602         port_disappeared,
 603         ports_connected,
 604         ports_disconnected))
 605   {
 606     return false;
 607   }
 608
 609   graph_canvas_ptr->graph = graph;
 610
 611   return true;
 612 }
 613
 614 void
 615 graph_canvas_detach(
 616   graph_canvas_handle graph_canvas)
 617 {
 618   ASSERT(graph_canvas_ptr->graph != NULL);
 619   graph_proxy_detach(graph_canvas_ptr->graph, graph_canvas);
 620   graph_canvas_ptr->graph = NULL;
 621 }
 622
 623 canvas_handle
 624 graph_canvas_get_canvas(
 625   graph_canvas_handle graph_canvas)
 626 {
 627   return graph_canvas_ptr->canvas;
 628 }