home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / tapecove.lha / TapeCover / Source / tapecover_io.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-10  |  22.9 KB  |  651 lines
  1. void init_tdat(struct TapeDat *tdat, char *buffer)
  2. {
  3. int  i;
  4.  
  5.     memset(buffer, ' ', BUF_LENGTH);
  6.     for (i = 0; i < TITLES_PER_SIDE; i++)
  7.         {
  8.         buffer[(i + 1) * TITLE_LENGTH - 1] = '\0';
  9.         tdat->sidea[i] = buffer + i * TITLE_LENGTH;
  10.         buffer[TITLES_PER_SIDE * TITLE_LENGTH + (i + 1) * TITLE_LENGTH - 1] = '\0';
  11.         tdat->sideb[i] = buffer + TITLES_PER_SIDE * TITLE_LENGTH + i * TITLE_LENGTH;
  12.         }
  13.     for (i = 0; i < LABELS; i++)
  14.         {
  15.         buffer[TBUF_LENGTH + (i + 1) * LABEL_LENGTH - 1] = '\0';
  16.         tdat->label[i] = buffer + TBUF_LENGTH + i * LABEL_LENGTH;
  17.         }
  18.     for (i = 0; i < INFOS; i++)
  19.         {
  20.         buffer[TLBUF_LENGTH + (i + 1) * INFO_LENGTH - 1] = '\0';
  21.         tdat->info[i] = buffer + TLBUF_LENGTH + i * INFO_LENGTH;
  22.         }
  23.     tdat->size.line1_bold = tdat->size.line2_bold = 0;
  24. }
  25.  
  26. void clear_sides(char *buffer)
  27. {
  28. int  i;
  29.  
  30.     memset(buffer, ' ', TBUF_LENGTH);
  31.     for (i = 0; i < TITLES_PER_SIDE; i++)
  32.         {
  33.         buffer[(i + 1) * TITLE_LENGTH - 1] = '\0';
  34.         buffer[TITLES_PER_SIDE * TITLE_LENGTH + (i + 1) * TITLE_LENGTH - 1] = '\0';
  35.         }
  36. }
  37.  
  38. void write_textjam1(struct RastPort *rp, ULONG x, ULONG y, ULONG v, ULONG h, char *text)
  39. {
  40. struct IntuiText i_text;
  41.  
  42.     i_text.FrontPen = v;
  43.     i_text.BackPen = h;
  44.     i_text.DrawMode = JAM1;
  45.     i_text.LeftEdge = 0;
  46.     i_text.TopEdge = 0;
  47.     i_text.ITextFont = NULL;
  48.     i_text.IText = text;
  49.     i_text.NextText = NULL;
  50.     PrintIText(rp, &i_text, x, y);
  51. }
  52.  
  53. void write_textjam2(struct RastPort *rp, ULONG x, ULONG y, ULONG v, ULONG h, char *text)
  54. {
  55. struct IntuiText i_text;
  56.  
  57.     i_text.FrontPen = v;
  58.     i_text.BackPen = h;
  59.     i_text.DrawMode = JAM2;
  60.     i_text.LeftEdge = 0;
  61.     i_text.TopEdge = 0;
  62.     i_text.ITextFont = NULL;
  63.     i_text.IText = text;
  64.     i_text.NextText = NULL;
  65.     PrintIText(rp, &i_text, x, y);
  66. }
  67.  
  68. void write_ctext(struct Window *wp, ULONG y, ULONG v, ULONG h, char *text)
  69. {
  70. struct IntuiText i_text;
  71. ULONG            x;
  72.  
  73.     i_text.FrontPen = v;
  74.     i_text.BackPen = h;
  75.     i_text.DrawMode = JAM2;
  76.     i_text.LeftEdge = 0;
  77.     i_text.TopEdge = 0;
  78.     i_text.ITextFont = NULL;
  79.     i_text.IText = text;
  80.     i_text.NextText = NULL;
  81.     x = (wp->Width - (wp->RPort->Font->tf_XSize * strlen(text))) / 2;
  82.     PrintIText(wp->RPort, &i_text, x, y);
  83. }
  84.  
  85. void write_ctext3d(struct Window *wp, ULONG y, ULONG v, ULONG h, char *text)
  86. {
  87. struct IntuiText i_text;
  88. ULONG            x;
  89.  
  90.     i_text.FrontPen = h;
  91.     i_text.BackPen = 0;
  92.     i_text.DrawMode = JAM2;
  93.     i_text.LeftEdge = 0;
  94.     i_text.TopEdge = 0;
  95.     i_text.ITextFont = NULL;
  96.     i_text.IText = text;
  97.     i_text.NextText = NULL;
  98.     x = (wp->Width - (wp->RPort->Font->tf_XSize * strlen(text))) / 2;
  99.     PrintIText(wp->RPort, &i_text, x + 1, y + 1);
  100.     i_text.FrontPen = v;
  101.     i_text.DrawMode = JAM1;
  102.     PrintIText(wp->RPort, &i_text, x, y);
  103. }
  104.  
  105. void write_bigtext(struct RastPort *rp, ULONG x, ULONG y, char *text)
  106. {
  107. struct IntuiText i_text;
  108. ULONG            font_x,
  109.                  font_y;
  110. char             btext[2];
  111. WORD             x_step;
  112. int              i;
  113.  
  114.     font_y = rp->Font->tf_YSize;
  115.     font_x = rp->Font->tf_XSize;
  116.     SetAPen(rp, 0);
  117.     RectFill(rp, x, y, x - 1 + (LABEL_LENGTH - 1) * font_x, y - 1 + font_y);
  118.     for (i = 0; i < BIGLABEL_LENGTH; i++)
  119.     {
  120.         btext[0] = text[i];
  121.         btext[1] = '\0';
  122.         i_text.FrontPen = 1;
  123.         i_text.BackPen = 0;
  124.         i_text.DrawMode = JAM2;
  125.         i_text.LeftEdge = 0;
  126.         i_text.TopEdge = 0;
  127.         i_text.ITextFont = NULL;
  128.         i_text.IText = btext;
  129.         i_text.NextText = NULL;
  130.         x_step = x + i * font_x * 1.456521739;
  131.         PrintIText(rp, &i_text, x_step, y);
  132.     }
  133. }
  134.  
  135. void box_rec(struct Window *wp, ULONG x1, ULONG y1, ULONG x2, ULONG y2)
  136. {
  137. APTR *VInfo;
  138.  
  139.     if (VInfo = GetVisualInfo(wp->WScreen, TAG_END))
  140.     {
  141.         DrawBevelBox(wp->RPort, x1, y1, x2 - x1 + 1, y2 - y1 + 1,
  142.                      GTBB_Recessed, TRUE,
  143.                      GT_VisualInfo, VInfo,
  144.                      TAG_END);
  145.         FreeVisualInfo(VInfo);
  146.     }
  147. }
  148.  
  149. void box_rai(struct Window *wp, ULONG x1, ULONG y1, ULONG x2, ULONG y2)
  150. {
  151. APTR *VInfo;
  152.  
  153.     if (VInfo = GetVisualInfo(wp->WScreen, TAG_END))
  154.     {
  155.         DrawBevelBox(wp->RPort, x1, y1, x2 - x1 + 1, y2 - y1 + 1,
  156.                      GT_VisualInfo, VInfo,
  157.                      TAG_END);
  158.         FreeVisualInfo(VInfo);
  159.     }
  160. }
  161.  
  162. void box_bor(struct Window *wp, ULONG x1, ULONG y1, ULONG x2, ULONG y2)
  163. {
  164.     SetAPen(wp->RPort, 1);
  165.     Move(wp->RPort, x1, y2);
  166.     Draw(wp->RPort, x1, y1);
  167.     Draw(wp->RPort, x2, y1);
  168.     SetAPen(wp->RPort, 2);
  169.     Draw(wp->RPort, x2, y2);
  170.     Draw(wp->RPort, x1 + 1, y2);
  171.     Draw(wp->RPort, x1 + 1, y1 + 1);
  172.     Draw(wp->RPort, x2 - 1, y1 + 1);
  173.     SetAPen(wp->RPort, 1);
  174.     Move(wp->RPort, x2 - 1, y1 + 2);
  175.     Draw(wp->RPort, x2 - 1, y2 - 1);
  176.     Draw(wp->RPort, x1 + 2, y2 - 1);
  177. }
  178.  
  179. void box_fill(struct Window *wp, ULONG x, ULONG y, ULONG width, ULONG height,
  180.               UBYTE percent)
  181. {
  182. FLOAT per_width;
  183.     
  184.     per_width = ((FLOAT) width / 100) * percent;
  185.     SetAPen(wp->RPort, 3);
  186.     SetDrMd(wp->RPort, JAM1);
  187.     RectFill(wp->RPort, x , y, (x + (ULONG) per_width) - 1, y + height - 1);
  188. }
  189.  
  190. void write_mask(struct IntDat *idat)
  191. {
  192. struct RastPort *rp;
  193. ULONG           font_x,
  194.                 font_y,
  195.                 winleft,
  196.                 wintop;
  197. int             i;
  198.  
  199.     rp = idat->mainwin->RPort;
  200.     font_x = rp->Font->tf_XSize;
  201.     font_y = rp->Font->tf_YSize;
  202.     winleft = (idat->mainwin->Width - (INFO_LENGTH - 1) * font_x) / 2;
  203.     wintop = idat->mainwin->BorderTop;
  204.     box_bor(idat->mainwin, winleft - 10, wintop + 5, winleft + (INFO_LENGTH - 1) * font_x + 10,
  205.          wintop + MAIN_LINES * (font_y + 6) + 15);
  206.     write_textjam1(rp, winleft + 1,
  207.                    wintop + 11,
  208.                    1, 0,
  209.                    GetString(&idat->li, MSG_SIDEA));
  210.     write_textjam1(rp, winleft,
  211.                    wintop + 10,
  212.                    2, 0,
  213.                    GetString(&idat->li, MSG_SIDEA));
  214.     write_textjam1(rp, winleft + 1 + TITLE_LENGTH * font_x,
  215.                    wintop + 11,
  216.                    1, 0,
  217.                    GetString(&idat->li, MSG_SIDEB));
  218.     write_textjam1(rp, winleft + TITLE_LENGTH * font_x,
  219.                    wintop + 10,
  220.                    2, 0,
  221.                    GetString(&idat->li, MSG_SIDEB));
  222.     write_textjam1(rp, winleft + 1,
  223.                    wintop + 11 + (TITLES_PER_SIDE + 1) * (font_y + 6),
  224.                    1, 0,
  225.                    GetString(&idat->li, MSG_LABEL));
  226.     write_textjam1(rp, winleft,
  227.                    wintop + 10 + (TITLES_PER_SIDE + 1) * (font_y + 6),
  228.                    2, 0,
  229.                    GetString(&idat->li, MSG_LABEL));
  230.     write_textjam1(rp, winleft + 1,
  231.                    wintop + 11 + (TITLES_PER_SIDE + LABELS + 2) * (font_y + 6),
  232.                    1, 0,
  233.                    GetString(&idat->li, MSG_BACK));
  234.     write_textjam1(rp, winleft,
  235.                    wintop + 10 + (TITLES_PER_SIDE + LABELS + 2) * (font_y + 6),
  236.                    2, 0,
  237.                    GetString(&idat->li, MSG_BACK));
  238.     for(i = 0; i < TITLES_PER_SIDE; i++)
  239.         {
  240.         box_rec(idat->mainwin, winleft - 3,
  241.                     wintop + 8 + (i + 1) * (font_y + 6),
  242.                     winleft + 2 + (TITLE_LENGTH - 1) * font_x,
  243.                     wintop + 5 + (i + 2) * (font_y + 6));
  244.         box_rec(idat->mainwin, winleft + TITLE_LENGTH * font_x - 3,
  245.                     wintop + 8 + (i + 1) * (font_y + 6),
  246.                     winleft + 2 + (INFO_LENGTH - 1) * font_x,
  247.                     wintop + 5 + (i + 2) * (font_y + 6));
  248.         }
  249.     for(i = 0; i < LABELS; i++)
  250.         box_rec(idat->mainwin, winleft - 3,
  251.                     wintop + 8 + (i + TITLES_PER_SIDE + 2) * (font_y + 6),
  252.                     winleft + 2 + (INFO_LENGTH - 1) * font_x,
  253.                     wintop + 5 + (i + TITLES_PER_SIDE + 3) * (font_y + 6));
  254.     for(i = 0; i < INFOS; i++)
  255.         box_rec(idat->mainwin, winleft - 3,
  256.                     wintop + 8 + (i + TITLES_PER_SIDE + LABELS + 3) * (font_y + 6),
  257.                     winleft + 2 + (INFO_LENGTH - 1) * font_x,
  258.                     wintop + 5 + (i + TITLES_PER_SIDE + LABELS + 4) * (font_y + 6));
  259. }
  260.  
  261. void write_dat(struct IntDat *idat, struct TapeDat *tdat)
  262. {
  263. struct RastPort *rp;
  264. ULONG           font_x,
  265.                 font_y,
  266.                 winleft,
  267.                 wintop;
  268. int             i;
  269.  
  270.     rp = idat->mainwin->RPort;
  271.     font_x = rp->Font->tf_XSize;
  272.     font_y = rp->Font->tf_YSize;
  273.     winleft = (idat->mainwin->Width - (INFO_LENGTH - 1) * font_x) / 2;
  274.     wintop = idat->mainwin->BorderTop;
  275.     for(i = 0; i < TITLES_PER_SIDE; i++)
  276.         {
  277.         write_textjam2(rp, winleft,
  278.                        wintop + 10 + (i + 1) * (font_y + 6),
  279.                        1, 0,
  280.                        tdat->sidea[i]);
  281.         write_textjam2(rp, winleft + TITLE_LENGTH * font_x,
  282.                        wintop + 10 + (i + 1) * (font_y + 6),
  283.                        1, 0,
  284.                        tdat->sideb[i]);
  285.         }
  286.     for(i = 0; i < LABELS; i++)
  287.         if ((i == 0) && (tdat->size.line1_bold == 0) ||
  288.             (i == 1) && (tdat->size.line2_bold == 0))
  289.             write_textjam2(rp, winleft,
  290.                            wintop + 10 + (i + TITLES_PER_SIDE + 2) * (font_y + 6),
  291.                            1, 0,
  292.                            tdat->label[i]);
  293.         else write_bigtext(rp, winleft,
  294.                                wintop + 10 + (i + TITLES_PER_SIDE + 2) * (font_y + 6),
  295.                                tdat->label[i]);
  296.     for(i = 0; i < INFOS; i++)
  297.         write_textjam2(rp, winleft,
  298.                        wintop + 10 + (i + TITLES_PER_SIDE + LABELS + 3) * (font_y + 6),
  299.                        1, 0,
  300.                        tdat->info[i]);
  301. }
  302.  
  303. void read_line(struct Window *wp, ULONG x, ULONG y, char *line, int *pos, BOOL big)
  304. {
  305. struct IntuiMessage *msg;
  306. struct RastPort     *rp;
  307.  
  308. int                 i,
  309.                     l,
  310.                     j,
  311.                     font_x,
  312.                     font_y;
  313. BYTE                key;
  314. ULONG               msg_class;
  315. BOOL                again = TRUE,
  316.                     sideab = FALSE;
  317. char                str[LABEL_LENGTH],
  318.                     text[LABEL_LENGTH];
  319.  
  320.     rp = wp->RPort;
  321.     font_x = rp->Font->tf_XSize;
  322.     font_y = rp->Font->tf_YSize;
  323.     if (big)
  324.         {
  325.         l = BIGLABEL_LENGTH;
  326.         strmid(line, text, 1, l);
  327.         }
  328.     else
  329.         {
  330.         l = strlen(line);
  331.         strcpy(text, line);
  332.         }
  333.     strmid(text, str, 1, l);
  334.     if (*pos <= 28)
  335.         {
  336.         sideab = TRUE;
  337.         box_rai(wp, x - 3, y - 2, x + 2 + (TITLE_LENGTH - 1) * font_x, y + font_y + 1);
  338.         }
  339.     else
  340.         box_rai(wp, x - 3, y - 2, x + 2 + (INFO_LENGTH - 1) * font_x, y + font_y + 1);
  341.     if (big)
  342.         write_bigtext(rp, x, y, str);
  343.     else
  344.         write_textjam2(rp, x, y, 1, 0, str);
  345.     strmid(text, str, 1, 1);
  346.     write_textjam2(rp, x, y, 1, 2, str);
  347.     i = 0;
  348.     while ((i < l) && again)
  349.         {
  350.         WaitPort(wp->UserPort);
  351.         while ((i < l) && again && (msg = GT_GetIMsg(wp->UserPort)))
  352.             {
  353.             key = msg->Code;
  354.             msg_class = msg->Class;
  355.             GT_ReplyIMsg(msg);
  356.             if (msg_class == IDCMP_RAWKEY)
  357.                 switch (key) {
  358.                     case 66:
  359.                         i = 0;
  360.                         break;
  361.                     case 76:
  362.                         *pos -= 2;
  363.                         if (*pos < 0)
  364.                             *pos = 0;
  365.                         again = FALSE;
  366.                         break;
  367.                     case 77:
  368.                         again = FALSE;
  369.                         break;
  370.                     case 78:
  371.                         i++;
  372.                         break;
  373.                     case 79:
  374.                         if (i > 0)
  375.                             i--;
  376.                         break;
  377.                     case 80:
  378.                         *pos = 0;
  379.                         again = FALSE;
  380.                         break;
  381.                     case 81:
  382.                         *pos = TITLES_PER_SIDE;
  383.                         again = FALSE;
  384.                         break;
  385.                     case 82:
  386.                         *pos = TITLES_PER_SIDE * 2;
  387.                         again = FALSE;
  388.                         break;
  389.                     case 83:
  390.                         *pos = TITLES_PER_SIDE * 2 + LABELS;
  391.                         again = FALSE;
  392.                         break;
  393.                     default:
  394.                         break;
  395.                 }
  396.             else if (msg_class == IDCMP_VANILLAKEY)
  397.                 switch (key) {
  398.                     case 8:
  399.                         if (i > 0)
  400.                         {
  401.                             i--;
  402.                             text[i] = ' ';
  403.                         }
  404.                         if (i == l - 2)
  405.                             text[l - 1] = ' ';
  406.                         break;
  407.                     case 9:
  408.                         i = l - 1;
  409.                         break;
  410.                     case 13:
  411.                         again = FALSE;
  412.                         break;
  413.                     case 19:
  414.                         if (i < l)
  415.                         {
  416.                             for (j = l - 1; j > i; j--)
  417.                                 text[j] = text[j - 1];
  418.                             text[i] = ' ';
  419.                         }
  420.                         break;
  421.                     case 24:
  422.                         for (j = 0; j < l; j++)
  423.                             text[j] = ' ';
  424.                         i = 0;
  425.                         break;
  426.                     case 27:
  427.                         *pos = TITLES_PER_SIDE * 2 + LABELS + INFOS;
  428.                         again = FALSE;
  429.                         break;
  430.                     case 127:
  431.                         for (j = i; j < l - 1; j++)
  432.                             text[j] = text[j + 1];
  433.                         text[l - 1] = ' ';
  434.                         break;
  435.                     default:
  436.                         text[i] = key;
  437.                         i++;
  438.                         break;
  439.                 }
  440.         strmid(text, str, 1, l);
  441.         if (big)
  442.             write_bigtext(rp, x, y, str);
  443.         else
  444.             write_textjam2(rp, x, y, 1, 0, str);
  445.         if ((i < l) && again)
  446.             {
  447.             strmid(text, str, i + 1, 1);
  448.             if (big)
  449.                 write_textjam2(rp, (ULONG) (x + i * font_x * 1.456521739), y, 1, 2, str);
  450.             else
  451.                 write_textjam2(rp, x + i * font_x, y, 1, 2, str);
  452.             }
  453.         }
  454.     }
  455.     strmid(text, str, 1, l);
  456.     if (sideab)
  457.         box_rec(wp, x - 3, y - 2, x + 2 + (TITLE_LENGTH - 1) * font_x, y + font_y + 1);
  458.     else
  459.         box_rec(wp, x - 3, y - 2, x + 2 + (INFO_LENGTH - 1) * font_x, y + font_y + 1);
  460.     if (big)
  461.         {
  462.         write_bigtext(rp, x, y, str);
  463.         strcat(text, "                     ");
  464.         strcpy(line, text);
  465.         }
  466.     else
  467.         {
  468.         write_textjam2(rp, x, y, 1, 0, str);
  469.         strcpy(line, text);
  470.         }
  471. }
  472.  
  473. BOOL asl_fr(struct IntDat *idat, struct PrefDat *prefs,
  474.             struct Window *win, short typ, char *path, char *file)
  475. {
  476.  
  477. struct FileRequester *fr;
  478. BOOL                 success = FALSE;
  479.  
  480.     if (fr = (struct FileRequester *)
  481.         AllocAslRequestTags(ASL_FileRequest, ASLFR_InitialWidth, prefs->aslwidth,
  482.                                              ASLFR_InitialHeight, prefs->aslheight,
  483.                                              ASLFR_InitialLeftEdge, (idat->scr->Width - prefs->aslwidth) / 2,
  484.                                              ASLFR_InitialTopEdge, (idat->scr->Height - prefs->aslheight) / 2,
  485.                                              ASLFR_Window, win,
  486.                                              ASLFR_SleepWindow, TRUE,
  487.                                              ASLFR_RejectIcons, TRUE,
  488.                                              TAG_END))
  489.         {
  490.         switch (typ) {
  491.             case ASLLOADTPC :
  492.                 if (AslRequestTags(fr, ASLFR_TitleText, GetString(&idat->li, MSG_ASLLOAD_WIN),
  493.                                        ASLFR_InitialFile, file,
  494.                                        ASLFR_InitialDrawer, path,
  495.                                        ASLFR_InitialPattern, tpcwld_str,
  496.                                        ASLFR_DoPatterns, TRUE,
  497.                                        TAG_END))
  498.                     {
  499.                     strcpy(file,fr->fr_File);
  500.                     strcpy(path,fr->fr_Drawer);
  501.                     success = TRUE;
  502.                     }
  503.                 break;
  504.             case ASLSAVETPC :
  505.                 if (AslRequestTags(fr, ASLFR_TitleText, GetString(&idat->li, MSG_ASLSAVE_WIN),
  506.                                        ASLFR_InitialFile, file,
  507.                                        ASLFR_InitialDrawer, path,
  508.                                        ASLFR_InitialPattern, tpcwld_str,
  509.                                        ASLFR_DoPatterns, TRUE,
  510.                                        ASLFR_DoSaveMode, TRUE,
  511.                                        TAG_END))
  512.                     {
  513.                     strcpy(file,fr->fr_File);
  514.                     strcpy(path,fr->fr_Drawer);
  515.                     success = TRUE;
  516.                     }
  517.                 break;
  518.             case ASLSAVEEXP :
  519.                 if (AslRequestTags(fr, ASLFR_TitleText, GetString(&idat->li, MSG_ASLEXPORT_WIN),
  520.                                        ASLFR_InitialFile, file,
  521.                                        ASLFR_InitialDrawer, path,
  522.                                        ASLFR_DoSaveMode, TRUE,
  523.                                        TAG_END))
  524.                     {
  525.                     strcpy(file,fr->fr_File);
  526.                     strcpy(path,fr->fr_Drawer);
  527.                     success = TRUE;
  528.                     }
  529.                 break;    
  530.             case ASLPATH :
  531.                 if (AslRequestTags(fr, ASLFR_TitleText, GetString(&idat->li, MSG_ASLPATH_WIN),
  532.                                        ASLFR_InitialDrawer, path,
  533.                                        ASLFR_DrawersOnly, TRUE,
  534.                                        TAG_END))
  535.                     {
  536.                     strcpy(path,fr->fr_Drawer);
  537.                     success = TRUE;
  538.                     }
  539.                 break;
  540.             case ASLLOADPREF :
  541.                 if (AslRequestTags(fr, ASLFR_TitleText, GetString(&idat->li, MSG_ASLPREFLOAD_WIN),
  542.                                        ASLFR_InitialFile, file,
  543.                                        ASLFR_InitialDrawer, path,
  544.                                        ASLFR_InitialPattern, prefwld_str,
  545.                                        ASLFR_DoPatterns, TRUE,
  546.                                        TAG_END))
  547.                     {
  548.                     strcpy(file,fr->fr_File);
  549.                     strcpy(path,fr->fr_Drawer);
  550.                     success = TRUE;
  551.                     }
  552.                 break;
  553.             case ASLSAVEPREF :
  554.                 if (AslRequestTags(fr, ASLFR_TitleText, GetString(&idat->li, MSG_ASLPREFSAVE_WIN),
  555.                                        ASLFR_InitialFile, file,
  556.                                        ASLFR_InitialDrawer, path,
  557.                                        ASLFR_InitialPattern, prefwld_str,
  558.                                        ASLFR_DoPatterns, TRUE,
  559.                                        ASLFR_DoSaveMode, TRUE,
  560.                                        TAG_END))
  561.                     {
  562.                     strcpy(file,fr->fr_File);
  563.                     strcpy(path,fr->fr_Drawer);
  564.                     success = TRUE;
  565.                     }
  566.                 break;
  567.             default:
  568.                 break;
  569.             }
  570.         prefs->aslwidth = fr->fr_Width;
  571.         prefs->aslheight = fr->fr_Height;
  572.         FreeAslRequest(fr);
  573.         }
  574.     return success;
  575. }
  576.  
  577. BOOL asl_for(struct IntDat *idat, struct PrefDat *prefs,
  578.              struct Window *win, struct TextAttr *fontn)
  579. {
  580.  
  581. struct FontRequester *fnr;
  582. BOOL                 success = FALSE;
  583.  
  584.     if (fnr = (struct FontRequester *)
  585.         AllocAslRequestTags(ASL_FontRequest, ASLFO_InitialWidth, prefs->aslwidth,
  586.                                              ASLFO_InitialHeight, prefs->aslheight,
  587.                                              ASLFO_InitialLeftEdge, (idat->scr->Width - prefs->aslwidth) / 2,
  588.                                              ASLFO_InitialTopEdge, (idat->scr->Height - prefs->aslheight) / 2,
  589.                                              ASLFO_Window, win,
  590.                                              ASLFO_SleepWindow, TRUE,
  591.                                              TAG_END))
  592.         {
  593.         if (AslRequestTags(fnr, ASLFO_TitleText, GetString(&idat->li, MSG_ASLFONT_WIN),
  594.                                 ASLFO_InitialName, fontn->ta_Name,
  595.                                 ASLFO_InitialSize, fontn->ta_YSize,
  596.                                 ASLFO_FixedWidthOnly, TRUE,
  597.                                 TAG_END))
  598.             {
  599.             strcpy(fontn->ta_Name, fnr->fo_Attr.ta_Name);
  600.             fontn->ta_YSize = fnr->fo_Attr.ta_YSize;
  601.             success = TRUE;
  602.             }
  603.         FreeAslRequest(fnr);
  604.         }
  605.     return success;
  606. }
  607.  
  608. BOOL asl_smr(struct IntDat *idat, struct Window *win, struct PrefDat *prefs)
  609. {
  610.  
  611. struct ScreenModeRequester *smr;
  612. BOOL                       success = FALSE;
  613.  
  614.     if (smr = (struct ScreenModeRequester *)
  615.         AllocAslRequestTags(ASL_ScreenModeRequest, ASLSM_InitialWidth, prefs->aslwidth,
  616.                                                    ASLSM_InitialHeight, prefs->aslheight,
  617.                                                    ASLSM_InitialLeftEdge, (idat->scr->Width - prefs->aslwidth) / 2,
  618.                                                    ASLSM_InitialTopEdge, (idat->scr->Height - prefs->aslheight) / 2,
  619.                                                    ASLSM_Window, win,
  620.                                                    ASLSM_SleepWindow, TRUE,
  621.                                                    TAG_END))
  622.         {
  623.         if (AslRequestTags(smr, ASLSM_TitleText, GetString(&idat->li, MSG_ASLSCREENMODE_WIN),
  624.                                 ASLSM_InitialDisplayID, prefs->scrid,
  625.                                 ASLSM_InitialDisplayWidth, prefs->scrwidth,
  626.                                 ASLSM_InitialDisplayHeight, prefs->scrheight,
  627.                                 ASLSM_InitialDisplayDepth, prefs->scrdepth,
  628.                                 ASLSM_InitialOverscanType, prefs->scroscan,
  629.                                 ASLSM_InitialAutoScroll, prefs->scrascroll,
  630.                                 ASLSM_DoWidth, TRUE,
  631.                                 ASLSM_DoHeight, TRUE,
  632.                                 ASLSM_DoDepth, TRUE,
  633.                                 ASLSM_MinDepth, 2,
  634.                                 ASLSM_DoOverscanType, TRUE,
  635.                                 ASLSM_DoAutoScroll, TRUE,
  636.                                 TAG_END))
  637.             {
  638.             prefs->scrid = smr->sm_DisplayID;
  639.             prefs->scrwidth = smr->sm_DisplayWidth;
  640.             prefs->scrheight = smr->sm_DisplayHeight;
  641.             prefs->scrdepth = smr->sm_DisplayDepth;
  642.             prefs->scroscan = smr->sm_OverscanType;
  643.             prefs->scrascroll = smr->sm_AutoScroll;
  644.             success = TRUE;
  645.             }
  646.         FreeAslRequest(smr);
  647.         }
  648.     return success;
  649. }
  650.  
  651.