home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_2.iso / files / 712b.lha / Struct-Saver_v1.20 / save_structs.c < prev    next >
C/C++ Source or Header  |  1992-11-21  |  22KB  |  942 lines
  1. #include "Struct-Saver.h"
  2.  
  3. /********** externals **********/
  4.  
  5. extern struct config config;
  6. extern FILE *fhd;
  7.  
  8. /********** Variablen, Daten, etc. **********/
  9.  
  10. char *null_str = "NULL";
  11. char buf_str[256], name_str[50], line_str[1024];
  12.  
  13. int menuitem_cnt = 0, subitem_cnt = 0;
  14.  
  15. struct str_node *first_str = NULL;
  16.  
  17. static struct list textattr_list = {NULL, "font", "struct TextAttr", "", 0};
  18. static struct list intuitext_list = {NULL, "text", "struct IntuiText", "", 0};
  19. static struct list border_data_list = {NULL, "border_data", "WORD", "[]", 0};
  20. static struct list border_list = {NULL, "border", "struct Border", "", 0};
  21. static struct list image_data_list = {NULL, "image_data", "UWORD", "[]", 0};
  22. static struct list image_list = {NULL, "image", "struct Image", "", 0};
  23. static struct list menuitem_list = {NULL, NULL, "struct MenuItem", "", 0};
  24. static struct list menu_list = {NULL, "menu", "struct Menu", "", 0};
  25. static struct list gad_boolinfo_list = {NULL, "boolinfo", "struct BoolInfo", "", 0};
  26. static struct list gad_propinfo_list = {NULL, "propinfo", "struct PropInfo", "", 0};
  27. static struct list gad_si_buffer_list = {NULL, "string", "UBYTE", "[]", 0};
  28. static struct list gad_stringinfo_list = {NULL, "stringinfo", "struct StringInfo", "", 0};
  29. static struct list gadget_list = {NULL, "gadget", "struct Gadget", "", 0};
  30.  
  31. static struct def_struct ta_flags_defs[] =
  32. {  {0x01, "FPF_ROMFONT"}, {0x02, "FPF_DISKFONT"}, {0x04, "FPF_REVPATH"},
  33.    {0x08, "FPF_TALLDOT"}, {0x10, "FPF_WIDEDOT"}, {0x20, "FPF_PROPORTIONAL"},
  34.    {0x40, "FPF_DESIGNED"}, {~0, NULL}
  35. };
  36. static struct def_struct ta_style_defs[] =
  37. {  {0, "FS_NORMAL"}, {0x01, "FSF_UNDERLINED"}, {0x02, "FSF_BOLD"},
  38.    {0x04, "FSF_ITALIC"}, {0x08, "FSF_EXTENDED"}, {~0, NULL}
  39. };
  40. static struct def_struct drawmode_defs[] =
  41. {  {0xf001, "JAM1"}, {1, "JAM2"}, {2, "COMPLEMENT"}, {4, "INVERSVID"},
  42.    {~0, NULL}
  43. };
  44. static struct def_struct mi_flags_defs[] =
  45. {  {0x0001, "CHECKIT"}, {0x0002, "ITEMTEXT"}, {0x0004, "COMMSEQ"},
  46.    {0x0008, "MENUTOGGLE"}, {0x0010, "ITEMENABLED"}, {0x00C0, "HIGHNONE"},
  47.    {0x0040, "HIGHCOMP"}, {0x0080, "HIGHBOX"}, {0x0100, "CHECKED"}, {~0, NULL}
  48. };
  49. static struct def_struct m_flags_defs[] =
  50. {  {0x0001, "MENUENABLED"}, {~0, NULL}
  51. };
  52. static struct def_struct gad_bi_flags_defs[] =
  53. {  {0x0001, "BOOLMASK"}, {~0, NULL}
  54. };
  55. static struct def_struct gad_pi_flags_defs[] =
  56. {  {0x0001, "AUTOKNOB"}, {0x0002, "FREEHORIZ"}, {0x0004, "FREEVERT"},
  57.    {0x0008, "PROPBORDERLESS"}, {0x0010, "PROPNEWLOOK"}, {~0, NULL}
  58. };
  59. static struct def_struct gad_flags_defs[] =
  60. {  {0xf003, "GADGHCOMP"}, {0x0003, "GADGHNONE"}, {0x0001, "GADGHBOX"},
  61.    {0x0002, "GADGHIMAGE"}, {0x0004, "GADGIMAGE"}, {0x0008, "GRELBOTTOM"},
  62.    {0x0010, "GRELRIGHT"}, {0x0020, "GRELWIDTH"}, {0x0040, "GRELHEIGHT"},
  63.    {0x0080, "SELECTED"}, {0x0100, "GADGDISABLED"}, {~0, NULL}
  64. };
  65. static struct def_struct gad_activation_defs[] =
  66. {  {0x0001, "RELVERIFY"}, {0x0002, "GADGIMMEDIATE"}, {0x0004, "ENDGADGET"},
  67.    {0x0008, "FOLLOWMOUSE"}, {0x0010, "RIGHTBORDER"}, {0x0020, "LEFTBORDER"},
  68.    {0x0040, "TOPBORDER"}, {0x0080, "BOTTOMBORDER"}, {0x0100, "TOGGLESELECT"},
  69.    {0x0200, "STRINGCENTER"}, {0x0400, "STRINGRIGHT"}, {0x0800, "LONGINT"},
  70.    {0x1000, "ALTKEYMAP"}, {0x2000, "BOOLEXTEND"}, {~0, NULL}
  71. };
  72. static struct def_struct gad_gadgettype_defs[] =
  73. {  {0x0003, "PROPGADGET"}, {0x0001, "BOOLGADGET"}, {0x0004, "STRGADGET"},
  74.    {0x1000, "REQGADGET"}, {0x2000, "GZZGADGET"}, {0x8000, "SYSGADGET"},
  75.    {~0, NULL}
  76. };
  77.  
  78. /********** Routinen **********/
  79.  
  80. STRPTR copy_str(char *s)
  81. /* return ptr to copy of s */
  82. {
  83.    struct str_node *n;
  84.  
  85.    if (n = malloc(sizeof(struct str_node) + strlen(s)))
  86.    {
  87.       n->next = first_str;
  88.       first_str = n;
  89.       strcpy(n->str, s);
  90.       return(n->str);
  91.    }
  92.    else
  93.    {
  94.       TITLE("Out of memory!");
  95.       return(null_str);
  96.    }
  97. }
  98.  
  99.  
  100. void free_strings(void)
  101. /* free all strings */
  102. {
  103.    struct str_node *n = first_str, *next;
  104.  
  105.    while (n)
  106.    {
  107.       next = n->next;
  108.       free(n);
  109.       n = next;
  110.    }
  111.    first_str = NULL;
  112. }
  113.  
  114.  
  115. void free_list(struct list *list)
  116. /* free all nodes of list */
  117. {
  118.    struct node *n = list->head, *next;
  119.  
  120.    while (n)
  121.    {
  122.       next = n->next;
  123.       free(n);
  124.       n = next;
  125.    }
  126.    list->head = NULL;
  127.    list->cnt = 0;
  128. }
  129.  
  130.  
  131. void free_lists(void)
  132. /* free all lists */
  133. {
  134.    free_list(&textattr_list);
  135.    free_list(&intuitext_list);
  136.    free_list(&border_data_list);
  137.    free_list(&border_list);
  138.    free_list(&image_data_list);
  139.    free_list(&image_list);
  140.    free_list(&menuitem_list);
  141.    menuitem_cnt = subitem_cnt = 0;
  142.    free_list(&menu_list);
  143.    free_list(&gad_boolinfo_list);
  144.    free_list(&gad_propinfo_list);
  145.    free_list(&gad_si_buffer_list);
  146.    free_list(&gad_stringinfo_list);
  147.    free_list(&gadget_list);
  148. }
  149.  
  150.  
  151. void add_node(struct list *list, APTR ptr)
  152. /* add node to list */
  153. {
  154.    struct node *n;
  155.    char str[20];
  156.  
  157.    list->cnt++;
  158.    sprintf(str, "%s_%d", list->str, list->cnt);
  159.    sprintf(name_str, "%s %s_%d%s =", list->prefix, list->str, list->cnt, list->suffix);
  160.  
  161.    if (n = malloc(sizeof(struct node) + strlen(str)))
  162.    {
  163.       n->next = list->head;
  164.       list->head = n;
  165.       n->ptr = ptr;
  166.       strcpy(n->str, str);
  167.    }
  168.    else
  169.       TITLE("Out of memory!");
  170. }
  171.  
  172.  
  173. STRPTR find_name(struct list *list, APTR ptr, BOOL aptr_flag)
  174. /* search for ptr in list, found => str, else => null_str */
  175. {
  176.    struct node *n = list->head;
  177.  
  178.    while (n)
  179.    {
  180.       if (n->ptr == ptr)
  181.      break;
  182.       n = n->next;
  183.    }
  184.    if (n)
  185.    {
  186.       if (aptr_flag)
  187.      sprintf(buf_str, "(APTR)(&%s)", n->str);
  188.       else
  189.      sprintf(buf_str, "&%s", n->str);
  190.       return(copy_str(buf_str));
  191.    }
  192.    else
  193.       return(null_str);
  194. }
  195.  
  196.  
  197. BOOL check_exist(struct list *list, APTR ptr)
  198. /* search for ptr in list, found => TRUE, else => FALSE */
  199. {
  200.    struct node *n = list->head;
  201.  
  202.    while (n)
  203.    {
  204.       if (n->ptr == ptr)
  205.      return(TRUE);
  206.       n = n->next;
  207.    }
  208.    return(FALSE);
  209. }
  210.  
  211.  
  212. void do_define(struct def_struct defs[], UWORD flags, int len)
  213. {
  214.    int i;
  215.    UWORD not_f;
  216.    BOOL first_fl = FALSE, print;
  217.    char str[40];
  218.  
  219.    if (config.use_defines)
  220.    {
  221.       buf_str[0] = 0;
  222.       if ((flags == 0) && ((defs[0].flag & 0xf000) != 0xf000))
  223.       {
  224.      if (defs[0].flag == 0)
  225.         sprintf(buf_str, defs[0].str);
  226.      else
  227.      {
  228.         if (len == 0)
  229.            sprintf(buf_str, "NULL");
  230.         else
  231.            sprintf(buf_str, "0x%0*x", len, flags);
  232.      }
  233.       }
  234.       else
  235.       {
  236.      for (i = 0; defs[i].flag != ~0; i++)
  237.      {
  238.         print = FALSE;
  239.  
  240.         if ((defs[i].flag & 0xf000) == 0xf000)
  241.         {
  242.            if (!((defs[i].flag & 0x0fff) & flags))
  243.            {
  244.           not_f = defs[i].flag & 0x0fff;
  245.           print = TRUE;
  246.            }
  247.         }
  248.         else
  249.            if ((flags & defs[i].flag) == defs[i].flag)
  250.            {
  251.           not_f = ~defs[i].flag;
  252.           print = TRUE;
  253.            }
  254.  
  255.         if (print)
  256.         {
  257.            flags &= not_f;
  258.            if (first_fl)
  259.           sprintf(str, " | %s", defs[i].str);
  260.            else
  261.            {
  262.           sprintf(str, "%s", defs[i].str);
  263.           first_fl = TRUE;
  264.            }
  265.            strcat(buf_str, str);
  266.         } /* if () */
  267.      } /* for (i) */
  268.       }
  269.  
  270.       if (buf_str[0] == 0)
  271.      sprintf(buf_str, "0x%x", flags);
  272.    }
  273.    else
  274.    {
  275.       if (len == 0)
  276.      sprintf(buf_str, "NULL");
  277.       else
  278.      sprintf(buf_str, "0x%0*x", len, flags);
  279.    }
  280. }
  281.  
  282.  
  283. void save_line(void)
  284. {
  285.    int i, old_i, todo = strlen(line_str);
  286.    char *ptr = line_str;
  287.  
  288.    fprintf(fhd, name_str);
  289.  
  290.    if (config.expanded)
  291.    {
  292.       fprintf(fhd, "\n{\n   ");
  293.  
  294.       i = 0;
  295.       while (i < todo)
  296.       {
  297.      while ((ptr[i] != '~') && (i < todo))
  298.         i++;
  299.      ptr[i] = 0;
  300.      fprintf(fhd, ptr);
  301.      if (i < todo)
  302.         fprintf(fhd, "\n   ");
  303.      i++;
  304.      ptr += i;
  305.      todo -= i;
  306.      i = 0;
  307.       }
  308.  
  309.       fprintf(fhd, "\n};\n\n");
  310.    }
  311.    else
  312.    {
  313.       for (i = 0; i < todo; i++)       /* remove tildes */
  314.      if (ptr[i] == '~')
  315.         ptr[i] = ' ';
  316.  
  317.       fprintf(fhd, " {");
  318.       i = MIN(config.line_length - strlen(name_str) - 3, todo);
  319.  
  320.       while (i < todo)
  321.       {
  322.      old_i = i;
  323.      while ((ptr[i] != ',') && (i > 0))  /* find comma */
  324.         i--;
  325.      if (i == 0)
  326.      {
  327.         i = old_i;
  328.         while ((ptr[i] != ',') && (i < todo))
  329.            i++;
  330.      }
  331.      ptr[i] = 0;               /* save up to comma */
  332.      fprintf(fhd, "%s,\n   ", ptr);
  333.  
  334.      i++;                   /* skip comma and */
  335.      if (ptr[i] == ' ')            /* space */
  336.         i++;
  337.      ptr += i;               /* do it for the rest of the string */
  338.      todo -= i;
  339.      i = MIN(config.line_length - 4, todo);
  340.       } /* while () */
  341.  
  342.       fprintf(fhd, "%s};\n", ptr);
  343.    } /* if (expanded) */
  344.  
  345.    free_strings();
  346. }
  347.  
  348. /********** get_ - Routinen **********/
  349.  
  350. STRPTR get_pointer(APTR p)
  351. {
  352.    if (!p)
  353.       return(null_str);
  354.    else
  355.    {
  356.       sprintf(buf_str, "%08x", (ULONG)p);
  357.       return(copy_str(buf_str));
  358.    }
  359. }
  360.  
  361. STRPTR get_string(UBYTE *s)
  362. {
  363.    if (s)
  364.    {
  365.       sprintf(buf_str, "\"%s\"", s);
  366.       return(copy_str(buf_str));
  367.    }
  368.    else
  369.       return(null_str);
  370. }
  371.  
  372. /***** TextAttr *****/
  373.  
  374. STRPTR get_ta_style(UBYTE s)
  375. {
  376.    do_define(ta_style_defs, (UWORD)s, 2);
  377.    return(copy_str(buf_str));
  378. }
  379.  
  380. STRPTR get_ta_flags(UBYTE f)
  381. {
  382.    do_define(ta_flags_defs, (UWORD)f, 2);
  383.    return(copy_str(buf_str));
  384. }
  385.  
  386. /***** DrawMode *****/
  387.  
  388. STRPTR get_drawmode(UBYTE dm)
  389. {
  390.    do_define(drawmode_defs, (UWORD)dm, 2);
  391.    return(copy_str(buf_str));
  392. }
  393.  
  394. /***** IntuiText *****/
  395.  
  396. STRPTR get_it_font(struct TextAttr *ta)
  397. {
  398.    return(find_name(&textattr_list, (APTR)ta, FALSE));
  399. }
  400.  
  401. STRPTR get_it_next(struct IntuiText *it)
  402. {
  403.    return(find_name(&intuitext_list, (APTR)it, FALSE));
  404. }
  405.  
  406. /***** Border *****/
  407.  
  408. STRPTR get_bo_xy(WORD *xy)
  409. {
  410.    return(find_name(&border_data_list, (APTR)xy, FALSE));
  411. }
  412.  
  413. STRPTR get_bo_next(struct Border *bo)
  414. {
  415.    return(find_name(&border_list, (APTR)bo, FALSE));
  416. }
  417.  
  418. /***** Image *****/
  419.  
  420. STRPTR get_im_data(UWORD *data)
  421. {
  422.    return(find_name(&image_data_list, (APTR)data, FALSE));
  423. }
  424.  
  425. STRPTR get_im_next(struct Image *im)
  426. {
  427.    return(find_name(&image_list, (APTR)im, FALSE));
  428. }
  429.  
  430. /***** MenuItem *****/
  431.  
  432. STRPTR get_mi_next(struct MenuItem *mi)
  433. {
  434.    return(find_name(&menuitem_list, (APTR)mi, FALSE));
  435. }
  436.  
  437. STRPTR get_mi_flags(UWORD f)
  438. {
  439.    do_define(mi_flags_defs, f, 4);
  440.    return(copy_str(buf_str));
  441. }
  442.  
  443. STRPTR get_mi_itemfill(APTR itf, struct MenuItem *mi)
  444. {
  445.    if (mi->Flags & ITEMTEXT)
  446.       return(find_name(&intuitext_list, (APTR)itf, TRUE));
  447.    else
  448.       return(find_name(&image_list, (APTR)itf, TRUE));
  449. }
  450.  
  451. STRPTR get_mi_selectfill(APTR sf, struct MenuItem *mi)
  452. {
  453.    if (mi->Flags & ITEMTEXT)
  454.       return(find_name(&intuitext_list, (APTR)sf, TRUE));
  455.    else
  456.       return(find_name(&image_list, (APTR)sf, TRUE));
  457. }
  458.  
  459. STRPTR get_mi_command(UBYTE c)
  460. {
  461.    if ((c >= ' ') && (c <= '~'))
  462.       sprintf(buf_str, "'%c'", c);
  463.    else
  464.       sprintf(buf_str, "0x%02x", (unsigned int)c);
  465.  
  466.    return(copy_str(buf_str));
  467. }
  468.  
  469. STRPTR get_mi_subitem(struct MenuItem *si)
  470. {
  471.    return(find_name(&menuitem_list, (APTR)si, FALSE));
  472. }
  473.  
  474. STRPTR get_mi_nextselect(UWORD ns)
  475. {
  476.    if (config.use_defines)
  477.       return("MENUNULL");
  478.    else
  479.       return("0xFFFF");
  480. }
  481.  
  482. /***** Menu *****/
  483.  
  484. STRPTR get_m_next(struct Menu *m)
  485. {
  486.    return(find_name(&menu_list, (APTR)m, FALSE));
  487. }
  488.  
  489. STRPTR get_m_flags(UWORD f)
  490. {
  491.    do_define(m_flags_defs, f, 4);
  492.    return(copy_str(buf_str));
  493. }
  494.  
  495. STRPTR get_m_firstitem(struct MenuItem *mi)
  496. {
  497.    return(find_name(&menuitem_list, (APTR)mi, FALSE));
  498. }
  499.  
  500. /***** BoolInfo *****/
  501.  
  502. STRPTR get_gad_bi_flags(UWORD f)
  503. {
  504.    do_define(gad_bi_flags_defs, f, 4);
  505.    return(copy_str(buf_str));
  506. }
  507.  
  508. /***** PropInfo *****/
  509.  
  510. STRPTR get_gad_pi_flags(UWORD f)
  511. {
  512.    do_define(gad_pi_flags_defs, f, 4);
  513.    return(copy_str(buf_str));
  514. }
  515.  
  516. /***** StringInfo *****/
  517.  
  518. STRPTR get_gad_si_buffer(UBYTE *s)
  519. {
  520.    return(find_name(&gad_si_buffer_list, (APTR)s, FALSE));
  521. }
  522.  
  523. STRPTR get_gad_si_altkeymap(struct Keymap *km)
  524. {
  525.    /* not implemented yet */
  526.    return(null_str);
  527. }
  528.  
  529. /***** Gadget *****/
  530.  
  531. STRPTR get_gad_next(struct Gadget *gad)
  532. {
  533.    return(find_name(&gadget_list, (APTR)gad, FALSE));
  534. }
  535.  
  536. STRPTR get_gad_flags(UWORD f)
  537. {
  538.    do_define(gad_flags_defs, f, 4);
  539.    return(copy_str(buf_str));
  540. }
  541.  
  542. STRPTR get_gad_activation(UWORD a)
  543. {
  544.    do_define(gad_activation_defs, a, 4);
  545.    return(copy_str(buf_str));
  546. }
  547.  
  548. STRPTR get_gad_gadgettype(UWORD t)
  549. {
  550.    do_define(gad_gadgettype_defs, t, 4);
  551.    return(copy_str(buf_str));
  552. }
  553.  
  554. STRPTR get_gad_gadgetrender(APTR gr, struct Gadget *gad)
  555. {
  556.    if (gad->Flags & GFLG_GADGIMAGE)
  557.       return(find_name(&image_list, (APTR)gr, TRUE));
  558.    else
  559.       return(find_name(&border_list, (APTR)gr, TRUE));
  560. }
  561.  
  562. STRPTR get_gad_selectrender(APTR sr, struct Gadget *gad)
  563. {
  564.    if (gad->Flags & GFLG_GADGIMAGE)
  565.       return(find_name(&image_list, (APTR)sr, TRUE));
  566.    else
  567.       return(find_name(&border_list, (APTR)sr, TRUE));
  568. }
  569.  
  570. STRPTR get_gad_text(struct IntuiText *it)
  571. {
  572.    return(find_name(&intuitext_list, (APTR)it, FALSE));
  573. }
  574.  
  575. STRPTR get_gad_specialinfo(APTR si, struct Gadget *gad)
  576. {
  577.    if (gad->GadgetType & GTYP_BOOLGADGET)
  578.       return(find_name(&gad_boolinfo_list, (APTR)si, TRUE));
  579.    else if (gad->GadgetType & GTYP_PROPGADGET)
  580.       return(find_name(&gad_propinfo_list, (APTR)si, TRUE));
  581.    else if (gad->GadgetType & GTYP_STRGADGET)
  582.       return(find_name(&gad_stringinfo_list, (APTR)si, TRUE));
  583.    else                 /* other type??? */
  584.       return("unknown");
  585. }
  586.  
  587. /********** _name - Routinen **********/
  588.  
  589. void textattr_name(struct TextAttr *ta)
  590. {
  591.    add_node(&textattr_list, (APTR)ta);
  592. }
  593.  
  594.  
  595. void intuitext_name(struct IntuiText *it)
  596. {
  597.    add_node(&intuitext_list, (APTR)it);
  598. }
  599.  
  600.  
  601. void border_data_name(WORD *bd)
  602. {
  603.    add_node(&border_data_list, (APTR)bd);
  604.    fprintf(fhd, name_str);
  605. }
  606.  
  607.  
  608. void border_name(struct Border *bo)
  609. {
  610.    add_node(&border_list, (APTR)bo);
  611. }
  612.  
  613.  
  614. void image_data_name(UWORD *id)
  615. {
  616.    add_node(&image_data_list, (APTR)id);
  617.    fprintf(fhd, name_str);
  618. }
  619.  
  620.  
  621. void image_name(struct Image *im)
  622. {
  623.    add_node(&image_list, (APTR)im);
  624. }
  625.  
  626.  
  627. void menuitem_name(struct MenuItem *mi, BOOL subitem)
  628. {
  629.    if (subitem)
  630.    {
  631.       menuitem_list.str = "subitem";
  632.       menuitem_list.cnt = subitem_cnt;
  633.    }
  634.    else
  635.    {
  636.       menuitem_list.str = "item";
  637.       menuitem_list.cnt = menuitem_cnt;
  638.    }
  639.    add_node(&menuitem_list, (APTR)mi);
  640.    if (subitem)
  641.       subitem_cnt = menuitem_list.cnt;
  642.    else
  643.       menuitem_cnt = menuitem_list.cnt;
  644. }
  645.  
  646.  
  647. void menu_name(struct Menu *m)
  648. {
  649.    add_node(&menu_list, (APTR)m);
  650. }
  651.  
  652.  
  653. void gad_boolinfo_name(struct BoolInfo *bi)
  654. {
  655.    add_node(&gad_boolinfo_list, (APTR)bi);
  656. }
  657.  
  658.  
  659. void gad_propinfo_name(struct PopInfo *pi)
  660. {
  661.    add_node(&gad_propinfo_list, (APTR)pi);
  662. }
  663.  
  664.  
  665. void gad_si_buffer_name(UBYTE *buf)
  666. {
  667.    add_node(&gad_si_buffer_list, (APTR)buf);
  668.    fprintf(fhd, name_str);
  669. }
  670.  
  671.  
  672. void gad_stringinfo_name(struct StringInfo *si)
  673. {
  674.    add_node(&gad_stringinfo_list, (APTR)si);
  675. }
  676.  
  677.  
  678. void gadget_name(struct Gadget *gad)
  679. {
  680.    add_node(&gadget_list, (APTR)gad);
  681. }
  682.  
  683. /********** save_ - Routinen **********/
  684.  
  685. /***** Text *****/
  686.  
  687. void save_textattr(struct TextAttr *ta)
  688. {
  689.    if (!ta || (ULONG)ta & 1) return;            /* security check */
  690.    if (check_exist(&textattr_list, (APTR)ta)) return;
  691.  
  692.    textattr_name(ta);
  693.    sprintf(line_str, "\"%s\", %d,~%s,~%s",
  694.      ta->ta_Name, ta->ta_YSize, get_ta_style(ta->ta_Style),
  695.      get_ta_flags(ta->ta_Flags));
  696.    save_line();
  697. }
  698.  
  699.  
  700. void save_intuitext(struct IntuiText *it)
  701. {
  702.    if (!it || (ULONG)it & 1) return;            /* security check */
  703.    if (check_exist(&intuitext_list, (APTR)it)) return;
  704.  
  705.    if (it->NextText) save_intuitext(it->NextText);
  706.    if (it->ITextFont) save_textattr(it->ITextFont);
  707.    intuitext_name(it);
  708.    sprintf(line_str, "%d,%d, %s, %d,%d,~%s,~%s,~%s",
  709.      it->FrontPen, it->BackPen, get_drawmode(it->DrawMode),
  710.      it->LeftEdge, it->TopEdge, get_it_font(it->ITextFont),
  711.      get_string(it->IText), get_it_next(it->NextText));
  712.    save_line();
  713. }
  714.  
  715. /***** Border *****/
  716.  
  717. void save_border_data(WORD *bd, int n)
  718. {
  719.    int i;
  720.  
  721.    if (!bd || (ULONG)bd & 1) return;            /* security check */
  722.    if (check_exist(&border_data_list, (APTR)bd)) return;
  723.  
  724.    border_data_name(bd);
  725.    fprintf(fhd, " {");
  726.    for (i = 0; i < n; i++, bd += 2)
  727.    {
  728.       fprintf(fhd, "%d,%d", *bd, *(bd+1));
  729.       if (i < n-1)
  730.      fprintf(fhd, ", ");
  731.    }
  732.    fprintf(fhd, "};\n");
  733. }
  734.  
  735.  
  736. void save_border(struct Border *bo)
  737. {
  738.    if (!bo || (ULONG)bo & 1) return;            /* security check */
  739.    if (check_exist(&border_list, (APTR)bo)) return;
  740.  
  741.    if (bo->NextBorder) save_border(bo->NextBorder);
  742.    if (bo->XY) save_border_data(bo->XY, (int)bo->Count);
  743.    border_name(bo);
  744.    sprintf(line_str, "%d,%d, %d,%d, %s,~%d, %s,~%s",
  745.      bo->LeftEdge, bo->TopEdge, bo->FrontPen, bo->BackPen,
  746.      get_drawmode(bo->DrawMode), bo->Count, get_bo_xy(bo->XY),
  747.      get_bo_next(bo->NextBorder));
  748.    save_line();
  749. }
  750.  
  751. /***** Image *****/
  752.  
  753. void save_image_data(UWORD *id, WORD w, WORD h, WORD d)
  754. {
  755.    int i,j;
  756.  
  757. if (d > 6) d = 6;
  758.  
  759.    if (!id || (ULONG)id & 1) return;            /* security check */
  760.    if (check_exist(&image_data_list, (APTR)id)) return;
  761.  
  762.    image_data_name(id);
  763.    fprintf(fhd, "\n{");
  764.    for (i = 0; i < d; i++)
  765.    {
  766.       for (j = 0; j < (w+15)/16*h; j++, id++)
  767.       {
  768.      if (j % 8 == 0)                  /* 8 Zahlen pro Zeile */
  769.         fprintf(fhd, "\n   ");
  770.      fprintf(fhd, "0x%04x, ", *id);
  771.       }
  772.       fprintf(fhd, "\n");
  773.    } /* for (i) */
  774.    fprintf(fhd, "};\n");
  775. }
  776.  
  777.  
  778. void save_image(struct Image *im)
  779. {
  780.    if (!im || (ULONG)im & 1) return;            /* security check */
  781.    if (check_exist(&image_list, (APTR)im)) return;
  782.  
  783.    if (im->NextImage) save_image(im->NextImage);
  784.    if (im->ImageData) save_image_data(im->ImageData, im->Width, im->Height, im->Depth);
  785.    image_name(im);
  786.    sprintf(line_str, "%d,%d, %d,%d, %d,~%s,~0x%02x, 0x%02x,~%s",
  787.      im->LeftEdge, im->TopEdge, im->Width, im->Height, im->Depth,
  788.      get_im_data(im->ImageData), (unsigned int)im->PlanePick,
  789.      (unsigned int)im->PlaneOnOff, get_im_next(im->NextImage));
  790.    save_line();
  791. }
  792.  
  793. /***** Menu *****/
  794.  
  795. void save_menuitem(struct MenuItem *mi, BOOL subitem)
  796. {
  797.    if (!mi || (ULONG)mi & 1) return;            /* security check */
  798.  
  799.    if (mi->NextItem) save_menuitem(mi->NextItem, subitem);
  800.    if (mi->SubItem) save_menuitem(mi->SubItem, TRUE);
  801.    if (mi->ItemFill)
  802.    {
  803.       if (mi->Flags & ITEMTEXT)
  804.      save_intuitext((struct IntuiText *)mi->ItemFill);
  805.       else
  806.      save_image((struct Image *)mi->ItemFill);
  807.    }
  808.    if (mi->SelectFill)
  809.    {
  810.       if (mi->Flags & ITEMTEXT)
  811.      save_intuitext((struct IntuiText *)mi->ItemFill);
  812.       else
  813.      save_image((struct Image *)mi->ItemFill);
  814.    }
  815.    menuitem_name(mi, subitem);
  816.    sprintf(line_str, "%s,~%d,%d, %d,%d,~%s,~0x%08x,~%s, %s,~%s, %s, %s",
  817.      get_mi_next(mi->NextItem), mi->LeftEdge, mi->TopEdge, mi->Width,
  818.      mi->Height, get_mi_flags(mi->Flags), mi->MutualExclude,
  819.      get_mi_itemfill(mi->ItemFill, mi),
  820.      get_mi_selectfill(mi->SelectFill, mi),
  821.      get_mi_command(mi->Command), get_mi_subitem(mi->SubItem),
  822.      get_mi_nextselect(mi->NextSelect));
  823.    save_line();
  824. }
  825.  
  826.  
  827. void save_menu(struct Menu *m)
  828. {
  829.    if (!m || (ULONG)m & 1) return;              /* security check */
  830.  
  831.    if (m->NextMenu) save_menu(m->NextMenu);
  832.    if (m->FirstItem) save_menuitem(m->FirstItem, FALSE);
  833.    menu_name(m);
  834.    sprintf(line_str, "%s,~%d,%d, %d,%d,~%s,~%s,~%s, 0,0,0,0",
  835.      get_m_next(m->NextMenu), m->LeftEdge, m->TopEdge, m->Width,
  836.      m->Height, get_m_flags(m->Flags), get_string(m->MenuName),
  837.      get_m_firstitem(m->FirstItem));
  838.    save_line();
  839. }
  840.  
  841. /***** Gadget *****/
  842.  
  843. void save_gad_boolinfo(struct BoolInfo *bi, struct Gadget *gad)
  844. {
  845.    if (!bi || (ULONG)bi & 1) return;            /* security check */
  846.  
  847.    if (bi->Mask) save_image_data(bi->Mask, gad->Width, gad->Height, 1);
  848.    gad_boolinfo_name(bi);
  849.    sprintf(line_str, "%s,~%s, 0",
  850.      get_gad_bi_flags(bi->Flags), get_im_data(bi->Mask));
  851.    save_line();
  852. }
  853.  
  854.  
  855. void save_gad_propinfo(struct PropInfo *pi)
  856. {
  857.    if (!pi || (ULONG)pi & 1) return;            /* security check */
  858.  
  859.    gad_propinfo_name(pi);
  860.    sprintf(line_str, "%s,~0x%04x,0x%04x, 0x%04x,0x%04x,~0,0,0,0,0,0",
  861.      get_gad_pi_flags(pi->Flags), pi->HorizPot, pi->VertPot,
  862.      pi->HorizBody, pi->VertBody);
  863.    save_line();
  864. }
  865.  
  866.  
  867. void save_gad_si_buffer(UBYTE *buf)
  868. {
  869.    if (!buf) return;
  870.  
  871.    gad_si_buffer_name(buf);
  872.    fprintf(fhd, " \"%s\";\n", buf);
  873. }
  874.  
  875.  
  876. void save_gad_si_altkeymap(struct KeyMap *keymap)
  877. {
  878.    if (!keymap || (ULONG)keymap & 1) return;
  879.    /* not implemented yet */
  880. }
  881.  
  882.  
  883. void save_gad_stringinfo(struct StringInfo *si)
  884. {
  885.    if (!si || (ULONG)si & 1) return;            /* security check */
  886.  
  887.    if (si->Buffer) save_gad_si_buffer(si->Buffer);
  888.    if (si->UndoBuffer) save_gad_si_buffer(si->UndoBuffer);
  889.    if (si->AltKeyMap) save_gad_si_altkeymap(si->AltKeyMap);
  890.    gad_stringinfo_name(si);
  891.    sprintf(line_str, "%s, %s,~%d, %d, %d,~0,0,0,0,0, NULL, 0, %s",
  892.      get_gad_si_buffer(si->Buffer),
  893.      get_gad_si_buffer(si->UndoBuffer), si->BufferPos, si->MaxChars,
  894.      si->DispPos, get_gad_si_altkeymap(si->AltKeyMap));
  895.    save_line();
  896. }
  897.  
  898.  
  899. void save_gadget(struct Gadget *gad)
  900. {
  901.    if (!gad || (ULONG)gad & 1) return;          /* security check */
  902.  
  903.    if (gad->NextGadget) save_gadget(gad->NextGadget);
  904.    if (gad->GadgetRender)
  905.    {
  906.       if (gad->Flags & GFLG_GADGIMAGE)
  907.      save_image((struct Image *)gad->GadgetRender);
  908.       else
  909.      save_border((struct Border *)gad->GadgetRender);
  910.    }
  911.    if (gad->SelectRender)
  912.    {
  913.       if (gad->Flags & GFLG_GADGIMAGE)
  914.      save_image((struct Image *)gad->SelectRender);
  915.       else
  916.      save_border((struct Border *)gad->SelectRender);
  917.    }
  918.    if (gad->GadgetText) save_intuitext(gad->GadgetText);
  919.    if (gad->SpecialInfo)
  920.    {
  921.       if (gad->GadgetType & GTYP_BOOLGADGET)
  922.      save_gad_boolinfo((struct BoolInfo *)gad->SpecialInfo, gad);
  923.       else if (gad->GadgetType & GTYP_PROPGADGET)
  924.      save_gad_propinfo((struct PropInfo *)gad->SpecialInfo);
  925.       else if (gad->GadgetType & GTYP_STRGADGET)
  926.      save_gad_stringinfo((struct StringInfo *)gad->SpecialInfo);
  927.    }
  928.    gadget_name(gad);
  929.    sprintf(line_str, "%s,~%d,%d, %d,%d,~%s,~%s,~%s,~%s, %s,~%s,~0x00000000,~%s,~%d, %s",
  930.      get_gad_next(gad->NextGadget), gad->LeftEdge, gad->TopEdge,
  931.      gad->Width, gad->Height, get_gad_flags(gad->Flags),
  932.      get_gad_activation(gad->Activation),
  933.      get_gad_gadgettype(gad->GadgetType),
  934.      get_gad_gadgetrender(gad->GadgetRender, gad),
  935.      get_gad_selectrender(gad->SelectRender, gad),
  936.      get_gad_text(gad->GadgetText),
  937.      get_gad_specialinfo(gad->SpecialInfo, gad),
  938.      gad->GadgetID, get_pointer(gad->UserData));
  939.    save_line();
  940. }
  941.  
  942.