home *** CD-ROM | disk | FTP | other *** search
/ ftp.update.uu.se / ftp.update.uu.se.2014.03.zip / ftp.update.uu.se / pub / rainbow / cpm / emacs / emacssrc.lzh / meupdate.c < prev    next >
C/C++ Source or Header  |  1992-03-11  |  4KB  |  166 lines
  1. /*
  2.  * The functions in this file
  3.  * handle redisplay. There are two halves,
  4.  * the ones that update the virtual display
  5.  * screen, and the ones that make the physical
  6.  * display screen the same as the virtual
  7.  * display screen. These functions use hints
  8.  * that are left in the windows by the
  9.  * commands.
  10.  */
  11. #define OWNER
  12. #include "medisp.h"
  13.  
  14. /*
  15.  * Make sure that the display is
  16.  * right. This is a three part process. First,
  17.  * scan through all of the windows looking for dirty
  18.  * ones. Check the framing, and refresh the screen.
  19.  * Second, make sure that "currow" and "curcol" are
  20.  * correct for the current window. Third, make the
  21.  * virtual and physical screens the same.
  22.  */
  23. extern char * Argv[];
  24. update()
  25. {
  26.     register LINE    *lp;
  27.     register WINDOW    *wp;
  28. #define vp1 (*(VIDEO **)0x108)
  29. #define i   (*(int *)0x10c)
  30. #define c   (*(int *)0x10e)
  31. #define lp2 (*(LINE **)0x110)
  32. #define wrows (*(int *)0x112)
  33. /* lp2 and wrows will be wiped out when meupdate is called. */
  34.  
  35.     wp = wheadp;
  36.     while (wp != NULL)
  37.     {    /* Look at any window with update flags set on.        */
  38.         wrows = wp->w_ntrows;
  39.         lp2 = wp->w_bufp->b_linep;
  40.  
  41.         if (wp->w_flag != 0)
  42.         {    /* If not force reframe, check the framing.    */
  43.             if ( ( wp->w_flag & WFFORCE ) == 0 )
  44.             {    lp = wp->w_linep;
  45.                 for ( i = 0 ; ++i <= wrows; )
  46.                 {    if ( lp == wp->w_dotp )
  47.                         goto out;
  48.                     if ( lp == lp2 )
  49.                         break;
  50.                     lp = lforw(lp);
  51.                 }
  52.             }
  53.             /* Not acceptable, better compute a new value    */
  54.             /* for the line at the top of the window. Then    */
  55.             /* set the "WFHARD" flag to force full redraw.    */
  56.             if ( ( i = wp->w_force ) > 0)
  57.             {    if ( --i >= wrows )
  58.                     i = wrows - 1;
  59.             } else if ( i < 0 )
  60.             {    i += wrows;
  61.                 if ( i < 0 ) i = 0;
  62.             } else     i = wrows >> 1;
  63.             lp = wp->w_dotp;
  64.             while ( --i >= 0 && lback(lp) != lp2 )
  65.             {    lp = lback(lp);
  66.             }
  67.             wp->w_linep = lp;
  68.             wp->w_flag |= WFHARD;    /* Force full.        */
  69. out:
  70. /* Try to use reduced update. Mode line update    */
  71. /* has its own special flag. The fast update is    */
  72. /* used if the only thing to do is within the    */
  73. /* line editing.                */
  74.             lp = wp->w_linep;
  75.             i  = wp->w_toprow;
  76.             if ( wp->w_flag & WFMODE )
  77.             {    Argv[3] = (char *)wp;
  78.                 ovloader( 28, 0 );
  79.             }    /* modeline(wp); */
  80.             if ( wp->w_flag & WFHARD )
  81.             {    while ( i < wp->w_toprow + wrows )
  82.                 {    if ( ! cramline( lp, wp ))
  83.                         lp = lforw(lp);
  84.                     ++i;/* cramline uses i... */
  85.                 }
  86.             }
  87.             else if (wp->w_flag & WFEDIT)
  88.             {    while (lp != wp->w_dotp)
  89.                 {    ++i;
  90.                     lp = lforw(lp);
  91.                 }
  92.                 cramline( lp, wp );
  93.             }
  94.             wp->w_flag  = 0;
  95.             wp->w_force = 0;
  96.         }
  97. /*#if    WFDEBUG
  98. /*        modeline(wp);
  99. /*        wp->w_flag =  0;
  100. /*        wp->w_force = 0;
  101. /*#endif*/
  102.         wp = wp->w_wndp;
  103.     }
  104.     /* Always recompute the row and column number of the hardware    */
  105.     /* cursor. This is the only update for simple moves.        */
  106.     lp = curwp->w_linep;
  107.     currow = curwp->w_toprow;
  108.     while (lp != curwp->w_dotp)
  109.     {    ++currow;
  110.         lp = lforw(lp);
  111.     }
  112.     curcol = 0;
  113.     i = 0;
  114.     while (i < curwp->w_doto)
  115.     {    c = lgetc(lp, i++);
  116.         if (c == '\t') curcol |= 0x07;
  117.         else if ( ! isinsert( c )) ++curcol;
  118.         ++curcol;
  119.     }
  120.     if (curcol >= 80)        /* Long line.        */
  121.         curcol = 79;
  122.     /* Special hacking if the screen is garbage. Clear the hardware    */
  123.     /* screen, and update your copy to agree with it. Set all the    */
  124.     /* virtual screen change bits, to force a full update.        */
  125.     if (sgarbf != FALSE)
  126.     {    for ( i=0; i < 23; ++i )
  127.         {    vscreen[i]->v_flag |= VFCHG;
  128.             clear( &( pscreen[ i ]->v_text[ 0 ]), 80, ' ' );
  129.         }
  130.         ansiclear();    /*clear */
  131.         ttrow = ttcol = 
  132.         sgarbf =    /* Erase-page clears    */
  133.         mpresf = 0;    /* the message area.    */
  134.     }
  135.     /* Make sure that the physical and virtual displays agree.    */
  136.     /* Unlike before, the "updateline" code is only called with a    */
  137.     /* line that has been updated for sure.                */
  138.     for (i=0; i<23; ++i)
  139.     {    vp1 = vscreen[i];
  140.         if (( vp1->v_flag & VFCHG ) != 0 )
  141.         {    vp1->v_flag &= ~VFCHG;
  142.             updateline( i, &vp1->v_text[0], 
  143.                 &pscreen[i]->v_text[0]);
  144.         }
  145.     }
  146.     /* Finally, update the hardware cursor and flush out buffers.    */
  147.     movecursor( currow, curcol );
  148. }
  149.  
  150. cramline( lp, wp )
  151. LINE * lp;
  152. WINDOW * wp;
  153. {    register int j, k, retval;
  154.  
  155.     retval = 1;
  156.     vscreen[i]->v_flag |= VFCHG;
  157.     vtmove( i, 0 );
  158.     if (lp != wp->w_bufp->b_linep)
  159.     {    k = llength(lp);
  160.         for ( retval = j = 0; j < k; ++j )
  161.             vtputc(lgetc(lp, j));
  162.     }
  163.     vteeol();
  164.     return ( retval );
  165. }
  166.