libgeda/src/a_basic.c

   1 /* gEDA - GPL Electronic Design Automation
   2  * libgeda - gEDA's library
   3  * Copyright (C) 1998-2007 Ales Hvezda
   4  * Copyright (C) 1998-2007 gEDA Contributors (see ChangeLog for details)
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
  19  */
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #ifdef HAVE_STRING_H
  24 #include <string.h>
  25 #endif
  26
  27 #include <gtk/gtk.h>
  28 #include <libguile.h>
  29
  30 #include "defines.h"
  31 #include "struct.h"
  32 #include "globals.h"
  33 #include "o_types.h"
  34 #include "colors.h"
  35
  36 #include "../include/prototype.h"
  37
  38 #ifdef HAVE_LIBDMALLOC
  39 #include <dmalloc.h>
  40 #endif
  41
  42 /*! \brief Current version string */
  43 #define VERSION_20020825 20020825
  44
  45 /*! \brief Save embedded attributes to current file
  46  *  \par Function Description
  47  *  This function will save all embedded attributes to a file.
  48  *
  49  *  \param [in,out] w_current
  50  *  \param [in]     object_list  The list of attributes to write to file
  51  *  \param [in]     fp           The file to write to.
  52  */
  53 void o_save_embedded(TOPLEVEL *w_current, OBJECT *object_list, FILE *fp)
  54 {
  55   OBJECT *o_current=NULL;
  56   char *out;
  57
  58   /* make sure you init net_consolide to false (default) in all */
  59   /* programs */
  60   if (w_current->net_consolidate == TRUE) {
  61     o_net_consolidate(w_current);
  62   }
  63
  64   o_current = object_list;
  65
  66   while ( o_current != NULL ) {
  67
  68     if (o_current->type != OBJ_HEAD) {
  69
  70       if (o_current->attribute == 0) {
  71
  72         switch (o_current->type) {
  73
  74           case(OBJ_LINE):
  75             out = (char *) o_line_save(o_current);
  76             break;
  77
  78           case(OBJ_NET):
  79             out = (char *) o_net_save(o_current);
  80             break;
  81
  82           case(OBJ_BUS):
  83             out = (char *) o_bus_save(o_current);
  84             break;
  85
  86           case(OBJ_BOX):
  87             out = (char *) o_box_save(o_current);
  88             break;
  89
  90           case(OBJ_CIRCLE):
  91             out = (char *) o_circle_save(o_current);
  92             break;
  93
  94           case(OBJ_COMPLEX):
  95             out = (char *) o_complex_save(o_current);
  96             if (o_complex_is_embedded(o_current)) {
  97               fprintf(fp, "[\n");
  98
  99               o_save_embedded(
 100                               w_current,
 101                               o_current->
 102                               complex->prim_objs,
 103                               fp);
 104
 105               fprintf(fp, "]\n");
 106             }
 107             break;
 108
 109           case(OBJ_PLACEHOLDER):  /* new type by SDB 1.20.2005 */
 110             out = (char *) o_complex_save(o_current);
 111             break;
 112
 113           case(OBJ_TEXT):
 114             out = (char *) o_text_save(o_current);
 115             break;
 116
 117           case(OBJ_PIN):
 118             out = (char *) o_pin_save(o_current);
 119             break;
 120
 121           case(OBJ_ARC):
 122             out = (char *) o_arc_save(o_current);
 123             break;
 124
 125           case(OBJ_PICTURE):
 126             out = (char *) o_picture_save(o_current);
 127             break;
 128
 129           default:
 130             fprintf(stderr, "Error type!\n");
 131             exit(-1);
 132             break;
 133         }
 134
 135         /* output the line */
 136         fprintf(fp, "%s\n", out);
 137         g_free(out);
 138
 139         /* save those attributes */
 140         if (o_current->attribs != NULL) {
 141           if (o_current->attribs->next != NULL) {
 142             o_save_attribs(fp, o_current->attribs->next);
 143           }
 144         }
 145
 146       }
 147     }
 148     o_current = o_current->next;
 149   }
 150 }
 151
 152 /*! \brief Write libgeda file header
 153  *  \par Function Description
 154  *  This function simply prints the DATE_VERSION and FILEFORMAT_VERSION
 155  *  definitions to the file.
 156  *
 157  *  \param [in] fp  The file to write the header to.
 158  */
 159 void o_save_write_header(FILE *fp)
 160 {
 161   fprintf(fp, "v %s %u\n", DATE_VERSION, FILEFORMAT_VERSION);
 162 }
 163
 164 /*! \brief Save a file
 165  *  \par Function Description
 166  *  This function saves the data in a libgeda format to a file
 167  *  \param [in] w_current  The data to save to file.
 168  *  \param [in] filename   The filename to save the data to.
 169  *  \return 1 on success, 0 on failure.
 170  */
 171 int o_save(TOPLEVEL *w_current, const char *filename)
 172 {
 173   OBJECT *o_current=NULL;
 174   FILE *fp;
 175   char *out;
 176   int already_wrote=0;
 177
 178   fp = fopen(filename, "wb");
 179
 180   if (fp == NULL) {
 181     s_log_message("o_save: Could not open [%s]\n", filename);
 182     return 0;
 183   }
 184
 185
 186   o_current = w_current->page_current->object_head;
 187
 188   /* make sure you init net_consolide to false (default) in all */
 189   /* programs */
 190   if (w_current->net_consolidate == TRUE) {
 191     o_net_consolidate(w_current);
 192   }
 193
 194   o_save_write_header(fp);
 195
 196   while ( o_current != NULL ) {
 197
 198     if (o_current->type != OBJ_HEAD) {
 199
 200       if (o_current->attribute == 0) {
 201
 202         switch (o_current->type) {
 203
 204           case(OBJ_LINE):
 205             out = (char *) o_line_save(o_current);
 206             break;
 207
 208           case(OBJ_NET):
 209             out = (char *) o_net_save(o_current);
 210             break;
 211
 212           case(OBJ_BUS):
 213             out = (char *) o_bus_save(o_current);
 214             break;
 215
 216           case(OBJ_BOX):
 217             out = (char *) o_box_save(o_current);
 218             break;
 219
 220           case(OBJ_CIRCLE):
 221             out = (char *) o_circle_save(o_current);
 222             break;
 223
 224           case(OBJ_COMPLEX):
 225             out = (char *) o_complex_save(o_current);
 226             fprintf(fp, "%s\n", out);
 227             already_wrote=1;
 228             g_free(out); /* need to free here because of the above flag */
 229             if (o_complex_is_embedded(o_current)) {
 230               fprintf(fp, "[\n");
 231
 232               o_save_embedded(
 233                               w_current,
 234                               o_current->
 235                               complex->prim_objs,
 236                               fp);
 237
 238               fprintf(fp, "]\n");
 239             }
 240             break;
 241
 242           case(OBJ_PLACEHOLDER):  /* new type by SDB 1.20.2005 */
 243             out = (char *) o_complex_save(o_current);
 244             break;
 245
 246           case(OBJ_TEXT):
 247             out = (char *) o_text_save(o_current);
 248             break;
 249
 250           case(OBJ_PIN):
 251             out = (char *) o_pin_save(o_current);
 252             break;
 253
 254           case(OBJ_ARC):
 255             out = (char *) o_arc_save(o_current);
 256             break;
 257
 258           case(OBJ_PICTURE):
 259             out = (char *) o_picture_save(o_current);
 260             break;
 261
 262           default:
 263             fprintf(stderr, "Error type!\n");
 264             exit(-1);
 265             break;
 266         }
 267
 268                                 /* output the line */
 269         if (!already_wrote) {
 270           fprintf(fp, "%s\n", out);
 271           g_free(out);
 272         } else {
 273           already_wrote=0;
 274         }
 275
 276                                 /* save those attributes */
 277         if (o_current->attribs != NULL) {
 278           if (o_current->attribs->next != NULL) {
 279             o_save_attribs(fp, o_current->attribs->next);
 280           }
 281         }
 282
 283       }
 284     }
 285     o_current = o_current->next;
 286   }
 287
 288   fclose(fp);
 289   return 1;
 290 }
 291
 292 /*! \brief Read a memory buffer
 293  *  \par Function Description
 294  *  This function reads data in libgeda format from a memory buffer.
 295  *
 296  *  If the size argument is negative, the buffer is assumed to be
 297  *  null-terminated.
 298  *
 299  *  The name argument is used for debugging, and should be set to a
 300  *  meaningful string (e.g. the name of the file the data is from).
 301  *
 302  *  \param [in,out] w_current    The current TOPLEVEL structure.
 303  *  \param [in]     object_list  The object_list to read data to.
 304  *  \param [in]     buffer       The memory buffer to read from.
 305  *  \param [in]     size         The size of the buffer.
 306  *  \param [in]     name         The name to describe the data with.
 307  *  \return object_list if successful read, or NULL on error.
 308  */
 309 OBJECT *o_read_buffer(TOPLEVEL *w_current, OBJECT *object_list,
 310                       char *buffer, const int size,
 311                       const char *name)
 312 {
 313   char *line = NULL;
 314   TextBuffer *tb = NULL;
 315
 316   char objtype;
 317   OBJECT *object_list_save=NULL;
 318   OBJECT *temp_tail=NULL;
 319   OBJECT *temp_parent=NULL;
 320   OBJECT *object_before_attr=NULL;
 321   unsigned int release_ver;
 322   unsigned int fileformat_ver;
 323   unsigned int current_fileformat_ver;
 324   int found_pin = 0;
 325   OBJECT* last_complex = NULL;
 326   int itemsread = 0;
 327
 328   int embedded_level = 0;
 329
 330
 331   /* fill version with default file format version (the current one) */
 332   current_fileformat_ver = FILEFORMAT_VERSION;
 333
 334   if (buffer == NULL) {
 335     s_log_message("o_read_buffer: Received NULL buffer\n");
 336     return(NULL);
 337   }
 338
 339   tb = s_textbuffer_new (buffer, size);
 340   g_assert (tb != NULL);
 341
 342   while (1) {
 343
 344     line = s_textbuffer_next_line(tb);
 345     if (line == NULL) break;
 346
 347     sscanf(line, "%c", &objtype);
 348
 349     /* Do we need to check the symbol version?  Yes, but only if */
 350     /* 1) the last object read was a complex and */
 351     /* 2) the next object isn't the start of attributes.  */
 352     /* If the next object is the start of attributes, then check the */
 353     /* symbol version after the attributes have been read in, see the */
 354     /* STARTATTACH_ATTR case */
 355     if (last_complex && objtype != STARTATTACH_ATTR)
 356     {
 357         /* yes */
 358         /* verify symbol version (not file format but rather contents) */
 359         o_complex_check_symversion(w_current, last_complex);
 360         last_complex = NULL;  /* no longer need to check */
 361     }
 362
 363     switch (objtype) {
 364
 365       case(OBJ_LINE):
 366         object_list = (OBJECT *) o_line_read(w_current, object_list, line,
 367                                              release_ver, fileformat_ver);
 368         break;
 369
 370
 371       case(OBJ_NET):
 372         object_list = (OBJECT *) o_net_read(w_current, object_list, line,
 373                                             release_ver, fileformat_ver);
 374         break;
 375
 376       case(OBJ_BUS):
 377         object_list = (OBJECT *) o_bus_read(w_current, object_list, line,
 378                                             release_ver, fileformat_ver);
 379         break;
 380
 381       case(OBJ_BOX):
 382         object_list = (OBJECT *) o_box_read(w_current, object_list, line,
 383                                             release_ver, fileformat_ver);
 384         break;
 385
 386       case(OBJ_PICTURE):
 387         line = g_strdup(line);
 388         object_list = (OBJECT *) o_picture_read(w_current, object_list,
 389                                                 line, tb,
 390                                                 release_ver, fileformat_ver);
 391         g_free (line);
 392         break;
 393
 394       case(OBJ_CIRCLE):
 395         object_list = (OBJECT *) o_circle_read(w_current, object_list, line,
 396                                                release_ver, fileformat_ver);
 397         break;
 398
 399       case(OBJ_COMPLEX):
 400       case(OBJ_PLACEHOLDER):
 401         object_list = (OBJECT *) o_complex_read(w_current, object_list, line,
 402                                                 release_ver, fileformat_ver);
 403
 404         /* this is necessary because complex may add attributes which float */
 405         /* needed now? */
 406         object_list = (OBJECT *) return_tail(object_list);
 407
 408         /* last_complex is used for verifying symversion attribute */
 409         last_complex = object_list;
 410         break;
 411
 412       case(OBJ_TEXT):
 413         line = g_strdup(line);
 414         object_list = (OBJECT *) o_text_read(w_current, object_list,
 415                                              line, tb,
 416                                              release_ver, fileformat_ver);
 417         g_free(line);
 418         break;
 419
 420       case(OBJ_PIN):
 421         object_list = (OBJECT *) o_pin_read(w_current, object_list, line,
 422                                             release_ver, fileformat_ver);
 423         found_pin++;
 424         break;
 425
 426       case(OBJ_ARC):
 427         object_list = (OBJECT *) o_arc_read(w_current, object_list, line,
 428                                             release_ver, fileformat_ver);
 429         break;
 430
 431       case(STARTATTACH_ATTR):
 432         object_before_attr = object_list;
 433         /* first is the fp */
 434         /* 2nd is the object to get the attributes */
 435         object_list = (OBJECT *) o_read_attribs(w_current, object_list,
 436                                                 tb,
 437                                                 release_ver, fileformat_ver);
 438
 439         /* by now we have finished reading all the attributes */
 440         /* did we just finish attaching to a complex object? */
 441         if (last_complex)
 442         {
 443           /* yes */
 444           /* verify symbol version (not file format but rather contents) */
 445           o_complex_check_symversion(w_current, last_complex);
 446           last_complex = NULL;
 447         }
 448
 449         /* slots only apply to complex objects */
 450         if (object_before_attr->type == OBJ_COMPLEX ||
 451             object_before_attr->type == OBJ_PLACEHOLDER) {
 452           o_attrib_slot_update(w_current, object_before_attr);
 453         }
 454
 455         /* need this? nope */
 456         /*object_list = return_tail(object_list);*/
 457         object_before_attr = NULL;
 458         break;
 459
 460       case(START_EMBEDDED):
 461
 462         if(object_list->type == OBJ_COMPLEX ||
 463            object_list->type == OBJ_PLACEHOLDER) {
 464
 465                 object_list_save = object_list;
 466                 object_list = object_list_save->complex->prim_objs;
 467
 468                 temp_tail = w_current->page_current->object_tail;
 469                 temp_parent = w_current->page_current->object_parent;
 470                 w_current->page_current->object_parent = object_list;
 471
 472                 embedded_level++;
 473         } else {
 474                 fprintf(stderr, "Read unexpected embedded "
 475                                 "symbol start marker in [%s] :\n>>\n%s<<\n",
 476                                 name, line);
 477         }
 478         break;
 479
 480       case(END_EMBEDDED):
 481         if(embedded_level>0) {
 482                 object_list = object_list_save;
 483                 /* don't do this since objects are already
 484                  * stored/read translated
 485                  * o_complex_world_translate(w_current, object_list->x,
 486                  *                   object_list->y, object_list->complex);
 487                  */
 488                 w_current->page_current->object_tail = temp_tail;
 489                 w_current->page_current->object_parent = temp_parent;
 490
 491           o_complex_recalc( w_current, object_list );
 492                 embedded_level--;
 493         } else {
 494                 fprintf(stderr, "Read unexpected embedded "
 495                                 "symbol end marker in [%s] :\n>>\n%s<<\n",
 496                                 name, line);
 497         }
 498
 499         break;
 500
 501       case(ENDATTACH_ATTR):
 502         /* this case is never hit, since the } is consumed by o_read_attribs */
 503         break;
 504
 505       case(INFO_FONT):
 506         o_text_set_info_font(line);
 507         break;
 508
 509       case(COMMENT):
 510         /* do nothing */
 511         break;
 512
 513       case(VERSION_CHAR):
 514         itemsread = sscanf(line, "v %u %u\n", &release_ver, &fileformat_ver);
 515
 516         /* 20030921 was the last version which did not have a fileformat */
 517         /* version.  The below latter test should not happen, but it is here */
 518         /* just in in case. */
 519         if (release_ver <= VERSION_20030921 || itemsread == 1)
 520         {
 521           fileformat_ver = 0;
 522         }
 523
 524         if (fileformat_ver < current_fileformat_ver)
 525         {
 526           s_log_message("Read an old format sym/sch file!\n"
 527                         "Please run g[sym|sch]update on:\n[%s]\n", name);
 528         }
 529         break;
 530
 531       default:
 532         fprintf(stderr, "Read garbage in [%s] :\n>>\n%s<<\n",
 533                 name, line);
 534         break;
 535     }
 536
 537   }
 538
 539   /* Was the very last thing we read a complex and has it not been checked */
 540   /* yet?  This would happen if the complex is at the very end of the file  */
 541   /* and had no attached attributes */
 542   if (last_complex)
 543   {
 544         o_complex_check_symversion(w_current, last_complex);
 545         last_complex = NULL;  /* no longer need to check */
 546   }
 547
 548   if (found_pin) {
 549     if (release_ver <= VERSION_20020825) {
 550       o_pin_update_whichend(w_current, return_head(object_list), found_pin);
 551     }
 552   }
 553
 554   tb = s_textbuffer_free(tb);
 555
 556   return(object_list);
 557
 558 }
 559
 560 /*! \brief Read a file
 561  *  \par Function Description
 562  *  This function reads a file in libgeda format.
 563  *
 564  *  \param [in,out] w_current    The current TOPLEVEL structure.
 565  *  \param [in]     object_list  The object_list to read data to.
 566  *  \param [in]     filename     The filename to read from.
 567  *  \return object_list if successful read, or NULL on error.
 568  */
 569 OBJECT *o_read(TOPLEVEL *w_current, OBJECT *object_list, char *filename)
 570 {
 571   GError *err = NULL;
 572   char *buffer = NULL;
 573   size_t size;
 574   OBJECT *result = NULL;
 575
 576   g_file_get_contents(filename, &buffer, &size, &err);
 577
 578   g_assert ((buffer == NULL && err != NULL)
 579             || (buffer != NULL && err == NULL));
 580
 581   if (err != NULL)
 582     {
 583       /* Report error to user, and free error */
 584       g_assert (buffer == NULL);
 585       fprintf (stderr, "o_read: Unable to read file: [%s]\n", err->message);
 586       g_error_free (err);
 587       return NULL;
 588     }
 589
 590   /* Parse file contents */
 591   g_assert (buffer != NULL);
 592   result = o_read_buffer (w_current, object_list, buffer, size, filename);
 593   g_free (buffer);
 594   return result;
 595 }
 596
 597 /*! \brief Scale a set of lines.
 598  *  \par Function Description
 599  *  This function takes a list of lines and scales them
 600  *  by the values of x_scale and y_scale.
 601  *
 602  *  \param [in] w_current  The current TOPLEVEL object.
 603  *  \param [in,out]  list  The list with lines to scale.
 604  *  \param [in]   x_scale  The x scale value for the lines.
 605  *  \param [in]   y_scale  The y scale value for the lines.
 606  *
 607  *  \todo this really doesn't belong here. you need more of a core routine
 608  *        first. yes.. this is the core routine, just strip out the drawing
 609  *        stuff
 610  *        move it to o_complex_scale
 611  */
 612 void o_scale(TOPLEVEL *w_current, OBJECT *list, int x_scale, int y_scale)
 613 {
 614   OBJECT *o_current;
 615
 616   /* this is okay if you just hit scale and have nothing selected */
 617   if (list == NULL) {
 618     /* w_current->event_state = SELECT;*/
 619     /* i_update_status(w_current, "Select Mode"); not here */
 620     /*          w_current->inside_action = 0;*/
 621     return;
 622   }
 623
 624
 625   o_current = list;
 626
 627
 628   while (o_current != NULL) {
 629
 630     switch(o_current->type) {
 631
 632       case(OBJ_LINE):
 633                                 /* erase the current selection */
 634         w_current->override_color =
 635           w_current->background_color;
 636         o_redraw_single(w_current, o_current);
 637                                 /* o_line_draw(w_current, o_current);*/
 638         w_current->override_color = -1;
 639
 640         o_line_scale_world(w_current,
 641                            x_scale, y_scale, o_current);
 642         break;
 643     }
 644
 645     o_current = o_current->next;
 646   }
 647
 648   /* don't do this at this level */
 649   /* w_current->page_current->CHANGED=1;*/
 650 }
 651
 652