home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 581a.lha / IntuitionSupLibrary_v2.0 / Editor / source.lzh / edit2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-25  |  16.2 KB  |  562 lines
  1.         /*************************************
  2.          *                                   *
  3.          *             Editor v1.0           *
  4.          *   by Torsten Jürgeleit in 08/91   *
  5.          *                                   *
  6.          *             Edit part 2           *
  7.          *                                   *
  8.          *************************************/
  9.  
  10.     /* Includes */
  11.  
  12. #include "includes.h"
  13. #include "defines.h"
  14. #include "imports.h"
  15. #include "protos.h"
  16.  
  17.     /* Defines */
  18.  
  19. #define EDIT_MODE_NORMAL    1
  20. #define EDIT_MODE_SPECIAL    2
  21.  
  22.     /* Defines */
  23.  
  24. #define EDIT_TITLE_LEFT_EDGE    0
  25. #define EDIT_TITLE_TOP_EDGE    5
  26. #define EDIT_TITLE_TYPE        TEXT_DATA_TYPE_TEXT
  27. #define EDIT_TITLE_FLAGS    (TEXT_DATA_FLAG_CENTER | TEXT_DATA_FLAG_BOLD)
  28. #define EDIT_TITLE_TEXT_ATTR    &topaz80_attr
  29.  
  30.     /* Edit template data */
  31.  
  32.    SHORT
  33. edit_template_data_action(struct Template  *old_tp, APTR normal_gl,
  34.                APTR special_gl1, APTR special_gl2, APTR edit_gl)
  35. {
  36.    struct TemplateList  *tl = &template_list;
  37.    struct Template      *pred_tp, *new_tp, *swap_tp;
  38.    struct MsgPort       *up = ewin->UserPort;
  39.    struct IntuiMessage  *msg;
  40.    APTR   gl;
  41.    BYTE   title[80];
  42.    USHORT entry, mode = EDIT_MODE_NORMAL, new_mode = EDIT_MODE_NORMAL;
  43.    ULONG  value;
  44.    BOOL   keepon, exit = FALSE;
  45.    SHORT  status = EDITOR_STATUS_NORMAL;
  46.  
  47.    /* Make clone of selected template and remove it from template list */
  48.    if (!(new_tp = clone_template(old_tp, TRUE))) {
  49.       status = EDITOR_ERROR_OUT_OF_MEM;
  50.    } else {
  51.       pred_tp = get_pred(&old_tp->tp_Node);   /* needed for Insert() */
  52.       Remove(&old_tp->tp_Node);
  53.  
  54.       /* Outer loop */
  55.       do {
  56.  
  57.      /* Init title text */
  58.      switch (TEMPLATE_GROUP(old_tp)) {
  59.         case TEMPLATE_GROUP_BORDER :
  60.            strcpy(&title[0], "Edit Border Data");
  61.            break;
  62.         case TEMPLATE_GROUP_TEXT :
  63.            strcpy(&title[0], "Edit Text Data");
  64.            break;
  65.         case TEMPLATE_GROUP_GADGET :
  66.            if (mode == EDIT_MODE_NORMAL) {
  67.           SPrintf(&title[0], "Edit normal %s Gadget Data",
  68.                  template_type_text_array[old_tp->tp_Type]);
  69.            } else {
  70.           SPrintf(&title[0], "Edit special %s Gadget Data",
  71.                  template_type_text_array[old_tp->tp_Type]);
  72.            }
  73.            break;
  74.      }
  75.  
  76.      /* Init edit display */
  77.      IClearRenderWindow(eri, ewin, 0, 0, -1, -1);
  78.      IPrintText(eri, ewin, &title[0], EDIT_TITLE_LEFT_EDGE,
  79.              EDIT_TITLE_TOP_EDGE, EDIT_TITLE_TYPE, EDIT_TITLE_FLAGS,
  80.                               EDIT_TITLE_TEXT_ATTR);
  81.      if (mode == EDIT_MODE_NORMAL) {
  82.         IDisplayGadgets(ewin, normal_gl);
  83.      } else {
  84.         if (special_gl1) {
  85.            ISetGadgetAttributes(special_gl1, 0, 0L, USE_CURRENT_VALUE,
  86.                    USE_CURRENT_VALUE, &new_tp->tp_TextList);
  87.            change_text_list_editor_mode(special_gl1, DEFAULT_LIST_MODE);
  88.            IDisplayGadgets(ewin, special_gl1);
  89.         }
  90.         if (special_gl2) {
  91.            IDisplayGadgets(ewin, special_gl2);
  92.         }
  93.      }
  94.      IDisplayGadgets(ewin, edit_gl);
  95.  
  96.      /* Inner loop */
  97.      keepon = TRUE;
  98.      do {
  99.         WaitPort(up);
  100.         while (msg = IGetMsg(up)) {
  101.            switch (msg->Class) {
  102.           case CLOSEWINDOW :
  103.              status = EDITOR_STATUS_QUIT;
  104.              keepon = FALSE;
  105.              exit   = TRUE;
  106.              break;
  107.           case ISUP_ID :
  108.              gl    = (APTR)msg->SpecialLink;
  109.              entry = msg->Code;
  110.              value = (ULONG)msg->IAddress;
  111.              if (gl == edit_gl) {
  112.  
  113.             /* Perform edit gadget action */
  114.             switch (entry) {
  115.                case EDIT_GADGET_OK :
  116.                   exit = TRUE;
  117.                   break;
  118.                case EDIT_GADGET_DEFAULT :
  119.                   free_template_data(new_tp);
  120.                   if ((status = init_default_template_data(new_tp,
  121.                        TRUE)) != EDITOR_STATUS_NORMAL) {
  122.                  swap_tp = old_tp;
  123.                  old_tp  = new_tp;
  124.                  new_tp  = swap_tp;
  125.                   } else {
  126.                  tl->tl_Flags |= TEMPLATE_LIST_FLAG_CHANGED;
  127.                   }
  128.                   exit = TRUE;
  129.                   break;
  130.                case EDIT_GADGET_SWITCH :
  131.                   if (mode == EDIT_MODE_NORMAL) {
  132.                  new_mode = EDIT_MODE_SPECIAL;
  133.                   } else {
  134.                  new_mode = EDIT_MODE_NORMAL;
  135.                   }
  136.                   break;
  137.                case EDIT_GADGET_CANCEL :
  138.                   swap_tp = old_tp;
  139.                   old_tp  = new_tp;
  140.                   new_tp  = swap_tp;
  141.                   exit    = TRUE;
  142.                   break;
  143.             }
  144.             keepon = FALSE;
  145.              } else {
  146.  
  147.             /* Perform data gadget action */
  148.             if (mode == EDIT_MODE_NORMAL) {
  149.                if ((status = change_normal_template_data(normal_gl,
  150.                            new_tp, entry, value)) !=
  151.                              EDITOR_STATUS_NORMAL) {
  152.                   keepon = FALSE;
  153.                   exit   = TRUE;
  154.                }
  155.             } else {
  156.                if (gl = special_gl1) {
  157.                   status = perform_text_list_editor_action(special_gl1,
  158.                               new_tp, entry, value);
  159.                } else {
  160.                   status = change_special_template_data(special_gl2,
  161.                               new_tp, entry, value);
  162.  
  163.                }
  164.                if (status != EDITOR_STATUS_NORMAL) {
  165.                   keepon = FALSE;
  166.                   exit   = TRUE;
  167.                }
  168.             }
  169.             tl->tl_Flags |= TEMPLATE_LIST_FLAG_CHANGED;
  170.              }
  171.              break;
  172.            }
  173.            IReplyMsg(msg);
  174.         }
  175.      } while (keepon == TRUE);
  176.  
  177.      IRemoveGadgets(edit_gl);
  178.      if (mode == EDIT_MODE_NORMAL) {
  179.         IRemoveGadgets(normal_gl);
  180.      } else {
  181.         if (special_gl1) {
  182.            IRemoveGadgets(special_gl1);
  183.         }
  184.         if (special_gl2) {
  185.            IRemoveGadgets(special_gl2);
  186.         }
  187.      }
  188.      if (new_mode != mode) {
  189.         mode = new_mode;
  190.      }
  191.       } while (exit == FALSE);
  192.  
  193.       /* Insert new template in list and free old one */
  194.       Insert(&tl->tl_List, &new_tp->tp_Node, &pred_tp->tp_Node);
  195.       ISetGadgetAttributes(egl, EDITOR_GADGET_TEMPLATES, 0L,
  196.             USE_CURRENT_VALUE, USE_CURRENT_VALUE, &tl->tl_List);
  197.       free_template(old_tp);
  198.       refresh_all_templates();
  199.    }
  200.    show_error(status);
  201.    MWCheck();
  202.    return(status);
  203. }
  204.     /* Change normal template data */
  205.  
  206.    SHORT
  207. change_normal_template_data(APTR gl, struct Template  *tp, USHORT entry,
  208.                                 ULONG value)
  209. {
  210.    struct Box         *box = &tp->tp_Box;
  211.    struct BorderData  *bd;
  212.    struct TextData    *td;
  213.    struct GadgetData  *gd;
  214.    struct TextFont    *tf;
  215.    BYTE   *old_text, buffer[40];
  216.    USHORT old_type, old_pos;
  217.    UWORD  old_size;
  218.    SHORT  status = EDITOR_STATUS_NORMAL;
  219.  
  220.    switch (TEMPLATE_GROUP(tp)) {
  221.       case TEMPLATE_GROUP_BORDER :
  222.      bd = &tp->tp_Data.tp_BorderData;
  223.      switch (entry) {
  224.         case BORDER_GADGET_NAME :
  225.            strcpy(&tp->tp_TemplateName[0], (BYTE *)value);
  226.            tp->tp_Flags &= ~TEMPLATE_FLAG_DEFAULT_NAME;
  227.            break;
  228.         case BORDER_GADGET_TYPE :
  229.            bd->bd_Type = value + 1;
  230.            break;
  231.      }
  232.      break;
  233.       case TEMPLATE_GROUP_TEXT :
  234.      gd = &text_gadget_data[TEXT_GADGET_TEXT];
  235.      td = &tp->tp_Data.tp_TextData;
  236.      switch (entry) {
  237.         case TEXT_GADGET_NAME :
  238.            strcpy(&tp->tp_TemplateName[0], (BYTE *)value);
  239.            tp->tp_Flags &= ~TEMPLATE_FLAG_DEFAULT_NAME;
  240.            break;
  241.         case TEXT_GADGET_TEXT :
  242.            if (td->td_Type == TEXT_DATA_TYPE_TEXT) {
  243.           old_text = td->td_Text;
  244.           if ((status = duplicate_string(&td->td_Text, (BYTE *)
  245.                       value)) != EDITOR_STATUS_NORMAL) {
  246.              td->td_Text = old_text;
  247.           } else {
  248.              DosFreeMem(old_text);
  249.           }
  250.            } else {
  251.           td->td_Text = (BYTE *)Atol((BYTE *)value);
  252.            }
  253.            ISetGadgetAttributes(gl, TEXT_GADGET_TEXT, 0L,
  254.              USE_CURRENT_VALUE, USE_CURRENT_VALUE, td->td_Text);
  255.            break;
  256.         case TEXT_GADGET_FONT :
  257.            old_text                = (BYTE *)tp->tp_TextAttr.ta_Name;
  258.            tp->tp_TextAttr.ta_Name = (STRPTR)value;
  259.            if (!(tf = open_font(&tp->tp_TextAttr))) {
  260.           DisplayBeep(NULL);
  261.           tp->tp_TextAttr.ta_Name = (STRPTR)old_text;
  262.           ISetGadgetAttributes(gl, TEXT_GADGET_FONT, 0L,
  263.                 USE_CURRENT_VALUE, USE_CURRENT_VALUE, old_text);
  264.            } else {
  265.           if ((status = duplicate_string((BYTE **)
  266.                 &tp->tp_TextAttr.ta_Name, (BYTE *)value)) !=
  267.                              EDITOR_STATUS_NORMAL) {
  268.              tp->tp_TextAttr.ta_Name = (STRPTR)old_text;
  269.           } else {
  270.              DosFreeMem(old_text);
  271.           }
  272.           if (tf->tf_YSize != tp->tp_TextAttr.ta_YSize) {
  273.              tp->tp_TextAttr.ta_YSize = tf->tf_YSize;
  274.              ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L,
  275.                        USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  276.                               (VOID *)tf->tf_YSize);
  277.           }
  278.           close_font(tf);
  279.            }
  280.            break;
  281.         case TEXT_GADGET_SIZE :
  282.            old_size                 = tp->tp_TextAttr.ta_YSize;
  283.            tp->tp_TextAttr.ta_YSize = value;
  284.            if (!(tf = open_font(&tp->tp_TextAttr))) {
  285.           DisplayBeep(NULL);
  286.           tp->tp_TextAttr.ta_YSize = old_size;
  287.           ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L,
  288.                        USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  289.                               (VOID *)old_size);
  290.            } else {
  291.           if (tf->tf_YSize != value) {
  292.              DisplayBeep(NULL);
  293.              tp->tp_TextAttr.ta_YSize = tf->tf_YSize;
  294.              ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L,
  295.                        USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  296.                               (VOID *)tf->tf_YSize);
  297.           }
  298.           close_font(tf);
  299.            }
  300.            break;
  301.         case TEXT_GADGET_TYPE :
  302.            old_type      = td->td_Type;
  303.            old_text      = td->td_Text;
  304.            td->td_Type   = value + 1;
  305.            gd->gd_Flags &= ~(GADGET_DATA_FLAG_STRING_UNSIGNED_DEC |
  306.                     GADGET_DATA_FLAG_STRING_SIGNED_DEC |
  307.                            GADGET_DATA_FLAG_STRING_HEX |
  308.                            GADGET_DATA_FLAG_STRING_BIN);
  309.            if (td->td_Type == TEXT_DATA_TYPE_TEXT) {
  310.           IConvertUnsignedDec((ULONG)old_text, &buffer[0]);
  311.           if ((status = duplicate_string(&td->td_Text, (BYTE *)
  312.                      &buffer[0])) != EDITOR_STATUS_NORMAL) {
  313.              td->td_Type = old_type;
  314.              td->td_Text = old_text;
  315.           }
  316.            } else {
  317.           switch (td->td_Type) {
  318.              case TEXT_DATA_TYPE_NUM_UNSIGNED_DEC :
  319.             gd->gd_Flags |= GADGET_DATA_FLAG_STRING_UNSIGNED_DEC;
  320.             break;
  321.              case TEXT_DATA_TYPE_NUM_SIGNED_DEC :
  322.             gd->gd_Flags |= GADGET_DATA_FLAG_STRING_SIGNED_DEC;
  323.             break;
  324.              case TEXT_DATA_TYPE_NUM_HEX :
  325.             gd->gd_Flags |= GADGET_DATA_FLAG_STRING_HEX;
  326.             break;
  327.              case TEXT_DATA_TYPE_NUM_BIN :
  328.             gd->gd_Flags |= GADGET_DATA_FLAG_STRING_BIN;
  329.             break;
  330.           }
  331.           if (old_type == TEXT_DATA_TYPE_TEXT) {
  332.              td->td_Text = (BYTE *)Atol(old_text);
  333.              DosFreeMem(old_text);
  334.           }
  335.            }
  336.            ISetGadgetAttributes(gl, TEXT_GADGET_TEXT, 0L,
  337.              USE_CURRENT_VALUE, USE_CURRENT_VALUE, td->td_Text);
  338.            break;
  339.         case TEXT_GADGET_BOLD :
  340.            if (value) {
  341.           td->td_Flags |= TEXT_DATA_FLAG_BOLD;
  342.            } else {
  343.           td->td_Flags &= ~TEXT_DATA_FLAG_BOLD;
  344.            }
  345.            break;
  346.         case TEXT_GADGET_ITALIC :
  347.            if (value) {
  348.           td->td_Flags |= TEXT_DATA_FLAG_ITALIC;
  349.            } else {
  350.           td->td_Flags &= ~TEXT_DATA_FLAG_ITALIC;
  351.            }
  352.            break;
  353.         case TEXT_GADGET_UNDERLINED :
  354.            if (value) {
  355.           td->td_Flags |= TEXT_DATA_FLAG_UNDERLINED;
  356.            } else {
  357.           td->td_Flags &= ~TEXT_DATA_FLAG_UNDERLINED;
  358.            }
  359.            break;
  360.         case TEXT_GADGET_COLOR2 :
  361.            if (value) {
  362.           td->td_Flags |= TEXT_DATA_FLAG_COLOR2;
  363.            } else {
  364.           td->td_Flags &= ~TEXT_DATA_FLAG_COLOR2;
  365.            }
  366.            break;
  367.         case TEXT_GADGET_COMPLEMENT :
  368.            if (value) {
  369.           td->td_Flags |= TEXT_DATA_FLAG_COMPLEMENT;
  370.            } else {
  371.           td->td_Flags &= ~TEXT_DATA_FLAG_COMPLEMENT;
  372.            }
  373.            break;
  374.      }
  375.  
  376.      /* Calc size of new text for template box */
  377.      box->bo_X2 = box->bo_X1 + IPrintText(pri, pwin, td->td_Text,
  378.                    td->td_LeftEdge, td->td_TopEdge, td->td_Type,
  379.                   TEXT_DATA_FLAG_NO_PRINT, td->td_TextAttr) - 1;
  380.      box->bo_Y2 = box->bo_Y1 + td->td_TextAttr->ta_YSize - 1;
  381.      break;
  382.       case TEMPLATE_GROUP_GADGET :
  383.      gd = &tp->tp_Data.tp_GadgetData;
  384.      switch (entry) {
  385.         case NORMAL_GADGET_NAME :
  386.            strcpy(&tp->tp_TemplateName[0], (BYTE *)value);
  387.            tp->tp_Flags &= ~TEMPLATE_FLAG_DEFAULT_NAME;
  388.            break;
  389.         case NORMAL_GADGET_TEXT :
  390.            old_text = gd->gd_Text;
  391.            if ((status = duplicate_string(&gd->gd_Text, (BYTE *)value))
  392.                           != EDITOR_STATUS_NORMAL) {
  393.           DisplayBeep(NULL);
  394.           gd->gd_Text = old_text;
  395.           ISetGadgetAttributes(gl, NORMAL_GADGET_TEXT, 0L,
  396.                 USE_CURRENT_VALUE, USE_CURRENT_VALUE, old_text);
  397.            } else {
  398.           DosFreeMem(old_text);
  399.            }
  400.            break;
  401.         case NORMAL_GADGET_FONT :
  402.            old_text                = (BYTE *)tp->tp_TextAttr.ta_Name;
  403.            tp->tp_TextAttr.ta_Name = (STRPTR)value;
  404.            if (!(tf = open_font(&tp->tp_TextAttr))) {
  405.           DisplayBeep(NULL);
  406.           tp->tp_TextAttr.ta_Name = (STRPTR)old_text;
  407.           ISetGadgetAttributes(gl, NORMAL_GADGET_FONT, 0L,
  408.                 USE_CURRENT_VALUE, USE_CURRENT_VALUE, old_text);
  409.            } else {
  410.           if ((status = duplicate_string((BYTE **)
  411.                 &tp->tp_TextAttr.ta_Name, (BYTE *)value)) !=
  412.                              EDITOR_STATUS_NORMAL) {
  413.              DisplayBeep(NULL);
  414.              tp->tp_TextAttr.ta_Name = (STRPTR)old_text;
  415.              ISetGadgetAttributes(gl, NORMAL_GADGET_FONT, 0L,
  416.                 USE_CURRENT_VALUE, USE_CURRENT_VALUE, old_text);
  417.           } else {
  418.              DosFreeMem(old_text);
  419.           }
  420.           if (tf->tf_YSize != tp->tp_TextAttr.ta_YSize) {
  421.              tp->tp_TextAttr.ta_YSize = tf->tf_YSize;
  422.              ISetGadgetAttributes(gl, NORMAL_GADGET_SIZE, 0L,
  423.                        USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  424.                               (VOID *)tf->tf_YSize);
  425.           }
  426.           close_font(tf);
  427.            }
  428.            break;
  429.         case NORMAL_GADGET_SIZE :
  430.            old_size                 = tp->tp_TextAttr.ta_YSize;
  431.            tp->tp_TextAttr.ta_YSize = value;
  432.            if (!(tf = open_font(&tp->tp_TextAttr))) {
  433.           DisplayBeep(NULL);
  434.           tp->tp_TextAttr.ta_YSize = old_size;
  435.           ISetGadgetAttributes(gl, NORMAL_GADGET_SIZE, 0L,
  436.                        USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  437.                               (VOID *)old_size);
  438.            } else {
  439.           if (tf->tf_YSize != value) {
  440.              DisplayBeep(NULL);
  441.              tp->tp_TextAttr.ta_YSize = tf->tf_YSize;
  442.              ISetGadgetAttributes(gl, NORMAL_GADGET_SIZE, 0L,
  443.                        USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  444.                               (VOID *)tf->tf_YSize);
  445.           }
  446.           close_font(tf);
  447.            }
  448.            break;
  449.         case NORMAL_GADGET_POS :
  450.            switch (GADGET_TEXT_POS_MASK(gd->gd_Flags)) {
  451.           case GADGET_DATA_FLAG_TEXT_LEFT :
  452.              old_pos = TEXT_POS_LEFT;
  453.              break;
  454.           case GADGET_DATA_FLAG_TEXT_RIGHT :
  455.              old_pos = TEXT_POS_RIGHT;
  456.              break;
  457.           case GADGET_DATA_FLAG_TEXT_ABOVE :
  458.              old_pos = TEXT_POS_ABOVE;
  459.              break;
  460.           case GADGET_DATA_FLAG_TEXT_BELOW :
  461.              old_pos = TEXT_POS_BELOW;
  462.              break;
  463.           default :
  464.              old_pos = TEXT_POS_INSIDE;
  465.              break;
  466.            }
  467.  
  468.            /* Check if text position possible for selected gadget type */
  469.            switch (gd->gd_Type) {
  470.           case GADGET_DATA_TYPE_MX :
  471.              if (value != TEXT_POS_LEFT && value != TEXT_POS_RIGHT) {
  472.             value = USE_CURRENT_VALUE;
  473.              }
  474.              break;
  475.           case GADGET_DATA_TYPE_LISTVIEW :
  476.           case GADGET_DATA_TYPE_PALETTE :
  477.              if (value != TEXT_POS_ABOVE) {
  478.             value = USE_CURRENT_VALUE;
  479.              }
  480.              break;
  481.           default :
  482.              break;
  483.            }
  484.            if (value == USE_CURRENT_VALUE) {
  485.           DisplayBeep(NULL);
  486.           ISetGadgetAttributes(gl, NORMAL_GADGET_POS, 0L,
  487.                       USE_CURRENT_VALUE, (ULONG)old_pos,
  488.                          (VOID *)USE_CURRENT_VALUE);
  489.            } else {
  490.           gd->gd_Flags &= ~(GADGET_DATA_FLAG_TEXT_LEFT |
  491.                            GADGET_DATA_FLAG_TEXT_RIGHT |
  492.                            GADGET_DATA_FLAG_TEXT_ABOVE |
  493.                            GADGET_DATA_FLAG_TEXT_BELOW);
  494.           switch (value) {
  495.              case TEXT_POS_LEFT :
  496.             gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_LEFT;
  497.             break;
  498.              case TEXT_POS_RIGHT :
  499.             gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_RIGHT;
  500.             break;
  501.              case TEXT_POS_ABOVE :
  502.             gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_ABOVE;
  503.             break;
  504.              case TEXT_POS_BELOW :
  505.             gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_BELOW;
  506.             break;
  507.              case TEXT_POS_INSIDE :
  508.             break;
  509.           }
  510.            }
  511.            break;
  512.         case NORMAL_GADGET_DISABLED :
  513.            if (value) {
  514.           gd->gd_Flags |= GADGET_DATA_FLAG_DISABLED;
  515.            } else {
  516.           gd->gd_Flags &= ~GADGET_DATA_FLAG_DISABLED;
  517.            }
  518.            break;
  519.         case NORMAL_GADGET_NO_BORDER :
  520.            if (value) {
  521.           gd->gd_Flags |= GADGET_DATA_FLAG_NO_BORDER;
  522.            } else {
  523.           gd->gd_Flags &= ~GADGET_DATA_FLAG_NO_BORDER;
  524.            }
  525.            break;
  526.         case NORMAL_GADGET_HIGHCOMP :
  527.            if (value) {
  528.           gd->gd_Flags |= GADGET_DATA_FLAG_HIGH_COMP;
  529.            } else {
  530.           gd->gd_Flags &= ~GADGET_DATA_FLAG_HIGH_COMP;
  531.            }
  532.            break;
  533.         case NORMAL_GADGET_HOTKEY :
  534.            if (value) {
  535.           gd->gd_Flags |= GADGET_DATA_FLAG_HOT_KEY;
  536.            } else {
  537.           gd->gd_Flags &= ~GADGET_DATA_FLAG_HOT_KEY;
  538.            }
  539.            break;
  540.         case NORMAL_GADGET_COLOR2 :
  541.            if (value) {
  542.           gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_COLOR2;
  543.            } else {
  544.           gd->gd_Flags &= ~GADGET_DATA_FLAG_TEXT_COLOR2;
  545.            }
  546.            break;
  547.      }
  548.      break;
  549.    }
  550.    return(status);
  551. }
  552.     /* Change special template data */
  553.  
  554.    SHORT
  555. change_special_template_data(APTR gl, struct Template  *tp, USHORT entry,
  556.                                 ULONG value)
  557. {
  558.    SHORT status = EDITOR_STATUS_NORMAL;
  559.  
  560.    return(status);
  561. }
  562.