home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 148.lha / SetFont_v2.0 / setfont.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-11-15  |  15.9 KB  |  417 lines
  1. /* SetFont 2.0    -
  2.  
  3.         by Dave Haynie
  4.             BIX:    hazy
  5.             Usenet:    {allegra|caip|ihnp4}!cbmvax!daveh
  6.             Drink:    Guiness
  7.  
  8.    BUSINESS (MUNDANE, BUT IMPORTANT):
  9.  
  10.     This program is written by me, Dave Haynie, as mentioned above.
  11.    I have, however, placed it in the PUBLIC DOMAIN.  That, of course, means
  12.    that you can do (almost) absolutely anything with it.  You may hack it
  13.    to bits, include it with YOUR product, sell it, GIVE IT AWAY, or anything
  14.    else you like.  Of course, since anyone else can also give it away, it
  15.    would be foolish to stick your name on it and try to sell it.  I really
  16.    would like everyone to give it away, nicely, without being mean about it.
  17.    If you want to use it with your product, do that too, new products for
  18.    the Amiga are generally a good thing for the entire Amiga community.  You
  19.    can take bit and pieces and use them in your own programs, or the whole
  20.    thing for that matter.  And if you really want to have fun, you can even
  21.    IMPROVE this program, as its far from perfect, and give YOUR version 
  22.    away too, if you're so inclined.  That's about it for the (mundane)
  23.    business section, let's get on to the (interesting) notes section.
  24.  
  25.    ABOUT IT:
  26.  
  27.     This program is designed to allow you to set the font of a console
  28.    window (or really, a general WorkBench window) to any font, ROM or disk
  29.    based, that you have in mind.  This works much better than the first
  30.    version, in that it allows a greater variety of things to be changed
  31.    in the WorkBench.  What, you say, a VARIETY of things?  Well, lemme
  32.    explain....
  33.  
  34.        First off, something about fonts.  Amiga fonts all over the place
  35.    default to one of two ROM fonts, as specified in Preferences.  A ROM font
  36.    is just a font that happens to stored in with the KickStart code, instead
  37.    of out on a disk.  Since anything ever running on any Amiga can get to 
  38.    these fonts, they're used very heavily, perhaps too much.  If you've 
  39.    ever used the NotePad, however, you will probably have used some other
  40.    fonts.  These fonts are available on disk, and in fact, you can use
  41.    FontEd to create a variety of disk fonts for your own use.
  42.  
  43.    Whether disk or ROM, most programs use the Amiga's font management
  44.    utilities, which are part of the KickStart based graphics library.  But
  45.    very few folks just look at the graphics library.  Most everyone looks 
  46.    at Intuition.  Intuition manages things like screens and windows, and
  47.    you can write things to both screens and windows.  And, perhaps not
  48.    coincidentally, both screens and windows have some idea of what font they
  49.    should use, providing they've been given no special directions toward
  50.    using some other fonts.  The screen stores a pointer to a critter called
  51.    a "TextAttr", which is essentially a DESCRIPTOR for a font.  A TextAttr
  52.    contains the name of the font, the point size of the font, and a little
  53.    more information related to the font.  Both screens and windows also
  54.    contains a graphics structure, called a RastPort, which points to the
  55.    memory used to store the displayed memory.  The RastPort sports a pointer
  56.    to a different critter, the "TextFont".  The is the actual font, which is
  57.    the result of passing a TextAttr to one of the font opening functions.
  58.  
  59.        In this version I allow you to change the screen's font information,
  60.    like before, but I also know a bit more about the console window now.
  61.    When I open a window within a screen, such as the WorkBench screen, 
  62.    it's RastPort gets its default font from the screen's TextAttr font 
  63.    descriptor.  If this window is going to be a console window, it will
  64.    build a ConUnit, which has its own idea of the current font, based on
  65.    the window's font when it is created.  I can use the ROM Kernal SetFont()
  66.    call to change the font of the Window's RastPort.  Then I send an "<ESC>c"
  67.    to the console which will reinitialize the ConUnit from the window (and
  68.    also clear the screen....oh well).
  69.  
  70.     I need pointers to the window and screen to do this.  Since the 
  71.    Window structure contains a pointer to its screen, my goal is to find
  72.    the window associated with the calling console.  The best way I've found
  73.    for this is by setting up the current console as an I/O item, then
  74.    calling the DOS Info() function, which will return a pointer to the
  75.    console's window.  From this window I can get a the screen pointer and
  76.    the window's RastPort, so the fonts can be put in place.  When the
  77.    Screen's TextAttr is changed, I only change the values of that font
  78.    descriptor that the user's asked me to change.  Occasionally, this can
  79.    result in a few bytes of unreclaimed memory, as in font names:  I have no
  80.    idea how much memory is reserved in the screen's TextAttr structure on
  81.    startup.  I use the SetFont() function to set the window's or screen's
  82.    RastPort fonts.
  83.  
  84.     There are a few potential problems with my scheme.  First of all,
  85.    many programs are written to support only the topaz 8 (80 column) font
  86.    (sloppy, I know, but that's life).  If you're a 60 column user, you've 
  87.    probably experienced this before.  It's not a problem with the Amiga as
  88.    a whole, since most of the system will adjust itself.  But it may be a
  89.    problem with programs that have a fixed idea of what a font should look
  90.    like.  Most 80 column fonts work with most applications, and an 80 column
  91.    8x8 font will work just about everywhere.  Some programs, like CLI for 
  92.    instance, have trouble with proportionally-spaced fonts.  The best thing to
  93.    to is try out the font you like.  One final problem is that some
  94.    applications ask the WorkBench screen to close when they start up.  It'll
  95.    close if there's nothing else open on it, but when it re-opens, it'll
  96.    restart with the Preferences-selected font, not the SetFont selected font.
  97.    Of course, preferences doesn't support arbitrary fonts (which is why this
  98.    program is even necessary).  Oh well, maybe in 1.3?  The solution to this
  99.    is to  always keep at least one window open, so that WorkBench will never 
  100.    be closed on you.
  101. */
  102.  
  103. #include <exec/types.h>
  104. #include <exec/io.h>
  105. #include <exec/ports.h>
  106. #include <exec/memory.h>
  107. #include <graphics/gfxbase.h>
  108. #include <graphics/text.h>
  109. #include <graphics/rastport.h>
  110. #include <libraries/diskfont.h>
  111. #include <libraries/dos.h>
  112. #include <libraries/dosextens.h>
  113. #include <libraries/diskfont.h>
  114. #include <intuition/intuitionbase.h>
  115. #include <stdio.h>
  116.  
  117. /* ========================================================================= */
  118.  
  119. /* External things */
  120.  
  121. extern struct Library *OpenLibrary();
  122. extern struct TextFont *OpenFont();
  123. extern struct TextFont *OpenDiskFont();
  124. extern struct Window *OpenWindow();
  125.  
  126. extern char *strcat();
  127. extern char *strcpy();
  128. extern long strlen();
  129.  
  130. /* ========================================================================= */
  131.  
  132. /* Global variables */
  133.  
  134. struct GfxBase *GfxBase = NULL;
  135. struct Library *DiskfontBase = NULL;
  136. struct IntuitionBase *IntuitionBase = NULL;
  137.  
  138. struct MsgPort portblk = { 
  139.    {0L, 0L, NT_MSGPORT, 0, 0L}, 0, -1, 0L, 
  140.    {&portblk.mp_MsgList.lh_Tail, 0L, &portblk.mp_MsgList.lh_Head, 0, 0} 
  141. }; 
  142. struct MsgPort *port = &portblk;
  143.  
  144. struct IOStdReq reqblk = { 
  145.     {{0L, 0L, 0, 0, 0L}, &portblk, 0}, 0L, 0L, 0, 0, 0, 0L, 0L, 0L, 0L
  146. }; 
  147. struct IOStdReq *request = &reqblk;
  148.  
  149. struct Window *window = NULL;
  150. struct Screen *screen = NULL;
  151.  
  152. /* ========================================================================= */ 
  153.  
  154. /* This section contains startup and shutdown functions. */
  155.  
  156. /* This function opens the required Amiga libraries, devices, and other
  157.    good stuff.  It returns TRUE if successful.  Graphics, Intuition, and
  158.    DiskFont libraries are opened. The console device is opened and the 
  159.    I/O request message port is initialized.  I also do a check to make sure
  160.    that the associated Task is really a Process.  This is absolutely 
  161.    necessary, as some of the functions that I'll be using later are DOS
  162.    functions, which require Processes, not Tasks.  */
  163.  
  164. BOOL OpenUp()
  165. {
  166.    /* The Libraries */
  167.  
  168.    if ((GfxBase = (struct GfxBase *) 
  169.       OpenLibrary("graphics.library", 0L)) == NULL) return FALSE;
  170.    if ((DiskfontBase = OpenLibrary("diskfont.library",0L)) == NULL) return FALSE;
  171.    if ((IntuitionBase = (struct IntuitionBase *)
  172.       OpenLibrary("intuition.library", 0L)) == NULL) return FALSE;
  173.  
  174.    /* The Devices */
  175.  
  176.    if ((OpenDevice("console.device", -1L, request, 0L)) != 0L) return FALSE;
  177.    if ((port->mp_SigBit = AllocSignal(-1L)) < 0L) return FALSE;
  178.    port->mp_SigTask = (struct Task *) FindTask((char *) NULL); 
  179.    if (port->mp_SigTask->tc_Node.ln_Type != NT_PROCESS) return FALSE;
  180.    return TRUE;
  181. }
  182.  
  183. /* This function frees up dynamically opened things, like the devices
  184.    and the libraries, opened above. */
  185.  
  186. void ShutDown()
  187. { 
  188.    if (request->io_Device != NULL) { 
  189.       if (port->mp_SigBit != -1) FreeSignal(port->mp_SigBit); 
  190.       CloseDevice(request); 
  191.    } 
  192.    if (IntuitionBase != NULL) CloseLibrary(IntuitionBase); 
  193.    if (DiskfontBase != NULL) CloseLibrary(DiskfontBase);
  194.    if (GfxBase != NULL) CloseLibrary(GfxBase);
  195. } 
  196.  
  197. /* ========================================================================= */
  198.  
  199. /* Attribute based functions. */
  200.  
  201. /* This function allocates space for the given font descriptor, converting
  202.    the point size into a numeric form at the same time. */
  203.  
  204. struct TextAttr *AllocAttr(fontname, pointname)
  205. char *fontname, *pointname;
  206. {
  207.    short point;
  208.    char *str;
  209.    struct TextAttr *attr = NULL;
  210.  
  211.    attr = (struct TextAttr *) AllocMem(sizeof(*attr),0L);
  212.  
  213.    if (pointname == NULL) point = 8;
  214.    else point = atoi(pointname);
  215.  
  216.    str = (char *) AllocMem(strlen(fontname)+6L,0L);
  217.    strcpy(str,fontname);
  218.    strcat(str,".font");
  219.    attr->ta_Name = str;
  220.    attr->ta_YSize = point;
  221.    attr->ta_Style = 0;
  222.    attr->ta_Flags = 0;
  223.    return attr;
  224. }
  225.  
  226. /* This function frees a TextAttr allocated with AllocAttr(). */
  227.  
  228. void FreeAttr(attr)
  229. struct TextAttr *attr;
  230. {
  231.    if (attr == NULL) return;
  232.    FreeMem(attr->ta_Name, strlen(attr->ta_Name));
  233.    FreeMem(attr,sizeof(*attr));
  234. }
  235. /* ========================================================================= */
  236.  
  237. /* This function allocates a packet and associated info block.  It returns
  238.    a pointer to this packet if successful, NULL otherwise. */
  239.  
  240. struct StandardPacket *AllocInfoPacket()
  241. {
  242.    struct StandardPacket *pac = NULL;
  243.    struct InfoData *inf = NULL;
  244.  
  245.    pac = (struct StandardPacket *) AllocMem(sizeof(*pac), MEMF_CLEAR);
  246.    if (pac == NULL) return NULL;
  247.    inf = (struct InfoData *) AllocMem(sizeof(*inf), MEMF_CLEAR);
  248.    if (inf == NULL) {
  249.       FreeMem(pac,sizeof(*pac));
  250.       return NULL;
  251.    }
  252.    pac->sp_Msg.mn_Node.ln_Name = (char *) &(pac->sp_Pkt); 
  253.    pac->sp_Pkt.dp_Link = &(pac->sp_Msg); 
  254.    pac->sp_Pkt.dp_BufAddr = ((ULONG) inf) >> 2; 
  255.    pac->sp_Pkt.dp_Type = ACTION_DISK_INFO; 
  256.  
  257.    return pac;
  258. }
  259.  
  260. /* ========================================================================= */
  261.  
  262. /* This function gets the Window pointer for the current console.  It 
  263.    takes the message port for the console.  It uses the fact that the I/O
  264.    device's message port points to the process associated with this CLI.  
  265.    This process needs a console window, and it should have a pointer to a
  266.    message port for this purpose.  We use DOS packets to request an
  267.    InfoData block on this console window.  The window pointer is passed 
  268.    back as the volume name of the console.  We're getting into DOS, so look
  269.    out for BCPL pointers and longword alignment! */
  270.  
  271. struct Window *GetConsoleWindow(port)
  272. struct MsgPort *port;
  273. {
  274.    struct MsgPort *cp;             /* Console port */
  275.    struct InfoData *inf;        /* Packet data block */
  276.    struct StandardPacket *pac = NULL;   /* Packet for DOS request */
  277.    struct Window *w = NULL;        /* Resulting Window */
  278.  
  279.    cp = (struct MsgPort *)((struct Process *)port->mp_SigTask)->pr_ConsoleTask; 
  280.    if (cp == 0L) return NULL;
  281.  
  282.    if ((pac = AllocInfoPacket()) == NULL) return NULL;
  283.    pac->sp_Pkt.dp_Port = port; 
  284.    inf = (struct InfoData *) (((ULONG) pac->sp_Pkt.dp_BufAddr) << 2);
  285.    PutMsg(cp, pac); 
  286.    WaitPort(port); 
  287.    w = (struct Window *) inf->id_VolumeNode;
  288.    FreeMem(inf, sizeof(*inf));
  289.    FreeMem(pac, sizeof(*pac));
  290.  
  291.    return w;
  292. }
  293.  
  294. /* ========================================================================= */
  295.  
  296. /* This function tries to get a requested font from an attribute descriptor;
  297.    it returns FALSE if the font doesn't exit. */
  298.  
  299. struct TextFont *GetFont(attr)
  300. struct TextAttr *attr;
  301. {
  302.    struct TextFont *font;
  303.    
  304.    if ((font = OpenDiskFont(attr)) != NULL) return font;
  305.    if ((font = OpenFont(attr)) != NULL) return font;
  306.    return NULL;
  307. }
  308.  
  309. /* ========================================================================= */
  310.  
  311. /* The main function */
  312.  
  313. main(argc, argv) 
  314. int argc; 
  315. char *argv[]; 
  316. { 
  317.    short i;
  318.    BOOL printmode = FALSE;
  319.    BOOL mode_screen = FALSE;
  320.    BOOL mode_title = FALSE;
  321.    BOOL mode_window = FALSE;
  322.    struct TextAttr *attr = NULL;
  323.    struct TextFont *newfont, *oldfont;
  324.  
  325.    /* Automatic help command */
  326.  
  327.    if (argc == 1) printmode = TRUE;
  328.    else if (argv[1][0] == '?') {
  329.       printf("SetFont 2.0 by Dave Haynie\n\n");
  330.       printf("Usage: SetFont [fontname [point [place]]], where\n\n");
  331.       printf("  \2331mfontname\2330m  is the font's name (e.g. \"topaz\")\n");
  332.       printf("  \2331mpoint\2330m     is the point size (default is 8)\n");
  333.       printf("  \2331mplace\2330m     pick the place, one or more of:\n");
  334.       printf("    \2331mSCREEN\2330m    set the screen font only\n");
  335.       printf("    \2331mTITLES\2330m    set the screen titles only\n");
  336.       printf("    \2331mWINDOW\2330m    set the window's font only\n\n");
  337.       printf("If no \2331mplace\2330m switch is given, everything is set.\n");
  338.       Exit(10);
  339.    }
  340.  
  341.    /* Process the command-line arguments, AmigaDOS style. */
  342.  
  343.    for (i=3; i<argc; i++)
  344.       if (argv[i][0] == 'T' || argv[i][0] == 't')      mode_title = TRUE;
  345.       else if (argv[i][0] == 'S' || argv[i][0] == 's') mode_screen = TRUE;
  346.       else if (argv[i][0] == 'W' || argv[i][0] == 'w') mode_window = TRUE;
  347.    if (!mode_title && !mode_screen && !mode_window)
  348.       mode_title = mode_screen = mode_window = TRUE;
  349.    
  350.    /* First all, we've got to open all the good stuff. */
  351.  
  352.    if (!OpenUp() || (window=GetConsoleWindow(port)) == NULL) {
  353.       ShutDown();
  354.       Exit(10);
  355.    }
  356.  
  357.    /* Process the informational print mode, real simple */
  358.  
  359.    if (printmode) {
  360.       printf("SetFont 2.0 by Dave Haynie\n\n");
  361.       attr = window->WScreen->Font;
  362.       printf("Screen Font: %s (%ld) ", attr->ta_Name, attr->ta_YSize);
  363.       printf("Style %ld, Flags %ld\n", attr->ta_Style, attr->ta_Flags);
  364.       ShutDown();
  365.       Exit(0);
  366.    }
  367.  
  368.    /* Get the attribute and font, where available. */
  369.  
  370.    attr = AllocAttr(argv[1], argv[2]);
  371.    if ((newfont = GetFont(attr)) == NULL) {
  372.       printf("Error: Font not found\n");
  373.       FreeAttr(attr);
  374.       ShutDown(); 
  375.       Exit(10);
  376.    }
  377.  
  378.    /* Here's where the various options are processed individually. */
  379.  
  380.    /* The screen titling  font is changed via a SetFont() call to the 
  381.       screen's RastPort.  */
  382.  
  383.    if (mode_title) {
  384.       oldfont = window->WScreen->RastPort.Font;
  385.       if (SetFont(&window->WScreen->RastPort,newfont) == 0) CloseFont(oldfont);
  386.    }
  387.  
  388.    /* If the current font is the same font, we can just change the point
  389.       size attribute value.  If its a completely new font, the entire
  390.       attribute pointer is reassigned.  This may not be necessary, but it
  391.       works this way, and I've had trouble with other schemes.  */
  392.  
  393.    if (mode_screen) {
  394.       if (strcmp(window->WScreen->Font->ta_Name,attr->ta_Name) == 0) {
  395.          window->WScreen->Font->ta_YSize = attr->ta_YSize;
  396.          FreeAttr(attr);
  397.       } else
  398.          window->WScreen->Font = attr;
  399.    }
  400.  
  401.    /* The window font is changed via a SetFont() call to the window's
  402.       RastPort, much in the same way that the screen's titling fonts are
  403.       changed.  Additionally, the console device must be reset to force
  404.       the ConUnit to be rebuit, which draws the new font from the
  405.       window.  */
  406.  
  407.    if (mode_window) {
  408.       oldfont = window->RPort->Font;
  409.       if (SetFont(window->RPort,newfont) != 0L) CloseFont(oldfont);
  410.       printf("\033c");
  411.    }
  412.    CloseFont(newfont);
  413.    ShutDown();
  414.    Exit(0);
  415. }
  416.  
  417.