home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSHJ2 / CALC.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  8.8 KB  |  473 lines
  1. #include    "defs.h"
  2. #include    "comp.h"
  3. #include    "table.h"
  4. #include    "cnvrt.h"
  5.  
  6. extern    int    unit_type;
  7. extern    double    modf();
  8.  
  9. /*
  10.     Function to convert unsigned integer to decimal ascii string
  11.     Divisor div specifies how many digits to convert.
  12. */
  13. utoa(buf,val,div)
  14. char     *buf;
  15. unsigned val, div;
  16. {
  17.     unsigned t;
  18.     while (div) {
  19.         while ((t = val / div) > 9)
  20.             val -= div * 10;
  21.         *buf++ = (char)t + '0';
  22.         val %= div; div /= 10;
  23.     }
  24.     *buf = 0;
  25. }
  26.  
  27. /*
  28.     Convert Point (ln) & 1/2 Point (rn) to 1/8 Point values.
  29.     Used for Point Size and Set Size. Valid rn digits are 0 & 5.
  30. */
  31. unsigned pt12(ln,rn)
  32. unsigned ln, rn;
  33. {
  34.     rn = rn == 5 ? 4:0;
  35.     return((ln * 8) + rn);
  36. }
  37.  
  38. /*
  39.     Getting Maximum X, Y and Line Space values
  40. */
  41. getmax(maxx,maxy,maxls)
  42. unsigned *maxx, *maxy, *maxls;
  43. {
  44.     int    ptype;
  45.  
  46.     ptype = get_pgtype();
  47.     if (setp.omod < 4) {            /* All Typesetters    */
  48.         *maxx    = (!setp.omod) ? 14688:15120;
  49.         *maxy    = 16128;
  50.         *maxls    = 15996;
  51.     }
  52.     else
  53.     if (setp.omod == 4) {            /* EP308 only        */
  54.         *maxx    = epxmax[ptype];
  55.     *maxls = *maxy    = epymax[ptype];
  56.     }
  57.     else {                    /* Laser only        */
  58.         *maxx    = pvxmax[ptype];
  59.     *maxls = *maxy    = pvymax[ptype];
  60.     }
  61.     if (*maxls > 15996)
  62.         *maxls    = 15996;        /* 999.3 points max    */
  63. }
  64.  
  65. /*
  66.     Conversion of machine unit integer n to Point.1/2 Point string "t".
  67.     Used for Point/Set Size fields.
  68. */
  69. mu_pt12(n,t)
  70. unsigned n;
  71. char    *t;
  72. {
  73.     utoa(t,n / 8,100);
  74.     *(t += 3) = '.';  
  75.     *(++t) = (n % 8) ? '5':'0';
  76.     *(++t) = 0;  
  77. }
  78.  
  79. /*
  80.     Conversion of machine unit long integer "n" to Hor. left/right
  81.     values string "t".
  82.     Used for Horizontal measure fields.
  83. */
  84. mu_hlrv(val,t)
  85. unsigned val;
  86. char     *t;
  87. {
  88.     double        n, ldiv, rmul, intg;
  89.     unsigned    ln, rn, ldig, rdig;
  90.  
  91.     n    = (double)val;
  92.     ldiv    = (rmul = (double)hlq[unit_type]) * hrq[unit_type];
  93.     n    /= ldiv;
  94.     n    = modf(n,&intg);
  95.     ln    = (unsigned)intg;
  96.     if (n > 0.0) {
  97.         n    *= rmul;
  98.         n    = modf(n,&intg);
  99.         rn    = (unsigned)intg;
  100.         if (n >= 0.5)
  101.             ++rn;
  102.         if (rn >= hlq[unit_type])
  103.         { rn = 0; ++ln; }
  104.     }
  105.     else    rn = 0;
  106.     if (unit_type == 2)            /* for metric    */
  107.         ldig = 100, rdig = 1;        /* show XXX.X    */
  108.     else    ldig = 10,  rdig = 10;        /* show XX.XX    */
  109.     setdspf(t,ln,rn,ldig,rdig);
  110. }
  111.  
  112. /*
  113.     Conversion of machine unit long n to Vert. left/right values
  114.     string "t".
  115.     Used for Vertical measure fields.
  116. */
  117. mu_vlrv(val,t)
  118. unsigned val;
  119. char    *t;
  120. {
  121.     double        n, ldiv, rmul, intg;
  122.     unsigned    ln, rn, ldig, rdig;
  123.  
  124.     n    = (double)val;
  125.     ldiv    = (rmul = (double)vlq[unit_type]) * vrq[unit_type];
  126.     n    /= ldiv;
  127.     n    = modf(n,&intg);
  128.     ln    = (unsigned)intg;
  129.     if (n > 0.0) {
  130.         n    *= rmul;
  131.         n    = modf(n,&intg);
  132.         rn    = (unsigned)intg;
  133.         if (n >= 0.5)
  134.             ++rn;
  135.         if (rn >= vlq[unit_type])
  136.         { rn = 0; ++ln; }
  137.     }
  138.     else    rn = 0;
  139.     if (unit_type == 0)            /* for inches    */
  140.         ldig = 10,    rdig = 10;    /* show XX.XX    */
  141.     else    ldig = 100,    rdig = 1;    /* show XXX.X    */
  142.     setdspf(t,ln,rn,ldig,rdig);
  143. }
  144.  
  145. /*
  146.     Routine to setup display string in the format of ldig.rdig
  147. */
  148. static    setdspf(t,ln,rn,ldig,rdig)
  149. char    *t;
  150. int    ln, rn, ldig, rdig;
  151. {
  152.     char    r[4];
  153.  
  154.     utoa(t,ln,ldig);
  155.     utoa(r,rn,rdig);
  156.     strcat(t,".");
  157.     strcat(t,r);
  158. }
  159.  
  160. /*
  161.     Routine to calculate character width from relative width
  162. */
  163. unsigned cwfrw(rw,k)
  164. unsigned char    rw, k;
  165. {
  166.     unsigned long    temp;
  167.     int        temp1;
  168.  
  169.     temp    = k ? (long)smsz:(long)cp.ssiz;
  170.     temp    *= (long)rw;
  171.     temp1    = (int)(temp / 24L);
  172.     if ((temp % 24L) >= 12L) ++temp1;
  173.     return(temp1);
  174. }
  175.  
  176. /*
  177.     Routine to get from font width table font data
  178. */
  179. unsigned char getfd(ofs,fp)
  180. unsigned    ofs, fp;
  181. {
  182.     return(*(pftpt+ofs+(fp * 2)));
  183. }
  184.  
  185. /*
  186.     Function to calculate the character width of argument flash position
  187.     If any Character Compensation is ON, substract it from width.
  188.     Returns -1 if character has no width.
  189. */
  190. unsigned cwffp(fp)
  191. unsigned char    fp;
  192. {
  193.     unsigned    cw;
  194.     unsigned char    rw;
  195.  
  196.     if ((rw = getfd(49,fp)) == 0xff)
  197.         cw = -1;
  198.     else {
  199.         cw = cwfrw(rw,0);
  200.         if (cp.mcomp) {
  201.           if (cw > cmpval)
  202.             cw -= cmpval;
  203.           else    cw = 0;
  204.           cmpval = cp.mcomp;
  205.         }
  206.         if (cp.acomp) {
  207.           if (cw > avcval)
  208.             cw -= avcval;
  209.           else    cw = 0;
  210.           avcval = acmp;
  211.         }
  212.     }
  213.     return(cw);
  214. }
  215.  
  216. /*
  217.     Routine to get flash position from text character
  218. */
  219. unsigned char getfp(c)
  220. unsigned char    c;
  221. {
  222.     unsigned    i;
  223.     unsigned char    fp;
  224.  
  225.     if (c == TSP)    fp = 119;
  226.     else
  227.     if (c == NSP)    fp = 120;
  228.     else
  229.     if (c == MSP)    fp = 121;
  230.     else
  231.     if ((fp = ptsfpos[c]) == 0xfe)
  232.     for (i = 0;i < 303;i += 3)
  233.         if (mcsdbl[i] == c)
  234.         { fp = mcsdbl[i+2]; break; }
  235.     return(!fp || fp > 121 ? 0xff:fp);
  236. }
  237.  
  238. /*
  239.     Function to calculate the character width from text character
  240.     Returns -1 if character undefined (no flash position).
  241. */
  242. unsigned cwidth(c)
  243. unsigned char    c;
  244. {
  245.     return((c = getfp(c)) == 0xff ? -1:cwffp(c));
  246. }
  247.  
  248. /*
  249.     Function to calculate the automatic variable character
  250.     compensation value.
  251.     i  --    0    Loosest
  252.         1    Medium
  253.         2    Tight
  254.     sz --    Set size value
  255. */
  256. aucomp(i,sz)
  257. unsigned char    i;
  258. unsigned    sz;
  259. {
  260.     int    temp, temp1, temp2;
  261.  
  262.     if (!avcc[i].var) return(0);
  263.     temp2 = sz >> 3;
  264.     if (!(temp2 -= avcc[i].zpt) ||
  265.         !(temp1 = 72 - avcc[i].zpt))
  266.         return(0);
  267.     temp2 *= avcc[i].var;
  268.     temp  = temp2 / temp1;
  269.     if (temp <= 0)
  270.         return(0);
  271.     temp2 %= temp1;
  272.     if (temp2 >= (temp1 / 2)) ++temp;
  273.     return(temp * 2);
  274. }
  275.  
  276. /*
  277.     Routine to get/load the AVCC value depending on
  278.     the current font, auto comp. mode and set size.
  279. */
  280. ldacmp()
  281. {
  282.     if (cp.acomp)
  283.         acmp = aucomp(cp.acomp - 1,cp.ssiz);
  284.     else    acmp = 0;
  285. }
  286.  
  287. /*
  288.     Routine to get from font width table AVCC data
  289.     of current font.
  290. */
  291. loadavcc()
  292. {
  293.     unsigned    i;
  294.     unsigned char    *ptr, *bptr;
  295.  
  296.     ptr    = pftpt + 35;            /* point to avcc flag    */
  297.     bptr    = pftpt + 36;            /* point to kern flag    */
  298.     kpptr    = pftpt + 779;            /* point to kern data    */
  299.     txkn    = (*(bptr) & 0x0e);        /* check any kerning    */
  300.     if (*(bptr) & 0x08)            /* kern pairs present ?    */
  301.         kpval = get_argument(pftpt + 777);    /* ok get count    */
  302.     else    kpval = 0;
  303.     if (!(*ptr & 0x01)) {            /* no Avcc clear vars    */
  304.       for (i = 0;i < 4;++i)
  305.         avcc[i].zpt = avcc[i].var = 0;
  306.     }
  307.     else {                    /* else load them...    */
  308.       ptr += 2;
  309.       for (i = 0;i < 4;++i) {
  310.         avcc[i].zpt = *(ptr++);
  311.         avcc[i].var = *(ptr++);
  312.       }
  313.     }
  314. }
  315.  
  316. /*
  317.     Routine to get from font width table sector Kerning data
  318.     of character c.
  319. */
  320. getkerval(c,ker)
  321. unsigned char    c, ker;
  322. {
  323.     unsigned char    *ptr;
  324.     unsigned    idx, i;
  325.  
  326.     kern[ker].ch = c;
  327.     idx = 289 + (unsigned)c * 4;
  328.     ptr = pftpt + idx;
  329.     for (i = 0;i < 4;++i) {
  330.         kern[ker].rval[i] = *ptr & 0x0f;
  331.         kern[ker].lval[i] = *ptr++ >> 4;
  332.     }
  333. }
  334.  
  335. /*
  336.     Routine to compute the actual sector Kerning value
  337.     of the character pair in the KERN structure.
  338. */
  339. cmpknval()
  340. {
  341.     unsigned char    min=127, *ptr;
  342.     unsigned    i, found;
  343.  
  344.     for (i = 0;i < 4;++i) {
  345.       kern[0].rval[i] += kern[1].lval[i];
  346.       if (min > kern[0].rval[i])
  347.         min = kern[0].rval[i];
  348.     }
  349.     if (kpval) {
  350.       ptr = kpptr;
  351.       found = i = 0;
  352.       while (i < kpval && !found) {
  353.         if (kern[0].ch == *ptr &&
  354.         kern[1].ch == *(ptr+1)) {
  355.         found = 1;
  356.         min += *(ptr+2);;
  357.         }
  358.         ptr += 3; ++i;
  359.       }
  360.     }
  361.     if (min) {
  362.       if (min > 127) {
  363.         min = ~min + 1;
  364.         return(0 - cwfrw(min,0));
  365.       }
  366.       else    return(cwfrw(min,0));
  367.     }
  368.     else    return(0);
  369. }
  370.  
  371.  
  372.  
  373. /*
  374.     Conversion of machine unit long integer "n" to Hor. left/right
  375.     values string "t".
  376.     Used for Horizontal measure fields.
  377. */
  378. imu_hlrv(val,t)
  379. int     val;
  380. char    *t;
  381. {
  382.     double    n, ldiv, rmul, intg;
  383.     int    ln, rn, ldig, rdig;
  384.     int    flag;
  385.  
  386.     flag = 0;
  387.     if(val < 0)
  388.     {
  389.         val = -val;
  390.         flag = 1;
  391.     }
  392.  
  393.     n    = (double)val;
  394.     ldiv    = (rmul = (double)hlq[unit_type]) * hrq[unit_type];
  395.     n    /= ldiv;
  396.     n    = modf(n,&intg);
  397.     ln    = intg;
  398.     if (n > 0.0) {
  399.         n    *= rmul;
  400.         n    = modf(n,&intg);
  401.         rn    = intg;
  402.         if (n >= 0.5)
  403.             ++rn;
  404.         if (rn >= hlq[unit_type])
  405.         { rn = 0; ++ln; }
  406.     }
  407.     else    rn = 0;
  408.     if (unit_type == 2)            /* for metric    */
  409.         ldig = 100, rdig = 1;        /* show XXX.X    */
  410.     else    ldig = 10,  rdig = 10;        /* show XX.XX    */
  411.     isetdspf(t,ln,rn,ldig,rdig,flag);
  412. }
  413.  
  414. /*
  415.     Conversion of machine unit long n to Vert. left/right values
  416.     string "t".
  417.     Used for Vertical measure fields.
  418. */
  419. imu_vlrv(val,t)
  420. int     val;
  421. char     *t;
  422. {
  423.     double    n, ldiv, rmul, intg;
  424.     int    ln, rn, ldig, rdig;
  425.     int    flag;
  426.  
  427.     flag = 0;
  428.     if(val < 0)
  429.     {
  430.         val = -val;
  431.         flag = 1;
  432.     }
  433.  
  434.     n    = (double)val;
  435.     ldiv    = (rmul = (double)vlq[unit_type]) * vrq[unit_type];
  436.     n    /= ldiv;
  437.     n    = modf(n,&intg);
  438.     ln    = intg;
  439.     if (n > 0.0) {
  440.         n    *= rmul;
  441.         n    = modf(n,&intg);
  442.         rn    = intg;
  443.         if (n >= 0.5)
  444.             ++rn;
  445.         if (rn >= vlq[unit_type])
  446.         { rn = 0; ++ln; }
  447.     }
  448.     else    rn = 0;
  449.     if (unit_type == 0)            /* for inches    */
  450.         ldig = 10,    rdig = 10;    /* show XX.XX    */
  451.     else    ldig = 100,    rdig = 1;    /* show XXX.X    */
  452.     isetdspf(t,ln,rn,ldig,rdig,flag);
  453. }
  454.  
  455.  
  456.  
  457. static    isetdspf(t,ln,rn,ldig,rdig,flag)
  458. char    *t;
  459. int    ln, rn, ldig, rdig;
  460. int    flag;
  461. {
  462.     char    r[4];
  463.     char *b;
  464.  
  465.     b = t;
  466.     if(flag)
  467.          strcpy(b++,"-");
  468.     utoa(b,ln,ldig);
  469.     utoa(r,rn,rdig);
  470.     strcat(t,".");
  471.     strcat(t,r);
  472. }
  473.