home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / usr.bin / window / ttgeneric.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-18  |  11.5 KB  |  550 lines
  1. /*
  2.  * Copyright (c) 1983 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * This code is derived from software contributed to Berkeley by
  6.  * Edward Wang at The University of California, Berkeley.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  * 2. Redistributions in binary form must reproduce the above copyright
  14.  *    notice, this list of conditions and the following disclaimer in the
  15.  *    documentation and/or other materials provided with the distribution.
  16.  * 3. All advertising materials mentioning features or use of this software
  17.  *    must display the following acknowledgement:
  18.  *    This product includes software developed by the University of
  19.  *    California, Berkeley and its contributors.
  20.  * 4. Neither the name of the University nor the names of its contributors
  21.  *    may be used to endorse or promote products derived from this software
  22.  *    without specific prior written permission.
  23.  *
  24.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34.  * SUCH DAMAGE.
  35.  */
  36.  
  37. #ifndef lint
  38. static char sccsid[] = "@(#)ttgeneric.c    3.46 (Berkeley) 8/12/90";
  39. #endif /* not lint */
  40.  
  41. #include "ww.h"
  42. #include "tt.h"
  43.  
  44. char PC, *BC, *UP;
  45. short ospeed;
  46.  
  47.     /* normal frame */
  48. short gen_frame[16] = {
  49.     ' ', '|', '-', '+',
  50.     '|', '|', '+', '+',
  51.     '-', '+', '-', '+',
  52.     '+', '+', '+', '+'
  53. };
  54.  
  55.     /* ANSI graphics frame */
  56. #define G (WWM_GRP << WWC_MSHIFT)
  57. short ansi_frame[16] = {
  58.     ' ',    'x'|G,    'Q'|G,    'm'|G,
  59.     'x'|G,    'x'|G,    'l'|G,    't'|G,
  60.     'q'|G,    'j'|G,    'q'|G,    'v'|G,
  61.     'k'|G,    'u'|G,    'w'|G,    'n'|G
  62. };
  63. struct tt_str ansi_AS = {
  64.     "\033(0", 3
  65. };
  66.  
  67. struct tt_str *gen_PC;
  68. struct tt_str *gen_CM;
  69. struct tt_str *gen_IM;
  70. struct tt_str *gen_IC;
  71. struct tt_str *gen_ICn;
  72. struct tt_str *gen_IP;
  73. struct tt_str *gen_EI;
  74. struct tt_str *gen_DC;
  75. struct tt_str *gen_DCn;
  76. struct tt_str *gen_AL;
  77. struct tt_str *gen_ALn;
  78. struct tt_str *gen_DL;
  79. struct tt_str *gen_DLn;
  80. struct tt_str *gen_CE;
  81. struct tt_str *gen_CD;
  82. struct tt_str *gen_CL;
  83. struct tt_str *gen_VS;
  84. struct tt_str *gen_VE;
  85. struct tt_str *gen_TI;
  86. struct tt_str *gen_TE;
  87. struct tt_str *gen_SO;
  88. struct tt_str *gen_SE;
  89. struct tt_str *gen_US;
  90. struct tt_str *gen_UE;
  91. struct tt_str *gen_LE;
  92. struct tt_str *gen_ND;
  93. struct tt_str *gen_UP;
  94. struct tt_str *gen_DO;
  95. struct tt_str *gen_BC;
  96. struct tt_str *gen_NL;
  97. struct tt_str *gen_CR;
  98. struct tt_str *gen_HO;
  99. struct tt_str *gen_AS;
  100. struct tt_str *gen_AE;
  101. struct tt_str *gen_XS;
  102. struct tt_str *gen_XE;
  103. struct tt_str *gen_SF;
  104. struct tt_str *gen_SFn;
  105. struct tt_str *gen_SR;
  106. struct tt_str *gen_SRn;
  107. struct tt_str *gen_CS;
  108. char gen_MI;
  109. char gen_MS;
  110. char gen_AM;
  111. char gen_OS;
  112. char gen_BS;
  113. char gen_DA;
  114. char gen_DB;
  115. char gen_NS;
  116. char gen_XN;
  117. int gen_CO;
  118. int gen_LI;
  119. int gen_UG;
  120. int gen_SG;
  121.  
  122. gen_setinsert(new)
  123. char new;
  124. {
  125.     if (new) {
  126.         if (gen_IM)
  127.             ttxputs(gen_IM);
  128.     } else
  129.         if (gen_EI)
  130.             ttxputs(gen_EI);
  131.     tt.tt_insert = new;
  132. }
  133.  
  134. gen_setmodes(new)
  135. register new;
  136. {
  137.     register diff;
  138.  
  139.     diff = new ^ tt.tt_modes;
  140.     if (diff & WWM_REV) {
  141.         if (new & WWM_REV) {
  142.             if (gen_SO)
  143.                 ttxputs(gen_SO);
  144.         } else
  145.             if (gen_SE)
  146.                 ttxputs(gen_SE);
  147.     }
  148.     if (diff & WWM_UL) {
  149.         if (new & WWM_UL) {
  150.             if (gen_US)
  151.                 ttxputs(gen_US);
  152.         } else
  153.             if (gen_UE)
  154.                 ttxputs(gen_UE);
  155.     }
  156.     if (diff & WWM_GRP) {
  157.         if (new & WWM_GRP) {
  158.             if (gen_AS)
  159.                 ttxputs(gen_AS);
  160.         } else
  161.             if (gen_AE)
  162.                 ttxputs(gen_AE);
  163.     }
  164.     if (diff & WWM_USR) {
  165.         if (new & WWM_USR) {
  166.             if (gen_XS)
  167.                 ttxputs(gen_XS);
  168.         } else
  169.             if (gen_XE)
  170.                 ttxputs(gen_XE);
  171.     }
  172.     tt.tt_modes = new;
  173. }
  174.  
  175. gen_insline(n)
  176. {
  177.     if (tt.tt_modes)            /* for concept 100 */
  178.         gen_setmodes(0);
  179.     if (gen_ALn)
  180.         ttpgoto(gen_ALn, 0, n, gen_LI - tt.tt_row);
  181.     else
  182.         while (--n >= 0)
  183.             tttputs(gen_AL, gen_LI - tt.tt_row);
  184. }
  185.  
  186. gen_delline(n)
  187. {
  188.     if (tt.tt_modes)            /* for concept 100 */
  189.         gen_setmodes(0);
  190.     if (gen_DLn)
  191.         ttpgoto(gen_DLn, 0, n, gen_LI - tt.tt_row);
  192.     else
  193.         while (--n >= 0)
  194.             tttputs(gen_DL, gen_LI - tt.tt_row);
  195. }
  196.  
  197. gen_putc(c)
  198. register char c;
  199. {
  200.     if (tt.tt_insert)
  201.         gen_setinsert(0);
  202.     if (tt.tt_nmodes != tt.tt_modes)
  203.         gen_setmodes(tt.tt_nmodes);
  204.     ttputc(c);
  205.     if (++tt.tt_col == gen_CO)
  206.         if (gen_XN)
  207.             tt.tt_col = tt.tt_row = -10;
  208.         else if (gen_AM)
  209.             tt.tt_col = 0, tt.tt_row++;
  210.         else
  211.             tt.tt_col--;
  212. }
  213.  
  214. gen_write(p, n)
  215.     register char *p;
  216.     register n;
  217. {
  218.     if (tt.tt_insert)
  219.         gen_setinsert(0);
  220.     if (tt.tt_nmodes != tt.tt_modes)
  221.         gen_setmodes(tt.tt_nmodes);
  222.     ttwrite(p, n);
  223.     tt.tt_col += n;
  224.     if (tt.tt_col == gen_CO)
  225.         if (gen_XN)
  226.             tt.tt_col = tt.tt_row = -10;
  227.         else if (gen_AM)
  228.             tt.tt_col = 0, tt.tt_row++;
  229.         else
  230.             tt.tt_col--;
  231. }
  232.  
  233. gen_move(row, col)
  234. register int row, col;
  235. {
  236.     if (tt.tt_row == row && tt.tt_col == col)
  237.         return;
  238.     if (!gen_MI && tt.tt_insert)
  239.         gen_setinsert(0);
  240.     if (!gen_MS && tt.tt_modes)
  241.         gen_setmodes(0);
  242.     if (row < tt.tt_scroll_top || row > tt.tt_scroll_bot)
  243.         gen_setscroll(0, tt.tt_nrow - 1);
  244.     if (tt.tt_row == row) {
  245.         if (col == 0) {
  246.             ttxputs(gen_CR);
  247.             goto out;
  248.         }
  249.         if (tt.tt_col == col - 1) {
  250.             if (gen_ND) {
  251.                 ttxputs(gen_ND);
  252.                 goto out;
  253.             }
  254.         } else if (tt.tt_col == col + 1) {
  255.             if (gen_LE) {
  256.                 ttxputs(gen_LE);
  257.                 goto out;
  258.             }
  259.         }
  260.     }
  261.     if (tt.tt_col == col) {
  262.         if (tt.tt_row == row + 1) {
  263.             if (gen_UP) {
  264.                 ttxputs(gen_UP);
  265.                 goto out;
  266.             }
  267.         } else if (tt.tt_row == row - 1) {
  268.             ttxputs(gen_DO);
  269.             goto out;
  270.         }
  271.     }
  272.     if (gen_HO && col == 0 && row == 0) {
  273.         ttxputs(gen_HO);
  274.         goto out;
  275.     }
  276.     tttgoto(gen_CM, col, row);
  277. out:
  278.     tt.tt_col = col;
  279.     tt.tt_row = row;
  280. }
  281.  
  282. gen_start()
  283. {
  284.     if (gen_VS)
  285.         ttxputs(gen_VS);
  286.     if (gen_TI)
  287.         ttxputs(gen_TI);
  288.     ttxputs(gen_CL);
  289.     tt.tt_col = tt.tt_row = 0;
  290.     tt.tt_insert = 0;
  291.     tt.tt_nmodes = tt.tt_modes = 0;
  292. }
  293.  
  294. gen_end()
  295. {
  296.     if (tt.tt_insert)
  297.         gen_setinsert(0);
  298.     if (gen_TE)
  299.         ttxputs(gen_TE);
  300.     if (gen_VE)
  301.         ttxputs(gen_VE);
  302. }
  303.  
  304. gen_clreol()
  305. {
  306.     if (tt.tt_modes)            /* for concept 100 */
  307.         gen_setmodes(0);
  308.     tttputs(gen_CE, gen_CO - tt.tt_col);
  309. }
  310.  
  311. gen_clreos()
  312. {
  313.     if (tt.tt_modes)            /* for concept 100 */
  314.         gen_setmodes(0);
  315.     tttputs(gen_CD, gen_LI - tt.tt_row);
  316. }
  317.  
  318. gen_clear()
  319. {
  320.     if (tt.tt_modes)            /* for concept 100 */
  321.         gen_setmodes(0);
  322.     ttxputs(gen_CL);
  323. }
  324.  
  325. gen_inschar(c)
  326. register char c;
  327. {
  328.     if (!tt.tt_insert)
  329.         gen_setinsert(1);
  330.     if (tt.tt_nmodes != tt.tt_modes)
  331.         gen_setmodes(tt.tt_nmodes);
  332.     if (gen_IC)
  333.         tttputs(gen_IC, gen_CO - tt.tt_col);
  334.     ttputc(c);
  335.     if (gen_IP)
  336.         tttputs(gen_IP, gen_CO - tt.tt_col);
  337.     if (++tt.tt_col == gen_CO)
  338.         if (gen_XN)
  339.             tt.tt_col = tt.tt_row = -10;
  340.         else if (gen_AM)
  341.             tt.tt_col = 0, tt.tt_row++;
  342.         else
  343.             tt.tt_col--;
  344. }
  345.  
  346. gen_insspace(n)
  347. {
  348.     if (gen_ICn)
  349.         ttpgoto(gen_ICn, 0, n, gen_CO - tt.tt_col);
  350.     else
  351.         while (--n >= 0)
  352.             tttputs(gen_IC, gen_CO - tt.tt_col);
  353. }
  354.  
  355. gen_delchar(n)
  356. {
  357.     if (gen_DCn)
  358.         ttpgoto(gen_DCn, 0, n, gen_CO - tt.tt_col);
  359.     else
  360.         while (--n >= 0)
  361.             tttputs(gen_DC, gen_CO - tt.tt_col);
  362. }
  363.  
  364. gen_scroll_down(n)
  365. {
  366.     gen_move(tt.tt_scroll_bot, 0);
  367.     if (gen_SFn)
  368.         ttpgoto(gen_SFn, 0, n, n);
  369.     else
  370.         while (--n >= 0)
  371.             ttxputs(gen_SF);
  372. }
  373.  
  374. gen_scroll_up(n)
  375. {
  376.     gen_move(tt.tt_scroll_top, 0);
  377.     if (gen_SRn)
  378.         ttpgoto(gen_SRn, 0, n, n);
  379.     else
  380.         while (--n >= 0)
  381.             ttxputs(gen_SR);
  382. }
  383.  
  384. gen_setscroll(top, bot)
  385. {
  386.     tttgoto(gen_CS, bot, top);
  387.     tt.tt_scroll_top = top;
  388.     tt.tt_scroll_bot = bot;
  389.     tt.tt_row = tt.tt_col = -10;
  390. }
  391.  
  392. tt_generic()
  393. {
  394.     gen_PC = tttgetstr("pc");
  395.     PC = gen_PC ? *gen_PC->ts_str : 0;
  396.     ospeed = wwospeed;
  397.  
  398.     gen_CM = ttxgetstr("cm");        /* may not work */
  399.     gen_IM = ttxgetstr("im");
  400.     gen_IC = tttgetstr("ic");
  401.     gen_ICn = tttgetstr("IC");
  402.     gen_IP = tttgetstr("ip");
  403.     gen_EI = ttxgetstr("ei");
  404.     gen_DC = tttgetstr("dc");
  405.     gen_DCn = tttgetstr("DC");
  406.     gen_AL = tttgetstr("al");
  407.     gen_ALn = tttgetstr("AL");
  408.     gen_DL = tttgetstr("dl");
  409.     gen_DLn = tttgetstr("DL");
  410.     gen_CE = tttgetstr("ce");
  411.     gen_CD = tttgetstr("cd");
  412.     gen_CL = ttxgetstr("cl");
  413.     gen_VS = ttxgetstr("vs");
  414.     gen_VE = ttxgetstr("ve");
  415.     gen_TI = ttxgetstr("ti");
  416.     gen_TE = ttxgetstr("te");
  417.     gen_SO = ttxgetstr("so");
  418.     gen_SE = ttxgetstr("se");
  419.     gen_US = ttxgetstr("us");
  420.     gen_UE = ttxgetstr("ue");
  421.     gen_LE = ttxgetstr("le");
  422.     gen_ND = ttxgetstr("nd");
  423.     gen_UP = ttxgetstr("up");
  424.     gen_DO = ttxgetstr("do");
  425.     gen_BC = ttxgetstr("bc");
  426.     gen_NL = ttxgetstr("nl");
  427.     gen_CR = ttxgetstr("cr");
  428.     gen_HO = ttxgetstr("ho");
  429.     gen_AS = ttxgetstr("as");
  430.     gen_AE = ttxgetstr("ae");
  431.     gen_XS = ttxgetstr("XS");
  432.     gen_XE = ttxgetstr("XE");
  433.     gen_SF = ttxgetstr("sf");
  434.     gen_SFn = ttxgetstr("SF");
  435.     gen_SR = ttxgetstr("sr");
  436.     gen_SRn = ttxgetstr("SR");
  437.     gen_CS = ttxgetstr("cs");
  438.     gen_MI = tgetflag("mi");
  439.     gen_MS = tgetflag("ms");
  440.     gen_AM = tgetflag("am");
  441.     gen_OS = tgetflag("os");
  442.     gen_BS = tgetflag("bs");
  443.     gen_DA = tgetflag("da");
  444.     gen_DB = tgetflag("db");
  445.     gen_NS = tgetflag("ns");
  446.     gen_XN = tgetflag("xn");
  447.     gen_CO = tgetnum("co");
  448.     gen_LI = tgetnum("li");
  449.     gen_UG = tgetnum("ug");
  450.     gen_SG = tgetnum("sg");
  451.     if (gen_CL == 0 || gen_OS || gen_CM == 0)
  452.         return -1;
  453.  
  454.     /*
  455.      * Deal with obsolete termcap fields.
  456.      */
  457.     if (gen_LE == 0)
  458.         if (gen_BC)
  459.             gen_LE = gen_BC;
  460.         else if (gen_BS) {
  461.             static struct tt_str bc = { "\b", 1 };
  462.             gen_BC = &bc;
  463.         }
  464.     if (gen_NL == 0) {
  465.         static struct tt_str nl = { "\n", 1 };
  466.         gen_NL = &nl;
  467.     }
  468.     if (gen_DO == 0)
  469.         gen_DO = gen_NL;
  470.     if (gen_CR == 0) {
  471.         static struct tt_str cr = { "\r", 1 };
  472.         gen_CR = &cr;
  473.     }
  474.     /*
  475.      * Most terminal will scroll with "nl", but very few specify "sf".
  476.      * We shouldn't use "do" here.
  477.      */
  478.     if (gen_SF == 0 && !gen_NS)
  479.         gen_SF = gen_NL;
  480.     BC = gen_LE ? gen_LE->ts_str : 0;
  481.     UP = gen_UP ? gen_UP->ts_str : 0;
  482.     /*
  483.      * Fix up display attributes that we can't handle, or don't
  484.      * really exist.
  485.      */
  486.     if (gen_SG > 0)
  487.         gen_SO = 0;
  488.     if (gen_UG > 0 || gen_US && gen_SO && ttstrcmp(gen_US, gen_SO) == 0)
  489.         gen_US = 0;
  490.  
  491.     if (gen_IM && gen_IM->ts_n == 0) {
  492.         free((char *) gen_IM);
  493.         gen_IM = 0;
  494.     }
  495.     if (gen_EI && gen_EI->ts_n == 0) {
  496.         free((char *) gen_EI);
  497.         gen_EI = 0;
  498.     }
  499.     if (gen_IC && gen_IC->ts_n == 0) {
  500.         free((char *) gen_IC);
  501.         gen_IC = 0;
  502.     }
  503.     if (gen_IM)
  504.         tt.tt_inschar = gen_inschar;
  505.     else if (gen_IC)
  506.         tt.tt_insspace = gen_insspace;
  507.     if (gen_DC)
  508.         tt.tt_delchar = gen_delchar;
  509.     if (gen_AL)
  510.         tt.tt_insline = gen_insline;
  511.     if (gen_DL)
  512.         tt.tt_delline = gen_delline;
  513.     if (gen_CE)
  514.         tt.tt_clreol = gen_clreol;
  515.     if (gen_CD)
  516.         tt.tt_clreos = gen_clreos;
  517.     if (gen_SF)
  518.         tt.tt_scroll_down = gen_scroll_down;
  519.     /*
  520.      * Don't allow scroll_up if da or db but not cs.
  521.      * See comment in wwscroll.c.
  522.      */
  523.     if (gen_SR && (gen_CS || !gen_DA && !gen_DB))
  524.         tt.tt_scroll_up = gen_scroll_up;
  525.     if (gen_CS)
  526.         tt.tt_setscroll = gen_setscroll;
  527.     if (gen_SO)
  528.         tt.tt_availmodes |= WWM_REV;
  529.     if (gen_US)
  530.         tt.tt_availmodes |= WWM_UL;
  531.     if (gen_AS)
  532.         tt.tt_availmodes |= WWM_GRP;
  533.     if (gen_XS)
  534.         tt.tt_availmodes |= WWM_USR;
  535.     tt.tt_wrap = gen_AM;
  536.     tt.tt_retain = gen_DB;
  537.     tt.tt_ncol = gen_CO;
  538.     tt.tt_nrow = gen_LI;
  539.     tt.tt_start = gen_start;
  540.     tt.tt_end = gen_end;
  541.     tt.tt_write = gen_write;
  542.     tt.tt_putc = gen_putc;
  543.     tt.tt_move = gen_move;
  544.     tt.tt_clear = gen_clear;
  545.     tt.tt_setmodes = gen_setmodes;
  546.     tt.tt_frame = gen_AS && ttstrcmp(gen_AS, &ansi_AS) == 0 ?
  547.         ansi_frame : gen_frame;
  548.     return 0;
  549. }
  550.