home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 360b.lha / showfont_v4.1 / showfont.c < prev    next >
C/C++ Source or Header  |  1990-01-28  |  39KB  |  1,536 lines
  1. /**************************************************************************/
  2. /*          ShowFont 4.1 © 1989, 1990 by Arthur Johnson Jr.          */
  3. /* ====================================================================== */
  4. /* Usage:  ShowFont [font_name] [font_size] [font_style {ubie}]       */
  5. /* ====================================================================== */
  6. /*                                      */
  7. /*   Date     STime   ETime   TTime   What?                  */
  8. /* --------   -----   -----   -----   ----------------------------------- */
  9. /* 12/18/89   18:23   19:03   00:40   Finding I didn't have all ARP stuff */
  10. /* 12/20/89   18:57   20:18   01:21   Adding the ARP file/dir requester   */
  11. /* 01/17/90   17:10   17:17   00:07   Getting ready to upload 4.1beta...  */
  12. /*                  -----                      */
  13. /*                  02:08                      */
  14. /*                                      */
  15. /**************************************************************************/
  16.  
  17. #include "intuition/intuition.h"
  18. #include "exec/memory.h"
  19. #include "libraries/diskfont.h"
  20. #include "libraries/dos.h"
  21. #include "libraries/dosextens.h"
  22. #include "libraries/ArpBase.h"
  23.  
  24. #define XAREA        20        /* no characters beyond (screenwidth - XAREA) */
  25. #define FONTBUFFER  5000    /* hopefully enough for most people */
  26. #define FONTNAMELEN 30        /* maximum font name length */
  27. #define MAXSTYLES   15        /* that should be enough */
  28. #define NUMSTYLES   4        /* Underlined, Bold, Italics, Extended */
  29.  
  30. #define MAXDISPLAY  8        /* max names, sizes, and styles to display */
  31. #define NAMELEN     20        /* maximum chars of name displayed */
  32. #define NAMEXPOS    8
  33. #define SIZEXPOS    200
  34. #define STYLXPOS    256
  35. #define TOPYPOS     8
  36.  
  37. #define BASELINE    6    /* for Topaz-8 font */
  38. #define XINCR        8
  39. #define YINCR        8
  40.  
  41. /* these are short little macro expanders to save me some typing effort */
  42. #define SIZES        fonts[namesel].sizes
  43. #define SIZESEL     fonts[namesel].sizesel
  44. #define STYLES        fonts[namesel].size[SIZESEL].styles
  45. #define STYLE        fonts[namesel].size[SIZESEL].style
  46. #define STYLESEL    fonts[namesel].size[SIZESEL].stylesel
  47.  
  48. extern struct DosLibrary *DOSBase;
  49.  
  50. extern struct NewScreen NewScreenStructure;
  51. extern struct NewWindow NewWindowStructure1;
  52. extern struct Menu Menu1;
  53. extern struct Requester FontRequesterStructure2;
  54. extern struct Requester AboutRequesterStructure3;
  55. extern struct Requester FehRequesterStructure4;
  56. extern struct Requester ScreenRequesterStructure5;
  57. extern struct Requester DirRequesterStructure6;
  58. extern struct PropInfo PropSInfo;
  59. extern struct PropInfo FontFontFontSInfo;
  60. extern struct PropInfo FontFontSizeSInfo;
  61. extern struct PropInfo FontFontStyleSInfo;
  62. extern struct Gadget Prop;
  63. extern struct Gadget FontFont;
  64. extern struct Gadget FontSize;
  65. extern struct Gadget FontStyle;
  66. extern struct Gadget ScreenGadget9;
  67. extern struct Gadget ScreenGadget10;
  68. extern struct Gadget ScreenGadget11;
  69. extern struct Gadget ScreenGadget12;
  70. extern struct Gadget ScreenGadget13;
  71. extern struct Gadget ScreenGadget14;
  72. extern struct Gadget ScreenGadget15;
  73. extern struct Gadget ScreenGadget16;
  74. extern struct Gadget ScreenGadget17;
  75. extern UBYTE DirDirNewDirSIBuff[];
  76. extern struct Gadget DirNewDir;
  77. extern UBYTE errormessage[];
  78. extern struct IntuiText FehIText15;
  79.  
  80. struct Screen *screen;
  81. struct Window *window;
  82. struct RastPort *rp;
  83. struct Gadget *whichgad;
  84. struct IntuiMessage *message;
  85.  
  86. struct IntuitionBase *IntuitionBase;
  87. struct GfxBase *GfxBase;
  88. struct DiskfontBase *DiskfontBase;
  89. struct ArpBase *ArpBase;
  90.  
  91. struct sizenode {
  92.     UWORD ysize;
  93.     int   styles;
  94.     UBYTE style[MAXSTYLES];
  95.     UBYTE flags;
  96.     int   stylesel;
  97. };
  98.  
  99. struct tempsizenode {
  100.     UWORD ysize;
  101.     int   styles;
  102.     UBYTE style[MAXSTYLES];
  103.     UBYTE flags;
  104.     struct tempsizenode *prev;
  105.     struct tempsizenode *next;
  106. };
  107.  
  108. struct fontinfo {
  109.     char    name[FONTNAMELEN + 1];
  110.     int     sizes;
  111.     struct  sizenode *size;
  112.     int     sizesel;
  113. };
  114. struct fontinfo *fonts;
  115.  
  116. struct tempfontinfo {
  117.     char    name[FONTNAMELEN + 1];
  118.     int     sizes;
  119.     struct  tempsizenode *size;
  120.     struct  tempfontinfo *prev;
  121.     struct  tempfontinfo *next;
  122. };
  123. struct tempfontinfo *tempfonts;
  124.  
  125. char fontname[FONTNAMELEN + 6]; /* include space for '.font\0' */
  126. struct TextAttr myfont = { /* necessary structure for fonts */
  127.     &fontname[0],   /* default is Topaz-8 fault */
  128.     8,
  129.     FS_NORMAL,
  130.     FPF_ROMFONT };
  131. struct TextFont *font;
  132.  
  133. struct {
  134.     UBYTE *string;
  135.     int length;
  136. } fontline[256];    /* maximum of 256 lines (one char/line) */
  137.  
  138. /* I just don't want to pass the following values around */
  139.  
  140. int numfonts;
  141.  
  142. int screenwidth = 640,
  143.     screenheight = 200,
  144.     screendepth = 2;
  145.  
  146. int nameline, sizeline, styleline,
  147.     namesel,
  148.     rfontlastline, rsizelastline, rstylelastline;
  149.  
  150. USHORT fontpropsize, fontproppos, sizepropsize, sizeproppos,
  151.     stylepropsize, styleproppos;
  152.  
  153. UBYTE qualifiers[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  154.                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  155.                0, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0, 0, 0,
  156.                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 2,
  157.                2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  158.                2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 2, 2,
  159.                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  160.                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 5,
  161.                5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  162.                5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  163.                3, 4, 4, 4, 4, 4, 4, 3, 4, 4, 4, 4, 3, 3, 3, 3,
  164.                3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 4,
  165.                4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  166.                4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 4, 4,
  167.                3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  168.                3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3 };
  169.  
  170. char whichkey[] = { '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
  171.             'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  172.             'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
  173.             'X', 'Y', 'Z', '?', '?', '?', '?', '?',
  174.             's', '1', '\'', '3', '4', '5', '7', '\'',
  175.             '9', '0', '8', '=', ',', '-', '.', '/',
  176.             '0', '1', '2', '3', '4', '5', '6', '7',
  177.             '8', '9', ';', ';', ',', '=', '.', '/',
  178.             '2', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
  179.             'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  180.             'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
  181.             'X', 'Y', 'Z', '[', '\\', ']', '6', '-',
  182.             '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
  183.             'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  184.             'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
  185.             'X', 'Y', 'Z', '[', '\\', ']', '`', '?',
  186.             '?', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
  187.             'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  188.             'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
  189.             'X', 'Y', 'Z', '?', '?', '?', '?', '?',
  190.             's', '1', '\'', '3', '4', '5', '7', '\'',
  191.             '9', '0', '8', '=', ',', '-', '.', '/',
  192.             '0', '1', '2', '3', '4', '5', '6', '7',
  193.             '8', '9', ';', ';', '-', '=', '.', '/',
  194.             '2', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
  195.             'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  196.             'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
  197.             'X', 'Y', 'Z', '[', '\\', ']', '6', '-',
  198.             '\'', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
  199.             'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  200.             'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
  201.             'X', 'Y', 'Z', '[', '\\', ']', '\'', 'm' };
  202.  
  203. void error(char *), clearfonts(), clearfontlines(), cleanup(char *),
  204.      cleartempsize(struct tempfontinfo *), cleartempfonts(),
  205.      addsizenode(struct tempfontinfo *, UWORD, UBYTE, UBYTE), readfonts(),
  206.      setupscreen(), refresh1(struct RastPort *),
  207.      refresh2(struct RastPort *), refresh3(struct RastPort *),
  208.      updateprop(struct Gadget *, struct Requester *, USHORT, USHORT),
  209.      duhprop(struct RastPort *, int), *findfonts(), makewindowtitle(char *),
  210.      main(int, char *[]);
  211.  
  212. int stylenum(UBYTE), definescreen(), findfont(),
  213.     propline(USHORT, int), selectfont(), changefontsdir();
  214.  
  215. USHORT proppos(int, int), propsize(int, int);
  216.  
  217. void error(char *s)
  218. {
  219.  
  220.     ULONG class;
  221.  
  222.     strcpy(errormessage, s);
  223.     FehIText15.LeftEdge = (100 - ((strlen(s) * XINCR) / 2));
  224.     Request(&FehRequesterStructure4, window);
  225.  
  226.     do {
  227.     while ((message = (struct IntuiMessage *)GetMsg(window->UserPort)) == 0) { }
  228.     class = message->Class;
  229.     ReplyMsg(message);
  230.     } while (class != GADGETUP);
  231.  
  232. }
  233.  
  234. void clearfonts()
  235. {
  236.  
  237.     register i;
  238.  
  239.     for (i = 0; i < numfonts; i++)
  240.     FreeMem(fonts[i].size, fonts[i].sizes * sizeof(struct sizenode));
  241.     FreeMem(fonts, numfonts * sizeof(struct fontinfo));
  242.  
  243.     numfonts = 0;   /* there are no fonts */
  244.  
  245. }
  246.  
  247. void clearfontlines()
  248. {
  249.  
  250.     register i = 0;
  251.  
  252.     while (fontline[i].length != 0) {
  253.     FreeMem(fontline[i].string, fontline[i].length);
  254.     fontline[i].length = 0;
  255.     ++i;
  256.     }
  257.  
  258. }
  259.  
  260. void cleanup(char *text)
  261. {
  262.  
  263.     clearfontlines();
  264.     clearfonts();
  265.     if (font) {
  266.     CloseFont(font);
  267.     }
  268.     if (window) {
  269.     ClearMenuStrip(window);
  270.     CloseWindow(window);
  271.     }
  272.     if (screen) {
  273.     CloseScreen(screen);
  274.     }
  275.     if (ArpBase) {
  276.     CloseLibrary(ArpBase);
  277.     }
  278.     if (DiskfontBase) {
  279.     CloseLibrary(DiskfontBase);
  280.     }
  281.     if (IntuitionBase) {
  282.     CloseLibrary(IntuitionBase);
  283.     }
  284.     if (GfxBase) {
  285.     CloseLibrary(GfxBase);
  286.     }
  287.  
  288.     if (text) {
  289.     puts(text);
  290.     }
  291.  
  292.     exit(0);
  293.  
  294. }
  295.  
  296. void cleartempsize(struct tempfontinfo *font)
  297. {
  298.  
  299.     struct tempsizenode *erase;
  300.  
  301.     while (font->size != NULL) {
  302.     erase = font->size;
  303.     font->size = font->size->next;
  304.     FreeMem(erase, sizeof(struct tempsizenode));
  305.     }
  306.  
  307. }
  308.  
  309. void cleartempfonts()
  310. {
  311.  
  312.     struct tempfontinfo *erase;
  313.  
  314.     while (tempfonts != NULL) {
  315.     erase = tempfonts;
  316.     tempfonts = tempfonts->next;
  317.     cleartempsize(erase);
  318.     FreeMem(erase, sizeof(struct tempfontinfo));
  319.     }
  320.  
  321. }
  322.  
  323. int stylenum(UBYTE style)
  324. {
  325.  
  326.     int flags = 0;
  327.  
  328.     if (style == FS_NORMAL) {
  329.     return(0);
  330.     }
  331.     if (style & FSF_UNDERLINED) {
  332.     flags |= 1;
  333.     }
  334.     if (style & FSF_BOLD) {
  335.     flags |= 2;
  336.     }
  337.     if (style & FSF_ITALIC) {
  338.     flags |= 4;
  339.     }
  340.     if (style & FSF_EXTENDED) {
  341.     flags |= 8;
  342.     }
  343.  
  344.     return(flags);
  345.  
  346. }
  347.  
  348. void addsizenode(struct tempfontinfo *font, UWORD ysize, UBYTE style, UBYTE flags)
  349. {
  350.  
  351.     struct tempsizenode *search, *prev, *newnode;
  352.  
  353.     int foundit = FALSE;
  354.  
  355.     prev = NULL;
  356.     search = font->size;
  357.     while (search != NULL) {
  358.     if ((search->ysize == ysize) && (search->flags == flags)) {
  359.         search->style[search->styles] = stylenum(style);
  360.         ++(search->styles);
  361.         foundit = TRUE;
  362.         break;
  363.     }
  364.     else {
  365.         if (search->ysize >= ysize) /* should go before this size */
  366.         break;
  367.         else {
  368.         prev = search;
  369.         search = search->next;
  370.         }
  371.     }
  372.     }
  373.     if (!foundit) {
  374.     newnode = (struct tempsizenode *)AllocMem(sizeof(struct tempsizenode), MEMF_CLEAR);
  375.     if (newnode == NULL)
  376.         cleanup("ShowFont: couldn't allocate 'tempsizenode' memory!");
  377.     newnode->ysize = ysize;
  378.     newnode->styles = 0;
  379.     newnode->flags = flags;
  380.     newnode->style[newnode->styles] = stylenum(style);
  381.     ++(newnode->styles);
  382.     ++(font->sizes);
  383.     if (font->size == NULL) {   /* list is empty */
  384.         newnode->prev = NULL;
  385.         newnode->next = NULL;
  386.         font->size = newnode;
  387.     }
  388.     else {
  389.         if (search == NULL) {   /* add at end o' list */
  390.         prev->next = newnode;
  391.         newnode->prev = prev;
  392.         newnode->next = NULL;
  393.         }
  394.         else {
  395.         if (search->prev == NULL) { /* add at beginning o' list */
  396.             newnode->prev = NULL;
  397.             newnode->next = search;
  398.             search->prev = newnode;
  399.             font->size = newnode;
  400.         }
  401.         else {    /* add in the middle o' the list */
  402.             search->prev->next = newnode;
  403.             newnode->prev = search->prev;
  404.             newnode->next = search;
  405.             search->prev = newnode;
  406.         }
  407.         }
  408.     }
  409.     }
  410.  
  411. }
  412.  
  413. void readfonts()
  414. {
  415.  
  416.     struct AvailFontsHeader *afh;
  417.     struct AvailFonts *af;
  418.  
  419.     struct tempfontinfo *search, *prev, *newnode;
  420.     struct tempsizenode *sizenode;
  421.  
  422.     char searchname[FONTNAMELEN + 6];
  423.  
  424.     int foundit;
  425.  
  426.     int mem = FONTBUFFER,
  427.     moremem;
  428.  
  429.     register i, j, k;
  430.  
  431.     clearfonts();
  432.  
  433.     do {
  434.     afh = (struct AvailFontsHeader *)AllocMem(mem, MEMF_CLEAR);
  435.     if (afh == NULL)
  436.         cleanup("ShowFont: couldn't allocate 'AvailFontsHeader' memory!");
  437.     moremem = AvailFonts(afh, mem, 0xFF);
  438.     if (moremem != 0) {
  439.         FreeMem(afh, mem);
  440.         mem += moremem;
  441.         printf("ShowFont: allocating %d bytes of memory for the FONTS: info.\n", mem);
  442.     }
  443.     } while (moremem != 0);
  444.  
  445.     if (afh->afh_NumEntries == 0) {
  446.     FreeMem(afh, mem);
  447.     cleanup("ShowFont: couldn't find any fonts! (Is FONTS: set correctly?)");
  448.     }
  449.  
  450.     tempfonts = NULL;
  451.  
  452.     af = (struct AvailFonts *)&afh[1];
  453.     for (i = 0; i < afh->afh_NumEntries; i++) {
  454.     if (!((af->af_Attr.ta_Flags & FPF_REMOVED) ||
  455.         (af->af_Attr.ta_Flags & FPF_REVPATH) ||
  456.         ((af->af_Type & AFF_MEMORY) &&
  457.          (af->af_Attr.ta_Flags & FPF_DISKFONT)))) {
  458.  
  459.         prev = NULL;
  460.         search = tempfonts;
  461.         foundit = FALSE;
  462.         while (search != NULL) {
  463.         strcpy(searchname, search->name);
  464.         strcat(searchname, ".font");
  465.         if (stricmp(af->af_Attr.ta_Name, searchname) == 0) {
  466.             addsizenode(search, af->af_Attr.ta_YSize, af->af_Attr.ta_Style, af->af_Attr.ta_Flags);
  467.             foundit = TRUE;
  468.             break;
  469.         }
  470.         else {
  471.             if (stricmp(af->af_Attr.ta_Name, searchname) < 0)
  472.             break;    /* should go before here */
  473.             else {
  474.             prev = search;
  475.             search = search->next;
  476.             }
  477.         }
  478.         }
  479.         if (!foundit) {
  480.         newnode = (struct tempfontinfo *)AllocMem(sizeof(struct tempfontinfo), MEMF_CLEAR);
  481.         if (newnode == NULL)
  482.             cleanup("ShowFont: couldn't allocate 'tempfontinfo' memory!");
  483.         stccpy(newnode->name, af->af_Attr.ta_Name, (strlen(af->af_Attr.ta_Name) - 4));
  484.         newnode->sizes = 0;
  485.         newnode->size = NULL;
  486.         addsizenode(newnode, af->af_Attr.ta_YSize, af->af_Attr.ta_Style, af->af_Attr.ta_Flags);
  487.         ++numfonts;
  488.         if (tempfonts == NULL) { /* list is empty */
  489.             newnode->prev = NULL;
  490.             newnode->next = NULL;
  491.             tempfonts = newnode;
  492.         }
  493.         else {
  494.             if (search == NULL) {   /* should add at end */
  495.             prev->next = newnode;
  496.             newnode->prev = prev;
  497.             newnode->next = NULL;
  498.             }
  499.             else {
  500.             if (search->prev == NULL) { /* add at beginning */
  501.                 newnode->prev = NULL;
  502.                 newnode->next = search;
  503.                 search->prev = newnode;
  504.                 tempfonts = newnode;
  505.             }
  506.             else { /* add in the middle o' the list */
  507.                 search->prev->next = newnode;
  508.                 newnode->prev = search->prev;
  509.                 newnode->next = search;
  510.                 search->prev = newnode;
  511.             }
  512.             }
  513.         }
  514.         }
  515.     }
  516.     af++;
  517.     }
  518.  
  519.     FreeMem(afh, mem);
  520.  
  521.     if ((fonts = (struct fontinfo *)AllocMem(numfonts * sizeof(struct fontinfo), MEMF_CLEAR)) == NULL)
  522.     cleanup("ShowFont: couldn't allocate 'fontinfo' memory!");
  523.  
  524.     search = tempfonts;
  525.  
  526.     for (i = 0; i < numfonts; i++) {
  527.     strcpy(fonts[i].name, search->name);
  528.     fonts[i].sizes = search->sizes;
  529.     if ((fonts[i].size = (struct sizenode *)AllocMem(fonts[i].sizes * sizeof(struct sizenode), MEMF_CLEAR)) == NULL)
  530.         cleanup("ShowFont: couldn't allocate 'sizenode' memory!");
  531.     sizenode = search->size;
  532.     for (j = 0; j < fonts[i].sizes; j++) {
  533.         fonts[i].size[j].ysize = sizenode->ysize;
  534.         fonts[i].size[j].styles = sizenode->styles;
  535.         for (k = 0; k < fonts[i].size[j].styles; k++)
  536.         fonts[i].size[j].style[k] = sizenode->style[k];
  537.         fonts[i].size[j].stylesel = 0;
  538.         fonts[i].size[j].flags = sizenode->flags;
  539.         sizenode = sizenode->next;
  540.     }
  541.     fonts[i].sizesel = 0;
  542.     search = search->next;
  543.     }
  544.  
  545.     cleartempfonts();
  546.  
  547. }
  548.  
  549. int definescreen()
  550. {
  551.  
  552.     struct RastPort *rp;
  553.  
  554.     int newscreenheight, newscreenwidth, newscreendepth,
  555.     y,
  556.     refresh = TRUE;
  557.  
  558.     ULONG   class;
  559.     struct Gadget *whichgad;
  560.  
  561.     newscreenheight = screenheight;
  562.     newscreenwidth = screenwidth;
  563.     newscreendepth = screendepth;
  564.  
  565.     Request(&ScreenRequesterStructure5, window);
  566.     rp = ScreenRequesterStructure5.ReqLayer->rp;
  567.  
  568.     while (0 == 0) {
  569.  
  570.     if (refresh) {
  571.  
  572.         SetAPen(rp, 0); /* clear those stupid gadgets! */
  573.         for (y = 8; y <= 71; y += 21) {
  574.         RectFill(rp, 16, y, 93, y + 10);
  575.         }
  576.         for (y = 8; y <= 72; y += 16) {
  577.         RectFill(rp, 206, y, 283, y + 10);
  578.         }
  579.  
  580.         /* non-elegant, but it works */
  581.  
  582.         ScreenGadget9.Flags = NULL;
  583.         ScreenGadget10.Flags = NULL;
  584.         ScreenGadget11.Flags = NULL;
  585.         ScreenGadget12.Flags = NULL;
  586.         ScreenGadget13.Flags = NULL;
  587.         ScreenGadget14.Flags = NULL;
  588.         ScreenGadget15.Flags = NULL;
  589.         ScreenGadget16.Flags = NULL;
  590.         ScreenGadget17.Flags = NULL;
  591.  
  592.         if ((newscreenwidth == 320) && (newscreenheight == 200)) {
  593.         ScreenGadget9.Flags = SELECTED;
  594.         }
  595.         if ((newscreenwidth == 320) && (newscreenheight == 400)) {
  596.         ScreenGadget10.Flags = SELECTED;
  597.         }
  598.         if ((newscreenwidth == 640) && (newscreenheight == 200)) {
  599.         ScreenGadget11.Flags = SELECTED;
  600.         }
  601.         if ((newscreenwidth == 640) && (newscreenheight == 400)) {
  602.         ScreenGadget12.Flags = SELECTED;
  603.         }
  604.  
  605.         switch (newscreendepth) {
  606.         case 1: ScreenGadget13.Flags = SELECTED;
  607.             break;
  608.         case 2: ScreenGadget14.Flags = SELECTED;
  609.             break;
  610.         case 3: ScreenGadget15.Flags = SELECTED;
  611.             break;
  612.         case 4: ScreenGadget16.Flags = SELECTED;
  613.             break;
  614.         case 5: ScreenGadget17.Flags = SELECTED;
  615.             break;
  616.         }
  617.  
  618.         if (newscreenwidth == 640) {
  619.         OffGadget(&ScreenGadget17, window, &ScreenRequesterStructure5);
  620.         }
  621.         else {
  622.         OnGadget(&ScreenGadget17, window, &ScreenRequesterStructure5);
  623.         }
  624.  
  625.         refresh = FALSE;
  626.  
  627.     }
  628.  
  629.     message = (struct IntuiMessage *)GetMsg(window->UserPort);
  630.     if (message != 0) {
  631.         class = message->Class;
  632.         whichgad = (struct Gadget *)message->IAddress;
  633.         ReplyMsg(message);
  634.  
  635.         if (class == GADGETUP) {
  636.         refresh = TRUE;
  637.         if (whichgad->GadgetID <= 5) {
  638.             newscreendepth = whichgad->GadgetID;
  639.         }
  640.         switch (whichgad->GadgetID) {
  641.             case 11: newscreenwidth = 320;
  642.                  newscreenheight = 200;
  643.                  break;
  644.             case 12: newscreenwidth = 320;
  645.                  newscreenheight = 400;
  646.                  break;
  647.             case 13: newscreenwidth = 640;
  648.                  newscreenheight = 200;
  649.                  if (newscreendepth == 5) {
  650.                 newscreendepth = 4;
  651.                  }
  652.                  break;
  653.             case 14: newscreenwidth = 640;
  654.                  newscreenheight = 400;
  655.                  if (newscreendepth == 5) {
  656.                 newscreendepth = 4;
  657.                  }
  658.                  break;
  659.             case 101: screenheight = newscreenheight;
  660.                   screenwidth = newscreenwidth;
  661.                   screendepth = newscreendepth;
  662.                   return(TRUE);
  663.                   break;
  664.             case 102: return(FALSE);
  665.                   break;
  666.         }
  667.         }
  668.     }
  669.     }
  670.  
  671. }
  672.  
  673. void setupscreen()
  674. {
  675.  
  676.     if (window) {
  677.     ClearMenuStrip(window);
  678.     CloseWindow(window);
  679.     }
  680.     if (screen)
  681.     CloseScreen(screen);
  682.  
  683.     NewScreenStructure.Width = screenwidth;
  684.     NewScreenStructure.Height = screenheight;
  685.     NewScreenStructure.Depth = screendepth;
  686.  
  687.     if (screenwidth == 320)
  688.     if (screenheight == 200)
  689.         NewScreenStructure.ViewModes = NULL;
  690.     else
  691.         NewScreenStructure.ViewModes = LACE;
  692.     else
  693.     if (screenheight == 200)
  694.         NewScreenStructure.ViewModes = HIRES;
  695.     else
  696.         NewScreenStructure.ViewModes = HIRES | LACE;
  697.  
  698.     NewWindowStructure1.Width = screenwidth;
  699.     NewWindowStructure1.Height = screenheight;
  700.  
  701.     if (screenwidth == 320) {
  702.     FontRequesterStructure2.LeftEdge = 0;
  703.     AboutRequesterStructure3.LeftEdge = 56;
  704.     FehRequesterStructure4.LeftEdge = 60;
  705.     ScreenRequesterStructure5.LeftEdge = 10;
  706.     DirRequesterStructure6.LeftEdge = 60;
  707.     }
  708.     else {
  709.     FontRequesterStructure2.LeftEdge = 160;
  710.     AboutRequesterStructure3.LeftEdge = 216;
  711.     FehRequesterStructure4.LeftEdge = 220;
  712.     ScreenRequesterStructure5.LeftEdge = 170;
  713.     DirRequesterStructure6.LeftEdge = 220;
  714.     }
  715.  
  716.     if (screenheight == 200) {
  717.     FontRequesterStructure2.TopEdge = 50;
  718.     AboutRequesterStructure3.TopEdge = 50;
  719.     FehRequesterStructure4.TopEdge = 75;
  720.     ScreenRequesterStructure5.TopEdge = 55;
  721.     DirRequesterStructure6.TopEdge = 75;
  722.     }
  723.     else {
  724.     FontRequesterStructure2.TopEdge = 150;
  725.     AboutRequesterStructure3.TopEdge = 150;
  726.     FehRequesterStructure4.TopEdge = 175;
  727.     ScreenRequesterStructure5.TopEdge = 155;
  728.     DirRequesterStructure6.TopEdge = 175;
  729.     }
  730.  
  731.     if ((screen = (struct Screen *)OpenScreen(&NewScreenStructure)) == NULL)
  732.     cleanup("ShowFont: couldn't open the screen.");
  733.     NewWindowStructure1.Screen = screen;
  734.  
  735.     if ((window = (struct Window *)OpenWindow(&NewWindowStructure1)) == NULL)
  736.     cleanup("ShowFont: couldn't open the window.");
  737.     rp = window->RPort;
  738.  
  739.     SetMenuStrip(window, &Menu1);
  740.  
  741. }
  742.  
  743. int findfont()
  744. {
  745.  
  746.     char searchname[FONTNAMELEN + 6];
  747.  
  748.     int low, mid, high;
  749.  
  750.     low = 0;
  751.     high = numfonts - 1;
  752.     while (low <= high) {
  753.     mid = (low + high) / 2;
  754.     strcpy(searchname, fonts[mid].name);
  755.     strcat(searchname, ".font");
  756.     if (stricmp(fontname, searchname) < 0)
  757.         high = mid - 1;
  758.     else
  759.         if (stricmp(fontname, searchname) > 0)
  760.         low = mid + 1;
  761.         else
  762.         return(mid);
  763.     }
  764.  
  765.     return(0);
  766.  
  767. }
  768.  
  769. USHORT proppos(int line, int maxline)
  770. {
  771.  
  772.     if (maxline == 1)
  773.     return((USHORT)MAXBODY);
  774.     else
  775.     return((USHORT)((MAXBODY * (line - 1)) / (maxline - 1)));
  776.  
  777. }
  778.  
  779. USHORT propsize(int display, int maxdisplay)
  780. {
  781.  
  782.     if (display >= maxdisplay)
  783.     return((USHORT)MAXPOT);
  784.     else
  785.     return((USHORT)((MAXPOT * display) / maxdisplay));
  786.  
  787. }
  788.  
  789. int propline(USHORT proppos, int maxline)
  790. {
  791.  
  792.     return((proppos * maxline) / MAXPOT);
  793.  
  794. }
  795.  
  796. void refresh1(struct RastPort *rp)
  797. {
  798.  
  799.     register loop,
  800.          x = NAMEXPOS,
  801.          y = TOPYPOS + BASELINE;
  802.  
  803.     char namestring[NAMELEN + 1];
  804.  
  805.     SetAPen(rp, 1);
  806.     SetBPen(rp, 0);
  807.  
  808.     for (loop = 0; loop < MAXDISPLAY; loop++) {
  809.     Move(rp, x, y);
  810.     SetDrMd(rp, JAM2);
  811.     if ((nameline + loop) < numfonts) {
  812.         if ((nameline + loop) == namesel)
  813.         SetDrMd(rp, JAM2 | INVERSVID);
  814.         sprintf(namestring, "%-20s", fonts[nameline + loop].name);
  815.         Text(rp, namestring, NAMELEN);
  816.     }
  817.     else
  818.         Text(rp, "                    ", NAMELEN);
  819.     y += YINCR;
  820.     }
  821.  
  822. }
  823.  
  824. void refresh2(struct RastPort *rp)
  825. {
  826.  
  827.     register loop,
  828.          x = SIZEXPOS,
  829.          y = TOPYPOS + BASELINE;
  830.  
  831.     char sizestring[3 + 1];
  832.  
  833.     for (loop = 0; loop < MAXDISPLAY; loop++) {
  834.     Move(rp, x, y);
  835.     SetDrMd(rp, JAM2);
  836.     SetBPen(rp, 0);
  837.     if ((sizeline + loop) < SIZES) {
  838.         SetAPen(rp, 1);
  839.         if (fonts[namesel].size[sizeline + loop].flags & FPF_PROPORTIONAL)
  840.         SetAPen(rp, 3);
  841.         if ((sizeline + loop) == SIZESEL)
  842.         SetDrMd(rp, JAM2 | INVERSVID);
  843.         sprintf(sizestring, "%3d", fonts[namesel].size[sizeline + loop].ysize);
  844.         Text(rp, sizestring, 3);
  845.     }
  846.     else
  847.         Text(rp, "   ", 3);
  848.     y += YINCR;
  849.     }
  850.  
  851. }
  852.  
  853. void refresh3(struct RastPort *rp)
  854. {
  855.  
  856.     register x = STYLXPOS,
  857.          y = TOPYPOS + BASELINE,
  858.          loop, i;
  859.  
  860.     unsigned char styles[NUMSTYLES];
  861.  
  862.     SetAPen(rp, 1);
  863.     SetBPen(rp, 0);
  864.  
  865.     for (loop = 0; loop < MAXDISPLAY; loop++) {
  866.     Move(rp, x, y);
  867.     SetDrMd(rp, JAM2);
  868.     if ((loop + styleline) == STYLESEL)
  869.         SetDrMd(rp, JAM2 | INVERSVID);
  870.     if ((loop + styleline) < STYLES) {
  871.         for (i = 0; i < NUMSTYLES; i++) {
  872.         styles[i] = '-';
  873.         }
  874.         if ((STYLE[(loop + styleline)] | 1) == STYLE[(loop + styleline)]) {
  875.         styles[0] = 'U';
  876.         }
  877.         if ((STYLE[(loop + styleline)] | 2) == STYLE[(loop + styleline)]) {
  878.         styles[1] = 'B';
  879.         }
  880.         if ((STYLE[(loop + styleline)] | 4) == STYLE[(loop + styleline)]) {
  881.         styles[2] = 'I';
  882.         }
  883.         if ((STYLE[(loop + styleline)] | 8) == STYLE[(loop + styleline)]) {
  884.         styles[3] = 'E';
  885.         }
  886.         Text(rp, styles, NUMSTYLES);
  887.     }
  888.     else {
  889.         for (i = 0; i < NUMSTYLES; i++) {
  890.         styles[i] = ' ';
  891.         }
  892.         Text(rp, styles, NUMSTYLES);
  893.     }
  894.     y += YINCR;
  895.     }
  896.  
  897. }
  898.  
  899. void updateprop(struct Gadget *prop, struct Requester *requester, USHORT proppos, USHORT propsize)
  900. {
  901.  
  902.     NewModifyProp(prop, window, requester, AUTOKNOB | FREEVERT, -1, proppos, -1, propsize, 1);
  903.  
  904. }
  905.  
  906. /* updatetype =  1 : refresh 1        */
  907. /*             update 2, 3    */
  908. /*             refresh 2, 3   */
  909. /*         2 : refresh 2        */
  910. /*             update 3        */
  911. /*             refresh 3        */
  912. /*         3 : refresh 3        */
  913. /*        10 : arrow 1, u/r 1 */
  914. /*        20 : arrow 2, u/r 2 */
  915. /*        30 : arrow 3, u/r 3 */
  916. void duhprop(struct RastPort *rp, int updatetype)
  917. {
  918.  
  919.     if (updatetype == 1) {
  920.     rsizelastline = (SIZES - MAXDISPLAY) + 1;
  921.     if (rsizelastline < 1)
  922.         rsizelastline = 1;
  923.     sizeline = SIZESEL;
  924.     if ((sizeline + 1) >= rsizelastline)
  925.         sizeline = rsizelastline - 1;
  926.     sizepropsize = propsize(MAXDISPLAY, SIZES);
  927.     sizeproppos = proppos((sizeline + 1), rsizelastline);
  928.     }
  929.     if (updatetype < 3) {
  930.     rstylelastline = (STYLES - MAXDISPLAY) + 1;
  931.     if (rstylelastline < 1)
  932.         rstylelastline = 1;
  933.     styleline = STYLESEL;
  934.     if ((styleline + 1) >= rstylelastline)
  935.         styleline = rstylelastline - 1;
  936.     stylepropsize = propsize(MAXDISPLAY, STYLES);
  937.     styleproppos = proppos((styleline + 1), rstylelastline);
  938.     }
  939.  
  940.     switch (updatetype) {
  941.      case 10: fontproppos = proppos((nameline + 1), rfontlastline);
  942.           break;
  943.      case 20: sizeproppos = proppos((sizeline + 1), rsizelastline);
  944.           break;
  945.      case 30: styleproppos = proppos((styleline + 1), rstylelastline);
  946.           break;
  947.     }
  948.  
  949.     switch (updatetype) {
  950.     case  1: refresh1(rp);
  951.          updateprop(&FontSize, &FontRequesterStructure2, sizeproppos, sizepropsize);
  952.          updateprop(&FontStyle, &FontRequesterStructure2, styleproppos, stylepropsize);
  953.          refresh2(rp);
  954.          refresh3(rp);
  955.          break;
  956.     case  2: refresh2(rp);
  957.          updateprop(&FontStyle, &FontRequesterStructure2, styleproppos, stylepropsize);
  958.          refresh3(rp);
  959.          break;
  960.     case  3: refresh3(rp);
  961.          break;
  962.     case 10: updateprop(&FontFont, &FontRequesterStructure2, fontproppos, fontpropsize);
  963.          refresh1(rp);
  964.          break;
  965.     case 20: updateprop(&FontSize, &FontRequesterStructure2, sizeproppos, sizepropsize);
  966.          refresh2(rp);
  967.          break;
  968.     case 30: updateprop(&FontStyle, &FontRequesterStructure2, styleproppos, stylepropsize);
  969.          refresh3(rp);
  970.          break;
  971.     }
  972.  
  973. }
  974.  
  975. int selectfont()
  976. {
  977.  
  978.     struct RastPort *rp;
  979.  
  980.     int returnvalue,
  981.     refreshhow,
  982.     x, y;
  983.  
  984.     ULONG  class;
  985.  
  986.     Request(&FontRequesterStructure2, window);
  987.     rp = FontRequesterStructure2.ReqLayer->rp;
  988.  
  989.     namesel = findfont();
  990.  
  991.     rfontlastline = numfonts - MAXDISPLAY + 1;
  992.     if (rfontlastline < 1)
  993.     rfontlastline = 1;
  994.     fontpropsize = propsize(MAXDISPLAY, numfonts);
  995.  
  996.     nameline = namesel;
  997.     if ((nameline + 1) >= rfontlastline)
  998.     nameline = rfontlastline - 1;
  999.  
  1000.     duhprop(rp, 1);
  1001.     duhprop(rp, 10);
  1002.  
  1003.     refreshhow = 0;
  1004.     returnvalue = 0;
  1005.  
  1006.     while (returnvalue == 0) {
  1007.     switch (refreshhow) {
  1008.         case 11: if (nameline > 0)
  1009.              --nameline;
  1010.              duhprop(rp, 10);
  1011.              break;
  1012.         case 12: nameline = propline(FontFontFontSInfo.VertPot, rfontlastline);
  1013.              if ((nameline + 1) >= rfontlastline)
  1014.              nameline = rfontlastline - 1;
  1015.              refresh1(rp);
  1016.              break;
  1017.         case 13: if ((nameline + 1) < rfontlastline)
  1018.              ++nameline;
  1019.              duhprop(rp, 10);
  1020.              break;
  1021.         case 21: if (sizeline > 0)
  1022.              --sizeline;
  1023.              duhprop(rp, 20);
  1024.              break;
  1025.         case 22: sizeline = propline(FontFontSizeSInfo.VertPot, rsizelastline);
  1026.              if ((sizeline + 1) >= rsizelastline)
  1027.              sizeline = rsizelastline - 1;
  1028.              refresh2(rp);
  1029.              break;
  1030.         case 23: if ((sizeline + 1) < rsizelastline)
  1031.              ++sizeline;
  1032.              duhprop(rp, 20);
  1033.              break;
  1034.         case 31: if (styleline > 0)
  1035.              --styleline;
  1036.              duhprop(rp, 30);
  1037.              break;
  1038.         case 32: styleline = propline(FontFontStyleSInfo.VertPot, rstylelastline);
  1039.              if ((styleline + 1) >= rstylelastline)
  1040.              styleline = rstylelastline - 1;
  1041.              refresh3(rp);
  1042.              break;
  1043.         case 33: if ((styleline + 1) < rstylelastline)
  1044.              ++styleline;
  1045.              duhprop(rp, 30);
  1046.              break;
  1047.     }
  1048.  
  1049.     message = (struct IntuiMessage *)GetMsg(window->UserPort);
  1050.     if (message != 0) {
  1051.         class = message->Class;
  1052.         x = message->MouseX - FontRequesterStructure2.LeftEdge;
  1053.         y = message->MouseY - FontRequesterStructure2.TopEdge;
  1054.         whichgad = (struct Gadget *)message->IAddress;
  1055.         ReplyMsg(message);
  1056.  
  1057.         if (class == GADGETDOWN) {
  1058.         refreshhow = whichgad->GadgetID;
  1059.         }
  1060.         if (class == GADGETUP) {
  1061.         switch (whichgad->GadgetID) {
  1062.             case 101: returnvalue = 1;
  1063.                   break;
  1064.             case 102: returnvalue = -1;
  1065.                   break;
  1066.         }
  1067.         refreshhow = 0; /* no more auto-scrolling */
  1068.         }
  1069.         if (class == MOUSEBUTTONS) {
  1070.         if ((y >= 0) && (y < 100) && (x >= 0) && (x < 320)) {
  1071.             y -= TOPYPOS;
  1072.             y = y / YINCR;
  1073.             if (y < MAXDISPLAY) {
  1074.             if ((x >= NAMEXPOS) && (x < (NAMEXPOS + NAMELEN * XINCR))) {
  1075.                 if (namesel == (nameline + y)) {
  1076.                 returnvalue = 1;
  1077.                 EndRequest(&FontRequesterStructure2, window);
  1078.                 }
  1079.                 else {
  1080.                 namesel = nameline + y;
  1081.                 if (namesel >= numfonts)
  1082.                     namesel = numfonts - 1;
  1083.                 duhprop(rp, 1);
  1084.                 }
  1085.             }
  1086.             if ((x >= SIZEXPOS) && (x < (SIZEXPOS + 3 * XINCR))) {
  1087.                 if (SIZESEL == (sizeline + y)) {
  1088.                 returnvalue = 1;
  1089.                 EndRequest(&FontRequesterStructure2, window);
  1090.                 }
  1091.                 else {
  1092.                 SIZESEL = sizeline + y;
  1093.                 if (SIZESEL >= SIZES)
  1094.                     SIZESEL = SIZES - 1;
  1095.                 duhprop(rp, 2);
  1096.                 }
  1097.             }
  1098.             if ((x >= STYLXPOS) && (x < (STYLXPOS + 4 * XINCR))) {
  1099.                 if (STYLESEL == (styleline + y)) {
  1100.                 returnvalue = 1;
  1101.                 EndRequest(&FontRequesterStructure2, window);
  1102.                 }
  1103.                 else {
  1104.                 STYLESEL = styleline + y;
  1105.                 if (STYLESEL >= STYLES)
  1106.                     STYLESEL = STYLES - 1;
  1107.                 duhprop(rp, 3);
  1108.                 }
  1109.             }
  1110.             }
  1111.         }
  1112.         }
  1113.     }
  1114.     }
  1115.  
  1116.     if (returnvalue == 1) {
  1117.     strcpy(fontname, fonts[namesel].name);
  1118.     strcat(fontname, ".font");
  1119.     myfont.ta_YSize = fonts[namesel].size[SIZESEL].ysize;
  1120.     myfont.ta_Style = STYLE[STYLESEL];
  1121.     myfont.ta_Flags = fonts[namesel].size[SIZESEL].flags;
  1122.     }
  1123.  
  1124.     return(returnvalue);
  1125.  
  1126. }
  1127.  
  1128. void *findfonts()
  1129. {
  1130.  
  1131.     struct RootNode *root;
  1132.     struct DosInfo *info;
  1133.     struct DevInfo *dev_node;
  1134.  
  1135.     char *name;
  1136.  
  1137.     root=(struct RootNode *)DOSBase->dl_Root;
  1138.     info=(struct DosInfo *)BADDR(root->rn_Info);
  1139.  
  1140.     Forbid();
  1141.  
  1142.     for (dev_node = (struct DevInfo *)BADDR(info->di_DevInfo);
  1143.      dev_node->dvi_Next != NULL;
  1144.      dev_node = (struct DevInfo *)BADDR(dev_node->dvi_Next)) {
  1145.  
  1146.     name = (char *)BADDR(dev_node->dvi_Name);
  1147.     if ((*name == 5) && (strnicmp((name + 1), "FONTS", 5) == 0)) {
  1148.         return(dev_node);
  1149.     }
  1150.  
  1151.     }
  1152.  
  1153.     return(NULL);
  1154.  
  1155. }
  1156.  
  1157. int changefontsdir()
  1158. {
  1159.  
  1160.     struct DevInfo *info;
  1161.     struct FileLock *lock;
  1162.  
  1163.     struct FileRequester *fr;
  1164.  
  1165.     ULONG class;
  1166.     struct Gadget *whichgad;
  1167.  
  1168.     int itsok;
  1169.  
  1170.     char dirname[256];
  1171.  
  1172.     if (ArpBase == NULL) {
  1173.     Request(&DirRequesterStructure6, window);
  1174.     Delay(10);
  1175.     ActivateGadget(&DirNewDir, window, &DirRequesterStructure6);
  1176.  
  1177.     while (TRUE) {
  1178.         while ((message = (struct IntuiMessage *)GetMsg(window->UserPort)) == 0) { }
  1179.         class = message->Class;
  1180.         whichgad = (struct Gadget *)message->IAddress;
  1181.         ReplyMsg(message);
  1182.  
  1183.         if (class == GADGETUP) {
  1184.         if (whichgad->GadgetID == 101) {
  1185.             strcpy(dirname, DirDirNewDirSIBuff);
  1186.             itsok = TRUE;
  1187.         }
  1188.         else {
  1189.             itsok = FALSE;
  1190.         }
  1191.         break;
  1192.         }
  1193.     }
  1194.     }
  1195.     else {
  1196.     fr = ArpAllocFreq();
  1197.     fr->fr_Window = window;
  1198.     if (FileRequest(fr) != NULL) {
  1199.         strcpy(dirname, fr->fr_Dir);
  1200.         itsok = TRUE;
  1201.     }
  1202.     else {
  1203.         itsok = FALSE;
  1204.     }
  1205.     }
  1206.  
  1207.     if (itsok) {
  1208.     lock = (struct FileLock *)Lock(dirname, ACCESS_READ);
  1209.     if (lock == NULL) {
  1210.         error("DIR NOT FOUND!");
  1211.         return(FALSE);
  1212.     }
  1213.     else {
  1214.         info = (struct DevInfo *)findfonts();
  1215.         UnLock(info->dvi_Lock);
  1216.         info->dvi_Lock = (BPTR)lock;
  1217.         info->dvi_Task = (APTR)(DeviceProc(DirDirNewDirSIBuff));
  1218.         Permit();
  1219.         return(TRUE);
  1220.     }
  1221.     }
  1222.     else {
  1223.     return(FALSE);
  1224.     }
  1225.  
  1226. }
  1227.  
  1228. void makewindowtitle(char *s)
  1229. {
  1230.  
  1231.     stccpy(s, fontname, (strlen(fontname) - 4));
  1232.     sprintf(s + strlen(s), " - %d", myfont.ta_YSize);
  1233.     if ((myfont.ta_Style | 1) == myfont.ta_Style) {
  1234.     strcat(s, "u");
  1235.     }
  1236.     if ((myfont.ta_Style | 2) == myfont.ta_Style) {
  1237.     strcat(s, "b");
  1238.     }
  1239.     if ((myfont.ta_Style | 4) == myfont.ta_Style) {
  1240.     strcat(s, "i");
  1241.     }
  1242.     if ((myfont.ta_Style | 8) == myfont.ta_Style) {
  1243.     strcat(s, "e");
  1244.     }
  1245.  
  1246. }
  1247.  
  1248. void main(int argc, char *argv[])
  1249. {
  1250.  
  1251.     int cont = TRUE,
  1252.     rethinkfont = TRUE;
  1253.  
  1254.     ULONG   class;
  1255.     USHORT  code;
  1256.  
  1257.     int line, maxline,
  1258.     yarea,
  1259.     len, pixels,
  1260.     whichmenu, whichitem,
  1261.     wproplastline,
  1262.     refreshhow,
  1263.     x, y;
  1264.  
  1265.     char windowtitle[81];
  1266.  
  1267.     USHORT numy, pos, size;
  1268.  
  1269.     register loop, i;
  1270.  
  1271.     UBYTE textline[256], character;
  1272.  
  1273.     if ((argc == 2) && (*argv[1] == '?'))
  1274.     cleanup("Usage: ShowFont [font_name] [font_size] [ubie]");
  1275.  
  1276.     if ((IntuitionBase = (struct IntuitionBase *)
  1277.         OpenLibrary("intuition.library", 0)) == NULL)
  1278.     cleanup("ShowFont: couldn't open 'intuition.library'.");
  1279.  
  1280.     if ((GfxBase = (struct GfxBase *)
  1281.         OpenLibrary("graphics.library", 0)) == NULL)
  1282.     cleanup("ShowFont: couldn't open 'graphics.library'.");
  1283.  
  1284.     if ((DiskfontBase = (struct DiskfontBase *)
  1285.         OpenLibrary("diskfont.library", 0)) == NULL)
  1286.     cleanup("ShowFont: couldn't open 'diskfont.library'.");
  1287.  
  1288.     ArpBase = (struct ArpBase *)OpenLibrary(ArpName, ArpVersion);
  1289.  
  1290.     setupscreen();
  1291.  
  1292.     fonts = NULL;
  1293.  
  1294.     if (argc == 1)
  1295.     strcpy(fontname, "Topaz.font");
  1296.     else
  1297.     sprintf(fontname, "%s.font", argv[1]);
  1298.     if (argc < 3) {
  1299.     readfonts();
  1300.     selectfont();
  1301.     }
  1302.     else {
  1303.     myfont.ta_YSize = atoi(argv[2]);
  1304.     if (argc == 4) {
  1305.         myfont.ta_Style = FS_NORMAL;
  1306.         for (loop = 0; loop < strlen(argv[3]); loop++) {
  1307.         switch (*(argv[3] + loop) & ~0x20) {
  1308.             case 'U': myfont.ta_Style |= 1;
  1309.                   break;
  1310.             case 'B': myfont.ta_Style |= 2;
  1311.                   break;
  1312.             case 'I': myfont.ta_Style |= 4;
  1313.                   break;
  1314.             case 'E': myfont.ta_Style |= 8;
  1315.                   break;
  1316.         }
  1317.         }
  1318.     }
  1319.     }
  1320.  
  1321.     for (i = 0; i < 256; ++i)
  1322.     fontline[i].length = 0;
  1323.  
  1324.     while (cont) {
  1325.  
  1326.     if (rethinkfont) {
  1327.  
  1328.         if (font)
  1329.         CloseFont(font);
  1330.  
  1331.         if ((font = (struct TextFont *)OpenDiskFont(&myfont)) == NULL) {
  1332.         error("FONT NOT FOUND!");
  1333.         strcpy(fontname, "Topaz.font");
  1334.         myfont.ta_YSize = 8;
  1335.         myfont.ta_Style = FS_NORMAL;
  1336.         myfont.ta_Flags = FPF_ROMFONT;
  1337.         if ((font = (struct TextFont *)OpenDiskFont(&myfont)) == NULL) {
  1338.             cleanup("ShowFont: couldn't default to Topaz-8!");
  1339.         }
  1340.         }
  1341.  
  1342.         if (myfont.ta_YSize > screenheight) {
  1343.         screenheight = 400;
  1344.         setupscreen();
  1345.         }
  1346.  
  1347.         SetFont(rp, font);
  1348.  
  1349.         clearfontlines();
  1350.  
  1351.         line = 0;
  1352.         len = 0;
  1353.  
  1354.         for (loop = font->tf_LoChar; loop <= font->tf_HiChar; ++loop) {
  1355.         textline[len++] = loop;
  1356.         pixels = TextLength(rp, textline, len) + window->BorderLeft;
  1357.         if (((pixels > (screenwidth - XAREA)) && (len > 1)) ||
  1358.             ((pixels <= (screenwidth - XAREA)) && (loop == font->tf_HiChar))) {
  1359.             if (pixels > (screenwidth - XAREA)) {
  1360.             --len;
  1361.             }
  1362.             fontline[line].string = (UBYTE *)AllocMem(len, MEMF_CLEAR);
  1363.             if (fontline[line].string == NULL)
  1364.             cleanup("ShowFont: couldn't allocate 'fontline' memory!");
  1365.             for (i = 0; i < len; i++) {
  1366.             fontline[line].string[i] = textline[i];
  1367.             }
  1368.             fontline[line].length = len;
  1369.             ++line;
  1370.             len = 0;
  1371.             if ((pixels > (screenwidth - XAREA)) && (loop <= font->tf_HiChar)) {
  1372.             --loop; /* must go back and insert that character */
  1373.             }
  1374.         }
  1375.         else {
  1376.             if (pixels > (screenwidth - XAREA)) {
  1377.             len = 0; /* don't include this character */
  1378.             }
  1379.         }
  1380.         }
  1381.  
  1382.         maxline = line;
  1383.         line = 0;
  1384.         yarea = screenheight - (window->BorderTop + window->BorderBottom);
  1385.         numy = yarea / font->tf_YSize;
  1386.  
  1387.         wproplastline = (maxline - numy) + 1;
  1388.         if (wproplastline < 1)
  1389.         wproplastline = 1;
  1390.  
  1391.         size = propsize(numy, maxline);
  1392.  
  1393.         makewindowtitle(windowtitle);
  1394.  
  1395.         makewindowtitle(windowtitle);
  1396.         SetWindowTitles(window, windowtitle, -1);
  1397.  
  1398.         rethinkfont = FALSE;
  1399.         refreshhow = 99;    /* refresh it once only */
  1400.     }
  1401.  
  1402.     switch (refreshhow) {
  1403.         case  1: if (line > 0)
  1404.              --line;
  1405.              break;
  1406.         case  2: pos = PropSInfo.VertPot;
  1407.              line = propline(pos, wproplastline);
  1408.              if ((line + 1) > wproplastline)
  1409.              line = wproplastline - 1;
  1410.              break;
  1411.         case  3: if ((line + 1) < wproplastline)
  1412.              ++line;
  1413.              break;
  1414.     }
  1415.  
  1416.     if (refreshhow != 0) {
  1417.  
  1418.         pos = proppos((line + 1), wproplastline);
  1419.  
  1420.         if (refreshhow != 2)    /* don't blink the slider */
  1421.         NewModifyProp(&Prop, window, NULL, AUTOKNOB | FREEVERT, -1, pos, -1, size, 1);
  1422.  
  1423.         WaitTOF();  /* might just possibly reduce blinking */
  1424.         SetAPen(rp, 0); /* clear the screen */
  1425.         RectFill(rp, window->BorderLeft, window->BorderTop, (screenwidth - XAREA), (screenheight - window->BorderBottom));
  1426.  
  1427.         SetAPen(rp, 1);
  1428.         SetBPen(rp, 0);
  1429.         SetDrMd(rp, JAM2);
  1430.  
  1431.         for (i = line; i < (line + numy); ++i) {
  1432.         Move(rp, window->BorderLeft, ((i - line) * font->tf_YSize) + window->BorderTop + font->tf_Baseline);
  1433.         Text(rp, fontline[i].string, fontline[i].length);
  1434.         }
  1435.  
  1436.         if (refreshhow == 99)
  1437.         refreshhow = 0; /* for initial refreshment only */
  1438.     }
  1439.  
  1440.     message = (struct IntuiMessage *)GetMsg(window->UserPort);
  1441.     if (message != 0) {
  1442.         class = message->Class;
  1443.         code  = message->Code;
  1444.         whichgad = (struct Gadget *)message->IAddress;
  1445.         x = message->MouseX;
  1446.         y = message->MouseY;
  1447.         ReplyMsg(message);
  1448.  
  1449.         if (class == CLOSEWINDOW)
  1450.         cont = FALSE;
  1451.         if (class == GADGETDOWN)
  1452.         refreshhow = whichgad->GadgetID;
  1453.         if (class == GADGETUP)
  1454.         refreshhow = 0; /* stop scrolling */
  1455.         if (class == MOUSEBUTTONS) {
  1456.         y -= window->BorderTop;
  1457.         y /= font->tf_YSize;
  1458.         if (y < maxline) {
  1459.             for (loop = 0; loop < fontline[(y + line)].length; loop++) {
  1460.             textline[loop] = fontline[(y + line)].string[loop];
  1461.             pixels = TextLength(rp, textline, (loop + 1)) + window->BorderLeft;
  1462.             if (x <= pixels)
  1463.                 break;
  1464.             }
  1465.             character = fontline[(y + line)].string[loop];
  1466.             switch (qualifiers[character]) {
  1467.             case 0: textline[0] = '\0';
  1468.                 break;
  1469.             case 1: strcpy(textline, "CONTROL-");
  1470.                 break;
  1471.             case 2: strcpy(textline, "SHIFT-");
  1472.                 break;
  1473.             case 3: strcpy(textline, "ALT-");
  1474.                 break;
  1475.             case 4: strcpy(textline, "ALT-SHIFT-");
  1476.                 break;
  1477.             case 5: strcpy(textline, "CONTROL-ALT-");
  1478.                 break;
  1479.             }
  1480.             len = strlen(textline);
  1481.             textline[len] = whichkey[character];
  1482.             textline[len + 1] = '\0';
  1483.             makewindowtitle(windowtitle);
  1484.             strcat(windowtitle, " (");
  1485.             strcat(windowtitle, textline);
  1486.             sprintf(windowtitle + strlen(windowtitle),
  1487.             ") [Dec %03d Hex $%02x]", character, character);
  1488.             SetWindowTitles(window, windowtitle, -1);
  1489.             while ((message = (struct IntuiMessage *)GetMsg(window->UserPort)) != 0)
  1490.             ReplyMsg(message);
  1491.         }
  1492.         }
  1493.         if (class == MENUPICK) {
  1494.         if (code != MENUNULL) {
  1495.             whichmenu = MENUNUM(code);
  1496.             whichitem = ITEMNUM(code);
  1497.             switch (whichmenu) {
  1498.             case 0 : switch (whichitem) {
  1499.                     case 0: Request(&AboutRequesterStructure3, window); /* about */
  1500.                         while ((message = (struct IntuiMessage *)GetMsg(window->UserPort)) != 0)
  1501.                         ReplyMsg(message);
  1502.                         break;
  1503.                     case 1: cont = FALSE; /* quit */
  1504.                         break;
  1505.                  }
  1506.                  break;
  1507.             case 1 : switch (whichitem) {
  1508.                     case 0: if (changefontsdir() == TRUE) {
  1509.                         readfonts();
  1510.                         if (selectfont() == 1) {
  1511.                             rethinkfont = TRUE;
  1512.                         }
  1513.                         }
  1514.                         break;
  1515.                     case 1: if (fonts == NULL)
  1516.                         readfonts();
  1517.                         if (selectfont() == 1)
  1518.                         rethinkfont = TRUE;
  1519.                         break; /* font selection */
  1520.                  }
  1521.                  break;
  1522.             case 2 : if (definescreen() == TRUE) {
  1523.                      setupscreen();
  1524.                      rethinkfont = TRUE;
  1525.                  }
  1526.                  break;
  1527.             }
  1528.         }
  1529.         }
  1530.     }
  1531.     }
  1532.  
  1533.     cleanup(NULL);
  1534.  
  1535. }
  1536.