home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 581a.lha / IntuitionSupLibrary_v2.0 / Texts / source.lzh / texts.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-20  |  6.5 KB  |  288 lines
  1.         /*************************************
  2.          *                                   *
  3.          *             Texts v2.0            *
  4.          *   by Torsten Jürgeleit in 05/91   *
  5.          *                                   *
  6.          *              Routines             *
  7.          *                                   *
  8.          *************************************/
  9.  
  10.     /* Includes */
  11.  
  12. #include <exec/types.h>
  13. #include <graphics/text.h>
  14. #include <intuition/intuition.h>
  15. #include <functions.h>
  16. #include <string.h>
  17. #include "/render/render.h"
  18. #include "texts.h"
  19.  
  20.     /* Display texts described by text list */
  21.  
  22.    VOID
  23. display_texts(struct RenderInfo  *ri, struct Window  *win,
  24.              struct TextData  *td, SHORT hoffset, SHORT voffset)
  25. {
  26.    while (td->td_Type != INTUISUP_DATA_END &&
  27.                     td->td_Type <= MAX_TEXT_DATA_TYPE) {
  28.       print_text(ri, win, td->td_Text, td->td_LeftEdge + hoffset,
  29.             td->td_TopEdge + voffset, td->td_Type, td->td_Flags,
  30.                                td->td_TextAttr);
  31.       td++;
  32.    }
  33. }
  34.     /* Print text and return width of text */
  35.  
  36.    USHORT
  37. print_text(struct RenderInfo  *ri, struct Window  *win, BYTE *text,
  38.            USHORT left_edge, USHORT top_edge, USHORT type, USHORT flags,
  39.                         struct TextAttr  *text_attr)
  40. {
  41.    struct IntuiText  it;
  42.    struct TextAttr   ta;
  43.    BYTE   buffer[MAX_NUM_BUFFER_SIZE];
  44.    USHORT width;
  45.  
  46.    if (ri && text) {
  47.       /* if no text attr given then use screen text attr */
  48.       if (!text_attr) {
  49.      text_attr = &ri->ri_TextAttr;
  50.       }
  51.       /* build text attr with style described by flags */
  52.       CopyMem((BYTE *)text_attr, (BYTE *)&ta, (LONG)sizeof(struct TextAttr));
  53.       ta.ta_Style = FS_NORMAL;
  54.       if (flags & TEXT_DATA_FLAG_BOLD) {
  55.      ta.ta_Style |= FSF_BOLD;
  56.       }
  57.       if (flags & TEXT_DATA_FLAG_ITALIC) {
  58.      ta.ta_Style |= FSF_ITALIC;
  59.       }
  60.       if (flags & TEXT_DATA_FLAG_UNDERLINED) {
  61.      ta.ta_Style |= FSF_UNDERLINED;
  62.       }
  63.       /* if number then convert it to text */
  64.       switch (type) {
  65.      case TEXT_DATA_TYPE_NUM_UNSIGNED_DEC :
  66.         convert_unsigned_dec((ULONG)text, &buffer[0]);
  67.         break;
  68.      case TEXT_DATA_TYPE_NUM_SIGNED_DEC :
  69.         convert_signed_dec((LONG)text, &buffer[0]);
  70.         break;
  71.      case TEXT_DATA_TYPE_NUM_HEX :
  72.         convert_hex((ULONG)text, &buffer[0]);
  73.         break;
  74.      case TEXT_DATA_TYPE_NUM_BIN :
  75.         convert_bin((ULONG)text, &buffer[0]);
  76.         break;
  77.       }
  78.       /* init intui text */
  79.       it.LeftEdge  = 0;
  80.       it.TopEdge   = 0;
  81.       it.BackPen   = ri->ri_BackPen;
  82.       it.IText     = (UBYTE *)(type == TEXT_DATA_TYPE_TEXT ? text : &buffer[0]);
  83.       it.ITextFont = &ta;
  84.       it.NextText  = NULL;
  85.       width        = IntuiTextLength(&it);
  86.       if (!(flags & TEXT_DATA_FLAG_NO_PRINT)) {
  87.      /* perform modifications indicated by flags */
  88.      if (flags & TEXT_DATA_FLAG_CENTER) {
  89.         left_edge = (win->Width - width) / 2;
  90.      } else {
  91.         if (flags & TEXT_DATA_FLAG_PLACE_LEFT) {
  92.            left_edge -= width;
  93.         }
  94.      }
  95.      if (flags & TEXT_DATA_FLAG_COLOR2) {
  96.         it.FrontPen = ri->ri_TextPen2;
  97.      } else {
  98.         it.FrontPen = ri->ri_TextPen1;
  99.      }
  100.      if (flags & TEXT_DATA_FLAG_COMPLEMENT) {
  101.         it.FrontPen ^= (1 << ri->ri_ScreenDepth) - 1;
  102.         it.BackPen  ^= (1 << ri->ri_ScreenDepth) - 1;
  103.      }
  104.      if (flags & TEXT_DATA_FLAG_BACK_FILL) {
  105.         it.DrawMode = JAM2;
  106.      } else {
  107.         it.DrawMode = JAM1;
  108.      }
  109.      if (!(flags & TEXT_DATA_FLAG_ABSOLUTE_POS) && (ri->ri_Flags &
  110.                        RENDER_INFO_FLAG_INNER_WINDOW)) {
  111.         if (!(flags & TEXT_DATA_FLAG_CENTER)) {
  112.            left_edge += ri->ri_WindowBorderLeft;
  113.         }
  114.         top_edge  += ri->ri_WindowBorderTop;
  115.      }
  116.      if (win) {
  117.         PrintIText(win->RPort, &it, (LONG)left_edge, (LONG)top_edge);
  118.      }
  119.       }
  120.    }
  121.    return(width);
  122. }
  123.     /* Convert num to string with unsigned dec value of num */
  124.  
  125. ULONG dec_table[MAX_DEC_NUM_DIGITS] = {   /* used also by gadgets.c */
  126.    1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1
  127. };
  128.  
  129.    USHORT
  130. convert_unsigned_dec(ULONG num, BYTE *buffer)
  131. {
  132.    USHORT i, len = 0;
  133.    BYTE   digit;
  134.  
  135.    if (!num) {
  136.       if (buffer) {
  137.      *buffer++ = '0';
  138.       }
  139.       len++;
  140.    } else {
  141.       /* strip leading zeros */
  142.       for (i = 0; i < MAX_DEC_NUM_DIGITS; i++) {
  143.      if (num >= dec_table[i]) {
  144.         break;
  145.      }
  146.       }
  147.       /* convert num */
  148.       for ( ; i < MAX_DEC_NUM_DIGITS; i++) {
  149.      if (digit = num / dec_table[i]) {
  150.         num -= digit * dec_table[i];
  151.      }
  152.      if (buffer) {
  153.         *buffer++ = '0' + digit;
  154.      }
  155.      len++;
  156.       }
  157.    }
  158.    if (buffer) {
  159.       *buffer = '\0';
  160.    }
  161.    return(len);
  162. }
  163.     /* Convert num to string with signed dec value of num */
  164.  
  165.    USHORT
  166. convert_signed_dec(LONG num, BYTE *buffer)
  167. {
  168.    USHORT i, len = 0;
  169.    BYTE   digit;
  170.  
  171.    if (!num) {
  172.       if (buffer) {
  173.      *buffer++ = '0';
  174.       }
  175.       len++;
  176.    } else {
  177.       /* if num is negativ then prepend minus sign */
  178.       if (num < 0) {
  179.      if (buffer) {
  180.         *buffer++ = '-';
  181.      }
  182.      len++;
  183.      num = -num;
  184.       }
  185.       /* strip leading zeros */
  186.       for (i = 0; i < MAX_DEC_NUM_DIGITS; i++) {
  187.      if (num >= dec_table[i]) {
  188.         break;
  189.      }
  190.       }
  191.       /* convert num */
  192.       for ( ; i < MAX_DEC_NUM_DIGITS; i++) {
  193.      if (digit = num / dec_table[i]) {
  194.         num -= digit * dec_table[i];
  195.      }
  196.      if (buffer) {
  197.         *buffer++ = '0' + digit;
  198.      }
  199.      len++;
  200.       }
  201.    }
  202.    if (buffer) {
  203.       *buffer = '\0';
  204.    }
  205.    return(len);
  206. }
  207.     /* Convert num to string with hex value of num */
  208.  
  209.    USHORT
  210. convert_hex(ULONG num, BYTE *buffer)
  211. {
  212.    ULONG  mask = 0xf0000000;
  213.    USHORT len = 0;
  214.    SHORT  i;
  215.    BYTE   digit;
  216.  
  217.    if (!num) {
  218.       if (buffer) {
  219.          *buffer++ = '0';
  220.       }
  221.       len++;
  222.    } else {
  223.       /* strip leading zeros */
  224.       for (i = (MAX_HEX_NUM_DIGITS - 1) * 4; i >= 0; i -= 4) {
  225.      if (digit = (num & mask) >> i) {
  226.         break;
  227.      } else {
  228.         mask >>= 4;
  229.      }
  230.       }
  231.       /* convert num */
  232.       for ( ; i >= 0; i -= 4) {
  233.      digit     = (num & mask) >> i;
  234.      mask    >>= 4;
  235.      if (buffer) {
  236.         *buffer++ = (digit < 10 ? '0' : 'a' - 10) + digit;
  237.      }
  238.      len++;
  239.       }
  240.    }
  241.    if (buffer) {
  242.       *buffer = '\0';
  243.    }
  244.    return(len);
  245. }
  246.     /* Convert num to string with bin value of num */
  247.  
  248.    USHORT
  249. convert_bin(ULONG num, BYTE *buffer)
  250. {
  251.    ULONG  mask = 0x80000000;
  252.    USHORT i, len = 0;
  253.  
  254.    if (!num) {
  255.       if (buffer) {
  256.      *buffer++ = '0';
  257.       }
  258.       len++;
  259.    } else {
  260.       /* strip leading zeros */
  261.       for (i = 0; i < MAX_BIN_NUM_DIGITS; i++) {
  262.      if (num & mask) {
  263.         break;
  264.      } else {
  265.         mask >>= 1;
  266.      }
  267.       }
  268.       /* convert num */
  269.       for ( ; i < MAX_BIN_NUM_DIGITS; i++) {
  270.      if (num & mask) {
  271.         if (buffer) {
  272.            *buffer++ = '1';
  273.         }
  274.      } else {
  275.         if (buffer) {
  276.            *buffer++ = '0';
  277.         }
  278.      }
  279.      len++;
  280.      mask >>= 1;
  281.       }
  282.    }
  283.    if (buffer) {
  284.       *buffer = '\0';
  285.    }
  286.    return(len);
  287. }
  288.