home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 3 / CDPDIII.bin / pd / utilities / dirutils / visualshell / src / config.c < prev    next >
C/C++ Source or Header  |  1992-10-29  |  18KB  |  603 lines
  1.             /*********************************
  2.          *                               *
  3.          *   Visual Shell v1.17  10/92   *
  4.          *                               *
  5.          *     by Torsten Jürgeleit      *
  6.          *                               *
  7.          *         config part           *
  8.          *                               *
  9.          *********************************/
  10.  
  11.     /* Includes */
  12.  
  13. #include "includes.h"
  14. #include "imports.h"
  15. #include "protos.h"
  16.  
  17.     /* Show configuration for VSh */
  18.  
  19.    VOID
  20. action_config(VOID)
  21. {
  22.    struct Gadget       *gadget_buffer, *gad;
  23.    struct StringInfo   *sinfo_buffer, *info;
  24.    struct IntuiText    *itext_buffer, *text;
  25.    struct ConfigEntry  *ce;
  26.    BYTE   *string_buffer, *buffer;
  27.    BOOL   success = FALSE;
  28.    USHORT i, text_len, max_text_len = 0, width, max_width = 0, left_offset,
  29.       top_offset = BORDER_TOP + MAX_OUTPUT_HEIGHT / 2 -
  30.                            (MAX_CONFIG_ENTRIES * 9) / 2;
  31.    event_mode = EVENT_MODE_IGNORE;
  32.    if (gadget_buffer = (struct Gadget *)AllocMem((LONG)(MAX_CONFIG_ENTRIES *
  33.             sizeof(struct Gadget)), MEMF_PUBLIC | MEMF_CLEAR)) {
  34.       if (sinfo_buffer = (struct StringInfo *)AllocMem((LONG)
  35.                (MAX_CONFIG_ENTRIES * sizeof(struct StringInfo)),
  36.                         MEMF_PUBLIC | MEMF_CLEAR)) {
  37.      if (string_buffer = AllocMem((LONG)(MAX_CONFIG_ENTRIES *
  38.            (MAX_CONFIG_ENTRY_LEN + 1)), MEMF_PUBLIC | MEMF_CLEAR)) {
  39.         if (itext_buffer = (struct IntuiText *)AllocMem((LONG)
  40.                 (MAX_CONFIG_ENTRIES * sizeof(struct IntuiText)),
  41.                         MEMF_PUBLIC | MEMF_CLEAR)) {
  42.            /* Initialize string gadgets */
  43.            ce     = &config_entry[i];
  44.            gad    = gadget_buffer;
  45.            info   = sinfo_buffer;
  46.            text   = itext_buffer;
  47.            buffer = string_buffer;
  48.            for (i = 0; i < MAX_CONFIG_ENTRIES; i++) {
  49.           if ((text_len = strlen(ce->ce_Text) + 1) > max_text_len) {
  50.              max_text_len = text_len;
  51.           }
  52.           if ((width = (ce->ce_MaxStringLen + 1) * 8) > max_width) {
  53.              max_width = width;
  54.           }
  55.           text->FrontPen   = COLOR1;
  56.           text->BackPen    = COLOR2;
  57.           text->DrawMode   = JAM1;
  58.           text->LeftEdge   = -(text_len * 8);
  59.           text->ITextFont  = &topaz80;
  60.           text->IText      = (UBYTE *)ce->ce_Text;
  61.  
  62.           info->Buffer     = (UBYTE *)buffer;
  63.           info->MaxChars   = ce->ce_MaxStringLen + 1;
  64.  
  65.           gad->TopEdge     = top_offset + i * 9;
  66.           gad->Width       = width;
  67.           gad->Height      = 8;
  68.           gad->Flags       = GADGHCOMP;
  69.           gad->GadgetType  = STRGADGET;
  70.           gad->Activation  = ce->ce_Activation;
  71.           gad->GadgetText  = text;
  72.           gad->SpecialInfo = (APTR)info;
  73.           gad->GadgetID    = i;
  74.           if (i < (MAX_CONFIG_ENTRIES - 1)) {
  75.              gad->NextGadget = gad + 1;
  76.           } else {
  77.              gad->NextGadget = NULL;
  78.           }
  79.           ce++;
  80.           gad++;
  81.           info++;
  82.           text++;
  83.           buffer += MAX_CONFIG_ENTRY_LEN + 1;
  84.            }
  85.            if ((max_text_len + max_width / 8) > (max_line_len - 2)) {
  86.           left_offset = BORDER_LEFT + (max_text_len + 1) * 8;
  87.           max_width   = ((max_line_len - 2) - max_text_len) * 8;
  88.            } else {
  89.           left_offset = (vsh_width - (max_text_len * 8 + max_width))
  90.                              / 2 + max_text_len * 8;
  91.            }
  92.  
  93.            /* Set left edge and width of gadgets */
  94.            gad = gadget_buffer;
  95.            for (i = 0; i < MAX_CONFIG_ENTRIES; i++, gad++) {
  96.           gad->LeftEdge = left_offset;
  97.           if (gad->Width > max_width) {
  98.              gad->Width = max_width;
  99.           }
  100.            }
  101.            fill_config_gadget_buffers(gadget_buffer);
  102.            perform_config_action(gadget_buffer);
  103.            success = TRUE;
  104.            FreeMem(itext_buffer, (LONG)(MAX_CONFIG_ENTRIES *
  105.                          sizeof(struct IntuiText)));
  106.         }
  107.         FreeMem(string_buffer, (LONG)(MAX_CONFIG_ENTRIES *
  108.                            (MAX_CONFIG_ENTRY_LEN + 1)));
  109.      }
  110.      FreeMem(sinfo_buffer, (LONG)(MAX_CONFIG_ENTRIES *
  111.                         sizeof(struct StringInfo)));
  112.       }
  113.       FreeMem(gadget_buffer, (LONG)(MAX_CONFIG_ENTRIES *
  114.                             sizeof(struct Gadget)));
  115.    }
  116.    if (success == FALSE) {
  117.       print_status(VSH_ERROR_OUT_OF_MEM);
  118.    } else {
  119.       draw_display(FULL_DISPLAY);
  120.    }
  121.    event_mode = EVENT_MODE_NORMAL;
  122. }
  123.     /* Perform configuration action */
  124.  
  125.    VOID
  126. perform_config_action(struct Gadget *gadget_list)
  127. {
  128.    struct Gadget  *error_gadget, *active_gadget = gadget_list;
  129.    BOOL keepon = TRUE;
  130.  
  131.    event_mode = EVENT_MODE_CONFIG;
  132.    qualifier  = QUALIFIER_NONE;
  133.    if (! show_flag) {  /* hidden display ? */
  134.       clear_display(PART_DISPLAY);
  135.    } else {
  136.       SetAPen(con_rport, (LONG)COLOR0);
  137.       RectFill(con_rport, (LONG)(BORDER_LEFT - 2), (LONG)BORDER_TOP, (LONG)
  138.               (vsh_width - BORDER_RIGHT + 1), (LONG)(cli_vpos - 3));
  139.    }
  140.    SetAPen(con_rport, (LONG)COLOR2);
  141.    RectFill(con_rport, (LONG)BORDER_LEFT, (LONG)BORDER_TOP, (LONG)(vsh_width
  142.                  - BORDER_RIGHT - 1), (LONG)(cli_vpos - 4));
  143.    display_text(COLOR3, COLOR2, (USHORT)((vsh_width - 13 * 8) / 2), (USHORT)
  144.                      (BORDER_TOP + 8), "Configuration");
  145.    SetFont(&con_window->WScreen->RastPort, con_font);   /* need console 8x8 text font for string gadgets */
  146.    RefreshGadgets(gadget_list, con_window, NULL);
  147.    display_text(COLOR3, COLOR2, (USHORT)((vsh_width - 64 * 8) / 2), (USHORT)
  148.                              (cli_vpos - 3 - 2 * 8),
  149.     "Use arrow keys, RETURN or SHIFT RETURN to change configuration !");
  150.    print_fkey_text(FKEY_MODE_CONFIG);
  151.    do {
  152.       ULONG signals;
  153.  
  154.       AddGList(con_window, gadget_list, -1L, -1L, NULL);
  155.       ActivateGadget(active_gadget, con_window, NULL);
  156.       signals = Wait(SIGF_ACTION);
  157.       RemoveGList(con_window, gadget_list, -1L);
  158.       switch (action) {
  159.      case VSH_ACTION_F1 :   /* load */
  160.         if (read_config_file() == FALSE) {
  161.            DisplayBeep(NULL);
  162.            set_default_config();
  163.         }
  164.         prepare_con_window();
  165.         keepon = FALSE;
  166.         break;
  167.      case VSH_ACTION_F2 :   /* save */
  168.         if (!(active_gadget = check_config(gadget_list))) {
  169.            set_new_config(gadget_list);
  170.            if (write_config_file() == FALSE) {
  171.           DisplayBeep(NULL);
  172.            }
  173.            prepare_con_window();
  174.            keepon = FALSE;
  175.         }
  176.         break;
  177.      case VSH_ACTION_F3 :   /* defaults */
  178.         set_default_config();
  179.         prepare_con_window();
  180.         keepon = FALSE;
  181.         break;
  182.      case VSH_ACTION_F4 :   /* use */
  183.         if (!(active_gadget = check_config(gadget_list))) {
  184.            set_new_config(gadget_list);
  185.            prepare_con_window();
  186.            keepon = FALSE;
  187.         }
  188.         break;
  189.      case VSH_ACTION_SHIFT_GADGET_END_KEY :   /* up */
  190.         if (error_gadget = check_config(gadget_list)) {
  191.            active_gadget = error_gadget;
  192.         } else {
  193.            if (active_gadget->GadgetID) {
  194.           active_gadget--;
  195.            } else {
  196.           active_gadget = gadget_list + (MAX_CONFIG_ENTRIES - 1);
  197.            }
  198.         }
  199.         break;
  200.      case VSH_ACTION_GADGET_END_KEY :   /* down */
  201.         if (error_gadget = check_config(gadget_list)) {
  202.            active_gadget = error_gadget;
  203.         } else {
  204.            if (active_gadget->GadgetID < (MAX_CONFIG_ENTRIES - 1)) {
  205.           active_gadget++;
  206.            } else {
  207.           active_gadget = gadget_list;
  208.            }
  209.         }
  210.         break;
  211.      case VSH_ACTION_QUIT :   /* cancel */
  212.      case VSH_ACTION_ESC :
  213.         keepon = FALSE;
  214.         break;
  215.       }
  216.    } while (keepon == TRUE);
  217.    SetFont(&con_window->WScreen->RastPort, old_wb_font);   /* restore original font */
  218.    event_mode = EVENT_MODE_IGNORE;
  219.    action     = VSH_ACTION_NONE;
  220. }
  221.     /* Fill configuration string gadget buffers */
  222.  
  223.    VOID
  224. fill_config_gadget_buffers(struct Gadget *gad)
  225. {
  226.    struct StringInfo  *sinfo;
  227.    BYTE   *buffer;
  228.    USHORT i;
  229.  
  230.    for (i = 0; i < MAX_CONFIG_ENTRIES; i++) {
  231.       sinfo  = (struct StringInfo *)gad++->SpecialInfo;
  232.       buffer = (BYTE *)sinfo->Buffer;
  233.       switch (i) {
  234.      case CONFIG_ENTRY_LEFT_EDGE :
  235.         SPrintf(buffer, "%d", con_window->LeftEdge);
  236.         sinfo->LongInt = con_window->LeftEdge;
  237.         break;
  238.      case CONFIG_ENTRY_TOP_EDGE :
  239.         SPrintf(buffer, "%d", con_window->TopEdge);
  240.         sinfo->LongInt = con_window->TopEdge;
  241.         break;
  242.      case CONFIG_ENTRY_WIDTH :
  243.         SPrintf(buffer, "%d", vsh_width);
  244.         sinfo->LongInt = vsh_width;
  245.         break;
  246.      case CONFIG_ENTRY_HEIGHT :
  247.         SPrintf(buffer, "%d", vsh_height);
  248.         sinfo->LongInt = vsh_height;
  249.         break;
  250.      case CONFIG_ENTRY_CLI_LINES :
  251.         SPrintf(buffer, "%d", vsh_cli_lines);
  252.         sinfo->LongInt = vsh_cli_lines;
  253.         break;
  254.      case CONFIG_ENTRY_SCROLL_SPEED :
  255.         SPrintf(buffer, "%d", vsh_scroll_speed);
  256.         sinfo->LongInt = vsh_scroll_speed;
  257.         break;
  258.      case CONFIG_ENTRY_KEYBOARD_TYPE :
  259.         SPrintf(buffer, "%d", vsh_keyboard_type);
  260.         sinfo->LongInt = vsh_keyboard_type;
  261.         break;
  262.      case CONFIG_ENTRY_DUMP_MODE :
  263.         SPrintf(buffer, "%d", vsh_dump_mode);
  264.         sinfo->LongInt = vsh_dump_mode;
  265.         break;
  266.      case CONFIG_ENTRY_EDITOR_NAME :
  267.         strcpy(buffer, vsh_editor_name);
  268.         break;
  269.      case CONFIG_ENTRY_EDITOR_OPTS :
  270.         strcpy(buffer, vsh_editor_opts);
  271.         break;
  272.       }
  273.       sinfo->BufferPos = strlen(buffer);
  274.    }
  275. }
  276.     /* Check configuration for validity */
  277.  
  278.    struct Gadget *
  279. check_config(struct Gadget *gadget_list)
  280. {
  281.    struct Gadget       *gad = gadget_list, *error_gadget = NULL;
  282.    struct ConfigEntry  *ce = &config_entry[0];
  283.    struct StringInfo   *sinfo;
  284.    LONG   value;
  285.    USHORT i, new_vsh_left, new_vsh_top, new_vsh_width, new_vsh_height,
  286.       new_vsh_cli_lines;
  287.    BYTE   *buffer;
  288.  
  289.    for (i = 0; i < MAX_CONFIG_ENTRIES && !error_gadget; i++, gad++, ce++) {
  290.       sinfo  = (struct StringInfo *)gad->SpecialInfo;
  291.       value  = sinfo->LongInt;
  292.       buffer = (BYTE *)sinfo->Buffer;
  293.       if (ce->ce_Activation == LONGINT && (value < ce->ce_MinValue ||
  294.                          value > ce->ce_MaxValue)) {
  295.      error_gadget = gad;
  296.       } else {
  297.      switch (i) {
  298.         case CONFIG_ENTRY_LEFT_EDGE :
  299.            new_vsh_left = value;
  300.            break;
  301.         case CONFIG_ENTRY_TOP_EDGE :
  302.            new_vsh_top = value;
  303.            break;
  304.         case CONFIG_ENTRY_WIDTH :
  305.            new_vsh_width = value;
  306.            break;
  307.         case CONFIG_ENTRY_HEIGHT :
  308.            new_vsh_height = value;
  309.            break;
  310.         case CONFIG_ENTRY_CLI_LINES :
  311.            new_vsh_cli_lines = value;
  312.            break;
  313.         case CONFIG_ENTRY_EDITOR_NAME :
  314.            if (*buffer == '\0') {
  315.           error_gadget = gad;
  316.            }
  317.            break;
  318.      }
  319.       }
  320.    }
  321.    if (!error_gadget) {   /* check con window dimension */
  322.       if ((new_vsh_left + new_vsh_width) > wb_width) {
  323.      error_gadget = gadget_list + CONFIG_ENTRY_LEFT_EDGE;
  324.       } else {
  325.      if ((new_vsh_top + new_vsh_height) > wb_height) {
  326.         error_gadget = gadget_list + CONFIG_ENTRY_TOP_EDGE;
  327.      } else {
  328.         if (new_vsh_cli_lines > DEFAULT_CLI_LINES && (MIN_VSH_HEIGHT +
  329.                 (new_vsh_cli_lines - DEFAULT_CLI_LINES) * 8)
  330.                              > new_vsh_height) {
  331.            error_gadget = gadget_list + CONFIG_ENTRY_CLI_LINES;
  332.         }
  333.      }
  334.       }
  335.    }
  336.    if (error_gadget) {
  337.       DisplayBeep(NULL);
  338.    }
  339.    return(error_gadget);
  340. }
  341.     /* Set default values for VSh configuration */
  342.  
  343.    VOID
  344. set_default_config(VOID)
  345. {
  346.    USHORT i;
  347.  
  348.    /* Set default console window dimension */
  349.    vsh_left          = DEFAULT_LEFT_EDGE;
  350.    vsh_top           = DEFAULT_TOP_EDGE;
  351.    vsh_width         = wb_width;
  352.    vsh_height        = wb_height;
  353.    vsh_cli_lines     = DEFAULT_CLI_LINES;
  354.    vsh_scroll_speed  = DEFAULT_SCROLL_SPEED;
  355.    vsh_keyboard_type = DEFAULT_KEYBOARD_TYPE;
  356.    vsh_dump_mode     = DEFAULT_DUMP_MODE;
  357.    strcpy(vsh_editor_name, DEFAULT_EDITOR_NAME);
  358.    strcpy(vsh_editor_opts, DEFAULT_EDITOR_OPTS);
  359.  
  360.    /* Init user func fkey texts and user funcs */
  361.    for (i = 0; i < MAX_FKEYS; i++) {
  362.       SPrintf(user_fkey_text[i], "User%-2d", i + 1);
  363.       *user_function[i] = '\0';
  364.    }
  365. }
  366.     /* Set new values for VSh configuration */
  367.  
  368.    VOID
  369. set_new_config(struct Gadget *gad)
  370. {
  371.    struct StringInfo  *sinfo;
  372.    BYTE   *buffer;
  373.    USHORT i;
  374.  
  375.    for (i = 0; i < MAX_CONFIG_ENTRIES; i++) {
  376.       sinfo  = (struct StringInfo *)gad++->SpecialInfo;
  377.       buffer = (BYTE *)sinfo->Buffer;
  378.       switch (i) {
  379.      case CONFIG_ENTRY_LEFT_EDGE :
  380.         vsh_left = sinfo->LongInt;
  381.         break;
  382.      case CONFIG_ENTRY_TOP_EDGE :
  383.         vsh_top = sinfo->LongInt;
  384.         break;
  385.      case CONFIG_ENTRY_WIDTH :
  386.         vsh_width = sinfo->LongInt;
  387.         break;
  388.      case CONFIG_ENTRY_HEIGHT :
  389.         vsh_height = sinfo->LongInt;
  390.         break;
  391.      case CONFIG_ENTRY_CLI_LINES :
  392.         vsh_cli_lines = sinfo->LongInt;
  393.         break;
  394.      case CONFIG_ENTRY_SCROLL_SPEED :
  395.         vsh_scroll_speed = sinfo->LongInt;
  396.         break;
  397.      case CONFIG_ENTRY_KEYBOARD_TYPE :
  398.         vsh_keyboard_type = sinfo->LongInt;
  399.         break;
  400.      case CONFIG_ENTRY_DUMP_MODE :
  401.         vsh_dump_mode = sinfo->LongInt;
  402.         break;
  403.      case CONFIG_ENTRY_EDITOR_NAME :
  404.         strcpy(vsh_editor_name, buffer);
  405.         break;
  406.      case CONFIG_ENTRY_EDITOR_OPTS :
  407.         strcpy(vsh_editor_opts, buffer);
  408.         break;
  409.       }
  410.    }
  411. }
  412.     /* Read config file and get informations out of it */
  413.  
  414.    BOOL
  415. read_config_file(VOID)
  416. {
  417.    BPTR   fh;
  418.    BYTE   *buffer = &path1_buffer[0];
  419.    USHORT i;
  420.    BOOL   success = FALSE;
  421.  
  422.    if (fh = (BPTR)Open(vsh_config_file, (LONG)MODE_OLDFILE)) {
  423.       if ((success = read_config_data(fh, buffer, (LONG)
  424.                   (strlen(vsh_config_file) + 1))) == TRUE) {
  425.      if (strcmp(buffer, vsh_config_file)) {
  426.         success = FALSE;
  427.      } else {
  428.         for (i = 0; i < MAX_CONFIG_ENTRIES && success == TRUE; i++) {
  429.            switch (i) {
  430.           case CONFIG_ENTRY_LEFT_EDGE :
  431.              success = read_config_data(fh, (BYTE *)&vsh_left,
  432.                             (LONG)sizeof(vsh_left));
  433.              break;
  434.           case CONFIG_ENTRY_TOP_EDGE :
  435.              success = read_config_data(fh, (BYTE *)&vsh_top, (LONG)
  436.                                sizeof(vsh_top));
  437.              break;
  438.           case CONFIG_ENTRY_WIDTH :
  439.              success = read_config_data(fh, (BYTE *)&vsh_width,
  440.                            (LONG)sizeof(vsh_width));
  441.              break;
  442.           case CONFIG_ENTRY_HEIGHT :
  443.              success = read_config_data(fh, (BYTE *)&vsh_height,
  444.                           (LONG)sizeof(vsh_height));
  445.              break;
  446.           case CONFIG_ENTRY_CLI_LINES :
  447.              success = read_config_data(fh, (BYTE *)&vsh_cli_lines,
  448.                            (LONG)sizeof(vsh_cli_lines));
  449.              break;
  450.           case CONFIG_ENTRY_SCROLL_SPEED :
  451.              success = read_config_data(fh, (BYTE *)
  452.              &vsh_scroll_speed, (LONG)sizeof(vsh_scroll_speed));
  453.              break;
  454.           case CONFIG_ENTRY_KEYBOARD_TYPE :
  455.              success = read_config_data(fh, (BYTE *)
  456.                &vsh_keyboard_type, (LONG)sizeof(vsh_keyboard_type));
  457.              break;
  458.           case CONFIG_ENTRY_DUMP_MODE :
  459.              success = read_config_data(fh, (BYTE *)
  460.                    &vsh_dump_mode, (LONG)sizeof(vsh_dump_mode));
  461.              break;
  462.           case CONFIG_ENTRY_EDITOR_NAME :
  463.              success = read_config_data(fh, vsh_editor_name, (LONG)
  464.                          (MAX_EDITOR_NAME_LEN + 1));
  465.              break;
  466.           case CONFIG_ENTRY_EDITOR_OPTS :
  467.              success = read_config_data(fh, vsh_editor_opts, (LONG)
  468.                          (MAX_EDITOR_OPTS_LEN + 1));
  469.              break;
  470.            }
  471.         }
  472.  
  473.         /* Read user functions */
  474.         for (i = 0; i < MAX_USER_FUNCTIONS && success == TRUE; i++) {
  475.            if ((success = read_config_data(fh, user_fkey_text[i], (LONG)
  476.                     (MAX_FKEY_NAME_LEN + 1))) == TRUE) {
  477.           success = read_config_data(fh, user_function[i], (LONG)
  478.                            (MAX_USER_FUNCTION_LEN + 1));
  479.            }
  480.         }
  481.      }
  482.       }
  483.       Close(fh);
  484.    }
  485.    if (success == TRUE) {
  486.  
  487.       /* Check console window dimension */
  488.       if ((vsh_left + vsh_width) > wb_width || (vsh_top + vsh_height) >
  489.                                 wb_height) {
  490.      /* Set default console window dimension */
  491.      vsh_left   = DEFAULT_LEFT_EDGE;
  492.      vsh_top    = DEFAULT_TOP_EDGE;
  493.      vsh_width  = wb_width;
  494.      vsh_height = wb_height;
  495.      if (vsh_cli_lines > DEFAULT_CLI_LINES && (MIN_VSH_HEIGHT +
  496.             (vsh_cli_lines - DEFAULT_CLI_LINES) * 8) > vsh_height) {
  497.         vsh_cli_lines = DEFAULT_CLI_LINES + (vsh_height -
  498.                             MIN_VSH_HEIGHT) / 8;
  499.      }
  500.       }
  501.    }
  502.    return(success);
  503. }
  504.     /* Read data from config file */
  505.  
  506.    BOOL
  507. read_config_data(BPTR fh, BYTE *buffer, ULONG size)
  508. {
  509.    BOOL success = TRUE;
  510.  
  511.    if (Read(fh, buffer, size) != size) {
  512.       success = FALSE;
  513.    }
  514.    return(success);
  515. }
  516.     /* Write config file */
  517.  
  518.    BOOL
  519. write_config_file(VOID)
  520. {
  521.    BPTR   fh;
  522.    USHORT i;
  523.    BOOL   success = FALSE;
  524.  
  525.    if (fh = (BPTR)Open(vsh_config_file, (LONG)MODE_NEWFILE)) {
  526.       if ((success = write_config_data(fh, vsh_config_file, (LONG)
  527.                   (strlen(vsh_config_file) + 1))) == TRUE) {
  528.      for (i = 0; i < MAX_CONFIG_ENTRIES && success == TRUE; i++) {
  529.         switch (i) {
  530.            case CONFIG_ENTRY_LEFT_EDGE :
  531.           success = write_config_data(fh, (BYTE *)&vsh_left, (LONG)
  532.                               sizeof(vsh_left));
  533.           break;
  534.            case CONFIG_ENTRY_TOP_EDGE :
  535.           success = write_config_data(fh, (BYTE *)&vsh_top, (LONG)
  536.                                sizeof(vsh_top));
  537.           break;
  538.            case CONFIG_ENTRY_WIDTH :
  539.           success = write_config_data(fh, (BYTE *)&vsh_width, (LONG)
  540.                              sizeof(vsh_width));
  541.           break;
  542.            case CONFIG_ENTRY_HEIGHT :
  543.           success = write_config_data(fh, (BYTE *)&vsh_height,
  544.                           (LONG)sizeof(vsh_height));
  545.           break;
  546.            case CONFIG_ENTRY_CLI_LINES :
  547.           success = write_config_data(fh, (BYTE *)&vsh_cli_lines,
  548.                            (LONG)sizeof(vsh_cli_lines));
  549.           break;
  550.            case CONFIG_ENTRY_SCROLL_SPEED :
  551.           success = write_config_data(fh, (BYTE *)&vsh_scroll_speed,
  552.                         (LONG)sizeof(vsh_scroll_speed));
  553.           break;
  554.            case CONFIG_ENTRY_KEYBOARD_TYPE :
  555.           success = write_config_data(fh, (BYTE *)
  556.                &vsh_keyboard_type, (LONG)sizeof(vsh_keyboard_type));
  557.           break;
  558.            case CONFIG_ENTRY_DUMP_MODE :
  559.           success = write_config_data(fh, (BYTE *)
  560.                    &vsh_dump_mode, (LONG)sizeof(vsh_dump_mode));
  561.           break;
  562.            case CONFIG_ENTRY_EDITOR_NAME :
  563.           success = write_config_data(fh, vsh_editor_name, (LONG)
  564.                          (MAX_EDITOR_NAME_LEN + 1));
  565.           break;
  566.            case CONFIG_ENTRY_EDITOR_OPTS :
  567.           success = write_config_data(fh, vsh_editor_opts, (LONG)
  568.                          (MAX_EDITOR_OPTS_LEN + 1));
  569.           break;
  570.         }
  571.      }
  572.  
  573.      /* Write user functions */
  574.      for (i = 0; i < MAX_USER_FUNCTIONS && success == TRUE; i++) {
  575.         if ((success = write_config_data(fh, user_fkey_text[i], (LONG)
  576.                     (MAX_FKEY_NAME_LEN + 1))) == TRUE) {
  577.            success = write_config_data(fh, user_function[i], (LONG)
  578.                            (MAX_USER_FUNCTION_LEN + 1));
  579.         }
  580.      }
  581.       }
  582.       Close(fh);
  583.       if (success == FALSE) {
  584.  
  585.      /* Delete invalid config file */
  586.      DeleteFile(vsh_config_file);
  587.       }
  588.    }
  589.    return(success);
  590. }
  591.     /* Write data to config file */
  592.  
  593.    BOOL
  594. write_config_data(BPTR fh, BYTE *buffer, ULONG size)
  595. {
  596.    BOOL success = TRUE;
  597.  
  598.    if (Write(fh, buffer, size) != size) {
  599.       success = FALSE;
  600.    }
  601.    return(success);
  602. }
  603.