home *** CD-ROM | disk | FTP | other *** search
/ Shareware 1 2 the Maxx / sw_1.zip / sw_1 / OS2 / BEAV132X.ZIP / WINDOW.C < prev    next >
C/C++ Source or Header  |  1992-01-06  |  11KB  |  484 lines
  1. /*
  2. *       Window handling.
  3. */
  4. #include    "def.h"
  5.  
  6. bool    mvupwind ();
  7. bool    shrinkwind ();
  8.  
  9. extern    char    MSG_no_splt[];
  10. extern    char    MSG_cnt_al_w[];
  11. extern    char    MSG_one_w[];
  12. extern    char    MSG_imp_chg[];
  13.  
  14. /*
  15. * Reposition the window so as to center on the dot.
  16. */
  17. bool reposition ()
  18. {
  19.     long    l_val;
  20.  
  21.     l_val = DOT_POS(curwp) - (curwp -> w_ntrows * R_BYTES(curwp) / 2L);
  22.     move_ptr (curwp, l_val, FALSE, TRUE, FALSE);
  23.     curwp -> w_flag |= WFHARD;
  24.     return (TRUE);
  25. }
  26.  
  27. /*
  28. * The command make the next
  29. * window (next => down the screen)
  30. * the current window. There are no real
  31. * errors, although the command does
  32. * nothing if there is only 1 window on
  33. * the screen.
  34. */
  35. bool nextwind ()
  36. {
  37.  
  38.     register    WINDOW * wp;
  39.  
  40.     if ((wp = curwp -> w_wndp) == NULL)
  41.         wp = wheadp;
  42.     curwp = wp;
  43.     curbp = wp -> w_bufp;
  44.     return (TRUE);
  45. }
  46.  
  47.  
  48. /*
  49. * This command makes the previous
  50. * window (previous => up the screen) the
  51. * current window. There arn't any errors,
  52. * although the command does not do a lot
  53. * if there is 1 window.
  54. */
  55. bool prevwind ()
  56. {
  57.  
  58.     register    WINDOW * wp1;
  59.     register    WINDOW * wp2;
  60.  
  61.     wp1 = wheadp;
  62.     wp2 = curwp;
  63.     if (wp1 == wp2)
  64.         wp2 = NULL;
  65.     while (wp1 -> w_wndp != wp2)
  66.         wp1 = wp1 -> w_wndp;
  67.     curwp = wp1;
  68.     curbp = wp1 -> w_bufp;
  69.     return (TRUE);
  70. }
  71.  
  72.  
  73. /*
  74. * This command moves the current
  75. * window down by "arg" lines. Recompute
  76. * the top line in the window. The move up and
  77. * move down code is almost completely the same;
  78. * most of the work has to do with reframing the
  79. * window, and picking a new dot. We share the
  80. * code by having "move down" just be an interface
  81. * to "move up".
  82. */
  83. bool    mvdnwind (f, n, k)
  84. register int    f, n, k;
  85. {
  86.     return (mvupwind (f, -n, KRANDOM));
  87. }
  88.  
  89.  
  90. /*
  91. * Move the current window up by "arg"
  92. * lines. Recompute the new top line of the window.
  93. * Look to see if "." is still on the screen. If it is,
  94. * you win. If it isn't, then move "." to center it
  95. * in the new framing of the window (this command does
  96. * not really move "."; it moves the frame).
  97. */
  98. bool    mvupwind (f, n, k)
  99. int     f, n, k;
  100. {
  101.     A32   l_val, l_bytes;
  102.  
  103.     l_bytes = (A32)R_BYTES(curwp);     /* number of bytes in a row */
  104.     l_val = n * l_bytes;     /* number of bytes to move */
  105.     move_ptr (curwp, l_val, FALSE, TRUE, TRUE);  /* move window */
  106.  
  107.     /* check that dot is in window */
  108.     while (DOT_POS(curwp) < WIND_POS(curwp))
  109.     {
  110.         /* dot is before the first window line */
  111.         move_ptr (curwp, l_bytes, TRUE, TRUE, TRUE);
  112.     }
  113.     while (DOT_POS (curwp) >=
  114.         ((l_bytes * curwp -> w_ntrows) + WIND_POS(curwp)))
  115.     {
  116.         /* dot is after the last window line */
  117.         move_ptr (curwp, -l_bytes, TRUE, TRUE, TRUE);
  118.     }
  119.     curwp -> w_flag |= WFHARD;
  120.     return (TRUE);
  121. }
  122.  
  123.  
  124. /*
  125. * This command makes the current
  126. * window the only window on the screen.
  127. * Try to set the framing
  128. * so that "." does not have to move on
  129. * the display. Some care has to be taken
  130. * to keep the values of dot and mark
  131. * in the buffer structures right if the
  132. * distruction of a window makes a buffer
  133. * become undisplayed.
  134. */
  135. bool    onlywind ()
  136. {
  137.  
  138.     register    WINDOW * wp;
  139.     register    LINE * lp;
  140.     register int    i;
  141.  
  142.     while (wheadp != curwp)
  143.     {
  144.  
  145.         wp = wheadp;
  146.         wheadp = wp -> w_wndp;
  147.         if (--wp -> w_bufp -> b_nwnd == 0)
  148.         {
  149.  
  150.             wp -> w_bufp -> b_dotp = wp -> w_dotp;
  151.             wp -> w_bufp -> b_doto = wp -> w_doto;
  152.             wp -> w_bufp -> b_markp = wp -> w_markp;
  153.             wp -> w_bufp -> b_marko = wp -> w_marko;
  154.         }
  155.  
  156.         free ((char *) wp);
  157.     }
  158.  
  159.     while (curwp -> w_wndp != NULL)
  160.     {
  161.  
  162.         wp = curwp -> w_wndp;
  163.         curwp -> w_wndp = wp -> w_wndp;
  164.         if (--wp -> w_bufp -> b_nwnd == 0)
  165.         {
  166.  
  167.             wp -> w_bufp -> b_dotp = wp -> w_dotp;
  168.             wp -> w_bufp -> b_doto = wp -> w_doto;
  169.             wp -> w_bufp -> b_markp = wp -> w_markp;
  170.             wp -> w_bufp -> b_marko = wp -> w_marko;
  171.         }
  172.  
  173.         free ((char *) wp);
  174.     }
  175.  
  176.     lp = curwp -> w_linep;
  177.     i = curwp -> w_toprow;
  178.     while (i != 0 && lback (lp) != curbp -> b_linep)
  179.     {
  180.  
  181.         --i;
  182.         lp = lback (lp);
  183.     }
  184.  
  185.     curwp -> w_toprow = 0;
  186.     curwp -> w_ntrows = nrow - 2;/* 2 = mode, echo.  */
  187.     curwp -> w_linep = lp;
  188.     curwp -> w_flag |= WFMODE | WFHARD;
  189.     return (TRUE);
  190. }
  191.  
  192. /*
  193.  * Delete the current window, placing its space in the window above,
  194.  * or, if it is the top window, the window below. Bound to C-X 0.
  195.  */
  196.  
  197. bool    delwind()
  198.  
  199. {
  200.     register WINDOW *wp;    /* window to recieve deleted space */
  201.     register WINDOW *lwp;    /* ptr window before curwp */
  202.     register int target;    /* target line to search for */
  203.  
  204.     /* if there is only one window, don't delete it */
  205.     if (wheadp->w_wndp == NULL) {
  206.         return(FALSE);
  207.     }
  208.  
  209.     /* find window before curwp in linked list */
  210.     wp = wheadp;
  211.     lwp = NULL;
  212.     while (wp != NULL) {
  213.         if (wp == curwp)
  214.             break;
  215.         lwp = wp;
  216.         wp = wp->w_wndp;
  217.     }
  218.  
  219.     /* find recieving window and give up our space */
  220.     wp = wheadp;
  221.     if (curwp->w_toprow == 0) {
  222.         /* find the next window down */
  223.         target = curwp->w_ntrows + 1;
  224.         while (wp != NULL) {
  225.             if (wp->w_toprow == target)
  226.                 break;
  227.             wp = wp->w_wndp;
  228.         }
  229.         if (wp == NULL)
  230.             return(FALSE);
  231.         wp->w_toprow = 0;
  232.         wp->w_ntrows += target;
  233.     } else {
  234.         /* find the next window up */
  235.         target = curwp->w_toprow - 1;
  236.         while (wp != NULL) {
  237.             if ((wp->w_toprow + wp->w_ntrows) == target)
  238.                 break;
  239.             wp = wp->w_wndp;
  240.         }
  241.         if (wp == NULL)
  242.             return(FALSE);
  243.         wp->w_ntrows += 1 + curwp->w_ntrows;
  244.     }
  245.  
  246.     /* get rid of the current window */
  247.     if (--curwp->w_bufp->b_nwnd == 0) {
  248.         curwp->w_bufp->b_dotp = curwp->w_dotp;
  249.         curwp->w_bufp->b_doto = curwp->w_doto;
  250.         curwp->w_bufp->b_markp = curwp->w_markp;
  251.         curwp->w_bufp->b_marko = curwp->w_marko;
  252.     }
  253.     if (lwp == NULL)
  254.         wheadp = curwp->w_wndp;
  255.     else
  256.         lwp->w_wndp = curwp->w_wndp;
  257.     free((char *)curwp);
  258.     curwp = wp;
  259.     wp -> w_flag |= WFMODE | WFHARD;
  260.     curbp = wp->w_bufp;
  261.     return(TRUE);
  262. }
  263.  
  264. /*
  265. * Split the current window. A window
  266. * smaller than 3 lines cannot be split.
  267. * The only other error that is possible is
  268. * a "malloc" failure allocating the structure
  269. * for the new window.
  270. */
  271. bool splitwind ()
  272. {
  273.  
  274.     register    WINDOW * wp;
  275.     register int    ntru;
  276.     register int    ntrl;
  277.     register int    ntrd;
  278.     register    WINDOW * wp1;
  279.     register    WINDOW * wp2;
  280.     char    buf[NCOL], buf1[NCOL];
  281.  
  282.     if (curwp -> w_ntrows < 3)
  283.     {
  284.         sprintf (buf1, MSG_no_splt, R_BYTE_FMT(curwp));
  285.         sprintf (buf, buf1, curwp -> w_ntrows);
  286.         writ_echo (buf);
  287.         return (FALSE);
  288.     }
  289.  
  290.     if ((wp = (WINDOW *) malloc (sizeof (WINDOW))) == NULL)
  291.     {
  292.         err_echo (MSG_cnt_al_w);
  293.         return (FALSE);
  294.     }
  295.  
  296.     ++curbp -> b_nwnd;          /* Displayed twice.  */
  297.     wp -> w_bufp = curbp;
  298.     wp -> w_dotp = curwp -> w_dotp;
  299.     wp -> w_doto = curwp -> w_doto;
  300.     wp -> w_unit_offset = curwp -> w_unit_offset;
  301.     wp -> w_markp = curwp -> w_markp;
  302.     wp -> w_marko = curwp -> w_marko;
  303.     wp -> w_flag = 0;
  304.     wp -> w_disp_shift = curwp -> w_disp_shift;
  305.     wp -> w_intel_mode = curwp -> w_intel_mode;
  306.     wp -> w_fmt_ptr = curwp -> w_fmt_ptr;
  307.     ntru = (curwp -> w_ntrows - 1) / 2;/* Upper size         */
  308.     ntrl = (curwp -> w_ntrows - 1) - ntru;/* Lower size      */
  309.  
  310.     curwp -> w_ntrows = ntru;
  311.     wp -> w_wndp = curwp -> w_wndp;
  312.     curwp -> w_wndp = wp;
  313.     wp -> w_toprow = curwp -> w_toprow + ntru + 1;
  314.     wp -> w_ntrows = ntrl;
  315.  
  316.     wind_on_dot (curwp);        /* put window on the dot */
  317.     wp -> w_loff = curwp -> w_loff;/* do the same for the new window */
  318.     wp -> w_linep = curwp -> w_linep;
  319.     curwp -> w_flag |= WFMODE | WFHARD;
  320.     wp -> w_flag |= WFMODE | WFHARD;
  321.     return (TRUE);
  322. }
  323.  
  324.  
  325. /*
  326. * Enlarge the current window.
  327. * Find the window that loses space. Make
  328. * sure it is big enough. If so, hack the window
  329. * descriptions, and ask redisplay to do all the
  330. * hard work. You don't just set "force reframe"
  331. * because dot would move.
  332. */
  333. bool enlargewind (f, n, k)
  334. int f, n, k;
  335. {
  336.     register    WINDOW * adjwp;
  337.     register    LINE * lp;
  338.     register int    i;
  339.  
  340.     if (n < 0)
  341.         return (shrinkwind (f, -n, KRANDOM));
  342.     if (wheadp -> w_wndp == NULL)
  343.     {
  344.  
  345.         writ_echo (MSG_one_w);
  346.         return (FALSE);
  347.     }
  348.  
  349.     if ((adjwp = curwp -> w_wndp) == NULL)
  350.     {
  351.         adjwp = wheadp;
  352.         while (adjwp -> w_wndp != curwp)
  353.             adjwp = adjwp -> w_wndp;
  354.     }
  355.  
  356.     if (adjwp -> w_ntrows <= n)
  357.     {
  358.         writ_echo (MSG_imp_chg);
  359.         return (FALSE);
  360.     }
  361.  
  362.     if (curwp -> w_wndp == adjwp)
  363.     {
  364.         /* Shrink below.     */
  365.         lp = adjwp -> w_linep;
  366.         for (i = 0; i < n && lp != adjwp -> w_bufp -> b_linep; ++i)
  367.             lp = lforw (lp);
  368.         adjwp -> w_linep = lp;
  369.         adjwp -> w_toprow += n;
  370.     }
  371.     else
  372.     {
  373.         /* Shrink above.     */
  374.         lp = curwp -> w_linep;
  375.         for (i = 0; i < n && lback (lp) != curbp -> b_linep; ++i)
  376.             lp = lback (lp);
  377.         curwp -> w_linep = lp;
  378.         curwp -> w_toprow -= n;
  379.     }
  380.  
  381.     curwp -> w_ntrows += n;
  382.     adjwp -> w_ntrows -= n;
  383.     curwp -> w_flag |= WFMODE | WFHARD;
  384.     adjwp -> w_flag |= WFMODE | WFHARD;
  385.     return (TRUE);
  386. }
  387.  
  388.  
  389. /*
  390. * Shrink the current window.
  391. * Find the window that gains space. Hack at
  392. * the window descriptions. Ask the redisplay to
  393. * do all the hard work.
  394. */
  395. bool shrinkwind (f, n, k)
  396. int f, n, k;
  397. {
  398.     register    WINDOW * adjwp;
  399.     register    LINE * lp;
  400.     register int    i;
  401.  
  402.     if (n < 0)
  403.         return (enlargewind (f, -n, KRANDOM));
  404.     if (wheadp -> w_wndp == NULL)
  405.     {
  406.         writ_echo (MSG_one_w);
  407.         return (FALSE);
  408.     }
  409.  
  410.     if ((adjwp = curwp -> w_wndp) == NULL)
  411.     {
  412.         adjwp = wheadp;
  413.         while (adjwp -> w_wndp != curwp)
  414.             adjwp = adjwp -> w_wndp;
  415.     }
  416.  
  417.     if (curwp -> w_ntrows <= n)
  418.     {
  419.         writ_echo (MSG_imp_chg);
  420.         return (FALSE);
  421.     }
  422.  
  423.     if (curwp -> w_wndp == adjwp)
  424.     {
  425.         /* Grow below.       */
  426.         lp = adjwp -> w_linep;
  427.         for (i = 0; i < n && lback (lp) != adjwp -> w_bufp -> b_linep; ++i)
  428.             lp = lback (lp);
  429.         adjwp -> w_linep = lp;
  430.         adjwp -> w_toprow -= n;
  431.     }
  432.     else
  433.     {
  434.         /* Grow above.       */
  435.         lp = curwp -> w_linep;
  436.         for (i = 0; i < n && lp != curbp -> b_linep; ++i)
  437.             lp = lforw (lp);
  438.         curwp -> w_linep = lp;
  439.         curwp -> w_toprow += n;
  440.     }
  441.  
  442.     curwp -> w_ntrows -= n;
  443.     adjwp -> w_ntrows += n;
  444.     curwp -> w_flag |= WFMODE | WFHARD;
  445.     adjwp -> w_flag |= WFMODE | WFHARD;
  446.     return (TRUE);
  447. }
  448.  
  449.  
  450. /*
  451. * Pick a window for a pop-up.
  452. * Split the screen if there is only
  453. * one window. Pick the uppermost window that
  454. * isn't the current window. An LRU algorithm
  455. * might be better. Return a pointer, or
  456. * NULL on error.
  457. */
  458. WINDOW * wpopup ()
  459. {
  460.  
  461.     register    WINDOW * wp;
  462.  
  463.     if (wheadp -> w_wndp == NULL
  464.         && splitwind () == FALSE)
  465.         return (NULL);
  466.     wp = wheadp;                /* Find window to use    */
  467.     while (wp != NULL && wp == curwp)
  468.         wp = wp -> w_wndp;
  469.     return (wp);
  470. }
  471.  
  472.  
  473. /*
  474. * Refresh the display.
  475. * In the normal case the
  476. * call to "update" in "main.c" refreshes the screen,
  477. * and all of the windows need not be recomputed.
  478. */
  479. bool refresh ()
  480. {
  481.     sgarbf = TRUE;
  482.     return (TRUE);
  483. }
  484.